103 files changed, 96581 insertions, 96568 deletions

diff --git a/mesalib/src/mesa/Makefile b/mesalib/src/mesa/Makefile
index 10d73f000..2eb8a18c9 100644
--- a/mesalib/src/mesa/Makefile
+++ b/mesalib/src/mesa/Makefile
@@ -1,230 +1,230 @@
-# src/mesa/Makefile
-
-TOP = ../..
-include $(TOP)/configs/current
-
-MESA_LIBS := libmesa.a libmesagallium.a
-DEPENDS := depend
-
-MESA_OBJ_DIR := .
-DRICORE_OBJ_DIR := objs-dricore
-
-include sources.mak
-
-# adjust object dirs
-MESA_OBJECTS := $(addprefix $(MESA_OBJ_DIR)/, $(MESA_OBJECTS))
-MESA_GALLIUM_OBJECTS := $(addprefix $(MESA_OBJ_DIR)/, $(MESA_GALLIUM_OBJECTS))
-
-DRICORE_OBJECTS := $(addprefix $(DRICORE_OBJ_DIR)/, $(MESA_OBJECTS))
-
-# define preprocessor flags
-MESA_CPPFLAGS := $(API_DEFINES) $(DEFINES)
-
-# append include dirs
-MESA_CPPFLAGS += $(INCLUDE_DIRS)
-
-DRICORE_CPPFLAGS = $(MESA_CPPFLAGS)
-
-# tidy compiler flags
-CFLAGS := $(filter-out $(DEFINES), $(CFLAGS))
-CXXFLAGS := $(filter-out $(DEFINES), $(CXXFLAGS))
-
-# LLVM is needed for the state tracker
-MESA_CFLAGS := $(LLVM_CFLAGS) $(CFLAGS)
-DRICORE_CFLAGS := $(LLVM_CFLAGS) $(DRI_CFLAGS)
-
-MESA_CXXFLAGS := $(LLVM_CFLAGS) $(CXXFLAGS)
-DRICORE_CXXFLAGS := $(LLVM_CFLAGS) $(DRI_CXXFLAGS)
-
-define mesa-cc-c
-	@mkdir -p $(dir $@)
-	$(CC) -c -o $@ $< $($(1)_CPPFLAGS) $($(1)_CFLAGS)
-endef
-
-define mesa-cxx-c
-	@mkdir -p $(dir $@)
-	$(CXX) -c -o $@ $< $($(1)_CPPFLAGS) $($(1)_CFLAGS) $($(1)_CXXFLAGS)
-endef
-
-$(MESA_OBJ_DIR)/%.o: %.c
-	$(call mesa-cc-c,MESA)
-
-$(MESA_OBJ_DIR)/%.o: %.cpp
-	$(call mesa-cxx-c,MESA)
-
-$(MESA_OBJ_DIR)/%.o: %.S
-	$(call mesa-cc-c,MESA)
-
-$(DRICORE_OBJ_DIR)/%.o: %.c
-	$(call mesa-cc-c,DRICORE)
-
-$(DRICORE_OBJ_DIR)/%.o: %.cpp
-	$(call mesa-cxx-c,DRICORE)
-
-$(DRICORE_OBJ_DIR)/%.o: %.S
-	$(call mesa-cc-c,DRICORE)
-
-# Default: build dependencies, then asm_subdirs, GLSL built-in lib,
-# then convenience libs (.a) and finally the device drivers:
-default: $(DEPENDS) asm_subdirs $(MESA_LIBS) $(DRICORE_LIBS) driver_subdirs
-
-main/api_exec_es1.c: main/APIspec.xml main/es_generator.py main/APIspecutil.py main/APIspec.py
-	$(PYTHON2) $(PYTHON_FLAGS) main/es_generator.py -S main/APIspec.xml -V GLES1.1 > $@
-
-main/api_exec_es2.c: main/APIspec.xml main/es_generator.py main/APIspecutil.py main/APIspec.py
-	$(PYTHON2) $(PYTHON_FLAGS) main/es_generator.py -S main/APIspec.xml -V GLES2.0 > $@
-
-program/program_parse.tab.c program/program_parse.tab.h: program/program_parse.y
-	bison -v -d --output=program/program_parse.tab.c $<
-
-program/lex.yy.c: program/program_lexer.l
-	flex --never-interactive --outfile=$@ $<
-
-######################################################################
-# Helper libraries used by many drivers:
-
-# Make archive of core mesa object files
-libmesa.a: $(MESA_OBJECTS) $(GLSL_LIBS)
-	@ $(MKLIB) -o mesa -static $(MESA_OBJECTS) $(GLSL_LIBS)
-
-# Shared dricore library for classic DRI drivers
-$(TOP)/$(LIB_DIR)/libdricore.so: $(DRICORE_OBJECTS) $(DRICORE_GLSL_LIBS)
-	@$(MKLIB) -o $@ -linker '$(CXX)' -ldflags '$(LDFLAGS)' \
-		-cplusplus -noprefix \
-		-install $(TOP)/$(LIB_DIR) -id $(DRI_DRIVER_INSTALL_DIR)/$@.dylib \
-		$(DRICORE_LIB_DEPS) $(DRICORE_OBJECTS)
-
-# Make archive of subset of core mesa object files for gallium
-libmesagallium.a: $(MESA_GALLIUM_OBJECTS) $(GLSL_LIBS)
-	@ $(MKLIB) -o mesagallium -static $(MESA_GALLIUM_OBJECTS) $(GLSL_LIBS)
-
-######################################################################
-# Device drivers
-driver_subdirs: $(MESA_LIBS) $(DRICORE_LIBS)
-	@ (cd drivers && $(MAKE))
-
-
-######################################################################
-# Assembly subdirs
-asm_subdirs:
-	@ if echo "$(ASM_FLAGS)" | grep -q USE_X86_ASM ; then \
-		(cd x86 && $(MAKE)) || exit 1 ; \
-	fi
-	@ if echo "$(ASM_FLAGS)" | grep -q USE_X86_64_ASM ; then \
-		(cd x86 && $(MAKE)) || exit 1 ; \
-		(cd x86-64 && $(MAKE)) || exit 1 ; \
-	fi
-
-
-######################################################################
-# Dependency generation
-
-depend: $(ALL_SOURCES)
-	@ echo "running $(MKDEP)"
-	@ touch depend
-	@$(MKDEP) $(MKDEP_OPTIONS) -p$(MESA_OBJ_DIR)/ $(MESA_CPPFLAGS) \
-		$(ALL_SOURCES) > /dev/null 2>/dev/null
-
-######################################################################
-# Installation rules
-
-# this isn't fleshed out yet but is probably the way to go in the future
-new_install:
-	(cd drivers && $(MAKE) install)
-
-ifneq (,$(DRICORE_LIBS))
-DRICORE_INSTALL_TARGET = install-dricore
-endif
-
-# XXX replace this with new_install above someday
-install: default $(DRICORE_INSTALL_TARGET)
-	@for driver in $(DRIVER_DIRS) ; do \
-	  case "$$driver" in \
-	    osmesa) if [ "$(DRIVER_DIRS)" = osmesa ]; then \
-	              $(MAKE) install-headers install-osmesa || exit 1 ; \
-	            else \
-	              $(MAKE) install-osmesa || exit 1 ; \
-	            fi ;; \
-	    dri)    $(MAKE) install-libgl install-dri || exit 1 ;; \
-	    *)      $(MAKE) install-libgl || exit 1 ;; \
-	  esac ; \
-	done
-
-pcedit = \
-	-e 's,@INSTALL_DIR@,$(INSTALL_DIR),' \
-	-e 's,@INSTALL_LIB_DIR@,$(INSTALL_LIB_DIR),' \
-	-e 's,@INSTALL_INC_DIR@,$(INSTALL_INC_DIR),' \
-	-e 's,@VERSION@,$(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY),' \
-
-
-gl_pcedit = sed \
-	$(pcedit) \
-	-e 's,@GL_PC_REQ_PRIV@,$(GL_PC_REQ_PRIV),' \
-	-e 's,@GL_PC_LIB_PRIV@,$(GL_PC_LIB_PRIV),' \
-	-e 's,@GL_PC_CFLAGS@,$(GL_PC_CFLAGS),' \
-	-e 's,@GLX_TLS@,$(GLX_TLS),' \
-	-e 's,@GL_LIB@,$(GL_LIB),'
-
-gl.pc: gl.pc.in
-	$(gl_pcedit) $< > $@
-
-osmesa_pcedit = sed \
-	$(pcedit) \
-	-e 's,@OSMESA_LIB@,$(OSMESA_LIB),' \
-	-e 's,@OSMESA_PC_REQ@,$(OSMESA_PC_REQ),' \
-	-e 's,@OSMESA_PC_LIB_PRIV@,$(OSMESA_PC_LIB_PRIV),'
-
-osmesa.pc: osmesa.pc.in
-	$(osmesa_pcedit) $< > $@
-
-install-headers:
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) -m 644 $(TOP)/include/GL/*.h \
-		$(DESTDIR)$(INSTALL_INC_DIR)/GL
-
-install-libgl: default gl.pc install-headers
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GL_LIB_GLOB) \
-		$(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -m 644 gl.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-
-install-osmesa: default osmesa.pc
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_GLOB) \
-		$(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -m 644 osmesa.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-
-install-dri: default
-	cd drivers/dri && $(MAKE) install
-
-# We don't need MINSTALL here because we're not installing symbolic links
-install-dricore: default
-	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-	$(INSTALL) -m 755 $(DRICORE_LIBS) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-
-
-# Emacs tags
-tags:
-	etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h
-
-clean-dricore:
-	-rm -f libdricore.so
-	-rm -f $(DRICORE_LIBS)
-	-rm -rf $(DRICORE_OBJ_DIR)
-
-clean: clean-dricore
-	-rm -f */*.o
-	-rm -f */*/*.o
-	-rm -f depend depend.bak libmesa.a libmesagallium.a
-	-rm -f drivers/*/*.o
-	-rm -f *.pc
-	-@cd drivers/dri && $(MAKE) clean
-	-@cd drivers/x11 && $(MAKE) clean
-	-@cd drivers/osmesa && $(MAKE) clean
-	-@cd x86 && $(MAKE) clean
-	-@cd x86-64 && $(MAKE) clean
-
-
--include $(DEPENDS)
+# src/mesa/Makefile

+

+TOP = ../..

+include $(TOP)/configs/current

+

+MESA_LIBS := libmesa.a libmesagallium.a

+DEPENDS := depend

+

+MESA_OBJ_DIR := .

+DRICORE_OBJ_DIR := objs-dricore

+

+include sources.mak

+

+# adjust object dirs

+MESA_OBJECTS := $(addprefix $(MESA_OBJ_DIR)/, $(MESA_OBJECTS))

+MESA_GALLIUM_OBJECTS := $(addprefix $(MESA_OBJ_DIR)/, $(MESA_GALLIUM_OBJECTS))

+

+DRICORE_OBJECTS := $(addprefix $(DRICORE_OBJ_DIR)/, $(MESA_OBJECTS))

+

+# define preprocessor flags

+MESA_CPPFLAGS := $(API_DEFINES) $(DEFINES)

+

+# append include dirs

+MESA_CPPFLAGS += $(INCLUDE_DIRS)

+

+DRICORE_CPPFLAGS = $(MESA_CPPFLAGS)

+

+# tidy compiler flags

+CFLAGS := $(filter-out $(DEFINES), $(CFLAGS))

+CXXFLAGS := $(filter-out $(DEFINES), $(CXXFLAGS))

+

+# LLVM is needed for the state tracker

+MESA_CFLAGS := $(LLVM_CFLAGS) $(CFLAGS)

+DRICORE_CFLAGS := $(LLVM_CFLAGS) $(DRI_CFLAGS)

+

+MESA_CXXFLAGS := $(LLVM_CFLAGS) $(CXXFLAGS)

+DRICORE_CXXFLAGS := $(LLVM_CFLAGS) $(DRI_CXXFLAGS)

+

+define mesa-cc-c

+	@mkdir -p $(dir $@)

+	$(CC) -c -o $@ $< $($(1)_CPPFLAGS) $($(1)_CFLAGS)

+endef

+

+define mesa-cxx-c

+	@mkdir -p $(dir $@)

+	$(CXX) -c -o $@ $< $($(1)_CPPFLAGS) $($(1)_CFLAGS) $($(1)_CXXFLAGS)

+endef

+

+$(MESA_OBJ_DIR)/%.o: %.c

+	$(call mesa-cc-c,MESA)

+

+$(MESA_OBJ_DIR)/%.o: %.cpp

+	$(call mesa-cxx-c,MESA)

+

+$(MESA_OBJ_DIR)/%.o: %.S

+	$(call mesa-cc-c,MESA)

+

+$(DRICORE_OBJ_DIR)/%.o: %.c

+	$(call mesa-cc-c,DRICORE)

+

+$(DRICORE_OBJ_DIR)/%.o: %.cpp

+	$(call mesa-cxx-c,DRICORE)

+

+$(DRICORE_OBJ_DIR)/%.o: %.S

+	$(call mesa-cc-c,DRICORE)

+

+# Default: build dependencies, then asm_subdirs, GLSL built-in lib,

+# then convenience libs (.a) and finally the device drivers:

+default: $(DEPENDS) asm_subdirs $(MESA_LIBS) $(DRICORE_LIBS) driver_subdirs

+

+main/api_exec_es1.c: main/APIspec.xml main/es_generator.py main/APIspecutil.py main/APIspec.py

+	$(PYTHON2) $(PYTHON_FLAGS) main/es_generator.py -S main/APIspec.xml -V GLES1.1 > $@

+

+main/api_exec_es2.c: main/APIspec.xml main/es_generator.py main/APIspecutil.py main/APIspec.py

+	$(PYTHON2) $(PYTHON_FLAGS) main/es_generator.py -S main/APIspec.xml -V GLES2.0 > $@

+

+program/program_parse.tab.c program/program_parse.tab.h: program/program_parse.y

+	bison -v -d --output=program/program_parse.tab.c $<

+

+program/lex.yy.c: program/program_lexer.l

+	flex --never-interactive --outfile=$@ $<

+

+######################################################################

+# Helper libraries used by many drivers:

+

+# Make archive of core mesa object files

+libmesa.a: $(MESA_OBJECTS) $(GLSL_LIBS)

+	@ $(MKLIB) -o mesa -static $(MESA_OBJECTS) $(GLSL_LIBS)

+

+# Shared dricore library for classic DRI drivers

+$(TOP)/$(LIB_DIR)/libdricore.so: $(DRICORE_OBJECTS) $(DRICORE_GLSL_LIBS)

+	@$(MKLIB) -o $@ -linker '$(CXX)' -ldflags '$(LDFLAGS)' \

+		-cplusplus -noprefix \

+		-install $(TOP)/$(LIB_DIR) -id $(DRI_DRIVER_INSTALL_DIR)/$@.dylib \

+		$(DRICORE_LIB_DEPS) $(DRICORE_OBJECTS)

+

+# Make archive of subset of core mesa object files for gallium

+libmesagallium.a: $(MESA_GALLIUM_OBJECTS) $(GLSL_LIBS)

+	@ $(MKLIB) -o mesagallium -static $(MESA_GALLIUM_OBJECTS) $(GLSL_LIBS)

+

+######################################################################

+# Device drivers

+driver_subdirs: $(MESA_LIBS) $(DRICORE_LIBS)

+	@ (cd drivers && $(MAKE))

+

+

+######################################################################

+# Assembly subdirs

+asm_subdirs:

+	@ if echo "$(ASM_FLAGS)" | grep -q USE_X86_ASM ; then \

+		(cd x86 && $(MAKE)) || exit 1 ; \

+	fi

+	@ if echo "$(ASM_FLAGS)" | grep -q USE_X86_64_ASM ; then \

+		(cd x86 && $(MAKE)) || exit 1 ; \

+		(cd x86-64 && $(MAKE)) || exit 1 ; \

+	fi

+

+

+######################################################################

+# Dependency generation

+

+depend: $(ALL_SOURCES)

+	@ echo "running $(MKDEP)"

+	@ touch depend

+	@$(MKDEP) $(MKDEP_OPTIONS) -p$(MESA_OBJ_DIR)/ $(MESA_CPPFLAGS) \

+		$(ALL_SOURCES) > /dev/null 2>/dev/null

+

+######################################################################

+# Installation rules

+

+# this isn't fleshed out yet but is probably the way to go in the future

+new_install:

+	(cd drivers && $(MAKE) install)

+

+ifneq (,$(DRICORE_LIBS))

+DRICORE_INSTALL_TARGET = install-dricore

+endif

+

+# XXX replace this with new_install above someday

+install: default $(DRICORE_INSTALL_TARGET)

+	@for driver in $(DRIVER_DIRS) ; do \

+	  case "$$driver" in \

+	    osmesa) if [ "$(DRIVER_DIRS)" = osmesa ]; then \

+	              $(MAKE) install-headers install-osmesa || exit 1 ; \

+	            else \

+	              $(MAKE) install-osmesa || exit 1 ; \

+	            fi ;; \

+	    dri)    $(MAKE) install-libgl install-dri || exit 1 ;; \

+	    *)      $(MAKE) install-libgl || exit 1 ;; \

+	  esac ; \

+	done

+

+pcedit = \

+	-e 's,@INSTALL_DIR@,$(INSTALL_DIR),' \

+	-e 's,@INSTALL_LIB_DIR@,$(INSTALL_LIB_DIR),' \

+	-e 's,@INSTALL_INC_DIR@,$(INSTALL_INC_DIR),' \

+	-e 's,@VERSION@,$(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY),' \

+

+

+gl_pcedit = sed \

+	$(pcedit) \

+	-e 's,@GL_PC_REQ_PRIV@,$(GL_PC_REQ_PRIV),' \

+	-e 's,@GL_PC_LIB_PRIV@,$(GL_PC_LIB_PRIV),' \

+	-e 's,@GL_PC_CFLAGS@,$(GL_PC_CFLAGS),' \

+	-e 's,@GLX_TLS@,$(GLX_TLS),' \

+	-e 's,@GL_LIB@,$(GL_LIB),'

+

+gl.pc: gl.pc.in

+	$(gl_pcedit) $< > $@

+

+osmesa_pcedit = sed \

+	$(pcedit) \

+	-e 's,@OSMESA_LIB@,$(OSMESA_LIB),' \

+	-e 's,@OSMESA_PC_REQ@,$(OSMESA_PC_REQ),' \

+	-e 's,@OSMESA_PC_LIB_PRIV@,$(OSMESA_PC_LIB_PRIV),'

+

+osmesa.pc: osmesa.pc.in

+	$(osmesa_pcedit) $< > $@

+

+install-headers:

+	$(INSTALL) -d $(DESTDIR)$(INSTALL_INC_DIR)/GL

+	$(INSTALL) -m 644 $(TOP)/include/GL/*.h \

+		$(DESTDIR)$(INSTALL_INC_DIR)/GL

+

+install-libgl: default gl.pc install-headers

+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)

+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig

+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GL_LIB_GLOB) \

+		$(DESTDIR)$(INSTALL_LIB_DIR)

+	$(INSTALL) -m 644 gl.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig

+

+install-osmesa: default osmesa.pc

+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)

+	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig

+	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(OSMESA_LIB_GLOB) \

+		$(DESTDIR)$(INSTALL_LIB_DIR)

+	$(INSTALL) -m 644 osmesa.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig

+

+install-dri: default

+	cd drivers/dri && $(MAKE) install

+

+# We don't need MINSTALL here because we're not installing symbolic links

+install-dricore: default

+	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)

+	$(INSTALL) -m 755 $(DRICORE_LIBS) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)

+

+

+# Emacs tags

+tags:

+	etags `find . -name \*.[ch]` $(TOP)/include/GL/*.h

+

+clean-dricore:

+	-rm -f libdricore.so

+	-rm -f $(DRICORE_LIBS)

+	-rm -rf $(DRICORE_OBJ_DIR)

+

+clean: clean-dricore

+	-rm -f */*.o

+	-rm -f */*/*.o

+	-rm -f depend depend.bak libmesa.a libmesagallium.a

+	-rm -f drivers/*/*.o

+	-rm -f *.pc

+	-@cd drivers/dri && $(MAKE) clean

+	-@cd drivers/x11 && $(MAKE) clean

+	-@cd drivers/osmesa && $(MAKE) clean

+	-@cd x86 && $(MAKE) clean

+	-@cd x86-64 && $(MAKE) clean

+

+

+-include $(DEPENDS)

diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript
index f797d62dc..410eacba7 100644
--- a/mesalib/src/mesa/SConscript
+++ b/mesalib/src/mesa/SConscript
@@ -1,402 +1,402 @@
-#######################################################################
-# SConscript for Mesa
-
-
-Import('*')
-
-env = env.Clone()
-
-env.Append(CPPPATH = [
-    '#/src/mapi',
-    '#/src/glsl',
-    '#/src/mesa',
-])
-
-env.Append(CPPDEFINES = [
-    'FEATURE_GL=1',
-])
-
-if env['platform'] == 'windows':
-    env.Append(CPPDEFINES = [
-        '_GDI32_', # prevent gl* being declared __declspec(dllimport) in MS headers
-        'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers
-    ])
-    if not env['gles']:
-        # prevent _glapi_* from being declared __declspec(dllimport)
-        env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS'])
-else:
-    env.Append(CPPDEFINES = [
-        'IN_DRI_DRIVER', # enable the remap table (for DRI drivers)
-    ])
-
-#
-# Source files
-#
-
-main_sources = [
-    'main/api_arrayelt.c',
-    'main/api_exec.c',
-    'main/api_loopback.c',
-    'main/api_noop.c',
-    'main/api_validate.c',
-    'main/accum.c',
-    'main/arbprogram.c',
-    'main/atifragshader.c',
-    'main/attrib.c',
-    'main/arrayobj.c',
-    'main/blend.c',
-    'main/bufferobj.c',
-    'main/buffers.c',
-    'main/clear.c',
-    'main/clip.c',
-    'main/colortab.c',
-    'main/condrender.c',
-    'main/context.c',
-    'main/convolve.c',
-    'main/cpuinfo.c',
-    'main/debug.c',
-    'main/depth.c',
-    'main/depthstencil.c',
-    'main/dlist.c',
-    'main/dlopen.c',
-    'main/drawpix.c',
-    'main/drawtex.c',
-    'main/enable.c',
-    'main/enums.c',
-    'main/eval.c',
-    'main/execmem.c',
-    'main/extensions.c',
-    'main/fbobject.c',
-    'main/feedback.c',
-    'main/ffvertex_prog.c',
-    'main/fog.c',
-    'main/formats.c',
-    'main/framebuffer.c',
-    'main/get.c',
-    'main/getstring.c',
-    'main/hash.c',
-    'main/hint.c',
-    'main/histogram.c',
-    'main/image.c',
-    'main/imports.c',
-    'main/light.c',
-    'main/lines.c',
-    'main/matrix.c',
-    'main/mipmap.c',
-    'main/mm.c',
-    'main/multisample.c',
-    'main/nvprogram.c',
-    'main/pack.c',
-    'main/pbo.c',
-    'main/pixel.c',
-    'main/pixelstore.c',
-    'main/pixeltransfer.c',
-    'main/points.c',
-    'main/polygon.c',
-    'main/querymatrix.c',
-    'main/queryobj.c',
-    'main/rastpos.c',
-    'main/readpix.c',
-    'main/remap.c',
-    'main/renderbuffer.c',
-    'main/scissor.c',
-    'main/shaderapi.c',
-    'main/shaderobj.c',
-    'main/shared.c',
-    'main/state.c',
-    'main/stencil.c',
-    'main/syncobj.c',
-    'main/texcompress.c',
-    'main/texcompress_rgtc.c',
-    'main/texcompress_s3tc.c',
-    'main/texcompress_fxt1.c',
-    'main/texenv.c',
-    'main/texenvprogram.c',
-    'main/texfetch.c',
-    'main/texformat.c',
-    'main/texgen.c',
-    'main/texgetimage.c',
-    'main/teximage.c',
-    'main/texobj.c',
-    'main/texpal.c',
-    'main/texparam.c',
-    'main/texrender.c',
-    'main/texstate.c',
-    'main/texstore.c',
-    'main/transformfeedback.c',
-    'main/uniforms.c',
-    'main/varray.c',
-    'main/version.c',
-    'main/viewport.c',
-    'main/vtxfmt.c',
-]
-
-math_sources = [
-    'math/m_debug_clip.c',
-    'math/m_debug_norm.c',
-    'math/m_debug_xform.c',
-    'math/m_eval.c',
-    'math/m_matrix.c',
-    'math/m_translate.c',
-    'math/m_vector.c',
-    'math/m_xform.c',
-]
-
-vbo_sources = [
-    'vbo/vbo_context.c',
-    'vbo/vbo_exec.c',
-    'vbo/vbo_exec_api.c',
-    'vbo/vbo_exec_array.c',
-    'vbo/vbo_exec_draw.c',
-    'vbo/vbo_exec_eval.c',
-    'vbo/vbo_rebase.c',
-    'vbo/vbo_split.c',
-    'vbo/vbo_split_copy.c',
-    'vbo/vbo_split_inplace.c',
-    'vbo/vbo_save.c',
-    'vbo/vbo_save_api.c',
-    'vbo/vbo_save_draw.c',
-    'vbo/vbo_save_loopback.c',
-]
-
-vf_sources = [
-    'vf/vf.c',
-    'vf/vf_generic.c',
-    'vf/vf_sse.c',
-]
-
-statetracker_sources = [
-    'state_tracker/st_atom.c',
-    'state_tracker/st_atom_blend.c',
-    'state_tracker/st_atom_clip.c',
-    'state_tracker/st_atom_constbuf.c',
-    'state_tracker/st_atom_depth.c',
-    'state_tracker/st_atom_framebuffer.c',
-    'state_tracker/st_atom_msaa.c',
-    'state_tracker/st_atom_pixeltransfer.c',
-    'state_tracker/st_atom_sampler.c',
-    'state_tracker/st_atom_scissor.c',
-    'state_tracker/st_atom_shader.c',
-    'state_tracker/st_atom_rasterizer.c',
-    'state_tracker/st_atom_stipple.c',
-    'state_tracker/st_atom_texture.c',
-    'state_tracker/st_atom_viewport.c',
-    'state_tracker/st_cb_accum.c',
-    'state_tracker/st_cb_bitmap.c',
-    'state_tracker/st_cb_blit.c',
-    'state_tracker/st_cb_bufferobjects.c',
-    'state_tracker/st_cb_clear.c',
-    'state_tracker/st_cb_condrender.c',
-    'state_tracker/st_cb_flush.c',
-    'state_tracker/st_cb_drawpixels.c',
-    'state_tracker/st_cb_drawtex.c',
-    'state_tracker/st_cb_eglimage.c',
-    'state_tracker/st_cb_fbo.c',
-    'state_tracker/st_cb_feedback.c',
-    'state_tracker/st_cb_program.c',
-    'state_tracker/st_cb_queryobj.c',
-    'state_tracker/st_cb_rasterpos.c',
-    'state_tracker/st_cb_readpixels.c',
-    'state_tracker/st_cb_syncobj.c',
-    'state_tracker/st_cb_strings.c',
-    'state_tracker/st_cb_texture.c',
-    'state_tracker/st_cb_viewport.c',
-    'state_tracker/st_cb_xformfb.c',
-    'state_tracker/st_context.c',
-    'state_tracker/st_debug.c',
-    'state_tracker/st_draw.c',
-    'state_tracker/st_draw_feedback.c',
-    'state_tracker/st_extensions.c',
-    'state_tracker/st_format.c',
-    'state_tracker/st_gen_mipmap.c',
-    'state_tracker/st_manager.c',
-    'state_tracker/st_mesa_to_tgsi.c',
-    'state_tracker/st_program.c',
-    'state_tracker/st_texture.c',
-]
-
-env.Append(YACCFLAGS = '-d')
-program_lex = env.CFile('program/lex.yy.c', 'program/program_lexer.l')
-program_parse = env.CFile('program/program_parse.tab.c',
-                          'program/program_parse.y')
-
-# Make program/program_parse.tab.h reacheable from the include path
-env.Append(CPPPATH = [Dir('.').abspath])
-
-program_sources = [
-    'program/arbprogparse.c',
-    'program/hash_table.c',
-    'program/ir_to_mesa.cpp',
-    'program/nvfragparse.c',
-    'program/nvvertparse.c',
-    'program/program.c',
-    'program/program_parse_extra.c',
-    'program/prog_cache.c',
-    'program/prog_execute.c',
-    'program/prog_instruction.c',
-    'program/prog_noise.c',
-    'program/prog_optimize.c',
-    'program/prog_parameter.c',
-    'program/prog_parameter_layout.c',
-    'program/prog_print.c',
-    'program/prog_statevars.c',
-    'program/prog_uniform.c',
-    'program/programopt.c',
-    'program/sampler.cpp',
-    'program/symbol_table.c',
-    program_lex,
-    program_parse[0],
-]
-
-mesa_sources = (
-    main_sources +
-    math_sources +
-    program_sources +
-    vbo_sources +
-    vf_sources +
-    statetracker_sources
-)
-
-if env['gles']:
-    from sys import executable as python_cmd
-
-    env.Append(CPPDEFINES = ['FEATURE_ES1=1', 'FEATURE_ES2=1'])
-
-    # generate GLES sources
-    gles_sources = []
-    gles_sources += env.CodeGenerate(
-        target = 'main/api_exec_es1.c',
-        script = 'main/es_generator.py',
-        source = 'main/APIspec.xml',
-        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES1.1 > $TARGET'
-    )
-    gles_sources += env.CodeGenerate(
-        target = 'main/api_exec_es2.c',
-        script = 'main/es_generator.py',
-        source = 'main/APIspec.xml',
-        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES2.0 > $TARGET'
-    )
-
-    # generate GLES headers
-    GLAPI = '#src/mapi/glapi/'
-    gles_headers = []
-    gles_headers += env.CodeGenerate(
-        target = 'es1api/main/glapidispatch.h',
-        script = GLAPI + 'gen/gl_table.py',
-        source = GLAPI + 'gen-es/es1_API.xml',
-        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es1api/main/remap_helper.h',
-        script = GLAPI + 'gen/remap_helper.py',
-        source = GLAPI + 'gen-es/es1_API.xml',
-        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es2api/main/glapidispatch.h',
-        script = GLAPI + 'gen/gl_table.py',
-        source = GLAPI + 'gen-es/es2_API.xml',
-        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es2api/main/remap_helper.h',
-        script = GLAPI + 'gen/remap_helper.py',
-        source = GLAPI + 'gen-es/es2_API.xml',
-        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',
-    )
-
-    env.Depends(gles_sources, gles_headers)
-
-    # gles_sources #include gles_headers with full path
-    env.Append(CPPPATH = [gles_headers[0].dir.up().up()])
-
-    mesa_sources += gles_sources
-
-#
-# Assembly sources
-#
-if env['gcc'] and env['platform'] != 'windows':
-    if env['machine'] == 'x86':
-        env.Append(CPPDEFINES = [
-            'USE_X86_ASM',
-            'USE_MMX_ASM',
-            'USE_3DNOW_ASM',
-            'USE_SSE_ASM',
-        ])
-        mesa_sources += [
-            'x86/common_x86.c',
-            'x86/x86_xform.c',
-            'x86/3dnow.c',
-            'x86/sse.c',
-            'x86/common_x86_asm.S',
-            'x86/x86_xform2.S',
-            'x86/x86_xform3.S',
-            'x86/x86_xform4.S',
-            'x86/x86_cliptest.S',
-            'x86/mmx_blend.S',
-            'x86/3dnow_xform1.S',
-            'x86/3dnow_xform2.S',
-            'x86/3dnow_xform3.S',
-            'x86/3dnow_xform4.S',
-            'x86/3dnow_normal.S',
-            'x86/sse_xform1.S',
-            'x86/sse_xform2.S',
-            'x86/sse_xform3.S',
-            'x86/sse_xform4.S',
-            'x86/sse_normal.S',
-            'x86/read_rgba_span_x86.S',
-        ]
-    elif env['machine'] == 'x86_64':
-        env.Append(CPPDEFINES = [
-            'USE_X86_64_ASM',
-        ])
-        mesa_sources += [
-            'x86-64/x86-64.c',
-            'x86-64/xform4.S',
-        ]
-    elif env['machine'] == 'ppc':
-        env.Append(CPPDEFINES = [
-            'USE_PPC_ASM',
-            'USE_VMX_ASM',
-        ])
-        mesa_sources += [
-            'ppc/common_ppc.c',
-        ]
-    elif env['machine'] == 'sparc':
-        mesa_sources += [
-            'sparc/sparc.c',
-            'sparc/clip.S',
-            'sparc/norm.S',
-            'sparc/xform.S',
-        ]
-    else:
-        pass
-
-    # Generate matypes.h
-    if env['machine'] in ('x86', 'x86_64'):
-        # See http://www.scons.org/wiki/UsingCodeGenerators
-        gen_matypes = env.Program(
-            target = 'gen_matypes',
-            source = 'x86/gen_matypes.c',
-        )
-        matypes = env.Command(
-            'matypes.h',
-            gen_matypes,
-            gen_matypes[0].abspath + ' > $TARGET',
-        )
-        # Add the dir containing the generated header (somewhere inside  the
-        # build dir) to the include path
-        env.Append(CPPPATH = [matypes[0].dir])
-
-#
-# Libraries
-#
-
-mesa = env.ConvenienceLibrary(
-    target = 'mesa',
-    source = mesa_sources,
-)
-
-env.Alias('mesa', mesa)
-
-Export('mesa')
+#######################################################################

+# SConscript for Mesa

+

+

+Import('*')

+

+env = env.Clone()

+

+env.Append(CPPPATH = [

+    '#/src/mapi',

+    '#/src/glsl',

+    '#/src/mesa',

+])

+

+env.Append(CPPDEFINES = [

+    'FEATURE_GL=1',

+])

+

+if env['platform'] == 'windows':

+    env.Append(CPPDEFINES = [

+        '_GDI32_', # prevent gl* being declared __declspec(dllimport) in MS headers

+        'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers

+    ])

+    if not env['gles']:

+        # prevent _glapi_* from being declared __declspec(dllimport)

+        env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS'])

+else:

+    env.Append(CPPDEFINES = [

+        'IN_DRI_DRIVER', # enable the remap table (for DRI drivers)

+    ])

+

+#

+# Source files

+#

+

+main_sources = [

+    'main/api_arrayelt.c',

+    'main/api_exec.c',

+    'main/api_loopback.c',

+    'main/api_noop.c',

+    'main/api_validate.c',

+    'main/accum.c',

+    'main/arbprogram.c',

+    'main/atifragshader.c',

+    'main/attrib.c',

+    'main/arrayobj.c',

+    'main/blend.c',

+    'main/bufferobj.c',

+    'main/buffers.c',

+    'main/clear.c',

+    'main/clip.c',

+    'main/colortab.c',

+    'main/condrender.c',

+    'main/context.c',

+    'main/convolve.c',

+    'main/cpuinfo.c',

+    'main/debug.c',

+    'main/depth.c',

+    'main/depthstencil.c',

+    'main/dlist.c',

+    'main/dlopen.c',

+    'main/drawpix.c',

+    'main/drawtex.c',

+    'main/enable.c',

+    'main/enums.c',

+    'main/eval.c',

+    'main/execmem.c',

+    'main/extensions.c',

+    'main/fbobject.c',

+    'main/feedback.c',

+    'main/ffvertex_prog.c',

+    'main/fog.c',

+    'main/formats.c',

+    'main/framebuffer.c',

+    'main/get.c',

+    'main/getstring.c',

+    'main/hash.c',

+    'main/hint.c',

+    'main/histogram.c',

+    'main/image.c',

+    'main/imports.c',

+    'main/light.c',

+    'main/lines.c',

+    'main/matrix.c',

+    'main/mipmap.c',

+    'main/mm.c',

+    'main/multisample.c',

+    'main/nvprogram.c',

+    'main/pack.c',

+    'main/pbo.c',

+    'main/pixel.c',

+    'main/pixelstore.c',

+    'main/pixeltransfer.c',

+    'main/points.c',

+    'main/polygon.c',

+    'main/querymatrix.c',

+    'main/queryobj.c',

+    'main/rastpos.c',

+    'main/readpix.c',

+    'main/remap.c',

+    'main/renderbuffer.c',

+    'main/scissor.c',

+    'main/shaderapi.c',

+    'main/shaderobj.c',

+    'main/shared.c',

+    'main/state.c',

+    'main/stencil.c',

+    'main/syncobj.c',

+    'main/texcompress.c',

+    'main/texcompress_rgtc.c',

+    'main/texcompress_s3tc.c',

+    'main/texcompress_fxt1.c',

+    'main/texenv.c',

+    'main/texenvprogram.c',

+    'main/texfetch.c',

+    'main/texformat.c',

+    'main/texgen.c',

+    'main/texgetimage.c',

+    'main/teximage.c',

+    'main/texobj.c',

+    'main/texpal.c',

+    'main/texparam.c',

+    'main/texrender.c',

+    'main/texstate.c',

+    'main/texstore.c',

+    'main/transformfeedback.c',

+    'main/uniforms.c',

+    'main/varray.c',

+    'main/version.c',

+    'main/viewport.c',

+    'main/vtxfmt.c',

+]

+

+math_sources = [

+    'math/m_debug_clip.c',

+    'math/m_debug_norm.c',

+    'math/m_debug_xform.c',

+    'math/m_eval.c',

+    'math/m_matrix.c',

+    'math/m_translate.c',

+    'math/m_vector.c',

+    'math/m_xform.c',

+]

+

+vbo_sources = [

+    'vbo/vbo_context.c',

+    'vbo/vbo_exec.c',

+    'vbo/vbo_exec_api.c',

+    'vbo/vbo_exec_array.c',

+    'vbo/vbo_exec_draw.c',

+    'vbo/vbo_exec_eval.c',

+    'vbo/vbo_rebase.c',

+    'vbo/vbo_split.c',

+    'vbo/vbo_split_copy.c',

+    'vbo/vbo_split_inplace.c',

+    'vbo/vbo_save.c',

+    'vbo/vbo_save_api.c',

+    'vbo/vbo_save_draw.c',

+    'vbo/vbo_save_loopback.c',

+]

+

+vf_sources = [

+    'vf/vf.c',

+    'vf/vf_generic.c',

+    'vf/vf_sse.c',

+]

+

+statetracker_sources = [

+    'state_tracker/st_atom.c',

+    'state_tracker/st_atom_blend.c',

+    'state_tracker/st_atom_clip.c',

+    'state_tracker/st_atom_constbuf.c',

+    'state_tracker/st_atom_depth.c',

+    'state_tracker/st_atom_framebuffer.c',

+    'state_tracker/st_atom_msaa.c',

+    'state_tracker/st_atom_pixeltransfer.c',

+    'state_tracker/st_atom_sampler.c',

+    'state_tracker/st_atom_scissor.c',

+    'state_tracker/st_atom_shader.c',

+    'state_tracker/st_atom_rasterizer.c',

+    'state_tracker/st_atom_stipple.c',

+    'state_tracker/st_atom_texture.c',

+    'state_tracker/st_atom_viewport.c',

+    'state_tracker/st_cb_accum.c',

+    'state_tracker/st_cb_bitmap.c',

+    'state_tracker/st_cb_blit.c',

+    'state_tracker/st_cb_bufferobjects.c',

+    'state_tracker/st_cb_clear.c',

+    'state_tracker/st_cb_condrender.c',

+    'state_tracker/st_cb_flush.c',

+    'state_tracker/st_cb_drawpixels.c',

+    'state_tracker/st_cb_drawtex.c',

+    'state_tracker/st_cb_eglimage.c',

+    'state_tracker/st_cb_fbo.c',

+    'state_tracker/st_cb_feedback.c',

+    'state_tracker/st_cb_program.c',

+    'state_tracker/st_cb_queryobj.c',

+    'state_tracker/st_cb_rasterpos.c',

+    'state_tracker/st_cb_readpixels.c',

+    'state_tracker/st_cb_syncobj.c',

+    'state_tracker/st_cb_strings.c',

+    'state_tracker/st_cb_texture.c',

+    'state_tracker/st_cb_viewport.c',

+    'state_tracker/st_cb_xformfb.c',

+    'state_tracker/st_context.c',

+    'state_tracker/st_debug.c',

+    'state_tracker/st_draw.c',

+    'state_tracker/st_draw_feedback.c',

+    'state_tracker/st_extensions.c',

+    'state_tracker/st_format.c',

+    'state_tracker/st_gen_mipmap.c',

+    'state_tracker/st_manager.c',

+    'state_tracker/st_mesa_to_tgsi.c',

+    'state_tracker/st_program.c',

+    'state_tracker/st_texture.c',

+]

+

+env.Append(YACCFLAGS = '-d')

+program_lex = env.CFile('program/lex.yy.c', 'program/program_lexer.l')

+program_parse = env.CFile('program/program_parse.tab.c',

+                          'program/program_parse.y')

+

+# Make program/program_parse.tab.h reacheable from the include path

+env.Append(CPPPATH = [Dir('.').abspath])

+

+program_sources = [

+    'program/arbprogparse.c',

+    'program/hash_table.c',

+    'program/ir_to_mesa.cpp',

+    'program/nvfragparse.c',

+    'program/nvvertparse.c',

+    'program/program.c',

+    'program/program_parse_extra.c',

+    'program/prog_cache.c',

+    'program/prog_execute.c',

+    'program/prog_instruction.c',

+    'program/prog_noise.c',

+    'program/prog_optimize.c',

+    'program/prog_parameter.c',

+    'program/prog_parameter_layout.c',

+    'program/prog_print.c',

+    'program/prog_statevars.c',

+    'program/prog_uniform.c',

+    'program/programopt.c',

+    'program/sampler.cpp',

+    'program/symbol_table.c',

+    program_lex,

+    program_parse[0],

+]

+

+mesa_sources = (

+    main_sources +

+    math_sources +

+    program_sources +

+    vbo_sources +

+    vf_sources +

+    statetracker_sources

+)

+

+if env['gles']:

+    from sys import executable as python_cmd

+

+    env.Append(CPPDEFINES = ['FEATURE_ES1=1', 'FEATURE_ES2=1'])

+

+    # generate GLES sources

+    gles_sources = []

+    gles_sources += env.CodeGenerate(

+        target = 'main/api_exec_es1.c',

+        script = 'main/es_generator.py',

+        source = 'main/APIspec.xml',

+        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES1.1 > $TARGET'

+    )

+    gles_sources += env.CodeGenerate(

+        target = 'main/api_exec_es2.c',

+        script = 'main/es_generator.py',

+        source = 'main/APIspec.xml',

+        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES2.0 > $TARGET'

+    )

+

+    # generate GLES headers

+    GLAPI = '#src/mapi/glapi/'

+    gles_headers = []

+    gles_headers += env.CodeGenerate(

+        target = 'es1api/main/glapidispatch.h',

+        script = GLAPI + 'gen/gl_table.py',

+        source = GLAPI + 'gen-es/es1_API.xml',

+        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es1api/main/remap_helper.h',

+        script = GLAPI + 'gen/remap_helper.py',

+        source = GLAPI + 'gen-es/es1_API.xml',

+        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es2api/main/glapidispatch.h',

+        script = GLAPI + 'gen/gl_table.py',

+        source = GLAPI + 'gen-es/es2_API.xml',

+        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es2api/main/remap_helper.h',

+        script = GLAPI + 'gen/remap_helper.py',

+        source = GLAPI + 'gen-es/es2_API.xml',

+        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',

+    )

+

+    env.Depends(gles_sources, gles_headers)

+

+    # gles_sources #include gles_headers with full path

+    env.Append(CPPPATH = [gles_headers[0].dir.up().up()])

+

+    mesa_sources += gles_sources

+

+#

+# Assembly sources

+#

+if env['gcc'] and env['platform'] != 'windows':

+    if env['machine'] == 'x86':

+        env.Append(CPPDEFINES = [

+            'USE_X86_ASM',

+            'USE_MMX_ASM',

+            'USE_3DNOW_ASM',

+            'USE_SSE_ASM',

+        ])

+        mesa_sources += [

+            'x86/common_x86.c',

+            'x86/x86_xform.c',

+            'x86/3dnow.c',

+            'x86/sse.c',

+            'x86/common_x86_asm.S',

+            'x86/x86_xform2.S',

+            'x86/x86_xform3.S',

+            'x86/x86_xform4.S',

+            'x86/x86_cliptest.S',

+            'x86/mmx_blend.S',

+            'x86/3dnow_xform1.S',

+            'x86/3dnow_xform2.S',

+            'x86/3dnow_xform3.S',

+            'x86/3dnow_xform4.S',

+            'x86/3dnow_normal.S',

+            'x86/sse_xform1.S',

+            'x86/sse_xform2.S',

+            'x86/sse_xform3.S',

+            'x86/sse_xform4.S',

+            'x86/sse_normal.S',

+            'x86/read_rgba_span_x86.S',

+        ]

+    elif env['machine'] == 'x86_64':

+        env.Append(CPPDEFINES = [

+            'USE_X86_64_ASM',

+        ])

+        mesa_sources += [

+            'x86-64/x86-64.c',

+            'x86-64/xform4.S',

+        ]

+    elif env['machine'] == 'ppc':

+        env.Append(CPPDEFINES = [

+            'USE_PPC_ASM',

+            'USE_VMX_ASM',

+        ])

+        mesa_sources += [

+            'ppc/common_ppc.c',

+        ]

+    elif env['machine'] == 'sparc':

+        mesa_sources += [

+            'sparc/sparc.c',

+            'sparc/clip.S',

+            'sparc/norm.S',

+            'sparc/xform.S',

+        ]

+    else:

+        pass

+

+    # Generate matypes.h

+    if env['machine'] in ('x86', 'x86_64'):

+        # See http://www.scons.org/wiki/UsingCodeGenerators

+        gen_matypes = env.Program(

+            target = 'gen_matypes',

+            source = 'x86/gen_matypes.c',

+        )

+        matypes = env.Command(

+            'matypes.h',

+            gen_matypes,

+            gen_matypes[0].abspath + ' > $TARGET',

+        )

+        # Add the dir containing the generated header (somewhere inside  the

+        # build dir) to the include path

+        env.Append(CPPPATH = [matypes[0].dir])

+

+#

+# Libraries

+#

+

+mesa = env.ConvenienceLibrary(

+    target = 'mesa',

+    source = mesa_sources,

+)

+

+env.Alias('mesa', mesa)

+

+Export('mesa')

diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c
index 2b00e8979..a3720a24d 100644
--- a/mesalib/src/mesa/drivers/common/meta.c
+++ b/mesalib/src/mesa/drivers/common/meta.c
@@ -1,2852 +1,2852 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * Meta operations.  Some GL operations can be expressed in terms of
- * other GL operations.  For example, glBlitFramebuffer() can be done
- * with texture mapping and glClear() can be done with polygon rendering.
- *
- * \author Brian Paul
- */
-
-
-#include "main/glheader.h"
-#include "main/mtypes.h"
-#include "main/imports.h"
-#include "main/arbprogram.h"
-#include "main/arrayobj.h"
-#include "main/blend.h"
-#include "main/bufferobj.h"
-#include "main/buffers.h"
-#include "main/colortab.h"
-#include "main/depth.h"
-#include "main/enable.h"
-#include "main/fbobject.h"
-#include "main/formats.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/matrix.h"
-#include "main/mipmap.h"
-#include "main/pbo.h"
-#include "main/polygon.h"
-#include "main/readpix.h"
-#include "main/scissor.h"
-#include "main/shaderapi.h"
-#include "main/shaderobj.h"
-#include "main/state.h"
-#include "main/stencil.h"
-#include "main/texobj.h"
-#include "main/texenv.h"
-#include "main/teximage.h"
-#include "main/texparam.h"
-#include "main/texstate.h"
-#include "main/varray.h"
-#include "main/viewport.h"
-#include "program/program.h"
-#include "swrast/swrast.h"
-#include "drivers/common/meta.h"
-
-
-/** Return offset in bytes of the field within a vertex struct */
-#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
-
-
-/**
- * Flags passed to _mesa_meta_begin().
- */
-/*@{*/
-#define META_ALL              ~0x0
-#define META_ALPHA_TEST        0x1
-#define META_BLEND             0x2  /**< includes logicop */
-#define META_COLOR_MASK        0x4
-#define META_DEPTH_TEST        0x8
-#define META_FOG              0x10
-#define META_PIXEL_STORE      0x20
-#define META_PIXEL_TRANSFER   0x40
-#define META_RASTERIZATION    0x80
-#define META_SCISSOR         0x100
-#define META_SHADER          0x200
-#define META_STENCIL_TEST    0x400
-#define META_TRANSFORM       0x800 /**< modelview, projection, clip planes */
-#define META_TEXTURE        0x1000
-#define META_VERTEX         0x2000
-#define META_VIEWPORT       0x4000
-/*@}*/
-
-
-/**
- * State which we may save/restore across meta ops.
- * XXX this may be incomplete...
- */
-struct save_state
-{
-   GLbitfield SavedState;  /**< bitmask of META_* flags */
-
-   /** META_ALPHA_TEST */
-   GLboolean AlphaEnabled;
-   GLenum AlphaFunc;
-   GLclampf AlphaRef;
-
-   /** META_BLEND */
-   GLbitfield BlendEnabled;
-   GLboolean ColorLogicOpEnabled;
-
-   /** META_COLOR_MASK */
-   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];
-
-   /** META_DEPTH_TEST */
-   struct gl_depthbuffer_attrib Depth;
-
-   /** META_FOG */
-   GLboolean Fog;
-
-   /** META_PIXEL_STORE */
-   struct gl_pixelstore_attrib Pack, Unpack;
-
-   /** META_PIXEL_TRANSFER */
-   GLfloat RedBias, RedScale;
-   GLfloat GreenBias, GreenScale;
-   GLfloat BlueBias, BlueScale;
-   GLfloat AlphaBias, AlphaScale;
-   GLfloat DepthBias, DepthScale;
-   GLboolean MapColorFlag;
-
-   /** META_RASTERIZATION */
-   GLenum FrontPolygonMode, BackPolygonMode;
-   GLboolean PolygonOffset;
-   GLboolean PolygonSmooth;
-   GLboolean PolygonStipple;
-   GLboolean PolygonCull;
-
-   /** META_SCISSOR */
-   struct gl_scissor_attrib Scissor;
-
-   /** META_SHADER */
-   GLboolean VertexProgramEnabled;
-   struct gl_vertex_program *VertexProgram;
-   GLboolean FragmentProgramEnabled;
-   struct gl_fragment_program *FragmentProgram;
-   struct gl_shader_program *VertexShader;
-   struct gl_shader_program *GeometryShader;
-   struct gl_shader_program *FragmentShader;
-   struct gl_shader_program *ActiveShader;
-
-   /** META_STENCIL_TEST */
-   struct gl_stencil_attrib Stencil;
-
-   /** META_TRANSFORM */
-   GLenum MatrixMode;
-   GLfloat ModelviewMatrix[16];
-   GLfloat ProjectionMatrix[16];
-   GLfloat TextureMatrix[16];
-   GLbitfield ClipPlanesEnabled;
-
-   /** META_TEXTURE */
-   GLuint ActiveUnit;
-   GLuint ClientActiveUnit;
-   /** for unit[0] only */
-   struct gl_texture_object *CurrentTexture[NUM_TEXTURE_TARGETS];
-   /** mask of TEXTURE_2D_BIT, etc */
-   GLbitfield TexEnabled[MAX_TEXTURE_UNITS];
-   GLbitfield TexGenEnabled[MAX_TEXTURE_UNITS];
-   GLuint EnvMode;  /* unit[0] only */
-
-   /** META_VERTEX */
-   struct gl_array_object *ArrayObj;
-   struct gl_buffer_object *ArrayBufferObj;
-
-   /** META_VIEWPORT */
-   GLint ViewportX, ViewportY, ViewportW, ViewportH;
-   GLclampd DepthNear, DepthFar;
-
-   /** Miscellaneous (always disabled) */
-   GLboolean Lighting;
-};
-
-
-/**
- * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.
- * This is currently shared by all the meta ops.  But we could create a
- * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.
- */
-struct temp_texture
-{
-   GLuint TexObj;
-   GLenum Target;         /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */
-   GLsizei MinSize;       /**< Min texture size to allocate */
-   GLsizei MaxSize;       /**< Max possible texture size */
-   GLboolean NPOT;        /**< Non-power of two size OK? */
-   GLsizei Width, Height; /**< Current texture size */
-   GLenum IntFormat;
-   GLfloat Sright, Ttop;  /**< right, top texcoords */
-};
-
-
-/**
- * State for glBlitFramebufer()
- */
-struct blit_state
-{
-   GLuint ArrayObj;
-   GLuint VBO;
-   GLuint DepthFP;
-};
-
-
-/**
- * State for glClear()
- */
-struct clear_state
-{
-   GLuint ArrayObj;
-   GLuint VBO;
-};
-
-
-/**
- * State for glCopyPixels()
- */
-struct copypix_state
-{
-   GLuint ArrayObj;
-   GLuint VBO;
-};
-
-
-/**
- * State for glDrawPixels()
- */
-struct drawpix_state
-{
-   GLuint ArrayObj;
-
-   GLuint StencilFP;  /**< Fragment program for drawing stencil images */
-   GLuint DepthFP;  /**< Fragment program for drawing depth images */
-};
-
-
-/**
- * State for glBitmap()
- */
-struct bitmap_state
-{
-   GLuint ArrayObj;
-   GLuint VBO;
-   struct temp_texture Tex;  /**< separate texture from other meta ops */
-};
-
-
-/**
- * State for _mesa_meta_generate_mipmap()
- */
-struct gen_mipmap_state
-{
-   GLuint ArrayObj;
-   GLuint VBO;
-   GLuint FBO;
-};
-
-#define MAX_META_OPS_DEPTH      2
-/**
- * All per-context meta state.
- */
-struct gl_meta_state
-{
-   /** Stack of state saved during meta-ops */
-   struct save_state Save[MAX_META_OPS_DEPTH];
-   /** Save stack depth */
-   GLuint SaveStackDepth;
-
-   struct temp_texture TempTex;
-
-   struct blit_state Blit;    /**< For _mesa_meta_BlitFramebuffer() */
-   struct clear_state Clear;  /**< For _mesa_meta_Clear() */
-   struct copypix_state CopyPix;  /**< For _mesa_meta_CopyPixels() */
-   struct drawpix_state DrawPix;  /**< For _mesa_meta_DrawPixels() */
-   struct bitmap_state Bitmap;    /**< For _mesa_meta_Bitmap() */
-   struct gen_mipmap_state Mipmap;    /**< For _mesa_meta_GenerateMipmap() */
-};
-
-
-/**
- * Initialize meta-ops for a context.
- * To be called once during context creation.
- */
-void
-_mesa_meta_init(struct gl_context *ctx)
-{
-   ASSERT(!ctx->Meta);
-
-   ctx->Meta = CALLOC_STRUCT(gl_meta_state);
-}
-
-
-/**
- * Free context meta-op state.
- * To be called once during context destruction.
- */
-void
-_mesa_meta_free(struct gl_context *ctx)
-{
-   /* Note: Any textures, VBOs, etc, that we allocate should get
-    * freed by the normal context destruction code.  But this would be
-    * the place to free other meta data someday.
-    */
-   free(ctx->Meta);
-   ctx->Meta = NULL;
-}
-
-
-/**
- * Enter meta state.  This is like a light-weight version of glPushAttrib
- * but it also resets most GL state back to default values.
- *
- * \param state  bitmask of META_* flags indicating which attribute groups
- *               to save and reset to their defaults
- */
-static void
-_mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
-{
-   struct save_state *save;
-
-   /* hope MAX_META_OPS_DEPTH is large enough */
-   assert(ctx->Meta->SaveStackDepth < MAX_META_OPS_DEPTH);
-
-   save = &ctx->Meta->Save[ctx->Meta->SaveStackDepth++];
-   memset(save, 0, sizeof(*save));
-   save->SavedState = state;
-
-   if (state & META_ALPHA_TEST) {
-      save->AlphaEnabled = ctx->Color.AlphaEnabled;
-      save->AlphaFunc = ctx->Color.AlphaFunc;
-      save->AlphaRef = ctx->Color.AlphaRef;
-      if (ctx->Color.AlphaEnabled)
-         _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);
-   }
-
-   if (state & META_BLEND) {
-      save->BlendEnabled = ctx->Color.BlendEnabled;
-      if (ctx->Color.BlendEnabled) {
-         if (ctx->Extensions.EXT_draw_buffers2) {
-            GLuint i;
-            for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-               _mesa_set_enablei(ctx, GL_BLEND, i, GL_FALSE);
-            }
-         }
-         else {
-            _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);
-         }
-      }
-      save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;
-      if (ctx->Color.ColorLogicOpEnabled)
-         _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);
-   }
-
-   if (state & META_COLOR_MASK) {
-      memcpy(save->ColorMask, ctx->Color.ColorMask,
-             sizeof(ctx->Color.ColorMask));
-      if (!ctx->Color.ColorMask[0][0] ||
-          !ctx->Color.ColorMask[0][1] ||
-          !ctx->Color.ColorMask[0][2] ||
-          !ctx->Color.ColorMask[0][3])
-         _mesa_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-   }
-
-   if (state & META_DEPTH_TEST) {
-      save->Depth = ctx->Depth; /* struct copy */
-      if (ctx->Depth.Test)
-         _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
-   }
-
-   if (state & META_FOG) {
-      save->Fog = ctx->Fog.Enabled;
-      if (ctx->Fog.Enabled)
-         _mesa_set_enable(ctx, GL_FOG, GL_FALSE);
-   }
-
-   if (state & META_PIXEL_STORE) {
-      save->Pack = ctx->Pack;
-      save->Unpack = ctx->Unpack;
-      ctx->Pack = ctx->DefaultPacking;
-      ctx->Unpack = ctx->DefaultPacking;
-   }
-
-   if (state & META_PIXEL_TRANSFER) {
-      save->RedScale = ctx->Pixel.RedScale;
-      save->RedBias = ctx->Pixel.RedBias;
-      save->GreenScale = ctx->Pixel.GreenScale;
-      save->GreenBias = ctx->Pixel.GreenBias;
-      save->BlueScale = ctx->Pixel.BlueScale;
-      save->BlueBias = ctx->Pixel.BlueBias;
-      save->AlphaScale = ctx->Pixel.AlphaScale;
-      save->AlphaBias = ctx->Pixel.AlphaBias;
-      save->MapColorFlag = ctx->Pixel.MapColorFlag;
-      ctx->Pixel.RedScale = 1.0F;
-      ctx->Pixel.RedBias = 0.0F;
-      ctx->Pixel.GreenScale = 1.0F;
-      ctx->Pixel.GreenBias = 0.0F;
-      ctx->Pixel.BlueScale = 1.0F;
-      ctx->Pixel.BlueBias = 0.0F;
-      ctx->Pixel.AlphaScale = 1.0F;
-      ctx->Pixel.AlphaBias = 0.0F;
-      ctx->Pixel.MapColorFlag = GL_FALSE;
-      /* XXX more state */
-      ctx->NewState |=_NEW_PIXEL;
-   }
-
-   if (state & META_RASTERIZATION) {
-      save->FrontPolygonMode = ctx->Polygon.FrontMode;
-      save->BackPolygonMode = ctx->Polygon.BackMode;
-      save->PolygonOffset = ctx->Polygon.OffsetFill;
-      save->PolygonSmooth = ctx->Polygon.SmoothFlag;
-      save->PolygonStipple = ctx->Polygon.StippleFlag;
-      save->PolygonCull = ctx->Polygon.CullFlag;
-      _mesa_PolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-      _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, GL_FALSE);
-      _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, GL_FALSE);
-      _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, GL_FALSE);
-      _mesa_set_enable(ctx, GL_CULL_FACE, GL_FALSE);
-   }
-
-   if (state & META_SCISSOR) {
-      save->Scissor = ctx->Scissor; /* struct copy */
-      _mesa_set_enable(ctx, GL_SCISSOR_TEST, GL_FALSE);
-   }
-
-   if (state & META_SHADER) {
-      if (ctx->Extensions.ARB_vertex_program) {
-         save->VertexProgramEnabled = ctx->VertexProgram.Enabled;
-         _mesa_reference_vertprog(ctx, &save->VertexProgram,
-				  ctx->VertexProgram.Current);
-         _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB, GL_FALSE);
-      }
-
-      if (ctx->Extensions.ARB_fragment_program) {
-         save->FragmentProgramEnabled = ctx->FragmentProgram.Enabled;
-         _mesa_reference_fragprog(ctx, &save->FragmentProgram,
-				  ctx->FragmentProgram.Current);
-         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_FALSE);
-      }
-
-      if (ctx->Extensions.ARB_shader_objects) {
-	 _mesa_reference_shader_program(ctx, &save->VertexShader,
-					ctx->Shader.CurrentVertexProgram);
-	 _mesa_reference_shader_program(ctx, &save->GeometryShader,
-					ctx->Shader.CurrentGeometryProgram);
-	 _mesa_reference_shader_program(ctx, &save->FragmentShader,
-					ctx->Shader.CurrentFragmentProgram);
-	 _mesa_reference_shader_program(ctx, &save->ActiveShader,
-					ctx->Shader.CurrentFragmentProgram);
-
-         _mesa_UseProgramObjectARB(0);
-      }
-   }
-
-   if (state & META_STENCIL_TEST) {
-      save->Stencil = ctx->Stencil; /* struct copy */
-      if (ctx->Stencil.Enabled)
-         _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
-      /* NOTE: other stencil state not reset */
-   }
-
-   if (state & META_TEXTURE) {
-      GLuint u, tgt;
-
-      save->ActiveUnit = ctx->Texture.CurrentUnit;
-      save->ClientActiveUnit = ctx->Array.ActiveTexture;
-      save->EnvMode = ctx->Texture.Unit[0].EnvMode;
-
-      /* Disable all texture units */
-      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         save->TexEnabled[u] = ctx->Texture.Unit[u].Enabled;
-         save->TexGenEnabled[u] = ctx->Texture.Unit[u].TexGenEnabled;
-         if (ctx->Texture.Unit[u].Enabled ||
-             ctx->Texture.Unit[u].TexGenEnabled) {
-            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
-            _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_FALSE);
-            if (ctx->Extensions.ARB_texture_cube_map)
-               _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_FALSE);
-         }
-      }
-
-      /* save current texture objects for unit[0] only */
-      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-         _mesa_reference_texobj(&save->CurrentTexture[tgt],
-                                ctx->Texture.Unit[0].CurrentTex[tgt]);
-      }
-
-      /* set defaults for unit[0] */
-      _mesa_ActiveTextureARB(GL_TEXTURE0);
-      _mesa_ClientActiveTextureARB(GL_TEXTURE0);
-      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-   }
-
-   if (state & META_TRANSFORM) {
-      GLuint activeTexture = ctx->Texture.CurrentUnit;
-      memcpy(save->ModelviewMatrix, ctx->ModelviewMatrixStack.Top->m,
-             16 * sizeof(GLfloat));
-      memcpy(save->ProjectionMatrix, ctx->ProjectionMatrixStack.Top->m,
-             16 * sizeof(GLfloat));
-      memcpy(save->TextureMatrix, ctx->TextureMatrixStack[0].Top->m,
-             16 * sizeof(GLfloat));
-      save->MatrixMode = ctx->Transform.MatrixMode;
-      /* set 1:1 vertex:pixel coordinate transform */
-      _mesa_ActiveTextureARB(GL_TEXTURE0);
-      _mesa_MatrixMode(GL_TEXTURE);
-      _mesa_LoadIdentity();
-      _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
-      _mesa_MatrixMode(GL_MODELVIEW);
-      _mesa_LoadIdentity();
-      _mesa_MatrixMode(GL_PROJECTION);
-      _mesa_LoadIdentity();
-      _mesa_Ortho(0.0, ctx->DrawBuffer->Width,
-                  0.0, ctx->DrawBuffer->Height,
-                  -1.0, 1.0);
-      save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
-      if (ctx->Transform.ClipPlanesEnabled) {
-         GLuint i;
-         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
-            _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
-         }
-      }
-   }
-
-   if (state & META_VERTEX) {
-      /* save vertex array object state */
-      _mesa_reference_array_object(ctx, &save->ArrayObj,
-                                   ctx->Array.ArrayObj);
-      _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj,
-                                    ctx->Array.ArrayBufferObj);
-      /* set some default state? */
-   }
-
-   if (state & META_VIEWPORT) {
-      /* save viewport state */
-      save->ViewportX = ctx->Viewport.X;
-      save->ViewportY = ctx->Viewport.Y;
-      save->ViewportW = ctx->Viewport.Width;
-      save->ViewportH = ctx->Viewport.Height;
-      /* set viewport to match window size */
-      if (ctx->Viewport.X != 0 ||
-          ctx->Viewport.Y != 0 ||
-          ctx->Viewport.Width != ctx->DrawBuffer->Width ||
-          ctx->Viewport.Height != ctx->DrawBuffer->Height) {
-         _mesa_set_viewport(ctx, 0, 0,
-                            ctx->DrawBuffer->Width, ctx->DrawBuffer->Height);
-      }
-      /* save depth range state */
-      save->DepthNear = ctx->Viewport.Near;
-      save->DepthFar = ctx->Viewport.Far;
-      /* set depth range to default */
-      _mesa_DepthRange(0.0, 1.0);
-   }
-
-   /* misc */
-   {
-      save->Lighting = ctx->Light.Enabled;
-      if (ctx->Light.Enabled)
-         _mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);
-   }
-}
-
-
-/**
- * Leave meta state.  This is like a light-weight version of glPopAttrib().
- */
-static void
-_mesa_meta_end(struct gl_context *ctx)
-{
-   struct save_state *save = &ctx->Meta->Save[--ctx->Meta->SaveStackDepth];
-   const GLbitfield state = save->SavedState;
-
-   if (state & META_ALPHA_TEST) {
-      if (ctx->Color.AlphaEnabled != save->AlphaEnabled)
-         _mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);
-      _mesa_AlphaFunc(save->AlphaFunc, save->AlphaRef);
-   }
-
-   if (state & META_BLEND) {
-      if (ctx->Color.BlendEnabled != save->BlendEnabled) {
-         if (ctx->Extensions.EXT_draw_buffers2) {
-            GLuint i;
-            for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-               _mesa_set_enablei(ctx, GL_BLEND, i, (save->BlendEnabled >> i) & 1);
-            }
-         }
-         else {
-            _mesa_set_enable(ctx, GL_BLEND, (save->BlendEnabled & 1));
-         }
-      }
-      if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)
-         _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);
-   }
-
-   if (state & META_COLOR_MASK) {
-      GLuint i;
-      for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-         if (!TEST_EQ_4V(ctx->Color.ColorMask[i], save->ColorMask[i])) {
-            if (i == 0) {
-               _mesa_ColorMask(save->ColorMask[i][0], save->ColorMask[i][1],
-                               save->ColorMask[i][2], save->ColorMask[i][3]);
-            }
-            else {
-               _mesa_ColorMaskIndexed(i,
-                                      save->ColorMask[i][0],
-                                      save->ColorMask[i][1],
-                                      save->ColorMask[i][2],
-                                      save->ColorMask[i][3]);
-            }
-         }
-      }
-   }
-
-   if (state & META_DEPTH_TEST) {
-      if (ctx->Depth.Test != save->Depth.Test)
-         _mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);
-      _mesa_DepthFunc(save->Depth.Func);
-      _mesa_DepthMask(save->Depth.Mask);
-   }
-
-   if (state & META_FOG) {
-      _mesa_set_enable(ctx, GL_FOG, save->Fog);
-   }
-
-   if (state & META_PIXEL_STORE) {
-      ctx->Pack = save->Pack;
-      ctx->Unpack = save->Unpack;
-   }
-
-   if (state & META_PIXEL_TRANSFER) {
-      ctx->Pixel.RedScale = save->RedScale;
-      ctx->Pixel.RedBias = save->RedBias;
-      ctx->Pixel.GreenScale = save->GreenScale;
-      ctx->Pixel.GreenBias = save->GreenBias;
-      ctx->Pixel.BlueScale = save->BlueScale;
-      ctx->Pixel.BlueBias = save->BlueBias;
-      ctx->Pixel.AlphaScale = save->AlphaScale;
-      ctx->Pixel.AlphaBias = save->AlphaBias;
-      ctx->Pixel.MapColorFlag = save->MapColorFlag;
-      /* XXX more state */
-      ctx->NewState |=_NEW_PIXEL;
-   }
-
-   if (state & META_RASTERIZATION) {
-      _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
-      _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
-      _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);
-      _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);
-      _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);
-      _mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);
-   }
-
-   if (state & META_SCISSOR) {
-      _mesa_set_enable(ctx, GL_SCISSOR_TEST, save->Scissor.Enabled);
-      _mesa_Scissor(save->Scissor.X, save->Scissor.Y,
-                    save->Scissor.Width, save->Scissor.Height);
-   }
-
-   if (state & META_SHADER) {
-      if (ctx->Extensions.ARB_vertex_program) {
-         _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB,
-                          save->VertexProgramEnabled);
-         _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, 
-                                  save->VertexProgram);
-	 _mesa_reference_vertprog(ctx, &save->VertexProgram, NULL);
-      }
-
-      if (ctx->Extensions.ARB_fragment_program) {
-         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB,
-                          save->FragmentProgramEnabled);
-         _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
-                                  save->FragmentProgram);
-	 _mesa_reference_fragprog(ctx, &save->FragmentProgram, NULL);
-      }
-
-      if (ctx->Extensions.ARB_vertex_shader)
-	 _mesa_use_shader_program(ctx, GL_VERTEX_SHADER, save->VertexShader);
-
-      if (ctx->Extensions.ARB_geometry_shader4)
-	 _mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB,
-				  save->GeometryShader);
-
-      if (ctx->Extensions.ARB_fragment_shader)
-	 _mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER,
-				  save->FragmentShader);
-
-      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram,
-				     save->ActiveShader);
-   }
-
-   if (state & META_STENCIL_TEST) {
-      const struct gl_stencil_attrib *stencil = &save->Stencil;
-
-      _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
-      _mesa_ClearStencil(stencil->Clear);
-      if (ctx->Extensions.EXT_stencil_two_side) {
-         _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
-                          stencil->TestTwoSide);
-         _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
-                                    ? GL_BACK : GL_FRONT);
-      }
-      /* front state */
-      _mesa_StencilFuncSeparate(GL_FRONT,
-                                stencil->Function[0],
-                                stencil->Ref[0],
-                                stencil->ValueMask[0]);
-      _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
-      _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
-                              stencil->ZFailFunc[0],
-                              stencil->ZPassFunc[0]);
-      /* back state */
-      _mesa_StencilFuncSeparate(GL_BACK,
-                                stencil->Function[1],
-                                stencil->Ref[1],
-                                stencil->ValueMask[1]);
-      _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
-      _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
-                              stencil->ZFailFunc[1],
-                              stencil->ZPassFunc[1]);
-   }
-
-   if (state & META_TEXTURE) {
-      GLuint u, tgt;
-
-      ASSERT(ctx->Texture.CurrentUnit == 0);
-
-      /* restore texenv for unit[0] */
-      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);
-
-      /* restore texture objects for unit[0] only */
-      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-         _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt],
-                                save->CurrentTexture[tgt]);
-         _mesa_reference_texobj(&save->CurrentTexture[tgt], NULL);
-      }
-
-      /* Re-enable textures, texgen */
-      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         if (save->TexEnabled[u]) {
-            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
-
-            if (save->TexEnabled[u] & TEXTURE_1D_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_TRUE);
-            if (save->TexEnabled[u] & TEXTURE_2D_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_TRUE);
-            if (save->TexEnabled[u] & TEXTURE_3D_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_TRUE);
-            if (save->TexEnabled[u] & TEXTURE_CUBE_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_TRUE);
-            if (save->TexEnabled[u] & TEXTURE_RECT_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_TRUE);
-         }
-
-         if (save->TexGenEnabled[u]) {
-            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
-
-            if (save->TexGenEnabled[u] & S_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_TRUE);
-            if (save->TexGenEnabled[u] & T_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_TRUE);
-            if (save->TexGenEnabled[u] & R_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_TRUE);
-            if (save->TexGenEnabled[u] & Q_BIT)
-               _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_TRUE);
-         }
-      }
-
-      /* restore current unit state */
-      _mesa_ActiveTextureARB(GL_TEXTURE0 + save->ActiveUnit);
-      _mesa_ClientActiveTextureARB(GL_TEXTURE0 + save->ClientActiveUnit);
-   }
-
-   if (state & META_TRANSFORM) {
-      GLuint activeTexture = ctx->Texture.CurrentUnit;
-      _mesa_ActiveTextureARB(GL_TEXTURE0);
-      _mesa_MatrixMode(GL_TEXTURE);
-      _mesa_LoadMatrixf(save->TextureMatrix);
-      _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
-
-      _mesa_MatrixMode(GL_MODELVIEW);
-      _mesa_LoadMatrixf(save->ModelviewMatrix);
-
-      _mesa_MatrixMode(GL_PROJECTION);
-      _mesa_LoadMatrixf(save->ProjectionMatrix);
-
-      _mesa_MatrixMode(save->MatrixMode);
-
-      if (save->ClipPlanesEnabled) {
-         GLuint i;
-         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
-            if (save->ClipPlanesEnabled & (1 << i)) {
-               _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
-            }
-         }
-      }
-   }
-
-   if (state & META_VERTEX) {
-      /* restore vertex buffer object */
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, save->ArrayBufferObj->Name);
-      _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj, NULL);
-
-      /* restore vertex array object */
-      _mesa_BindVertexArray(save->ArrayObj->Name);
-      _mesa_reference_array_object(ctx, &save->ArrayObj, NULL);
-   }
-
-   if (state & META_VIEWPORT) {
-      if (save->ViewportX != ctx->Viewport.X ||
-          save->ViewportY != ctx->Viewport.Y ||
-          save->ViewportW != ctx->Viewport.Width ||
-          save->ViewportH != ctx->Viewport.Height) {
-         _mesa_set_viewport(ctx, save->ViewportX, save->ViewportY,
-                            save->ViewportW, save->ViewportH);
-      }
-      _mesa_DepthRange(save->DepthNear, save->DepthFar);
-   }
-
-   /* misc */
-   if (save->Lighting) {
-      _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
-   }
-}
-
-
-/**
- * Convert Z from a normalized value in the range [0, 1] to an object-space
- * Z coordinate in [-1, +1] so that drawing at the new Z position with the
- * default/identity ortho projection results in the original Z value.
- * Used by the meta-Clear, Draw/CopyPixels and Bitmap functions where the Z
- * value comes from the clear value or raster position.
- */
-static INLINE GLfloat
-invert_z(GLfloat normZ)
-{
-   GLfloat objZ = 1.0 - 2.0 * normZ;
-   return objZ;
-}
-
-
-/**
- * One-time init for a temp_texture object.
- * Choose tex target, compute max tex size, etc.
- */
-static void
-init_temp_texture(struct gl_context *ctx, struct temp_texture *tex)
-{
-   /* prefer texture rectangle */
-   if (ctx->Extensions.NV_texture_rectangle) {
-      tex->Target = GL_TEXTURE_RECTANGLE;
-      tex->MaxSize = ctx->Const.MaxTextureRectSize;
-      tex->NPOT = GL_TRUE;
-   }
-   else {
-      /* use 2D texture, NPOT if possible */
-      tex->Target = GL_TEXTURE_2D;
-      tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
-   }
-   tex->MinSize = 16;  /* 16 x 16 at least */
-   assert(tex->MaxSize > 0);
-
-   _mesa_GenTextures(1, &tex->TexObj);
-}
-
-
-/**
- * Return pointer to temp_texture info for non-bitmap ops.
- * This does some one-time init if needed.
- */
-static struct temp_texture *
-get_temp_texture(struct gl_context *ctx)
-{
-   struct temp_texture *tex = &ctx->Meta->TempTex;
-
-   if (!tex->TexObj) {
-      init_temp_texture(ctx, tex);
-   }
-
-   return tex;
-}
-
-
-/**
- * Return pointer to temp_texture info for _mesa_meta_bitmap().
- * We use a separate texture for bitmaps to reduce texture
- * allocation/deallocation.
- */
-static struct temp_texture *
-get_bitmap_temp_texture(struct gl_context *ctx)
-{
-   struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;
-
-   if (!tex->TexObj) {
-      init_temp_texture(ctx, tex);
-   }
-
-   return tex;
-}
-
-
-/**
- * Compute the width/height of texture needed to draw an image of the
- * given size.  Return a flag indicating whether the current texture
- * can be re-used (glTexSubImage2D) or if a new texture needs to be
- * allocated (glTexImage2D).
- * Also, compute s/t texcoords for drawing.
- *
- * \return GL_TRUE if new texture is needed, GL_FALSE otherwise
- */
-static GLboolean
-alloc_texture(struct temp_texture *tex,
-              GLsizei width, GLsizei height, GLenum intFormat)
-{
-   GLboolean newTex = GL_FALSE;
-
-   ASSERT(width <= tex->MaxSize);
-   ASSERT(height <= tex->MaxSize);
-
-   if (width > tex->Width ||
-       height > tex->Height ||
-       intFormat != tex->IntFormat) {
-      /* alloc new texture (larger or different format) */
-
-      if (tex->NPOT) {
-         /* use non-power of two size */
-         tex->Width = MAX2(tex->MinSize, width);
-         tex->Height = MAX2(tex->MinSize, height);
-      }
-      else {
-         /* find power of two size */
-         GLsizei w, h;
-         w = h = tex->MinSize;
-         while (w < width)
-            w *= 2;
-         while (h < height)
-            h *= 2;
-         tex->Width = w;
-         tex->Height = h;
-      }
-
-      tex->IntFormat = intFormat;
-
-      newTex = GL_TRUE;
-   }
-
-   /* compute texcoords */
-   if (tex->Target == GL_TEXTURE_RECTANGLE) {
-      tex->Sright = (GLfloat) width;
-      tex->Ttop = (GLfloat) height;
-   }
-   else {
-      tex->Sright = (GLfloat) width / tex->Width;
-      tex->Ttop = (GLfloat) height / tex->Height;
-   }
-
-   return newTex;
-}
-
-
-/**
- * Setup/load texture for glCopyPixels or glBlitFramebuffer.
- */
-static void
-setup_copypix_texture(struct temp_texture *tex,
-                      GLboolean newTex,
-                      GLint srcX, GLint srcY,
-                      GLsizei width, GLsizei height, GLenum intFormat,
-                      GLenum filter)
-{
-   _mesa_BindTexture(tex->Target, tex->TexObj);
-   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, filter);
-   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, filter);
-   _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
-   /* copy framebuffer image to texture */
-   if (newTex) {
-      /* create new tex image */
-      if (tex->Width == width && tex->Height == height) {
-         /* create new tex with framebuffer data */
-         _mesa_CopyTexImage2D(tex->Target, 0, tex->IntFormat,
-                              srcX, srcY, width, height, 0);
-      }
-      else {
-         /* create empty texture */
-         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
-                          tex->Width, tex->Height, 0,
-                          intFormat, GL_UNSIGNED_BYTE, NULL);
-         /* load image */
-         _mesa_CopyTexSubImage2D(tex->Target, 0,
-                                 0, 0, srcX, srcY, width, height);
-      }
-   }
-   else {
-      /* replace existing tex image */
-      _mesa_CopyTexSubImage2D(tex->Target, 0,
-                              0, 0, srcX, srcY, width, height);
-   }
-}
-
-
-/**
- * Setup/load texture for glDrawPixels.
- */
-static void
-setup_drawpix_texture(struct gl_context *ctx,
-		      struct temp_texture *tex,
-                      GLboolean newTex,
-                      GLenum texIntFormat,
-                      GLsizei width, GLsizei height,
-                      GLenum format, GLenum type,
-                      const GLvoid *pixels)
-{
-   _mesa_BindTexture(tex->Target, tex->TexObj);
-   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-   _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
-   /* copy pixel data to texture */
-   if (newTex) {
-      /* create new tex image */
-      if (tex->Width == width && tex->Height == height) {
-         /* create new tex and load image data */
-         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
-                          tex->Width, tex->Height, 0, format, type, pixels);
-      }
-      else {
-	 struct gl_buffer_object *save_unpack_obj = NULL;
-
-	 _mesa_reference_buffer_object(ctx, &save_unpack_obj,
-				       ctx->Unpack.BufferObj);
-	 _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-         /* create empty texture */
-         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
-                          tex->Width, tex->Height, 0, format, type, NULL);
-	 if (save_unpack_obj != NULL)
-	    _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
-				save_unpack_obj->Name);
-         /* load image */
-         _mesa_TexSubImage2D(tex->Target, 0,
-                             0, 0, width, height, format, type, pixels);
-      }
-   }
-   else {
-      /* replace existing tex image */
-      _mesa_TexSubImage2D(tex->Target, 0,
-                          0, 0, width, height, format, type, pixels);
-   }
-}
-
-
-
-/**
- * One-time init for drawing depth pixels.
- */
-static void
-init_blit_depth_pixels(struct gl_context *ctx)
-{
-   static const char *program =
-      "!!ARBfp1.0\n"
-      "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
-      "END \n";
-   char program2[200];
-   struct blit_state *blit = &ctx->Meta->Blit;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   const char *texTarget;
-
-   assert(blit->DepthFP == 0);
-
-   /* replace %s with "RECT" or "2D" */
-   assert(strlen(program) + 4 < sizeof(program2));
-   if (tex->Target == GL_TEXTURE_RECTANGLE)
-      texTarget = "RECT";
-   else
-      texTarget = "2D";
-   _mesa_snprintf(program2, sizeof(program2), program, texTarget);
-
-   _mesa_GenPrograms(1, &blit->DepthFP);
-   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
-   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
-                          strlen(program2), (const GLubyte *) program2);
-}
-
-
-/**
- * Try to do a glBlitFramebuffer using no-copy texturing.
- * We can do this when the src renderbuffer is actually a texture.
- * But if the src buffer == dst buffer we cannot do this.
- *
- * \return new buffer mask indicating the buffers left to blit using the
- *         normal path.
- */
-static GLbitfield
-blitframebuffer_texture(struct gl_context *ctx,
-                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                        GLbitfield mask, GLenum filter)
-{
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      const struct gl_framebuffer *drawFb = ctx->DrawBuffer;
-      const struct gl_framebuffer *readFb = ctx->ReadBuffer;
-      const struct gl_renderbuffer_attachment *drawAtt =
-         &drawFb->Attachment[drawFb->_ColorDrawBufferIndexes[0]];
-      const struct gl_renderbuffer_attachment *readAtt =
-         &readFb->Attachment[readFb->_ColorReadBufferIndex];
-
-      if (readAtt && readAtt->Texture) {
-         const struct gl_texture_object *texObj = readAtt->Texture;
-         const GLuint srcLevel = readAtt->TextureLevel;
-         const GLenum minFilterSave = texObj->MinFilter;
-         const GLenum magFilterSave = texObj->MagFilter;
-         const GLint baseLevelSave = texObj->BaseLevel;
-         const GLint maxLevelSave = texObj->MaxLevel;
-         const GLenum wrapSSave = texObj->WrapS;
-         const GLenum wrapTSave = texObj->WrapT;
-         const GLenum target = texObj->Target;
-
-         if (drawAtt->Texture == readAtt->Texture) {
-            /* Can't use same texture as both the source and dest.  We need
-             * to handle overlapping blits and besides, some hw may not
-             * support this.
-             */
-            return mask;
-         }
-
-         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_RECTANGLE_ARB) {
-            /* Can't handle other texture types at this time */
-            return mask;
-         }
-
-         /*
-         printf("Blit from texture!\n");
-         printf("  srcAtt %p  dstAtt %p\n", readAtt, drawAtt);
-         printf("  srcTex %p  dstText %p\n", texObj, drawAtt->Texture);
-         */
-
-         /* Prepare src texture state */
-         _mesa_BindTexture(target, texObj->Name);
-         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
-         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
-         if (target != GL_TEXTURE_RECTANGLE_ARB) {
-            _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, srcLevel);
-            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);
-         }
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-         _mesa_set_enable(ctx, target, GL_TRUE);
-
-         /* Prepare vertex data (the VBO was previously created and bound) */
-         {
-            struct vertex {
-               GLfloat x, y, s, t;
-            };
-            struct vertex verts[4];
-            GLfloat s0, t0, s1, t1;
-
-            if (target == GL_TEXTURE_2D) {
-               const struct gl_texture_image *texImage
-                   = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
-               s0 = srcX0 / (float) texImage->Width;
-               s1 = srcX1 / (float) texImage->Width;
-               t0 = srcY0 / (float) texImage->Height;
-               t1 = srcY1 / (float) texImage->Height;
-            }
-            else {
-               assert(target == GL_TEXTURE_RECTANGLE_ARB);
-               s0 = srcX0;
-               s1 = srcX1;
-               t0 = srcY0;
-               t1 = srcY1;
-            }
-
-            verts[0].x = (GLfloat) dstX0;
-            verts[0].y = (GLfloat) dstY0;
-            verts[1].x = (GLfloat) dstX1;
-            verts[1].y = (GLfloat) dstY0;
-            verts[2].x = (GLfloat) dstX1;
-            verts[2].y = (GLfloat) dstY1;
-            verts[3].x = (GLfloat) dstX0;
-            verts[3].y = (GLfloat) dstY1;
-
-            verts[0].s = s0;
-            verts[0].t = t0;
-            verts[1].s = s1;
-            verts[1].t = t0;
-            verts[2].s = s1;
-            verts[2].t = t1;
-            verts[3].s = s0;
-            verts[3].t = t1;
-
-            _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
-         }
-
-         _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-         /* Restore texture object state, the texture binding will
-          * be restored by _mesa_meta_end().
-          */
-         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
-         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
-         if (target != GL_TEXTURE_RECTANGLE_ARB) {
-            _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);
-            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
-         }
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
-
-         /* Done with color buffer */
-         mask &= ~GL_COLOR_BUFFER_BIT;
-      }
-   }
-
-   return mask;
-}
-
-
-/**
- * Meta implementation of ctx->Driver.BlitFramebuffer() in terms
- * of texture mapping and polygon rendering.
- */
-void
-_mesa_meta_BlitFramebuffer(struct gl_context *ctx,
-                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                           GLbitfield mask, GLenum filter)
-{
-   struct blit_state *blit = &ctx->Meta->Blit;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   const GLsizei maxTexSize = tex->MaxSize;
-   const GLint srcX = MIN2(srcX0, srcX1);
-   const GLint srcY = MIN2(srcY0, srcY1);
-   const GLint srcW = abs(srcX1 - srcX0);
-   const GLint srcH = abs(srcY1 - srcY0);
-   const GLboolean srcFlipX = srcX1 < srcX0;
-   const GLboolean srcFlipY = srcY1 < srcY0;
-   struct vertex {
-      GLfloat x, y, s, t;
-   };
-   struct vertex verts[4];
-   GLboolean newTex;
-
-   if (srcW > maxTexSize || srcH > maxTexSize) {
-      /* XXX avoid this fallback */
-      _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
-                              dstX0, dstY0, dstX1, dstY1, mask, filter);
-      return;
-   }
-
-   if (srcFlipX) {
-      GLint tmp = dstX0;
-      dstX0 = dstX1;
-      dstX1 = tmp;
-   }
-
-   if (srcFlipY) {
-      GLint tmp = dstY0;
-      dstY0 = dstY1;
-      dstY1 = tmp;
-   }
-
-   /* only scissor effects blit so save/clear all other relevant state */
-   _mesa_meta_begin(ctx, ~META_SCISSOR);
-
-   if (blit->ArrayObj == 0) {
-      /* one-time setup */
-
-      /* create vertex array object */
-      _mesa_GenVertexArrays(1, &blit->ArrayObj);
-      _mesa_BindVertexArray(blit->ArrayObj);
-
-      /* create vertex array buffer */
-      _mesa_GenBuffersARB(1, &blit->VBO);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
-      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
-                          NULL, GL_DYNAMIC_DRAW_ARB);
-
-      /* setup vertex arrays */
-      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
-      _mesa_EnableClientState(GL_VERTEX_ARRAY);
-      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
-   }
-   else {
-      _mesa_BindVertexArray(blit->ArrayObj);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
-   }
-
-   /* Try faster, direct texture approach first */
-   mask = blitframebuffer_texture(ctx, srcX0, srcY0, srcX1, srcY1,
-                                  dstX0, dstY0, dstX1, dstY1, mask, filter);
-   if (mask == 0x0) {
-      _mesa_meta_end(ctx);
-      return;
-   }
-
-   /* Continue with "normal" approach which involves copying the src rect
-    * into a temporary texture and is "blitted" by drawing a textured quad.
-    */
-
-   newTex = alloc_texture(tex, srcW, srcH, GL_RGBA);
-
-   /* vertex positions/texcoords (after texture allocation!) */
-   {
-      verts[0].x = (GLfloat) dstX0;
-      verts[0].y = (GLfloat) dstY0;
-      verts[1].x = (GLfloat) dstX1;
-      verts[1].y = (GLfloat) dstY0;
-      verts[2].x = (GLfloat) dstX1;
-      verts[2].y = (GLfloat) dstY1;
-      verts[3].x = (GLfloat) dstX0;
-      verts[3].y = (GLfloat) dstY1;
-
-      verts[0].s = 0.0F;
-      verts[0].t = 0.0F;
-      verts[1].s = tex->Sright;
-      verts[1].t = 0.0F;
-      verts[2].s = tex->Sright;
-      verts[2].t = tex->Ttop;
-      verts[3].s = 0.0F;
-      verts[3].t = tex->Ttop;
-
-      /* upload new vertex data */
-      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
-   }
-
-   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
-
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      setup_copypix_texture(tex, newTex, srcX, srcY, srcW, srcH,
-                            GL_RGBA, filter);
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-      mask &= ~GL_COLOR_BUFFER_BIT;
-   }
-
-   if (mask & GL_DEPTH_BUFFER_BIT) {
-      GLuint *tmp = (GLuint *) malloc(srcW * srcH * sizeof(GLuint));
-      if (tmp) {
-         if (!blit->DepthFP)
-            init_blit_depth_pixels(ctx);
-
-         /* maybe change tex format here */
-         newTex = alloc_texture(tex, srcW, srcH, GL_DEPTH_COMPONENT);
-
-         _mesa_ReadPixels(srcX, srcY, srcW, srcH,
-                          GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
-
-         setup_drawpix_texture(ctx, tex, newTex, GL_DEPTH_COMPONENT, srcW, srcH,
-                               GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
-
-         _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
-         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
-         _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-         _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
-         _mesa_DepthFunc(GL_ALWAYS);
-         _mesa_DepthMask(GL_TRUE);
-
-         _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-         mask &= ~GL_DEPTH_BUFFER_BIT;
-
-         free(tmp);
-      }
-   }
-
-   if (mask & GL_STENCIL_BUFFER_BIT) {
-      /* XXX can't easily do stencil */
-   }
-
-   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
-
-   _mesa_meta_end(ctx);
-
-   if (mask) {
-      _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
-                              dstX0, dstY0, dstX1, dstY1, mask, filter);
-   }
-}
-
-
-/**
- * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
- */
-void
-_mesa_meta_Clear(struct gl_context *ctx, GLbitfield buffers)
-{
-   struct clear_state *clear = &ctx->Meta->Clear;
-   struct vertex {
-      GLfloat x, y, z, r, g, b, a;
-   };
-   struct vertex verts[4];
-   /* save all state but scissor, pixel pack/unpack */
-   GLbitfield metaSave = META_ALL - META_SCISSOR - META_PIXEL_STORE;
-   const GLuint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
-
-   if (buffers & BUFFER_BITS_COLOR) {
-      /* if clearing color buffers, don't save/restore colormask */
-      metaSave -= META_COLOR_MASK;
-   }
-
-   _mesa_meta_begin(ctx, metaSave);
-
-   if (clear->ArrayObj == 0) {
-      /* one-time setup */
-
-      /* create vertex array object */
-      _mesa_GenVertexArrays(1, &clear->ArrayObj);
-      _mesa_BindVertexArray(clear->ArrayObj);
-
-      /* create vertex array buffer */
-      _mesa_GenBuffersARB(1, &clear->VBO);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
-
-      /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
-      _mesa_EnableClientState(GL_VERTEX_ARRAY);
-      _mesa_EnableClientState(GL_COLOR_ARRAY);
-   }
-   else {
-      _mesa_BindVertexArray(clear->ArrayObj);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
-   }
-
-   /* GL_COLOR_BUFFER_BIT */
-   if (buffers & BUFFER_BITS_COLOR) {
-      /* leave colormask, glDrawBuffer state as-is */
-   }
-   else {
-      ASSERT(metaSave & META_COLOR_MASK);
-      _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-   }
-
-   /* GL_DEPTH_BUFFER_BIT */
-   if (buffers & BUFFER_BIT_DEPTH) {
-      _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
-      _mesa_DepthFunc(GL_ALWAYS);
-      _mesa_DepthMask(GL_TRUE);
-   }
-   else {
-      assert(!ctx->Depth.Test);
-   }
-
-   /* GL_STENCIL_BUFFER_BIT */
-   if (buffers & BUFFER_BIT_STENCIL) {
-      _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
-      _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,
-                              GL_REPLACE, GL_REPLACE, GL_REPLACE);
-      _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,
-                                ctx->Stencil.Clear & stencilMax,
-                                ctx->Stencil.WriteMask[0]);
-   }
-   else {
-      assert(!ctx->Stencil.Enabled);
-   }
-
-   /* vertex positions/colors */
-   {
-      const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin;
-      const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin;
-      const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax;
-      const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax;
-      const GLfloat z = invert_z(ctx->Depth.Clear);
-      GLuint i;
-
-      verts[0].x = x0;
-      verts[0].y = y0;
-      verts[0].z = z;
-      verts[1].x = x1;
-      verts[1].y = y0;
-      verts[1].z = z;
-      verts[2].x = x1;
-      verts[2].y = y1;
-      verts[2].z = z;
-      verts[3].x = x0;
-      verts[3].y = y1;
-      verts[3].z = z;
-
-      /* vertex colors */
-      for (i = 0; i < 4; i++) {
-         verts[i].r = ctx->Color.ClearColor[0];
-         verts[i].g = ctx->Color.ClearColor[1];
-         verts[i].b = ctx->Color.ClearColor[2];
-         verts[i].a = ctx->Color.ClearColor[3];
-      }
-
-      /* upload new vertex data */
-      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,
-			  GL_DYNAMIC_DRAW_ARB);
-   }
-
-   /* draw quad */
-   _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-   _mesa_meta_end(ctx);
-}
-
-
-/**
- * Meta implementation of ctx->Driver.CopyPixels() in terms
- * of texture mapping and polygon rendering.
- */
-void
-_mesa_meta_CopyPixels(struct gl_context *ctx, GLint srcX, GLint srcY,
-                      GLsizei width, GLsizei height,
-                      GLint dstX, GLint dstY, GLenum type)
-{
-   struct copypix_state *copypix = &ctx->Meta->CopyPix;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   struct vertex {
-      GLfloat x, y, z, s, t;
-   };
-   struct vertex verts[4];
-   GLboolean newTex;
-   GLenum intFormat = GL_RGBA;
-
-   if (type != GL_COLOR ||
-       ctx->_ImageTransferState ||
-       ctx->Fog.Enabled ||
-       width > tex->MaxSize ||
-       height > tex->MaxSize) {
-      /* XXX avoid this fallback */
-      _swrast_CopyPixels(ctx, srcX, srcY, width, height, dstX, dstY, type);
-      return;
-   }
-
-   /* Most GL state applies to glCopyPixels, but a there's a few things
-    * we need to override:
-    */
-   _mesa_meta_begin(ctx, (META_RASTERIZATION |
-                          META_SHADER |
-                          META_TEXTURE |
-                          META_TRANSFORM |
-                          META_VERTEX |
-                          META_VIEWPORT));
-
-   if (copypix->ArrayObj == 0) {
-      /* one-time setup */
-
-      /* create vertex array object */
-      _mesa_GenVertexArrays(1, &copypix->ArrayObj);
-      _mesa_BindVertexArray(copypix->ArrayObj);
-
-      /* create vertex array buffer */
-      _mesa_GenBuffersARB(1, &copypix->VBO);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
-      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
-                          NULL, GL_DYNAMIC_DRAW_ARB);
-
-      /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
-      _mesa_EnableClientState(GL_VERTEX_ARRAY);
-      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
-   }
-   else {
-      _mesa_BindVertexArray(copypix->ArrayObj);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
-   }
-
-   newTex = alloc_texture(tex, width, height, intFormat);
-
-   /* vertex positions, texcoords (after texture allocation!) */
-   {
-      const GLfloat dstX0 = (GLfloat) dstX;
-      const GLfloat dstY0 = (GLfloat) dstY;
-      const GLfloat dstX1 = dstX + width * ctx->Pixel.ZoomX;
-      const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
-      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
-
-      verts[0].x = dstX0;
-      verts[0].y = dstY0;
-      verts[0].z = z;
-      verts[0].s = 0.0F;
-      verts[0].t = 0.0F;
-      verts[1].x = dstX1;
-      verts[1].y = dstY0;
-      verts[1].z = z;
-      verts[1].s = tex->Sright;
-      verts[1].t = 0.0F;
-      verts[2].x = dstX1;
-      verts[2].y = dstY1;
-      verts[2].z = z;
-      verts[2].s = tex->Sright;
-      verts[2].t = tex->Ttop;
-      verts[3].x = dstX0;
-      verts[3].y = dstY1;
-      verts[3].z = z;
-      verts[3].s = 0.0F;
-      verts[3].t = tex->Ttop;
-
-      /* upload new vertex data */
-      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
-   }
-
-   /* Alloc/setup texture */
-   setup_copypix_texture(tex, newTex, srcX, srcY, width, height,
-                         GL_RGBA, GL_NEAREST);
-
-   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
-
-   /* draw textured quad */
-   _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
-
-   _mesa_meta_end(ctx);
-}
-
-
-
-/**
- * When the glDrawPixels() image size is greater than the max rectangle
- * texture size we use this function to break the glDrawPixels() image
- * into tiles which fit into the max texture size.
- */
-static void
-tiled_draw_pixels(struct gl_context *ctx,
-                  GLint tileSize,
-                  GLint x, GLint y, GLsizei width, GLsizei height,
-                  GLenum format, GLenum type,
-                  const struct gl_pixelstore_attrib *unpack,
-                  const GLvoid *pixels)
-{
-   struct gl_pixelstore_attrib tileUnpack = *unpack;
-   GLint i, j;
-
-   if (tileUnpack.RowLength == 0)
-      tileUnpack.RowLength = width;
-
-   for (i = 0; i < width; i += tileSize) {
-      const GLint tileWidth = MIN2(tileSize, width - i);
-      const GLint tileX = (GLint) (x + i * ctx->Pixel.ZoomX);
-
-      tileUnpack.SkipPixels = unpack->SkipPixels + i;
-
-      for (j = 0; j < height; j += tileSize) {
-         const GLint tileHeight = MIN2(tileSize, height - j);
-         const GLint tileY = (GLint) (y + j * ctx->Pixel.ZoomY);
-
-         tileUnpack.SkipRows = unpack->SkipRows + j;
-
-         _mesa_meta_DrawPixels(ctx, tileX, tileY, tileWidth, tileHeight,
-                               format, type, &tileUnpack, pixels);
-      }
-   }
-}
-
-
-/**
- * One-time init for drawing stencil pixels.
- */
-static void
-init_draw_stencil_pixels(struct gl_context *ctx)
-{
-   /* This program is run eight times, once for each stencil bit.
-    * The stencil values to draw are found in an 8-bit alpha texture.
-    * We read the texture/stencil value and test if bit 'b' is set.
-    * If the bit is not set, use KIL to kill the fragment.
-    * Finally, we use the stencil test to update the stencil buffer.
-    *
-    * The basic algorithm for checking if a bit is set is:
-    *   if (is_odd(value / (1 << bit)))
-    *      result is one (or non-zero).
-    *   else
-    *      result is zero.
-    * The program parameter contains three values:
-    *   parm.x = 255 / (1 << bit)
-    *   parm.y = 0.5
-    *   parm.z = 0.0
-    */
-   static const char *program =
-      "!!ARBfp1.0\n"
-      "PARAM parm = program.local[0]; \n"
-      "TEMP t; \n"
-      "TEX t, fragment.texcoord[0], texture[0], %s; \n"   /* NOTE %s here! */
-      "# t = t * 255 / bit \n"
-      "MUL t.x, t.a, parm.x; \n"
-      "# t = (int) t \n"
-      "FRC t.y, t.x; \n"
-      "SUB t.x, t.x, t.y; \n"
-      "# t = t * 0.5 \n"
-      "MUL t.x, t.x, parm.y; \n"
-      "# t = fract(t.x) \n"
-      "FRC t.x, t.x; # if t.x != 0, then the bit is set \n"
-      "# t.x = (t.x == 0 ? 1 : 0) \n"
-      "SGE t.x, -t.x, parm.z; \n"
-      "KIL -t.x; \n"
-      "# for debug only \n"
-      "#MOV result.color, t.x; \n"
-      "END \n";
-   char program2[1000];
-   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   const char *texTarget;
-
-   assert(drawpix->StencilFP == 0);
-
-   /* replace %s with "RECT" or "2D" */
-   assert(strlen(program) + 4 < sizeof(program2));
-   if (tex->Target == GL_TEXTURE_RECTANGLE)
-      texTarget = "RECT";
-   else
-      texTarget = "2D";
-   _mesa_snprintf(program2, sizeof(program2), program, texTarget);
-
-   _mesa_GenPrograms(1, &drawpix->StencilFP);
-   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
-   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
-                          strlen(program2), (const GLubyte *) program2);
-}
-
-
-/**
- * One-time init for drawing depth pixels.
- */
-static void
-init_draw_depth_pixels(struct gl_context *ctx)
-{
-   static const char *program =
-      "!!ARBfp1.0\n"
-      "PARAM color = program.local[0]; \n"
-      "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
-      "MOV result.color, color; \n"
-      "END \n";
-   char program2[200];
-   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   const char *texTarget;
-
-   assert(drawpix->DepthFP == 0);
-
-   /* replace %s with "RECT" or "2D" */
-   assert(strlen(program) + 4 < sizeof(program2));
-   if (tex->Target == GL_TEXTURE_RECTANGLE)
-      texTarget = "RECT";
-   else
-      texTarget = "2D";
-   _mesa_snprintf(program2, sizeof(program2), program, texTarget);
-
-   _mesa_GenPrograms(1, &drawpix->DepthFP);
-   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
-   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
-                          strlen(program2), (const GLubyte *) program2);
-}
-
-
-/**
- * Meta implementation of ctx->Driver.DrawPixels() in terms
- * of texture mapping and polygon rendering.
- */
-void
-_mesa_meta_DrawPixels(struct gl_context *ctx,
-                      GLint x, GLint y, GLsizei width, GLsizei height,
-                      GLenum format, GLenum type,
-                      const struct gl_pixelstore_attrib *unpack,
-                      const GLvoid *pixels)
-{
-   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
-   struct temp_texture *tex = get_temp_texture(ctx);
-   const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
-   const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
-   struct vertex {
-      GLfloat x, y, z, s, t;
-   };
-   struct vertex verts[4];
-   GLenum texIntFormat;
-   GLboolean fallback, newTex;
-   GLbitfield metaExtraSave = 0x0;
-   GLuint vbo;
-
-   /*
-    * Determine if we can do the glDrawPixels with texture mapping.
-    */
-   fallback = GL_FALSE;
-   if (ctx->_ImageTransferState ||
-       ctx->Fog.Enabled) {
-      fallback = GL_TRUE;
-   }
-
-   if (_mesa_is_color_format(format)) {
-      /* use more compact format when possible */
-      /* XXX disable special case for GL_LUMINANCE for now to work around
-       * apparent i965 driver bug (see bug #23670).
-       */
-      if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
-         texIntFormat = format;
-      else
-         texIntFormat = GL_RGBA;
-   }
-   else if (_mesa_is_stencil_format(format)) {
-      if (ctx->Extensions.ARB_fragment_program &&
-          ctx->Pixel.IndexShift == 0 &&
-          ctx->Pixel.IndexOffset == 0 &&
-          type == GL_UNSIGNED_BYTE) {
-         /* We'll store stencil as alpha.  This only works for GLubyte
-          * image data because of how incoming values are mapped to alpha
-          * in [0,1].
-          */
-         texIntFormat = GL_ALPHA;
-         metaExtraSave = (META_COLOR_MASK |
-                          META_DEPTH_TEST |
-                          META_SHADER |
-                          META_STENCIL_TEST);
-      }
-      else {
-         fallback = GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depth_format(format)) {
-      if (ctx->Extensions.ARB_depth_texture &&
-          ctx->Extensions.ARB_fragment_program) {
-         texIntFormat = GL_DEPTH_COMPONENT;
-         metaExtraSave = (META_SHADER);
-      }
-      else {
-         fallback = GL_TRUE;
-      }
-   }
-   else {
-      fallback = GL_TRUE;
-   }
-
-   if (fallback) {
-      _swrast_DrawPixels(ctx, x, y, width, height,
-                         format, type, unpack, pixels);
-      return;
-   }
-
-   /*
-    * Check image size against max texture size, draw as tiles if needed.
-    */
-   if (width > tex->MaxSize || height > tex->MaxSize) {
-      tiled_draw_pixels(ctx, tex->MaxSize, x, y, width, height,
-                        format, type, unpack, pixels);
-      return;
-   }
-
-   /* Most GL state applies to glDrawPixels (like blending, stencil, etc),
-    * but a there's a few things we need to override:
-    */
-   _mesa_meta_begin(ctx, (META_RASTERIZATION |
-                          META_SHADER |
-                          META_TEXTURE |
-                          META_TRANSFORM |
-                          META_VERTEX |
-                          META_VIEWPORT |
-                          metaExtraSave));
-
-   newTex = alloc_texture(tex, width, height, texIntFormat);
-
-   /* vertex positions, texcoords (after texture allocation!) */
-   {
-      const GLfloat x0 = (GLfloat) x;
-      const GLfloat y0 = (GLfloat) y;
-      const GLfloat x1 = x + width * ctx->Pixel.ZoomX;
-      const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
-      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
-
-      verts[0].x = x0;
-      verts[0].y = y0;
-      verts[0].z = z;
-      verts[0].s = 0.0F;
-      verts[0].t = 0.0F;
-      verts[1].x = x1;
-      verts[1].y = y0;
-      verts[1].z = z;
-      verts[1].s = tex->Sright;
-      verts[1].t = 0.0F;
-      verts[2].x = x1;
-      verts[2].y = y1;
-      verts[2].z = z;
-      verts[2].s = tex->Sright;
-      verts[2].t = tex->Ttop;
-      verts[3].x = x0;
-      verts[3].y = y1;
-      verts[3].z = z;
-      verts[3].s = 0.0F;
-      verts[3].t = tex->Ttop;
-   }
-
-   if (drawpix->ArrayObj == 0) {
-      /* one-time setup: create vertex array object */
-      _mesa_GenVertexArrays(1, &drawpix->ArrayObj);
-   }
-   _mesa_BindVertexArray(drawpix->ArrayObj);
-
-   /* create vertex array buffer */
-   _mesa_GenBuffersARB(1, &vbo);
-   _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
-   _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
-                       verts, GL_DYNAMIC_DRAW_ARB);
-
-   /* setup vertex arrays */
-   _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-   _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
-   _mesa_EnableClientState(GL_VERTEX_ARRAY);
-   _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
-
-   /* set given unpack params */
-   ctx->Unpack = *unpack;
-
-   _mesa_set_enable(ctx, tex->Target, GL_TRUE);
-
-   if (_mesa_is_stencil_format(format)) {
-      /* Drawing stencil */
-      GLint bit;
-
-      if (!drawpix->StencilFP)
-         init_draw_stencil_pixels(ctx);
-
-      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
-                            GL_ALPHA, type, pixels);
-
-      _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-
-      _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
-
-      /* set all stencil bits to 0 */
-      _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
-      _mesa_StencilFunc(GL_ALWAYS, 0, 255);
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-  
-      /* set stencil bits to 1 where needed */
-      _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-
-      _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
-      _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
-
-      for (bit = 0; bit < ctx->DrawBuffer->Visual.stencilBits; bit++) {
-         const GLuint mask = 1 << bit;
-         if (mask & origStencilMask) {
-            _mesa_StencilFunc(GL_ALWAYS, mask, mask);
-            _mesa_StencilMask(mask);
-
-            _mesa_ProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0,
-                                             255.0 / mask, 0.5, 0.0, 0.0);
-
-            _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-         }
-      }
-   }
-   else if (_mesa_is_depth_format(format)) {
-      /* Drawing depth */
-      if (!drawpix->DepthFP)
-         init_draw_depth_pixels(ctx);
-
-      _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
-      _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
-
-      /* polygon color = current raster color */
-      _mesa_ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0,
-                                        ctx->Current.RasterColor);
-
-      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
-                            format, type, pixels);
-
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-   }
-   else {
-      /* Drawing RGBA */
-      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
-                            format, type, pixels);
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-   }
-
-   _mesa_set_enable(ctx, tex->Target, GL_FALSE);
-
-   _mesa_DeleteBuffersARB(1, &vbo);
-
-   /* restore unpack params */
-   ctx->Unpack = unpackSave;
-
-   _mesa_meta_end(ctx);
-}
-
-static GLboolean
-alpha_test_raster_color(struct gl_context *ctx)
-{
-   GLfloat alpha = ctx->Current.RasterColor[ACOMP];
-   GLfloat ref = ctx->Color.AlphaRef;
-
-   switch (ctx->Color.AlphaFunc) {
-      case GL_NEVER:
-	 return GL_FALSE;
-      case GL_LESS:
-	 return alpha < ref;
-      case GL_EQUAL:
-	 return alpha == ref;
-      case GL_LEQUAL:
-	 return alpha <= ref;
-      case GL_GREATER:
-	 return alpha > ref;
-      case GL_NOTEQUAL:
-	 return alpha != ref;
-      case GL_GEQUAL:
-	 return alpha >= ref;
-      case GL_ALWAYS:
-	 return GL_TRUE;
-      default:
-	 assert(0);
-	 return GL_FALSE;
-   }
-}
-
-/**
- * Do glBitmap with a alpha texture quad.  Use the alpha test to cull
- * the 'off' bits.  A bitmap cache as in the gallium/mesa state
- * tracker would improve performance a lot.
- */
-void
-_mesa_meta_Bitmap(struct gl_context *ctx,
-                  GLint x, GLint y, GLsizei width, GLsizei height,
-                  const struct gl_pixelstore_attrib *unpack,
-                  const GLubyte *bitmap1)
-{
-   struct bitmap_state *bitmap = &ctx->Meta->Bitmap;
-   struct temp_texture *tex = get_bitmap_temp_texture(ctx);
-   const GLenum texIntFormat = GL_ALPHA;
-   const struct gl_pixelstore_attrib unpackSave = *unpack;
-   GLubyte fg, bg;
-   struct vertex {
-      GLfloat x, y, z, s, t, r, g, b, a;
-   };
-   struct vertex verts[4];
-   GLboolean newTex;
-   GLubyte *bitmap8;
-
-   /*
-    * Check if swrast fallback is needed.
-    */
-   if (ctx->_ImageTransferState ||
-       ctx->FragmentProgram._Enabled ||
-       ctx->Fog.Enabled ||
-       ctx->Texture._EnabledUnits ||
-       width > tex->MaxSize ||
-       height > tex->MaxSize) {
-      _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);
-      return;
-   }
-
-   if (ctx->Color.AlphaEnabled && !alpha_test_raster_color(ctx))
-      return;
-
-   /* Most GL state applies to glBitmap (like blending, stencil, etc),
-    * but a there's a few things we need to override:
-    */
-   _mesa_meta_begin(ctx, (META_ALPHA_TEST |
-                          META_PIXEL_STORE |
-                          META_RASTERIZATION |
-                          META_SHADER |
-                          META_TEXTURE |
-                          META_TRANSFORM |
-                          META_VERTEX |
-                          META_VIEWPORT));
-
-   if (bitmap->ArrayObj == 0) {
-      /* one-time setup */
-
-      /* create vertex array object */
-      _mesa_GenVertexArraysAPPLE(1, &bitmap->ArrayObj);
-      _mesa_BindVertexArrayAPPLE(bitmap->ArrayObj);
-
-      /* create vertex array buffer */
-      _mesa_GenBuffersARB(1, &bitmap->VBO);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
-      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
-                          NULL, GL_DYNAMIC_DRAW_ARB);
-
-      /* setup vertex arrays */
-      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
-      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
-      _mesa_EnableClientState(GL_VERTEX_ARRAY);
-      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
-      _mesa_EnableClientState(GL_COLOR_ARRAY);
-   }
-   else {
-      _mesa_BindVertexArray(bitmap->ArrayObj);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
-   }
-
-   newTex = alloc_texture(tex, width, height, texIntFormat);
-
-   /* vertex positions, texcoords, colors (after texture allocation!) */
-   {
-      const GLfloat x0 = (GLfloat) x;
-      const GLfloat y0 = (GLfloat) y;
-      const GLfloat x1 = (GLfloat) (x + width);
-      const GLfloat y1 = (GLfloat) (y + height);
-      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
-      GLuint i;
-
-      verts[0].x = x0;
-      verts[0].y = y0;
-      verts[0].z = z;
-      verts[0].s = 0.0F;
-      verts[0].t = 0.0F;
-      verts[1].x = x1;
-      verts[1].y = y0;
-      verts[1].z = z;
-      verts[1].s = tex->Sright;
-      verts[1].t = 0.0F;
-      verts[2].x = x1;
-      verts[2].y = y1;
-      verts[2].z = z;
-      verts[2].s = tex->Sright;
-      verts[2].t = tex->Ttop;
-      verts[3].x = x0;
-      verts[3].y = y1;
-      verts[3].z = z;
-      verts[3].s = 0.0F;
-      verts[3].t = tex->Ttop;
-
-      for (i = 0; i < 4; i++) {
-         verts[i].r = ctx->Current.RasterColor[0];
-         verts[i].g = ctx->Current.RasterColor[1];
-         verts[i].b = ctx->Current.RasterColor[2];
-         verts[i].a = ctx->Current.RasterColor[3];
-      }
-
-      /* upload new vertex data */
-      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
-   }
-
-   /* choose different foreground/background alpha values */
-   CLAMPED_FLOAT_TO_UBYTE(fg, ctx->Current.RasterColor[ACOMP]);
-   bg = (fg > 127 ? 0 : 255);
-
-   bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);
-   if (!bitmap1) {
-      _mesa_meta_end(ctx);
-      return;
-   }
-
-   bitmap8 = (GLubyte *) malloc(width * height);
-   if (bitmap8) {
-      memset(bitmap8, bg, width * height);
-      _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
-                          bitmap8, width, fg);
-
-      _mesa_set_enable(ctx, tex->Target, GL_TRUE);
-
-      _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);
-      _mesa_AlphaFunc(GL_NOTEQUAL, UBYTE_TO_FLOAT(bg));
-
-      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
-                            GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);
-
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-      _mesa_set_enable(ctx, tex->Target, GL_FALSE);
-
-      free(bitmap8);
-   }
-
-   _mesa_unmap_pbo_source(ctx, &unpackSave);
-
-   _mesa_meta_end(ctx);
-}
-
-
-/**
- * Check if the call to _mesa_meta_GenerateMipmap() will require a
- * software fallback.  The fallback path will require that the texture
- * images are mapped.
- * \return GL_TRUE if a fallback is needed, GL_FALSE otherwise
- */
-GLboolean
-_mesa_meta_check_generate_mipmap_fallback(struct gl_context *ctx, GLenum target,
-                                          struct gl_texture_object *texObj)
-{
-   const GLuint fboSave = ctx->DrawBuffer->Name;
-   struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
-   struct gl_texture_image *baseImage;
-   GLuint srcLevel;
-   GLenum status;
-
-   /* check for fallbacks */
-   if (!ctx->Extensions.EXT_framebuffer_object ||
-       target == GL_TEXTURE_3D) {
-      return GL_TRUE;
-   }
-
-   srcLevel = texObj->BaseLevel;
-   baseImage = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
-   if (!baseImage || _mesa_is_format_compressed(baseImage->TexFormat)) {
-      return GL_TRUE;
-   }
-
-   /*
-    * Test that we can actually render in the texture's format.
-    */
-   if (!mipmap->FBO)
-      _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
-   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
-
-   if (target == GL_TEXTURE_1D) {
-      _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
-                                    GL_COLOR_ATTACHMENT0_EXT,
-                                    target, texObj->Name, srcLevel);
-   }
-#if 0
-   /* other work is needed to enable 3D mipmap generation */
-   else if (target == GL_TEXTURE_3D) {
-      GLint zoffset = 0;
-      _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,
-                                    GL_COLOR_ATTACHMENT0_EXT,
-                                    target, texObj->Name, srcLevel, zoffset);
-   }
-#endif
-   else {
-      /* 2D / cube */
-      _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
-                                    GL_COLOR_ATTACHMENT0_EXT,
-                                    target, texObj->Name, srcLevel);
-   }
-
-   status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-
-   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
-
-   if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Called via ctx->Driver.GenerateMipmap()
- * Note: texture borders and 3D texture support not yet complete.
- */
-void
-_mesa_meta_GenerateMipmap(struct gl_context *ctx, GLenum target,
-                          struct gl_texture_object *texObj)
-{
-   struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
-   struct vertex {
-      GLfloat x, y, s, t, r;
-   };
-   struct vertex verts[4];
-   const GLuint baseLevel = texObj->BaseLevel;
-   const GLuint maxLevel = texObj->MaxLevel;
-   const GLenum minFilterSave = texObj->MinFilter;
-   const GLenum magFilterSave = texObj->MagFilter;
-   const GLint maxLevelSave = texObj->MaxLevel;
-   const GLboolean genMipmapSave = texObj->GenerateMipmap;
-   const GLenum wrapSSave = texObj->WrapS;
-   const GLenum wrapTSave = texObj->WrapT;
-   const GLenum wrapRSave = texObj->WrapR;
-   const GLuint fboSave = ctx->DrawBuffer->Name;
-   const GLuint original_active_unit = ctx->Texture.CurrentUnit;
-   GLenum faceTarget;
-   GLuint dstLevel;
-   GLuint border = 0;
-
-   if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) {
-      _mesa_generate_mipmap(ctx, target, texObj);
-      return;
-   }
-
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) {
-      faceTarget = target;
-      target = GL_TEXTURE_CUBE_MAP;
-   }
-   else {
-      faceTarget = target;
-   }
-
-   _mesa_meta_begin(ctx, META_ALL);
-
-   if (original_active_unit != 0)
-      _mesa_BindTexture(target, texObj->Name);
-
-   if (mipmap->ArrayObj == 0) {
-      /* one-time setup */
-
-      /* create vertex array object */
-      _mesa_GenVertexArraysAPPLE(1, &mipmap->ArrayObj);
-      _mesa_BindVertexArrayAPPLE(mipmap->ArrayObj);
-
-      /* create vertex array buffer */
-      _mesa_GenBuffersARB(1, &mipmap->VBO);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
-      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
-                          NULL, GL_DYNAMIC_DRAW_ARB);
-
-      /* setup vertex arrays */
-      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
-      _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
-      _mesa_EnableClientState(GL_VERTEX_ARRAY);
-      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
-   }
-   else {
-      _mesa_BindVertexArray(mipmap->ArrayObj);
-      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
-   }
-
-   if (!mipmap->FBO) {
-      _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
-   }
-   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
-
-   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-   _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-
-   _mesa_set_enable(ctx, target, GL_TRUE);
-
-   /* setup texcoords once (XXX what about border?) */
-   switch (faceTarget) {
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-      verts[0].s = 0.0F;
-      verts[0].t = 0.0F;
-      verts[0].r = 0.0F;
-      verts[1].s = 1.0F;
-      verts[1].t = 0.0F;
-      verts[1].r = 0.0F;
-      verts[2].s = 1.0F;
-      verts[2].t = 1.0F;
-      verts[2].r = 0.0F;
-      verts[3].s = 0.0F;
-      verts[3].t = 1.0F;
-      verts[3].r = 0.0F;
-      break;
-   case GL_TEXTURE_3D:
-      abort();
-      break;
-   default:
-      /* cube face */
-      {
-         static const GLfloat st[4][2] = {
-            {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}
-         };
-         GLuint i;
-
-         /* loop over quad verts */
-         for (i = 0; i < 4; i++) {
-            /* Compute sc = +/-scale and tc = +/-scale.
-             * Not +/-1 to avoid cube face selection ambiguity near the edges,
-             * though that can still sometimes happen with this scale factor...
-             */
-            const GLfloat scale = 0.9999f;
-            const GLfloat sc = (2.0f * st[i][0] - 1.0f) * scale;
-            const GLfloat tc = (2.0f * st[i][1] - 1.0f) * scale;
-
-            switch (faceTarget) {
-            case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-               verts[i].s = 1.0f;
-               verts[i].t = -tc;
-               verts[i].r = -sc;
-               break;
-            case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-               verts[i].s = -1.0f;
-               verts[i].t = -tc;
-               verts[i].r = sc;
-               break;
-            case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-               verts[i].s = sc;
-               verts[i].t = 1.0f;
-               verts[i].r = tc;
-               break;
-            case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-               verts[i].s = sc;
-               verts[i].t = -1.0f;
-               verts[i].r = -tc;
-               break;
-            case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-               verts[i].s = sc;
-               verts[i].t = -tc;
-               verts[i].r = 1.0f;
-               break;
-            case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-               verts[i].s = -sc;
-               verts[i].t = -tc;
-               verts[i].r = -1.0f;
-               break;
-            default:
-               assert(0);
-            }
-         }
-      }
-   }
-
-   _mesa_set_enable(ctx, target, GL_TRUE);
-
-   /* setup vertex positions */
-   {
-      verts[0].x = 0.0F;
-      verts[0].y = 0.0F;
-      verts[1].x = 1.0F;
-      verts[1].y = 0.0F;
-      verts[2].x = 1.0F;
-      verts[2].y = 1.0F;
-      verts[3].x = 0.0F;
-      verts[3].y = 1.0F;
-      
-      /* upload new vertex data */
-      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
-   }
-
-   /* setup projection matrix */
-   _mesa_MatrixMode(GL_PROJECTION);
-   _mesa_LoadIdentity();
-   _mesa_Ortho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
-
-   /* texture is already locked, unlock now */
-   _mesa_unlock_texture(ctx, texObj);
-
-   for (dstLevel = baseLevel + 1; dstLevel <= maxLevel; dstLevel++) {
-      const struct gl_texture_image *srcImage;
-      const GLuint srcLevel = dstLevel - 1;
-      GLsizei srcWidth, srcHeight, srcDepth;
-      GLsizei dstWidth, dstHeight, dstDepth;
-      GLenum status;
-
-      srcImage = _mesa_select_tex_image(ctx, texObj, faceTarget, srcLevel);
-      assert(srcImage->Border == 0); /* XXX we can fix this */
-
-      /* src size w/out border */
-      srcWidth = srcImage->Width - 2 * border;
-      srcHeight = srcImage->Height - 2 * border;
-      srcDepth = srcImage->Depth - 2 * border;
-
-      /* new dst size w/ border */
-      dstWidth = MAX2(1, srcWidth / 2) + 2 * border;
-      dstHeight = MAX2(1, srcHeight / 2) + 2 * border;
-      dstDepth = MAX2(1, srcDepth / 2) + 2 * border;
-
-      if (dstWidth == srcImage->Width &&
-          dstHeight == srcImage->Height &&
-          dstDepth == srcImage->Depth) {
-         /* all done */
-         break;
-      }
-
-      /* Set MaxLevel large enough to hold the new level when we allocate it  */
-      _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, dstLevel);
-
-      /* Create empty dest image */
-      if (target == GL_TEXTURE_1D) {
-         _mesa_TexImage1D(target, dstLevel, srcImage->InternalFormat,
-                          dstWidth, border,
-                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-      }
-      else if (target == GL_TEXTURE_3D) {
-         _mesa_TexImage3D(target, dstLevel, srcImage->InternalFormat,
-                          dstWidth, dstHeight, dstDepth, border,
-                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-      }
-      else {
-         /* 2D or cube */
-         _mesa_TexImage2D(faceTarget, dstLevel, srcImage->InternalFormat,
-                          dstWidth, dstHeight, border,
-                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-
-         if (target == GL_TEXTURE_CUBE_MAP) {
-            /* If texturing from a cube, we need to make sure all src faces
-             * have been defined (even if we're not sampling from them.)
-             * Otherwise the texture object will be 'incomplete' and
-             * texturing from it will not be allowed.
-             */
-            GLuint face;
-            for (face = 0; face < 6; face++) {
-               if (!texObj->Image[face][srcLevel] ||
-                   texObj->Image[face][srcLevel]->Width != srcWidth) {
-                  _mesa_TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,
-                                   srcLevel, srcImage->InternalFormat,
-                                   srcWidth, srcHeight, border,
-                                   GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-               }
-            }
-         }
-      }
-
-      /* limit minification to src level */
-      _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);
-
-      /* Set to draw into the current dstLevel */
-      if (target == GL_TEXTURE_1D) {
-         _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
-                                       GL_COLOR_ATTACHMENT0_EXT,
-                                       target,
-                                       texObj->Name,
-                                       dstLevel);
-      }
-      else if (target == GL_TEXTURE_3D) {
-         GLint zoffset = 0; /* XXX unfinished */
-         _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,
-                                       GL_COLOR_ATTACHMENT0_EXT,
-                                       target,
-                                       texObj->Name,
-                                       dstLevel, zoffset);
-      }
-      else {
-         /* 2D / cube */
-         _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
-                                       GL_COLOR_ATTACHMENT0_EXT,
-                                       faceTarget,
-                                       texObj->Name,
-                                       dstLevel);
-      }
-
-      _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
-
-      /* sanity check */
-      status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-      if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         abort();
-         break;
-      }
-
-      assert(dstWidth == ctx->DrawBuffer->Width);
-      assert(dstHeight == ctx->DrawBuffer->Height);
-
-      /* setup viewport */
-      _mesa_set_viewport(ctx, 0, 0, dstWidth, dstHeight);
-
-      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
-   }
-
-   _mesa_lock_texture(ctx, texObj); /* relock */
-
-   _mesa_meta_end(ctx);
-
-   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
-   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
-   _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
-   _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, genMipmapSave);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
-   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, wrapRSave);
-
-   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
-}
-
-
-/**
- * Determine the GL data type to use for the temporary image read with
- * ReadPixels() and passed to Tex[Sub]Image().
- */
-static GLenum
-get_temp_image_type(struct gl_context *ctx, GLenum baseFormat)
-{
-   switch (baseFormat) {
-   case GL_RGBA:
-   case GL_RGB:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-      if (ctx->DrawBuffer->Visual.redBits <= 8)
-         return GL_UNSIGNED_BYTE;
-      else if (ctx->DrawBuffer->Visual.redBits <= 8)
-         return GL_UNSIGNED_SHORT;
-      else
-         return GL_FLOAT;
-   case GL_DEPTH_COMPONENT:
-      return GL_UNSIGNED_INT;
-   case GL_DEPTH_STENCIL:
-      return GL_UNSIGNED_INT_24_8;
-   default:
-      _mesa_problem(ctx, "Unexpected format in get_temp_image_type()");
-      return 0;
-   }
-}
-
-
-/**
- * Helper for _mesa_meta_CopyTexImage1/2D() functions.
- * Have to be careful with locking and meta state for pixel transfer.
- */
-static void
-copy_tex_image(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,
-               GLenum internalFormat, GLint x, GLint y,
-               GLsizei width, GLsizei height, GLint border)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLenum format, type;
-   GLint bpp;
-   void *buf;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-
-   /* Choose format/type for temporary image buffer */
-   format = _mesa_base_tex_format(ctx, internalFormat);
-   type = get_temp_image_type(ctx, format);
-   bpp = _mesa_bytes_per_pixel(format, type);
-   if (bpp <= 0) {
-      _mesa_problem(ctx, "Bad bpp in meta copy_tex_image()");
-      return;
-   }
-
-   /*
-    * Alloc image buffer (XXX could use a PBO)
-    */
-   buf = malloc(width * height * bpp);
-   if (!buf) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
-      return;
-   }
-
-   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */
-
-   /*
-    * Read image from framebuffer (disable pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
-   ctx->Driver.ReadPixels(ctx, x, y, width, height,
-			  format, type, &ctx->Pack, buf);
-   _mesa_meta_end(ctx);
-
-   if (texImage->Data) {
-      ctx->Driver.FreeTexImageData(ctx, texImage);
-   }
-
-   /* The texture's format was already chosen in _mesa_CopyTexImage() */
-   ASSERT(texImage->TexFormat != MESA_FORMAT_NONE);
-
-   /*
-    * Store texture data (with pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE);
-
-   _mesa_update_state(ctx); /* to update pixel transfer state */
-
-   if (target == GL_TEXTURE_1D) {
-      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                             width, border, format, type,
-                             buf, &ctx->Unpack, texObj, texImage);
-   }
-   else {
-      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                             width, height, border, format, type,
-                             buf, &ctx->Unpack, texObj, texImage);
-   }
-   _mesa_meta_end(ctx);
-
-   _mesa_lock_texture(ctx, texObj); /* re-lock */
-
-   free(buf);
-}
-
-
-void
-_mesa_meta_CopyTexImage1D(struct gl_context *ctx, GLenum target, GLint level,
-                          GLenum internalFormat, GLint x, GLint y,
-                          GLsizei width, GLint border)
-{
-   copy_tex_image(ctx, 1, target, level, internalFormat, x, y,
-                  width, 1, border);
-}
-
-
-void
-_mesa_meta_CopyTexImage2D(struct gl_context *ctx, GLenum target, GLint level,
-                          GLenum internalFormat, GLint x, GLint y,
-                          GLsizei width, GLsizei height, GLint border)
-{
-   copy_tex_image(ctx, 2, target, level, internalFormat, x, y,
-                  width, height, border);
-}
-
-
-
-/**
- * Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.
- * Have to be careful with locking and meta state for pixel transfer.
- */
-static void
-copy_tex_sub_image(struct gl_context *ctx,
-                   GLuint dims, GLenum target, GLint level,
-                   GLint xoffset, GLint yoffset, GLint zoffset,
-                   GLint x, GLint y,
-                   GLsizei width, GLsizei height)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLenum format, type;
-   GLint bpp;
-   void *buf;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-   /* Choose format/type for temporary image buffer */
-   format = _mesa_get_format_base_format(texImage->TexFormat);
-   type = get_temp_image_type(ctx, format);
-   bpp = _mesa_bytes_per_pixel(format, type);
-   if (bpp <= 0) {
-      _mesa_problem(ctx, "Bad bpp in meta copy_tex_sub_image()");
-      return;
-   }
-
-   /*
-    * Alloc image buffer (XXX could use a PBO)
-    */
-   buf = malloc(width * height * bpp);
-   if (!buf) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage%uD", dims);
-      return;
-   }
-
-   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */
-
-   /*
-    * Read image from framebuffer (disable pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
-   ctx->Driver.ReadPixels(ctx, x, y, width, height,
-			  format, type, &ctx->Pack, buf);
-   _mesa_meta_end(ctx);
-
-   _mesa_update_state(ctx); /* to update pixel transfer state */
-
-   /*
-    * Store texture data (with pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE);
-   if (target == GL_TEXTURE_1D) {
-      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset,
-                                width, format, type, buf,
-                                &ctx->Unpack, texObj, texImage);
-   }
-   else if (target == GL_TEXTURE_3D) {
-      ctx->Driver.TexSubImage3D(ctx, target, level, xoffset, yoffset, zoffset,
-                                width, height, 1, format, type, buf,
-                                &ctx->Unpack, texObj, texImage);
-   }
-   else {
-      ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,
-                                width, height, format, type, buf,
-                                &ctx->Unpack, texObj, texImage);
-   }
-   _mesa_meta_end(ctx);
-
-   _mesa_lock_texture(ctx, texObj); /* re-lock */
-
-   free(buf);
-}
-
-
-void
-_mesa_meta_CopyTexSubImage1D(struct gl_context *ctx, GLenum target, GLint level,
-                             GLint xoffset,
-                             GLint x, GLint y, GLsizei width)
-{
-   copy_tex_sub_image(ctx, 1, target, level, xoffset, 0, 0,
-                      x, y, width, 1);
-}
-
-
-void
-_mesa_meta_CopyTexSubImage2D(struct gl_context *ctx, GLenum target, GLint level,
-                             GLint xoffset, GLint yoffset,
-                             GLint x, GLint y,
-                             GLsizei width, GLsizei height)
-{
-   copy_tex_sub_image(ctx, 2, target, level, xoffset, yoffset, 0,
-                      x, y, width, height);
-}
-
-
-void
-_mesa_meta_CopyTexSubImage3D(struct gl_context *ctx, GLenum target, GLint level,
-                             GLint xoffset, GLint yoffset, GLint zoffset,
-                             GLint x, GLint y,
-                             GLsizei width, GLsizei height)
-{
-   copy_tex_sub_image(ctx, 3, target, level, xoffset, yoffset, zoffset,
-                      x, y, width, height);
-}
-
-
-void
-_mesa_meta_CopyColorTable(struct gl_context *ctx,
-                          GLenum target, GLenum internalformat,
-                          GLint x, GLint y, GLsizei width)
-{
-   GLfloat *buf;
-
-   buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
-   if (!buf) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorTable");
-      return;
-   }
-
-   /*
-    * Read image from framebuffer (disable pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
-   ctx->Driver.ReadPixels(ctx, x, y, width, 1,
-                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
-
-   _mesa_ColorTable(target, internalformat, width, GL_RGBA, GL_FLOAT, buf);
-
-   _mesa_meta_end(ctx);
-
-   free(buf);
-}
-
-
-void
-_mesa_meta_CopyColorSubTable(struct gl_context *ctx,GLenum target, GLsizei start,
-                             GLint x, GLint y, GLsizei width)
-{
-   GLfloat *buf;
-
-   buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
-   if (!buf) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorSubTable");
-      return;
-   }
-
-   /*
-    * Read image from framebuffer (disable pixel transfer ops)
-    */
-   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);
-   ctx->Driver.ReadPixels(ctx, x, y, width, 1,
-                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
-
-   _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_FLOAT, buf);
-
-   _mesa_meta_end(ctx);
-
-   free(buf);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * Meta operations.  Some GL operations can be expressed in terms of

+ * other GL operations.  For example, glBlitFramebuffer() can be done

+ * with texture mapping and glClear() can be done with polygon rendering.

+ *

+ * \author Brian Paul

+ */

+

+

+#include "main/glheader.h"

+#include "main/mtypes.h"

+#include "main/imports.h"

+#include "main/arbprogram.h"

+#include "main/arrayobj.h"

+#include "main/blend.h"

+#include "main/bufferobj.h"

+#include "main/buffers.h"

+#include "main/colortab.h"

+#include "main/depth.h"

+#include "main/enable.h"

+#include "main/fbobject.h"

+#include "main/formats.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/matrix.h"

+#include "main/mipmap.h"

+#include "main/pbo.h"

+#include "main/polygon.h"

+#include "main/readpix.h"

+#include "main/scissor.h"

+#include "main/shaderapi.h"

+#include "main/shaderobj.h"

+#include "main/state.h"

+#include "main/stencil.h"

+#include "main/texobj.h"

+#include "main/texenv.h"

+#include "main/teximage.h"

+#include "main/texparam.h"

+#include "main/texstate.h"

+#include "main/varray.h"

+#include "main/viewport.h"

+#include "program/program.h"

+#include "swrast/swrast.h"

+#include "drivers/common/meta.h"

+

+

+/** Return offset in bytes of the field within a vertex struct */

+#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))

+

+

+/**

+ * Flags passed to _mesa_meta_begin().

+ */

+/*@{*/

+#define META_ALL              ~0x0

+#define META_ALPHA_TEST        0x1

+#define META_BLEND             0x2  /**< includes logicop */

+#define META_COLOR_MASK        0x4

+#define META_DEPTH_TEST        0x8

+#define META_FOG              0x10

+#define META_PIXEL_STORE      0x20

+#define META_PIXEL_TRANSFER   0x40

+#define META_RASTERIZATION    0x80

+#define META_SCISSOR         0x100

+#define META_SHADER          0x200

+#define META_STENCIL_TEST    0x400

+#define META_TRANSFORM       0x800 /**< modelview, projection, clip planes */

+#define META_TEXTURE        0x1000

+#define META_VERTEX         0x2000

+#define META_VIEWPORT       0x4000

+/*@}*/

+

+

+/**

+ * State which we may save/restore across meta ops.

+ * XXX this may be incomplete...

+ */

+struct save_state

+{

+   GLbitfield SavedState;  /**< bitmask of META_* flags */

+

+   /** META_ALPHA_TEST */

+   GLboolean AlphaEnabled;

+   GLenum AlphaFunc;

+   GLclampf AlphaRef;

+

+   /** META_BLEND */

+   GLbitfield BlendEnabled;

+   GLboolean ColorLogicOpEnabled;

+

+   /** META_COLOR_MASK */

+   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];

+

+   /** META_DEPTH_TEST */

+   struct gl_depthbuffer_attrib Depth;

+

+   /** META_FOG */

+   GLboolean Fog;

+

+   /** META_PIXEL_STORE */

+   struct gl_pixelstore_attrib Pack, Unpack;

+

+   /** META_PIXEL_TRANSFER */

+   GLfloat RedBias, RedScale;

+   GLfloat GreenBias, GreenScale;

+   GLfloat BlueBias, BlueScale;

+   GLfloat AlphaBias, AlphaScale;

+   GLfloat DepthBias, DepthScale;

+   GLboolean MapColorFlag;

+

+   /** META_RASTERIZATION */

+   GLenum FrontPolygonMode, BackPolygonMode;

+   GLboolean PolygonOffset;

+   GLboolean PolygonSmooth;

+   GLboolean PolygonStipple;

+   GLboolean PolygonCull;

+

+   /** META_SCISSOR */

+   struct gl_scissor_attrib Scissor;

+

+   /** META_SHADER */

+   GLboolean VertexProgramEnabled;

+   struct gl_vertex_program *VertexProgram;

+   GLboolean FragmentProgramEnabled;

+   struct gl_fragment_program *FragmentProgram;

+   struct gl_shader_program *VertexShader;

+   struct gl_shader_program *GeometryShader;

+   struct gl_shader_program *FragmentShader;

+   struct gl_shader_program *ActiveShader;

+

+   /** META_STENCIL_TEST */

+   struct gl_stencil_attrib Stencil;

+

+   /** META_TRANSFORM */

+   GLenum MatrixMode;

+   GLfloat ModelviewMatrix[16];

+   GLfloat ProjectionMatrix[16];

+   GLfloat TextureMatrix[16];

+   GLbitfield ClipPlanesEnabled;

+

+   /** META_TEXTURE */

+   GLuint ActiveUnit;

+   GLuint ClientActiveUnit;

+   /** for unit[0] only */

+   struct gl_texture_object *CurrentTexture[NUM_TEXTURE_TARGETS];

+   /** mask of TEXTURE_2D_BIT, etc */

+   GLbitfield TexEnabled[MAX_TEXTURE_UNITS];

+   GLbitfield TexGenEnabled[MAX_TEXTURE_UNITS];

+   GLuint EnvMode;  /* unit[0] only */

+

+   /** META_VERTEX */

+   struct gl_array_object *ArrayObj;

+   struct gl_buffer_object *ArrayBufferObj;

+

+   /** META_VIEWPORT */

+   GLint ViewportX, ViewportY, ViewportW, ViewportH;

+   GLclampd DepthNear, DepthFar;

+

+   /** Miscellaneous (always disabled) */

+   GLboolean Lighting;

+};

+

+

+/**

+ * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.

+ * This is currently shared by all the meta ops.  But we could create a

+ * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.

+ */

+struct temp_texture

+{

+   GLuint TexObj;

+   GLenum Target;         /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */

+   GLsizei MinSize;       /**< Min texture size to allocate */

+   GLsizei MaxSize;       /**< Max possible texture size */

+   GLboolean NPOT;        /**< Non-power of two size OK? */

+   GLsizei Width, Height; /**< Current texture size */

+   GLenum IntFormat;

+   GLfloat Sright, Ttop;  /**< right, top texcoords */

+};

+

+

+/**

+ * State for glBlitFramebufer()

+ */

+struct blit_state

+{

+   GLuint ArrayObj;

+   GLuint VBO;

+   GLuint DepthFP;

+};

+

+

+/**

+ * State for glClear()

+ */

+struct clear_state

+{

+   GLuint ArrayObj;

+   GLuint VBO;

+};

+

+

+/**

+ * State for glCopyPixels()

+ */

+struct copypix_state

+{

+   GLuint ArrayObj;

+   GLuint VBO;

+};

+

+

+/**

+ * State for glDrawPixels()

+ */

+struct drawpix_state

+{

+   GLuint ArrayObj;

+

+   GLuint StencilFP;  /**< Fragment program for drawing stencil images */

+   GLuint DepthFP;  /**< Fragment program for drawing depth images */

+};

+

+

+/**

+ * State for glBitmap()

+ */

+struct bitmap_state

+{

+   GLuint ArrayObj;

+   GLuint VBO;

+   struct temp_texture Tex;  /**< separate texture from other meta ops */

+};

+

+

+/**

+ * State for _mesa_meta_generate_mipmap()

+ */

+struct gen_mipmap_state

+{

+   GLuint ArrayObj;

+   GLuint VBO;

+   GLuint FBO;

+};

+

+#define MAX_META_OPS_DEPTH      2

+/**

+ * All per-context meta state.

+ */

+struct gl_meta_state

+{

+   /** Stack of state saved during meta-ops */

+   struct save_state Save[MAX_META_OPS_DEPTH];

+   /** Save stack depth */

+   GLuint SaveStackDepth;

+

+   struct temp_texture TempTex;

+

+   struct blit_state Blit;    /**< For _mesa_meta_BlitFramebuffer() */

+   struct clear_state Clear;  /**< For _mesa_meta_Clear() */

+   struct copypix_state CopyPix;  /**< For _mesa_meta_CopyPixels() */

+   struct drawpix_state DrawPix;  /**< For _mesa_meta_DrawPixels() */

+   struct bitmap_state Bitmap;    /**< For _mesa_meta_Bitmap() */

+   struct gen_mipmap_state Mipmap;    /**< For _mesa_meta_GenerateMipmap() */

+};

+

+

+/**

+ * Initialize meta-ops for a context.

+ * To be called once during context creation.

+ */

+void

+_mesa_meta_init(struct gl_context *ctx)

+{

+   ASSERT(!ctx->Meta);

+

+   ctx->Meta = CALLOC_STRUCT(gl_meta_state);

+}

+

+

+/**

+ * Free context meta-op state.

+ * To be called once during context destruction.

+ */

+void

+_mesa_meta_free(struct gl_context *ctx)

+{

+   /* Note: Any textures, VBOs, etc, that we allocate should get

+    * freed by the normal context destruction code.  But this would be

+    * the place to free other meta data someday.

+    */

+   free(ctx->Meta);

+   ctx->Meta = NULL;

+}

+

+

+/**

+ * Enter meta state.  This is like a light-weight version of glPushAttrib

+ * but it also resets most GL state back to default values.

+ *

+ * \param state  bitmask of META_* flags indicating which attribute groups

+ *               to save and reset to their defaults

+ */

+static void

+_mesa_meta_begin(struct gl_context *ctx, GLbitfield state)

+{

+   struct save_state *save;

+

+   /* hope MAX_META_OPS_DEPTH is large enough */

+   assert(ctx->Meta->SaveStackDepth < MAX_META_OPS_DEPTH);

+

+   save = &ctx->Meta->Save[ctx->Meta->SaveStackDepth++];

+   memset(save, 0, sizeof(*save));

+   save->SavedState = state;

+

+   if (state & META_ALPHA_TEST) {

+      save->AlphaEnabled = ctx->Color.AlphaEnabled;

+      save->AlphaFunc = ctx->Color.AlphaFunc;

+      save->AlphaRef = ctx->Color.AlphaRef;

+      if (ctx->Color.AlphaEnabled)

+         _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);

+   }

+

+   if (state & META_BLEND) {

+      save->BlendEnabled = ctx->Color.BlendEnabled;

+      if (ctx->Color.BlendEnabled) {

+         if (ctx->Extensions.EXT_draw_buffers2) {

+            GLuint i;

+            for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+               _mesa_set_enablei(ctx, GL_BLEND, i, GL_FALSE);

+            }

+         }

+         else {

+            _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);

+         }

+      }

+      save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;

+      if (ctx->Color.ColorLogicOpEnabled)

+         _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);

+   }

+

+   if (state & META_COLOR_MASK) {

+      memcpy(save->ColorMask, ctx->Color.ColorMask,

+             sizeof(ctx->Color.ColorMask));

+      if (!ctx->Color.ColorMask[0][0] ||

+          !ctx->Color.ColorMask[0][1] ||

+          !ctx->Color.ColorMask[0][2] ||

+          !ctx->Color.ColorMask[0][3])

+         _mesa_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

+   }

+

+   if (state & META_DEPTH_TEST) {

+      save->Depth = ctx->Depth; /* struct copy */

+      if (ctx->Depth.Test)

+         _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);

+   }

+

+   if (state & META_FOG) {

+      save->Fog = ctx->Fog.Enabled;

+      if (ctx->Fog.Enabled)

+         _mesa_set_enable(ctx, GL_FOG, GL_FALSE);

+   }

+

+   if (state & META_PIXEL_STORE) {

+      save->Pack = ctx->Pack;

+      save->Unpack = ctx->Unpack;

+      ctx->Pack = ctx->DefaultPacking;

+      ctx->Unpack = ctx->DefaultPacking;

+   }

+

+   if (state & META_PIXEL_TRANSFER) {

+      save->RedScale = ctx->Pixel.RedScale;

+      save->RedBias = ctx->Pixel.RedBias;

+      save->GreenScale = ctx->Pixel.GreenScale;

+      save->GreenBias = ctx->Pixel.GreenBias;

+      save->BlueScale = ctx->Pixel.BlueScale;

+      save->BlueBias = ctx->Pixel.BlueBias;

+      save->AlphaScale = ctx->Pixel.AlphaScale;

+      save->AlphaBias = ctx->Pixel.AlphaBias;

+      save->MapColorFlag = ctx->Pixel.MapColorFlag;

+      ctx->Pixel.RedScale = 1.0F;

+      ctx->Pixel.RedBias = 0.0F;

+      ctx->Pixel.GreenScale = 1.0F;

+      ctx->Pixel.GreenBias = 0.0F;

+      ctx->Pixel.BlueScale = 1.0F;

+      ctx->Pixel.BlueBias = 0.0F;

+      ctx->Pixel.AlphaScale = 1.0F;

+      ctx->Pixel.AlphaBias = 0.0F;

+      ctx->Pixel.MapColorFlag = GL_FALSE;

+      /* XXX more state */

+      ctx->NewState |=_NEW_PIXEL;

+   }

+

+   if (state & META_RASTERIZATION) {

+      save->FrontPolygonMode = ctx->Polygon.FrontMode;

+      save->BackPolygonMode = ctx->Polygon.BackMode;

+      save->PolygonOffset = ctx->Polygon.OffsetFill;

+      save->PolygonSmooth = ctx->Polygon.SmoothFlag;

+      save->PolygonStipple = ctx->Polygon.StippleFlag;

+      save->PolygonCull = ctx->Polygon.CullFlag;

+      _mesa_PolygonMode(GL_FRONT_AND_BACK, GL_FILL);

+      _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, GL_FALSE);

+      _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, GL_FALSE);

+      _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, GL_FALSE);

+      _mesa_set_enable(ctx, GL_CULL_FACE, GL_FALSE);

+   }

+

+   if (state & META_SCISSOR) {

+      save->Scissor = ctx->Scissor; /* struct copy */

+      _mesa_set_enable(ctx, GL_SCISSOR_TEST, GL_FALSE);

+   }

+

+   if (state & META_SHADER) {

+      if (ctx->Extensions.ARB_vertex_program) {

+         save->VertexProgramEnabled = ctx->VertexProgram.Enabled;

+         _mesa_reference_vertprog(ctx, &save->VertexProgram,

+				  ctx->VertexProgram.Current);

+         _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB, GL_FALSE);

+      }

+

+      if (ctx->Extensions.ARB_fragment_program) {

+         save->FragmentProgramEnabled = ctx->FragmentProgram.Enabled;

+         _mesa_reference_fragprog(ctx, &save->FragmentProgram,

+				  ctx->FragmentProgram.Current);

+         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_FALSE);

+      }

+

+      if (ctx->Extensions.ARB_shader_objects) {

+	 _mesa_reference_shader_program(ctx, &save->VertexShader,

+					ctx->Shader.CurrentVertexProgram);

+	 _mesa_reference_shader_program(ctx, &save->GeometryShader,

+					ctx->Shader.CurrentGeometryProgram);

+	 _mesa_reference_shader_program(ctx, &save->FragmentShader,

+					ctx->Shader.CurrentFragmentProgram);

+	 _mesa_reference_shader_program(ctx, &save->ActiveShader,

+					ctx->Shader.CurrentFragmentProgram);

+

+         _mesa_UseProgramObjectARB(0);

+      }

+   }

+

+   if (state & META_STENCIL_TEST) {

+      save->Stencil = ctx->Stencil; /* struct copy */

+      if (ctx->Stencil.Enabled)

+         _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);

+      /* NOTE: other stencil state not reset */

+   }

+

+   if (state & META_TEXTURE) {

+      GLuint u, tgt;

+

+      save->ActiveUnit = ctx->Texture.CurrentUnit;

+      save->ClientActiveUnit = ctx->Array.ActiveTexture;

+      save->EnvMode = ctx->Texture.Unit[0].EnvMode;

+

+      /* Disable all texture units */

+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+         save->TexEnabled[u] = ctx->Texture.Unit[u].Enabled;

+         save->TexGenEnabled[u] = ctx->Texture.Unit[u].TexGenEnabled;

+         if (ctx->Texture.Unit[u].Enabled ||

+             ctx->Texture.Unit[u].TexGenEnabled) {

+            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);

+            _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_FALSE);

+            if (ctx->Extensions.ARB_texture_cube_map)

+               _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_FALSE);

+         }

+      }

+

+      /* save current texture objects for unit[0] only */

+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+         _mesa_reference_texobj(&save->CurrentTexture[tgt],

+                                ctx->Texture.Unit[0].CurrentTex[tgt]);

+      }

+

+      /* set defaults for unit[0] */

+      _mesa_ActiveTextureARB(GL_TEXTURE0);

+      _mesa_ClientActiveTextureARB(GL_TEXTURE0);

+      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

+   }

+

+   if (state & META_TRANSFORM) {

+      GLuint activeTexture = ctx->Texture.CurrentUnit;

+      memcpy(save->ModelviewMatrix, ctx->ModelviewMatrixStack.Top->m,

+             16 * sizeof(GLfloat));

+      memcpy(save->ProjectionMatrix, ctx->ProjectionMatrixStack.Top->m,

+             16 * sizeof(GLfloat));

+      memcpy(save->TextureMatrix, ctx->TextureMatrixStack[0].Top->m,

+             16 * sizeof(GLfloat));

+      save->MatrixMode = ctx->Transform.MatrixMode;

+      /* set 1:1 vertex:pixel coordinate transform */

+      _mesa_ActiveTextureARB(GL_TEXTURE0);

+      _mesa_MatrixMode(GL_TEXTURE);

+      _mesa_LoadIdentity();

+      _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);

+      _mesa_MatrixMode(GL_MODELVIEW);

+      _mesa_LoadIdentity();

+      _mesa_MatrixMode(GL_PROJECTION);

+      _mesa_LoadIdentity();

+      _mesa_Ortho(0.0, ctx->DrawBuffer->Width,

+                  0.0, ctx->DrawBuffer->Height,

+                  -1.0, 1.0);

+      save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;

+      if (ctx->Transform.ClipPlanesEnabled) {

+         GLuint i;

+         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {

+            _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);

+         }

+      }

+   }

+

+   if (state & META_VERTEX) {

+      /* save vertex array object state */

+      _mesa_reference_array_object(ctx, &save->ArrayObj,

+                                   ctx->Array.ArrayObj);

+      _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj,

+                                    ctx->Array.ArrayBufferObj);

+      /* set some default state? */

+   }

+

+   if (state & META_VIEWPORT) {

+      /* save viewport state */

+      save->ViewportX = ctx->Viewport.X;

+      save->ViewportY = ctx->Viewport.Y;

+      save->ViewportW = ctx->Viewport.Width;

+      save->ViewportH = ctx->Viewport.Height;

+      /* set viewport to match window size */

+      if (ctx->Viewport.X != 0 ||

+          ctx->Viewport.Y != 0 ||

+          ctx->Viewport.Width != ctx->DrawBuffer->Width ||

+          ctx->Viewport.Height != ctx->DrawBuffer->Height) {

+         _mesa_set_viewport(ctx, 0, 0,

+                            ctx->DrawBuffer->Width, ctx->DrawBuffer->Height);

+      }

+      /* save depth range state */

+      save->DepthNear = ctx->Viewport.Near;

+      save->DepthFar = ctx->Viewport.Far;

+      /* set depth range to default */

+      _mesa_DepthRange(0.0, 1.0);

+   }

+

+   /* misc */

+   {

+      save->Lighting = ctx->Light.Enabled;

+      if (ctx->Light.Enabled)

+         _mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);

+   }

+}

+

+

+/**

+ * Leave meta state.  This is like a light-weight version of glPopAttrib().

+ */

+static void

+_mesa_meta_end(struct gl_context *ctx)

+{

+   struct save_state *save = &ctx->Meta->Save[--ctx->Meta->SaveStackDepth];

+   const GLbitfield state = save->SavedState;

+

+   if (state & META_ALPHA_TEST) {

+      if (ctx->Color.AlphaEnabled != save->AlphaEnabled)

+         _mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);

+      _mesa_AlphaFunc(save->AlphaFunc, save->AlphaRef);

+   }

+

+   if (state & META_BLEND) {

+      if (ctx->Color.BlendEnabled != save->BlendEnabled) {

+         if (ctx->Extensions.EXT_draw_buffers2) {

+            GLuint i;

+            for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+               _mesa_set_enablei(ctx, GL_BLEND, i, (save->BlendEnabled >> i) & 1);

+            }

+         }

+         else {

+            _mesa_set_enable(ctx, GL_BLEND, (save->BlendEnabled & 1));

+         }

+      }

+      if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)

+         _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);

+   }

+

+   if (state & META_COLOR_MASK) {

+      GLuint i;

+      for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+         if (!TEST_EQ_4V(ctx->Color.ColorMask[i], save->ColorMask[i])) {

+            if (i == 0) {

+               _mesa_ColorMask(save->ColorMask[i][0], save->ColorMask[i][1],

+                               save->ColorMask[i][2], save->ColorMask[i][3]);

+            }

+            else {

+               _mesa_ColorMaskIndexed(i,

+                                      save->ColorMask[i][0],

+                                      save->ColorMask[i][1],

+                                      save->ColorMask[i][2],

+                                      save->ColorMask[i][3]);

+            }

+         }

+      }

+   }

+

+   if (state & META_DEPTH_TEST) {

+      if (ctx->Depth.Test != save->Depth.Test)

+         _mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);

+      _mesa_DepthFunc(save->Depth.Func);

+      _mesa_DepthMask(save->Depth.Mask);

+   }

+

+   if (state & META_FOG) {

+      _mesa_set_enable(ctx, GL_FOG, save->Fog);

+   }

+

+   if (state & META_PIXEL_STORE) {

+      ctx->Pack = save->Pack;

+      ctx->Unpack = save->Unpack;

+   }

+

+   if (state & META_PIXEL_TRANSFER) {

+      ctx->Pixel.RedScale = save->RedScale;

+      ctx->Pixel.RedBias = save->RedBias;

+      ctx->Pixel.GreenScale = save->GreenScale;

+      ctx->Pixel.GreenBias = save->GreenBias;

+      ctx->Pixel.BlueScale = save->BlueScale;

+      ctx->Pixel.BlueBias = save->BlueBias;

+      ctx->Pixel.AlphaScale = save->AlphaScale;

+      ctx->Pixel.AlphaBias = save->AlphaBias;

+      ctx->Pixel.MapColorFlag = save->MapColorFlag;

+      /* XXX more state */

+      ctx->NewState |=_NEW_PIXEL;

+   }

+

+   if (state & META_RASTERIZATION) {

+      _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);

+      _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);

+      _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);

+      _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);

+      _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);

+      _mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);

+   }

+

+   if (state & META_SCISSOR) {

+      _mesa_set_enable(ctx, GL_SCISSOR_TEST, save->Scissor.Enabled);

+      _mesa_Scissor(save->Scissor.X, save->Scissor.Y,

+                    save->Scissor.Width, save->Scissor.Height);

+   }

+

+   if (state & META_SHADER) {

+      if (ctx->Extensions.ARB_vertex_program) {

+         _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB,

+                          save->VertexProgramEnabled);

+         _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, 

+                                  save->VertexProgram);

+	 _mesa_reference_vertprog(ctx, &save->VertexProgram, NULL);

+      }

+

+      if (ctx->Extensions.ARB_fragment_program) {

+         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB,

+                          save->FragmentProgramEnabled);

+         _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,

+                                  save->FragmentProgram);

+	 _mesa_reference_fragprog(ctx, &save->FragmentProgram, NULL);

+      }

+

+      if (ctx->Extensions.ARB_vertex_shader)

+	 _mesa_use_shader_program(ctx, GL_VERTEX_SHADER, save->VertexShader);

+

+      if (ctx->Extensions.ARB_geometry_shader4)

+	 _mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB,

+				  save->GeometryShader);

+

+      if (ctx->Extensions.ARB_fragment_shader)

+	 _mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER,

+				  save->FragmentShader);

+

+      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram,

+				     save->ActiveShader);

+   }

+

+   if (state & META_STENCIL_TEST) {

+      const struct gl_stencil_attrib *stencil = &save->Stencil;

+

+      _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);

+      _mesa_ClearStencil(stencil->Clear);

+      if (ctx->Extensions.EXT_stencil_two_side) {

+         _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,

+                          stencil->TestTwoSide);

+         _mesa_ActiveStencilFaceEXT(stencil->ActiveFace

+                                    ? GL_BACK : GL_FRONT);

+      }

+      /* front state */

+      _mesa_StencilFuncSeparate(GL_FRONT,

+                                stencil->Function[0],

+                                stencil->Ref[0],

+                                stencil->ValueMask[0]);

+      _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);

+      _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],

+                              stencil->ZFailFunc[0],

+                              stencil->ZPassFunc[0]);

+      /* back state */

+      _mesa_StencilFuncSeparate(GL_BACK,

+                                stencil->Function[1],

+                                stencil->Ref[1],

+                                stencil->ValueMask[1]);

+      _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);

+      _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],

+                              stencil->ZFailFunc[1],

+                              stencil->ZPassFunc[1]);

+   }

+

+   if (state & META_TEXTURE) {

+      GLuint u, tgt;

+

+      ASSERT(ctx->Texture.CurrentUnit == 0);

+

+      /* restore texenv for unit[0] */

+      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);

+

+      /* restore texture objects for unit[0] only */

+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+         _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt],

+                                save->CurrentTexture[tgt]);

+         _mesa_reference_texobj(&save->CurrentTexture[tgt], NULL);

+      }

+

+      /* Re-enable textures, texgen */

+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+         if (save->TexEnabled[u]) {

+            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);

+

+            if (save->TexEnabled[u] & TEXTURE_1D_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_TRUE);

+            if (save->TexEnabled[u] & TEXTURE_2D_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_TRUE);

+            if (save->TexEnabled[u] & TEXTURE_3D_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_TRUE);

+            if (save->TexEnabled[u] & TEXTURE_CUBE_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_TRUE);

+            if (save->TexEnabled[u] & TEXTURE_RECT_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_TRUE);

+         }

+

+         if (save->TexGenEnabled[u]) {

+            _mesa_ActiveTextureARB(GL_TEXTURE0 + u);

+

+            if (save->TexGenEnabled[u] & S_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_TRUE);

+            if (save->TexGenEnabled[u] & T_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_TRUE);

+            if (save->TexGenEnabled[u] & R_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_TRUE);

+            if (save->TexGenEnabled[u] & Q_BIT)

+               _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_TRUE);

+         }

+      }

+

+      /* restore current unit state */

+      _mesa_ActiveTextureARB(GL_TEXTURE0 + save->ActiveUnit);

+      _mesa_ClientActiveTextureARB(GL_TEXTURE0 + save->ClientActiveUnit);

+   }

+

+   if (state & META_TRANSFORM) {

+      GLuint activeTexture = ctx->Texture.CurrentUnit;

+      _mesa_ActiveTextureARB(GL_TEXTURE0);

+      _mesa_MatrixMode(GL_TEXTURE);

+      _mesa_LoadMatrixf(save->TextureMatrix);

+      _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);

+

+      _mesa_MatrixMode(GL_MODELVIEW);

+      _mesa_LoadMatrixf(save->ModelviewMatrix);

+

+      _mesa_MatrixMode(GL_PROJECTION);

+      _mesa_LoadMatrixf(save->ProjectionMatrix);

+

+      _mesa_MatrixMode(save->MatrixMode);

+

+      if (save->ClipPlanesEnabled) {

+         GLuint i;

+         for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {

+            if (save->ClipPlanesEnabled & (1 << i)) {

+               _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);

+            }

+         }

+      }

+   }

+

+   if (state & META_VERTEX) {

+      /* restore vertex buffer object */

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, save->ArrayBufferObj->Name);

+      _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj, NULL);

+

+      /* restore vertex array object */

+      _mesa_BindVertexArray(save->ArrayObj->Name);

+      _mesa_reference_array_object(ctx, &save->ArrayObj, NULL);

+   }

+

+   if (state & META_VIEWPORT) {

+      if (save->ViewportX != ctx->Viewport.X ||

+          save->ViewportY != ctx->Viewport.Y ||

+          save->ViewportW != ctx->Viewport.Width ||

+          save->ViewportH != ctx->Viewport.Height) {

+         _mesa_set_viewport(ctx, save->ViewportX, save->ViewportY,

+                            save->ViewportW, save->ViewportH);

+      }

+      _mesa_DepthRange(save->DepthNear, save->DepthFar);

+   }

+

+   /* misc */

+   if (save->Lighting) {

+      _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);

+   }

+}

+

+

+/**

+ * Convert Z from a normalized value in the range [0, 1] to an object-space

+ * Z coordinate in [-1, +1] so that drawing at the new Z position with the

+ * default/identity ortho projection results in the original Z value.

+ * Used by the meta-Clear, Draw/CopyPixels and Bitmap functions where the Z

+ * value comes from the clear value or raster position.

+ */

+static INLINE GLfloat

+invert_z(GLfloat normZ)

+{

+   GLfloat objZ = 1.0 - 2.0 * normZ;

+   return objZ;

+}

+

+

+/**

+ * One-time init for a temp_texture object.

+ * Choose tex target, compute max tex size, etc.

+ */

+static void

+init_temp_texture(struct gl_context *ctx, struct temp_texture *tex)

+{

+   /* prefer texture rectangle */

+   if (ctx->Extensions.NV_texture_rectangle) {

+      tex->Target = GL_TEXTURE_RECTANGLE;

+      tex->MaxSize = ctx->Const.MaxTextureRectSize;

+      tex->NPOT = GL_TRUE;

+   }

+   else {

+      /* use 2D texture, NPOT if possible */

+      tex->Target = GL_TEXTURE_2D;

+      tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;

+   }

+   tex->MinSize = 16;  /* 16 x 16 at least */

+   assert(tex->MaxSize > 0);

+

+   _mesa_GenTextures(1, &tex->TexObj);

+}

+

+

+/**

+ * Return pointer to temp_texture info for non-bitmap ops.

+ * This does some one-time init if needed.

+ */

+static struct temp_texture *

+get_temp_texture(struct gl_context *ctx)

+{

+   struct temp_texture *tex = &ctx->Meta->TempTex;

+

+   if (!tex->TexObj) {

+      init_temp_texture(ctx, tex);

+   }

+

+   return tex;

+}

+

+

+/**

+ * Return pointer to temp_texture info for _mesa_meta_bitmap().

+ * We use a separate texture for bitmaps to reduce texture

+ * allocation/deallocation.

+ */

+static struct temp_texture *

+get_bitmap_temp_texture(struct gl_context *ctx)

+{

+   struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;

+

+   if (!tex->TexObj) {

+      init_temp_texture(ctx, tex);

+   }

+

+   return tex;

+}

+

+

+/**

+ * Compute the width/height of texture needed to draw an image of the

+ * given size.  Return a flag indicating whether the current texture

+ * can be re-used (glTexSubImage2D) or if a new texture needs to be

+ * allocated (glTexImage2D).

+ * Also, compute s/t texcoords for drawing.

+ *

+ * \return GL_TRUE if new texture is needed, GL_FALSE otherwise

+ */

+static GLboolean

+alloc_texture(struct temp_texture *tex,

+              GLsizei width, GLsizei height, GLenum intFormat)

+{

+   GLboolean newTex = GL_FALSE;

+

+   ASSERT(width <= tex->MaxSize);

+   ASSERT(height <= tex->MaxSize);

+

+   if (width > tex->Width ||

+       height > tex->Height ||

+       intFormat != tex->IntFormat) {

+      /* alloc new texture (larger or different format) */

+

+      if (tex->NPOT) {

+         /* use non-power of two size */

+         tex->Width = MAX2(tex->MinSize, width);

+         tex->Height = MAX2(tex->MinSize, height);

+      }

+      else {

+         /* find power of two size */

+         GLsizei w, h;

+         w = h = tex->MinSize;

+         while (w < width)

+            w *= 2;

+         while (h < height)

+            h *= 2;

+         tex->Width = w;

+         tex->Height = h;

+      }

+

+      tex->IntFormat = intFormat;

+

+      newTex = GL_TRUE;

+   }

+

+   /* compute texcoords */

+   if (tex->Target == GL_TEXTURE_RECTANGLE) {

+      tex->Sright = (GLfloat) width;

+      tex->Ttop = (GLfloat) height;

+   }

+   else {

+      tex->Sright = (GLfloat) width / tex->Width;

+      tex->Ttop = (GLfloat) height / tex->Height;

+   }

+

+   return newTex;

+}

+

+

+/**

+ * Setup/load texture for glCopyPixels or glBlitFramebuffer.

+ */

+static void

+setup_copypix_texture(struct temp_texture *tex,

+                      GLboolean newTex,

+                      GLint srcX, GLint srcY,

+                      GLsizei width, GLsizei height, GLenum intFormat,

+                      GLenum filter)

+{

+   _mesa_BindTexture(tex->Target, tex->TexObj);

+   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, filter);

+   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, filter);

+   _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

+

+   /* copy framebuffer image to texture */

+   if (newTex) {

+      /* create new tex image */

+      if (tex->Width == width && tex->Height == height) {

+         /* create new tex with framebuffer data */

+         _mesa_CopyTexImage2D(tex->Target, 0, tex->IntFormat,

+                              srcX, srcY, width, height, 0);

+      }

+      else {

+         /* create empty texture */

+         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,

+                          tex->Width, tex->Height, 0,

+                          intFormat, GL_UNSIGNED_BYTE, NULL);

+         /* load image */

+         _mesa_CopyTexSubImage2D(tex->Target, 0,

+                                 0, 0, srcX, srcY, width, height);

+      }

+   }

+   else {

+      /* replace existing tex image */

+      _mesa_CopyTexSubImage2D(tex->Target, 0,

+                              0, 0, srcX, srcY, width, height);

+   }

+}

+

+

+/**

+ * Setup/load texture for glDrawPixels.

+ */

+static void

+setup_drawpix_texture(struct gl_context *ctx,

+		      struct temp_texture *tex,

+                      GLboolean newTex,

+                      GLenum texIntFormat,

+                      GLsizei width, GLsizei height,

+                      GLenum format, GLenum type,

+                      const GLvoid *pixels)

+{

+   _mesa_BindTexture(tex->Target, tex->TexObj);

+   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

+   _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

+   _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

+

+   /* copy pixel data to texture */

+   if (newTex) {

+      /* create new tex image */

+      if (tex->Width == width && tex->Height == height) {

+         /* create new tex and load image data */

+         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,

+                          tex->Width, tex->Height, 0, format, type, pixels);

+      }

+      else {

+	 struct gl_buffer_object *save_unpack_obj = NULL;

+

+	 _mesa_reference_buffer_object(ctx, &save_unpack_obj,

+				       ctx->Unpack.BufferObj);

+	 _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);

+         /* create empty texture */

+         _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,

+                          tex->Width, tex->Height, 0, format, type, NULL);

+	 if (save_unpack_obj != NULL)

+	    _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,

+				save_unpack_obj->Name);

+         /* load image */

+         _mesa_TexSubImage2D(tex->Target, 0,

+                             0, 0, width, height, format, type, pixels);

+      }

+   }

+   else {

+      /* replace existing tex image */

+      _mesa_TexSubImage2D(tex->Target, 0,

+                          0, 0, width, height, format, type, pixels);

+   }

+}

+

+

+

+/**

+ * One-time init for drawing depth pixels.

+ */

+static void

+init_blit_depth_pixels(struct gl_context *ctx)

+{

+   static const char *program =

+      "!!ARBfp1.0\n"

+      "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"

+      "END \n";

+   char program2[200];

+   struct blit_state *blit = &ctx->Meta->Blit;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   const char *texTarget;

+

+   assert(blit->DepthFP == 0);

+

+   /* replace %s with "RECT" or "2D" */

+   assert(strlen(program) + 4 < sizeof(program2));

+   if (tex->Target == GL_TEXTURE_RECTANGLE)

+      texTarget = "RECT";

+   else

+      texTarget = "2D";

+   _mesa_snprintf(program2, sizeof(program2), program, texTarget);

+

+   _mesa_GenPrograms(1, &blit->DepthFP);

+   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);

+   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,

+                          strlen(program2), (const GLubyte *) program2);

+}

+

+

+/**

+ * Try to do a glBlitFramebuffer using no-copy texturing.

+ * We can do this when the src renderbuffer is actually a texture.

+ * But if the src buffer == dst buffer we cannot do this.

+ *

+ * \return new buffer mask indicating the buffers left to blit using the

+ *         normal path.

+ */

+static GLbitfield

+blitframebuffer_texture(struct gl_context *ctx,

+                        GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                        GLbitfield mask, GLenum filter)

+{

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      const struct gl_framebuffer *drawFb = ctx->DrawBuffer;

+      const struct gl_framebuffer *readFb = ctx->ReadBuffer;

+      const struct gl_renderbuffer_attachment *drawAtt =

+         &drawFb->Attachment[drawFb->_ColorDrawBufferIndexes[0]];

+      const struct gl_renderbuffer_attachment *readAtt =

+         &readFb->Attachment[readFb->_ColorReadBufferIndex];

+

+      if (readAtt && readAtt->Texture) {

+         const struct gl_texture_object *texObj = readAtt->Texture;

+         const GLuint srcLevel = readAtt->TextureLevel;

+         const GLenum minFilterSave = texObj->MinFilter;

+         const GLenum magFilterSave = texObj->MagFilter;

+         const GLint baseLevelSave = texObj->BaseLevel;

+         const GLint maxLevelSave = texObj->MaxLevel;

+         const GLenum wrapSSave = texObj->WrapS;

+         const GLenum wrapTSave = texObj->WrapT;

+         const GLenum target = texObj->Target;

+

+         if (drawAtt->Texture == readAtt->Texture) {

+            /* Can't use same texture as both the source and dest.  We need

+             * to handle overlapping blits and besides, some hw may not

+             * support this.

+             */

+            return mask;

+         }

+

+         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_RECTANGLE_ARB) {

+            /* Can't handle other texture types at this time */

+            return mask;

+         }

+

+         /*

+         printf("Blit from texture!\n");

+         printf("  srcAtt %p  dstAtt %p\n", readAtt, drawAtt);

+         printf("  srcTex %p  dstText %p\n", texObj, drawAtt->Texture);

+         */

+

+         /* Prepare src texture state */

+         _mesa_BindTexture(target, texObj->Name);

+         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);

+         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);

+         if (target != GL_TEXTURE_RECTANGLE_ARB) {

+            _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, srcLevel);

+            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);

+         }

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

+         _mesa_set_enable(ctx, target, GL_TRUE);

+

+         /* Prepare vertex data (the VBO was previously created and bound) */

+         {

+            struct vertex {

+               GLfloat x, y, s, t;

+            };

+            struct vertex verts[4];

+            GLfloat s0, t0, s1, t1;

+

+            if (target == GL_TEXTURE_2D) {

+               const struct gl_texture_image *texImage

+                   = _mesa_select_tex_image(ctx, texObj, target, srcLevel);

+               s0 = srcX0 / (float) texImage->Width;

+               s1 = srcX1 / (float) texImage->Width;

+               t0 = srcY0 / (float) texImage->Height;

+               t1 = srcY1 / (float) texImage->Height;

+            }

+            else {

+               assert(target == GL_TEXTURE_RECTANGLE_ARB);

+               s0 = srcX0;

+               s1 = srcX1;

+               t0 = srcY0;

+               t1 = srcY1;

+            }

+

+            verts[0].x = (GLfloat) dstX0;

+            verts[0].y = (GLfloat) dstY0;

+            verts[1].x = (GLfloat) dstX1;

+            verts[1].y = (GLfloat) dstY0;

+            verts[2].x = (GLfloat) dstX1;

+            verts[2].y = (GLfloat) dstY1;

+            verts[3].x = (GLfloat) dstX0;

+            verts[3].y = (GLfloat) dstY1;

+

+            verts[0].s = s0;

+            verts[0].t = t0;

+            verts[1].s = s1;

+            verts[1].t = t0;

+            verts[2].s = s1;

+            verts[2].t = t1;

+            verts[3].s = s0;

+            verts[3].t = t1;

+

+            _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);

+         }

+

+         _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+

+         /* Restore texture object state, the texture binding will

+          * be restored by _mesa_meta_end().

+          */

+         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);

+         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);

+         if (target != GL_TEXTURE_RECTANGLE_ARB) {

+            _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);

+            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);

+         }

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);

+

+         /* Done with color buffer */

+         mask &= ~GL_COLOR_BUFFER_BIT;

+      }

+   }

+

+   return mask;

+}

+

+

+/**

+ * Meta implementation of ctx->Driver.BlitFramebuffer() in terms

+ * of texture mapping and polygon rendering.

+ */

+void

+_mesa_meta_BlitFramebuffer(struct gl_context *ctx,

+                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                           GLbitfield mask, GLenum filter)

+{

+   struct blit_state *blit = &ctx->Meta->Blit;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   const GLsizei maxTexSize = tex->MaxSize;

+   const GLint srcX = MIN2(srcX0, srcX1);

+   const GLint srcY = MIN2(srcY0, srcY1);

+   const GLint srcW = abs(srcX1 - srcX0);

+   const GLint srcH = abs(srcY1 - srcY0);

+   const GLboolean srcFlipX = srcX1 < srcX0;

+   const GLboolean srcFlipY = srcY1 < srcY0;

+   struct vertex {

+      GLfloat x, y, s, t;

+   };

+   struct vertex verts[4];

+   GLboolean newTex;

+

+   if (srcW > maxTexSize || srcH > maxTexSize) {

+      /* XXX avoid this fallback */

+      _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,

+                              dstX0, dstY0, dstX1, dstY1, mask, filter);

+      return;

+   }

+

+   if (srcFlipX) {

+      GLint tmp = dstX0;

+      dstX0 = dstX1;

+      dstX1 = tmp;

+   }

+

+   if (srcFlipY) {

+      GLint tmp = dstY0;

+      dstY0 = dstY1;

+      dstY1 = tmp;

+   }

+

+   /* only scissor effects blit so save/clear all other relevant state */

+   _mesa_meta_begin(ctx, ~META_SCISSOR);

+

+   if (blit->ArrayObj == 0) {

+      /* one-time setup */

+

+      /* create vertex array object */

+      _mesa_GenVertexArrays(1, &blit->ArrayObj);

+      _mesa_BindVertexArray(blit->ArrayObj);

+

+      /* create vertex array buffer */

+      _mesa_GenBuffersARB(1, &blit->VBO);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);

+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),

+                          NULL, GL_DYNAMIC_DRAW_ARB);

+

+      /* setup vertex arrays */

+      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));

+      _mesa_EnableClientState(GL_VERTEX_ARRAY);

+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);

+   }

+   else {

+      _mesa_BindVertexArray(blit->ArrayObj);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);

+   }

+

+   /* Try faster, direct texture approach first */

+   mask = blitframebuffer_texture(ctx, srcX0, srcY0, srcX1, srcY1,

+                                  dstX0, dstY0, dstX1, dstY1, mask, filter);

+   if (mask == 0x0) {

+      _mesa_meta_end(ctx);

+      return;

+   }

+

+   /* Continue with "normal" approach which involves copying the src rect

+    * into a temporary texture and is "blitted" by drawing a textured quad.

+    */

+

+   newTex = alloc_texture(tex, srcW, srcH, GL_RGBA);

+

+   /* vertex positions/texcoords (after texture allocation!) */

+   {

+      verts[0].x = (GLfloat) dstX0;

+      verts[0].y = (GLfloat) dstY0;

+      verts[1].x = (GLfloat) dstX1;

+      verts[1].y = (GLfloat) dstY0;

+      verts[2].x = (GLfloat) dstX1;

+      verts[2].y = (GLfloat) dstY1;

+      verts[3].x = (GLfloat) dstX0;

+      verts[3].y = (GLfloat) dstY1;

+

+      verts[0].s = 0.0F;

+      verts[0].t = 0.0F;

+      verts[1].s = tex->Sright;

+      verts[1].t = 0.0F;

+      verts[2].s = tex->Sright;

+      verts[2].t = tex->Ttop;

+      verts[3].s = 0.0F;

+      verts[3].t = tex->Ttop;

+

+      /* upload new vertex data */

+      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);

+   }

+

+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);

+

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      setup_copypix_texture(tex, newTex, srcX, srcY, srcW, srcH,

+                            GL_RGBA, filter);

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+      mask &= ~GL_COLOR_BUFFER_BIT;

+   }

+

+   if (mask & GL_DEPTH_BUFFER_BIT) {

+      GLuint *tmp = (GLuint *) malloc(srcW * srcH * sizeof(GLuint));

+      if (tmp) {

+         if (!blit->DepthFP)

+            init_blit_depth_pixels(ctx);

+

+         /* maybe change tex format here */

+         newTex = alloc_texture(tex, srcW, srcH, GL_DEPTH_COMPONENT);

+

+         _mesa_ReadPixels(srcX, srcY, srcW, srcH,

+                          GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);

+

+         setup_drawpix_texture(ctx, tex, newTex, GL_DEPTH_COMPONENT, srcW, srcH,

+                               GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);

+

+         _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);

+         _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);

+         _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

+         _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);

+         _mesa_DepthFunc(GL_ALWAYS);

+         _mesa_DepthMask(GL_TRUE);

+

+         _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+         mask &= ~GL_DEPTH_BUFFER_BIT;

+

+         free(tmp);

+      }

+   }

+

+   if (mask & GL_STENCIL_BUFFER_BIT) {

+      /* XXX can't easily do stencil */

+   }

+

+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);

+

+   _mesa_meta_end(ctx);

+

+   if (mask) {

+      _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,

+                              dstX0, dstY0, dstX1, dstY1, mask, filter);

+   }

+}

+

+

+/**

+ * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.

+ */

+void

+_mesa_meta_Clear(struct gl_context *ctx, GLbitfield buffers)

+{

+   struct clear_state *clear = &ctx->Meta->Clear;

+   struct vertex {

+      GLfloat x, y, z, r, g, b, a;

+   };

+   struct vertex verts[4];

+   /* save all state but scissor, pixel pack/unpack */

+   GLbitfield metaSave = META_ALL - META_SCISSOR - META_PIXEL_STORE;

+   const GLuint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;

+

+   if (buffers & BUFFER_BITS_COLOR) {

+      /* if clearing color buffers, don't save/restore colormask */

+      metaSave -= META_COLOR_MASK;

+   }

+

+   _mesa_meta_begin(ctx, metaSave);

+

+   if (clear->ArrayObj == 0) {

+      /* one-time setup */

+

+      /* create vertex array object */

+      _mesa_GenVertexArrays(1, &clear->ArrayObj);

+      _mesa_BindVertexArray(clear->ArrayObj);

+

+      /* create vertex array buffer */

+      _mesa_GenBuffersARB(1, &clear->VBO);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);

+

+      /* setup vertex arrays */

+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));

+      _mesa_EnableClientState(GL_VERTEX_ARRAY);

+      _mesa_EnableClientState(GL_COLOR_ARRAY);

+   }

+   else {

+      _mesa_BindVertexArray(clear->ArrayObj);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);

+   }

+

+   /* GL_COLOR_BUFFER_BIT */

+   if (buffers & BUFFER_BITS_COLOR) {

+      /* leave colormask, glDrawBuffer state as-is */

+   }

+   else {

+      ASSERT(metaSave & META_COLOR_MASK);

+      _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

+   }

+

+   /* GL_DEPTH_BUFFER_BIT */

+   if (buffers & BUFFER_BIT_DEPTH) {

+      _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);

+      _mesa_DepthFunc(GL_ALWAYS);

+      _mesa_DepthMask(GL_TRUE);

+   }

+   else {

+      assert(!ctx->Depth.Test);

+   }

+

+   /* GL_STENCIL_BUFFER_BIT */

+   if (buffers & BUFFER_BIT_STENCIL) {

+      _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);

+      _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,

+                              GL_REPLACE, GL_REPLACE, GL_REPLACE);

+      _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,

+                                ctx->Stencil.Clear & stencilMax,

+                                ctx->Stencil.WriteMask[0]);

+   }

+   else {

+      assert(!ctx->Stencil.Enabled);

+   }

+

+   /* vertex positions/colors */

+   {

+      const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin;

+      const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin;

+      const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax;

+      const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax;

+      const GLfloat z = invert_z(ctx->Depth.Clear);

+      GLuint i;

+

+      verts[0].x = x0;

+      verts[0].y = y0;

+      verts[0].z = z;

+      verts[1].x = x1;

+      verts[1].y = y0;

+      verts[1].z = z;

+      verts[2].x = x1;

+      verts[2].y = y1;

+      verts[2].z = z;

+      verts[3].x = x0;

+      verts[3].y = y1;

+      verts[3].z = z;

+

+      /* vertex colors */

+      for (i = 0; i < 4; i++) {

+         verts[i].r = ctx->Color.ClearColor[0];

+         verts[i].g = ctx->Color.ClearColor[1];

+         verts[i].b = ctx->Color.ClearColor[2];

+         verts[i].a = ctx->Color.ClearColor[3];

+      }

+

+      /* upload new vertex data */

+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,

+			  GL_DYNAMIC_DRAW_ARB);

+   }

+

+   /* draw quad */

+   _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+

+   _mesa_meta_end(ctx);

+}

+

+

+/**

+ * Meta implementation of ctx->Driver.CopyPixels() in terms

+ * of texture mapping and polygon rendering.

+ */

+void

+_mesa_meta_CopyPixels(struct gl_context *ctx, GLint srcX, GLint srcY,

+                      GLsizei width, GLsizei height,

+                      GLint dstX, GLint dstY, GLenum type)

+{

+   struct copypix_state *copypix = &ctx->Meta->CopyPix;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   struct vertex {

+      GLfloat x, y, z, s, t;

+   };

+   struct vertex verts[4];

+   GLboolean newTex;

+   GLenum intFormat = GL_RGBA;

+

+   if (type != GL_COLOR ||

+       ctx->_ImageTransferState ||

+       ctx->Fog.Enabled ||

+       width > tex->MaxSize ||

+       height > tex->MaxSize) {

+      /* XXX avoid this fallback */

+      _swrast_CopyPixels(ctx, srcX, srcY, width, height, dstX, dstY, type);

+      return;

+   }

+

+   /* Most GL state applies to glCopyPixels, but a there's a few things

+    * we need to override:

+    */

+   _mesa_meta_begin(ctx, (META_RASTERIZATION |

+                          META_SHADER |

+                          META_TEXTURE |

+                          META_TRANSFORM |

+                          META_VERTEX |

+                          META_VIEWPORT));

+

+   if (copypix->ArrayObj == 0) {

+      /* one-time setup */

+

+      /* create vertex array object */

+      _mesa_GenVertexArrays(1, &copypix->ArrayObj);

+      _mesa_BindVertexArray(copypix->ArrayObj);

+

+      /* create vertex array buffer */

+      _mesa_GenBuffersARB(1, &copypix->VBO);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);

+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),

+                          NULL, GL_DYNAMIC_DRAW_ARB);

+

+      /* setup vertex arrays */

+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));

+      _mesa_EnableClientState(GL_VERTEX_ARRAY);

+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);

+   }

+   else {

+      _mesa_BindVertexArray(copypix->ArrayObj);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);

+   }

+

+   newTex = alloc_texture(tex, width, height, intFormat);

+

+   /* vertex positions, texcoords (after texture allocation!) */

+   {

+      const GLfloat dstX0 = (GLfloat) dstX;

+      const GLfloat dstY0 = (GLfloat) dstY;

+      const GLfloat dstX1 = dstX + width * ctx->Pixel.ZoomX;

+      const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;

+      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);

+

+      verts[0].x = dstX0;

+      verts[0].y = dstY0;

+      verts[0].z = z;

+      verts[0].s = 0.0F;

+      verts[0].t = 0.0F;

+      verts[1].x = dstX1;

+      verts[1].y = dstY0;

+      verts[1].z = z;

+      verts[1].s = tex->Sright;

+      verts[1].t = 0.0F;

+      verts[2].x = dstX1;

+      verts[2].y = dstY1;

+      verts[2].z = z;

+      verts[2].s = tex->Sright;

+      verts[2].t = tex->Ttop;

+      verts[3].x = dstX0;

+      verts[3].y = dstY1;

+      verts[3].z = z;

+      verts[3].s = 0.0F;

+      verts[3].t = tex->Ttop;

+

+      /* upload new vertex data */

+      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);

+   }

+

+   /* Alloc/setup texture */

+   setup_copypix_texture(tex, newTex, srcX, srcY, width, height,

+                         GL_RGBA, GL_NEAREST);

+

+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);

+

+   /* draw textured quad */

+   _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+

+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);

+

+   _mesa_meta_end(ctx);

+}

+

+

+

+/**

+ * When the glDrawPixels() image size is greater than the max rectangle

+ * texture size we use this function to break the glDrawPixels() image

+ * into tiles which fit into the max texture size.

+ */

+static void

+tiled_draw_pixels(struct gl_context *ctx,

+                  GLint tileSize,

+                  GLint x, GLint y, GLsizei width, GLsizei height,

+                  GLenum format, GLenum type,

+                  const struct gl_pixelstore_attrib *unpack,

+                  const GLvoid *pixels)

+{

+   struct gl_pixelstore_attrib tileUnpack = *unpack;

+   GLint i, j;

+

+   if (tileUnpack.RowLength == 0)

+      tileUnpack.RowLength = width;

+

+   for (i = 0; i < width; i += tileSize) {

+      const GLint tileWidth = MIN2(tileSize, width - i);

+      const GLint tileX = (GLint) (x + i * ctx->Pixel.ZoomX);

+

+      tileUnpack.SkipPixels = unpack->SkipPixels + i;

+

+      for (j = 0; j < height; j += tileSize) {

+         const GLint tileHeight = MIN2(tileSize, height - j);

+         const GLint tileY = (GLint) (y + j * ctx->Pixel.ZoomY);

+

+         tileUnpack.SkipRows = unpack->SkipRows + j;

+

+         _mesa_meta_DrawPixels(ctx, tileX, tileY, tileWidth, tileHeight,

+                               format, type, &tileUnpack, pixels);

+      }

+   }

+}

+

+

+/**

+ * One-time init for drawing stencil pixels.

+ */

+static void

+init_draw_stencil_pixels(struct gl_context *ctx)

+{

+   /* This program is run eight times, once for each stencil bit.

+    * The stencil values to draw are found in an 8-bit alpha texture.

+    * We read the texture/stencil value and test if bit 'b' is set.

+    * If the bit is not set, use KIL to kill the fragment.

+    * Finally, we use the stencil test to update the stencil buffer.

+    *

+    * The basic algorithm for checking if a bit is set is:

+    *   if (is_odd(value / (1 << bit)))

+    *      result is one (or non-zero).

+    *   else

+    *      result is zero.

+    * The program parameter contains three values:

+    *   parm.x = 255 / (1 << bit)

+    *   parm.y = 0.5

+    *   parm.z = 0.0

+    */

+   static const char *program =

+      "!!ARBfp1.0\n"

+      "PARAM parm = program.local[0]; \n"

+      "TEMP t; \n"

+      "TEX t, fragment.texcoord[0], texture[0], %s; \n"   /* NOTE %s here! */

+      "# t = t * 255 / bit \n"

+      "MUL t.x, t.a, parm.x; \n"

+      "# t = (int) t \n"

+      "FRC t.y, t.x; \n"

+      "SUB t.x, t.x, t.y; \n"

+      "# t = t * 0.5 \n"

+      "MUL t.x, t.x, parm.y; \n"

+      "# t = fract(t.x) \n"

+      "FRC t.x, t.x; # if t.x != 0, then the bit is set \n"

+      "# t.x = (t.x == 0 ? 1 : 0) \n"

+      "SGE t.x, -t.x, parm.z; \n"

+      "KIL -t.x; \n"

+      "# for debug only \n"

+      "#MOV result.color, t.x; \n"

+      "END \n";

+   char program2[1000];

+   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   const char *texTarget;

+

+   assert(drawpix->StencilFP == 0);

+

+   /* replace %s with "RECT" or "2D" */

+   assert(strlen(program) + 4 < sizeof(program2));

+   if (tex->Target == GL_TEXTURE_RECTANGLE)

+      texTarget = "RECT";

+   else

+      texTarget = "2D";

+   _mesa_snprintf(program2, sizeof(program2), program, texTarget);

+

+   _mesa_GenPrograms(1, &drawpix->StencilFP);

+   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);

+   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,

+                          strlen(program2), (const GLubyte *) program2);

+}

+

+

+/**

+ * One-time init for drawing depth pixels.

+ */

+static void

+init_draw_depth_pixels(struct gl_context *ctx)

+{

+   static const char *program =

+      "!!ARBfp1.0\n"

+      "PARAM color = program.local[0]; \n"

+      "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"

+      "MOV result.color, color; \n"

+      "END \n";

+   char program2[200];

+   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   const char *texTarget;

+

+   assert(drawpix->DepthFP == 0);

+

+   /* replace %s with "RECT" or "2D" */

+   assert(strlen(program) + 4 < sizeof(program2));

+   if (tex->Target == GL_TEXTURE_RECTANGLE)

+      texTarget = "RECT";

+   else

+      texTarget = "2D";

+   _mesa_snprintf(program2, sizeof(program2), program, texTarget);

+

+   _mesa_GenPrograms(1, &drawpix->DepthFP);

+   _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);

+   _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,

+                          strlen(program2), (const GLubyte *) program2);

+}

+

+

+/**

+ * Meta implementation of ctx->Driver.DrawPixels() in terms

+ * of texture mapping and polygon rendering.

+ */

+void

+_mesa_meta_DrawPixels(struct gl_context *ctx,

+                      GLint x, GLint y, GLsizei width, GLsizei height,

+                      GLenum format, GLenum type,

+                      const struct gl_pixelstore_attrib *unpack,

+                      const GLvoid *pixels)

+{

+   struct drawpix_state *drawpix = &ctx->Meta->DrawPix;

+   struct temp_texture *tex = get_temp_texture(ctx);

+   const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;

+   const GLuint origStencilMask = ctx->Stencil.WriteMask[0];

+   struct vertex {

+      GLfloat x, y, z, s, t;

+   };

+   struct vertex verts[4];

+   GLenum texIntFormat;

+   GLboolean fallback, newTex;

+   GLbitfield metaExtraSave = 0x0;

+   GLuint vbo;

+

+   /*

+    * Determine if we can do the glDrawPixels with texture mapping.

+    */

+   fallback = GL_FALSE;

+   if (ctx->_ImageTransferState ||

+       ctx->Fog.Enabled) {

+      fallback = GL_TRUE;

+   }

+

+   if (_mesa_is_color_format(format)) {

+      /* use more compact format when possible */

+      /* XXX disable special case for GL_LUMINANCE for now to work around

+       * apparent i965 driver bug (see bug #23670).

+       */

+      if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)

+         texIntFormat = format;

+      else

+         texIntFormat = GL_RGBA;

+   }

+   else if (_mesa_is_stencil_format(format)) {

+      if (ctx->Extensions.ARB_fragment_program &&

+          ctx->Pixel.IndexShift == 0 &&

+          ctx->Pixel.IndexOffset == 0 &&

+          type == GL_UNSIGNED_BYTE) {

+         /* We'll store stencil as alpha.  This only works for GLubyte

+          * image data because of how incoming values are mapped to alpha

+          * in [0,1].

+          */

+         texIntFormat = GL_ALPHA;

+         metaExtraSave = (META_COLOR_MASK |

+                          META_DEPTH_TEST |

+                          META_SHADER |

+                          META_STENCIL_TEST);

+      }

+      else {

+         fallback = GL_TRUE;

+      }

+   }

+   else if (_mesa_is_depth_format(format)) {

+      if (ctx->Extensions.ARB_depth_texture &&

+          ctx->Extensions.ARB_fragment_program) {

+         texIntFormat = GL_DEPTH_COMPONENT;

+         metaExtraSave = (META_SHADER);

+      }

+      else {

+         fallback = GL_TRUE;

+      }

+   }

+   else {

+      fallback = GL_TRUE;

+   }

+

+   if (fallback) {

+      _swrast_DrawPixels(ctx, x, y, width, height,

+                         format, type, unpack, pixels);

+      return;

+   }

+

+   /*

+    * Check image size against max texture size, draw as tiles if needed.

+    */

+   if (width > tex->MaxSize || height > tex->MaxSize) {

+      tiled_draw_pixels(ctx, tex->MaxSize, x, y, width, height,

+                        format, type, unpack, pixels);

+      return;

+   }

+

+   /* Most GL state applies to glDrawPixels (like blending, stencil, etc),

+    * but a there's a few things we need to override:

+    */

+   _mesa_meta_begin(ctx, (META_RASTERIZATION |

+                          META_SHADER |

+                          META_TEXTURE |

+                          META_TRANSFORM |

+                          META_VERTEX |

+                          META_VIEWPORT |

+                          metaExtraSave));

+

+   newTex = alloc_texture(tex, width, height, texIntFormat);

+

+   /* vertex positions, texcoords (after texture allocation!) */

+   {

+      const GLfloat x0 = (GLfloat) x;

+      const GLfloat y0 = (GLfloat) y;

+      const GLfloat x1 = x + width * ctx->Pixel.ZoomX;

+      const GLfloat y1 = y + height * ctx->Pixel.ZoomY;

+      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);

+

+      verts[0].x = x0;

+      verts[0].y = y0;

+      verts[0].z = z;

+      verts[0].s = 0.0F;

+      verts[0].t = 0.0F;

+      verts[1].x = x1;

+      verts[1].y = y0;

+      verts[1].z = z;

+      verts[1].s = tex->Sright;

+      verts[1].t = 0.0F;

+      verts[2].x = x1;

+      verts[2].y = y1;

+      verts[2].z = z;

+      verts[2].s = tex->Sright;

+      verts[2].t = tex->Ttop;

+      verts[3].x = x0;

+      verts[3].y = y1;

+      verts[3].z = z;

+      verts[3].s = 0.0F;

+      verts[3].t = tex->Ttop;

+   }

+

+   if (drawpix->ArrayObj == 0) {

+      /* one-time setup: create vertex array object */

+      _mesa_GenVertexArrays(1, &drawpix->ArrayObj);

+   }

+   _mesa_BindVertexArray(drawpix->ArrayObj);

+

+   /* create vertex array buffer */

+   _mesa_GenBuffersARB(1, &vbo);

+   _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);

+   _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),

+                       verts, GL_DYNAMIC_DRAW_ARB);

+

+   /* setup vertex arrays */

+   _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+   _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));

+   _mesa_EnableClientState(GL_VERTEX_ARRAY);

+   _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);

+

+   /* set given unpack params */

+   ctx->Unpack = *unpack;

+

+   _mesa_set_enable(ctx, tex->Target, GL_TRUE);

+

+   if (_mesa_is_stencil_format(format)) {

+      /* Drawing stencil */

+      GLint bit;

+

+      if (!drawpix->StencilFP)

+         init_draw_stencil_pixels(ctx);

+

+      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,

+                            GL_ALPHA, type, pixels);

+

+      _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

+

+      _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);

+

+      /* set all stencil bits to 0 */

+      _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);

+      _mesa_StencilFunc(GL_ALWAYS, 0, 255);

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+  

+      /* set stencil bits to 1 where needed */

+      _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

+

+      _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);

+      _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);

+

+      for (bit = 0; bit < ctx->DrawBuffer->Visual.stencilBits; bit++) {

+         const GLuint mask = 1 << bit;

+         if (mask & origStencilMask) {

+            _mesa_StencilFunc(GL_ALWAYS, mask, mask);

+            _mesa_StencilMask(mask);

+

+            _mesa_ProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0,

+                                             255.0 / mask, 0.5, 0.0, 0.0);

+

+            _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+         }

+      }

+   }

+   else if (_mesa_is_depth_format(format)) {

+      /* Drawing depth */

+      if (!drawpix->DepthFP)

+         init_draw_depth_pixels(ctx);

+

+      _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);

+      _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);

+

+      /* polygon color = current raster color */

+      _mesa_ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0,

+                                        ctx->Current.RasterColor);

+

+      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,

+                            format, type, pixels);

+

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+   }

+   else {

+      /* Drawing RGBA */

+      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,

+                            format, type, pixels);

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+   }

+

+   _mesa_set_enable(ctx, tex->Target, GL_FALSE);

+

+   _mesa_DeleteBuffersARB(1, &vbo);

+

+   /* restore unpack params */

+   ctx->Unpack = unpackSave;

+

+   _mesa_meta_end(ctx);

+}

+

+static GLboolean

+alpha_test_raster_color(struct gl_context *ctx)

+{

+   GLfloat alpha = ctx->Current.RasterColor[ACOMP];

+   GLfloat ref = ctx->Color.AlphaRef;

+

+   switch (ctx->Color.AlphaFunc) {

+      case GL_NEVER:

+	 return GL_FALSE;

+      case GL_LESS:

+	 return alpha < ref;

+      case GL_EQUAL:

+	 return alpha == ref;

+      case GL_LEQUAL:

+	 return alpha <= ref;

+      case GL_GREATER:

+	 return alpha > ref;

+      case GL_NOTEQUAL:

+	 return alpha != ref;

+      case GL_GEQUAL:

+	 return alpha >= ref;

+      case GL_ALWAYS:

+	 return GL_TRUE;

+      default:

+	 assert(0);

+	 return GL_FALSE;

+   }

+}

+

+/**

+ * Do glBitmap with a alpha texture quad.  Use the alpha test to cull

+ * the 'off' bits.  A bitmap cache as in the gallium/mesa state

+ * tracker would improve performance a lot.

+ */

+void

+_mesa_meta_Bitmap(struct gl_context *ctx,

+                  GLint x, GLint y, GLsizei width, GLsizei height,

+                  const struct gl_pixelstore_attrib *unpack,

+                  const GLubyte *bitmap1)

+{

+   struct bitmap_state *bitmap = &ctx->Meta->Bitmap;

+   struct temp_texture *tex = get_bitmap_temp_texture(ctx);

+   const GLenum texIntFormat = GL_ALPHA;

+   const struct gl_pixelstore_attrib unpackSave = *unpack;

+   GLubyte fg, bg;

+   struct vertex {

+      GLfloat x, y, z, s, t, r, g, b, a;

+   };

+   struct vertex verts[4];

+   GLboolean newTex;

+   GLubyte *bitmap8;

+

+   /*

+    * Check if swrast fallback is needed.

+    */

+   if (ctx->_ImageTransferState ||

+       ctx->FragmentProgram._Enabled ||

+       ctx->Fog.Enabled ||

+       ctx->Texture._EnabledUnits ||

+       width > tex->MaxSize ||

+       height > tex->MaxSize) {

+      _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);

+      return;

+   }

+

+   if (ctx->Color.AlphaEnabled && !alpha_test_raster_color(ctx))

+      return;

+

+   /* Most GL state applies to glBitmap (like blending, stencil, etc),

+    * but a there's a few things we need to override:

+    */

+   _mesa_meta_begin(ctx, (META_ALPHA_TEST |

+                          META_PIXEL_STORE |

+                          META_RASTERIZATION |

+                          META_SHADER |

+                          META_TEXTURE |

+                          META_TRANSFORM |

+                          META_VERTEX |

+                          META_VIEWPORT));

+

+   if (bitmap->ArrayObj == 0) {

+      /* one-time setup */

+

+      /* create vertex array object */

+      _mesa_GenVertexArraysAPPLE(1, &bitmap->ArrayObj);

+      _mesa_BindVertexArrayAPPLE(bitmap->ArrayObj);

+

+      /* create vertex array buffer */

+      _mesa_GenBuffersARB(1, &bitmap->VBO);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);

+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),

+                          NULL, GL_DYNAMIC_DRAW_ARB);

+

+      /* setup vertex arrays */

+      _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+      _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));

+      _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));

+      _mesa_EnableClientState(GL_VERTEX_ARRAY);

+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);

+      _mesa_EnableClientState(GL_COLOR_ARRAY);

+   }

+   else {

+      _mesa_BindVertexArray(bitmap->ArrayObj);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);

+   }

+

+   newTex = alloc_texture(tex, width, height, texIntFormat);

+

+   /* vertex positions, texcoords, colors (after texture allocation!) */

+   {

+      const GLfloat x0 = (GLfloat) x;

+      const GLfloat y0 = (GLfloat) y;

+      const GLfloat x1 = (GLfloat) (x + width);

+      const GLfloat y1 = (GLfloat) (y + height);

+      const GLfloat z = invert_z(ctx->Current.RasterPos[2]);

+      GLuint i;

+

+      verts[0].x = x0;

+      verts[0].y = y0;

+      verts[0].z = z;

+      verts[0].s = 0.0F;

+      verts[0].t = 0.0F;

+      verts[1].x = x1;

+      verts[1].y = y0;

+      verts[1].z = z;

+      verts[1].s = tex->Sright;

+      verts[1].t = 0.0F;

+      verts[2].x = x1;

+      verts[2].y = y1;

+      verts[2].z = z;

+      verts[2].s = tex->Sright;

+      verts[2].t = tex->Ttop;

+      verts[3].x = x0;

+      verts[3].y = y1;

+      verts[3].z = z;

+      verts[3].s = 0.0F;

+      verts[3].t = tex->Ttop;

+

+      for (i = 0; i < 4; i++) {

+         verts[i].r = ctx->Current.RasterColor[0];

+         verts[i].g = ctx->Current.RasterColor[1];

+         verts[i].b = ctx->Current.RasterColor[2];

+         verts[i].a = ctx->Current.RasterColor[3];

+      }

+

+      /* upload new vertex data */

+      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);

+   }

+

+   /* choose different foreground/background alpha values */

+   CLAMPED_FLOAT_TO_UBYTE(fg, ctx->Current.RasterColor[ACOMP]);

+   bg = (fg > 127 ? 0 : 255);

+

+   bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);

+   if (!bitmap1) {

+      _mesa_meta_end(ctx);

+      return;

+   }

+

+   bitmap8 = (GLubyte *) malloc(width * height);

+   if (bitmap8) {

+      memset(bitmap8, bg, width * height);

+      _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,

+                          bitmap8, width, fg);

+

+      _mesa_set_enable(ctx, tex->Target, GL_TRUE);

+

+      _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);

+      _mesa_AlphaFunc(GL_NOTEQUAL, UBYTE_TO_FLOAT(bg));

+

+      setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,

+                            GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);

+

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+

+      _mesa_set_enable(ctx, tex->Target, GL_FALSE);

+

+      free(bitmap8);

+   }

+

+   _mesa_unmap_pbo_source(ctx, &unpackSave);

+

+   _mesa_meta_end(ctx);

+}

+

+

+/**

+ * Check if the call to _mesa_meta_GenerateMipmap() will require a

+ * software fallback.  The fallback path will require that the texture

+ * images are mapped.

+ * \return GL_TRUE if a fallback is needed, GL_FALSE otherwise

+ */

+GLboolean

+_mesa_meta_check_generate_mipmap_fallback(struct gl_context *ctx, GLenum target,

+                                          struct gl_texture_object *texObj)

+{

+   const GLuint fboSave = ctx->DrawBuffer->Name;

+   struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;

+   struct gl_texture_image *baseImage;

+   GLuint srcLevel;

+   GLenum status;

+

+   /* check for fallbacks */

+   if (!ctx->Extensions.EXT_framebuffer_object ||

+       target == GL_TEXTURE_3D) {

+      return GL_TRUE;

+   }

+

+   srcLevel = texObj->BaseLevel;

+   baseImage = _mesa_select_tex_image(ctx, texObj, target, srcLevel);

+   if (!baseImage || _mesa_is_format_compressed(baseImage->TexFormat)) {

+      return GL_TRUE;

+   }

+

+   /*

+    * Test that we can actually render in the texture's format.

+    */

+   if (!mipmap->FBO)

+      _mesa_GenFramebuffersEXT(1, &mipmap->FBO);

+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);

+

+   if (target == GL_TEXTURE_1D) {

+      _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,

+                                    GL_COLOR_ATTACHMENT0_EXT,

+                                    target, texObj->Name, srcLevel);

+   }

+#if 0

+   /* other work is needed to enable 3D mipmap generation */

+   else if (target == GL_TEXTURE_3D) {

+      GLint zoffset = 0;

+      _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,

+                                    GL_COLOR_ATTACHMENT0_EXT,

+                                    target, texObj->Name, srcLevel, zoffset);

+   }

+#endif

+   else {

+      /* 2D / cube */

+      _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

+                                    GL_COLOR_ATTACHMENT0_EXT,

+                                    target, texObj->Name, srcLevel);

+   }

+

+   status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

+

+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);

+

+   if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Called via ctx->Driver.GenerateMipmap()

+ * Note: texture borders and 3D texture support not yet complete.

+ */

+void

+_mesa_meta_GenerateMipmap(struct gl_context *ctx, GLenum target,

+                          struct gl_texture_object *texObj)

+{

+   struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;

+   struct vertex {

+      GLfloat x, y, s, t, r;

+   };

+   struct vertex verts[4];

+   const GLuint baseLevel = texObj->BaseLevel;

+   const GLuint maxLevel = texObj->MaxLevel;

+   const GLenum minFilterSave = texObj->MinFilter;

+   const GLenum magFilterSave = texObj->MagFilter;

+   const GLint maxLevelSave = texObj->MaxLevel;

+   const GLboolean genMipmapSave = texObj->GenerateMipmap;

+   const GLenum wrapSSave = texObj->WrapS;

+   const GLenum wrapTSave = texObj->WrapT;

+   const GLenum wrapRSave = texObj->WrapR;

+   const GLuint fboSave = ctx->DrawBuffer->Name;

+   const GLuint original_active_unit = ctx->Texture.CurrentUnit;

+   GLenum faceTarget;

+   GLuint dstLevel;

+   GLuint border = 0;

+

+   if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) {

+      _mesa_generate_mipmap(ctx, target, texObj);

+      return;

+   }

+

+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&

+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) {

+      faceTarget = target;

+      target = GL_TEXTURE_CUBE_MAP;

+   }

+   else {

+      faceTarget = target;

+   }

+

+   _mesa_meta_begin(ctx, META_ALL);

+

+   if (original_active_unit != 0)

+      _mesa_BindTexture(target, texObj->Name);

+

+   if (mipmap->ArrayObj == 0) {

+      /* one-time setup */

+

+      /* create vertex array object */

+      _mesa_GenVertexArraysAPPLE(1, &mipmap->ArrayObj);

+      _mesa_BindVertexArrayAPPLE(mipmap->ArrayObj);

+

+      /* create vertex array buffer */

+      _mesa_GenBuffersARB(1, &mipmap->VBO);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);

+      _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),

+                          NULL, GL_DYNAMIC_DRAW_ARB);

+

+      /* setup vertex arrays */

+      _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));

+      _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(s));

+      _mesa_EnableClientState(GL_VERTEX_ARRAY);

+      _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);

+   }

+   else {

+      _mesa_BindVertexArray(mipmap->ArrayObj);

+      _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);

+   }

+

+   if (!mipmap->FBO) {

+      _mesa_GenFramebuffersEXT(1, &mipmap->FBO);

+   }

+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);

+

+   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

+   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

+   _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

+

+   _mesa_set_enable(ctx, target, GL_TRUE);

+

+   /* setup texcoords once (XXX what about border?) */

+   switch (faceTarget) {

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+      verts[0].s = 0.0F;

+      verts[0].t = 0.0F;

+      verts[0].r = 0.0F;

+      verts[1].s = 1.0F;

+      verts[1].t = 0.0F;

+      verts[1].r = 0.0F;

+      verts[2].s = 1.0F;

+      verts[2].t = 1.0F;

+      verts[2].r = 0.0F;

+      verts[3].s = 0.0F;

+      verts[3].t = 1.0F;

+      verts[3].r = 0.0F;

+      break;

+   case GL_TEXTURE_3D:

+      abort();

+      break;

+   default:

+      /* cube face */

+      {

+         static const GLfloat st[4][2] = {

+            {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}

+         };

+         GLuint i;

+

+         /* loop over quad verts */

+         for (i = 0; i < 4; i++) {

+            /* Compute sc = +/-scale and tc = +/-scale.

+             * Not +/-1 to avoid cube face selection ambiguity near the edges,

+             * though that can still sometimes happen with this scale factor...

+             */

+            const GLfloat scale = 0.9999f;

+            const GLfloat sc = (2.0f * st[i][0] - 1.0f) * scale;

+            const GLfloat tc = (2.0f * st[i][1] - 1.0f) * scale;

+

+            switch (faceTarget) {

+            case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+               verts[i].s = 1.0f;

+               verts[i].t = -tc;

+               verts[i].r = -sc;

+               break;

+            case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+               verts[i].s = -1.0f;

+               verts[i].t = -tc;

+               verts[i].r = sc;

+               break;

+            case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+               verts[i].s = sc;

+               verts[i].t = 1.0f;

+               verts[i].r = tc;

+               break;

+            case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+               verts[i].s = sc;

+               verts[i].t = -1.0f;

+               verts[i].r = -tc;

+               break;

+            case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+               verts[i].s = sc;

+               verts[i].t = -tc;

+               verts[i].r = 1.0f;

+               break;

+            case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+               verts[i].s = -sc;

+               verts[i].t = -tc;

+               verts[i].r = -1.0f;

+               break;

+            default:

+               assert(0);

+            }

+         }

+      }

+   }

+

+   _mesa_set_enable(ctx, target, GL_TRUE);

+

+   /* setup vertex positions */

+   {

+      verts[0].x = 0.0F;

+      verts[0].y = 0.0F;

+      verts[1].x = 1.0F;

+      verts[1].y = 0.0F;

+      verts[2].x = 1.0F;

+      verts[2].y = 1.0F;

+      verts[3].x = 0.0F;

+      verts[3].y = 1.0F;

+      

+      /* upload new vertex data */

+      _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);

+   }

+

+   /* setup projection matrix */

+   _mesa_MatrixMode(GL_PROJECTION);

+   _mesa_LoadIdentity();

+   _mesa_Ortho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

+

+   /* texture is already locked, unlock now */

+   _mesa_unlock_texture(ctx, texObj);

+

+   for (dstLevel = baseLevel + 1; dstLevel <= maxLevel; dstLevel++) {

+      const struct gl_texture_image *srcImage;

+      const GLuint srcLevel = dstLevel - 1;

+      GLsizei srcWidth, srcHeight, srcDepth;

+      GLsizei dstWidth, dstHeight, dstDepth;

+      GLenum status;

+

+      srcImage = _mesa_select_tex_image(ctx, texObj, faceTarget, srcLevel);

+      assert(srcImage->Border == 0); /* XXX we can fix this */

+

+      /* src size w/out border */

+      srcWidth = srcImage->Width - 2 * border;

+      srcHeight = srcImage->Height - 2 * border;

+      srcDepth = srcImage->Depth - 2 * border;

+

+      /* new dst size w/ border */

+      dstWidth = MAX2(1, srcWidth / 2) + 2 * border;

+      dstHeight = MAX2(1, srcHeight / 2) + 2 * border;

+      dstDepth = MAX2(1, srcDepth / 2) + 2 * border;

+

+      if (dstWidth == srcImage->Width &&

+          dstHeight == srcImage->Height &&

+          dstDepth == srcImage->Depth) {

+         /* all done */

+         break;

+      }

+

+      /* Set MaxLevel large enough to hold the new level when we allocate it  */

+      _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, dstLevel);

+

+      /* Create empty dest image */

+      if (target == GL_TEXTURE_1D) {

+         _mesa_TexImage1D(target, dstLevel, srcImage->InternalFormat,

+                          dstWidth, border,

+                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);

+      }

+      else if (target == GL_TEXTURE_3D) {

+         _mesa_TexImage3D(target, dstLevel, srcImage->InternalFormat,

+                          dstWidth, dstHeight, dstDepth, border,

+                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);

+      }

+      else {

+         /* 2D or cube */

+         _mesa_TexImage2D(faceTarget, dstLevel, srcImage->InternalFormat,

+                          dstWidth, dstHeight, border,

+                          GL_RGBA, GL_UNSIGNED_BYTE, NULL);

+

+         if (target == GL_TEXTURE_CUBE_MAP) {

+            /* If texturing from a cube, we need to make sure all src faces

+             * have been defined (even if we're not sampling from them.)

+             * Otherwise the texture object will be 'incomplete' and

+             * texturing from it will not be allowed.

+             */

+            GLuint face;

+            for (face = 0; face < 6; face++) {

+               if (!texObj->Image[face][srcLevel] ||

+                   texObj->Image[face][srcLevel]->Width != srcWidth) {

+                  _mesa_TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,

+                                   srcLevel, srcImage->InternalFormat,

+                                   srcWidth, srcHeight, border,

+                                   GL_RGBA, GL_UNSIGNED_BYTE, NULL);

+               }

+            }

+         }

+      }

+

+      /* limit minification to src level */

+      _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);

+

+      /* Set to draw into the current dstLevel */

+      if (target == GL_TEXTURE_1D) {

+         _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,

+                                       GL_COLOR_ATTACHMENT0_EXT,

+                                       target,

+                                       texObj->Name,

+                                       dstLevel);

+      }

+      else if (target == GL_TEXTURE_3D) {

+         GLint zoffset = 0; /* XXX unfinished */

+         _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,

+                                       GL_COLOR_ATTACHMENT0_EXT,

+                                       target,

+                                       texObj->Name,

+                                       dstLevel, zoffset);

+      }

+      else {

+         /* 2D / cube */

+         _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,

+                                       GL_COLOR_ATTACHMENT0_EXT,

+                                       faceTarget,

+                                       texObj->Name,

+                                       dstLevel);

+      }

+

+      _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0_EXT);

+

+      /* sanity check */

+      status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);

+      if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         abort();

+         break;

+      }

+

+      assert(dstWidth == ctx->DrawBuffer->Width);

+      assert(dstHeight == ctx->DrawBuffer->Height);

+

+      /* setup viewport */

+      _mesa_set_viewport(ctx, 0, 0, dstWidth, dstHeight);

+

+      _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);

+   }

+

+   _mesa_lock_texture(ctx, texObj); /* relock */

+

+   _mesa_meta_end(ctx);

+

+   _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);

+   _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);

+   _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);

+   _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, genMipmapSave);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);

+   _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, wrapRSave);

+

+   _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);

+}

+

+

+/**

+ * Determine the GL data type to use for the temporary image read with

+ * ReadPixels() and passed to Tex[Sub]Image().

+ */

+static GLenum

+get_temp_image_type(struct gl_context *ctx, GLenum baseFormat)

+{

+   switch (baseFormat) {

+   case GL_RGBA:

+   case GL_RGB:

+   case GL_ALPHA:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+      if (ctx->DrawBuffer->Visual.redBits <= 8)

+         return GL_UNSIGNED_BYTE;

+      else if (ctx->DrawBuffer->Visual.redBits <= 8)

+         return GL_UNSIGNED_SHORT;

+      else

+         return GL_FLOAT;

+   case GL_DEPTH_COMPONENT:

+      return GL_UNSIGNED_INT;

+   case GL_DEPTH_STENCIL:

+      return GL_UNSIGNED_INT_24_8;

+   default:

+      _mesa_problem(ctx, "Unexpected format in get_temp_image_type()");

+      return 0;

+   }

+}

+

+

+/**

+ * Helper for _mesa_meta_CopyTexImage1/2D() functions.

+ * Have to be careful with locking and meta state for pixel transfer.

+ */

+static void

+copy_tex_image(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,

+               GLenum internalFormat, GLint x, GLint y,

+               GLsizei width, GLsizei height, GLint border)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GLenum format, type;

+   GLint bpp;

+   void *buf;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+

+   /* Choose format/type for temporary image buffer */

+   format = _mesa_base_tex_format(ctx, internalFormat);

+   type = get_temp_image_type(ctx, format);

+   bpp = _mesa_bytes_per_pixel(format, type);

+   if (bpp <= 0) {

+      _mesa_problem(ctx, "Bad bpp in meta copy_tex_image()");

+      return;

+   }

+

+   /*

+    * Alloc image buffer (XXX could use a PBO)

+    */

+   buf = malloc(width * height * bpp);

+   if (!buf) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);

+      return;

+   }

+

+   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */

+

+   /*

+    * Read image from framebuffer (disable pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);

+   ctx->Driver.ReadPixels(ctx, x, y, width, height,

+			  format, type, &ctx->Pack, buf);

+   _mesa_meta_end(ctx);

+

+   if (texImage->Data) {

+      ctx->Driver.FreeTexImageData(ctx, texImage);

+   }

+

+   /* The texture's format was already chosen in _mesa_CopyTexImage() */

+   ASSERT(texImage->TexFormat != MESA_FORMAT_NONE);

+

+   /*

+    * Store texture data (with pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE);

+

+   _mesa_update_state(ctx); /* to update pixel transfer state */

+

+   if (target == GL_TEXTURE_1D) {

+      ctx->Driver.TexImage1D(ctx, target, level, internalFormat,

+                             width, border, format, type,

+                             buf, &ctx->Unpack, texObj, texImage);

+   }

+   else {

+      ctx->Driver.TexImage2D(ctx, target, level, internalFormat,

+                             width, height, border, format, type,

+                             buf, &ctx->Unpack, texObj, texImage);

+   }

+   _mesa_meta_end(ctx);

+

+   _mesa_lock_texture(ctx, texObj); /* re-lock */

+

+   free(buf);

+}

+

+

+void

+_mesa_meta_CopyTexImage1D(struct gl_context *ctx, GLenum target, GLint level,

+                          GLenum internalFormat, GLint x, GLint y,

+                          GLsizei width, GLint border)

+{

+   copy_tex_image(ctx, 1, target, level, internalFormat, x, y,

+                  width, 1, border);

+}

+

+

+void

+_mesa_meta_CopyTexImage2D(struct gl_context *ctx, GLenum target, GLint level,

+                          GLenum internalFormat, GLint x, GLint y,

+                          GLsizei width, GLsizei height, GLint border)

+{

+   copy_tex_image(ctx, 2, target, level, internalFormat, x, y,

+                  width, height, border);

+}

+

+

+

+/**

+ * Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.

+ * Have to be careful with locking and meta state for pixel transfer.

+ */

+static void

+copy_tex_sub_image(struct gl_context *ctx,

+                   GLuint dims, GLenum target, GLint level,

+                   GLint xoffset, GLint yoffset, GLint zoffset,

+                   GLint x, GLint y,

+                   GLsizei width, GLsizei height)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GLenum format, type;

+   GLint bpp;

+   void *buf;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+   /* Choose format/type for temporary image buffer */

+   format = _mesa_get_format_base_format(texImage->TexFormat);

+   type = get_temp_image_type(ctx, format);

+   bpp = _mesa_bytes_per_pixel(format, type);

+   if (bpp <= 0) {

+      _mesa_problem(ctx, "Bad bpp in meta copy_tex_sub_image()");

+      return;

+   }

+

+   /*

+    * Alloc image buffer (XXX could use a PBO)

+    */

+   buf = malloc(width * height * bpp);

+   if (!buf) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage%uD", dims);

+      return;

+   }

+

+   _mesa_unlock_texture(ctx, texObj); /* need to unlock first */

+

+   /*

+    * Read image from framebuffer (disable pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);

+   ctx->Driver.ReadPixels(ctx, x, y, width, height,

+			  format, type, &ctx->Pack, buf);

+   _mesa_meta_end(ctx);

+

+   _mesa_update_state(ctx); /* to update pixel transfer state */

+

+   /*

+    * Store texture data (with pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE);

+   if (target == GL_TEXTURE_1D) {

+      ctx->Driver.TexSubImage1D(ctx, target, level, xoffset,

+                                width, format, type, buf,

+                                &ctx->Unpack, texObj, texImage);

+   }

+   else if (target == GL_TEXTURE_3D) {

+      ctx->Driver.TexSubImage3D(ctx, target, level, xoffset, yoffset, zoffset,

+                                width, height, 1, format, type, buf,

+                                &ctx->Unpack, texObj, texImage);

+   }

+   else {

+      ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,

+                                width, height, format, type, buf,

+                                &ctx->Unpack, texObj, texImage);

+   }

+   _mesa_meta_end(ctx);

+

+   _mesa_lock_texture(ctx, texObj); /* re-lock */

+

+   free(buf);

+}

+

+

+void

+_mesa_meta_CopyTexSubImage1D(struct gl_context *ctx, GLenum target, GLint level,

+                             GLint xoffset,

+                             GLint x, GLint y, GLsizei width)

+{

+   copy_tex_sub_image(ctx, 1, target, level, xoffset, 0, 0,

+                      x, y, width, 1);

+}

+

+

+void

+_mesa_meta_CopyTexSubImage2D(struct gl_context *ctx, GLenum target, GLint level,

+                             GLint xoffset, GLint yoffset,

+                             GLint x, GLint y,

+                             GLsizei width, GLsizei height)

+{

+   copy_tex_sub_image(ctx, 2, target, level, xoffset, yoffset, 0,

+                      x, y, width, height);

+}

+

+

+void

+_mesa_meta_CopyTexSubImage3D(struct gl_context *ctx, GLenum target, GLint level,

+                             GLint xoffset, GLint yoffset, GLint zoffset,

+                             GLint x, GLint y,

+                             GLsizei width, GLsizei height)

+{

+   copy_tex_sub_image(ctx, 3, target, level, xoffset, yoffset, zoffset,

+                      x, y, width, height);

+}

+

+

+void

+_mesa_meta_CopyColorTable(struct gl_context *ctx,

+                          GLenum target, GLenum internalformat,

+                          GLint x, GLint y, GLsizei width)

+{

+   GLfloat *buf;

+

+   buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));

+   if (!buf) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorTable");

+      return;

+   }

+

+   /*

+    * Read image from framebuffer (disable pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);

+   ctx->Driver.ReadPixels(ctx, x, y, width, 1,

+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);

+

+   _mesa_ColorTable(target, internalformat, width, GL_RGBA, GL_FLOAT, buf);

+

+   _mesa_meta_end(ctx);

+

+   free(buf);

+}

+

+

+void

+_mesa_meta_CopyColorSubTable(struct gl_context *ctx,GLenum target, GLsizei start,

+                             GLint x, GLint y, GLsizei width)

+{

+   GLfloat *buf;

+

+   buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));

+   if (!buf) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorSubTable");

+      return;

+   }

+

+   /*

+    * Read image from framebuffer (disable pixel transfer ops)

+    */

+   _mesa_meta_begin(ctx, META_PIXEL_STORE | META_PIXEL_TRANSFER);

+   ctx->Driver.ReadPixels(ctx, x, y, width, 1,

+                          GL_RGBA, GL_FLOAT, &ctx->Pack, buf);

+

+   _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_FLOAT, buf);

+

+   _mesa_meta_end(ctx);

+

+   free(buf);

+}

diff --git a/mesalib/src/mesa/drivers/dri/Makefile.template b/mesalib/src/mesa/drivers/dri/Makefile.template
index d1a119379..195d60a9c 100644
--- a/mesalib/src/mesa/drivers/dri/Makefile.template
+++ b/mesalib/src/mesa/drivers/dri/Makefile.template
@@ -1,111 +1,111 @@
-# -*-makefile-*-
-
-COMMON_GALLIUM_SOURCES = \
-        ../common/utils.c \
-        ../common/vblank.c \
-        ../common/dri_util.c \
-        ../common/xmlconfig.c
-
-COMMON_SOURCES = $(COMMON_GALLIUM_SOURCES) \
-        ../../common/driverfuncs.c \
-        ../common/texmem.c \
-        ../common/drirenderbuffer.c
-
-INCLUDES = $(SHARED_INCLUDES) $(EXPAT_INCLUDES)
-
-OBJECTS = $(C_SOURCES:.c=.o) \
-	  $(CXX_SOURCES:.cpp=.o) \
-	  $(ASM_SOURCES:.S=.o) 
-
-
-### Include directories
-SHARED_INCLUDES = \
-	-I. \
-	-I$(TOP)/src/mesa/drivers/dri/common \
-	-Iserver \
-	-I$(TOP)/include \
-	-I$(TOP)/src/mapi \
-	-I$(TOP)/src/mesa \
-	-I$(TOP)/src/egl/main \
-	-I$(TOP)/src/egl/drivers/dri \
-	$(LIBDRM_CFLAGS)
-
-CFLAGS += $(API_DEFINES)
-CXXFLAGS += $(API_DEFINES)
-
-##### RULES #####
-
-.c.o:
-	$(CC) -c $(INCLUDES) $(DRI_CFLAGS) $(DRIVER_DEFINES) $< -o $@
-
-.cpp.o:
-	$(CC) -c $(INCLUDES) $(DRI_CXXFLAGS) $(DRIVER_DEFINES) $< -o $@
-
-.S.o:
-	$(CC) -c $(INCLUDES) $(DRI_CFLAGS) $(DRIVER_DEFINES) $< -o $@
-
-
-##### TARGETS #####
-
-default: subdirs lib
-
-
-.PHONY: lib
-lib: symlinks subdirs depend
-	@$(MAKE) $(LIBNAME) $(TOP)/$(LIB_DIR)/$(LIBNAME)
-
-$(LIBNAME): $(OBJECTS) $(EXTRA_MODULES) $(MESA_MODULES) Makefile \
-		$(TOP)/src/mesa/drivers/dri/Makefile.template $(TOP)/src/mesa/drivers/dri/common/dri_test.o
-	$(MKLIB) -o $@.tmp -noprefix -linker '$(CXX)' -ldflags '$(LDFLAGS)' \
-		$(OBJECTS) $(EXTRA_MODULES) $(DRI_LIB_DEPS)
-	$(CXX) $(CFLAGS) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)
-	@rm -f $@.test
-	mv -f $@.tmp $@
-
-
-$(TOP)/$(LIB_DIR)/$(LIBNAME): $(LIBNAME)
-	$(INSTALL) $(LIBNAME) $(TOP)/$(LIB_DIR) 
-
-
-# If the Makefile defined SUBDIRS, run make in each
-.PHONY: subdirs
-subdirs:
-	@if test -n "$(SUBDIRS)" ; then \
-		for dir in $(SUBDIRS) ; do \
-			if [ -d $$dir ] ; then \
-				(cd $$dir && $(MAKE)) || exit 1; \
-			fi \
-		done \
-	fi
-
-
-.PHONY: symlinks
-symlinks:
-
-
-depend: $(C_SOURCES) $(CXX_SOURCES) $(ASM_SOURCES) $(SYMLINKS)
-	@ echo "running $(MKDEP)"
-	@ rm -f depend
-	@ touch depend
-	@ $(MKDEP) $(MKDEP_OPTIONS) $(DRIVER_DEFINES) $(INCLUDES) \
-		$(C_SOURCES) $(CXX_SOURCES) \
-		$(ASM_SOURCES) > /dev/null 2>/dev/null
-
-
-# Emacs tags
-tags:
-	etags `find . -name \*.[ch]` `find ../include`
-
-
-# Remove .o and backup files
-clean:
-	-rm -f *.o */*.o *~ *.so *~ server/*.o $(SYMLINKS)
-	-rm -f depend depend.bak
-
-
-install: $(LIBNAME)
-	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-	$(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
-
-
--include depend
+# -*-makefile-*-

+

+COMMON_GALLIUM_SOURCES = \

+        ../common/utils.c \

+        ../common/vblank.c \

+        ../common/dri_util.c \

+        ../common/xmlconfig.c

+

+COMMON_SOURCES = $(COMMON_GALLIUM_SOURCES) \

+        ../../common/driverfuncs.c \

+        ../common/texmem.c \

+        ../common/drirenderbuffer.c

+

+INCLUDES = $(SHARED_INCLUDES) $(EXPAT_INCLUDES)

+

+OBJECTS = $(C_SOURCES:.c=.o) \

+	  $(CXX_SOURCES:.cpp=.o) \

+	  $(ASM_SOURCES:.S=.o) 

+

+

+### Include directories

+SHARED_INCLUDES = \

+	-I. \

+	-I$(TOP)/src/mesa/drivers/dri/common \

+	-Iserver \

+	-I$(TOP)/include \

+	-I$(TOP)/src/mapi \

+	-I$(TOP)/src/mesa \

+	-I$(TOP)/src/egl/main \

+	-I$(TOP)/src/egl/drivers/dri \

+	$(LIBDRM_CFLAGS)

+

+CFLAGS += $(API_DEFINES)

+CXXFLAGS += $(API_DEFINES)

+

+##### RULES #####

+

+.c.o:

+	$(CC) -c $(INCLUDES) $(DRI_CFLAGS) $(DRIVER_DEFINES) $< -o $@

+

+.cpp.o:

+	$(CC) -c $(INCLUDES) $(DRI_CXXFLAGS) $(DRIVER_DEFINES) $< -o $@

+

+.S.o:

+	$(CC) -c $(INCLUDES) $(DRI_CFLAGS) $(DRIVER_DEFINES) $< -o $@

+

+

+##### TARGETS #####

+

+default: subdirs lib

+

+

+.PHONY: lib

+lib: symlinks subdirs depend

+	@$(MAKE) $(LIBNAME) $(TOP)/$(LIB_DIR)/$(LIBNAME)

+

+$(LIBNAME): $(OBJECTS) $(EXTRA_MODULES) $(MESA_MODULES) Makefile \

+		$(TOP)/src/mesa/drivers/dri/Makefile.template $(TOP)/src/mesa/drivers/dri/common/dri_test.o

+	$(MKLIB) -o $@.tmp -noprefix -linker '$(CXX)' -ldflags '$(LDFLAGS)' \

+		$(OBJECTS) $(EXTRA_MODULES) $(DRI_LIB_DEPS)

+	$(CXX) $(CFLAGS) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)

+	@rm -f $@.test

+	mv -f $@.tmp $@

+

+

+$(TOP)/$(LIB_DIR)/$(LIBNAME): $(LIBNAME)

+	$(INSTALL) $(LIBNAME) $(TOP)/$(LIB_DIR) 

+

+

+# If the Makefile defined SUBDIRS, run make in each

+.PHONY: subdirs

+subdirs:

+	@if test -n "$(SUBDIRS)" ; then \

+		for dir in $(SUBDIRS) ; do \

+			if [ -d $$dir ] ; then \

+				(cd $$dir && $(MAKE)) || exit 1; \

+			fi \

+		done \

+	fi

+

+

+.PHONY: symlinks

+symlinks:

+

+

+depend: $(C_SOURCES) $(CXX_SOURCES) $(ASM_SOURCES) $(SYMLINKS)

+	@ echo "running $(MKDEP)"

+	@ rm -f depend

+	@ touch depend

+	@ $(MKDEP) $(MKDEP_OPTIONS) $(DRIVER_DEFINES) $(INCLUDES) \

+		$(C_SOURCES) $(CXX_SOURCES) \

+		$(ASM_SOURCES) > /dev/null 2>/dev/null

+

+

+# Emacs tags

+tags:

+	etags `find . -name \*.[ch]` `find ../include`

+

+

+# Remove .o and backup files

+clean:

+	-rm -f *.o */*.o *~ *.so *~ server/*.o $(SYMLINKS)

+	-rm -f depend depend.bak

+

+

+install: $(LIBNAME)

+	$(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)

+	$(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)

+

+

+-include depend

diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.c b/mesalib/src/mesa/drivers/dri/common/dri_util.c
index 82638fa72..6d3dd0a2c 100644
--- a/mesalib/src/mesa/drivers/dri/common/dri_util.c
+++ b/mesalib/src/mesa/drivers/dri/common/dri_util.c
@@ -1,1030 +1,1030 @@
-/**
- * \file dri_util.c
- * DRI utility functions.
- *
- * This module acts as glue between GLX and the actual hardware driver.  A DRI
- * driver doesn't really \e have to use any of this - it's optional.  But, some
- * useful stuff is done here that otherwise would have to be duplicated in most
- * drivers.
- * 
- * Basically, these utility functions take care of some of the dirty details of
- * screen initialization, context creation, context binding, DRM setup, etc.
- *
- * These functions are compiled into each DRI driver so libGL.so knows nothing
- * about them.
- */
-
-
-#include <assert.h>
-#include <stdarg.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <stdio.h>
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void *)-1)
-#endif
-
-#include "main/imports.h"
-#define None 0
-
-#include "dri_util.h"
-#include "drm_sarea.h"
-#include "utils.h"
-#include "xmlpool.h"
-#include "../glsl/glsl_parser_extras.h"
-
-PUBLIC const char __dri2ConfigOptions[] =
-   DRI_CONF_BEGIN
-      DRI_CONF_SECTION_PERFORMANCE
-         DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1)
-      DRI_CONF_SECTION_END
-   DRI_CONF_END;
-
-static const uint __dri2NConfigOptions = 1;
-
-#ifndef GLX_OML_sync_control
-typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);
-#endif
-
-static void dri_get_drawable(__DRIdrawable *pdp);
-static void dri_put_drawable(__DRIdrawable *pdp);
-
-/**
- * This is just a token extension used to signal that the driver
- * supports setting a read drawable.
- */
-const __DRIextension driReadDrawableExtension = {
-    __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION
-};
-
-GLint
-driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )
-{
-   if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;
-   if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;
-   if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;
-   if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;
-
-   if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;
-
-   return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);
-}
-
-/*****************************************************************/
-/** \name Context (un)binding functions                          */
-/*****************************************************************/
-/*@{*/
-
-/**
- * Unbind context.
- * 
- * \param scrn the screen.
- * \param gc context.
- *
- * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
- * 
- * \internal
- * This function calls __DriverAPIRec::UnbindContext, and then decrements
- * __DRIdrawableRec::refcount which must be non-zero for a successful
- * return.
- * 
- * While casting the opaque private pointers associated with the parameters
- * into their respective real types it also assures they are not \c NULL. 
- */
-static int driUnbindContext(__DRIcontext *pcp)
-{
-    __DRIscreen *psp;
-    __DRIdrawable *pdp;
-    __DRIdrawable *prp;
-
-    /*
-    ** Assume error checking is done properly in glXMakeCurrent before
-    ** calling driUnbindContext.
-    */
-
-    if (pcp == NULL)
-        return GL_FALSE;
-
-    psp = pcp->driScreenPriv;
-    pdp = pcp->driDrawablePriv;
-    prp = pcp->driReadablePriv;
-
-    /* already unbound */
-    if (!pdp && !prp)
-      return GL_TRUE;
-    /* Let driver unbind drawable from context */
-    (*psp->DriverAPI.UnbindContext)(pcp);
-
-    assert(pdp);
-    if (pdp->refcount == 0) {
-	/* ERROR!!! */
-	return GL_FALSE;
-    }
-
-    dri_put_drawable(pdp);
-
-    if (prp != pdp) {
-        if (prp->refcount == 0) {
-	    /* ERROR!!! */
-	    return GL_FALSE;
-	}
-
-    	dri_put_drawable(prp);
-    }
-
-
-    /* XXX this is disabled so that if we call SwapBuffers on an unbound
-     * window we can determine the last context bound to the window and
-     * use that context's lock. (BrianP, 2-Dec-2000)
-     */
-    pcp->driDrawablePriv = pcp->driReadablePriv = NULL;
-
-    return GL_TRUE;
-}
-
-/**
- * This function takes both a read buffer and a draw buffer.  This is needed
- * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
- * function.
- */
-static int driBindContext(__DRIcontext *pcp,
-			  __DRIdrawable *pdp,
-			  __DRIdrawable *prp)
-{
-    __DRIscreen *psp = NULL;
-
-    /*
-    ** Assume error checking is done properly in glXMakeCurrent before
-    ** calling driUnbindContext.
-    */
-
-    if (!pcp)
-	return GL_FALSE;
-
-    /* Bind the drawable to the context */
-    psp = pcp->driScreenPriv;
-    pcp->driDrawablePriv = pdp;
-    pcp->driReadablePriv = prp;
-    if (pdp) {
-	pdp->driContextPriv = pcp;
-	dri_get_drawable(pdp);
-    }
-    if (prp && pdp != prp) {
-	dri_get_drawable(prp);
-    }
-
-    /*
-    ** Now that we have a context associated with this drawable, we can
-    ** initialize the drawable information if has not been done before.
-    */
-
-    if (!psp->dri2.enabled) {
-	if (pdp && !pdp->pStamp) {
-	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-	    __driUtilUpdateDrawableInfo(pdp);
-	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-	}
-	if (prp && pdp != prp && !prp->pStamp) {
-	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-	    __driUtilUpdateDrawableInfo(prp);
-	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-        }
-    }
-
-    /* Call device-specific MakeCurrent */
-    return (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
-}
-
-/*@}*/
-
-
-/*****************************************************************/
-/** \name Drawable handling functions                            */
-/*****************************************************************/
-/*@{*/
-
-/**
- * Update private drawable information.
- *
- * \param pdp pointer to the private drawable information to update.
- * 
- * This function basically updates the __DRIdrawable struct's
- * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
- * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
- * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
- * the values are different that means we have to update the clipping
- * info.
- */
-void
-__driUtilUpdateDrawableInfo(__DRIdrawable *pdp)
-{
-    __DRIscreen *psp = pdp->driScreenPriv;
-    __DRIcontext *pcp = pdp->driContextPriv;
-    
-    if (!pcp 
-	|| ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {
-	/* ERROR!!! 
-	 * ...but we must ignore it. There can be many contexts bound to a
-	 * drawable.
-	 */
-    }
-
-    if (pdp->pClipRects) {
-	free(pdp->pClipRects); 
-	pdp->pClipRects = NULL;
-    }
-
-    if (pdp->pBackClipRects) {
-	free(pdp->pBackClipRects); 
-	pdp->pBackClipRects = NULL;
-    }
-
-    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-
-    if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,
-			  &pdp->index, &pdp->lastStamp,
-			  &pdp->x, &pdp->y, &pdp->w, &pdp->h,
-			  &pdp->numClipRects, &pdp->pClipRects,
-			  &pdp->backX,
-			  &pdp->backY,
-			  &pdp->numBackClipRects,
-			  &pdp->pBackClipRects,
-			  pdp->loaderPrivate)) {
-	/* Error -- eg the window may have been destroyed.  Keep going
-	 * with no cliprects.
-	 */
-        pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
-	pdp->numClipRects = 0;
-	pdp->pClipRects = NULL;
-	pdp->numBackClipRects = 0;
-	pdp->pBackClipRects = NULL;
-    }
-    else
-       pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
-
-    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-}
-
-/*@}*/
-
-/*****************************************************************/
-/** \name GLX callbacks                                          */
-/*****************************************************************/
-/*@{*/
-
-static void driReportDamage(__DRIdrawable *pdp,
-			    struct drm_clip_rect *pClipRects, int numClipRects)
-{
-    __DRIscreen *psp = pdp->driScreenPriv;
-
-    /* Check that we actually have the new damage report method */
-    if (psp->damage) {
-	/* Report the damage.  Currently, all our drivers draw
-	 * directly to the front buffer, so we report the damage there
-	 * rather than to the backing storein (if any).
-	 */
-	(*psp->damage->reportDamage)(pdp,
-				     pdp->x, pdp->y,
-				     pClipRects, numClipRects,
-				     GL_TRUE, pdp->loaderPrivate);
-    }
-}
-
-
-/**
- * Swap buffers.
- *
- * \param drawablePrivate opaque pointer to the per-drawable private info.
- * 
- * \internal
- * This function calls __DRIdrawable::swapBuffers.
- * 
- * Is called directly from glXSwapBuffers().
- */
-static void driSwapBuffers(__DRIdrawable *dPriv)
-{
-    __DRIscreen *psp = dPriv->driScreenPriv;
-    drm_clip_rect_t *rects;
-    int i;
-
-    psp->DriverAPI.SwapBuffers(dPriv);
-
-    if (!dPriv->numClipRects)
-        return;
-
-    rects = malloc(sizeof(*rects) * dPriv->numClipRects);
-
-    if (!rects)
-        return;
-
-    for (i = 0; i < dPriv->numClipRects; i++) {
-        rects[i].x1 = dPriv->pClipRects[i].x1 - dPriv->x;
-        rects[i].y1 = dPriv->pClipRects[i].y1 - dPriv->y;
-        rects[i].x2 = dPriv->pClipRects[i].x2 - dPriv->x;
-        rects[i].y2 = dPriv->pClipRects[i].y2 - dPriv->y;
-    }
-
-    driReportDamage(dPriv, rects, dPriv->numClipRects);
-    free(rects);
-}
-
-static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,
-			      int64_t *msc )
-{
-    return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);
-}
-
-
-static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,
-			 int64_t divisor, int64_t remainder,
-			 int64_t * msc, int64_t * sbc)
-{
-    __DRIswapInfo  sInfo;
-    int  status;
-
-    status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
-                                                         divisor, remainder,
-                                                         msc );
-
-    /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
-     * is supported but GLX_OML_sync_control is not.  Therefore, don't return
-     * an error value if GetSwapInfo() is not implemented.
-    */
-    if ( status == 0
-         && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
-        status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
-        *sbc = sInfo.swap_count;
-    }
-
-    return status;
-}
-
-
-const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {
-    { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },
-    driWaitForMSC,
-    driDrawableGetMSC,
-};
-
-
-static void driCopySubBuffer(__DRIdrawable *dPriv,
-			      int x, int y, int w, int h)
-{
-    drm_clip_rect_t rect;
-
-    rect.x1 = x;
-    rect.y1 = dPriv->h - y - h;
-    rect.x2 = x + w;
-    rect.y2 = rect.y1 + h;
-    driReportDamage(dPriv, &rect, 1);
-
-    dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
-}
-
-const __DRIcopySubBufferExtension driCopySubBufferExtension = {
-    { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },
-    driCopySubBuffer
-};
-
-static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)
-{
-    dPriv->swap_interval = interval;
-}
-
-static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)
-{
-    return dPriv->swap_interval;
-}
-
-const __DRIswapControlExtension driSwapControlExtension = {
-    { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },
-    driSetSwapInterval,
-    driGetSwapInterval
-};
-
-
-/**
- * This is called via __DRIscreenRec's createNewDrawable pointer.
- */
-static __DRIdrawable *
-driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,
-		     drm_drawable_t hwDrawable, int renderType,
-		     const int *attrs, void *data)
-{
-    __DRIdrawable *pdp;
-
-    /* Since pbuffers are not yet supported, no drawable attributes are
-     * supported either.
-     */
-    (void) attrs;
-
-    pdp = malloc(sizeof *pdp);
-    if (!pdp) {
-	return NULL;
-    }
-
-    pdp->driContextPriv = NULL;
-    pdp->loaderPrivate = data;
-    pdp->hHWDrawable = hwDrawable;
-    pdp->refcount = 1;
-    pdp->pStamp = NULL;
-    pdp->lastStamp = 0;
-    pdp->index = 0;
-    pdp->x = 0;
-    pdp->y = 0;
-    pdp->w = 0;
-    pdp->h = 0;
-    pdp->numClipRects = 0;
-    pdp->numBackClipRects = 0;
-    pdp->pClipRects = NULL;
-    pdp->pBackClipRects = NULL;
-    pdp->vblSeq = 0;
-    pdp->vblFlags = 0;
-
-    pdp->driScreenPriv = psp;
-
-    if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes, 0)) {
-       free(pdp);
-       return NULL;
-    }
-
-    pdp->msc_base = 0;
-
-    /* This special default value is replaced with the configured
-     * default value when the drawable is first bound to a direct
-     * rendering context. 
-     */
-    pdp->swap_interval = (unsigned)-1;
-
-    return pdp;
-}
-
-
-static __DRIdrawable *
-dri2CreateNewDrawable(__DRIscreen *screen,
-		      const __DRIconfig *config,
-		      void *loaderPrivate)
-{
-    __DRIdrawable *pdraw;
-
-    pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);
-    if (!pdraw)
-    	return NULL;
-
-    pdraw->pClipRects = &pdraw->dri2.clipRect;
-    pdraw->pBackClipRects = &pdraw->dri2.clipRect;
-
-    pdraw->pStamp = &pdraw->dri2.stamp;
-    *pdraw->pStamp = pdraw->lastStamp + 1;
-
-    return pdraw;
-}
-
-static __DRIbuffer *
-dri2AllocateBuffer(__DRIscreen *screen,
-		   unsigned int attachment, unsigned int format,
-		   int width, int height)
-{
-    return (*screen->DriverAPI.AllocateBuffer)(screen, attachment, format,
-					       width, height);
-}
-
-static void
-dri2ReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)
-{
-   (*screen->DriverAPI.ReleaseBuffer)(screen, buffer);
-}
-
-
-static int
-dri2ConfigQueryb(__DRIscreen *screen, const char *var, GLboolean *val)
-{
-   if (!driCheckOption(&screen->optionCache, var, DRI_BOOL))
-      return -1;
-
-   *val = driQueryOptionb(&screen->optionCache, var);
-
-   return 0;
-}
-
-static int
-dri2ConfigQueryi(__DRIscreen *screen, const char *var, GLint *val)
-{
-   if (!driCheckOption(&screen->optionCache, var, DRI_INT) &&
-       !driCheckOption(&screen->optionCache, var, DRI_ENUM))
-      return -1;
-
-    *val = driQueryOptioni(&screen->optionCache, var);
-
-    return 0;
-}
-
-static int
-dri2ConfigQueryf(__DRIscreen *screen, const char *var, GLfloat *val)
-{
-   if (!driCheckOption(&screen->optionCache, var, DRI_FLOAT))
-      return -1;
-
-    *val = driQueryOptionf(&screen->optionCache, var);
-
-    return 0;
-}
-
-
-static void dri_get_drawable(__DRIdrawable *pdp)
-{
-    pdp->refcount++;
-}
-	
-static void dri_put_drawable(__DRIdrawable *pdp)
-{
-    __DRIscreen *psp;
-
-    if (pdp) {
-	pdp->refcount--;
-	if (pdp->refcount)
-	    return;
-
-	psp = pdp->driScreenPriv;
-        (*psp->DriverAPI.DestroyBuffer)(pdp);
-	if (pdp->pClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {
-	    free(pdp->pClipRects);
-	    pdp->pClipRects = NULL;
-	}
-	if (pdp->pBackClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {
-	    free(pdp->pBackClipRects);
-	    pdp->pBackClipRects = NULL;
-	}
-	free(pdp);
-    }
-}
-
-static void
-driDestroyDrawable(__DRIdrawable *pdp)
-{
-    dri_put_drawable(pdp);
-}
-
-/*@}*/
-
-
-/*****************************************************************/
-/** \name Context handling functions                             */
-/*****************************************************************/
-/*@{*/
-
-/**
- * Destroy the per-context private information.
- * 
- * \internal
- * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
- * drmDestroyContext(), and finally frees \p contextPrivate.
- */
-static void
-driDestroyContext(__DRIcontext *pcp)
-{
-    if (pcp) {
-	(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
-	free(pcp);
-    }
-}
-
-
-/**
- * Create the per-drawable private driver information.
- * 
- * \param render_type   Type of rendering target.  \c GLX_RGBA is the only
- *                      type likely to ever be supported for direct-rendering.
- * \param shared        Context with which to share textures, etc. or NULL
- *
- * \returns An opaque pointer to the per-context private information on
- *          success, or \c NULL on failure.
- * 
- * \internal
- * This function allocates and fills a __DRIcontextRec structure.  It
- * performs some device independent initialization and passes all the
- * relevent information to __DriverAPIRec::CreateContext to create the
- * context.
- *
- */
-static __DRIcontext *
-driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,
-		    int render_type, __DRIcontext *shared, 
-		    drm_context_t hwContext, void *data)
-{
-    __DRIcontext *pcp;
-    void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
-
-    pcp = malloc(sizeof *pcp);
-    if (!pcp)
-	return NULL;
-
-    pcp->driScreenPriv = psp;
-    pcp->driDrawablePriv = NULL;
-    pcp->loaderPrivate = data;
-    
-    pcp->dri2.draw_stamp = 0;
-    pcp->dri2.read_stamp = 0;
-
-    pcp->hHWContext = hwContext;
-
-    if ( !(*psp->DriverAPI.CreateContext)(API_OPENGL,
-					  &config->modes, pcp, shareCtx) ) {
-        free(pcp);
-        return NULL;
-    }
-
-    return pcp;
-}
-
-static unsigned int
-dri2GetAPIMask(__DRIscreen *screen)
-{
-    return screen->api_mask;
-}
-
-static __DRIcontext *
-dri2CreateNewContextForAPI(__DRIscreen *screen, int api,
-			   const __DRIconfig *config,
-			   __DRIcontext *shared, void *data)
-{
-    __DRIcontext *context;
-    const struct gl_config *modes = (config != NULL) ? &config->modes : NULL;
-    void *shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
-    gl_api mesa_api;
-
-    if (!(screen->api_mask & (1 << api)))
-	return NULL;
-
-    switch (api) {
-    case __DRI_API_OPENGL:
-	    mesa_api = API_OPENGL;
-	    break;
-    case __DRI_API_GLES:
-	    mesa_api = API_OPENGLES;
-	    break;
-    case __DRI_API_GLES2:
-	    mesa_api = API_OPENGLES2;
-	    break;
-    default:
-	    return NULL;
-    }
-
-    context = malloc(sizeof *context);
-    if (!context)
-	return NULL;
-
-    context->driScreenPriv = screen;
-    context->driDrawablePriv = NULL;
-    context->loaderPrivate = data;
-    
-    if (!(*screen->DriverAPI.CreateContext)(mesa_api, modes,
-					    context, shareCtx) ) {
-        free(context);
-        return NULL;
-    }
-
-    return context;
-}
-
-
-static __DRIcontext *
-dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,
-		      __DRIcontext *shared, void *data)
-{
-   return dri2CreateNewContextForAPI(screen, __DRI_API_OPENGL,
-				     config, shared, data);
-}
-
-static int
-driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)
-{
-    return GL_FALSE;
-}
-
-/*@}*/
-
-
-/*****************************************************************/
-/** \name Screen handling functions                              */
-/*****************************************************************/
-/*@{*/
-
-/**
- * Destroy the per-screen private information.
- * 
- * \internal
- * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
- * drmClose(), and finally frees \p screenPrivate.
- */
-static void driDestroyScreen(__DRIscreen *psp)
-{
-    if (psp) {
-	/* No interaction with the X-server is possible at this point.  This
-	 * routine is called after XCloseDisplay, so there is no protocol
-	 * stream open to the X-server anymore.
-	 */
-
-       _mesa_destroy_shader_compiler();
-
-	if (psp->DriverAPI.DestroyScreen)
-	    (*psp->DriverAPI.DestroyScreen)(psp);
-
-	if (!psp->dri2.enabled) {
-	   (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
-	   (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
-	   (void)drmCloseOnce(psp->fd);
-	} else {
-	   driDestroyOptionCache(&psp->optionCache);
-	   driDestroyOptionInfo(&psp->optionInfo);
-	}
-
-	free(psp);
-    }
-}
-
-static void
-setupLoaderExtensions(__DRIscreen *psp,
-		      const __DRIextension **extensions)
-{
-    int i;
-
-    for (i = 0; extensions[i]; i++) {
-	if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)
-	    psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];
-	if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)
-	    psp->damage = (__DRIdamageExtension *) extensions[i];
-	if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)
-	    psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];
-	if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)
-	    psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];
-	if (strcmp(extensions[i]->name, __DRI_IMAGE_LOOKUP) == 0)
-	    psp->dri2.image = (__DRIimageLookupExtension *) extensions[i];
-	if (strcmp(extensions[i]->name, __DRI_USE_INVALIDATE) == 0)
-	    psp->dri2.useInvalidate = (__DRIuseInvalidateExtension *) extensions[i];
-    }
-}
-
-/**
- * This is the bootstrap function for the driver.  libGL supplies all of the
- * requisite information about the system, and the driver initializes itself.
- * This routine also fills in the linked list pointed to by \c driver_modes
- * with the \c struct gl_config that the driver can support for windows or
- * pbuffers.
- *
- * For legacy DRI.
- * 
- * \param scrn  Index of the screen
- * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
- *                    all drivers.
- * \param dri_version Version of the "server-side" DRI.
- * \param drm_version Version of the kernel DRM.
- * \param frame_buffer Data describing the location and layout of the
- *                     framebuffer.
- * \param pSAREA       Pointer to the SAREA.
- * \param fd           Device handle for the DRM.
- * \param extensions   ??
- * \param driver_modes  Returns modes suppoted by the driver
- * \param loaderPrivate  ??
- * 
- * \note There is no need to check the minimum API version in this
- * function.  Since the name of this function is versioned, it is
- * impossible for a loader that is too old to even load this driver.
- */
-static __DRIscreen *
-driCreateNewScreen(int scrn,
-		   const __DRIversion *ddx_version,
-		   const __DRIversion *dri_version,
-		   const __DRIversion *drm_version,
-		   const __DRIframebuffer *frame_buffer,
-		   drmAddress pSAREA, int fd, 
-		   const __DRIextension **extensions,
-		   const __DRIconfig ***driver_modes,
-		   void *loaderPrivate)
-{
-    static const __DRIextension *emptyExtensionList[] = { NULL };
-    __DRIscreen *psp;
-
-    if (driDriverAPI.InitScreen == NULL)
-	return NULL;
-
-    psp = calloc(1, sizeof *psp);
-    if (!psp)
-	return NULL;
-
-    setupLoaderExtensions(psp, extensions);
-
-    /*
-    ** NOT_DONE: This is used by the X server to detect when the client
-    ** has died while holding the drawable lock.  The client sets the
-    ** drawable lock to this value.
-    */
-    psp->drawLockID = 1;
-
-    psp->drm_version = *drm_version;
-    psp->ddx_version = *ddx_version;
-    psp->dri_version = *dri_version;
-
-    psp->pSAREA = pSAREA;
-    psp->lock = (drmLock *) &psp->pSAREA->lock;
-
-    psp->pFB = frame_buffer->base;
-    psp->fbSize = frame_buffer->size;
-    psp->fbStride = frame_buffer->stride;
-    psp->fbWidth = frame_buffer->width;
-    psp->fbHeight = frame_buffer->height;
-    psp->devPrivSize = frame_buffer->dev_priv_size;
-    psp->pDevPriv = frame_buffer->dev_priv;
-    psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
-
-    psp->extensions = emptyExtensionList;
-    psp->fd = fd;
-    psp->myNum = scrn;
-    psp->dri2.enabled = GL_FALSE;
-
-    psp->DriverAPI = driDriverAPI;
-    psp->api_mask = (1 << __DRI_API_OPENGL);
-
-    *driver_modes = driDriverAPI.InitScreen(psp);
-    if (*driver_modes == NULL) {
-	free(psp);
-	return NULL;
-    }
-
-    return psp;
-}
-
-/**
- * DRI2
- */
-static __DRIscreen *
-dri2CreateNewScreen(int scrn, int fd,
-		    const __DRIextension **extensions,
-		    const __DRIconfig ***driver_configs, void *data)
-{
-    static const __DRIextension *emptyExtensionList[] = { NULL };
-    __DRIscreen *psp;
-    drmVersionPtr version;
-
-    if (driDriverAPI.InitScreen2 == NULL)
-        return NULL;
-
-    psp = calloc(1, sizeof(*psp));
-    if (!psp)
-	return NULL;
-
-    setupLoaderExtensions(psp, extensions);
-
-    version = drmGetVersion(fd);
-    if (version) {
-	psp->drm_version.major = version->version_major;
-	psp->drm_version.minor = version->version_minor;
-	psp->drm_version.patch = version->version_patchlevel;
-	drmFreeVersion(version);
-    }
-
-    psp->extensions = emptyExtensionList;
-    psp->fd = fd;
-    psp->myNum = scrn;
-    psp->dri2.enabled = GL_TRUE;
-
-    psp->DriverAPI = driDriverAPI;
-    psp->api_mask = (1 << __DRI_API_OPENGL);
-    *driver_configs = driDriverAPI.InitScreen2(psp);
-    if (*driver_configs == NULL) {
-	free(psp);
-	return NULL;
-    }
-
-    psp->DriverAPI = driDriverAPI;
-    psp->loaderPrivate = data;
-
-    driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions,
-		       __dri2NConfigOptions);
-    driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum,
-			"dri2");
-
-    return psp;
-}
-
-static const __DRIextension **driGetExtensions(__DRIscreen *psp)
-{
-    return psp->extensions;
-}
-
-/** Core interface */
-const __DRIcoreExtension driCoreExtension = {
-    { __DRI_CORE, __DRI_CORE_VERSION },
-    NULL,
-    driDestroyScreen,
-    driGetExtensions,
-    driGetConfigAttrib,
-    driIndexConfigAttrib,
-    NULL,
-    driDestroyDrawable,
-    driSwapBuffers,
-    NULL,
-    driCopyContext,
-    driDestroyContext,
-    driBindContext,
-    driUnbindContext
-};
-
-/** Legacy DRI interface */
-const __DRIlegacyExtension driLegacyExtension = {
-    { __DRI_LEGACY, __DRI_LEGACY_VERSION },
-    driCreateNewScreen,
-    driCreateNewDrawable,
-    driCreateNewContext,
-};
-
-/** DRI2 interface */
-const __DRIdri2Extension driDRI2Extension = {
-    { __DRI_DRI2, __DRI_DRI2_VERSION },
-    dri2CreateNewScreen,
-    dri2CreateNewDrawable,
-    dri2CreateNewContext,
-    dri2GetAPIMask,
-    dri2CreateNewContextForAPI,
-    dri2AllocateBuffer,
-    dri2ReleaseBuffer
-};
-
-const __DRI2configQueryExtension dri2ConfigQueryExtension = {
-   { __DRI2_CONFIG_QUERY, __DRI2_CONFIG_QUERY_VERSION },
-   dri2ConfigQueryb,
-   dri2ConfigQueryi,
-   dri2ConfigQueryf,
-};
-
-/**
- * Calculate amount of swap interval used between GLX buffer swaps.
- * 
- * The usage value, on the range [0,max], is the fraction of total swap
- * interval time used between GLX buffer swaps is calculated.
- *
- *            \f$p = t_d / (i * t_r)\f$
- * 
- * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
- * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
- * required for a single vertical refresh period (as returned by \c
- * glXGetMscRateOML).
- * 
- * See the documentation for the GLX_MESA_swap_frame_usage extension for more
- * details.
- *
- * \param   dPriv  Pointer to the private drawable structure.
- * \return  If less than a single swap interval time period was required
- *          between GLX buffer swaps, a number greater than 0 and less than
- *          1.0 is returned.  If exactly one swap interval time period is
- *          required, 1.0 is returned, and if more than one is required then
- *          a number greater than 1.0 will be returned.
- *
- * \sa glXSwapIntervalSGI glXGetMscRateOML
- * 
- * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
- *       be possible to cache the sync rate?
- */
-float
-driCalculateSwapUsage( __DRIdrawable *dPriv, int64_t last_swap_ust,
-		       int64_t current_ust )
-{
-   int32_t   n;
-   int32_t   d;
-   int       interval;
-   float     usage = 1.0;
-   __DRIscreen *psp = dPriv->driScreenPriv;
-
-   if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {
-      interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;
-
-
-      /* We want to calculate
-       * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
-       * current_UST by calling __glXGetUST.  last_swap_UST is stored in
-       * dPriv->swap_ust.  interval has already been calculated.
-       *
-       * The only tricky part is us_per_refresh.  us_per_refresh is
-       * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
-       * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
-       * the denominator of the final calculation, we calculate
-       * (interval * 1000000 * d) and move n into the numerator.
-       */
-
-      usage = (current_ust - last_swap_ust);
-      usage *= n;
-      usage /= (interval * d);
-      usage /= 1000000.0;
-   }
-   
-   return usage;
-}
-
-void
-dri2InvalidateDrawable(__DRIdrawable *drawable)
-{
-    drawable->dri2.stamp++;
-}
-
-/*@}*/
+/**

+ * \file dri_util.c

+ * DRI utility functions.

+ *

+ * This module acts as glue between GLX and the actual hardware driver.  A DRI

+ * driver doesn't really \e have to use any of this - it's optional.  But, some

+ * useful stuff is done here that otherwise would have to be duplicated in most

+ * drivers.

+ * 

+ * Basically, these utility functions take care of some of the dirty details of

+ * screen initialization, context creation, context binding, DRM setup, etc.

+ *

+ * These functions are compiled into each DRI driver so libGL.so knows nothing

+ * about them.

+ */

+

+

+#include <assert.h>

+#include <stdarg.h>

+#include <unistd.h>

+#include <sys/mman.h>

+#include <stdio.h>

+

+#ifndef MAP_FAILED

+#define MAP_FAILED ((void *)-1)

+#endif

+

+#include "main/imports.h"

+#define None 0

+

+#include "dri_util.h"

+#include "drm_sarea.h"

+#include "utils.h"

+#include "xmlpool.h"

+#include "../glsl/glsl_parser_extras.h"

+

+PUBLIC const char __dri2ConfigOptions[] =

+   DRI_CONF_BEGIN

+      DRI_CONF_SECTION_PERFORMANCE

+         DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1)

+      DRI_CONF_SECTION_END

+   DRI_CONF_END;

+

+static const uint __dri2NConfigOptions = 1;

+

+#ifndef GLX_OML_sync_control

+typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);

+#endif

+

+static void dri_get_drawable(__DRIdrawable *pdp);

+static void dri_put_drawable(__DRIdrawable *pdp);

+

+/**

+ * This is just a token extension used to signal that the driver

+ * supports setting a read drawable.

+ */

+const __DRIextension driReadDrawableExtension = {

+    __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION

+};

+

+GLint

+driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )

+{

+   if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;

+   if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;

+   if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;

+   if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;

+

+   if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;

+

+   return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);

+}

+

+/*****************************************************************/

+/** \name Context (un)binding functions                          */

+/*****************************************************************/

+/*@{*/

+

+/**

+ * Unbind context.

+ * 

+ * \param scrn the screen.

+ * \param gc context.

+ *

+ * \return \c GL_TRUE on success, or \c GL_FALSE on failure.

+ * 

+ * \internal

+ * This function calls __DriverAPIRec::UnbindContext, and then decrements

+ * __DRIdrawableRec::refcount which must be non-zero for a successful

+ * return.

+ * 

+ * While casting the opaque private pointers associated with the parameters

+ * into their respective real types it also assures they are not \c NULL. 

+ */

+static int driUnbindContext(__DRIcontext *pcp)

+{

+    __DRIscreen *psp;

+    __DRIdrawable *pdp;

+    __DRIdrawable *prp;

+

+    /*

+    ** Assume error checking is done properly in glXMakeCurrent before

+    ** calling driUnbindContext.

+    */

+

+    if (pcp == NULL)

+        return GL_FALSE;

+

+    psp = pcp->driScreenPriv;

+    pdp = pcp->driDrawablePriv;

+    prp = pcp->driReadablePriv;

+

+    /* already unbound */

+    if (!pdp && !prp)

+      return GL_TRUE;

+    /* Let driver unbind drawable from context */

+    (*psp->DriverAPI.UnbindContext)(pcp);

+

+    assert(pdp);

+    if (pdp->refcount == 0) {

+	/* ERROR!!! */

+	return GL_FALSE;

+    }

+

+    dri_put_drawable(pdp);

+

+    if (prp != pdp) {

+        if (prp->refcount == 0) {

+	    /* ERROR!!! */

+	    return GL_FALSE;

+	}

+

+    	dri_put_drawable(prp);

+    }

+

+

+    /* XXX this is disabled so that if we call SwapBuffers on an unbound

+     * window we can determine the last context bound to the window and

+     * use that context's lock. (BrianP, 2-Dec-2000)

+     */

+    pcp->driDrawablePriv = pcp->driReadablePriv = NULL;

+

+    return GL_TRUE;

+}

+

+/**

+ * This function takes both a read buffer and a draw buffer.  This is needed

+ * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent

+ * function.

+ */

+static int driBindContext(__DRIcontext *pcp,

+			  __DRIdrawable *pdp,

+			  __DRIdrawable *prp)

+{

+    __DRIscreen *psp = NULL;

+

+    /*

+    ** Assume error checking is done properly in glXMakeCurrent before

+    ** calling driUnbindContext.

+    */

+

+    if (!pcp)

+	return GL_FALSE;

+

+    /* Bind the drawable to the context */

+    psp = pcp->driScreenPriv;

+    pcp->driDrawablePriv = pdp;

+    pcp->driReadablePriv = prp;

+    if (pdp) {

+	pdp->driContextPriv = pcp;

+	dri_get_drawable(pdp);

+    }

+    if (prp && pdp != prp) {

+	dri_get_drawable(prp);

+    }

+

+    /*

+    ** Now that we have a context associated with this drawable, we can

+    ** initialize the drawable information if has not been done before.

+    */

+

+    if (!psp->dri2.enabled) {

+	if (pdp && !pdp->pStamp) {

+	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+	    __driUtilUpdateDrawableInfo(pdp);

+	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+	}

+	if (prp && pdp != prp && !prp->pStamp) {

+	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+	    __driUtilUpdateDrawableInfo(prp);

+	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+        }

+    }

+

+    /* Call device-specific MakeCurrent */

+    return (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);

+}

+

+/*@}*/

+

+

+/*****************************************************************/

+/** \name Drawable handling functions                            */

+/*****************************************************************/

+/*@{*/

+

+/**

+ * Update private drawable information.

+ *

+ * \param pdp pointer to the private drawable information to update.

+ * 

+ * This function basically updates the __DRIdrawable struct's

+ * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.

+ * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which

+ * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If

+ * the values are different that means we have to update the clipping

+ * info.

+ */

+void

+__driUtilUpdateDrawableInfo(__DRIdrawable *pdp)

+{

+    __DRIscreen *psp = pdp->driScreenPriv;

+    __DRIcontext *pcp = pdp->driContextPriv;

+    

+    if (!pcp 

+	|| ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {

+	/* ERROR!!! 

+	 * ...but we must ignore it. There can be many contexts bound to a

+	 * drawable.

+	 */

+    }

+

+    if (pdp->pClipRects) {

+	free(pdp->pClipRects); 

+	pdp->pClipRects = NULL;

+    }

+

+    if (pdp->pBackClipRects) {

+	free(pdp->pBackClipRects); 

+	pdp->pBackClipRects = NULL;

+    }

+

+    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+

+    if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,

+			  &pdp->index, &pdp->lastStamp,

+			  &pdp->x, &pdp->y, &pdp->w, &pdp->h,

+			  &pdp->numClipRects, &pdp->pClipRects,

+			  &pdp->backX,

+			  &pdp->backY,

+			  &pdp->numBackClipRects,

+			  &pdp->pBackClipRects,

+			  pdp->loaderPrivate)) {

+	/* Error -- eg the window may have been destroyed.  Keep going

+	 * with no cliprects.

+	 */

+        pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */

+	pdp->numClipRects = 0;

+	pdp->pClipRects = NULL;

+	pdp->numBackClipRects = 0;

+	pdp->pBackClipRects = NULL;

+    }

+    else

+       pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);

+

+    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

+}

+

+/*@}*/

+

+/*****************************************************************/

+/** \name GLX callbacks                                          */

+/*****************************************************************/

+/*@{*/

+

+static void driReportDamage(__DRIdrawable *pdp,

+			    struct drm_clip_rect *pClipRects, int numClipRects)

+{

+    __DRIscreen *psp = pdp->driScreenPriv;

+

+    /* Check that we actually have the new damage report method */

+    if (psp->damage) {

+	/* Report the damage.  Currently, all our drivers draw

+	 * directly to the front buffer, so we report the damage there

+	 * rather than to the backing storein (if any).

+	 */

+	(*psp->damage->reportDamage)(pdp,

+				     pdp->x, pdp->y,

+				     pClipRects, numClipRects,

+				     GL_TRUE, pdp->loaderPrivate);

+    }

+}

+

+

+/**

+ * Swap buffers.

+ *

+ * \param drawablePrivate opaque pointer to the per-drawable private info.

+ * 

+ * \internal

+ * This function calls __DRIdrawable::swapBuffers.

+ * 

+ * Is called directly from glXSwapBuffers().

+ */

+static void driSwapBuffers(__DRIdrawable *dPriv)

+{

+    __DRIscreen *psp = dPriv->driScreenPriv;

+    drm_clip_rect_t *rects;

+    int i;

+

+    psp->DriverAPI.SwapBuffers(dPriv);

+

+    if (!dPriv->numClipRects)

+        return;

+

+    rects = malloc(sizeof(*rects) * dPriv->numClipRects);

+

+    if (!rects)

+        return;

+

+    for (i = 0; i < dPriv->numClipRects; i++) {

+        rects[i].x1 = dPriv->pClipRects[i].x1 - dPriv->x;

+        rects[i].y1 = dPriv->pClipRects[i].y1 - dPriv->y;

+        rects[i].x2 = dPriv->pClipRects[i].x2 - dPriv->x;

+        rects[i].y2 = dPriv->pClipRects[i].y2 - dPriv->y;

+    }

+

+    driReportDamage(dPriv, rects, dPriv->numClipRects);

+    free(rects);

+}

+

+static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,

+			      int64_t *msc )

+{

+    return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);

+}

+

+

+static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,

+			 int64_t divisor, int64_t remainder,

+			 int64_t * msc, int64_t * sbc)

+{

+    __DRIswapInfo  sInfo;

+    int  status;

+

+    status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,

+                                                         divisor, remainder,

+                                                         msc );

+

+    /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync

+     * is supported but GLX_OML_sync_control is not.  Therefore, don't return

+     * an error value if GetSwapInfo() is not implemented.

+    */

+    if ( status == 0

+         && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {

+        status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );

+        *sbc = sInfo.swap_count;

+    }

+

+    return status;

+}

+

+

+const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {

+    { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },

+    driWaitForMSC,

+    driDrawableGetMSC,

+};

+

+

+static void driCopySubBuffer(__DRIdrawable *dPriv,

+			      int x, int y, int w, int h)

+{

+    drm_clip_rect_t rect;

+

+    rect.x1 = x;

+    rect.y1 = dPriv->h - y - h;

+    rect.x2 = x + w;

+    rect.y2 = rect.y1 + h;

+    driReportDamage(dPriv, &rect, 1);

+

+    dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);

+}

+

+const __DRIcopySubBufferExtension driCopySubBufferExtension = {

+    { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },

+    driCopySubBuffer

+};

+

+static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)

+{

+    dPriv->swap_interval = interval;

+}

+

+static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)

+{

+    return dPriv->swap_interval;

+}

+

+const __DRIswapControlExtension driSwapControlExtension = {

+    { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },

+    driSetSwapInterval,

+    driGetSwapInterval

+};

+

+

+/**

+ * This is called via __DRIscreenRec's createNewDrawable pointer.

+ */

+static __DRIdrawable *

+driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,

+		     drm_drawable_t hwDrawable, int renderType,

+		     const int *attrs, void *data)

+{

+    __DRIdrawable *pdp;

+

+    /* Since pbuffers are not yet supported, no drawable attributes are

+     * supported either.

+     */

+    (void) attrs;

+

+    pdp = malloc(sizeof *pdp);

+    if (!pdp) {

+	return NULL;

+    }

+

+    pdp->driContextPriv = NULL;

+    pdp->loaderPrivate = data;

+    pdp->hHWDrawable = hwDrawable;

+    pdp->refcount = 1;

+    pdp->pStamp = NULL;

+    pdp->lastStamp = 0;

+    pdp->index = 0;

+    pdp->x = 0;

+    pdp->y = 0;

+    pdp->w = 0;

+    pdp->h = 0;

+    pdp->numClipRects = 0;

+    pdp->numBackClipRects = 0;

+    pdp->pClipRects = NULL;

+    pdp->pBackClipRects = NULL;

+    pdp->vblSeq = 0;

+    pdp->vblFlags = 0;

+

+    pdp->driScreenPriv = psp;

+

+    if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes, 0)) {

+       free(pdp);

+       return NULL;

+    }

+

+    pdp->msc_base = 0;

+

+    /* This special default value is replaced with the configured

+     * default value when the drawable is first bound to a direct

+     * rendering context. 

+     */

+    pdp->swap_interval = (unsigned)-1;

+

+    return pdp;

+}

+

+

+static __DRIdrawable *

+dri2CreateNewDrawable(__DRIscreen *screen,

+		      const __DRIconfig *config,

+		      void *loaderPrivate)

+{

+    __DRIdrawable *pdraw;

+

+    pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);

+    if (!pdraw)

+    	return NULL;

+

+    pdraw->pClipRects = &pdraw->dri2.clipRect;

+    pdraw->pBackClipRects = &pdraw->dri2.clipRect;

+

+    pdraw->pStamp = &pdraw->dri2.stamp;

+    *pdraw->pStamp = pdraw->lastStamp + 1;

+

+    return pdraw;

+}

+

+static __DRIbuffer *

+dri2AllocateBuffer(__DRIscreen *screen,

+		   unsigned int attachment, unsigned int format,

+		   int width, int height)

+{

+    return (*screen->DriverAPI.AllocateBuffer)(screen, attachment, format,

+					       width, height);

+}

+

+static void

+dri2ReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)

+{

+   (*screen->DriverAPI.ReleaseBuffer)(screen, buffer);

+}

+

+

+static int

+dri2ConfigQueryb(__DRIscreen *screen, const char *var, GLboolean *val)

+{

+   if (!driCheckOption(&screen->optionCache, var, DRI_BOOL))

+      return -1;

+

+   *val = driQueryOptionb(&screen->optionCache, var);

+

+   return 0;

+}

+

+static int

+dri2ConfigQueryi(__DRIscreen *screen, const char *var, GLint *val)

+{

+   if (!driCheckOption(&screen->optionCache, var, DRI_INT) &&

+       !driCheckOption(&screen->optionCache, var, DRI_ENUM))

+      return -1;

+

+    *val = driQueryOptioni(&screen->optionCache, var);

+

+    return 0;

+}

+

+static int

+dri2ConfigQueryf(__DRIscreen *screen, const char *var, GLfloat *val)

+{

+   if (!driCheckOption(&screen->optionCache, var, DRI_FLOAT))

+      return -1;

+

+    *val = driQueryOptionf(&screen->optionCache, var);

+

+    return 0;

+}

+

+

+static void dri_get_drawable(__DRIdrawable *pdp)

+{

+    pdp->refcount++;

+}

+	

+static void dri_put_drawable(__DRIdrawable *pdp)

+{

+    __DRIscreen *psp;

+

+    if (pdp) {

+	pdp->refcount--;

+	if (pdp->refcount)

+	    return;

+

+	psp = pdp->driScreenPriv;

+        (*psp->DriverAPI.DestroyBuffer)(pdp);

+	if (pdp->pClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {

+	    free(pdp->pClipRects);

+	    pdp->pClipRects = NULL;

+	}

+	if (pdp->pBackClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {

+	    free(pdp->pBackClipRects);

+	    pdp->pBackClipRects = NULL;

+	}

+	free(pdp);

+    }

+}

+

+static void

+driDestroyDrawable(__DRIdrawable *pdp)

+{

+    dri_put_drawable(pdp);

+}

+

+/*@}*/

+

+

+/*****************************************************************/

+/** \name Context handling functions                             */

+/*****************************************************************/

+/*@{*/

+

+/**

+ * Destroy the per-context private information.

+ * 

+ * \internal

+ * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls

+ * drmDestroyContext(), and finally frees \p contextPrivate.

+ */

+static void

+driDestroyContext(__DRIcontext *pcp)

+{

+    if (pcp) {

+	(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);

+	free(pcp);

+    }

+}

+

+

+/**

+ * Create the per-drawable private driver information.

+ * 

+ * \param render_type   Type of rendering target.  \c GLX_RGBA is the only

+ *                      type likely to ever be supported for direct-rendering.

+ * \param shared        Context with which to share textures, etc. or NULL

+ *

+ * \returns An opaque pointer to the per-context private information on

+ *          success, or \c NULL on failure.

+ * 

+ * \internal

+ * This function allocates and fills a __DRIcontextRec structure.  It

+ * performs some device independent initialization and passes all the

+ * relevent information to __DriverAPIRec::CreateContext to create the

+ * context.

+ *

+ */

+static __DRIcontext *

+driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,

+		    int render_type, __DRIcontext *shared, 

+		    drm_context_t hwContext, void *data)

+{

+    __DRIcontext *pcp;

+    void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;

+

+    pcp = malloc(sizeof *pcp);

+    if (!pcp)

+	return NULL;

+

+    pcp->driScreenPriv = psp;

+    pcp->driDrawablePriv = NULL;

+    pcp->loaderPrivate = data;

+    

+    pcp->dri2.draw_stamp = 0;

+    pcp->dri2.read_stamp = 0;

+

+    pcp->hHWContext = hwContext;

+

+    if ( !(*psp->DriverAPI.CreateContext)(API_OPENGL,

+					  &config->modes, pcp, shareCtx) ) {

+        free(pcp);

+        return NULL;

+    }

+

+    return pcp;

+}

+

+static unsigned int

+dri2GetAPIMask(__DRIscreen *screen)

+{

+    return screen->api_mask;

+}

+

+static __DRIcontext *

+dri2CreateNewContextForAPI(__DRIscreen *screen, int api,

+			   const __DRIconfig *config,

+			   __DRIcontext *shared, void *data)

+{

+    __DRIcontext *context;

+    const struct gl_config *modes = (config != NULL) ? &config->modes : NULL;

+    void *shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;

+    gl_api mesa_api;

+

+    if (!(screen->api_mask & (1 << api)))

+	return NULL;

+

+    switch (api) {

+    case __DRI_API_OPENGL:

+	    mesa_api = API_OPENGL;

+	    break;

+    case __DRI_API_GLES:

+	    mesa_api = API_OPENGLES;

+	    break;

+    case __DRI_API_GLES2:

+	    mesa_api = API_OPENGLES2;

+	    break;

+    default:

+	    return NULL;

+    }

+

+    context = malloc(sizeof *context);

+    if (!context)

+	return NULL;

+

+    context->driScreenPriv = screen;

+    context->driDrawablePriv = NULL;

+    context->loaderPrivate = data;

+    

+    if (!(*screen->DriverAPI.CreateContext)(mesa_api, modes,

+					    context, shareCtx) ) {

+        free(context);

+        return NULL;

+    }

+

+    return context;

+}

+

+

+static __DRIcontext *

+dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,

+		      __DRIcontext *shared, void *data)

+{

+   return dri2CreateNewContextForAPI(screen, __DRI_API_OPENGL,

+				     config, shared, data);

+}

+

+static int

+driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)

+{

+    return GL_FALSE;

+}

+

+/*@}*/

+

+

+/*****************************************************************/

+/** \name Screen handling functions                              */

+/*****************************************************************/

+/*@{*/

+

+/**

+ * Destroy the per-screen private information.

+ * 

+ * \internal

+ * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls

+ * drmClose(), and finally frees \p screenPrivate.

+ */

+static void driDestroyScreen(__DRIscreen *psp)

+{

+    if (psp) {

+	/* No interaction with the X-server is possible at this point.  This

+	 * routine is called after XCloseDisplay, so there is no protocol

+	 * stream open to the X-server anymore.

+	 */

+

+       _mesa_destroy_shader_compiler();

+

+	if (psp->DriverAPI.DestroyScreen)

+	    (*psp->DriverAPI.DestroyScreen)(psp);

+

+	if (!psp->dri2.enabled) {

+	   (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);

+	   (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);

+	   (void)drmCloseOnce(psp->fd);

+	} else {

+	   driDestroyOptionCache(&psp->optionCache);

+	   driDestroyOptionInfo(&psp->optionInfo);

+	}

+

+	free(psp);

+    }

+}

+

+static void

+setupLoaderExtensions(__DRIscreen *psp,

+		      const __DRIextension **extensions)

+{

+    int i;

+

+    for (i = 0; extensions[i]; i++) {

+	if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)

+	    psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];

+	if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)

+	    psp->damage = (__DRIdamageExtension *) extensions[i];

+	if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)

+	    psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];

+	if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)

+	    psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];

+	if (strcmp(extensions[i]->name, __DRI_IMAGE_LOOKUP) == 0)

+	    psp->dri2.image = (__DRIimageLookupExtension *) extensions[i];

+	if (strcmp(extensions[i]->name, __DRI_USE_INVALIDATE) == 0)

+	    psp->dri2.useInvalidate = (__DRIuseInvalidateExtension *) extensions[i];

+    }

+}

+

+/**

+ * This is the bootstrap function for the driver.  libGL supplies all of the

+ * requisite information about the system, and the driver initializes itself.

+ * This routine also fills in the linked list pointed to by \c driver_modes

+ * with the \c struct gl_config that the driver can support for windows or

+ * pbuffers.

+ *

+ * For legacy DRI.

+ * 

+ * \param scrn  Index of the screen

+ * \param ddx_version Version of the 2D DDX.  This may not be meaningful for

+ *                    all drivers.

+ * \param dri_version Version of the "server-side" DRI.

+ * \param drm_version Version of the kernel DRM.

+ * \param frame_buffer Data describing the location and layout of the

+ *                     framebuffer.

+ * \param pSAREA       Pointer to the SAREA.

+ * \param fd           Device handle for the DRM.

+ * \param extensions   ??

+ * \param driver_modes  Returns modes suppoted by the driver

+ * \param loaderPrivate  ??

+ * 

+ * \note There is no need to check the minimum API version in this

+ * function.  Since the name of this function is versioned, it is

+ * impossible for a loader that is too old to even load this driver.

+ */

+static __DRIscreen *

+driCreateNewScreen(int scrn,

+		   const __DRIversion *ddx_version,

+		   const __DRIversion *dri_version,

+		   const __DRIversion *drm_version,

+		   const __DRIframebuffer *frame_buffer,

+		   drmAddress pSAREA, int fd, 

+		   const __DRIextension **extensions,

+		   const __DRIconfig ***driver_modes,

+		   void *loaderPrivate)

+{

+    static const __DRIextension *emptyExtensionList[] = { NULL };

+    __DRIscreen *psp;

+

+    if (driDriverAPI.InitScreen == NULL)

+	return NULL;

+

+    psp = calloc(1, sizeof *psp);

+    if (!psp)

+	return NULL;

+

+    setupLoaderExtensions(psp, extensions);

+

+    /*

+    ** NOT_DONE: This is used by the X server to detect when the client

+    ** has died while holding the drawable lock.  The client sets the

+    ** drawable lock to this value.

+    */

+    psp->drawLockID = 1;

+

+    psp->drm_version = *drm_version;

+    psp->ddx_version = *ddx_version;

+    psp->dri_version = *dri_version;

+

+    psp->pSAREA = pSAREA;

+    psp->lock = (drmLock *) &psp->pSAREA->lock;

+

+    psp->pFB = frame_buffer->base;

+    psp->fbSize = frame_buffer->size;

+    psp->fbStride = frame_buffer->stride;

+    psp->fbWidth = frame_buffer->width;

+    psp->fbHeight = frame_buffer->height;

+    psp->devPrivSize = frame_buffer->dev_priv_size;

+    psp->pDevPriv = frame_buffer->dev_priv;

+    psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;

+

+    psp->extensions = emptyExtensionList;

+    psp->fd = fd;

+    psp->myNum = scrn;

+    psp->dri2.enabled = GL_FALSE;

+

+    psp->DriverAPI = driDriverAPI;

+    psp->api_mask = (1 << __DRI_API_OPENGL);

+

+    *driver_modes = driDriverAPI.InitScreen(psp);

+    if (*driver_modes == NULL) {

+	free(psp);

+	return NULL;

+    }

+

+    return psp;

+}

+

+/**

+ * DRI2

+ */

+static __DRIscreen *

+dri2CreateNewScreen(int scrn, int fd,

+		    const __DRIextension **extensions,

+		    const __DRIconfig ***driver_configs, void *data)

+{

+    static const __DRIextension *emptyExtensionList[] = { NULL };

+    __DRIscreen *psp;

+    drmVersionPtr version;

+

+    if (driDriverAPI.InitScreen2 == NULL)

+        return NULL;

+

+    psp = calloc(1, sizeof(*psp));

+    if (!psp)

+	return NULL;

+

+    setupLoaderExtensions(psp, extensions);

+

+    version = drmGetVersion(fd);

+    if (version) {

+	psp->drm_version.major = version->version_major;

+	psp->drm_version.minor = version->version_minor;

+	psp->drm_version.patch = version->version_patchlevel;

+	drmFreeVersion(version);

+    }

+

+    psp->extensions = emptyExtensionList;

+    psp->fd = fd;

+    psp->myNum = scrn;

+    psp->dri2.enabled = GL_TRUE;

+

+    psp->DriverAPI = driDriverAPI;

+    psp->api_mask = (1 << __DRI_API_OPENGL);

+    *driver_configs = driDriverAPI.InitScreen2(psp);

+    if (*driver_configs == NULL) {

+	free(psp);

+	return NULL;

+    }

+

+    psp->DriverAPI = driDriverAPI;

+    psp->loaderPrivate = data;

+

+    driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions,

+		       __dri2NConfigOptions);

+    driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum,

+			"dri2");

+

+    return psp;

+}

+

+static const __DRIextension **driGetExtensions(__DRIscreen *psp)

+{

+    return psp->extensions;

+}

+

+/** Core interface */

+const __DRIcoreExtension driCoreExtension = {

+    { __DRI_CORE, __DRI_CORE_VERSION },

+    NULL,

+    driDestroyScreen,

+    driGetExtensions,

+    driGetConfigAttrib,

+    driIndexConfigAttrib,

+    NULL,

+    driDestroyDrawable,

+    driSwapBuffers,

+    NULL,

+    driCopyContext,

+    driDestroyContext,

+    driBindContext,

+    driUnbindContext

+};

+

+/** Legacy DRI interface */

+const __DRIlegacyExtension driLegacyExtension = {

+    { __DRI_LEGACY, __DRI_LEGACY_VERSION },

+    driCreateNewScreen,

+    driCreateNewDrawable,

+    driCreateNewContext,

+};

+

+/** DRI2 interface */

+const __DRIdri2Extension driDRI2Extension = {

+    { __DRI_DRI2, __DRI_DRI2_VERSION },

+    dri2CreateNewScreen,

+    dri2CreateNewDrawable,

+    dri2CreateNewContext,

+    dri2GetAPIMask,

+    dri2CreateNewContextForAPI,

+    dri2AllocateBuffer,

+    dri2ReleaseBuffer

+};

+

+const __DRI2configQueryExtension dri2ConfigQueryExtension = {

+   { __DRI2_CONFIG_QUERY, __DRI2_CONFIG_QUERY_VERSION },

+   dri2ConfigQueryb,

+   dri2ConfigQueryi,

+   dri2ConfigQueryf,

+};

+

+/**

+ * Calculate amount of swap interval used between GLX buffer swaps.

+ * 

+ * The usage value, on the range [0,max], is the fraction of total swap

+ * interval time used between GLX buffer swaps is calculated.

+ *

+ *            \f$p = t_d / (i * t_r)\f$

+ * 

+ * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the

+ * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time

+ * required for a single vertical refresh period (as returned by \c

+ * glXGetMscRateOML).

+ * 

+ * See the documentation for the GLX_MESA_swap_frame_usage extension for more

+ * details.

+ *

+ * \param   dPriv  Pointer to the private drawable structure.

+ * \return  If less than a single swap interval time period was required

+ *          between GLX buffer swaps, a number greater than 0 and less than

+ *          1.0 is returned.  If exactly one swap interval time period is

+ *          required, 1.0 is returned, and if more than one is required then

+ *          a number greater than 1.0 will be returned.

+ *

+ * \sa glXSwapIntervalSGI glXGetMscRateOML

+ * 

+ * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it

+ *       be possible to cache the sync rate?

+ */

+float

+driCalculateSwapUsage( __DRIdrawable *dPriv, int64_t last_swap_ust,

+		       int64_t current_ust )

+{

+   int32_t   n;

+   int32_t   d;

+   int       interval;

+   float     usage = 1.0;

+   __DRIscreen *psp = dPriv->driScreenPriv;

+

+   if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {

+      interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;

+

+

+      /* We want to calculate

+       * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get

+       * current_UST by calling __glXGetUST.  last_swap_UST is stored in

+       * dPriv->swap_ust.  interval has already been calculated.

+       *

+       * The only tricky part is us_per_refresh.  us_per_refresh is

+       * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it

+       * around and say us_per_refresh = 1000000 * d / n.  Since this goes in

+       * the denominator of the final calculation, we calculate

+       * (interval * 1000000 * d) and move n into the numerator.

+       */

+

+      usage = (current_ust - last_swap_ust);

+      usage *= n;

+      usage /= (interval * d);

+      usage /= 1000000.0;

+   }

+   

+   return usage;

+}

+

+void

+dri2InvalidateDrawable(__DRIdrawable *drawable)

+{

+    drawable->dri2.stamp++;

+}

+

+/*@}*/

diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.h b/mesalib/src/mesa/drivers/dri/common/dri_util.h
index 3d3d5c9cd..8d2a38524 100644
--- a/mesalib/src/mesa/drivers/dri/common/dri_util.h
+++ b/mesalib/src/mesa/drivers/dri/common/dri_util.h
@@ -1,563 +1,563 @@
-/*
- * 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 PRECISION INSIGHT AND/OR ITS 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.
- */
-
-/**
- * \file dri_util.h
- * DRI utility functions definitions.
- *
- * This module acts as glue between GLX and the actual hardware driver.  A DRI
- * driver doesn't really \e have to use any of this - it's optional.  But, some
- * useful stuff is done here that otherwise would have to be duplicated in most
- * drivers.
- * 
- * Basically, these utility functions take care of some of the dirty details of
- * screen initialization, context creation, context binding, DRM setup, etc.
- *
- * These functions are compiled into each DRI driver so libGL.so knows nothing
- * about them.
- *
- * \sa dri_util.c.
- * 
- * \author Kevin E. Martin <kevin@precisioninsight.com>
- * \author Brian Paul <brian@precisioninsight.com>
- */
-
-#ifndef _DRI_UTIL_H_
-#define _DRI_UTIL_H_
-
-#include <GL/gl.h>
-#include <drm.h>
-#include <drm_sarea.h>
-#include <xf86drm.h>
-#include "xmlconfig.h"
-#include "main/glheader.h"
-#include "main/mtypes.h"
-#include "GL/internal/dri_interface.h"
-
-#define GLX_BAD_CONTEXT                    5
-
-typedef struct __DRIswapInfoRec        __DRIswapInfo;
-
-/**
- * Extensions.
- */
-extern const __DRIlegacyExtension driLegacyExtension;
-extern const __DRIcoreExtension driCoreExtension;
-extern const __DRIdri2Extension driDRI2Extension;
-extern const __DRIextension driReadDrawableExtension;
-extern const __DRIcopySubBufferExtension driCopySubBufferExtension;
-extern const __DRIswapControlExtension driSwapControlExtension;
-extern const __DRImediaStreamCounterExtension driMediaStreamCounterExtension;
-extern const __DRI2configQueryExtension dri2ConfigQueryExtension;
-
-/**
- * Used by DRI_VALIDATE_DRAWABLE_INFO
- */
-#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \
-    do {                                                        \
-	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \
-	    __driUtilUpdateDrawableInfo(pDrawPriv);             \
-	}                                                       \
-    } while (0)
-
-
-/**
- * Utility macro to validate the drawable information.
- *
- * See __DRIdrawable::pStamp and __DRIdrawable::lastStamp.
- */
-#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \
-do {                                                                    \
-    while (*(pdp->pStamp) != pdp->lastStamp) {                          \
-        register unsigned int hwContext = psp->pSAREA->lock.lock &      \
-		     ~(DRM_LOCK_HELD | DRM_LOCK_CONT);                  \
-	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock, hwContext);             \
-                                                                        \
-	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \
-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
-	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \
-                                                                        \
-	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock, hwContext);         \
-    }                                                                   \
-} while (0)
-
-/**
- * Same as above, but for two drawables simultaneously.
- *
- */
-
-#define DRI_VALIDATE_TWO_DRAWABLES_INFO(psp, pdp, prp)			\
-do {								\
-    while (*((pdp)->pStamp) != (pdp)->lastStamp ||			\
-	   *((prp)->pStamp) != (prp)->lastStamp) {			\
-        register unsigned int hwContext = (psp)->pSAREA->lock.lock &	\
-	    ~(DRM_LOCK_HELD | DRM_LOCK_CONT);				\
-	DRM_UNLOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);		\
-									\
-	DRM_SPINLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID);	\
-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(prp);				\
-	DRM_SPINUNLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID); \
-									\
-	DRM_LIGHT_LOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);	\
-    }                                                                   \
-} while (0)
-
-
-/**
- * Driver callback functions.
- *
- * Each DRI driver must have one of these structures with all the pointers set
- * to appropriate functions within the driver.
- * 
- * When glXCreateContext() is called, for example, it'll call a helper function
- * dri_util.c which in turn will jump through the \a CreateContext pointer in
- * this structure.
- */
-struct __DriverAPIRec {
-    const __DRIconfig **(*InitScreen) (__DRIscreen * priv);
-
-    /**
-     * Screen destruction callback
-     */
-    void (*DestroyScreen)(__DRIscreen *driScrnPriv);
-
-    /**
-     * Context creation callback
-     */	    	    
-    GLboolean (*CreateContext)(gl_api api,
-			       const struct gl_config *glVis,
-			       __DRIcontext *driContextPriv,
-                               void *sharedContextPrivate);
-
-    /**
-     * Context destruction callback
-     */
-    void (*DestroyContext)(__DRIcontext *driContextPriv);
-
-    /**
-     * Buffer (drawable) creation callback
-     */
-    GLboolean (*CreateBuffer)(__DRIscreen *driScrnPriv,
-                              __DRIdrawable *driDrawPriv,
-                              const struct gl_config *glVis,
-                              GLboolean pixmapBuffer);
-    
-    /**
-     * Buffer (drawable) destruction callback
-     */
-    void (*DestroyBuffer)(__DRIdrawable *driDrawPriv);
-
-    /**
-     * Buffer swapping callback 
-     */
-    void (*SwapBuffers)(__DRIdrawable *driDrawPriv);
-
-    /**
-     * Context activation callback
-     */
-    GLboolean (*MakeCurrent)(__DRIcontext *driContextPriv,
-                             __DRIdrawable *driDrawPriv,
-                             __DRIdrawable *driReadPriv);
-
-    /**
-     * Context unbinding callback
-     */
-    GLboolean (*UnbindContext)(__DRIcontext *driContextPriv);
-  
-    /**
-     * Retrieves statistics about buffer swap operations.  Required if
-     * GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.
-     */
-    int (*GetSwapInfo)( __DRIdrawable *dPriv, __DRIswapInfo * sInfo );
-
-
-    /**
-     * These are required if GLX_OML_sync_control is supported.
-     */
-    /*@{*/
-    int (*WaitForMSC)( __DRIdrawable *priv, int64_t target_msc, 
-		       int64_t divisor, int64_t remainder,
-		       int64_t * msc );
-    int (*WaitForSBC)( __DRIdrawable *priv, int64_t target_sbc,
-		       int64_t * msc, int64_t * sbc );
-
-    int64_t (*SwapBuffersMSC)( __DRIdrawable *priv, int64_t target_msc,
-			       int64_t divisor, int64_t remainder );
-    /*@}*/
-    void (*CopySubBuffer)(__DRIdrawable *driDrawPriv,
-			  int x, int y, int w, int h);
-
-    /**
-     * New version of GetMSC so we can pass drawable data to the low
-     * level DRM driver (e.g. pipe info).  Required if
-     * GLX_SGI_video_sync or GLX_OML_sync_control is supported.
-     */
-    int (*GetDrawableMSC) ( __DRIscreen * priv,
-			    __DRIdrawable *drawablePrivate,
-			    int64_t *count);
-
-
-
-    /* DRI2 Entry point */
-    const __DRIconfig **(*InitScreen2) (__DRIscreen * priv);
-
-    __DRIbuffer *(*AllocateBuffer) (__DRIscreen *screenPrivate,
-				    unsigned int attachment,
-				    unsigned int format,
-				    int width, int height);
-    void (*ReleaseBuffer) (__DRIscreen *screenPrivate, __DRIbuffer *buffer);
-};
-
-extern const struct __DriverAPIRec driDriverAPI;
-
-
-struct __DRIswapInfoRec {
-    /** 
-     * Number of swapBuffers operations that have been *completed*. 
-     */
-    uint64_t swap_count;
-
-    /**
-     * Unadjusted system time of the last buffer swap.  This is the time
-     * when the swap completed, not the time when swapBuffers was called.
-     */
-    int64_t   swap_ust;
-
-    /**
-     * Number of swap operations that occurred after the swap deadline.  That
-     * is if a swap happens more than swap_interval frames after the previous
-     * swap, it has missed its deadline.  If swap_interval is 0, then the
-     * swap deadline is 1 frame after the previous swap.
-     */
-    uint64_t swap_missed_count;
-
-    /**
-     * Amount of time used by the last swap that missed its deadline.  This
-     * is calculated as (__glXGetUST() - swap_ust) / (swap_interval * 
-     * time_for_single_vrefresh)).  If the actual value of swap_interval is
-     * 0, then 1 is used instead.  If swap_missed_count is non-zero, this
-     * should be greater-than 1.0.
-     */
-    float     swap_missed_usage;
-};
-
-
-/**
- * Per-drawable private DRI driver information.
- */
-struct __DRIdrawableRec {
-    /**
-     * Kernel drawable handle
-     */
-    drm_drawable_t hHWDrawable;
-
-    /**
-     * Driver's private drawable information.  
-     *
-     * This structure is opaque.
-     */
-    void *driverPrivate;
-
-    /**
-     * Private data from the loader.  We just hold on to it and pass
-     * it back when calling into loader provided functions.
-     */
-    void *loaderPrivate;
-
-    /**
-     * Reference count for number of context's currently bound to this
-     * drawable.  
-     *
-     * Once it reaches zero, the drawable can be destroyed.
-     *
-     * \note This behavior will change with GLX 1.3.
-     */
-    int refcount;
-
-    /**
-     * Index of this drawable information in the SAREA.
-     */
-    unsigned int index;
-
-    /**
-     * Pointer to the "drawable has changed ID" stamp in the SAREA (or
-     * to dri2.stamp if DRI2 is being used).
-     */
-    unsigned int *pStamp;
-
-    /**
-     * Last value of the stamp.
-     *
-     * If this differs from the value stored at __DRIdrawable::pStamp,
-     * then the drawable information has been modified by the X server, and the
-     * drawable information (below) should be retrieved from the X server.
-     */
-    unsigned int lastStamp;
-
-    /**
-     * \name Drawable 
-     *
-     * Drawable information used in software fallbacks.
-     */
-    /*@{*/
-    int x;
-    int y;
-    int w;
-    int h;
-    int numClipRects;
-    drm_clip_rect_t *pClipRects;
-    /*@}*/
-
-    /**
-     * \name Back and depthbuffer
-     *
-     * Information about the back and depthbuffer where different from above.
-     */
-    /*@{*/
-    int backX;
-    int backY;
-    int backClipRectType;
-    int numBackClipRects;
-    drm_clip_rect_t *pBackClipRects;
-    /*@}*/
-
-    /**
-     * \name Vertical blank tracking information
-     * Used for waiting on vertical blank events.
-     */
-    /*@{*/
-    unsigned int vblSeq;
-    unsigned int vblFlags;
-    /*@}*/
-
-    /**
-     * \name Monotonic MSC tracking
-     *
-     * Low level driver is responsible for updating msc_base and
-     * vblSeq values so that higher level code can calculate
-     * a new msc value or msc target for a WaitMSC call.  The new value
-     * will be:
-     *   msc = msc_base + get_vblank_count() - vblank_base;
-     *
-     * And for waiting on a value, core code will use:
-     *   actual_target = target_msc - msc_base + vblank_base;
-     */
-    /*@{*/
-    int64_t vblank_base;
-    int64_t msc_base;
-    /*@}*/
-
-    /**
-     * Pointer to context to which this drawable is currently bound.
-     */
-    __DRIcontext *driContextPriv;
-
-    /**
-     * Pointer to screen on which this drawable was created.
-     */
-    __DRIscreen *driScreenPriv;
-
-    /**
-     * Controls swap interval as used by GLX_SGI_swap_control and
-     * GLX_MESA_swap_control.
-     */
-    unsigned int swap_interval;
-
-    struct {
-	unsigned int stamp;
-	drm_clip_rect_t clipRect;
-    } dri2;
-};
-
-/**
- * Per-context private driver information.
- */
-struct __DRIcontextRec {
-    /**
-     * Kernel context handle used to access the device lock.
-     */
-    drm_context_t hHWContext;
-
-    /**
-     * Device driver's private context data.  This structure is opaque.
-     */
-    void *driverPrivate;
-
-    /**
-     * Pointer to drawable currently bound to this context for drawing.
-     */
-    __DRIdrawable *driDrawablePriv;
-
-    /**
-     * Pointer to drawable currently bound to this context for reading.
-     */
-    __DRIdrawable *driReadablePriv;
-
-    /**
-     * Pointer to screen on which this context was created.
-     */
-    __DRIscreen *driScreenPriv;
-
-    /**
-     * The loaders's private context data.  This structure is opaque.
-     */
-    void *loaderPrivate;
-
-    struct {
-	int draw_stamp;
-	int read_stamp;
-    } dri2;
-};
-
-/**
- * Per-screen private driver information.
- */
-struct __DRIscreenRec {
-    /**
-     * Current screen's number
-     */
-    int myNum;
-
-    /**
-     * Callback functions into the hardware-specific DRI driver code.
-     */
-    struct __DriverAPIRec DriverAPI;
-
-    const __DRIextension **extensions;
-    /**
-     * DDX / 2D driver version information.
-     */
-    __DRIversion ddx_version;
-
-    /**
-     * DRI X extension version information.
-     */
-    __DRIversion dri_version;
-
-    /**
-     * DRM (kernel module) version information.
-     */
-    __DRIversion drm_version;
-
-    /**
-     * ID used when the client sets the drawable lock.
-     *
-     * The X server uses this value to detect if the client has died while
-     * holding the drawable lock.
-     */
-    int drawLockID;
-
-    /**
-     * File descriptor returned when the kernel device driver is opened.
-     * 
-     * Used to:
-     *   - authenticate client to kernel
-     *   - map the frame buffer, SAREA, etc.
-     *   - close the kernel device driver
-     */
-    int fd;
-
-    /**
-     * SAREA pointer 
-     *
-     * Used to access:
-     *   - the device lock
-     *   - the device-independent per-drawable and per-context(?) information
-     */
-    drm_sarea_t *pSAREA;
-
-    /**
-     * \name Direct frame buffer access information 
-     * Used for software fallbacks.
-     */
-    /*@{*/
-    unsigned char *pFB;
-    int fbSize;
-    int fbOrigin;
-    int fbStride;
-    int fbWidth;
-    int fbHeight;
-    int fbBPP;
-    /*@}*/
-
-    /**
-     * \name Device-dependent private information (stored in the SAREA).
-     *
-     * This data is accessed by the client driver only.
-     */
-    /*@{*/
-    void *pDevPriv;
-    int devPrivSize;
-    /*@}*/
-
-    /**
-     * Device-dependent private information (not stored in the SAREA).
-     * 
-     * This pointer is never touched by the DRI layer.
-     */
-#ifdef __cplusplus
-    void *priv;
-#else
-    void *private;
-#endif
-
-    /* Extensions provided by the loader. */
-    const __DRIgetDrawableInfoExtension *getDrawableInfo;
-    const __DRIsystemTimeExtension *systemTime;
-    const __DRIdamageExtension *damage;
-
-    struct {
-	/* Flag to indicate that this is a DRI2 screen.  Many of the above
-	 * fields will not be valid or initializaed in that case. */
-	int enabled;
-	__DRIdri2LoaderExtension *loader;
-	__DRIimageLookupExtension *image;
-	__DRIuseInvalidateExtension *useInvalidate;
-    } dri2;
-
-    /* The lock actually in use, old sarea or DRI2 */
-    drmLock *lock;
-
-    driOptionCache optionInfo;
-    driOptionCache optionCache;
-   unsigned int api_mask;
-   void *loaderPrivate;
-};
-
-extern void
-__driUtilUpdateDrawableInfo(__DRIdrawable *pdp);
-
-extern float
-driCalculateSwapUsage( __DRIdrawable *dPriv,
-		       int64_t last_swap_ust, int64_t current_ust );
-
-extern GLint
-driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 );
-
-extern void
-dri2InvalidateDrawable(__DRIdrawable *drawable);
-
-#endif /* _DRI_UTIL_H_ */
+/*

+ * 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 PRECISION INSIGHT AND/OR ITS 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.

+ */

+

+/**

+ * \file dri_util.h

+ * DRI utility functions definitions.

+ *

+ * This module acts as glue between GLX and the actual hardware driver.  A DRI

+ * driver doesn't really \e have to use any of this - it's optional.  But, some

+ * useful stuff is done here that otherwise would have to be duplicated in most

+ * drivers.

+ * 

+ * Basically, these utility functions take care of some of the dirty details of

+ * screen initialization, context creation, context binding, DRM setup, etc.

+ *

+ * These functions are compiled into each DRI driver so libGL.so knows nothing

+ * about them.

+ *

+ * \sa dri_util.c.

+ * 

+ * \author Kevin E. Martin <kevin@precisioninsight.com>

+ * \author Brian Paul <brian@precisioninsight.com>

+ */

+

+#ifndef _DRI_UTIL_H_

+#define _DRI_UTIL_H_

+

+#include <GL/gl.h>

+#include <drm.h>

+#include <drm_sarea.h>

+#include <xf86drm.h>

+#include "xmlconfig.h"

+#include "main/glheader.h"

+#include "main/mtypes.h"

+#include "GL/internal/dri_interface.h"

+

+#define GLX_BAD_CONTEXT                    5

+

+typedef struct __DRIswapInfoRec        __DRIswapInfo;

+

+/**

+ * Extensions.

+ */

+extern const __DRIlegacyExtension driLegacyExtension;

+extern const __DRIcoreExtension driCoreExtension;

+extern const __DRIdri2Extension driDRI2Extension;

+extern const __DRIextension driReadDrawableExtension;

+extern const __DRIcopySubBufferExtension driCopySubBufferExtension;

+extern const __DRIswapControlExtension driSwapControlExtension;

+extern const __DRImediaStreamCounterExtension driMediaStreamCounterExtension;

+extern const __DRI2configQueryExtension dri2ConfigQueryExtension;

+

+/**

+ * Used by DRI_VALIDATE_DRAWABLE_INFO

+ */

+#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \

+    do {                                                        \

+	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \

+	    __driUtilUpdateDrawableInfo(pDrawPriv);             \

+	}                                                       \

+    } while (0)

+

+

+/**

+ * Utility macro to validate the drawable information.

+ *

+ * See __DRIdrawable::pStamp and __DRIdrawable::lastStamp.

+ */

+#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \

+do {                                                                    \

+    while (*(pdp->pStamp) != pdp->lastStamp) {                          \

+        register unsigned int hwContext = psp->pSAREA->lock.lock &      \

+		     ~(DRM_LOCK_HELD | DRM_LOCK_CONT);                  \

+	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock, hwContext);             \

+                                                                        \

+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \

+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \

+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \

+                                                                        \

+	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock, hwContext);         \

+    }                                                                   \

+} while (0)

+

+/**

+ * Same as above, but for two drawables simultaneously.

+ *

+ */

+

+#define DRI_VALIDATE_TWO_DRAWABLES_INFO(psp, pdp, prp)			\

+do {								\

+    while (*((pdp)->pStamp) != (pdp)->lastStamp ||			\

+	   *((prp)->pStamp) != (prp)->lastStamp) {			\

+        register unsigned int hwContext = (psp)->pSAREA->lock.lock &	\

+	    ~(DRM_LOCK_HELD | DRM_LOCK_CONT);				\

+	DRM_UNLOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);		\

+									\

+	DRM_SPINLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID);	\

+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \

+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(prp);				\

+	DRM_SPINUNLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID); \

+									\

+	DRM_LIGHT_LOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);	\

+    }                                                                   \

+} while (0)

+

+

+/**

+ * Driver callback functions.

+ *

+ * Each DRI driver must have one of these structures with all the pointers set

+ * to appropriate functions within the driver.

+ * 

+ * When glXCreateContext() is called, for example, it'll call a helper function

+ * dri_util.c which in turn will jump through the \a CreateContext pointer in

+ * this structure.

+ */

+struct __DriverAPIRec {

+    const __DRIconfig **(*InitScreen) (__DRIscreen * priv);

+

+    /**

+     * Screen destruction callback

+     */

+    void (*DestroyScreen)(__DRIscreen *driScrnPriv);

+

+    /**

+     * Context creation callback

+     */	    	    

+    GLboolean (*CreateContext)(gl_api api,

+			       const struct gl_config *glVis,

+			       __DRIcontext *driContextPriv,

+                               void *sharedContextPrivate);

+

+    /**

+     * Context destruction callback

+     */

+    void (*DestroyContext)(__DRIcontext *driContextPriv);

+

+    /**

+     * Buffer (drawable) creation callback

+     */

+    GLboolean (*CreateBuffer)(__DRIscreen *driScrnPriv,

+                              __DRIdrawable *driDrawPriv,

+                              const struct gl_config *glVis,

+                              GLboolean pixmapBuffer);

+    

+    /**

+     * Buffer (drawable) destruction callback

+     */

+    void (*DestroyBuffer)(__DRIdrawable *driDrawPriv);

+

+    /**

+     * Buffer swapping callback 

+     */

+    void (*SwapBuffers)(__DRIdrawable *driDrawPriv);

+

+    /**

+     * Context activation callback

+     */

+    GLboolean (*MakeCurrent)(__DRIcontext *driContextPriv,

+                             __DRIdrawable *driDrawPriv,

+                             __DRIdrawable *driReadPriv);

+

+    /**

+     * Context unbinding callback

+     */

+    GLboolean (*UnbindContext)(__DRIcontext *driContextPriv);

+  

+    /**

+     * Retrieves statistics about buffer swap operations.  Required if

+     * GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.

+     */

+    int (*GetSwapInfo)( __DRIdrawable *dPriv, __DRIswapInfo * sInfo );

+

+

+    /**

+     * These are required if GLX_OML_sync_control is supported.

+     */

+    /*@{*/

+    int (*WaitForMSC)( __DRIdrawable *priv, int64_t target_msc, 

+		       int64_t divisor, int64_t remainder,

+		       int64_t * msc );

+    int (*WaitForSBC)( __DRIdrawable *priv, int64_t target_sbc,

+		       int64_t * msc, int64_t * sbc );

+

+    int64_t (*SwapBuffersMSC)( __DRIdrawable *priv, int64_t target_msc,

+			       int64_t divisor, int64_t remainder );

+    /*@}*/

+    void (*CopySubBuffer)(__DRIdrawable *driDrawPriv,

+			  int x, int y, int w, int h);

+

+    /**

+     * New version of GetMSC so we can pass drawable data to the low

+     * level DRM driver (e.g. pipe info).  Required if

+     * GLX_SGI_video_sync or GLX_OML_sync_control is supported.

+     */

+    int (*GetDrawableMSC) ( __DRIscreen * priv,

+			    __DRIdrawable *drawablePrivate,

+			    int64_t *count);

+

+

+

+    /* DRI2 Entry point */

+    const __DRIconfig **(*InitScreen2) (__DRIscreen * priv);

+

+    __DRIbuffer *(*AllocateBuffer) (__DRIscreen *screenPrivate,

+				    unsigned int attachment,

+				    unsigned int format,

+				    int width, int height);

+    void (*ReleaseBuffer) (__DRIscreen *screenPrivate, __DRIbuffer *buffer);

+};

+

+extern const struct __DriverAPIRec driDriverAPI;

+

+

+struct __DRIswapInfoRec {

+    /** 

+     * Number of swapBuffers operations that have been *completed*. 

+     */

+    uint64_t swap_count;

+

+    /**

+     * Unadjusted system time of the last buffer swap.  This is the time

+     * when the swap completed, not the time when swapBuffers was called.

+     */

+    int64_t   swap_ust;

+

+    /**

+     * Number of swap operations that occurred after the swap deadline.  That

+     * is if a swap happens more than swap_interval frames after the previous

+     * swap, it has missed its deadline.  If swap_interval is 0, then the

+     * swap deadline is 1 frame after the previous swap.

+     */

+    uint64_t swap_missed_count;

+

+    /**

+     * Amount of time used by the last swap that missed its deadline.  This

+     * is calculated as (__glXGetUST() - swap_ust) / (swap_interval * 

+     * time_for_single_vrefresh)).  If the actual value of swap_interval is

+     * 0, then 1 is used instead.  If swap_missed_count is non-zero, this

+     * should be greater-than 1.0.

+     */

+    float     swap_missed_usage;

+};

+

+

+/**

+ * Per-drawable private DRI driver information.

+ */

+struct __DRIdrawableRec {

+    /**

+     * Kernel drawable handle

+     */

+    drm_drawable_t hHWDrawable;

+

+    /**

+     * Driver's private drawable information.  

+     *

+     * This structure is opaque.

+     */

+    void *driverPrivate;

+

+    /**

+     * Private data from the loader.  We just hold on to it and pass

+     * it back when calling into loader provided functions.

+     */

+    void *loaderPrivate;

+

+    /**

+     * Reference count for number of context's currently bound to this

+     * drawable.  

+     *

+     * Once it reaches zero, the drawable can be destroyed.

+     *

+     * \note This behavior will change with GLX 1.3.

+     */

+    int refcount;

+

+    /**

+     * Index of this drawable information in the SAREA.

+     */

+    unsigned int index;

+

+    /**

+     * Pointer to the "drawable has changed ID" stamp in the SAREA (or

+     * to dri2.stamp if DRI2 is being used).

+     */

+    unsigned int *pStamp;

+

+    /**

+     * Last value of the stamp.

+     *

+     * If this differs from the value stored at __DRIdrawable::pStamp,

+     * then the drawable information has been modified by the X server, and the

+     * drawable information (below) should be retrieved from the X server.

+     */

+    unsigned int lastStamp;

+

+    /**

+     * \name Drawable 

+     *

+     * Drawable information used in software fallbacks.

+     */

+    /*@{*/

+    int x;

+    int y;

+    int w;

+    int h;

+    int numClipRects;

+    drm_clip_rect_t *pClipRects;

+    /*@}*/

+

+    /**

+     * \name Back and depthbuffer

+     *

+     * Information about the back and depthbuffer where different from above.

+     */

+    /*@{*/

+    int backX;

+    int backY;

+    int backClipRectType;

+    int numBackClipRects;

+    drm_clip_rect_t *pBackClipRects;

+    /*@}*/

+

+    /**

+     * \name Vertical blank tracking information

+     * Used for waiting on vertical blank events.

+     */

+    /*@{*/

+    unsigned int vblSeq;

+    unsigned int vblFlags;

+    /*@}*/

+

+    /**

+     * \name Monotonic MSC tracking

+     *

+     * Low level driver is responsible for updating msc_base and

+     * vblSeq values so that higher level code can calculate

+     * a new msc value or msc target for a WaitMSC call.  The new value

+     * will be:

+     *   msc = msc_base + get_vblank_count() - vblank_base;

+     *

+     * And for waiting on a value, core code will use:

+     *   actual_target = target_msc - msc_base + vblank_base;

+     */

+    /*@{*/

+    int64_t vblank_base;

+    int64_t msc_base;

+    /*@}*/

+

+    /**

+     * Pointer to context to which this drawable is currently bound.

+     */

+    __DRIcontext *driContextPriv;

+

+    /**

+     * Pointer to screen on which this drawable was created.

+     */

+    __DRIscreen *driScreenPriv;

+

+    /**

+     * Controls swap interval as used by GLX_SGI_swap_control and

+     * GLX_MESA_swap_control.

+     */

+    unsigned int swap_interval;

+

+    struct {

+	unsigned int stamp;

+	drm_clip_rect_t clipRect;

+    } dri2;

+};

+

+/**

+ * Per-context private driver information.

+ */

+struct __DRIcontextRec {

+    /**

+     * Kernel context handle used to access the device lock.

+     */

+    drm_context_t hHWContext;

+

+    /**

+     * Device driver's private context data.  This structure is opaque.

+     */

+    void *driverPrivate;

+

+    /**

+     * Pointer to drawable currently bound to this context for drawing.

+     */

+    __DRIdrawable *driDrawablePriv;

+

+    /**

+     * Pointer to drawable currently bound to this context for reading.

+     */

+    __DRIdrawable *driReadablePriv;

+

+    /**

+     * Pointer to screen on which this context was created.

+     */

+    __DRIscreen *driScreenPriv;

+

+    /**

+     * The loaders's private context data.  This structure is opaque.

+     */

+    void *loaderPrivate;

+

+    struct {

+	int draw_stamp;

+	int read_stamp;

+    } dri2;

+};

+

+/**

+ * Per-screen private driver information.

+ */

+struct __DRIscreenRec {

+    /**

+     * Current screen's number

+     */

+    int myNum;

+

+    /**

+     * Callback functions into the hardware-specific DRI driver code.

+     */

+    struct __DriverAPIRec DriverAPI;

+

+    const __DRIextension **extensions;

+    /**

+     * DDX / 2D driver version information.

+     */

+    __DRIversion ddx_version;

+

+    /**

+     * DRI X extension version information.

+     */

+    __DRIversion dri_version;

+

+    /**

+     * DRM (kernel module) version information.

+     */

+    __DRIversion drm_version;

+

+    /**

+     * ID used when the client sets the drawable lock.

+     *

+     * The X server uses this value to detect if the client has died while

+     * holding the drawable lock.

+     */

+    int drawLockID;

+

+    /**

+     * File descriptor returned when the kernel device driver is opened.

+     * 

+     * Used to:

+     *   - authenticate client to kernel

+     *   - map the frame buffer, SAREA, etc.

+     *   - close the kernel device driver

+     */

+    int fd;

+

+    /**

+     * SAREA pointer 

+     *

+     * Used to access:

+     *   - the device lock

+     *   - the device-independent per-drawable and per-context(?) information

+     */

+    drm_sarea_t *pSAREA;

+

+    /**

+     * \name Direct frame buffer access information 

+     * Used for software fallbacks.

+     */

+    /*@{*/

+    unsigned char *pFB;

+    int fbSize;

+    int fbOrigin;

+    int fbStride;

+    int fbWidth;

+    int fbHeight;

+    int fbBPP;

+    /*@}*/

+

+    /**

+     * \name Device-dependent private information (stored in the SAREA).

+     *

+     * This data is accessed by the client driver only.

+     */

+    /*@{*/

+    void *pDevPriv;

+    int devPrivSize;

+    /*@}*/

+

+    /**

+     * Device-dependent private information (not stored in the SAREA).

+     * 

+     * This pointer is never touched by the DRI layer.

+     */

+#ifdef __cplusplus

+    void *priv;

+#else

+    void *private;

+#endif

+

+    /* Extensions provided by the loader. */

+    const __DRIgetDrawableInfoExtension *getDrawableInfo;

+    const __DRIsystemTimeExtension *systemTime;

+    const __DRIdamageExtension *damage;

+

+    struct {

+	/* Flag to indicate that this is a DRI2 screen.  Many of the above

+	 * fields will not be valid or initializaed in that case. */

+	int enabled;

+	__DRIdri2LoaderExtension *loader;

+	__DRIimageLookupExtension *image;

+	__DRIuseInvalidateExtension *useInvalidate;

+    } dri2;

+

+    /* The lock actually in use, old sarea or DRI2 */

+    drmLock *lock;

+

+    driOptionCache optionInfo;

+    driOptionCache optionCache;

+   unsigned int api_mask;

+   void *loaderPrivate;

+};

+

+extern void

+__driUtilUpdateDrawableInfo(__DRIdrawable *pdp);

+

+extern float

+driCalculateSwapUsage( __DRIdrawable *dPriv,

+		       int64_t last_swap_ust, int64_t current_ust );

+

+extern GLint

+driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 );

+

+extern void

+dri2InvalidateDrawable(__DRIdrawable *drawable);

+

+#endif /* _DRI_UTIL_H_ */

diff --git a/mesalib/src/mesa/drivers/dri/common/utils.c b/mesalib/src/mesa/drivers/dri/common/utils.c
index 083edfaa9..a36f65da4 100644
--- a/mesalib/src/mesa/drivers/dri/common/utils.c
+++ b/mesalib/src/mesa/drivers/dri/common/utils.c
@@ -1,824 +1,826 @@
-/*
- * (C) Copyright IBM Corporation 2002, 2004
- * 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
- * on 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
- * VA LINUX SYSTEM, IBM 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.
- */
-
-/**
- * \file utils.c
- * Utility functions for DRI drivers.
- *
- * \author Ian Romanick <idr@us.ibm.com>
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include "main/mtypes.h"
-#include "main/cpuinfo.h"
-#include "main/extensions.h"
-#include "utils.h"
-
-
-/**
- * Print message to \c stderr if the \c LIBGL_DEBUG environment variable
- * is set. 
- * 
- * Is called from the drivers.
- * 
- * \param f \c printf like format string.
- */
-void
-__driUtilMessage(const char *f, ...)
-{
-    va_list args;
-
-    if (getenv("LIBGL_DEBUG")) {
-        fprintf(stderr, "libGL: ");
-        va_start(args, f);
-        vfprintf(stderr, f, args);
-        va_end(args);
-        fprintf(stderr, "\n");
-    }
-}
-
-
-unsigned
-driParseDebugString( const char * debug, 
-		     const struct dri_debug_control * control  )
-{
-   unsigned   flag;
-
-
-   flag = 0;
-   if ( debug != NULL ) {
-      while( control->string != NULL ) {
-	 if ( !strcmp( debug, "all" ) ||
-	      strstr( debug, control->string ) != NULL ) {
-	    flag |= control->flag;
-	 }
-
-	 control++;
-      }
-   }
-
-   return flag;
-}
-
-
-
-/**
- * Create the \c GL_RENDERER string for DRI drivers.
- * 
- * Almost all DRI drivers use a \c GL_RENDERER string of the form:
- *
- *    "Mesa DRI <chip> <driver date> <AGP speed) <CPU information>"
- *
- * Using the supplied chip name, driver data, and AGP speed, this function
- * creates the string.
- * 
- * \param buffer         Buffer to hold the \c GL_RENDERER string.
- * \param hardware_name  Name of the hardware.
- * \param driver_date    Driver date.
- * \param agp_mode       AGP mode (speed).
- * 
- * \returns
- * The length of the string stored in \c buffer.  This does \b not include
- * the terminating \c NUL character.
- */
-unsigned
-driGetRendererString( char * buffer, const char * hardware_name,
-		      const char * driver_date, GLuint agp_mode )
-{
-   unsigned offset;
-   char *cpu;
-
-   offset = sprintf( buffer, "Mesa DRI %s %s", hardware_name, driver_date );
-
-   /* Append any AGP-specific information.
-    */
-   switch ( agp_mode ) {
-   case 1:
-   case 2:
-   case 4:
-   case 8:
-      offset += sprintf( & buffer[ offset ], " AGP %ux", agp_mode );
-      break;
-	
-   default:
-      break;
-   }
-
-   /* Append any CPU-specific information.
-    */
-   cpu = _mesa_get_cpu_string();
-   if (cpu) {
-      offset += sprintf(buffer + offset, " %s", cpu);
-      free(cpu);
-   }
-
-   return offset;
-}
-
-
-
-
-#define need_GL_ARB_copy_buffer
-#define need_GL_ARB_draw_buffers
-#define need_GL_ARB_multisample
-#define need_GL_ARB_texture_compression
-#define need_GL_ARB_transpose_matrix
-#define need_GL_ARB_vertex_buffer_object
-#define need_GL_ARB_window_pos
-#define need_GL_EXT_compiled_vertex_array
-#define need_GL_EXT_multi_draw_arrays
-#define need_GL_EXT_polygon_offset
-#define need_GL_EXT_texture_object
-#define need_GL_EXT_vertex_array
-#define need_GL_IBM_multimode_draw_arrays
-#define need_GL_MESA_window_pos
-
-/* These are needed in *all* drivers because Mesa internally implements
- * certain functionality in terms of functions provided by these extensions.
- * For example, glBlendFunc is implemented by calling glBlendFuncSeparateEXT.
- */
-#define need_GL_EXT_blend_func_separate
-#define need_GL_NV_vertex_program
-
-#include "main/remap_helper.h"
-
-static const struct dri_extension all_mesa_extensions[] = {
-   { "GL_ARB_copy_buffer",           GL_ARB_copy_buffer_functions },
-   { "GL_ARB_draw_buffers",          GL_ARB_draw_buffers_functions },
-   { "GL_ARB_multisample",           GL_ARB_multisample_functions },
-   { "GL_ARB_texture_compression",   GL_ARB_texture_compression_functions },
-   { "GL_ARB_transpose_matrix",      GL_ARB_transpose_matrix_functions },
-   { "GL_ARB_vertex_buffer_object",  GL_ARB_vertex_buffer_object_functions},
-   { "GL_ARB_window_pos",            GL_ARB_window_pos_functions },
-   { "GL_EXT_blend_func_separate",   GL_EXT_blend_func_separate_functions },
-   { "GL_EXT_compiled_vertex_array", GL_EXT_compiled_vertex_array_functions },
-   { "GL_EXT_multi_draw_arrays",     GL_EXT_multi_draw_arrays_functions },
-   { "GL_EXT_polygon_offset",        GL_EXT_polygon_offset_functions },
-   { "GL_EXT_texture_object",        GL_EXT_texture_object_functions },
-   { "GL_EXT_vertex_array",          GL_EXT_vertex_array_functions },
-   { "GL_IBM_multimode_draw_arrays", GL_IBM_multimode_draw_arrays_functions },
-   { "GL_MESA_window_pos",           GL_MESA_window_pos_functions },
-   { "GL_NV_vertex_program",         GL_NV_vertex_program_functions },
-   { NULL,                           NULL }
-};
-
-
-/**
- * Enable and map extensions supported by the driver.
- * 
- * When ctx is NULL, extensions are not enabled, but their functions
- * are still mapped.  When extensions_to_enable is NULL, all static
- * functions known to mesa core are mapped.
- *
- * \bug
- * ARB_imaging isn't handled properly.  In Mesa, enabling ARB_imaging also
- * enables all the sub-extensions that are folded into it.  This means that
- * we need to add entry-points (via \c driInitSingleExtension) for those
- * new functions here.
- */
-void driInitExtensions( struct gl_context * ctx,
-			const struct dri_extension * extensions_to_enable,
-			GLboolean enable_imaging )
-{
-   static int first_time = 1;
-   unsigned   i;
-
-   if ( first_time ) {
-      first_time = 0;
-      driInitExtensions( NULL, all_mesa_extensions, GL_FALSE );
-   }
-
-   if ( (ctx != NULL) && enable_imaging ) {
-      _mesa_enable_imaging_extensions( ctx );
-   }
-
-   /* The caller is too lazy to list any extension */
-   if ( extensions_to_enable == NULL ) {
-      /* Map the static functions.  Together with those mapped by remap
-       * table, this should cover everything mesa core knows.
-       */
-      _mesa_map_static_functions();
-      return;
-   }
-
-   for ( i = 0 ; extensions_to_enable[i].name != NULL ; i++ ) {
-       driInitSingleExtension( ctx, & extensions_to_enable[i] );
-   }
-}
-
-
-
-
-/**
- * Enable and map functions for a single extension
- * 
- * \param ctx  Context where extension is to be enabled.
- * \param ext  Extension that is to be enabled.
- * 
- * \sa driInitExtensions, _mesa_enable_extension, _mesa_map_function_array
- */
-void driInitSingleExtension( struct gl_context * ctx,
-			     const struct dri_extension * ext )
-{
-    if ( ext->functions != NULL ) {
-       _mesa_map_function_array(ext->functions);
-    }
-
-    if ( ctx != NULL ) {
-	_mesa_enable_extension( ctx, ext->name );
-    }
-}
-
-
-/**
- * Utility function used by drivers to test the verions of other components.
- *
- * \param driver_name  Name of the driver.  Used in error messages.
- * \param driActual    Actual DRI version supplied __driCreateNewScreen.
- * \param driExpected  Minimum DRI version required by the driver.
- * \param ddxActual    Actual DDX version supplied __driCreateNewScreen.
- * \param ddxExpected  Minimum DDX minor and range of DDX major version required by the driver.
- * \param drmActual    Actual DRM version supplied __driCreateNewScreen.
- * \param drmExpected  Minimum DRM version required by the driver.
- * 
- * \returns \c GL_TRUE if all version requirements are met.  Otherwise,
- *          \c GL_FALSE is returned.
- * 
- * \sa __driCreateNewScreen, driCheckDriDdxDrmVersions2
- *
- * \todo
- * Now that the old \c driCheckDriDdxDrmVersions function is gone, this
- * function and \c driCheckDriDdxDrmVersions2 should be renamed.
- */
-GLboolean
-driCheckDriDdxDrmVersions3(const char * driver_name,
-			   const __DRIversion * driActual,
-			   const __DRIversion * driExpected,
-			   const __DRIversion * ddxActual,
-			   const __DRIutilversion2 * ddxExpected,
-			   const __DRIversion * drmActual,
-			   const __DRIversion * drmExpected)
-{
-   static const char format[] = "%s DRI driver expected %s version %d.%d.x "
-       "but got version %d.%d.%d\n";
-   static const char format2[] = "%s DRI driver expected %s version %d-%d.%d.x "
-       "but got version %d.%d.%d\n";
-
-
-   /* Check the DRI version */
-   if ( (driActual->major != driExpected->major)
-	|| (driActual->minor < driExpected->minor) ) {
-      fprintf(stderr, format, driver_name, "DRI",
-		       driExpected->major, driExpected->minor,
-		       driActual->major, driActual->minor, driActual->patch);
-      return GL_FALSE;
-   }
-
-   /* Check that the DDX driver version is compatible */
-   if ( (ddxActual->major < ddxExpected->major_min)
-	|| (ddxActual->major > ddxExpected->major_max)
-	|| (ddxActual->minor < ddxExpected->minor) ) {
-      fprintf(stderr, format2, driver_name, "DDX",
-		       ddxExpected->major_min, ddxExpected->major_max, ddxExpected->minor,
-		       ddxActual->major, ddxActual->minor, ddxActual->patch);
-      return GL_FALSE;
-   }
-   
-   /* Check that the DRM driver version is compatible */
-   if ( (drmActual->major != drmExpected->major)
-	|| (drmActual->minor < drmExpected->minor) ) {
-      fprintf(stderr, format, driver_name, "DRM",
-		       drmExpected->major, drmExpected->minor,
-		       drmActual->major, drmActual->minor, drmActual->patch);
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-GLboolean
-driCheckDriDdxDrmVersions2(const char * driver_name,
-			   const __DRIversion * driActual,
-			   const __DRIversion * driExpected,
-			   const __DRIversion * ddxActual,
-			   const __DRIversion * ddxExpected,
-			   const __DRIversion * drmActual,
-			   const __DRIversion * drmExpected)
-{
-   __DRIutilversion2 ddx_expected;
-   ddx_expected.major_min = ddxExpected->major;
-   ddx_expected.major_max = ddxExpected->major;
-   ddx_expected.minor = ddxExpected->minor;
-   ddx_expected.patch = ddxExpected->patch;
-   return driCheckDriDdxDrmVersions3(driver_name, driActual,
-				driExpected, ddxActual, & ddx_expected,
-				drmActual, drmExpected);
-}
-
-GLboolean driClipRectToFramebuffer( const struct gl_framebuffer *buffer,
-				    GLint *x, GLint *y,
-				    GLsizei *width, GLsizei *height )
-{
-   /* left clipping */
-   if (*x < buffer->_Xmin) {
-      *width -= (buffer->_Xmin - *x);
-      *x = buffer->_Xmin;
-   }
-
-   /* right clipping */
-   if (*x + *width > buffer->_Xmax)
-      *width -= (*x + *width - buffer->_Xmax - 1);
-
-   if (*width <= 0)
-      return GL_FALSE;
-
-   /* bottom clipping */
-   if (*y < buffer->_Ymin) {
-      *height -= (buffer->_Ymin - *y);
-      *y = buffer->_Ymin;
-   }
-
-   /* top clipping */
-   if (*y + *height > buffer->_Ymax)
-      *height -= (*y + *height - buffer->_Ymax - 1);
-
-   if (*height <= 0)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-/**
- * Creates a set of \c struct gl_config that a driver will expose.
- * 
- * A set of \c struct gl_config will be created based on the supplied
- * parameters.  The number of modes processed will be 2 *
- * \c num_depth_stencil_bits * \c num_db_modes.
- * 
- * For the most part, data is just copied from \c depth_bits, \c stencil_bits,
- * \c db_modes, and \c visType into each \c struct gl_config element.
- * However, the meanings of \c fb_format and \c fb_type require further
- * explanation.  The \c fb_format specifies which color components are in
- * each pixel and what the default order is.  For example, \c GL_RGB specifies
- * that red, green, blue are available and red is in the "most significant"
- * position and blue is in the "least significant".  The \c fb_type specifies
- * the bit sizes of each component and the actual ordering.  For example, if
- * \c GL_UNSIGNED_SHORT_5_6_5_REV is specified with \c GL_RGB, bits [15:11]
- * are the blue value, bits [10:5] are the green value, and bits [4:0] are
- * the red value.
- * 
- * One sublte issue is the combination of \c GL_RGB  or \c GL_BGR and either
- * of the \c GL_UNSIGNED_INT_8_8_8_8 modes.  The resulting mask values in the
- * \c struct gl_config structure is \b identical to the \c GL_RGBA or
- * \c GL_BGRA case, except the \c alphaMask is zero.  This means that, as
- * far as this routine is concerned, \c GL_RGB with \c GL_UNSIGNED_INT_8_8_8_8
- * still uses 32-bits.
- *
- * If in doubt, look at the tables used in the function.
- * 
- * \param ptr_to_modes  Pointer to a pointer to a linked list of
- *                      \c struct gl_config.  Upon completion, a pointer to
- *                      the next element to be process will be stored here.
- *                      If the function fails and returns \c GL_FALSE, this
- *                      value will be unmodified, but some elements in the
- *                      linked list may be modified.
- * \param fb_format     Format of the framebuffer.  Currently only \c GL_RGB,
- *                      \c GL_RGBA, \c GL_BGR, and \c GL_BGRA are supported.
- * \param fb_type       Type of the pixels in the framebuffer.  Currently only
- *                      \c GL_UNSIGNED_SHORT_5_6_5, 
- *                      \c GL_UNSIGNED_SHORT_5_6_5_REV,
- *                      \c GL_UNSIGNED_INT_8_8_8_8, and
- *                      \c GL_UNSIGNED_INT_8_8_8_8_REV are supported.
- * \param depth_bits    Array of depth buffer sizes to be exposed.
- * \param stencil_bits  Array of stencil buffer sizes to be exposed.
- * \param num_depth_stencil_bits  Number of entries in both \c depth_bits and
- *                      \c stencil_bits.
- * \param db_modes      Array of buffer swap modes.  If an element has a
- *                      value of \c GLX_NONE, then it represents a
- *                      single-buffered mode.  Other valid values are
- *                      \c GLX_SWAP_EXCHANGE_OML, \c GLX_SWAP_COPY_OML, and
- *                      \c GLX_SWAP_UNDEFINED_OML.  See the
- *                      GLX_OML_swap_method extension spec for more details.
- * \param num_db_modes  Number of entries in \c db_modes.
- * \param msaa_samples  Array of msaa sample count. 0 represents a visual
- *                      without a multisample buffer.
- * \param num_msaa_modes Number of entries in \c msaa_samples.
- * \param visType       GLX visual type.  Usually either \c GLX_TRUE_COLOR or
- *                      \c GLX_DIRECT_COLOR.
- * 
- * \returns
- * \c GL_TRUE on success or \c GL_FALSE on failure.  Currently the only
- * cause of failure is a bad parameter (i.e., unsupported \c fb_format or
- * \c fb_type).
- * 
- * \todo
- * There is currently no way to support packed RGB modes (i.e., modes with
- * exactly 3 bytes per pixel) or floating-point modes.  This could probably
- * be done by creating some new, private enums with clever names likes
- * \c GL_UNSIGNED_3BYTE_8_8_8, \c GL_4FLOAT_32_32_32_32, 
- * \c GL_4HALF_16_16_16_16, etc.  We can cross that bridge when we come to it.
- */
-__DRIconfig **
-driCreateConfigs(GLenum fb_format, GLenum fb_type,
-		 const uint8_t * depth_bits, const uint8_t * stencil_bits,
-		 unsigned num_depth_stencil_bits,
-		 const GLenum * db_modes, unsigned num_db_modes,
-		 const uint8_t * msaa_samples, unsigned num_msaa_modes,
-		 GLboolean enable_accum)
-{
-   static const uint8_t bits_table[4][4] = {
-     /* R  G  B  A */
-      { 3, 3, 2, 0 }, /* Any GL_UNSIGNED_BYTE_3_3_2 */
-      { 5, 6, 5, 0 }, /* Any GL_UNSIGNED_SHORT_5_6_5 */
-      { 8, 8, 8, 0 }, /* Any RGB with any GL_UNSIGNED_INT_8_8_8_8 */
-      { 8, 8, 8, 8 }  /* Any RGBA with any GL_UNSIGNED_INT_8_8_8_8 */
-   };
-
-   static const uint32_t masks_table_rgb[6][4] = {
-      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 3_3_2       */
-      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 2_3_3_REV   */
-      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5       */
-      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5_REV   */
-      { 0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000 }, /* 8_8_8_8     */
-      { 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }  /* 8_8_8_8_REV */
-   };
-
-   static const uint32_t masks_table_rgba[6][4] = {
-      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 3_3_2       */
-      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 2_3_3_REV   */
-      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5       */
-      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5_REV   */
-      { 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF }, /* 8_8_8_8     */
-      { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }, /* 8_8_8_8_REV */
-   };
-
-   static const uint32_t masks_table_bgr[6][4] = {
-      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 3_3_2       */
-      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 2_3_3_REV   */
-      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5       */
-      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5_REV   */
-      { 0x0000FF00, 0x00FF0000, 0xFF000000, 0x00000000 }, /* 8_8_8_8     */
-      { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }, /* 8_8_8_8_REV */
-   };
-
-   static const uint32_t masks_table_bgra[6][4] = {
-      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 3_3_2       */
-      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 2_3_3_REV   */
-      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5       */
-      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5_REV   */
-      { 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF }, /* 8_8_8_8     */
-      { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }, /* 8_8_8_8_REV */
-   };
-
-   static const uint8_t bytes_per_pixel[6] = {
-      1, /* 3_3_2       */
-      1, /* 2_3_3_REV   */
-      2, /* 5_6_5       */
-      2, /* 5_6_5_REV   */
-      4, /* 8_8_8_8     */
-      4  /* 8_8_8_8_REV */
-   };
-
-   const uint8_t  * bits;
-   const uint32_t * masks;
-   int index;
-   __DRIconfig **configs, **c;
-   struct gl_config *modes;
-   unsigned i, j, k, h;
-   unsigned num_modes;
-   unsigned num_accum_bits = (enable_accum) ? 2 : 1;
-
-   switch ( fb_type ) {
-      case GL_UNSIGNED_BYTE_3_3_2:
-	 index = 0;
-	 break;
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-	 index = 1;
-	 break;
-      case GL_UNSIGNED_SHORT_5_6_5:
-	 index = 2;
-	 break;
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-	 index = 3;
-	 break;
-      case GL_UNSIGNED_INT_8_8_8_8:
-	 index = 4;
-	 break;
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-	 index = 5;
-	 break;
-      default:
-	 fprintf( stderr, "[%s:%u] Unknown framebuffer type 0x%04x.\n",
-               __FUNCTION__, __LINE__, fb_type );
-	 return NULL;
-   }
-
-
-   /* Valid types are GL_UNSIGNED_SHORT_5_6_5 and GL_UNSIGNED_INT_8_8_8_8 and
-    * the _REV versions.
-    *
-    * Valid formats are GL_RGBA, GL_RGB, and GL_BGRA.
-    */
-
-   switch ( fb_format ) {
-      case GL_RGB:
-         masks = masks_table_rgb[ index ];
-         break;
-
-      case GL_RGBA:
-         masks = masks_table_rgba[ index ];
-         break;
-
-      case GL_BGR:
-         masks = masks_table_bgr[ index ];
-         break;
-
-      case GL_BGRA:
-         masks = masks_table_bgra[ index ];
-         break;
-
-      default:
-         fprintf( stderr, "[%s:%u] Unknown framebuffer format 0x%04x.\n",
-               __FUNCTION__, __LINE__, fb_format );
-         return NULL;
-   }
-
-   switch ( bytes_per_pixel[ index ] ) {
-      case 1:
-	 bits = bits_table[0];
-	 break;
-      case 2:
-	 bits = bits_table[1];
-	 break;
-      default:
-	 bits = ((fb_format == GL_RGB) || (fb_format == GL_BGR))
-	    ? bits_table[2]
-	    : bits_table[3];
-	 break;
-   }
-
-   num_modes = num_depth_stencil_bits * num_db_modes * num_accum_bits * num_msaa_modes;
-   configs = calloc(1, (num_modes + 1) * sizeof *configs);
-   if (configs == NULL)
-       return NULL;
-
-    c = configs;
-    for ( k = 0 ; k < num_depth_stencil_bits ; k++ ) {
-	for ( i = 0 ; i < num_db_modes ; i++ ) {
-	    for ( h = 0 ; h < num_msaa_modes; h++ ) {
-	    	for ( j = 0 ; j < num_accum_bits ; j++ ) {
-		    *c = malloc (sizeof **c);
-		    modes = &(*c)->modes;
-		    c++;
-
-		    memset(modes, 0, sizeof *modes);
-		    modes->redBits   = bits[0];
-		    modes->greenBits = bits[1];
-		    modes->blueBits  = bits[2];
-		    modes->alphaBits = bits[3];
-		    modes->redMask   = masks[0];
-		    modes->greenMask = masks[1];
-		    modes->blueMask  = masks[2];
-		    modes->alphaMask = masks[3];
-		    modes->rgbBits   = modes->redBits + modes->greenBits
-		    	+ modes->blueBits + modes->alphaBits;
-
-		    modes->accumRedBits   = 16 * j;
-		    modes->accumGreenBits = 16 * j;
-		    modes->accumBlueBits  = 16 * j;
-		    modes->accumAlphaBits = (masks[3] != 0) ? 16 * j : 0;
-		    modes->visualRating = (j == 0) ? GLX_NONE : GLX_SLOW_CONFIG;
-
-		    modes->stencilBits = stencil_bits[k];
-		    modes->depthBits = depth_bits[k];
-
-		    modes->transparentPixel = GLX_NONE;
-		    modes->transparentRed = GLX_DONT_CARE;
-		    modes->transparentGreen = GLX_DONT_CARE;
-		    modes->transparentBlue = GLX_DONT_CARE;
-		    modes->transparentAlpha = GLX_DONT_CARE;
-		    modes->transparentIndex = GLX_DONT_CARE;
-		    modes->rgbMode = GL_TRUE;
-
-		    if ( db_modes[i] == GLX_NONE ) {
-		    	modes->doubleBufferMode = GL_FALSE;
-		    }
-		    else {
-		    	modes->doubleBufferMode = GL_TRUE;
-		    	modes->swapMethod = db_modes[i];
-		    }
-
-		    modes->samples = msaa_samples[h];
-		    modes->sampleBuffers = modes->samples ? 1 : 0;
-
-
-		    modes->haveAccumBuffer = ((modes->accumRedBits +
-					   modes->accumGreenBits +
-					   modes->accumBlueBits +
-					   modes->accumAlphaBits) > 0);
-		    modes->haveDepthBuffer = (modes->depthBits > 0);
-		    modes->haveStencilBuffer = (modes->stencilBits > 0);
-
-		    modes->bindToTextureRgb = GL_TRUE;
-		    modes->bindToTextureRgba = GL_TRUE;
-		    modes->bindToMipmapTexture = GL_FALSE;
-		    modes->bindToTextureTargets =
-			__DRI_ATTRIB_TEXTURE_1D_BIT |
-			__DRI_ATTRIB_TEXTURE_2D_BIT |
-			__DRI_ATTRIB_TEXTURE_RECTANGLE_BIT;
-
-		    modes->sRGBCapable = GL_FALSE;
-		}
-	    }
-	}
-    }
-    *c = NULL;
-
-    return configs;
-}
-
-__DRIconfig **driConcatConfigs(__DRIconfig **a,
-			       __DRIconfig **b)
-{
-    __DRIconfig **all;
-    int i, j, index;
-
-    i = 0;
-    while (a[i] != NULL)
-	i++;
-    j = 0;
-    while (b[j] != NULL)
-	j++;
-   
-    all = malloc((i + j + 1) * sizeof *all);
-    index = 0;
-    for (i = 0; a[i] != NULL; i++)
-	all[index++] = a[i];
-    for (j = 0; b[j] != NULL; j++)
-	all[index++] = b[j];
-    all[index++] = NULL;
-
-    free(a);
-    free(b);
-
-    return all;
-}
-
-#define __ATTRIB(attrib, field) \
-    { attrib, offsetof(struct gl_config, field) }
-
-static const struct { unsigned int attrib, offset; } attribMap[] = {
-    __ATTRIB(__DRI_ATTRIB_BUFFER_SIZE,			rgbBits),
-    __ATTRIB(__DRI_ATTRIB_LEVEL,			level),
-    __ATTRIB(__DRI_ATTRIB_RED_SIZE,			redBits),
-    __ATTRIB(__DRI_ATTRIB_GREEN_SIZE,			greenBits),
-    __ATTRIB(__DRI_ATTRIB_BLUE_SIZE,			blueBits),
-    __ATTRIB(__DRI_ATTRIB_ALPHA_SIZE,			alphaBits),
-    __ATTRIB(__DRI_ATTRIB_DEPTH_SIZE,			depthBits),
-    __ATTRIB(__DRI_ATTRIB_STENCIL_SIZE,			stencilBits),
-    __ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE,		accumRedBits),
-    __ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE,		accumGreenBits),
-    __ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE,		accumBlueBits),
-    __ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE,		accumAlphaBits),
-    __ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS,		sampleBuffers),
-    __ATTRIB(__DRI_ATTRIB_SAMPLES,			samples),
-    __ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER,		doubleBufferMode),
-    __ATTRIB(__DRI_ATTRIB_STEREO,			stereoMode),
-    __ATTRIB(__DRI_ATTRIB_AUX_BUFFERS,			numAuxBuffers),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_TYPE,		transparentPixel),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_INDEX_VALUE,	transparentPixel),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_RED_VALUE,	transparentRed),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_GREEN_VALUE,	transparentGreen),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_BLUE_VALUE,	transparentBlue),
-    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE,	transparentAlpha),
-    __ATTRIB(__DRI_ATTRIB_FLOAT_MODE,			floatMode),
-    __ATTRIB(__DRI_ATTRIB_RED_MASK,			redMask),
-    __ATTRIB(__DRI_ATTRIB_GREEN_MASK,			greenMask),
-    __ATTRIB(__DRI_ATTRIB_BLUE_MASK,			blueMask),
-    __ATTRIB(__DRI_ATTRIB_ALPHA_MASK,			alphaMask),
-    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH,		maxPbufferWidth),
-    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT,		maxPbufferHeight),
-    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS,		maxPbufferPixels),
-    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH,	optimalPbufferWidth),
-    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT,	optimalPbufferHeight),
-    __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,			swapMethod),
-    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB,		bindToTextureRgb),
-    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA,		bindToTextureRgba),
-    __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,	bindToMipmapTexture),
-    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS,	bindToTextureTargets),
-    __ATTRIB(__DRI_ATTRIB_YINVERTED,			yInverted),
-    __ATTRIB(__DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE,	sRGBCapable),
-
-    /* The struct field doesn't matter here, these are handled by the
-     * switch in driGetConfigAttribIndex.  We need them in the array
-     * so the iterator includes them though.*/
-    __ATTRIB(__DRI_ATTRIB_RENDER_TYPE,			level),
-    __ATTRIB(__DRI_ATTRIB_CONFIG_CAVEAT,		level),
-    __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,			level)
-};
-
-#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
-
-
-/**
- * Return the value of a configuration attribute.  The attribute is
- * indicated by the index.
- */
-static int
-driGetConfigAttribIndex(const __DRIconfig *config,
-			unsigned int index, unsigned int *value)
-{
-    switch (attribMap[index].attrib) {
-    case __DRI_ATTRIB_RENDER_TYPE:
-        /* no support for color index mode */
-	*value = __DRI_ATTRIB_RGBA_BIT;
-	break;
-    case __DRI_ATTRIB_CONFIG_CAVEAT:
-	if (config->modes.visualRating == GLX_NON_CONFORMANT_CONFIG)
-	    *value = __DRI_ATTRIB_NON_CONFORMANT_CONFIG;
-	else if (config->modes.visualRating == GLX_SLOW_CONFIG)
-	    *value = __DRI_ATTRIB_SLOW_BIT;
-	else
-	    *value = 0;
-	break;
-    case __DRI_ATTRIB_SWAP_METHOD:
-        /* XXX no return value??? */
-	break;
-
-    case __DRI_ATTRIB_FLOAT_MODE:
-        /* this field is not int-sized */
-        *value = config->modes.floatMode;
-        break;
-
-    default:
-        /* any other int-sized field */
-	*value = *(unsigned int *)
-	    ((char *) &config->modes + attribMap[index].offset);
-	
-	break;
-    }
-
-    return GL_TRUE;
-}
-
-
-/**
- * Get the value of a configuration attribute.
- * \param attrib  the attribute (one of the _DRI_ATTRIB_x tokens)
- * \param value  returns the attribute's value
- * \return 1 for success, 0 for failure
- */
-int
-driGetConfigAttrib(const __DRIconfig *config,
-		   unsigned int attrib, unsigned int *value)
-{
-    int i;
-
-    for (i = 0; i < ARRAY_SIZE(attribMap); i++)
-	if (attribMap[i].attrib == attrib)
-	    return driGetConfigAttribIndex(config, i, value);
-
-    return GL_FALSE;
-}
-
-
-/**
- * Get a configuration attribute name and value, given an index.
- * \param index  which field of the __DRIconfig to query
- * \param attrib  returns the attribute name (one of the _DRI_ATTRIB_x tokens)
- * \param value  returns the attribute's value
- * \return 1 for success, 0 for failure
- */
-int
-driIndexConfigAttrib(const __DRIconfig *config, int index,
-		     unsigned int *attrib, unsigned int *value)
-{
-    if (index >= 0 && index < ARRAY_SIZE(attribMap)) {
-	*attrib = attribMap[index].attrib;
-	return driGetConfigAttribIndex(config, index, value);
-    }
-
-    return GL_FALSE;
-}
+/*

+ * (C) Copyright IBM Corporation 2002, 2004

+ * 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

+ * on 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

+ * VA LINUX SYSTEM, IBM 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.

+ */

+

+/**

+ * \file utils.c

+ * Utility functions for DRI drivers.

+ *

+ * \author Ian Romanick <idr@us.ibm.com>

+ */

+

+#include <string.h>

+#include <stdlib.h>

+#include "main/mtypes.h"

+#include "main/cpuinfo.h"

+#include "main/extensions.h"

+#include "utils.h"

+

+

+/**

+ * Print message to \c stderr if the \c LIBGL_DEBUG environment variable

+ * is set. 

+ * 

+ * Is called from the drivers.

+ * 

+ * \param f \c printf like format string.

+ */

+void

+__driUtilMessage(const char *f, ...)

+{

+    va_list args;

+

+    if (getenv("LIBGL_DEBUG")) {

+        fprintf(stderr, "libGL: ");

+        va_start(args, f);

+        vfprintf(stderr, f, args);

+        va_end(args);

+        fprintf(stderr, "\n");

+    }

+}

+

+

+unsigned

+driParseDebugString( const char * debug, 

+		     const struct dri_debug_control * control  )

+{

+   unsigned   flag;

+

+

+   flag = 0;

+   if ( debug != NULL ) {

+      while( control->string != NULL ) {

+	 if ( !strcmp( debug, "all" ) ||

+	      strstr( debug, control->string ) != NULL ) {

+	    flag |= control->flag;

+	 }

+

+	 control++;

+      }

+   }

+

+   return flag;

+}

+

+

+

+/**

+ * Create the \c GL_RENDERER string for DRI drivers.

+ * 

+ * Almost all DRI drivers use a \c GL_RENDERER string of the form:

+ *

+ *    "Mesa DRI <chip> <driver date> <AGP speed) <CPU information>"

+ *

+ * Using the supplied chip name, driver data, and AGP speed, this function

+ * creates the string.

+ * 

+ * \param buffer         Buffer to hold the \c GL_RENDERER string.

+ * \param hardware_name  Name of the hardware.

+ * \param driver_date    Driver date.

+ * \param agp_mode       AGP mode (speed).

+ * 

+ * \returns

+ * The length of the string stored in \c buffer.  This does \b not include

+ * the terminating \c NUL character.

+ */

+unsigned

+driGetRendererString( char * buffer, const char * hardware_name,

+		      const char * driver_date, GLuint agp_mode )

+{

+   unsigned offset;

+   char *cpu;

+

+   offset = sprintf( buffer, "Mesa DRI %s %s", hardware_name, driver_date );

+

+   /* Append any AGP-specific information.

+    */

+   switch ( agp_mode ) {

+   case 1:

+   case 2:

+   case 4:

+   case 8:

+      offset += sprintf( & buffer[ offset ], " AGP %ux", agp_mode );

+      break;

+	

+   default:

+      break;

+   }

+

+   /* Append any CPU-specific information.

+    */

+   cpu = _mesa_get_cpu_string();

+   if (cpu) {

+      offset += sprintf(buffer + offset, " %s", cpu);

+      free(cpu);

+   }

+

+   return offset;

+}

+

+

+

+

+#define need_GL_ARB_copy_buffer

+#define need_GL_ARB_draw_buffers

+#define need_GL_ARB_multisample

+#define need_GL_ARB_texture_compression

+#define need_GL_ARB_transpose_matrix

+#define need_GL_ARB_vertex_buffer_object

+#define need_GL_ARB_window_pos

+#define need_GL_EXT_compiled_vertex_array

+#define need_GL_EXT_multi_draw_arrays

+#define need_GL_EXT_polygon_offset

+#define need_GL_EXT_texture_object

+#define need_GL_EXT_vertex_array

+#define need_GL_IBM_multimode_draw_arrays

+#define need_GL_MESA_window_pos

+

+/* These are needed in *all* drivers because Mesa internally implements

+ * certain functionality in terms of functions provided by these extensions.

+ * For example, glBlendFunc is implemented by calling glBlendFuncSeparateEXT.

+ */

+#define need_GL_EXT_blend_func_separate

+#define need_GL_NV_vertex_program

+

+#include "main/remap_helper.h"

+

+static const struct dri_extension all_mesa_extensions[] = {

+   { "GL_ARB_copy_buffer",           GL_ARB_copy_buffer_functions },

+   { "GL_ARB_draw_buffers",          GL_ARB_draw_buffers_functions },

+   { "GL_ARB_multisample",           GL_ARB_multisample_functions },

+   { "GL_ARB_texture_compression",   GL_ARB_texture_compression_functions },

+   { "GL_ARB_transpose_matrix",      GL_ARB_transpose_matrix_functions },

+   { "GL_ARB_vertex_buffer_object",  GL_ARB_vertex_buffer_object_functions},

+   { "GL_ARB_window_pos",            GL_ARB_window_pos_functions },

+   { "GL_EXT_blend_func_separate",   GL_EXT_blend_func_separate_functions },

+   { "GL_EXT_compiled_vertex_array", GL_EXT_compiled_vertex_array_functions },

+   { "GL_EXT_multi_draw_arrays",     GL_EXT_multi_draw_arrays_functions },

+   { "GL_EXT_polygon_offset",        GL_EXT_polygon_offset_functions },

+   { "GL_EXT_texture_object",        GL_EXT_texture_object_functions },

+   { "GL_EXT_vertex_array",          GL_EXT_vertex_array_functions },

+   { "GL_IBM_multimode_draw_arrays", GL_IBM_multimode_draw_arrays_functions },

+   { "GL_MESA_window_pos",           GL_MESA_window_pos_functions },

+   { "GL_NV_vertex_program",         GL_NV_vertex_program_functions },

+   { NULL,                           NULL }

+};

+

+

+/**

+ * Enable and map extensions supported by the driver.

+ * 

+ * When ctx is NULL, extensions are not enabled, but their functions

+ * are still mapped.  When extensions_to_enable is NULL, all static

+ * functions known to mesa core are mapped.

+ *

+ * \bug

+ * ARB_imaging isn't handled properly.  In Mesa, enabling ARB_imaging also

+ * enables all the sub-extensions that are folded into it.  This means that

+ * we need to add entry-points (via \c driInitSingleExtension) for those

+ * new functions here.

+ */

+void driInitExtensions( struct gl_context * ctx,

+			const struct dri_extension * extensions_to_enable,

+			GLboolean enable_imaging )

+{

+   static int first_time = 1;

+   unsigned   i;

+

+   if ( first_time ) {

+      first_time = 0;

+      driInitExtensions( NULL, all_mesa_extensions, GL_FALSE );

+   }

+

+   if ( (ctx != NULL) && enable_imaging ) {

+      _mesa_enable_imaging_extensions( ctx );

+   }

+

+   /* The caller is too lazy to list any extension */

+   if ( extensions_to_enable == NULL ) {

+      /* Map the static functions.  Together with those mapped by remap

+       * table, this should cover everything mesa core knows.

+       */

+#ifdef _GLAPI_USE_REMAP_TABLE

+      _mesa_map_static_functions();

+#endif

+      return;

+   }

+

+   for ( i = 0 ; extensions_to_enable[i].name != NULL ; i++ ) {

+       driInitSingleExtension( ctx, & extensions_to_enable[i] );

+   }

+}

+

+

+

+

+/**

+ * Enable and map functions for a single extension

+ * 

+ * \param ctx  Context where extension is to be enabled.

+ * \param ext  Extension that is to be enabled.

+ * 

+ * \sa driInitExtensions, _mesa_enable_extension, _mesa_map_function_array

+ */

+void driInitSingleExtension( struct gl_context * ctx,

+			     const struct dri_extension * ext )

+{

+    if ( ext->functions != NULL ) {

+       _mesa_map_function_array(ext->functions);

+    }

+

+    if ( ctx != NULL ) {

+	_mesa_enable_extension( ctx, ext->name );

+    }

+}

+

+

+/**

+ * Utility function used by drivers to test the verions of other components.

+ *

+ * \param driver_name  Name of the driver.  Used in error messages.

+ * \param driActual    Actual DRI version supplied __driCreateNewScreen.

+ * \param driExpected  Minimum DRI version required by the driver.

+ * \param ddxActual    Actual DDX version supplied __driCreateNewScreen.

+ * \param ddxExpected  Minimum DDX minor and range of DDX major version required by the driver.

+ * \param drmActual    Actual DRM version supplied __driCreateNewScreen.

+ * \param drmExpected  Minimum DRM version required by the driver.

+ * 

+ * \returns \c GL_TRUE if all version requirements are met.  Otherwise,

+ *          \c GL_FALSE is returned.

+ * 

+ * \sa __driCreateNewScreen, driCheckDriDdxDrmVersions2

+ *

+ * \todo

+ * Now that the old \c driCheckDriDdxDrmVersions function is gone, this

+ * function and \c driCheckDriDdxDrmVersions2 should be renamed.

+ */

+GLboolean

+driCheckDriDdxDrmVersions3(const char * driver_name,

+			   const __DRIversion * driActual,

+			   const __DRIversion * driExpected,

+			   const __DRIversion * ddxActual,

+			   const __DRIutilversion2 * ddxExpected,

+			   const __DRIversion * drmActual,

+			   const __DRIversion * drmExpected)

+{

+   static const char format[] = "%s DRI driver expected %s version %d.%d.x "

+       "but got version %d.%d.%d\n";

+   static const char format2[] = "%s DRI driver expected %s version %d-%d.%d.x "

+       "but got version %d.%d.%d\n";

+

+

+   /* Check the DRI version */

+   if ( (driActual->major != driExpected->major)

+	|| (driActual->minor < driExpected->minor) ) {

+      fprintf(stderr, format, driver_name, "DRI",

+		       driExpected->major, driExpected->minor,

+		       driActual->major, driActual->minor, driActual->patch);

+      return GL_FALSE;

+   }

+

+   /* Check that the DDX driver version is compatible */

+   if ( (ddxActual->major < ddxExpected->major_min)

+	|| (ddxActual->major > ddxExpected->major_max)

+	|| (ddxActual->minor < ddxExpected->minor) ) {

+      fprintf(stderr, format2, driver_name, "DDX",

+		       ddxExpected->major_min, ddxExpected->major_max, ddxExpected->minor,

+		       ddxActual->major, ddxActual->minor, ddxActual->patch);

+      return GL_FALSE;

+   }

+   

+   /* Check that the DRM driver version is compatible */

+   if ( (drmActual->major != drmExpected->major)

+	|| (drmActual->minor < drmExpected->minor) ) {

+      fprintf(stderr, format, driver_name, "DRM",

+		       drmExpected->major, drmExpected->minor,

+		       drmActual->major, drmActual->minor, drmActual->patch);

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+GLboolean

+driCheckDriDdxDrmVersions2(const char * driver_name,

+			   const __DRIversion * driActual,

+			   const __DRIversion * driExpected,

+			   const __DRIversion * ddxActual,

+			   const __DRIversion * ddxExpected,

+			   const __DRIversion * drmActual,

+			   const __DRIversion * drmExpected)

+{

+   __DRIutilversion2 ddx_expected;

+   ddx_expected.major_min = ddxExpected->major;

+   ddx_expected.major_max = ddxExpected->major;

+   ddx_expected.minor = ddxExpected->minor;

+   ddx_expected.patch = ddxExpected->patch;

+   return driCheckDriDdxDrmVersions3(driver_name, driActual,

+				driExpected, ddxActual, & ddx_expected,

+				drmActual, drmExpected);

+}

+

+GLboolean driClipRectToFramebuffer( const struct gl_framebuffer *buffer,

+				    GLint *x, GLint *y,

+				    GLsizei *width, GLsizei *height )

+{

+   /* left clipping */

+   if (*x < buffer->_Xmin) {

+      *width -= (buffer->_Xmin - *x);

+      *x = buffer->_Xmin;

+   }

+

+   /* right clipping */

+   if (*x + *width > buffer->_Xmax)

+      *width -= (*x + *width - buffer->_Xmax - 1);

+

+   if (*width <= 0)

+      return GL_FALSE;

+

+   /* bottom clipping */

+   if (*y < buffer->_Ymin) {

+      *height -= (buffer->_Ymin - *y);

+      *y = buffer->_Ymin;

+   }

+

+   /* top clipping */

+   if (*y + *height > buffer->_Ymax)

+      *height -= (*y + *height - buffer->_Ymax - 1);

+

+   if (*height <= 0)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+/**

+ * Creates a set of \c struct gl_config that a driver will expose.

+ * 

+ * A set of \c struct gl_config will be created based on the supplied

+ * parameters.  The number of modes processed will be 2 *

+ * \c num_depth_stencil_bits * \c num_db_modes.

+ * 

+ * For the most part, data is just copied from \c depth_bits, \c stencil_bits,

+ * \c db_modes, and \c visType into each \c struct gl_config element.

+ * However, the meanings of \c fb_format and \c fb_type require further

+ * explanation.  The \c fb_format specifies which color components are in

+ * each pixel and what the default order is.  For example, \c GL_RGB specifies

+ * that red, green, blue are available and red is in the "most significant"

+ * position and blue is in the "least significant".  The \c fb_type specifies

+ * the bit sizes of each component and the actual ordering.  For example, if

+ * \c GL_UNSIGNED_SHORT_5_6_5_REV is specified with \c GL_RGB, bits [15:11]

+ * are the blue value, bits [10:5] are the green value, and bits [4:0] are

+ * the red value.

+ * 

+ * One sublte issue is the combination of \c GL_RGB  or \c GL_BGR and either

+ * of the \c GL_UNSIGNED_INT_8_8_8_8 modes.  The resulting mask values in the

+ * \c struct gl_config structure is \b identical to the \c GL_RGBA or

+ * \c GL_BGRA case, except the \c alphaMask is zero.  This means that, as

+ * far as this routine is concerned, \c GL_RGB with \c GL_UNSIGNED_INT_8_8_8_8

+ * still uses 32-bits.

+ *

+ * If in doubt, look at the tables used in the function.

+ * 

+ * \param ptr_to_modes  Pointer to a pointer to a linked list of

+ *                      \c struct gl_config.  Upon completion, a pointer to

+ *                      the next element to be process will be stored here.

+ *                      If the function fails and returns \c GL_FALSE, this

+ *                      value will be unmodified, but some elements in the

+ *                      linked list may be modified.

+ * \param fb_format     Format of the framebuffer.  Currently only \c GL_RGB,

+ *                      \c GL_RGBA, \c GL_BGR, and \c GL_BGRA are supported.

+ * \param fb_type       Type of the pixels in the framebuffer.  Currently only

+ *                      \c GL_UNSIGNED_SHORT_5_6_5, 

+ *                      \c GL_UNSIGNED_SHORT_5_6_5_REV,

+ *                      \c GL_UNSIGNED_INT_8_8_8_8, and

+ *                      \c GL_UNSIGNED_INT_8_8_8_8_REV are supported.

+ * \param depth_bits    Array of depth buffer sizes to be exposed.

+ * \param stencil_bits  Array of stencil buffer sizes to be exposed.

+ * \param num_depth_stencil_bits  Number of entries in both \c depth_bits and

+ *                      \c stencil_bits.

+ * \param db_modes      Array of buffer swap modes.  If an element has a

+ *                      value of \c GLX_NONE, then it represents a

+ *                      single-buffered mode.  Other valid values are

+ *                      \c GLX_SWAP_EXCHANGE_OML, \c GLX_SWAP_COPY_OML, and

+ *                      \c GLX_SWAP_UNDEFINED_OML.  See the

+ *                      GLX_OML_swap_method extension spec for more details.

+ * \param num_db_modes  Number of entries in \c db_modes.

+ * \param msaa_samples  Array of msaa sample count. 0 represents a visual

+ *                      without a multisample buffer.

+ * \param num_msaa_modes Number of entries in \c msaa_samples.

+ * \param visType       GLX visual type.  Usually either \c GLX_TRUE_COLOR or

+ *                      \c GLX_DIRECT_COLOR.

+ * 

+ * \returns

+ * \c GL_TRUE on success or \c GL_FALSE on failure.  Currently the only

+ * cause of failure is a bad parameter (i.e., unsupported \c fb_format or

+ * \c fb_type).

+ * 

+ * \todo

+ * There is currently no way to support packed RGB modes (i.e., modes with

+ * exactly 3 bytes per pixel) or floating-point modes.  This could probably

+ * be done by creating some new, private enums with clever names likes

+ * \c GL_UNSIGNED_3BYTE_8_8_8, \c GL_4FLOAT_32_32_32_32, 

+ * \c GL_4HALF_16_16_16_16, etc.  We can cross that bridge when we come to it.

+ */

+__DRIconfig **

+driCreateConfigs(GLenum fb_format, GLenum fb_type,

+		 const uint8_t * depth_bits, const uint8_t * stencil_bits,

+		 unsigned num_depth_stencil_bits,

+		 const GLenum * db_modes, unsigned num_db_modes,

+		 const uint8_t * msaa_samples, unsigned num_msaa_modes,

+		 GLboolean enable_accum)

+{

+   static const uint8_t bits_table[4][4] = {

+     /* R  G  B  A */

+      { 3, 3, 2, 0 }, /* Any GL_UNSIGNED_BYTE_3_3_2 */

+      { 5, 6, 5, 0 }, /* Any GL_UNSIGNED_SHORT_5_6_5 */

+      { 8, 8, 8, 0 }, /* Any RGB with any GL_UNSIGNED_INT_8_8_8_8 */

+      { 8, 8, 8, 8 }  /* Any RGBA with any GL_UNSIGNED_INT_8_8_8_8 */

+   };

+

+   static const uint32_t masks_table_rgb[6][4] = {

+      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 3_3_2       */

+      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 2_3_3_REV   */

+      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5       */

+      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5_REV   */

+      { 0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000 }, /* 8_8_8_8     */

+      { 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }  /* 8_8_8_8_REV */

+   };

+

+   static const uint32_t masks_table_rgba[6][4] = {

+      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 3_3_2       */

+      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 2_3_3_REV   */

+      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5       */

+      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5_REV   */

+      { 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF }, /* 8_8_8_8     */

+      { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }, /* 8_8_8_8_REV */

+   };

+

+   static const uint32_t masks_table_bgr[6][4] = {

+      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 3_3_2       */

+      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 2_3_3_REV   */

+      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5       */

+      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5_REV   */

+      { 0x0000FF00, 0x00FF0000, 0xFF000000, 0x00000000 }, /* 8_8_8_8     */

+      { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }, /* 8_8_8_8_REV */

+   };

+

+   static const uint32_t masks_table_bgra[6][4] = {

+      { 0x00000007, 0x00000038, 0x000000C0, 0x00000000 }, /* 3_3_2       */

+      { 0x000000E0, 0x0000001C, 0x00000003, 0x00000000 }, /* 2_3_3_REV   */

+      { 0x0000001F, 0x000007E0, 0x0000F800, 0x00000000 }, /* 5_6_5       */

+      { 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }, /* 5_6_5_REV   */

+      { 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF }, /* 8_8_8_8     */

+      { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }, /* 8_8_8_8_REV */

+   };

+

+   static const uint8_t bytes_per_pixel[6] = {

+      1, /* 3_3_2       */

+      1, /* 2_3_3_REV   */

+      2, /* 5_6_5       */

+      2, /* 5_6_5_REV   */

+      4, /* 8_8_8_8     */

+      4  /* 8_8_8_8_REV */

+   };

+

+   const uint8_t  * bits;

+   const uint32_t * masks;

+   int index;

+   __DRIconfig **configs, **c;

+   struct gl_config *modes;

+   unsigned i, j, k, h;

+   unsigned num_modes;

+   unsigned num_accum_bits = (enable_accum) ? 2 : 1;

+

+   switch ( fb_type ) {

+      case GL_UNSIGNED_BYTE_3_3_2:

+	 index = 0;

+	 break;

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+	 index = 1;

+	 break;

+      case GL_UNSIGNED_SHORT_5_6_5:

+	 index = 2;

+	 break;

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+	 index = 3;

+	 break;

+      case GL_UNSIGNED_INT_8_8_8_8:

+	 index = 4;

+	 break;

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+	 index = 5;

+	 break;

+      default:

+	 fprintf( stderr, "[%s:%u] Unknown framebuffer type 0x%04x.\n",

+               __FUNCTION__, __LINE__, fb_type );

+	 return NULL;

+   }

+

+

+   /* Valid types are GL_UNSIGNED_SHORT_5_6_5 and GL_UNSIGNED_INT_8_8_8_8 and

+    * the _REV versions.

+    *

+    * Valid formats are GL_RGBA, GL_RGB, and GL_BGRA.

+    */

+

+   switch ( fb_format ) {

+      case GL_RGB:

+         masks = masks_table_rgb[ index ];

+         break;

+

+      case GL_RGBA:

+         masks = masks_table_rgba[ index ];

+         break;

+

+      case GL_BGR:

+         masks = masks_table_bgr[ index ];

+         break;

+

+      case GL_BGRA:

+         masks = masks_table_bgra[ index ];

+         break;

+

+      default:

+         fprintf( stderr, "[%s:%u] Unknown framebuffer format 0x%04x.\n",

+               __FUNCTION__, __LINE__, fb_format );

+         return NULL;

+   }

+

+   switch ( bytes_per_pixel[ index ] ) {

+      case 1:

+	 bits = bits_table[0];

+	 break;

+      case 2:

+	 bits = bits_table[1];

+	 break;

+      default:

+	 bits = ((fb_format == GL_RGB) || (fb_format == GL_BGR))

+	    ? bits_table[2]

+	    : bits_table[3];

+	 break;

+   }

+

+   num_modes = num_depth_stencil_bits * num_db_modes * num_accum_bits * num_msaa_modes;

+   configs = calloc(1, (num_modes + 1) * sizeof *configs);

+   if (configs == NULL)

+       return NULL;

+

+    c = configs;

+    for ( k = 0 ; k < num_depth_stencil_bits ; k++ ) {

+	for ( i = 0 ; i < num_db_modes ; i++ ) {

+	    for ( h = 0 ; h < num_msaa_modes; h++ ) {

+	    	for ( j = 0 ; j < num_accum_bits ; j++ ) {

+		    *c = malloc (sizeof **c);

+		    modes = &(*c)->modes;

+		    c++;

+

+		    memset(modes, 0, sizeof *modes);

+		    modes->redBits   = bits[0];

+		    modes->greenBits = bits[1];

+		    modes->blueBits  = bits[2];

+		    modes->alphaBits = bits[3];

+		    modes->redMask   = masks[0];

+		    modes->greenMask = masks[1];

+		    modes->blueMask  = masks[2];

+		    modes->alphaMask = masks[3];

+		    modes->rgbBits   = modes->redBits + modes->greenBits

+		    	+ modes->blueBits + modes->alphaBits;

+

+		    modes->accumRedBits   = 16 * j;

+		    modes->accumGreenBits = 16 * j;

+		    modes->accumBlueBits  = 16 * j;

+		    modes->accumAlphaBits = (masks[3] != 0) ? 16 * j : 0;

+		    modes->visualRating = (j == 0) ? GLX_NONE : GLX_SLOW_CONFIG;

+

+		    modes->stencilBits = stencil_bits[k];

+		    modes->depthBits = depth_bits[k];

+

+		    modes->transparentPixel = GLX_NONE;

+		    modes->transparentRed = GLX_DONT_CARE;

+		    modes->transparentGreen = GLX_DONT_CARE;

+		    modes->transparentBlue = GLX_DONT_CARE;

+		    modes->transparentAlpha = GLX_DONT_CARE;

+		    modes->transparentIndex = GLX_DONT_CARE;

+		    modes->rgbMode = GL_TRUE;

+

+		    if ( db_modes[i] == GLX_NONE ) {

+		    	modes->doubleBufferMode = GL_FALSE;

+		    }

+		    else {

+		    	modes->doubleBufferMode = GL_TRUE;

+		    	modes->swapMethod = db_modes[i];

+		    }

+

+		    modes->samples = msaa_samples[h];

+		    modes->sampleBuffers = modes->samples ? 1 : 0;

+

+

+		    modes->haveAccumBuffer = ((modes->accumRedBits +

+					   modes->accumGreenBits +

+					   modes->accumBlueBits +

+					   modes->accumAlphaBits) > 0);

+		    modes->haveDepthBuffer = (modes->depthBits > 0);

+		    modes->haveStencilBuffer = (modes->stencilBits > 0);

+

+		    modes->bindToTextureRgb = GL_TRUE;

+		    modes->bindToTextureRgba = GL_TRUE;

+		    modes->bindToMipmapTexture = GL_FALSE;

+		    modes->bindToTextureTargets =

+			__DRI_ATTRIB_TEXTURE_1D_BIT |

+			__DRI_ATTRIB_TEXTURE_2D_BIT |

+			__DRI_ATTRIB_TEXTURE_RECTANGLE_BIT;

+

+		    modes->sRGBCapable = GL_FALSE;

+		}

+	    }

+	}

+    }

+    *c = NULL;

+

+    return configs;

+}

+

+__DRIconfig **driConcatConfigs(__DRIconfig **a,

+			       __DRIconfig **b)

+{

+    __DRIconfig **all;

+    int i, j, index;

+

+    i = 0;

+    while (a[i] != NULL)

+	i++;

+    j = 0;

+    while (b[j] != NULL)

+	j++;

+   

+    all = malloc((i + j + 1) * sizeof *all);

+    index = 0;

+    for (i = 0; a[i] != NULL; i++)

+	all[index++] = a[i];

+    for (j = 0; b[j] != NULL; j++)

+	all[index++] = b[j];

+    all[index++] = NULL;

+

+    free(a);

+    free(b);

+

+    return all;

+}

+

+#define __ATTRIB(attrib, field) \

+    { attrib, offsetof(struct gl_config, field) }

+

+static const struct { unsigned int attrib, offset; } attribMap[] = {

+    __ATTRIB(__DRI_ATTRIB_BUFFER_SIZE,			rgbBits),

+    __ATTRIB(__DRI_ATTRIB_LEVEL,			level),

+    __ATTRIB(__DRI_ATTRIB_RED_SIZE,			redBits),

+    __ATTRIB(__DRI_ATTRIB_GREEN_SIZE,			greenBits),

+    __ATTRIB(__DRI_ATTRIB_BLUE_SIZE,			blueBits),

+    __ATTRIB(__DRI_ATTRIB_ALPHA_SIZE,			alphaBits),

+    __ATTRIB(__DRI_ATTRIB_DEPTH_SIZE,			depthBits),

+    __ATTRIB(__DRI_ATTRIB_STENCIL_SIZE,			stencilBits),

+    __ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE,		accumRedBits),

+    __ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE,		accumGreenBits),

+    __ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE,		accumBlueBits),

+    __ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE,		accumAlphaBits),

+    __ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS,		sampleBuffers),

+    __ATTRIB(__DRI_ATTRIB_SAMPLES,			samples),

+    __ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER,		doubleBufferMode),

+    __ATTRIB(__DRI_ATTRIB_STEREO,			stereoMode),

+    __ATTRIB(__DRI_ATTRIB_AUX_BUFFERS,			numAuxBuffers),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_TYPE,		transparentPixel),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_INDEX_VALUE,	transparentPixel),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_RED_VALUE,	transparentRed),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_GREEN_VALUE,	transparentGreen),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_BLUE_VALUE,	transparentBlue),

+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE,	transparentAlpha),

+    __ATTRIB(__DRI_ATTRIB_FLOAT_MODE,			floatMode),

+    __ATTRIB(__DRI_ATTRIB_RED_MASK,			redMask),

+    __ATTRIB(__DRI_ATTRIB_GREEN_MASK,			greenMask),

+    __ATTRIB(__DRI_ATTRIB_BLUE_MASK,			blueMask),

+    __ATTRIB(__DRI_ATTRIB_ALPHA_MASK,			alphaMask),

+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH,		maxPbufferWidth),

+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT,		maxPbufferHeight),

+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS,		maxPbufferPixels),

+    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH,	optimalPbufferWidth),

+    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT,	optimalPbufferHeight),

+    __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,			swapMethod),

+    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB,		bindToTextureRgb),

+    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA,		bindToTextureRgba),

+    __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,	bindToMipmapTexture),

+    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS,	bindToTextureTargets),

+    __ATTRIB(__DRI_ATTRIB_YINVERTED,			yInverted),

+    __ATTRIB(__DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE,	sRGBCapable),

+

+    /* The struct field doesn't matter here, these are handled by the

+     * switch in driGetConfigAttribIndex.  We need them in the array

+     * so the iterator includes them though.*/

+    __ATTRIB(__DRI_ATTRIB_RENDER_TYPE,			level),

+    __ATTRIB(__DRI_ATTRIB_CONFIG_CAVEAT,		level),

+    __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,			level)

+};

+

+#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))

+

+

+/**

+ * Return the value of a configuration attribute.  The attribute is

+ * indicated by the index.

+ */

+static int

+driGetConfigAttribIndex(const __DRIconfig *config,

+			unsigned int index, unsigned int *value)

+{

+    switch (attribMap[index].attrib) {

+    case __DRI_ATTRIB_RENDER_TYPE:

+        /* no support for color index mode */

+	*value = __DRI_ATTRIB_RGBA_BIT;

+	break;

+    case __DRI_ATTRIB_CONFIG_CAVEAT:

+	if (config->modes.visualRating == GLX_NON_CONFORMANT_CONFIG)

+	    *value = __DRI_ATTRIB_NON_CONFORMANT_CONFIG;

+	else if (config->modes.visualRating == GLX_SLOW_CONFIG)

+	    *value = __DRI_ATTRIB_SLOW_BIT;

+	else

+	    *value = 0;

+	break;

+    case __DRI_ATTRIB_SWAP_METHOD:

+        /* XXX no return value??? */

+	break;

+

+    case __DRI_ATTRIB_FLOAT_MODE:

+        /* this field is not int-sized */

+        *value = config->modes.floatMode;

+        break;

+

+    default:

+        /* any other int-sized field */

+	*value = *(unsigned int *)

+	    ((char *) &config->modes + attribMap[index].offset);

+	

+	break;

+    }

+

+    return GL_TRUE;

+}

+

+

+/**

+ * Get the value of a configuration attribute.

+ * \param attrib  the attribute (one of the _DRI_ATTRIB_x tokens)

+ * \param value  returns the attribute's value

+ * \return 1 for success, 0 for failure

+ */

+int

+driGetConfigAttrib(const __DRIconfig *config,

+		   unsigned int attrib, unsigned int *value)

+{

+    int i;

+

+    for (i = 0; i < ARRAY_SIZE(attribMap); i++)

+	if (attribMap[i].attrib == attrib)

+	    return driGetConfigAttribIndex(config, i, value);

+

+    return GL_FALSE;

+}

+

+

+/**

+ * Get a configuration attribute name and value, given an index.

+ * \param index  which field of the __DRIconfig to query

+ * \param attrib  returns the attribute name (one of the _DRI_ATTRIB_x tokens)

+ * \param value  returns the attribute's value

+ * \return 1 for success, 0 for failure

+ */

+int

+driIndexConfigAttrib(const __DRIconfig *config, int index,

+		     unsigned int *attrib, unsigned int *value)

+{

+    if (index >= 0 && index < ARRAY_SIZE(attribMap)) {

+	*attrib = attribMap[index].attrib;

+	return driGetConfigAttribIndex(config, index, value);

+    }

+

+    return GL_FALSE;

+}

diff --git a/mesalib/src/mesa/drivers/dri/swrast/swrast.c b/mesalib/src/mesa/drivers/dri/swrast/swrast.c
index 719b406ec..e6d1ab741 100644
--- a/mesalib/src/mesa/drivers/dri/swrast/swrast.c
+++ b/mesalib/src/mesa/drivers/dri/swrast/swrast.c
@@ -1,806 +1,811 @@
-/*
- * Copyright 2008, 2010 George Sapountzis <gsapountzis@gmail.com>
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * DRI software rasterizer
- *
- * This is the mesa swrast module packaged into a DRI driver structure.
- *
- * The front-buffer is allocated by the loader. The loader provides read/write
- * callbacks for access to the front-buffer. The driver uses a scratch row for
- * front-buffer rendering to avoid repeated calls to the loader.
- *
- * The back-buffer is allocated by the driver and is private.
- */
-
-#include "main/context.h"
-#include "main/extensions.h"
-#include "main/formats.h"
-#include "main/framebuffer.h"
-#include "main/imports.h"
-#include "main/renderbuffer.h"
-#include "swrast/swrast.h"
-#include "swrast_setup/swrast_setup.h"
-#include "tnl/tnl.h"
-#include "tnl/t_context.h"
-#include "tnl/t_pipeline.h"
-#include "vbo/vbo.h"
-#include "drivers/common/driverfuncs.h"
-#include "drivers/common/meta.h"
-#include "utils.h"
-
-#include "main/teximage.h"
-#include "main/texformat.h"
-#include "main/texstate.h"
-
-#include "swrast_priv.h"
-
-
-/**
- * Screen and config-related functions
- */
-
-static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target,
-				GLint texture_format, __DRIdrawable *dPriv)
-{
-    struct dri_context *dri_ctx;
-    int x, y, w, h;
-    __DRIscreen *sPriv = dPriv->driScreenPriv;
-    struct gl_texture_unit *texUnit;
-    struct gl_texture_object *texObj;
-    struct gl_texture_image *texImage;
-    uint32_t internalFormat;
-    gl_format texFormat;
-
-    dri_ctx = pDRICtx->driverPrivate;
-
-    internalFormat = (texture_format == __DRI_TEXTURE_FORMAT_RGB ? 3 : 4);
-
-    texUnit = _mesa_get_current_tex_unit(&dri_ctx->Base);
-    texObj = _mesa_select_tex_object(&dri_ctx->Base, texUnit, target);
-    texImage = _mesa_get_tex_image(&dri_ctx->Base, texObj, target, 0);
-
-    _mesa_lock_texture(&dri_ctx->Base, texObj);
-
-    sPriv->swrast_loader->getDrawableInfo(dPriv, &x, &y, &w, &h, dPriv->loaderPrivate);
-
-    if (texture_format == __DRI_TEXTURE_FORMAT_RGB)
-	texFormat = MESA_FORMAT_XRGB8888;
-    else
-	texFormat = MESA_FORMAT_ARGB8888;
-
-    _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage,
-			       w, h, 1, 0, internalFormat, texFormat);
-
-    sPriv->swrast_loader->getImage(dPriv, x, y, w, h, (char *)texImage->Data,
-				   dPriv->loaderPrivate);
-
-    _mesa_unlock_texture(&dri_ctx->Base, texObj);
-}
-
-static void swrastSetTexBuffer(__DRIcontext *pDRICtx, GLint target,
-			       __DRIdrawable *dPriv)
-{
-    swrastSetTexBuffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);
-}
-
-static const __DRItexBufferExtension swrastTexBufferExtension = {
-    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
-    swrastSetTexBuffer,
-    swrastSetTexBuffer2,
-};
-
-static const __DRIextension *dri_screen_extensions[] = {
-    &swrastTexBufferExtension.base,
-    NULL
-};
-
-static __DRIconfig **
-swrastFillInModes(__DRIscreen *psp,
-		  unsigned pixel_bits, unsigned depth_bits,
-		  unsigned stencil_bits, GLboolean have_back_buffer)
-{
-    __DRIconfig **configs;
-    unsigned depth_buffer_factor;
-    unsigned back_buffer_factor;
-    GLenum fb_format;
-    GLenum fb_type;
-
-    /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't
-     * support pageflipping at all.
-     */
-    static const GLenum back_buffer_modes[] = {
-	GLX_NONE, GLX_SWAP_UNDEFINED_OML
-    };
-
-    uint8_t depth_bits_array[4];
-    uint8_t stencil_bits_array[4];
-    uint8_t msaa_samples_array[1];
-
-    depth_bits_array[0] = 0;
-    depth_bits_array[1] = 0;
-    depth_bits_array[2] = depth_bits;
-    depth_bits_array[3] = depth_bits;
-
-    /* Just like with the accumulation buffer, always provide some modes
-     * with a stencil buffer.
-     */
-    stencil_bits_array[0] = 0;
-    stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;
-    stencil_bits_array[2] = 0;
-    stencil_bits_array[3] = (stencil_bits == 0) ? 8 : stencil_bits;
-
-    msaa_samples_array[0] = 0;
-
-    depth_buffer_factor = 4;
-    back_buffer_factor = 2;
-
-    switch (pixel_bits) {
-    case 8:
-	fb_format = GL_RGB;
-	fb_type = GL_UNSIGNED_BYTE_2_3_3_REV;
-	break;
-    case 16:
-	fb_format = GL_RGB;
-	fb_type = GL_UNSIGNED_SHORT_5_6_5;
-	break;
-    case 24:
-	fb_format = GL_BGR;
-	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
-	break;
-    case 32:
-	fb_format = GL_BGRA;
-	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
-	break;
-    default:
-	fprintf(stderr, "[%s:%u] bad depth %d\n", __func__, __LINE__,
-		pixel_bits);
-	return NULL;
-    }
-
-    configs = driCreateConfigs(fb_format, fb_type,
-			       depth_bits_array, stencil_bits_array,
-			       depth_buffer_factor, back_buffer_modes,
-			       back_buffer_factor, msaa_samples_array, 1,
-			       GL_TRUE);
-    if (configs == NULL) {
-	fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
-		__LINE__);
-	return NULL;
-    }
-
-    return configs;
-}
-
-static const __DRIconfig **
-dri_init_screen(__DRIscreen * psp)
-{
-    __DRIconfig **configs8, **configs16, **configs24, **configs32;
-
-    TRACE;
-
-    psp->extensions = dri_screen_extensions;
-
-    configs8  = swrastFillInModes(psp,  8,  8, 0, 1);
-    configs16 = swrastFillInModes(psp, 16, 16, 0, 1);
-    configs24 = swrastFillInModes(psp, 24, 24, 8, 1);
-    configs32 = swrastFillInModes(psp, 32, 24, 8, 1);
-
-    configs16 = driConcatConfigs(configs8, configs16);
-    configs24 = driConcatConfigs(configs16, configs24);
-    configs32 = driConcatConfigs(configs24, configs32);
-
-    return (const __DRIconfig **)configs32;
-}
-
-static void
-dri_destroy_screen(__DRIscreen * sPriv)
-{
-    TRACE;
-}
-
-
-/**
- * Framebuffer and renderbuffer-related functions.
- */
-
-static GLuint
-choose_pixel_format(const struct gl_config *v)
-{
-    int depth = v->rgbBits;
-
-    if (depth == 32
-	&& v->redMask   == 0xff0000
-	&& v->greenMask == 0x00ff00
-	&& v->blueMask  == 0x0000ff)
-	return PF_A8R8G8B8;
-    else if (depth == 24
-	     && v->redMask   == 0xff0000
-	     && v->greenMask == 0x00ff00
-	     && v->blueMask  == 0x0000ff)
-	return PF_X8R8G8B8;
-    else if (depth == 16
-	     && v->redMask   == 0xf800
-	     && v->greenMask == 0x07e0
-	     && v->blueMask  == 0x001f)
-	return PF_R5G6B5;
-    else if (depth == 8
-	     && v->redMask   == 0x07
-	     && v->greenMask == 0x38
-	     && v->blueMask  == 0xc0)
-	return PF_R3G3B2;
-
-    _mesa_problem( NULL, "unexpected format in %s", __FUNCTION__ );
-    return 0;
-}
-
-static void
-swrast_delete_renderbuffer(struct gl_renderbuffer *rb)
-{
-    TRACE;
-
-    free(rb->Data);
-    free(rb);
-}
-
-/* see bytes_per_line in libGL */
-static INLINE int
-bytes_per_line(unsigned pitch_bits, unsigned mul)
-{
-   unsigned mask = mul - 1;
-
-   return ((pitch_bits + mask) & ~mask) / 8;
-}
-
-static GLboolean
-swrast_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
-			   GLenum internalFormat, GLuint width, GLuint height)
-{
-    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);
-
-    TRACE;
-
-    rb->Data = NULL;
-    rb->Width = width;
-    rb->Height = height;
-
-    xrb->pitch = bytes_per_line(width * xrb->bpp, 32);
-
-    return GL_TRUE;
-}
-
-static GLboolean
-swrast_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
-			  GLenum internalFormat, GLuint width, GLuint height)
-{
-    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);
-
-    TRACE;
-
-    free(rb->Data);
-
-    swrast_alloc_front_storage(ctx, rb, internalFormat, width, height);
-
-    rb->Data = malloc(height * xrb->pitch);
-
-    return GL_TRUE;
-}
-
-static struct swrast_renderbuffer *
-swrast_new_renderbuffer(const struct gl_config *visual, GLboolean front)
-{
-    struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb);
-    GLuint pixel_format;
-
-    TRACE;
-
-    if (!xrb)
-	return NULL;
-
-    _mesa_init_renderbuffer(&xrb->Base, 0);
-
-    pixel_format = choose_pixel_format(visual);
-
-    xrb->Base.Delete = swrast_delete_renderbuffer;
-    if (front) {
-	xrb->Base.AllocStorage = swrast_alloc_front_storage;
-	swrast_set_span_funcs_front(xrb, pixel_format);
-    }
-    else {
-	xrb->Base.AllocStorage = swrast_alloc_back_storage;
-	swrast_set_span_funcs_back(xrb, pixel_format);
-    }
-
-    switch (pixel_format) {
-    case PF_A8R8G8B8:
-	xrb->Base.Format = MESA_FORMAT_ARGB8888;
-	xrb->Base.InternalFormat = GL_RGBA;
-	xrb->Base._BaseFormat = GL_RGBA;
-	xrb->Base.DataType = GL_UNSIGNED_BYTE;
-	xrb->bpp = 32;
-	break;
-    case PF_X8R8G8B8:
-	xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */
-	xrb->Base.InternalFormat = GL_RGB;
-	xrb->Base._BaseFormat = GL_RGB;
-	xrb->Base.DataType = GL_UNSIGNED_BYTE;
-	xrb->bpp = 32;
-	break;
-    case PF_R5G6B5:
-	xrb->Base.Format = MESA_FORMAT_RGB565;
-	xrb->Base.InternalFormat = GL_RGB;
-	xrb->Base._BaseFormat = GL_RGB;
-	xrb->Base.DataType = GL_UNSIGNED_BYTE;
-	xrb->bpp = 16;
-	break;
-    case PF_R3G3B2:
-	xrb->Base.Format = MESA_FORMAT_RGB332;
-	xrb->Base.InternalFormat = GL_RGB;
-	xrb->Base._BaseFormat = GL_RGB;
-	xrb->Base.DataType = GL_UNSIGNED_BYTE;
-	xrb->bpp = 8;
-	break;
-    default:
-	return NULL;
-    }
-
-    return xrb;
-}
-
-static GLboolean
-dri_create_buffer(__DRIscreen * sPriv,
-		  __DRIdrawable * dPriv,
-		  const struct gl_config * visual, GLboolean isPixmap)
-{
-    struct dri_drawable *drawable = NULL;
-    struct gl_framebuffer *fb;
-    struct swrast_renderbuffer *frontrb, *backrb;
-
-    TRACE;
-
-    drawable = CALLOC_STRUCT(dri_drawable);
-    if (drawable == NULL)
-	goto drawable_fail;
-
-    dPriv->driverPrivate = drawable;
-    drawable->dPriv = dPriv;
-
-    drawable->row = malloc(MAX_WIDTH * 4);
-    if (drawable->row == NULL)
-	goto drawable_fail;
-
-    fb = &drawable->Base;
-
-    /* basic framebuffer setup */
-    _mesa_initialize_window_framebuffer(fb, visual);
-
-    /* add front renderbuffer */
-    frontrb = swrast_new_renderbuffer(visual, GL_TRUE);
-    _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontrb->Base);
-
-    /* add back renderbuffer */
-    if (visual->doubleBufferMode) {
-	backrb = swrast_new_renderbuffer(visual, GL_FALSE);
-	_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backrb->Base);
-    }
-
-    /* add software renderbuffers */
-    _mesa_add_soft_renderbuffers(fb,
-				 GL_FALSE, /* color */
-				 visual->haveDepthBuffer,
-				 visual->haveStencilBuffer,
-				 visual->haveAccumBuffer,
-				 GL_FALSE, /* alpha */
-				 GL_FALSE /* aux bufs */);
-
-    return GL_TRUE;
-
-drawable_fail:
-
-    if (drawable)
-	free(drawable->row);
-
-    FREE(drawable);
-
-    return GL_FALSE;
-}
-
-static void
-dri_destroy_buffer(__DRIdrawable * dPriv)
-{
-    TRACE;
-
-    if (dPriv) {
-	struct dri_drawable *drawable = dri_drawable(dPriv);
-	struct gl_framebuffer *fb;
-
-	free(drawable->row);
-
-	fb = &drawable->Base;
-
-	fb->DeletePending = GL_TRUE;
-	_mesa_reference_framebuffer(&fb, NULL);
-    }
-}
-
-static void
-dri_swap_buffers(__DRIdrawable * dPriv)
-{
-    __DRIscreen *sPriv = dPriv->driScreenPriv;
-
-    GET_CURRENT_CONTEXT(ctx);
-
-    struct dri_drawable *drawable = dri_drawable(dPriv);
-    struct gl_framebuffer *fb;
-    struct swrast_renderbuffer *frontrb, *backrb;
-
-    TRACE;
-
-    fb = &drawable->Base;
-
-    frontrb =
-	swrast_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-    backrb =
-	swrast_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
-
-    /* check for signle-buffered */
-    if (backrb == NULL)
-	return;
-
-    /* check if swapping currently bound buffer */
-    if (ctx && ctx->DrawBuffer == fb) {
-	/* flush pending rendering */
-	_mesa_notifySwapBuffers(ctx);
-    }
-
-    sPriv->swrast_loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,
-				   0, 0,
-				   frontrb->Base.Width,
-				   frontrb->Base.Height,
-				   backrb->Base.Data,
-				   dPriv->loaderPrivate);
-}
-
-
-/**
- * General device driver functions.
- */
-
-static void
-get_window_size( struct gl_framebuffer *fb, GLsizei *w, GLsizei *h )
-{
-    __DRIdrawable *dPriv = swrast_drawable(fb)->dPriv;
-    __DRIscreen *sPriv = dPriv->driScreenPriv;
-    int x, y;
-
-    sPriv->swrast_loader->getDrawableInfo(dPriv,
-					  &x, &y, w, h,
-					  dPriv->loaderPrivate);
-}
-
-static void
-swrast_check_and_update_window_size( struct gl_context *ctx, struct gl_framebuffer *fb )
-{
-    GLsizei width, height;
-
-    get_window_size(fb, &width, &height);
-    if (fb->Width != width || fb->Height != height) {
-	_mesa_resize_framebuffer(ctx, fb, width, height);
-    }
-}
-
-static const GLubyte *
-get_string(struct gl_context *ctx, GLenum pname)
-{
-    (void) ctx;
-    switch (pname) {
-	case GL_VENDOR:
-	    return (const GLubyte *) "Mesa Project";
-	case GL_RENDERER:
-	    return (const GLubyte *) "Software Rasterizer";
-	default:
-	    return NULL;
-    }
-}
-
-static void
-update_state( struct gl_context *ctx, GLuint new_state )
-{
-    /* not much to do here - pass it on */
-    _swrast_InvalidateState( ctx, new_state );
-    _swsetup_InvalidateState( ctx, new_state );
-    _vbo_InvalidateState( ctx, new_state );
-    _tnl_InvalidateState( ctx, new_state );
-}
-
-static void
-viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
-{
-    struct gl_framebuffer *draw = ctx->WinSysDrawBuffer;
-    struct gl_framebuffer *read = ctx->WinSysReadBuffer;
-
-    swrast_check_and_update_window_size(ctx, draw);
-    swrast_check_and_update_window_size(ctx, read);
-}
-
-static gl_format swrastChooseTextureFormat(struct gl_context * ctx,
-					   GLint internalFormat,
-					   GLenum format,
-					   GLenum type)
-{
-    if (internalFormat == GL_RGB)
-	return MESA_FORMAT_XRGB8888;
-    return _mesa_choose_tex_format(ctx, internalFormat, format, type);
-}
-
-static void
-swrast_init_driver_functions(struct dd_function_table *driver)
-{
-    driver->GetString = get_string;
-    driver->UpdateState = update_state;
-    driver->GetBufferSize = NULL;
-    driver->Viewport = viewport;
-    driver->ChooseTextureFormat = swrastChooseTextureFormat;
-}
-
-static const char *es2_extensions[] = {
-   /* Used by mesa internally (cf all_mesa_extensions in ../common/utils.c) */
-   "GL_ARB_draw_buffers",
-   "GL_ARB_multisample",
-   "GL_ARB_texture_compression",
-   "GL_ARB_transpose_matrix",
-   "GL_ARB_vertex_buffer_object",
-   "GL_ARB_window_pos",
-   "GL_EXT_blend_func_separate",
-   "GL_EXT_compiled_vertex_array",
-   "GL_EXT_framebuffer_blit",
-   "GL_EXT_multi_draw_arrays",
-   "GL_EXT_polygon_offset",
-   "GL_EXT_texture_object",
-   "GL_EXT_vertex_array",
-   "GL_IBM_multimode_draw_arrays",
-   "GL_MESA_window_pos",
-   "GL_NV_vertex_program",
-
-   /* Required by GLES2 */
-   "GL_ARB_fragment_program",
-   "GL_ARB_fragment_shader",
-   "GL_ARB_multitexture",
-   "GL_ARB_shader_objects",
-   "GL_ARB_texture_cube_map",
-   "GL_ARB_texture_mirrored_repeat",
-   "GL_ARB_texture_non_power_of_two",
-   "GL_ARB_vertex_shader",
-   "GL_EXT_blend_color",
-   "GL_EXT_blend_equation_separate",
-   "GL_EXT_blend_minmax",
-   "GL_EXT_blend_subtract",
-   "GL_EXT_stencil_wrap",
-
-   /* Optional GLES2 */
-   "GL_ARB_framebuffer_object",
-   "GL_EXT_texture_filter_anisotropic",
-   "GL_ARB_depth_texture",
-   "GL_EXT_packed_depth_stencil",
-   "GL_EXT_framebuffer_object",
-   NULL,
-};
-
-static void
-InitExtensionsES2(struct gl_context *ctx)
-{
-   int i;
-
-   /* Can't use driInitExtensions() since it uses extensions from
-    * main/remap_helper.h when called the first time. */
-
-   for (i = 0; es2_extensions[i]; i++)
-      _mesa_enable_extension(ctx, es2_extensions[i]);
-}
-
-/**
- * Context-related functions.
- */
-
-static GLboolean
-dri_create_context(gl_api api,
-		   const struct gl_config * visual,
-		   __DRIcontext * cPriv, void *sharedContextPrivate)
-{
-    struct dri_context *ctx = NULL;
-    struct dri_context *share = (struct dri_context *)sharedContextPrivate;
-    struct gl_context *mesaCtx = NULL;
-    struct gl_context *sharedCtx = NULL;
-    struct dd_function_table functions;
-
-    TRACE;
-
-    ctx = CALLOC_STRUCT(dri_context);
-    if (ctx == NULL)
-	goto context_fail;
-
-    cPriv->driverPrivate = ctx;
-    ctx->cPriv = cPriv;
-
-    /* build table of device driver functions */
-    _mesa_init_driver_functions(&functions);
-    swrast_init_driver_functions(&functions);
-
-    if (share) {
-	sharedCtx = &share->Base;
-    }
-
-    mesaCtx = &ctx->Base;
-
-    /* basic context setup */
-    if (!_mesa_initialize_context(mesaCtx, api, visual, sharedCtx, &functions, (void *) cPriv)) {
-	goto context_fail;
-    }
-
-    /* do bounds checking to prevent segfaults and server crashes! */
-    mesaCtx->Const.CheckArrayBounds = GL_TRUE;
-
-    /* create module contexts */
-    _swrast_CreateContext( mesaCtx );
-    _vbo_CreateContext( mesaCtx );
-    _tnl_CreateContext( mesaCtx );
-    _swsetup_CreateContext( mesaCtx );
-    _swsetup_Wakeup( mesaCtx );
-
-    /* use default TCL pipeline */
-    {
-       TNLcontext *tnl = TNL_CONTEXT(mesaCtx);
-       tnl->Driver.RunPipeline = _tnl_run_pipeline;
-    }
-
-    _mesa_meta_init(mesaCtx);
-    _mesa_enable_sw_extensions(mesaCtx);
-
-    switch (api) {
-    case API_OPENGL:
-        _mesa_enable_1_3_extensions(mesaCtx);
-        _mesa_enable_1_4_extensions(mesaCtx);
-        _mesa_enable_1_5_extensions(mesaCtx);
-        _mesa_enable_2_0_extensions(mesaCtx);
-        _mesa_enable_2_1_extensions(mesaCtx);
-
-        driInitExtensions( mesaCtx, NULL, GL_FALSE );
-        break;
-    case API_OPENGLES:
-        _mesa_enable_1_3_extensions(mesaCtx);
-        _mesa_enable_1_4_extensions(mesaCtx);
-        _mesa_enable_1_5_extensions(mesaCtx);
-
-        break;
-    case API_OPENGLES2:
-        InitExtensionsES2( mesaCtx);
-        break;
-    }
-
-    return GL_TRUE;
-
-context_fail:
-
-    FREE(ctx);
-
-    return GL_FALSE;
-}
-
-static void
-dri_destroy_context(__DRIcontext * cPriv)
-{
-    TRACE;
-
-    if (cPriv) {
-	struct dri_context *ctx = dri_context(cPriv);
-	struct gl_context *mesaCtx;
-
-	mesaCtx = &ctx->Base;
-
-        _mesa_meta_free(mesaCtx);
-	_swsetup_DestroyContext( mesaCtx );
-	_swrast_DestroyContext( mesaCtx );
-	_tnl_DestroyContext( mesaCtx );
-	_vbo_DestroyContext( mesaCtx );
-	_mesa_destroy_context( mesaCtx );
-    }
-}
-
-static GLboolean
-dri_make_current(__DRIcontext * cPriv,
-		 __DRIdrawable * driDrawPriv,
-		 __DRIdrawable * driReadPriv)
-{
-    struct gl_context *mesaCtx;
-    struct gl_framebuffer *mesaDraw;
-    struct gl_framebuffer *mesaRead;
-    TRACE;
-
-    if (cPriv) {
-	struct dri_context *ctx = dri_context(cPriv);
-	struct dri_drawable *draw;
-	struct dri_drawable *read;
-
-	if (!driDrawPriv || !driReadPriv)
-	    return GL_FALSE;
-
-	draw = dri_drawable(driDrawPriv);
-	read = dri_drawable(driReadPriv);
-	mesaCtx = &ctx->Base;
-	mesaDraw = &draw->Base;
-	mesaRead = &read->Base;
-
-	/* check for same context and buffer */
-	if (mesaCtx == _mesa_get_current_context()
-	    && mesaCtx->DrawBuffer == mesaDraw
-	    && mesaCtx->ReadBuffer == mesaRead) {
-	    return GL_TRUE;
-	}
-
-	_glapi_check_multithread();
-
-	swrast_check_and_update_window_size(mesaCtx, mesaDraw);
-	if (mesaRead != mesaDraw)
-	    swrast_check_and_update_window_size(mesaCtx, mesaRead);
-
-	_mesa_make_current( mesaCtx,
-			    mesaDraw,
-			    mesaRead );
-    }
-    else {
-	/* unbind */
-	_mesa_make_current( NULL, NULL, NULL );
-    }
-
-    return GL_TRUE;
-}
-
-static GLboolean
-dri_unbind_context(__DRIcontext * cPriv)
-{
-    TRACE;
-    (void) cPriv;
-
-    /* Unset current context and dispath table */
-    _mesa_make_current(NULL, NULL, NULL);
-
-    return GL_TRUE;
-}
-
-
-const struct __DriverAPIRec driDriverAPI = {
-    .InitScreen = dri_init_screen,
-    .DestroyScreen = dri_destroy_screen,
-    .CreateContext = dri_create_context,
-    .DestroyContext = dri_destroy_context,
-    .CreateBuffer = dri_create_buffer,
-    .DestroyBuffer = dri_destroy_buffer,
-    .SwapBuffers = dri_swap_buffers,
-    .MakeCurrent = dri_make_current,
-    .UnbindContext = dri_unbind_context,
-};
-
-/* This is the table of extensions that the loader will dlsym() for. */
-PUBLIC const __DRIextension *__driDriverExtensions[] = {
-    &driCoreExtension.base,
-    &driSWRastExtension.base,
-    NULL
-};
+/*

+ * Copyright 2008, 2010 George Sapountzis <gsapountzis@gmail.com>

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/*

+ * DRI software rasterizer

+ *

+ * This is the mesa swrast module packaged into a DRI driver structure.

+ *

+ * The front-buffer is allocated by the loader. The loader provides read/write

+ * callbacks for access to the front-buffer. The driver uses a scratch row for

+ * front-buffer rendering to avoid repeated calls to the loader.

+ *

+ * The back-buffer is allocated by the driver and is private.

+ */

+

+#ifdef _MSC_VER

+#define WIN32_LEAN_AND_MEAN 1

+#include <windows.h>

+#endif

+

+#include "main/context.h"

+#include "main/extensions.h"

+#include "main/formats.h"

+#include "main/framebuffer.h"

+#include "main/imports.h"

+#include "main/renderbuffer.h"

+#include "swrast/swrast.h"

+#include "swrast_setup/swrast_setup.h"

+#include "tnl/tnl.h"

+#include "tnl/t_context.h"

+#include "tnl/t_pipeline.h"

+#include "vbo/vbo.h"

+#include "drivers/common/driverfuncs.h"

+#include "drivers/common/meta.h"

+#include "utils.h"

+

+#include "main/teximage.h"

+#include "main/texformat.h"

+#include "main/texstate.h"

+

+#include "swrast_priv.h"

+

+

+/**

+ * Screen and config-related functions

+ */

+

+static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target,

+				GLint texture_format, __DRIdrawable *dPriv)

+{

+    struct dri_context *dri_ctx;

+    int x, y, w, h;

+    __DRIscreen *sPriv = dPriv->driScreenPriv;

+    struct gl_texture_unit *texUnit;

+    struct gl_texture_object *texObj;

+    struct gl_texture_image *texImage;

+    uint32_t internalFormat;

+    gl_format texFormat;

+

+    dri_ctx = pDRICtx->driverPrivate;

+

+    internalFormat = (texture_format == __DRI_TEXTURE_FORMAT_RGB ? 3 : 4);

+

+    texUnit = _mesa_get_current_tex_unit(&dri_ctx->Base);

+    texObj = _mesa_select_tex_object(&dri_ctx->Base, texUnit, target);

+    texImage = _mesa_get_tex_image(&dri_ctx->Base, texObj, target, 0);

+

+    _mesa_lock_texture(&dri_ctx->Base, texObj);

+

+    sPriv->swrast_loader->getDrawableInfo(dPriv, &x, &y, &w, &h, dPriv->loaderPrivate);

+

+    if (texture_format == __DRI_TEXTURE_FORMAT_RGB)

+	texFormat = MESA_FORMAT_XRGB8888;

+    else

+	texFormat = MESA_FORMAT_ARGB8888;

+

+    _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage,

+			       w, h, 1, 0, internalFormat, texFormat);

+

+    sPriv->swrast_loader->getImage(dPriv, x, y, w, h, (char *)texImage->Data,

+				   dPriv->loaderPrivate);

+

+    _mesa_unlock_texture(&dri_ctx->Base, texObj);

+}

+

+static void swrastSetTexBuffer(__DRIcontext *pDRICtx, GLint target,

+			       __DRIdrawable *dPriv)

+{

+    swrastSetTexBuffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);

+}

+

+static const __DRItexBufferExtension swrastTexBufferExtension = {

+    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },

+    swrastSetTexBuffer,

+    swrastSetTexBuffer2,

+};

+

+static const __DRIextension *dri_screen_extensions[] = {

+    &swrastTexBufferExtension.base,

+    NULL

+};

+

+static __DRIconfig **

+swrastFillInModes(__DRIscreen *psp,

+		  unsigned pixel_bits, unsigned depth_bits,

+		  unsigned stencil_bits, GLboolean have_back_buffer)

+{

+    __DRIconfig **configs;

+    unsigned depth_buffer_factor;

+    unsigned back_buffer_factor;

+    GLenum fb_format;

+    GLenum fb_type;

+

+    /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't

+     * support pageflipping at all.

+     */

+    static const GLenum back_buffer_modes[] = {

+	GLX_NONE, GLX_SWAP_UNDEFINED_OML

+    };

+

+    uint8_t depth_bits_array[4];

+    uint8_t stencil_bits_array[4];

+    uint8_t msaa_samples_array[1];

+

+    depth_bits_array[0] = 0;

+    depth_bits_array[1] = 0;

+    depth_bits_array[2] = depth_bits;

+    depth_bits_array[3] = depth_bits;

+

+    /* Just like with the accumulation buffer, always provide some modes

+     * with a stencil buffer.

+     */

+    stencil_bits_array[0] = 0;

+    stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;

+    stencil_bits_array[2] = 0;

+    stencil_bits_array[3] = (stencil_bits == 0) ? 8 : stencil_bits;

+

+    msaa_samples_array[0] = 0;

+

+    depth_buffer_factor = 4;

+    back_buffer_factor = 2;

+

+    switch (pixel_bits) {

+    case 8:

+	fb_format = GL_RGB;

+	fb_type = GL_UNSIGNED_BYTE_2_3_3_REV;

+	break;

+    case 16:

+	fb_format = GL_RGB;

+	fb_type = GL_UNSIGNED_SHORT_5_6_5;

+	break;

+    case 24:

+	fb_format = GL_BGR;

+	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;

+	break;

+    case 32:

+	fb_format = GL_BGRA;

+	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;

+	break;

+    default:

+	fprintf(stderr, "[%s:%u] bad depth %d\n", __FUNCTION__, __LINE__,

+		pixel_bits);

+	return NULL;

+    }

+

+    configs = driCreateConfigs(fb_format, fb_type,

+			       depth_bits_array, stencil_bits_array,

+			       depth_buffer_factor, back_buffer_modes,

+			       back_buffer_factor, msaa_samples_array, 1,

+			       GL_TRUE);

+    if (configs == NULL) {

+	fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __FUNCTION__,

+		__LINE__);

+	return NULL;

+    }

+

+    return configs;

+}

+

+static const __DRIconfig **

+dri_init_screen(__DRIscreen * psp)

+{

+    __DRIconfig **configs8, **configs16, **configs24, **configs32;

+

+    TRACE;

+

+    psp->extensions = dri_screen_extensions;

+

+    configs8  = swrastFillInModes(psp,  8,  8, 0, 1);

+    configs16 = swrastFillInModes(psp, 16, 16, 0, 1);

+    configs24 = swrastFillInModes(psp, 24, 24, 8, 1);

+    configs32 = swrastFillInModes(psp, 32, 24, 8, 1);

+

+    configs16 = driConcatConfigs(configs8, configs16);

+    configs24 = driConcatConfigs(configs16, configs24);

+    configs32 = driConcatConfigs(configs24, configs32);

+

+    return (const __DRIconfig **)configs32;

+}

+

+static void

+dri_destroy_screen(__DRIscreen * sPriv)

+{

+    TRACE;

+}

+

+

+/**

+ * Framebuffer and renderbuffer-related functions.

+ */

+

+static GLuint

+choose_pixel_format(const struct gl_config *v)

+{

+    int depth = v->rgbBits;

+

+    if (depth == 32

+	&& v->redMask   == 0xff0000

+	&& v->greenMask == 0x00ff00

+	&& v->blueMask  == 0x0000ff)

+	return PF_A8R8G8B8;

+    else if (depth == 24

+	     && v->redMask   == 0xff0000

+	     && v->greenMask == 0x00ff00

+	     && v->blueMask  == 0x0000ff)

+	return PF_X8R8G8B8;

+    else if (depth == 16

+	     && v->redMask   == 0xf800

+	     && v->greenMask == 0x07e0

+	     && v->blueMask  == 0x001f)

+	return PF_R5G6B5;

+    else if (depth == 8

+	     && v->redMask   == 0x07

+	     && v->greenMask == 0x38

+	     && v->blueMask  == 0xc0)

+	return PF_R3G3B2;

+

+    _mesa_problem( NULL, "unexpected format in %s", __FUNCTION__ );

+    return 0;

+}

+

+static void

+swrast_delete_renderbuffer(struct gl_renderbuffer *rb)

+{

+    TRACE;

+

+    free(rb->Data);

+    free(rb);

+}

+

+/* see bytes_per_line in libGL */

+static INLINE int

+bytes_per_line(unsigned pitch_bits, unsigned mul)

+{

+   unsigned mask = mul - 1;

+

+   return ((pitch_bits + mask) & ~mask) / 8;

+}

+

+static GLboolean

+swrast_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,

+			   GLenum internalFormat, GLuint width, GLuint height)

+{

+    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);

+

+    TRACE;

+

+    rb->Data = NULL;

+    rb->Width = width;

+    rb->Height = height;

+

+    xrb->pitch = bytes_per_line(width * xrb->bpp, 32);

+

+    return GL_TRUE;

+}

+

+static GLboolean

+swrast_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,

+			  GLenum internalFormat, GLuint width, GLuint height)

+{

+    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);

+

+    TRACE;

+

+    free(rb->Data);

+

+    swrast_alloc_front_storage(ctx, rb, internalFormat, width, height);

+

+    rb->Data = malloc(height * xrb->pitch);

+

+    return GL_TRUE;

+}

+

+static struct swrast_renderbuffer *

+swrast_new_renderbuffer(const struct gl_config *visual, GLboolean front)

+{

+    struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb);

+    GLuint pixel_format;

+

+    TRACE;

+

+    if (!xrb)

+	return NULL;

+

+    _mesa_init_renderbuffer(&xrb->Base, 0);

+

+    pixel_format = choose_pixel_format(visual);

+

+    xrb->Base.Delete = swrast_delete_renderbuffer;

+    if (front) {

+	xrb->Base.AllocStorage = swrast_alloc_front_storage;

+	swrast_set_span_funcs_front(xrb, pixel_format);

+    }

+    else {

+	xrb->Base.AllocStorage = swrast_alloc_back_storage;

+	swrast_set_span_funcs_back(xrb, pixel_format);

+    }

+

+    switch (pixel_format) {

+    case PF_A8R8G8B8:

+	xrb->Base.Format = MESA_FORMAT_ARGB8888;

+	xrb->Base.InternalFormat = GL_RGBA;

+	xrb->Base._BaseFormat = GL_RGBA;

+	xrb->Base.DataType = GL_UNSIGNED_BYTE;

+	xrb->bpp = 32;

+	break;

+    case PF_X8R8G8B8:

+	xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */

+	xrb->Base.InternalFormat = GL_RGB;

+	xrb->Base._BaseFormat = GL_RGB;

+	xrb->Base.DataType = GL_UNSIGNED_BYTE;

+	xrb->bpp = 32;

+	break;

+    case PF_R5G6B5:

+	xrb->Base.Format = MESA_FORMAT_RGB565;

+	xrb->Base.InternalFormat = GL_RGB;

+	xrb->Base._BaseFormat = GL_RGB;

+	xrb->Base.DataType = GL_UNSIGNED_BYTE;

+	xrb->bpp = 16;

+	break;

+    case PF_R3G3B2:

+	xrb->Base.Format = MESA_FORMAT_RGB332;

+	xrb->Base.InternalFormat = GL_RGB;

+	xrb->Base._BaseFormat = GL_RGB;

+	xrb->Base.DataType = GL_UNSIGNED_BYTE;

+	xrb->bpp = 8;

+	break;

+    default:

+	return NULL;

+    }

+

+    return xrb;

+}

+

+static GLboolean

+dri_create_buffer(__DRIscreen * sPriv,

+		  __DRIdrawable * dPriv,

+		  const struct gl_config * visual, GLboolean isPixmap)

+{

+    struct dri_drawable *drawable = NULL;

+    struct gl_framebuffer *fb;

+    struct swrast_renderbuffer *frontrb, *backrb;

+

+    TRACE;

+

+    drawable = CALLOC_STRUCT(dri_drawable);

+    if (drawable == NULL)

+	goto drawable_fail;

+

+    dPriv->driverPrivate = drawable;

+    drawable->dPriv = dPriv;

+

+    drawable->row = malloc(MAX_WIDTH * 4);

+    if (drawable->row == NULL)

+	goto drawable_fail;

+

+    fb = &drawable->Base;

+

+    /* basic framebuffer setup */

+    _mesa_initialize_window_framebuffer(fb, visual);

+

+    /* add front renderbuffer */

+    frontrb = swrast_new_renderbuffer(visual, GL_TRUE);

+    _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontrb->Base);

+

+    /* add back renderbuffer */

+    if (visual->doubleBufferMode) {

+	backrb = swrast_new_renderbuffer(visual, GL_FALSE);

+	_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backrb->Base);

+    }

+

+    /* add software renderbuffers */

+    _mesa_add_soft_renderbuffers(fb,

+				 GL_FALSE, /* color */

+				 visual->haveDepthBuffer,

+				 visual->haveStencilBuffer,

+				 visual->haveAccumBuffer,

+				 GL_FALSE, /* alpha */

+				 GL_FALSE /* aux bufs */);

+

+    return GL_TRUE;

+

+drawable_fail:

+

+    if (drawable)

+	free(drawable->row);

+

+    FREE(drawable);

+

+    return GL_FALSE;

+}

+

+static void

+dri_destroy_buffer(__DRIdrawable * dPriv)

+{

+    TRACE;

+

+    if (dPriv) {

+	struct dri_drawable *drawable = dri_drawable(dPriv);

+	struct gl_framebuffer *fb;

+

+	free(drawable->row);

+

+	fb = &drawable->Base;

+

+	fb->DeletePending = GL_TRUE;

+	_mesa_reference_framebuffer(&fb, NULL);

+    }

+}

+

+static void

+dri_swap_buffers(__DRIdrawable * dPriv)

+{

+    __DRIscreen *sPriv = dPriv->driScreenPriv;

+

+    GET_CURRENT_CONTEXT(ctx);

+

+    struct dri_drawable *drawable = dri_drawable(dPriv);

+    struct gl_framebuffer *fb;

+    struct swrast_renderbuffer *frontrb, *backrb;

+

+    TRACE;

+

+    fb = &drawable->Base;

+

+    frontrb =

+	swrast_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+    backrb =

+	swrast_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);

+

+    /* check for signle-buffered */

+    if (backrb == NULL)

+	return;

+

+    /* check if swapping currently bound buffer */

+    if (ctx && ctx->DrawBuffer == fb) {

+	/* flush pending rendering */

+	_mesa_notifySwapBuffers(ctx);

+    }

+

+    sPriv->swrast_loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,

+				   0, 0,

+				   frontrb->Base.Width,

+				   frontrb->Base.Height,

+				   backrb->Base.Data,

+				   dPriv->loaderPrivate);

+}

+

+

+/**

+ * General device driver functions.

+ */

+

+static void

+get_window_size( struct gl_framebuffer *fb, GLsizei *w, GLsizei *h )

+{

+    __DRIdrawable *dPriv = swrast_drawable(fb)->dPriv;

+    __DRIscreen *sPriv = dPriv->driScreenPriv;

+    int x, y;

+

+    sPriv->swrast_loader->getDrawableInfo(dPriv,

+					  &x, &y, w, h,

+					  dPriv->loaderPrivate);

+}

+

+static void

+swrast_check_and_update_window_size( struct gl_context *ctx, struct gl_framebuffer *fb )

+{

+    GLsizei width, height;

+

+    get_window_size(fb, &width, &height);

+    if (fb->Width != width || fb->Height != height) {

+	_mesa_resize_framebuffer(ctx, fb, width, height);

+    }

+}

+

+static const GLubyte *

+get_string(struct gl_context *ctx, GLenum pname)

+{

+    (void) ctx;

+    switch (pname) {

+	case GL_VENDOR:

+	    return (const GLubyte *) "Mesa Project";

+	case GL_RENDERER:

+	    return (const GLubyte *) "Software Rasterizer";

+	default:

+	    return NULL;

+    }

+}

+

+static void

+update_state( struct gl_context *ctx, GLuint new_state )

+{

+    /* not much to do here - pass it on */

+    _swrast_InvalidateState( ctx, new_state );

+    _swsetup_InvalidateState( ctx, new_state );

+    _vbo_InvalidateState( ctx, new_state );

+    _tnl_InvalidateState( ctx, new_state );

+}

+

+static void

+viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h)

+{

+    struct gl_framebuffer *draw = ctx->WinSysDrawBuffer;

+    struct gl_framebuffer *read = ctx->WinSysReadBuffer;

+

+    swrast_check_and_update_window_size(ctx, draw);

+    swrast_check_and_update_window_size(ctx, read);

+}

+

+static gl_format swrastChooseTextureFormat(struct gl_context * ctx,

+					   GLint internalFormat,

+					   GLenum format,

+					   GLenum type)

+{

+    if (internalFormat == GL_RGB)

+	return MESA_FORMAT_XRGB8888;

+    return _mesa_choose_tex_format(ctx, internalFormat, format, type);

+}

+

+static void

+swrast_init_driver_functions(struct dd_function_table *driver)

+{

+    driver->GetString = get_string;

+    driver->UpdateState = update_state;

+    driver->GetBufferSize = NULL;

+    driver->Viewport = viewport;

+    driver->ChooseTextureFormat = swrastChooseTextureFormat;

+}

+

+static const char *es2_extensions[] = {

+   /* Used by mesa internally (cf all_mesa_extensions in ../common/utils.c) */

+   "GL_ARB_draw_buffers",

+   "GL_ARB_multisample",

+   "GL_ARB_texture_compression",

+   "GL_ARB_transpose_matrix",

+   "GL_ARB_vertex_buffer_object",

+   "GL_ARB_window_pos",

+   "GL_EXT_blend_func_separate",

+   "GL_EXT_compiled_vertex_array",

+   "GL_EXT_framebuffer_blit",

+   "GL_EXT_multi_draw_arrays",

+   "GL_EXT_polygon_offset",

+   "GL_EXT_texture_object",

+   "GL_EXT_vertex_array",

+   "GL_IBM_multimode_draw_arrays",

+   "GL_MESA_window_pos",

+   "GL_NV_vertex_program",

+

+   /* Required by GLES2 */

+   "GL_ARB_fragment_program",

+   "GL_ARB_fragment_shader",

+   "GL_ARB_multitexture",

+   "GL_ARB_shader_objects",

+   "GL_ARB_texture_cube_map",

+   "GL_ARB_texture_mirrored_repeat",

+   "GL_ARB_texture_non_power_of_two",

+   "GL_ARB_vertex_shader",

+   "GL_EXT_blend_color",

+   "GL_EXT_blend_equation_separate",

+   "GL_EXT_blend_minmax",

+   "GL_EXT_blend_subtract",

+   "GL_EXT_stencil_wrap",

+

+   /* Optional GLES2 */

+   "GL_ARB_framebuffer_object",

+   "GL_EXT_texture_filter_anisotropic",

+   "GL_ARB_depth_texture",

+   "GL_EXT_packed_depth_stencil",

+   "GL_EXT_framebuffer_object",

+   NULL,

+};

+

+static void

+InitExtensionsES2(struct gl_context *ctx)

+{

+   int i;

+

+   /* Can't use driInitExtensions() since it uses extensions from

+    * main/remap_helper.h when called the first time. */

+

+   for (i = 0; es2_extensions[i]; i++)

+      _mesa_enable_extension(ctx, es2_extensions[i]);

+}

+

+/**

+ * Context-related functions.

+ */

+

+static GLboolean

+dri_create_context(gl_api api,

+		   const struct gl_config * visual,

+		   __DRIcontext * cPriv, void *sharedContextPrivate)

+{

+    struct dri_context *ctx = NULL;

+    struct dri_context *share = (struct dri_context *)sharedContextPrivate;

+    struct gl_context *mesaCtx = NULL;

+    struct gl_context *sharedCtx = NULL;

+    struct dd_function_table functions;

+

+    TRACE;

+

+    ctx = CALLOC_STRUCT(dri_context);

+    if (ctx == NULL)

+	goto context_fail;

+

+    cPriv->driverPrivate = ctx;

+    ctx->cPriv = cPriv;

+

+    /* build table of device driver functions */

+    _mesa_init_driver_functions(&functions);

+    swrast_init_driver_functions(&functions);

+

+    if (share) {

+	sharedCtx = &share->Base;

+    }

+

+    mesaCtx = &ctx->Base;

+

+    /* basic context setup */

+    if (!_mesa_initialize_context(mesaCtx, api, visual, sharedCtx, &functions, (void *) cPriv)) {

+	goto context_fail;

+    }

+

+    /* do bounds checking to prevent segfaults and server crashes! */

+    mesaCtx->Const.CheckArrayBounds = GL_TRUE;

+

+    /* create module contexts */

+    _swrast_CreateContext( mesaCtx );

+    _vbo_CreateContext( mesaCtx );

+    _tnl_CreateContext( mesaCtx );

+    _swsetup_CreateContext( mesaCtx );

+    _swsetup_Wakeup( mesaCtx );

+

+    /* use default TCL pipeline */

+    {

+       TNLcontext *tnl = TNL_CONTEXT(mesaCtx);

+       tnl->Driver.RunPipeline = _tnl_run_pipeline;

+    }

+

+    _mesa_meta_init(mesaCtx);

+    _mesa_enable_sw_extensions(mesaCtx);

+

+    switch (api) {

+    case API_OPENGL:

+        _mesa_enable_1_3_extensions(mesaCtx);

+        _mesa_enable_1_4_extensions(mesaCtx);

+        _mesa_enable_1_5_extensions(mesaCtx);

+        _mesa_enable_2_0_extensions(mesaCtx);

+        _mesa_enable_2_1_extensions(mesaCtx);

+

+        driInitExtensions( mesaCtx, NULL, GL_FALSE );

+        break;

+    case API_OPENGLES:

+        _mesa_enable_1_3_extensions(mesaCtx);

+        _mesa_enable_1_4_extensions(mesaCtx);

+        _mesa_enable_1_5_extensions(mesaCtx);

+

+        break;

+    case API_OPENGLES2:

+        InitExtensionsES2( mesaCtx);

+        break;

+    }

+

+    return GL_TRUE;

+

+context_fail:

+

+    FREE(ctx);

+

+    return GL_FALSE;

+}

+

+static void

+dri_destroy_context(__DRIcontext * cPriv)

+{

+    TRACE;

+

+    if (cPriv) {

+	struct dri_context *ctx = dri_context(cPriv);

+	struct gl_context *mesaCtx;

+

+	mesaCtx = &ctx->Base;

+

+        _mesa_meta_free(mesaCtx);

+	_swsetup_DestroyContext( mesaCtx );

+	_swrast_DestroyContext( mesaCtx );

+	_tnl_DestroyContext( mesaCtx );

+	_vbo_DestroyContext( mesaCtx );

+	_mesa_destroy_context( mesaCtx );

+    }

+}

+

+static GLboolean

+dri_make_current(__DRIcontext * cPriv,

+		 __DRIdrawable * driDrawPriv,

+		 __DRIdrawable * driReadPriv)

+{

+    struct gl_context *mesaCtx;

+    struct gl_framebuffer *mesaDraw;

+    struct gl_framebuffer *mesaRead;

+    TRACE;

+

+    if (cPriv) {

+	struct dri_context *ctx = dri_context(cPriv);

+	struct dri_drawable *draw;

+	struct dri_drawable *read;

+

+	if (!driDrawPriv || !driReadPriv)

+	    return GL_FALSE;

+

+	draw = dri_drawable(driDrawPriv);

+	read = dri_drawable(driReadPriv);

+	mesaCtx = &ctx->Base;

+	mesaDraw = &draw->Base;

+	mesaRead = &read->Base;

+

+	/* check for same context and buffer */

+	if (mesaCtx == _mesa_get_current_context()

+	    && mesaCtx->DrawBuffer == mesaDraw

+	    && mesaCtx->ReadBuffer == mesaRead) {

+	    return GL_TRUE;

+	}

+

+	_glapi_check_multithread();

+

+	swrast_check_and_update_window_size(mesaCtx, mesaDraw);

+	if (mesaRead != mesaDraw)

+	    swrast_check_and_update_window_size(mesaCtx, mesaRead);

+

+	_mesa_make_current( mesaCtx,

+			    mesaDraw,

+			    mesaRead );

+    }

+    else {

+	/* unbind */

+	_mesa_make_current( NULL, NULL, NULL );

+    }

+

+    return GL_TRUE;

+}

+

+static GLboolean

+dri_unbind_context(__DRIcontext * cPriv)

+{

+    TRACE;

+    (void) cPriv;

+

+    /* Unset current context and dispath table */

+    _mesa_make_current(NULL, NULL, NULL);

+

+    return GL_TRUE;

+}

+

+

+const struct __DriverAPIRec driDriverAPI = {

+    /*.InitScreen = */dri_init_screen,

+    /*.DestroyScreen = */dri_destroy_screen,

+    /*.CreateContext = */dri_create_context,

+    /*.DestroyContext = */dri_destroy_context,

+    /*.CreateBuffer = */dri_create_buffer,

+    /*.DestroyBuffer = */dri_destroy_buffer,

+    /*.SwapBuffers = */dri_swap_buffers,

+    /*.MakeCurrent = */dri_make_current,

+    /*.UnbindContext = */dri_unbind_context,

+};

+

+/* This is the table of extensions that the loader will dlsym() for. */

+PUBLIC const __DRIextension *__driDriverExtensions[] = {

+    &driCoreExtension.base,

+    &driSWRastExtension.base,

+    NULL

+};

diff --git a/mesalib/src/mesa/drivers/dri/swrast/swrast_priv.h b/mesalib/src/mesa/drivers/dri/swrast/swrast_priv.h
index 4c3c9830f..e61965147 100644
--- a/mesalib/src/mesa/drivers/dri/swrast/swrast_priv.h
+++ b/mesalib/src/mesa/drivers/dri/swrast/swrast_priv.h
@@ -32,6 +32,13 @@
 #include "main/mtypes.h"

 #include "drisw_util.h"

 

+#ifdef _MSC_VER

+#ifdef PUBLIC

+#undef PUBLIC

+#endif

+#define PUBLIC __declspec(dllexport)

+#endif

+

 

 /**

  * Debugging

diff --git a/mesalib/src/mesa/drivers/windows/gdi/wmesa.c b/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
index 4a8b1b283..1a13e9f5c 100644
--- a/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
+++ b/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
@@ -1,1662 +1,1662 @@
-/*
- * Windows (Win32/Win64) device driver for Mesa
- *
- */
-
-#include "wmesadef.h"
-#include "colors.h"
-#include <GL/wmesa.h>
-#include <winuser.h>
-#include "context.h"
-#include "extensions.h"
-#include "framebuffer.h"
-#include "renderbuffer.h"
-#include "drivers/common/driverfuncs.h"
-#include "drivers/common/meta.h"
-#include "vbo/vbo.h"
-#include "swrast/swrast.h"
-#include "swrast_setup/swrast_setup.h"
-#include "tnl/tnl.h"
-#include "tnl/t_context.h"
-#include "tnl/t_pipeline.h"
-
-
-/* linked list of our Framebuffers (windows) */
-static WMesaFramebuffer FirstFramebuffer = NULL;
-
-
-/**
- * Create a new WMesaFramebuffer object which will correspond to the
- * given HDC (Window handle).
- */
-WMesaFramebuffer
-wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)
-{
-    WMesaFramebuffer pwfb
-        = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));
-    if (pwfb) {
-        _mesa_initialize_window_framebuffer(&pwfb->Base, visual);
-        pwfb->hDC = hdc;
-        /* insert at head of list */
-        pwfb->next = FirstFramebuffer;
-        FirstFramebuffer = pwfb;
-    }
-    return pwfb;
-}
-
-/**
- * Given an hdc, free the corresponding WMesaFramebuffer
- */
-void
-wmesa_free_framebuffer(HDC hdc)
-{
-    WMesaFramebuffer pwfb, prev;
-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
-        if (pwfb->hDC == hdc)
-            break;
-	prev = pwfb;
-    }
-    if (pwfb) {
-        struct gl_framebuffer *fb;
-	if (pwfb == FirstFramebuffer)
-	    FirstFramebuffer = pwfb->next;
-	else
-	    prev->next = pwfb->next;
-        fb = &pwfb->Base;
-        _mesa_reference_framebuffer(&fb, NULL); 
-    }
-}
-
-/**
- * Given an hdc, return the corresponding WMesaFramebuffer
- */
-WMesaFramebuffer
-wmesa_lookup_framebuffer(HDC hdc)
-{
-    WMesaFramebuffer pwfb;
-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
-        if (pwfb->hDC == hdc)
-            return pwfb;
-    }
-    return NULL;
-}
-
-
-/**
- * Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer.
- */
-static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb)
-{
-    return (WMesaFramebuffer) fb;
-}
-
-
-/**
- * Given a struct gl_context, return the corresponding WMesaContext.
- */
-static WMesaContext wmesa_context(const struct gl_context *ctx)
-{
-    return (WMesaContext) ctx;
-}
-
-
-/*
- * Every driver should implement a GetString function in order to
- * return a meaningful GL_RENDERER string.
- */
-static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name)
-{
-    return (name == GL_RENDERER) ? 
-	(GLubyte *) "Mesa Windows GDI Driver" : NULL;
-}
-
-
-/*
- * Determine the pixel format based on the pixel size.
- */
-static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)
-{
-    pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
-
-    /* Only 16 and 32 bit targets are supported now */
-    assert(pwfb->cColorBits == 0 ||
-	   pwfb->cColorBits == 16 || 
-	   pwfb->cColorBits == 24 || 
-	   pwfb->cColorBits == 32);
-
-    switch(pwfb->cColorBits){
-    case 8:
-	pwfb->pixelformat = PF_INDEX8;
-	break;
-    case 16:
-	pwfb->pixelformat = PF_5R6G5B;
-	break;
-    case 24:
-    case 32:
-	pwfb->pixelformat = PF_8R8G8B;
-	break;
-    default:
-	pwfb->pixelformat = PF_BADFORMAT;
-    }
-}
-
-
-/**
- * Create DIB for back buffer.
- * We write into this memory with the span routines and then blit it
- * to the window on a buffer swap.
- */
-BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize)
-{
-    HDC          hdc = pwfb->hDC;
-    LPBITMAPINFO pbmi = &(pwfb->bmi);
-    HDC          hic;
-
-    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    pbmi->bmiHeader.biWidth = lxSize;
-    pbmi->bmiHeader.biHeight= -lySize;
-    pbmi->bmiHeader.biPlanes = 1;
-    pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL);
-    pbmi->bmiHeader.biCompression = BI_RGB;
-    pbmi->bmiHeader.biSizeImage = 0;
-    pbmi->bmiHeader.biXPelsPerMeter = 0;
-    pbmi->bmiHeader.biYPelsPerMeter = 0;
-    pbmi->bmiHeader.biClrUsed = 0;
-    pbmi->bmiHeader.biClrImportant = 0;
-    
-    pwfb->cColorBits = pbmi->bmiHeader.biBitCount;
-    pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3;
-    
-    hic = CreateIC("display", NULL, NULL, NULL);
-    pwfb->dib_hDC = CreateCompatibleDC(hic);
-    
-    pwfb->hbmDIB = CreateDIBSection(hic,
-				   &pwfb->bmi,
-				   DIB_RGB_COLORS,
-				   (void **)&(pwfb->pbPixels),
-				   0,
-				   0);
-    pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB);
-    
-    DeleteDC(hic);
-
-    wmSetPixelFormat(pwfb, pwfb->hDC);
-    return TRUE;
-}
-
-
-static wmDeleteBackingStore(WMesaFramebuffer pwfb)
-{
-    if (pwfb->hbmDIB) {
-	SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap);
-	DeleteDC(pwfb->dib_hDC);
-	DeleteObject(pwfb->hbmDIB);
-    }
-}
-
-
-/**
- * Find the width and height of the window named by hdc.
- */
-static void
-get_window_size(HDC hdc, GLuint *width, GLuint *height)
-{
-    if (WindowFromDC(hdc)) {
-        RECT rect;
-        GetClientRect(WindowFromDC(hdc), &rect);
-        *width = rect.right - rect.left;
-        *height = rect.bottom - rect.top;
-    }
-    else { /* Memory context */
-        /* From contributed code - use the size of the desktop
-         * for the size of a memory context (?) */
-        *width = GetDeviceCaps(hdc, HORZRES);
-        *height = GetDeviceCaps(hdc, VERTRES);
-    }
-}
-
-
-static void
-wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height)
-{
-    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
-    get_window_size(pwfb->hDC, width, height);
-}
-
-
-static void wmesa_flush(struct gl_context *ctx)
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer);
-
-    if (ctx->Visual.doubleBufferMode == 1) {
-	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
-	       pwfb->dib_hDC, 0, 0, SRCCOPY);
-    }
-    else {
-	/* Do nothing for single buffer */
-    }
-}
-
-
-/**********************************************************************/
-/*****                   CLEAR Functions                          *****/
-/**********************************************************************/
-
-/* If we do not implement these, Mesa clears the buffers via the pixel
- * span writing interface, which is very slow for a clear operation.
- */
-
-/*
- * Set the color used to clear the color buffer.
- */
-static void clear_color(struct gl_context *ctx, const GLfloat color[4])
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLubyte col[3];
-    UINT    bytesPerPixel = pwfb->cColorBits / 8; 
-
-    CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);
-    CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);
-    CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);
-    pwc->clearColorRef = RGB(col[0], col[1], col[2]);
-    DeleteObject(pwc->clearPen);
-    DeleteObject(pwc->clearBrush);
-    pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef); 
-    pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef); 
-}
-
-
-/* 
- * Clear the specified region of the color buffer using the clear color 
- * or index as specified by one of the two functions above. 
- * 
- * This procedure clears either the front and/or the back COLOR buffers. 
- * Only the "left" buffer is cleared since we are not stereo. 
- * Clearing of the other non-color buffers is left to the swrast. 
- */ 
-
-static void clear(struct gl_context *ctx, GLbitfield mask)
-{
-#define FLIP(Y)  (ctx->DrawBuffer->Height - (Y) - 1)
-    const GLint x = ctx->DrawBuffer->_Xmin;
-    const GLint y = ctx->DrawBuffer->_Ymin;
-    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
-    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
-
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    int done = 0;
-
-    /* Let swrast do all the work if the masks are not set to
-     * clear all channels. */
-    if (!ctx->Color.ColorMask[0][0] ||
-	!ctx->Color.ColorMask[0][1] ||
-	!ctx->Color.ColorMask[0][2] ||
-	!ctx->Color.ColorMask[0][3]) {
-	_swrast_Clear(ctx, mask);
-	return;
-    }
-
-    /* Back buffer */
-    if (mask & BUFFER_BIT_BACK_LEFT) { 
-	
-	int     i, rowSize; 
-	UINT    bytesPerPixel = pwfb->cColorBits / 8; 
-	LPBYTE  lpb, clearRow;
-	LPWORD  lpw;
-	BYTE    bColor; 
-	WORD    wColor; 
-	BYTE    r, g, b; 
-	DWORD   dwColor; 
-	LPDWORD lpdw; 
-	
-	/* Try for a fast clear - clearing entire buffer with a single
-	 * byte value. */
-	if (width == ctx->DrawBuffer->Width &&
-            height == ctx->DrawBuffer->Height) { /* entire buffer */
-	    /* Now check for an easy clear value */
-	    switch (bytesPerPixel) {
-	    case 1:
-		bColor = BGR8(GetRValue(pwc->clearColorRef), 
-			      GetGValue(pwc->clearColorRef), 
-			      GetBValue(pwc->clearColorRef));
-		memset(pwfb->pbPixels, bColor, 
-		       pwfb->ScanWidth * height);
-		done = 1;
-		break;
-	    case 2:
-		wColor = BGR16(GetRValue(pwc->clearColorRef), 
-			       GetGValue(pwc->clearColorRef), 
-			       GetBValue(pwc->clearColorRef)); 
-		if (((wColor >> 8) & 0xff) == (wColor & 0xff)) {
-		    memset(pwfb->pbPixels, wColor & 0xff, 
-			   pwfb->ScanWidth * height);
-		    done = 1;
-		}
-		break;
-	    case 3:
-		/* fall through */
-	    case 4:
-		if (GetRValue(pwc->clearColorRef) == 
-		    GetGValue(pwc->clearColorRef) &&
-		    GetRValue(pwc->clearColorRef) == 
-		    GetBValue(pwc->clearColorRef)) {
-		    memset(pwfb->pbPixels, 
-			   GetRValue(pwc->clearColorRef), 
-			   pwfb->ScanWidth * height);
-		    done = 1;
-		}
-		break;
-	    default:
-		break;
-	    }
-	} /* all */
-
-	if (!done) {
-	    /* Need to clear a row at a time.  Begin by setting the first
-	     * row in the area to be cleared to the clear color. */
-	    
-	    clearRow = pwfb->pbPixels + 
-		pwfb->ScanWidth * FLIP(y) +
-		bytesPerPixel * x; 
-	    switch (bytesPerPixel) {
-	    case 1:
-		lpb = clearRow;
-		bColor = BGR8(GetRValue(pwc->clearColorRef), 
-			      GetGValue(pwc->clearColorRef), 
-			      GetBValue(pwc->clearColorRef));
-		memset(lpb, bColor, width);
-		break;
-	    case 2:
-		lpw = (LPWORD)clearRow;
-		wColor = BGR16(GetRValue(pwc->clearColorRef), 
-			       GetGValue(pwc->clearColorRef), 
-			       GetBValue(pwc->clearColorRef)); 
-		for (i=0; i<width; i++)
-		    *lpw++ = wColor;
-		break;
-	    case 3: 
-		lpb = clearRow;
-		r = GetRValue(pwc->clearColorRef); 
-		g = GetGValue(pwc->clearColorRef); 
-		b = GetBValue(pwc->clearColorRef); 
-		for (i=0; i<width; i++) {
-		    *lpb++ = b; 
-		    *lpb++ = g; 
-		    *lpb++ = r; 
-		} 
-		break;
-	    case 4: 
-		lpdw = (LPDWORD)clearRow; 
-		dwColor = BGR32(GetRValue(pwc->clearColorRef), 
-				GetGValue(pwc->clearColorRef), 
-				GetBValue(pwc->clearColorRef)); 
-		for (i=0; i<width; i++)
-		    *lpdw++ = dwColor;
-		break;
-	    default:
-		break;
-	    } /* switch */
-	    
-	    /* copy cleared row to other rows in buffer */
-	    lpb = clearRow - pwfb->ScanWidth;
-	    rowSize = width * bytesPerPixel;
-	    for (i=1; i<height; i++) { 
-		memcpy(lpb, clearRow, rowSize); 
-		lpb -= pwfb->ScanWidth; 
-	    } 
-	} /* not done */
-	mask &= ~BUFFER_BIT_BACK_LEFT;
-    } /* back buffer */ 
-
-    /* front buffer */
-    if (mask & BUFFER_BIT_FRONT_LEFT) { 
-	HDC DC = pwc->hDC; 
-	HPEN Old_Pen = SelectObject(DC, pwc->clearPen); 
-	HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush);
-	Rectangle(DC,
-		  x,
-		  FLIP(y) + 1,
-		  x + width + 1,
-		  FLIP(y) - height + 1);
-	SelectObject(DC, Old_Pen); 
-	SelectObject(DC, Old_Brush); 
-	mask &= ~BUFFER_BIT_FRONT_LEFT;
-    } /* front buffer */ 
-    
-    /* Call swrast if there is anything left to clear (like DEPTH) */ 
-    if (mask) 
-	_swrast_Clear(ctx, mask);
-  
-#undef FLIP
-} 
-
-
-/**********************************************************************/
-/*****                   PIXEL Functions                          *****/
-/**********************************************************************/
-
-#define FLIP(Y)  (rb->Height - (Y) - 1)
-
-
-/**
- ** Front Buffer reading/writing
- ** These are slow, but work with all non-indexed visual types.
- **/
-
-/* Write a horizontal span of RGBA color pixels with a boolean mask. */
-static void write_rgba_span_front(const struct gl_context *ctx, 
-				   struct gl_renderbuffer *rb, 
-				   GLuint n, GLint x, GLint y,
-				   const GLubyte rgba[][4], 
-				   const GLubyte mask[] )
-{
-   WMesaContext pwc = wmesa_context(ctx);
-   WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC);
-   CONST BITMAPINFO bmi=
-   {
-      {
-         sizeof(BITMAPINFOHEADER),
-         n, 1, 1, 32, BI_RGB, 0, 1, 1, 0, 0
-      }
-   };
-   HBITMAP bmp=0;
-   HDC mdc=0;
-   typedef union
-   {
-      unsigned i;
-      struct {
-         unsigned b:8, g:8, r:8, a:8;
-      };
-   } BGRA;
-   BGRA *bgra, c;
-   GLuint i;
-
-   if (n < 16) {   // the value 16 is just guessed
-      y=FLIP(y);
-      if (mask) {
-         for (i=0; i<n; i++)
-            if (mask[i])
-               SetPixel(pwc->hDC, x+i, y,
-                        RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
-      }
-      else {
-         for (i=0; i<n; i++)
-            SetPixel(pwc->hDC, x+i, y,
-                     RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
-      }
-   }
-   else {
-      if (!pwfb) {
-         _mesa_problem(NULL, "wmesa: write_rgba_span_front on unknown hdc");
-         return;
-      }
-      bgra=malloc(n*sizeof(BGRA));
-      if (!bgra) {
-         _mesa_problem(NULL, "wmesa: write_rgba_span_front: out of memory");
-         return;
-      }
-      c.a=0;
-      if (mask) {
-         for (i=0; i<n; i++) {
-            if (mask[i]) {
-               c.r=rgba[i][RCOMP];
-               c.g=rgba[i][GCOMP];
-               c.b=rgba[i][BCOMP];
-               c.a=rgba[i][ACOMP];
-               bgra[i]=c;
-            }
-            else
-               bgra[i].i=0;
-         }
-      }
-      else {
-         for (i=0; i<n; i++) {
-            c.r=rgba[i][RCOMP];
-            c.g=rgba[i][GCOMP];
-            c.b=rgba[i][BCOMP];
-            c.a=rgba[i][ACOMP];
-            bgra[i]=c;
-         }
-      }
-      bmp=CreateBitmap(n, 1,  1, 32, bgra);
-      mdc=CreateCompatibleDC(pwfb->hDC);
-      SelectObject(mdc, bmp);
-      y=FLIP(y);
-      BitBlt(pwfb->hDC, x, y, n, 1, mdc, 0, 0, SRCCOPY);
-      SelectObject(mdc, 0);
-      DeleteObject(bmp);
-      DeleteDC(mdc);
-      free(bgra);
-   }
-}
-
-/* Write a horizontal span of RGB color pixels with a boolean mask. */
-static void write_rgb_span_front(const struct gl_context *ctx, 
-				  struct gl_renderbuffer *rb, 
-				  GLuint n, GLint x, GLint y,
-				  const GLubyte rgb[][3], 
-				  const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    GLuint i;
-    
-    (void) ctx;
-    y=FLIP(y);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-		SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 
-					       rgb[i][BCOMP]));
-    }
-    else {
-	for (i=0; i<n; i++)
-	    SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 
-					   rgb[i][BCOMP]));
-    }
-    
-}
-
-/*
- * Write a horizontal span of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_span_front(const struct gl_context *ctx, 
-					struct gl_renderbuffer *rb,
-					GLuint n, GLint x, GLint y,
-					const GLchan color[4], 
-					const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    COLORREF colorref;
-
-    (void) ctx;
-    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
-    y=FLIP(y);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-		SetPixel(pwc->hDC, x+i, y, colorref);
-    }
-    else
-	for (i=0; i<n; i++)
-	    SetPixel(pwc->hDC, x+i, y, colorref);
-
-}
-
-/* Write an array of RGBA pixels with a boolean mask. */
-static void write_rgba_pixels_front(const struct gl_context *ctx, 
-				     struct gl_renderbuffer *rb,
-				     GLuint n, 
-				     const GLint x[], const GLint y[],
-				     const GLubyte rgba[][4], 
-				     const GLubyte mask[] )
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    (void) ctx;
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), 
-		     RGB(rgba[i][RCOMP], rgba[i][GCOMP], 
-			 rgba[i][BCOMP]));
-}
-
-
-
-/*
- * Write an array of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_pixels_front(const struct gl_context *ctx, 
-					  struct gl_renderbuffer *rb,
-					  GLuint n,
-					  const GLint x[], const GLint y[],
-					  const GLchan color[4],
-					  const GLubyte mask[] )
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    COLORREF colorref;
-    (void) ctx;
-    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), colorref);
-}
-
-/* Read a horizontal span of color pixels. */
-static void read_rgba_span_front(const struct gl_context *ctx, 
-				  struct gl_renderbuffer *rb,
-				  GLuint n, GLint x, GLint y,
-				  GLubyte rgba[][4] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    GLuint i;
-    COLORREF Color;
-    y = FLIP(y);
-    for (i=0; i<n; i++) {
-	Color = GetPixel(pwc->hDC, x+i, y);
-	rgba[i][RCOMP] = GetRValue(Color);
-	rgba[i][GCOMP] = GetGValue(Color);
-	rgba[i][BCOMP] = GetBValue(Color);
-	rgba[i][ACOMP] = 255;
-    }
-}
-
-
-/* Read an array of color pixels. */
-static void read_rgba_pixels_front(const struct gl_context *ctx, 
-				    struct gl_renderbuffer *rb,
-				    GLuint n, const GLint x[], const GLint y[],
-				    GLubyte rgba[][4])
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    GLuint i;
-    COLORREF Color;
-    for (i=0; i<n; i++) {
-        GLint y2 = FLIP(y[i]);
-        Color = GetPixel(pwc->hDC, x[i], y2);
-        rgba[i][RCOMP] = GetRValue(Color);
-        rgba[i][GCOMP] = GetGValue(Color);
-        rgba[i][BCOMP] = GetBValue(Color);
-        rgba[i][ACOMP] = 255;
-    }
-}
-
-/*********************************************************************/
-
-/* DOUBLE BUFFER 32-bit */
-
-#define WMSETPIXEL32(pwc, y, x, r, g, b) { \
-LPDWORD lpdw = ((LPDWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \
-*lpdw = BGR32((r),(g),(b)); }
-
-
-
-/* Write a horizontal span of RGBA color pixels with a boolean mask. */
-static void write_rgba_span_32(const struct gl_context *ctx, 
-			       struct gl_renderbuffer *rb, 
-			       GLuint n, GLint x, GLint y,
-			       const GLubyte rgba[][4], 
-			       const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPDWORD lpdw;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpdw[i] = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 
-				rgba[i][BCOMP]);
-    }
-    else {
-	for (i=0; i<n; i++)
-                *lpdw++ = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 
-				rgba[i][BCOMP]);
-    }
-}
-
-
-/* Write a horizontal span of RGB color pixels with a boolean mask. */
-static void write_rgb_span_32(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb, 
-			      GLuint n, GLint x, GLint y,
-			      const GLubyte rgb[][3], 
-			      const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPDWORD lpdw;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpdw[i] = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 
-				rgb[i][BCOMP]);
-    }
-    else {
-	for (i=0; i<n; i++)
-                *lpdw++ = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 
-				rgb[i][BCOMP]);
-    }
-}
-
-/*
- * Write a horizontal span of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_span_32(const struct gl_context *ctx, 
-				    struct gl_renderbuffer *rb,
-				    GLuint n, GLint x, GLint y,
-				    const GLchan color[4], 
-				    const GLubyte mask[])
-{
-    LPDWORD lpdw;
-    DWORD pixel;
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    y=FLIP(y);
-    pixel = BGR32(color[RCOMP], color[GCOMP], color[BCOMP]);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpdw[i] = pixel;
-    }
-    else
-	for (i=0; i<n; i++)
-                *lpdw++ = pixel;
-
-}
-
-/* Write an array of RGBA pixels with a boolean mask. */
-static void write_rgba_pixels_32(const struct gl_context *ctx, 
-				 struct gl_renderbuffer *rb,
-				 GLuint n, const GLint x[], const GLint y[],
-				 const GLubyte rgba[][4], 
-				 const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL32(pwfb, FLIP(y[i]), x[i],
-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-}
-
-/*
- * Write an array of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_pixels_32(const struct gl_context *ctx, 
-				      struct gl_renderbuffer *rb,
-				      GLuint n,
-				      const GLint x[], const GLint y[],
-				      const GLchan color[4],
-				      const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL32(pwfb, FLIP(y[i]),x[i],color[RCOMP],
-			 color[GCOMP], color[BCOMP]);
-}
-
-/* Read a horizontal span of color pixels. */
-static void read_rgba_span_32(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb,
-			      GLuint n, GLint x, GLint y,
-			      GLubyte rgba[][4] )
-{
-    GLuint i;
-    DWORD pixel;
-    LPDWORD lpdw;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    
-    y = FLIP(y);
-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    for (i=0; i<n; i++) {
-	pixel = lpdw[i];
-	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);
-	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);
-	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);
-	rgba[i][ACOMP] = 255;
-    }
-}
-
-
-/* Read an array of color pixels. */
-static void read_rgba_pixels_32(const struct gl_context *ctx, 
-				struct gl_renderbuffer *rb,
-				GLuint n, const GLint x[], const GLint y[],
-				GLubyte rgba[][4])
-{
-    GLuint i;
-    DWORD pixel;
-    LPDWORD lpdw;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-
-    for (i=0; i<n; i++) {
-	GLint y2 = FLIP(y[i]);
-	lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];
-	pixel = *lpdw;
-	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);
-	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);
-	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);
-	rgba[i][ACOMP] = 255;
-  }
-}
-
-
-/*********************************************************************/
-
-/* DOUBLE BUFFER 24-bit */
-
-#define WMSETPIXEL24(pwc, y, x, r, g, b) { \
-LPBYTE lpb = ((LPBYTE)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (3 * x)); \
-lpb[0] = (b); \
-lpb[1] = (g); \
-lpb[2] = (r); }
-
-/* Write a horizontal span of RGBA color pixels with a boolean mask. */
-static void write_rgba_span_24(const struct gl_context *ctx, 
-			       struct gl_renderbuffer *rb, 
-			       GLuint n, GLint x, GLint y,
-			       const GLubyte rgba[][4], 
-			       const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPBYTE lpb;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i]) {
-                lpb[3*i] = rgba[i][BCOMP];
-                lpb[3*i+1] = rgba[i][GCOMP];
-                lpb[3*i+2] = rgba[i][RCOMP];
-	    }
-    }
-    else {
-	    for (i=0; i<n; i++) {
-            *lpb++ = rgba[i][BCOMP];
-            *lpb++ = rgba[i][GCOMP];
-            *lpb++ = rgba[i][RCOMP];
-	    }
-    }
-}
-
-
-/* Write a horizontal span of RGB color pixels with a boolean mask. */
-static void write_rgb_span_24(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb, 
-			      GLuint n, GLint x, GLint y,
-			      const GLubyte rgb[][3], 
-			      const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPBYTE lpb;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i]) {
-            lpb[3*i] = rgb[i][BCOMP];
-            lpb[3*i+1] = rgb[i][GCOMP];
-            lpb[3*i+2] = rgb[i][RCOMP];
-	    }
-    }
-    else {
-    	for (i=0; i<n; i++) {
-    		*lpb++ = rgb[i][BCOMP];
-    		*lpb++ = rgb[i][GCOMP];
-    		*lpb++ = rgb[i][RCOMP];
-    	}
-    }
-}
-
-/*
- * Write a horizontal span of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_span_24(const struct gl_context *ctx, 
-				    struct gl_renderbuffer *rb,
-				    GLuint n, GLint x, GLint y,
-				    const GLchan color[4], 
-				    const GLubyte mask[])
-{
-    LPBYTE lpb;
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
-    y=FLIP(y);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i]) {
-	    	lpb[3*i] = color[BCOMP];
-	    	lpb[3*i+1] = color[GCOMP];
-	    	lpb[3*i+2] = color[RCOMP];
-	    }
-    }
-    else
-	for (i=0; i<n; i++) {
-		*lpb++ = color[BCOMP];
-		*lpb++ = color[GCOMP];
-		*lpb++ = color[RCOMP];		
-	}
-}
-
-/* Write an array of RGBA pixels with a boolean mask. */
-static void write_rgba_pixels_24(const struct gl_context *ctx, 
-				 struct gl_renderbuffer *rb,
-				 GLuint n, const GLint x[], const GLint y[],
-				 const GLubyte rgba[][4], 
-				 const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL24(pwfb, FLIP(y[i]), x[i],
-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-}
-
-/*
- * Write an array of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_pixels_24(const struct gl_context *ctx, 
-				      struct gl_renderbuffer *rb,
-				      GLuint n,
-				      const GLint x[], const GLint y[],
-				      const GLchan color[4],
-				      const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL24(pwfb, FLIP(y[i]),x[i],color[RCOMP],
-			 color[GCOMP], color[BCOMP]);
-}
-
-/* Read a horizontal span of color pixels. */
-static void read_rgba_span_24(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb,
-			      GLuint n, GLint x, GLint y,
-			      GLubyte rgba[][4] )
-{
-    GLuint i;
-    LPBYTE lpb;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    
-    y = FLIP(y);
-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
-    for (i=0; i<n; i++) {
-	rgba[i][RCOMP] = lpb[3*i+2];
-	rgba[i][GCOMP] = lpb[3*i+1];
-	rgba[i][BCOMP] = lpb[3*i];
-	rgba[i][ACOMP] = 255;
-    }
-}
-
-
-/* Read an array of color pixels. */
-static void read_rgba_pixels_24(const struct gl_context *ctx, 
-				struct gl_renderbuffer *rb,
-				GLuint n, const GLint x[], const GLint y[],
-				GLubyte rgba[][4])
-{
-    GLuint i;
-    LPBYTE lpb;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-
-    for (i=0; i<n; i++) {
-	GLint y2 = FLIP(y[i]);
-	lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + (3 * x[i]);
-	rgba[i][RCOMP] = lpb[3*i+2];
-	rgba[i][GCOMP] = lpb[3*i+1];
-	rgba[i][BCOMP] = lpb[3*i];
-	rgba[i][ACOMP] = 255;
-  }
-}
-
-
-/*********************************************************************/
-
-/* DOUBLE BUFFER 16-bit */
-
-#define WMSETPIXEL16(pwc, y, x, r, g, b) { \
-LPWORD lpw = ((LPWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \
-*lpw = BGR16((r),(g),(b)); }
-
-
-
-/* Write a horizontal span of RGBA color pixels with a boolean mask. */
-static void write_rgba_span_16(const struct gl_context *ctx, 
-			       struct gl_renderbuffer *rb, 
-			       GLuint n, GLint x, GLint y,
-			       const GLubyte rgba[][4], 
-			       const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPWORD lpw;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpw[i] = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 
-			       rgba[i][BCOMP]);
-    }
-    else {
-	for (i=0; i<n; i++)
-                *lpw++ = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 
-			       rgba[i][BCOMP]);
-    }
-}
-
-
-/* Write a horizontal span of RGB color pixels with a boolean mask. */
-static void write_rgb_span_16(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb, 
-			      GLuint n, GLint x, GLint y,
-			      const GLubyte rgb[][3], 
-			      const GLubyte mask[] )
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    GLuint i;
-    LPWORD lpw;
-
-    (void) ctx;
-    
-    y=FLIP(y);
-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpw[i] = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 
-			       rgb[i][BCOMP]);
-    }
-    else {
-	for (i=0; i<n; i++)
-                *lpw++ = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 
-			       rgb[i][BCOMP]);
-    }
-}
-
-/*
- * Write a horizontal span of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_span_16(const struct gl_context *ctx, 
-				    struct gl_renderbuffer *rb,
-				    GLuint n, GLint x, GLint y,
-				    const GLchan color[4], 
-				    const GLubyte mask[])
-{
-    LPWORD lpw;
-    WORD pixel;
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    (void) ctx;
-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    y=FLIP(y);
-    pixel = BGR16(color[RCOMP], color[GCOMP], color[BCOMP]);
-    if (mask) {
-	for (i=0; i<n; i++)
-	    if (mask[i])
-                lpw[i] = pixel;
-    }
-    else
-	for (i=0; i<n; i++)
-                *lpw++ = pixel;
-
-}
-
-/* Write an array of RGBA pixels with a boolean mask. */
-static void write_rgba_pixels_16(const struct gl_context *ctx, 
-				 struct gl_renderbuffer *rb,
-				 GLuint n, const GLint x[], const GLint y[],
-				 const GLubyte rgba[][4], 
-				 const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    (void) ctx;
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL16(pwfb, FLIP(y[i]), x[i],
-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-}
-
-/*
- * Write an array of pixels with a boolean mask.  The current color
- * is used for all pixels.
- */
-static void write_mono_rgba_pixels_16(const struct gl_context *ctx, 
-				      struct gl_renderbuffer *rb,
-				      GLuint n,
-				      const GLint x[], const GLint y[],
-				      const GLchan color[4],
-				      const GLubyte mask[])
-{
-    GLuint i;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    (void) ctx;
-    for (i=0; i<n; i++)
-	if (mask[i])
-	    WMSETPIXEL16(pwfb, FLIP(y[i]),x[i],color[RCOMP],
-			 color[GCOMP], color[BCOMP]);
-}
-
-/* Read a horizontal span of color pixels. */
-static void read_rgba_span_16(const struct gl_context *ctx, 
-			      struct gl_renderbuffer *rb,
-			      GLuint n, GLint x, GLint y,
-			      GLubyte rgba[][4] )
-{
-    GLuint i, pixel;
-    LPWORD lpw;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-    
-    y = FLIP(y);
-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
-    for (i=0; i<n; i++) {
-	pixel = lpw[i];
-	/* Windows uses 5,5,5 for 16-bit */
-	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;
-	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;
-	rgba[i][BCOMP] = (pixel & 0x001f) << 3;
-	rgba[i][ACOMP] = 255;
-    }
-}
-
-
-/* Read an array of color pixels. */
-static void read_rgba_pixels_16(const struct gl_context *ctx, 
-				struct gl_renderbuffer *rb,
-				GLuint n, const GLint x[], const GLint y[],
-				GLubyte rgba[][4])
-{
-    GLuint i, pixel;
-    LPWORD lpw;
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
-
-    for (i=0; i<n; i++) {
-	GLint y2 = FLIP(y[i]);
-	lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];
-	pixel = *lpw;
-	/* Windows uses 5,5,5 for 16-bit */
-	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;
-	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;
-	rgba[i][BCOMP] = (pixel & 0x001f) << 3;
-	rgba[i][ACOMP] = 255;
-  }
-}
-
-
-
-
-/**********************************************************************/
-/*****                   BUFFER Functions                         *****/
-/**********************************************************************/
-
-
-
-
-static void
-wmesa_delete_renderbuffer(struct gl_renderbuffer *rb)
-{
-    free(rb);
-}
-
-
-/**
- * This is called by Mesa whenever it determines that the window size
- * has changed.  Do whatever's needed to cope with that.
- */
-static GLboolean
-wmesa_renderbuffer_storage(struct gl_context *ctx, 
-			   struct gl_renderbuffer *rb,
-			   GLenum internalFormat, 
-			   GLuint width, 
-			   GLuint height)
-{
-    rb->Width = width;
-    rb->Height = height;
-    return GL_TRUE;
-}
-
-
-/**
- * Plug in the Get/PutRow/Values functions for a renderbuffer depending
- * on if we're drawing to the front or back color buffer.
- */
-void wmesa_set_renderbuffer_funcs(struct gl_renderbuffer *rb, int pixelformat,
-                                  int cColorBits, int double_buffer)
-{
-    if (double_buffer) {
-        /* back buffer */
-	/* Picking the correct span functions is important because
-	 * the DIB was allocated with the indicated depth. */
-	switch(pixelformat) {
-	case PF_5R6G5B:
-	    rb->PutRow = write_rgba_span_16;
-	    rb->PutRowRGB = write_rgb_span_16;
-	    rb->PutMonoRow = write_mono_rgba_span_16;
-	    rb->PutValues = write_rgba_pixels_16;
-	    rb->PutMonoValues = write_mono_rgba_pixels_16;
-	    rb->GetRow = read_rgba_span_16;
-	    rb->GetValues = read_rgba_pixels_16;
-	    break;
-	case PF_8R8G8B:
-		if (cColorBits == 24)
-		{
-		    rb->PutRow = write_rgba_span_24;
-		    rb->PutRowRGB = write_rgb_span_24;
-		    rb->PutMonoRow = write_mono_rgba_span_24;
-		    rb->PutValues = write_rgba_pixels_24;
-		    rb->PutMonoValues = write_mono_rgba_pixels_24;
-		    rb->GetRow = read_rgba_span_24;
-		    rb->GetValues = read_rgba_pixels_24;
-		}
-		else
-		{
-	        rb->PutRow = write_rgba_span_32;
-	        rb->PutRowRGB = write_rgb_span_32;
-	        rb->PutMonoRow = write_mono_rgba_span_32;
-	        rb->PutValues = write_rgba_pixels_32;
-	        rb->PutMonoValues = write_mono_rgba_pixels_32;
-	        rb->GetRow = read_rgba_span_32;
-	        rb->GetValues = read_rgba_pixels_32;
-		}
-	    break;
-	default:
-	    break;
-	}
-    }
-    else {
-        /* front buffer (actual Windows window) */
-	rb->PutRow = write_rgba_span_front;
-	rb->PutRowRGB = write_rgb_span_front;
-	rb->PutMonoRow = write_mono_rgba_span_front;
-	rb->PutValues = write_rgba_pixels_front;
-	rb->PutMonoValues = write_mono_rgba_pixels_front;
-	rb->GetRow = read_rgba_span_front;
-	rb->GetValues = read_rgba_pixels_front;
-    }
-}
-
-/**
- * Called by ctx->Driver.ResizeBuffers()
- * Resize the front/back colorbuffers to match the latest window size.
- */
-static void
-wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer,
-                     GLuint width, GLuint height)
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
-
-    if (pwfb->Base.Width != width || pwfb->Base.Height != height) {
-	/* Realloc back buffer */
-	if (ctx->Visual.doubleBufferMode == 1) {
-	    wmDeleteBackingStore(pwfb);
-	    wmCreateBackingStore(pwfb, width, height);
-	}
-    }
-    _mesa_resize_framebuffer(ctx, buffer, width, height);
-}
-
-
-/**
- * Called by glViewport.
- * This is a good time for us to poll the current window size and adjust
- * our renderbuffers to match the current window size.
- * Remember, we have no opportunity to respond to conventional
- * resize events since the driver has no event loop.
- * Thus, we poll.
- * MakeCurrent also ends up making a call here, so that ensures
- * we get the viewport set correctly, even if the app does not call
- * glViewport and relies on the defaults.
- */
-static void wmesa_viewport(struct gl_context *ctx, 
-			   GLint x, GLint y, 
-			   GLsizei width, GLsizei height)
-{
-    WMesaContext pwc = wmesa_context(ctx);
-    GLuint new_width, new_height;
-
-    wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height);
-
-    /**
-     * Resize buffers if the window size changed.
-     */
-    wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height);
-    ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */
-}
-
-
-
-
-/**
- * Called when the driver should update it's state, based on the new_state
- * flags.
- */
-static void wmesa_update_state(struct gl_context *ctx, GLuint new_state)
-{
-    _swrast_InvalidateState(ctx, new_state);
-    _swsetup_InvalidateState(ctx, new_state);
-    _vbo_InvalidateState(ctx, new_state);
-    _tnl_InvalidateState(ctx, new_state);
-
-    /* TODO - This code is not complete yet because I 
-     * don't know what to do for all state updates.
-     */
-
-    if (new_state & _NEW_BUFFERS) {
-    }
-}
-
-
-
-
-
-/**********************************************************************/
-/*****                   WMESA Functions                          *****/
-/**********************************************************************/
-
-WMesaContext WMesaCreateContext(HDC hDC, 
-				HPALETTE* Pal,
-				GLboolean rgb_flag,
-				GLboolean db_flag,
-				GLboolean alpha_flag)
-{
-    WMesaContext c;
-    struct dd_function_table functions;
-    GLint red_bits, green_bits, blue_bits, alpha_bits;
-    struct gl_context *ctx;
-    struct gl_config *visual;
-
-    (void) Pal;
-    
-    /* Indexed mode not supported */
-    if (!rgb_flag)
-	return NULL;
-
-    /* Allocate wmesa context */
-    c = CALLOC_STRUCT(wmesa_context);
-    if (!c)
-	return NULL;
-
-#if 0
-    /* I do not understand this contributed code */
-    /* Support memory and device contexts */
-    if(WindowFromDC(hDC) != NULL) {
-	c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */
-    }
-    else {
-	c->hDC = hDC;
-    }
-#else
-    c->hDC = hDC;
-#endif
-
-    /* Get data for visual */
-    /* Dealing with this is actually a bit of overkill because Mesa will end
-     * up treating all color component size requests less than 8 by using 
-     * a single byte per channel.  In addition, the interface to the span
-     * routines passes colors as an entire byte per channel anyway, so there
-     * is nothing to be saved by telling the visual to be 16 bits if the device
-     * is 16 bits.  That is, Mesa is going to compute colors down to 8 bits per
-     * channel anyway.
-     * But we go through the motions here anyway.
-     */
-    switch (GetDeviceCaps(c->hDC, BITSPIXEL)) {
-    case 16:
-	red_bits = green_bits = blue_bits = 5;
-	alpha_bits = 0;
-	break;
-    default:
-	red_bits = green_bits = blue_bits = 8;
-	alpha_bits = 8;
-	break;
-    }
-    /* Create visual based on flags */
-    visual = _mesa_create_visual(db_flag,    /* db_flag */
-                                 GL_FALSE,   /* stereo */
-                                 red_bits, green_bits, blue_bits, /* color RGB */
-                                 alpha_flag ? alpha_bits : 0, /* color A */
-                                 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */
-                                 8,          /* stencil_bits */
-                                 16,16,16,   /* accum RGB */
-                                 alpha_flag ? 16 : 0, /* accum A */
-                                 1);         /* num samples */
-    
-    if (!visual) {
-	free(c);
-	return NULL;
-    }
-
-    /* Set up driver functions */
-    _mesa_init_driver_functions(&functions);
-    functions.GetString = wmesa_get_string;
-    functions.UpdateState = wmesa_update_state;
-    functions.GetBufferSize = wmesa_get_buffer_size;
-    functions.Flush = wmesa_flush;
-    functions.Clear = clear;
-    functions.ClearColor = clear_color;
-    functions.ResizeBuffers = wmesa_resize_buffers;
-    functions.Viewport = wmesa_viewport;
-
-    /* initialize the Mesa context data */
-    ctx = &c->gl_ctx;
-    _mesa_initialize_context(ctx, API_OPENGL, visual,
-                             NULL, &functions, (void *)c);
-
-    /* visual no longer needed - it was copied by _mesa_initialize_context() */
-    _mesa_destroy_visual(visual);
-
-    _mesa_enable_sw_extensions(ctx);
-    _mesa_enable_1_3_extensions(ctx);
-    _mesa_enable_1_4_extensions(ctx);
-    _mesa_enable_1_5_extensions(ctx);
-    _mesa_enable_2_0_extensions(ctx);
-    _mesa_enable_2_1_extensions(ctx);
-  
-    _mesa_meta_init(ctx);
-
-    /* Initialize the software rasterizer and helper modules. */
-    if (!_swrast_CreateContext(ctx) ||
-        !_vbo_CreateContext(ctx) ||
-        !_tnl_CreateContext(ctx) ||
-	!_swsetup_CreateContext(ctx)) {
-	_mesa_free_context_data(ctx);
-	free(c);
-	return NULL;
-    }
-    _swsetup_Wakeup(ctx);
-    TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
-
-    return c;
-}
-
-
-void WMesaDestroyContext( WMesaContext pwc )
-{
-    struct gl_context *ctx = &pwc->gl_ctx;
-    WMesaFramebuffer pwfb;
-    GET_CURRENT_CONTEXT(cur_ctx);
-
-    if (cur_ctx == ctx) {
-        /* unbind current if deleting current context */
-        WMesaMakeCurrent(NULL, NULL);
-    }
-
-    /* clean up frame buffer resources */
-    pwfb = wmesa_lookup_framebuffer(pwc->hDC);
-    if (pwfb) {
-	if (ctx->Visual.doubleBufferMode == 1)
-	    wmDeleteBackingStore(pwfb);
-	wmesa_free_framebuffer(pwc->hDC);
-    }
-
-    /* Release for device, not memory contexts */
-    if (WindowFromDC(pwc->hDC) != NULL)
-    {
-      ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);
-    }
-    DeleteObject(pwc->clearPen); 
-    DeleteObject(pwc->clearBrush); 
-    
-    _mesa_meta_free(ctx);
-
-    _swsetup_DestroyContext(ctx);
-    _tnl_DestroyContext(ctx);
-    _vbo_DestroyContext(ctx);
-    _swrast_DestroyContext(ctx);
-    
-    _mesa_free_context_data(ctx);
-    free(pwc);
-}
-
-
-/**
- * Create a new color renderbuffer.
- */
-struct gl_renderbuffer *
-wmesa_new_renderbuffer(void)
-{
-    struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer);
-    if (!rb)
-        return NULL;
-
-    _mesa_init_renderbuffer(rb, (GLuint)0);
-    
-    rb->_BaseFormat = GL_RGBA;
-    rb->InternalFormat = GL_RGBA;
-    rb->DataType = CHAN_TYPE;
-    rb->Delete = wmesa_delete_renderbuffer;
-    rb->AllocStorage = wmesa_renderbuffer_storage;
-    return rb;
-}
-
-
-void WMesaMakeCurrent(WMesaContext c, HDC hdc)
-{
-    WMesaFramebuffer pwfb;
-
-    {
-        /* return if already current */
-        GET_CURRENT_CONTEXT(ctx);
-        WMesaContext pwc = wmesa_context(ctx);
-        if (pwc && c == pwc && pwc->hDC == hdc)
-            return;
-    }
-
-    pwfb = wmesa_lookup_framebuffer(hdc);
-
-    /* Lazy creation of framebuffers */
-    if (c && !pwfb && hdc) {
-        struct gl_renderbuffer *rb;
-        struct gl_config *visual = &c->gl_ctx.Visual;
-        GLuint width, height;
-
-        get_window_size(hdc, &width, &height);
-
-	c->clearPen = CreatePen(PS_SOLID, 1, 0); 
-	c->clearBrush = CreateSolidBrush(0); 
-
-        pwfb = wmesa_new_framebuffer(hdc, visual);
-
-	/* Create back buffer if double buffered */
-	if (visual->doubleBufferMode == 1) {
-	    wmCreateBackingStore(pwfb, width, height);
-	}
-	
-        /* make render buffers */
-        if (visual->doubleBufferMode == 1) {
-            rb = wmesa_new_renderbuffer();
-            _mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb);
-            wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 1);
-	}
-        rb = wmesa_new_renderbuffer();
-        _mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb);
-        wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 0);
-
-	/* Let Mesa own the Depth, Stencil, and Accum buffers */
-        _mesa_add_soft_renderbuffers(&pwfb->Base,
-                                     GL_FALSE, /* color */
-                                     visual->depthBits > 0,
-                                     visual->stencilBits > 0,
-                                     visual->accumRedBits > 0,
-                                     visual->alphaBits >0, 
-                                     GL_FALSE);
-    }
-
-    if (c && pwfb)
-	_mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base);
-    else
-        _mesa_make_current(NULL, NULL, NULL);
-}
-
-
-void WMesaSwapBuffers( HDC hdc )
-{
-    GET_CURRENT_CONTEXT(ctx);
-    WMesaContext pwc = wmesa_context(ctx);
-    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);
-
-    if (!pwfb) {
-        _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");
-        return;
-    }
-
-    /* If we're swapping the buffer associated with the current context
-     * we have to flush any pending rendering commands first.
-     */
-    if (pwc->hDC == hdc) {
-	_mesa_notifySwapBuffers(ctx);
-
-	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
-	       pwfb->dib_hDC, 0, 0, SRCCOPY);
-    }
-    else {
-        /* XXX for now only allow swapping current window */
-        _mesa_problem(NULL, "wmesa: can't swap non-current window");
-    }
-}
-
-void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx)
-{
-	_mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);	
-}
-
+/*

+ * Windows (Win32/Win64) device driver for Mesa

+ *

+ */

+

+#include "wmesadef.h"

+#include "colors.h"

+#include <GL/wmesa.h>

+#include <winuser.h>

+#include "context.h"

+#include "extensions.h"

+#include "framebuffer.h"

+#include "renderbuffer.h"

+#include "drivers/common/driverfuncs.h"

+#include "drivers/common/meta.h"

+#include "vbo/vbo.h"

+#include "swrast/swrast.h"

+#include "swrast_setup/swrast_setup.h"

+#include "tnl/tnl.h"

+#include "tnl/t_context.h"

+#include "tnl/t_pipeline.h"

+

+

+/* linked list of our Framebuffers (windows) */

+static WMesaFramebuffer FirstFramebuffer = NULL;

+

+

+/**

+ * Create a new WMesaFramebuffer object which will correspond to the

+ * given HDC (Window handle).

+ */

+WMesaFramebuffer

+wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)

+{

+    WMesaFramebuffer pwfb

+        = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));

+    if (pwfb) {

+        _mesa_initialize_window_framebuffer(&pwfb->Base, visual);

+        pwfb->hDC = hdc;

+        /* insert at head of list */

+        pwfb->next = FirstFramebuffer;

+        FirstFramebuffer = pwfb;

+    }

+    return pwfb;

+}

+

+/**

+ * Given an hdc, free the corresponding WMesaFramebuffer

+ */

+void

+wmesa_free_framebuffer(HDC hdc)

+{

+    WMesaFramebuffer pwfb, prev;

+    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {

+        if (pwfb->hDC == hdc)

+            break;

+	prev = pwfb;

+    }

+    if (pwfb) {

+        struct gl_framebuffer *fb;

+	if (pwfb == FirstFramebuffer)

+	    FirstFramebuffer = pwfb->next;

+	else

+	    prev->next = pwfb->next;

+        fb = &pwfb->Base;

+        _mesa_reference_framebuffer(&fb, NULL); 

+    }

+}

+

+/**

+ * Given an hdc, return the corresponding WMesaFramebuffer

+ */

+WMesaFramebuffer

+wmesa_lookup_framebuffer(HDC hdc)

+{

+    WMesaFramebuffer pwfb;

+    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {

+        if (pwfb->hDC == hdc)

+            return pwfb;

+    }

+    return NULL;

+}

+

+

+/**

+ * Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer.

+ */

+static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb)

+{

+    return (WMesaFramebuffer) fb;

+}

+

+

+/**

+ * Given a struct gl_context, return the corresponding WMesaContext.

+ */

+static WMesaContext wmesa_context(const struct gl_context *ctx)

+{

+    return (WMesaContext) ctx;

+}

+

+

+/*

+ * Every driver should implement a GetString function in order to

+ * return a meaningful GL_RENDERER string.

+ */

+static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name)

+{

+    return (name == GL_RENDERER) ? 

+	(GLubyte *) "Mesa Windows GDI Driver" : NULL;

+}

+

+

+/*

+ * Determine the pixel format based on the pixel size.

+ */

+static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)

+{

+    pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);

+

+    /* Only 16 and 32 bit targets are supported now */

+    assert(pwfb->cColorBits == 0 ||

+	   pwfb->cColorBits == 16 || 

+	   pwfb->cColorBits == 24 || 

+	   pwfb->cColorBits == 32);

+

+    switch(pwfb->cColorBits){

+    case 8:

+	pwfb->pixelformat = PF_INDEX8;

+	break;

+    case 16:

+	pwfb->pixelformat = PF_5R6G5B;

+	break;

+    case 24:

+    case 32:

+	pwfb->pixelformat = PF_8R8G8B;

+	break;

+    default:

+	pwfb->pixelformat = PF_BADFORMAT;

+    }

+}

+

+

+/**

+ * Create DIB for back buffer.

+ * We write into this memory with the span routines and then blit it

+ * to the window on a buffer swap.

+ */

+BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize)

+{

+    HDC          hdc = pwfb->hDC;

+    LPBITMAPINFO pbmi = &(pwfb->bmi);

+    HDC          hic;

+

+    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

+    pbmi->bmiHeader.biWidth = lxSize;

+    pbmi->bmiHeader.biHeight= -lySize;

+    pbmi->bmiHeader.biPlanes = 1;

+    pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL);

+    pbmi->bmiHeader.biCompression = BI_RGB;

+    pbmi->bmiHeader.biSizeImage = 0;

+    pbmi->bmiHeader.biXPelsPerMeter = 0;

+    pbmi->bmiHeader.biYPelsPerMeter = 0;

+    pbmi->bmiHeader.biClrUsed = 0;

+    pbmi->bmiHeader.biClrImportant = 0;

+    

+    pwfb->cColorBits = pbmi->bmiHeader.biBitCount;

+    pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3;

+    

+    hic = CreateIC("display", NULL, NULL, NULL);

+    pwfb->dib_hDC = CreateCompatibleDC(hic);

+    

+    pwfb->hbmDIB = CreateDIBSection(hic,

+				   &pwfb->bmi,

+				   DIB_RGB_COLORS,

+				   (void **)&(pwfb->pbPixels),

+				   0,

+				   0);

+    pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB);

+    

+    DeleteDC(hic);

+

+    wmSetPixelFormat(pwfb, pwfb->hDC);

+    return TRUE;

+}

+

+

+static wmDeleteBackingStore(WMesaFramebuffer pwfb)

+{

+    if (pwfb->hbmDIB) {

+	SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap);

+	DeleteDC(pwfb->dib_hDC);

+	DeleteObject(pwfb->hbmDIB);

+    }

+}

+

+

+/**

+ * Find the width and height of the window named by hdc.

+ */

+static void

+get_window_size(HDC hdc, GLuint *width, GLuint *height)

+{

+    if (WindowFromDC(hdc)) {

+        RECT rect;

+        GetClientRect(WindowFromDC(hdc), &rect);

+        *width = rect.right - rect.left;

+        *height = rect.bottom - rect.top;

+    }

+    else { /* Memory context */

+        /* From contributed code - use the size of the desktop

+         * for the size of a memory context (?) */

+        *width = GetDeviceCaps(hdc, HORZRES);

+        *height = GetDeviceCaps(hdc, VERTRES);

+    }

+}

+

+

+static void

+wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height)

+{

+    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);

+    get_window_size(pwfb->hDC, width, height);

+}

+

+

+static void wmesa_flush(struct gl_context *ctx)

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer);

+

+    if (ctx->Visual.doubleBufferMode == 1) {

+	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,

+	       pwfb->dib_hDC, 0, 0, SRCCOPY);

+    }

+    else {

+	/* Do nothing for single buffer */

+    }

+}

+

+

+/**********************************************************************/

+/*****                   CLEAR Functions                          *****/

+/**********************************************************************/

+

+/* If we do not implement these, Mesa clears the buffers via the pixel

+ * span writing interface, which is very slow for a clear operation.

+ */

+

+/*

+ * Set the color used to clear the color buffer.

+ */

+static void clear_color(struct gl_context *ctx, const GLfloat color[4])

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLubyte col[3];

+    UINT    bytesPerPixel = pwfb->cColorBits / 8; 

+

+    CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);

+    CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);

+    CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);

+    pwc->clearColorRef = RGB(col[0], col[1], col[2]);

+    DeleteObject(pwc->clearPen);

+    DeleteObject(pwc->clearBrush);

+    pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef); 

+    pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef); 

+}

+

+

+/* 

+ * Clear the specified region of the color buffer using the clear color 

+ * or index as specified by one of the two functions above. 

+ * 

+ * This procedure clears either the front and/or the back COLOR buffers. 

+ * Only the "left" buffer is cleared since we are not stereo. 

+ * Clearing of the other non-color buffers is left to the swrast. 

+ */ 

+

+static void clear(struct gl_context *ctx, GLbitfield mask)

+{

+#define FLIP(Y)  (ctx->DrawBuffer->Height - (Y) - 1)

+    const GLint x = ctx->DrawBuffer->_Xmin;

+    const GLint y = ctx->DrawBuffer->_Ymin;

+    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

+    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

+

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    int done = 0;

+

+    /* Let swrast do all the work if the masks are not set to

+     * clear all channels. */

+    if (!ctx->Color.ColorMask[0][0] ||

+	!ctx->Color.ColorMask[0][1] ||

+	!ctx->Color.ColorMask[0][2] ||

+	!ctx->Color.ColorMask[0][3]) {

+	_swrast_Clear(ctx, mask);

+	return;

+    }

+

+    /* Back buffer */

+    if (mask & BUFFER_BIT_BACK_LEFT) { 

+	

+	int     i, rowSize; 

+	UINT    bytesPerPixel = pwfb->cColorBits / 8; 

+	LPBYTE  lpb, clearRow;

+	LPWORD  lpw;

+	BYTE    bColor; 

+	WORD    wColor; 

+	BYTE    r, g, b; 

+	DWORD   dwColor; 

+	LPDWORD lpdw; 

+	

+	/* Try for a fast clear - clearing entire buffer with a single

+	 * byte value. */

+	if (width == ctx->DrawBuffer->Width &&

+            height == ctx->DrawBuffer->Height) { /* entire buffer */

+	    /* Now check for an easy clear value */

+	    switch (bytesPerPixel) {

+	    case 1:

+		bColor = BGR8(GetRValue(pwc->clearColorRef), 

+			      GetGValue(pwc->clearColorRef), 

+			      GetBValue(pwc->clearColorRef));

+		memset(pwfb->pbPixels, bColor, 

+		       pwfb->ScanWidth * height);

+		done = 1;

+		break;

+	    case 2:

+		wColor = BGR16(GetRValue(pwc->clearColorRef), 

+			       GetGValue(pwc->clearColorRef), 

+			       GetBValue(pwc->clearColorRef)); 

+		if (((wColor >> 8) & 0xff) == (wColor & 0xff)) {

+		    memset(pwfb->pbPixels, wColor & 0xff, 

+			   pwfb->ScanWidth * height);

+		    done = 1;

+		}

+		break;

+	    case 3:

+		/* fall through */

+	    case 4:

+		if (GetRValue(pwc->clearColorRef) == 

+		    GetGValue(pwc->clearColorRef) &&

+		    GetRValue(pwc->clearColorRef) == 

+		    GetBValue(pwc->clearColorRef)) {

+		    memset(pwfb->pbPixels, 

+			   GetRValue(pwc->clearColorRef), 

+			   pwfb->ScanWidth * height);

+		    done = 1;

+		}

+		break;

+	    default:

+		break;

+	    }

+	} /* all */

+

+	if (!done) {

+	    /* Need to clear a row at a time.  Begin by setting the first

+	     * row in the area to be cleared to the clear color. */

+	    

+	    clearRow = pwfb->pbPixels + 

+		pwfb->ScanWidth * FLIP(y) +

+		bytesPerPixel * x; 

+	    switch (bytesPerPixel) {

+	    case 1:

+		lpb = clearRow;

+		bColor = BGR8(GetRValue(pwc->clearColorRef), 

+			      GetGValue(pwc->clearColorRef), 

+			      GetBValue(pwc->clearColorRef));

+		memset(lpb, bColor, width);

+		break;

+	    case 2:

+		lpw = (LPWORD)clearRow;

+		wColor = BGR16(GetRValue(pwc->clearColorRef), 

+			       GetGValue(pwc->clearColorRef), 

+			       GetBValue(pwc->clearColorRef)); 

+		for (i=0; i<width; i++)

+		    *lpw++ = wColor;

+		break;

+	    case 3: 

+		lpb = clearRow;

+		r = GetRValue(pwc->clearColorRef); 

+		g = GetGValue(pwc->clearColorRef); 

+		b = GetBValue(pwc->clearColorRef); 

+		for (i=0; i<width; i++) {

+		    *lpb++ = b; 

+		    *lpb++ = g; 

+		    *lpb++ = r; 

+		} 

+		break;

+	    case 4: 

+		lpdw = (LPDWORD)clearRow; 

+		dwColor = BGR32(GetRValue(pwc->clearColorRef), 

+				GetGValue(pwc->clearColorRef), 

+				GetBValue(pwc->clearColorRef)); 

+		for (i=0; i<width; i++)

+		    *lpdw++ = dwColor;

+		break;

+	    default:

+		break;

+	    } /* switch */

+	    

+	    /* copy cleared row to other rows in buffer */

+	    lpb = clearRow - pwfb->ScanWidth;

+	    rowSize = width * bytesPerPixel;

+	    for (i=1; i<height; i++) { 

+		memcpy(lpb, clearRow, rowSize); 

+		lpb -= pwfb->ScanWidth; 

+	    } 

+	} /* not done */

+	mask &= ~BUFFER_BIT_BACK_LEFT;

+    } /* back buffer */ 

+

+    /* front buffer */

+    if (mask & BUFFER_BIT_FRONT_LEFT) { 

+	HDC DC = pwc->hDC; 

+	HPEN Old_Pen = SelectObject(DC, pwc->clearPen); 

+	HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush);

+	Rectangle(DC,

+		  x,

+		  FLIP(y) + 1,

+		  x + width + 1,

+		  FLIP(y) - height + 1);

+	SelectObject(DC, Old_Pen); 

+	SelectObject(DC, Old_Brush); 

+	mask &= ~BUFFER_BIT_FRONT_LEFT;

+    } /* front buffer */ 

+    

+    /* Call swrast if there is anything left to clear (like DEPTH) */ 

+    if (mask) 

+	_swrast_Clear(ctx, mask);

+  

+#undef FLIP

+} 

+

+

+/**********************************************************************/

+/*****                   PIXEL Functions                          *****/

+/**********************************************************************/

+

+#define FLIP(Y)  (rb->Height - (Y) - 1)

+

+

+/**

+ ** Front Buffer reading/writing

+ ** These are slow, but work with all non-indexed visual types.

+ **/

+

+/* Write a horizontal span of RGBA color pixels with a boolean mask. */

+static void write_rgba_span_front(const struct gl_context *ctx, 

+				   struct gl_renderbuffer *rb, 

+				   GLuint n, GLint x, GLint y,

+				   const GLubyte rgba[][4], 

+				   const GLubyte mask[] )

+{

+   WMesaContext pwc = wmesa_context(ctx);

+   WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC);

+   CONST BITMAPINFO bmi=

+   {

+      {

+         sizeof(BITMAPINFOHEADER),

+         n, 1, 1, 32, BI_RGB, 0, 1, 1, 0, 0

+      }

+   };

+   HBITMAP bmp=0;

+   HDC mdc=0;

+   typedef union

+   {

+      unsigned i;

+      struct {

+         unsigned b:8, g:8, r:8, a:8;

+      };

+   } BGRA;

+   BGRA *bgra, c;

+   GLuint i;

+

+   if (n < 16) {   // the value 16 is just guessed

+      y=FLIP(y);

+      if (mask) {

+         for (i=0; i<n; i++)

+            if (mask[i])

+               SetPixel(pwc->hDC, x+i, y,

+                        RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

+      }

+      else {

+         for (i=0; i<n; i++)

+            SetPixel(pwc->hDC, x+i, y,

+                     RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

+      }

+   }

+   else {

+      if (!pwfb) {

+         _mesa_problem(NULL, "wmesa: write_rgba_span_front on unknown hdc");

+         return;

+      }

+      bgra=malloc(n*sizeof(BGRA));

+      if (!bgra) {

+         _mesa_problem(NULL, "wmesa: write_rgba_span_front: out of memory");

+         return;

+      }

+      c.a=0;

+      if (mask) {

+         for (i=0; i<n; i++) {

+            if (mask[i]) {

+               c.r=rgba[i][RCOMP];

+               c.g=rgba[i][GCOMP];

+               c.b=rgba[i][BCOMP];

+               c.a=rgba[i][ACOMP];

+               bgra[i]=c;

+            }

+            else

+               bgra[i].i=0;

+         }

+      }

+      else {

+         for (i=0; i<n; i++) {

+            c.r=rgba[i][RCOMP];

+            c.g=rgba[i][GCOMP];

+            c.b=rgba[i][BCOMP];

+            c.a=rgba[i][ACOMP];

+            bgra[i]=c;

+         }

+      }

+      bmp=CreateBitmap(n, 1,  1, 32, bgra);

+      mdc=CreateCompatibleDC(pwfb->hDC);

+      SelectObject(mdc, bmp);

+      y=FLIP(y);

+      BitBlt(pwfb->hDC, x, y, n, 1, mdc, 0, 0, SRCCOPY);

+      SelectObject(mdc, 0);

+      DeleteObject(bmp);

+      DeleteDC(mdc);

+      free(bgra);

+   }

+}

+

+/* Write a horizontal span of RGB color pixels with a boolean mask. */

+static void write_rgb_span_front(const struct gl_context *ctx, 

+				  struct gl_renderbuffer *rb, 

+				  GLuint n, GLint x, GLint y,

+				  const GLubyte rgb[][3], 

+				  const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    GLuint i;

+    

+    (void) ctx;

+    y=FLIP(y);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+		SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 

+					       rgb[i][BCOMP]));

+    }

+    else {

+	for (i=0; i<n; i++)

+	    SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 

+					   rgb[i][BCOMP]));

+    }

+    

+}

+

+/*

+ * Write a horizontal span of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_span_front(const struct gl_context *ctx, 

+					struct gl_renderbuffer *rb,

+					GLuint n, GLint x, GLint y,

+					const GLchan color[4], 

+					const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    COLORREF colorref;

+

+    (void) ctx;

+    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);

+    y=FLIP(y);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+		SetPixel(pwc->hDC, x+i, y, colorref);

+    }

+    else

+	for (i=0; i<n; i++)

+	    SetPixel(pwc->hDC, x+i, y, colorref);

+

+}

+

+/* Write an array of RGBA pixels with a boolean mask. */

+static void write_rgba_pixels_front(const struct gl_context *ctx, 

+				     struct gl_renderbuffer *rb,

+				     GLuint n, 

+				     const GLint x[], const GLint y[],

+				     const GLubyte rgba[][4], 

+				     const GLubyte mask[] )

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    (void) ctx;

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), 

+		     RGB(rgba[i][RCOMP], rgba[i][GCOMP], 

+			 rgba[i][BCOMP]));

+}

+

+

+

+/*

+ * Write an array of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_pixels_front(const struct gl_context *ctx, 

+					  struct gl_renderbuffer *rb,

+					  GLuint n,

+					  const GLint x[], const GLint y[],

+					  const GLchan color[4],

+					  const GLubyte mask[] )

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    COLORREF colorref;

+    (void) ctx;

+    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), colorref);

+}

+

+/* Read a horizontal span of color pixels. */

+static void read_rgba_span_front(const struct gl_context *ctx, 

+				  struct gl_renderbuffer *rb,

+				  GLuint n, GLint x, GLint y,

+				  GLubyte rgba[][4] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    GLuint i;

+    COLORREF Color;

+    y = FLIP(y);

+    for (i=0; i<n; i++) {

+	Color = GetPixel(pwc->hDC, x+i, y);

+	rgba[i][RCOMP] = GetRValue(Color);

+	rgba[i][GCOMP] = GetGValue(Color);

+	rgba[i][BCOMP] = GetBValue(Color);

+	rgba[i][ACOMP] = 255;

+    }

+}

+

+

+/* Read an array of color pixels. */

+static void read_rgba_pixels_front(const struct gl_context *ctx, 

+				    struct gl_renderbuffer *rb,

+				    GLuint n, const GLint x[], const GLint y[],

+				    GLubyte rgba[][4])

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    GLuint i;

+    COLORREF Color;

+    for (i=0; i<n; i++) {

+        GLint y2 = FLIP(y[i]);

+        Color = GetPixel(pwc->hDC, x[i], y2);

+        rgba[i][RCOMP] = GetRValue(Color);

+        rgba[i][GCOMP] = GetGValue(Color);

+        rgba[i][BCOMP] = GetBValue(Color);

+        rgba[i][ACOMP] = 255;

+    }

+}

+

+/*********************************************************************/

+

+/* DOUBLE BUFFER 32-bit */

+

+#define WMSETPIXEL32(pwc, y, x, r, g, b) { \

+LPDWORD lpdw = ((LPDWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \

+*lpdw = BGR32((r),(g),(b)); }

+

+

+

+/* Write a horizontal span of RGBA color pixels with a boolean mask. */

+static void write_rgba_span_32(const struct gl_context *ctx, 

+			       struct gl_renderbuffer *rb, 

+			       GLuint n, GLint x, GLint y,

+			       const GLubyte rgba[][4], 

+			       const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPDWORD lpdw;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpdw[i] = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 

+				rgba[i][BCOMP]);

+    }

+    else {

+	for (i=0; i<n; i++)

+                *lpdw++ = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 

+				rgba[i][BCOMP]);

+    }

+}

+

+

+/* Write a horizontal span of RGB color pixels with a boolean mask. */

+static void write_rgb_span_32(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb, 

+			      GLuint n, GLint x, GLint y,

+			      const GLubyte rgb[][3], 

+			      const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPDWORD lpdw;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpdw[i] = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 

+				rgb[i][BCOMP]);

+    }

+    else {

+	for (i=0; i<n; i++)

+                *lpdw++ = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 

+				rgb[i][BCOMP]);

+    }

+}

+

+/*

+ * Write a horizontal span of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_span_32(const struct gl_context *ctx, 

+				    struct gl_renderbuffer *rb,

+				    GLuint n, GLint x, GLint y,

+				    const GLchan color[4], 

+				    const GLubyte mask[])

+{

+    LPDWORD lpdw;

+    DWORD pixel;

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    y=FLIP(y);

+    pixel = BGR32(color[RCOMP], color[GCOMP], color[BCOMP]);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpdw[i] = pixel;

+    }

+    else

+	for (i=0; i<n; i++)

+                *lpdw++ = pixel;

+

+}

+

+/* Write an array of RGBA pixels with a boolean mask. */

+static void write_rgba_pixels_32(const struct gl_context *ctx, 

+				 struct gl_renderbuffer *rb,

+				 GLuint n, const GLint x[], const GLint y[],

+				 const GLubyte rgba[][4], 

+				 const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL32(pwfb, FLIP(y[i]), x[i],

+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

+}

+

+/*

+ * Write an array of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_pixels_32(const struct gl_context *ctx, 

+				      struct gl_renderbuffer *rb,

+				      GLuint n,

+				      const GLint x[], const GLint y[],

+				      const GLchan color[4],

+				      const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL32(pwfb, FLIP(y[i]),x[i],color[RCOMP],

+			 color[GCOMP], color[BCOMP]);

+}

+

+/* Read a horizontal span of color pixels. */

+static void read_rgba_span_32(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb,

+			      GLuint n, GLint x, GLint y,

+			      GLubyte rgba[][4] )

+{

+    GLuint i;

+    DWORD pixel;

+    LPDWORD lpdw;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    

+    y = FLIP(y);

+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    for (i=0; i<n; i++) {

+	pixel = lpdw[i];

+	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);

+	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);

+	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);

+	rgba[i][ACOMP] = 255;

+    }

+}

+

+

+/* Read an array of color pixels. */

+static void read_rgba_pixels_32(const struct gl_context *ctx, 

+				struct gl_renderbuffer *rb,

+				GLuint n, const GLint x[], const GLint y[],

+				GLubyte rgba[][4])

+{

+    GLuint i;

+    DWORD pixel;

+    LPDWORD lpdw;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+

+    for (i=0; i<n; i++) {

+	GLint y2 = FLIP(y[i]);

+	lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];

+	pixel = *lpdw;

+	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);

+	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);

+	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);

+	rgba[i][ACOMP] = 255;

+  }

+}

+

+

+/*********************************************************************/

+

+/* DOUBLE BUFFER 24-bit */

+

+#define WMSETPIXEL24(pwc, y, x, r, g, b) { \

+LPBYTE lpb = ((LPBYTE)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (3 * x)); \

+lpb[0] = (b); \

+lpb[1] = (g); \

+lpb[2] = (r); }

+

+/* Write a horizontal span of RGBA color pixels with a boolean mask. */

+static void write_rgba_span_24(const struct gl_context *ctx, 

+			       struct gl_renderbuffer *rb, 

+			       GLuint n, GLint x, GLint y,

+			       const GLubyte rgba[][4], 

+			       const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPBYTE lpb;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i]) {

+                lpb[3*i] = rgba[i][BCOMP];

+                lpb[3*i+1] = rgba[i][GCOMP];

+                lpb[3*i+2] = rgba[i][RCOMP];

+	    }

+    }

+    else {

+	    for (i=0; i<n; i++) {

+            *lpb++ = rgba[i][BCOMP];

+            *lpb++ = rgba[i][GCOMP];

+            *lpb++ = rgba[i][RCOMP];

+	    }

+    }

+}

+

+

+/* Write a horizontal span of RGB color pixels with a boolean mask. */

+static void write_rgb_span_24(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb, 

+			      GLuint n, GLint x, GLint y,

+			      const GLubyte rgb[][3], 

+			      const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPBYTE lpb;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i]) {

+            lpb[3*i] = rgb[i][BCOMP];

+            lpb[3*i+1] = rgb[i][GCOMP];

+            lpb[3*i+2] = rgb[i][RCOMP];

+	    }

+    }

+    else {

+    	for (i=0; i<n; i++) {

+    		*lpb++ = rgb[i][BCOMP];

+    		*lpb++ = rgb[i][GCOMP];

+    		*lpb++ = rgb[i][RCOMP];

+    	}

+    }

+}

+

+/*

+ * Write a horizontal span of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_span_24(const struct gl_context *ctx, 

+				    struct gl_renderbuffer *rb,

+				    GLuint n, GLint x, GLint y,

+				    const GLchan color[4], 

+				    const GLubyte mask[])

+{

+    LPBYTE lpb;

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

+    y=FLIP(y);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i]) {

+	    	lpb[3*i] = color[BCOMP];

+	    	lpb[3*i+1] = color[GCOMP];

+	    	lpb[3*i+2] = color[RCOMP];

+	    }

+    }

+    else

+	for (i=0; i<n; i++) {

+		*lpb++ = color[BCOMP];

+		*lpb++ = color[GCOMP];

+		*lpb++ = color[RCOMP];		

+	}

+}

+

+/* Write an array of RGBA pixels with a boolean mask. */

+static void write_rgba_pixels_24(const struct gl_context *ctx, 

+				 struct gl_renderbuffer *rb,

+				 GLuint n, const GLint x[], const GLint y[],

+				 const GLubyte rgba[][4], 

+				 const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL24(pwfb, FLIP(y[i]), x[i],

+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

+}

+

+/*

+ * Write an array of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_pixels_24(const struct gl_context *ctx, 

+				      struct gl_renderbuffer *rb,

+				      GLuint n,

+				      const GLint x[], const GLint y[],

+				      const GLchan color[4],

+				      const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL24(pwfb, FLIP(y[i]),x[i],color[RCOMP],

+			 color[GCOMP], color[BCOMP]);

+}

+

+/* Read a horizontal span of color pixels. */

+static void read_rgba_span_24(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb,

+			      GLuint n, GLint x, GLint y,

+			      GLubyte rgba[][4] )

+{

+    GLuint i;

+    LPBYTE lpb;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    

+    y = FLIP(y);

+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

+    for (i=0; i<n; i++) {

+	rgba[i][RCOMP] = lpb[3*i+2];

+	rgba[i][GCOMP] = lpb[3*i+1];

+	rgba[i][BCOMP] = lpb[3*i];

+	rgba[i][ACOMP] = 255;

+    }

+}

+

+

+/* Read an array of color pixels. */

+static void read_rgba_pixels_24(const struct gl_context *ctx, 

+				struct gl_renderbuffer *rb,

+				GLuint n, const GLint x[], const GLint y[],

+				GLubyte rgba[][4])

+{

+    GLuint i;

+    LPBYTE lpb;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+

+    for (i=0; i<n; i++) {

+	GLint y2 = FLIP(y[i]);

+	lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + (3 * x[i]);

+	rgba[i][RCOMP] = lpb[3*i+2];

+	rgba[i][GCOMP] = lpb[3*i+1];

+	rgba[i][BCOMP] = lpb[3*i];

+	rgba[i][ACOMP] = 255;

+  }

+}

+

+

+/*********************************************************************/

+

+/* DOUBLE BUFFER 16-bit */

+

+#define WMSETPIXEL16(pwc, y, x, r, g, b) { \

+LPWORD lpw = ((LPWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \

+*lpw = BGR16((r),(g),(b)); }

+

+

+

+/* Write a horizontal span of RGBA color pixels with a boolean mask. */

+static void write_rgba_span_16(const struct gl_context *ctx, 

+			       struct gl_renderbuffer *rb, 

+			       GLuint n, GLint x, GLint y,

+			       const GLubyte rgba[][4], 

+			       const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPWORD lpw;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpw[i] = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 

+			       rgba[i][BCOMP]);

+    }

+    else {

+	for (i=0; i<n; i++)

+                *lpw++ = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 

+			       rgba[i][BCOMP]);

+    }

+}

+

+

+/* Write a horizontal span of RGB color pixels with a boolean mask. */

+static void write_rgb_span_16(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb, 

+			      GLuint n, GLint x, GLint y,

+			      const GLubyte rgb[][3], 

+			      const GLubyte mask[] )

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    GLuint i;

+    LPWORD lpw;

+

+    (void) ctx;

+    

+    y=FLIP(y);

+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpw[i] = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 

+			       rgb[i][BCOMP]);

+    }

+    else {

+	for (i=0; i<n; i++)

+                *lpw++ = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 

+			       rgb[i][BCOMP]);

+    }

+}

+

+/*

+ * Write a horizontal span of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_span_16(const struct gl_context *ctx, 

+				    struct gl_renderbuffer *rb,

+				    GLuint n, GLint x, GLint y,

+				    const GLchan color[4], 

+				    const GLubyte mask[])

+{

+    LPWORD lpw;

+    WORD pixel;

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    (void) ctx;

+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    y=FLIP(y);

+    pixel = BGR16(color[RCOMP], color[GCOMP], color[BCOMP]);

+    if (mask) {

+	for (i=0; i<n; i++)

+	    if (mask[i])

+                lpw[i] = pixel;

+    }

+    else

+	for (i=0; i<n; i++)

+                *lpw++ = pixel;

+

+}

+

+/* Write an array of RGBA pixels with a boolean mask. */

+static void write_rgba_pixels_16(const struct gl_context *ctx, 

+				 struct gl_renderbuffer *rb,

+				 GLuint n, const GLint x[], const GLint y[],

+				 const GLubyte rgba[][4], 

+				 const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    (void) ctx;

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL16(pwfb, FLIP(y[i]), x[i],

+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

+}

+

+/*

+ * Write an array of pixels with a boolean mask.  The current color

+ * is used for all pixels.

+ */

+static void write_mono_rgba_pixels_16(const struct gl_context *ctx, 

+				      struct gl_renderbuffer *rb,

+				      GLuint n,

+				      const GLint x[], const GLint y[],

+				      const GLchan color[4],

+				      const GLubyte mask[])

+{

+    GLuint i;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    (void) ctx;

+    for (i=0; i<n; i++)

+	if (mask[i])

+	    WMSETPIXEL16(pwfb, FLIP(y[i]),x[i],color[RCOMP],

+			 color[GCOMP], color[BCOMP]);

+}

+

+/* Read a horizontal span of color pixels. */

+static void read_rgba_span_16(const struct gl_context *ctx, 

+			      struct gl_renderbuffer *rb,

+			      GLuint n, GLint x, GLint y,

+			      GLubyte rgba[][4] )

+{

+    GLuint i, pixel;

+    LPWORD lpw;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+    

+    y = FLIP(y);

+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

+    for (i=0; i<n; i++) {

+	pixel = lpw[i];

+	/* Windows uses 5,5,5 for 16-bit */

+	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;

+	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;

+	rgba[i][BCOMP] = (pixel & 0x001f) << 3;

+	rgba[i][ACOMP] = 255;

+    }

+}

+

+

+/* Read an array of color pixels. */

+static void read_rgba_pixels_16(const struct gl_context *ctx, 

+				struct gl_renderbuffer *rb,

+				GLuint n, const GLint x[], const GLint y[],

+				GLubyte rgba[][4])

+{

+    GLuint i, pixel;

+    LPWORD lpw;

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

+

+    for (i=0; i<n; i++) {

+	GLint y2 = FLIP(y[i]);

+	lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];

+	pixel = *lpw;

+	/* Windows uses 5,5,5 for 16-bit */

+	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;

+	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;

+	rgba[i][BCOMP] = (pixel & 0x001f) << 3;

+	rgba[i][ACOMP] = 255;

+  }

+}

+

+

+

+

+/**********************************************************************/

+/*****                   BUFFER Functions                         *****/

+/**********************************************************************/

+

+

+

+

+static void

+wmesa_delete_renderbuffer(struct gl_renderbuffer *rb)

+{

+    free(rb);

+}

+

+

+/**

+ * This is called by Mesa whenever it determines that the window size

+ * has changed.  Do whatever's needed to cope with that.

+ */

+static GLboolean

+wmesa_renderbuffer_storage(struct gl_context *ctx, 

+			   struct gl_renderbuffer *rb,

+			   GLenum internalFormat, 

+			   GLuint width, 

+			   GLuint height)

+{

+    rb->Width = width;

+    rb->Height = height;

+    return GL_TRUE;

+}

+

+

+/**

+ * Plug in the Get/PutRow/Values functions for a renderbuffer depending

+ * on if we're drawing to the front or back color buffer.

+ */

+void wmesa_set_renderbuffer_funcs(struct gl_renderbuffer *rb, int pixelformat,

+                                  int cColorBits, int double_buffer)

+{

+    if (double_buffer) {

+        /* back buffer */

+	/* Picking the correct span functions is important because

+	 * the DIB was allocated with the indicated depth. */

+	switch(pixelformat) {

+	case PF_5R6G5B:

+	    rb->PutRow = write_rgba_span_16;

+	    rb->PutRowRGB = write_rgb_span_16;

+	    rb->PutMonoRow = write_mono_rgba_span_16;

+	    rb->PutValues = write_rgba_pixels_16;

+	    rb->PutMonoValues = write_mono_rgba_pixels_16;

+	    rb->GetRow = read_rgba_span_16;

+	    rb->GetValues = read_rgba_pixels_16;

+	    break;

+	case PF_8R8G8B:

+		if (cColorBits == 24)

+		{

+		    rb->PutRow = write_rgba_span_24;

+		    rb->PutRowRGB = write_rgb_span_24;

+		    rb->PutMonoRow = write_mono_rgba_span_24;

+		    rb->PutValues = write_rgba_pixels_24;

+		    rb->PutMonoValues = write_mono_rgba_pixels_24;

+		    rb->GetRow = read_rgba_span_24;

+		    rb->GetValues = read_rgba_pixels_24;

+		}

+		else

+		{

+	        rb->PutRow = write_rgba_span_32;

+	        rb->PutRowRGB = write_rgb_span_32;

+	        rb->PutMonoRow = write_mono_rgba_span_32;

+	        rb->PutValues = write_rgba_pixels_32;

+	        rb->PutMonoValues = write_mono_rgba_pixels_32;

+	        rb->GetRow = read_rgba_span_32;

+	        rb->GetValues = read_rgba_pixels_32;

+		}

+	    break;

+	default:

+	    break;

+	}

+    }

+    else {

+        /* front buffer (actual Windows window) */

+	rb->PutRow = write_rgba_span_front;

+	rb->PutRowRGB = write_rgb_span_front;

+	rb->PutMonoRow = write_mono_rgba_span_front;

+	rb->PutValues = write_rgba_pixels_front;

+	rb->PutMonoValues = write_mono_rgba_pixels_front;

+	rb->GetRow = read_rgba_span_front;

+	rb->GetValues = read_rgba_pixels_front;

+    }

+}

+

+/**

+ * Called by ctx->Driver.ResizeBuffers()

+ * Resize the front/back colorbuffers to match the latest window size.

+ */

+static void

+wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer,

+                     GLuint width, GLuint height)

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);

+

+    if (pwfb->Base.Width != width || pwfb->Base.Height != height) {

+	/* Realloc back buffer */

+	if (ctx->Visual.doubleBufferMode == 1) {

+	    wmDeleteBackingStore(pwfb);

+	    wmCreateBackingStore(pwfb, width, height);

+	}

+    }

+    _mesa_resize_framebuffer(ctx, buffer, width, height);

+}

+

+

+/**

+ * Called by glViewport.

+ * This is a good time for us to poll the current window size and adjust

+ * our renderbuffers to match the current window size.

+ * Remember, we have no opportunity to respond to conventional

+ * resize events since the driver has no event loop.

+ * Thus, we poll.

+ * MakeCurrent also ends up making a call here, so that ensures

+ * we get the viewport set correctly, even if the app does not call

+ * glViewport and relies on the defaults.

+ */

+static void wmesa_viewport(struct gl_context *ctx, 

+			   GLint x, GLint y, 

+			   GLsizei width, GLsizei height)

+{

+    WMesaContext pwc = wmesa_context(ctx);

+    GLuint new_width, new_height;

+

+    wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height);

+

+    /**

+     * Resize buffers if the window size changed.

+     */

+    wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height);

+    ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */

+}

+

+

+

+

+/**

+ * Called when the driver should update it's state, based on the new_state

+ * flags.

+ */

+static void wmesa_update_state(struct gl_context *ctx, GLuint new_state)

+{

+    _swrast_InvalidateState(ctx, new_state);

+    _swsetup_InvalidateState(ctx, new_state);

+    _vbo_InvalidateState(ctx, new_state);

+    _tnl_InvalidateState(ctx, new_state);

+

+    /* TODO - This code is not complete yet because I 

+     * don't know what to do for all state updates.

+     */

+

+    if (new_state & _NEW_BUFFERS) {

+    }

+}

+

+

+

+

+

+/**********************************************************************/

+/*****                   WMESA Functions                          *****/

+/**********************************************************************/

+

+WMesaContext WMesaCreateContext(HDC hDC, 

+				HPALETTE* Pal,

+				GLboolean rgb_flag,

+				GLboolean db_flag,

+				GLboolean alpha_flag)

+{

+    WMesaContext c;

+    struct dd_function_table functions;

+    GLint red_bits, green_bits, blue_bits, alpha_bits;

+    struct gl_context *ctx;

+    struct gl_config *visual;

+

+    (void) Pal;

+    

+    /* Indexed mode not supported */

+    if (!rgb_flag)

+	return NULL;

+

+    /* Allocate wmesa context */

+    c = CALLOC_STRUCT(wmesa_context);

+    if (!c)

+	return NULL;

+

+#if 0

+    /* I do not understand this contributed code */

+    /* Support memory and device contexts */

+    if(WindowFromDC(hDC) != NULL) {

+	c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */

+    }

+    else {

+	c->hDC = hDC;

+    }

+#else

+    c->hDC = hDC;

+#endif

+

+    /* Get data for visual */

+    /* Dealing with this is actually a bit of overkill because Mesa will end

+     * up treating all color component size requests less than 8 by using 

+     * a single byte per channel.  In addition, the interface to the span

+     * routines passes colors as an entire byte per channel anyway, so there

+     * is nothing to be saved by telling the visual to be 16 bits if the device

+     * is 16 bits.  That is, Mesa is going to compute colors down to 8 bits per

+     * channel anyway.

+     * But we go through the motions here anyway.

+     */

+    switch (GetDeviceCaps(c->hDC, BITSPIXEL)) {

+    case 16:

+	red_bits = green_bits = blue_bits = 5;

+	alpha_bits = 0;

+	break;

+    default:

+	red_bits = green_bits = blue_bits = 8;

+	alpha_bits = 8;

+	break;

+    }

+    /* Create visual based on flags */

+    visual = _mesa_create_visual(db_flag,    /* db_flag */

+                                 GL_FALSE,   /* stereo */

+                                 red_bits, green_bits, blue_bits, /* color RGB */

+                                 alpha_flag ? alpha_bits : 0, /* color A */

+                                 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */

+                                 8,          /* stencil_bits */

+                                 16,16,16,   /* accum RGB */

+                                 alpha_flag ? 16 : 0, /* accum A */

+                                 1);         /* num samples */

+    

+    if (!visual) {

+	free(c);

+	return NULL;

+    }

+

+    /* Set up driver functions */

+    _mesa_init_driver_functions(&functions);

+    functions.GetString = wmesa_get_string;

+    functions.UpdateState = wmesa_update_state;

+    functions.GetBufferSize = wmesa_get_buffer_size;

+    functions.Flush = wmesa_flush;

+    functions.Clear = clear;

+    functions.ClearColor = clear_color;

+    functions.ResizeBuffers = wmesa_resize_buffers;

+    functions.Viewport = wmesa_viewport;

+

+    /* initialize the Mesa context data */

+    ctx = &c->gl_ctx;

+    _mesa_initialize_context(ctx, API_OPENGL, visual,

+                             NULL, &functions, (void *)c);

+

+    /* visual no longer needed - it was copied by _mesa_initialize_context() */

+    _mesa_destroy_visual(visual);

+

+    _mesa_enable_sw_extensions(ctx);

+    _mesa_enable_1_3_extensions(ctx);

+    _mesa_enable_1_4_extensions(ctx);

+    _mesa_enable_1_5_extensions(ctx);

+    _mesa_enable_2_0_extensions(ctx);

+    _mesa_enable_2_1_extensions(ctx);

+  

+    _mesa_meta_init(ctx);

+

+    /* Initialize the software rasterizer and helper modules. */

+    if (!_swrast_CreateContext(ctx) ||

+        !_vbo_CreateContext(ctx) ||

+        !_tnl_CreateContext(ctx) ||

+	!_swsetup_CreateContext(ctx)) {

+	_mesa_free_context_data(ctx);

+	free(c);

+	return NULL;

+    }

+    _swsetup_Wakeup(ctx);

+    TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;

+

+    return c;

+}

+

+

+void WMesaDestroyContext( WMesaContext pwc )

+{

+    struct gl_context *ctx = &pwc->gl_ctx;

+    WMesaFramebuffer pwfb;

+    GET_CURRENT_CONTEXT(cur_ctx);

+

+    if (cur_ctx == ctx) {

+        /* unbind current if deleting current context */

+        WMesaMakeCurrent(NULL, NULL);

+    }

+

+    /* clean up frame buffer resources */

+    pwfb = wmesa_lookup_framebuffer(pwc->hDC);

+    if (pwfb) {

+	if (ctx->Visual.doubleBufferMode == 1)

+	    wmDeleteBackingStore(pwfb);

+	wmesa_free_framebuffer(pwc->hDC);

+    }

+

+    /* Release for device, not memory contexts */

+    if (WindowFromDC(pwc->hDC) != NULL)

+    {

+      ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);

+    }

+    DeleteObject(pwc->clearPen); 

+    DeleteObject(pwc->clearBrush); 

+    

+    _mesa_meta_free(ctx);

+

+    _swsetup_DestroyContext(ctx);

+    _tnl_DestroyContext(ctx);

+    _vbo_DestroyContext(ctx);

+    _swrast_DestroyContext(ctx);

+    

+    _mesa_free_context_data(ctx);

+    free(pwc);

+}

+

+

+/**

+ * Create a new color renderbuffer.

+ */

+struct gl_renderbuffer *

+wmesa_new_renderbuffer(void)

+{

+    struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer);

+    if (!rb)

+        return NULL;

+

+    _mesa_init_renderbuffer(rb, (GLuint)0);

+    

+    rb->_BaseFormat = GL_RGBA;

+    rb->InternalFormat = GL_RGBA;

+    rb->DataType = CHAN_TYPE;

+    rb->Delete = wmesa_delete_renderbuffer;

+    rb->AllocStorage = wmesa_renderbuffer_storage;

+    return rb;

+}

+

+

+void WMesaMakeCurrent(WMesaContext c, HDC hdc)

+{

+    WMesaFramebuffer pwfb;

+

+    {

+        /* return if already current */

+        GET_CURRENT_CONTEXT(ctx);

+        WMesaContext pwc = wmesa_context(ctx);

+        if (pwc && c == pwc && pwc->hDC == hdc)

+            return;

+    }

+

+    pwfb = wmesa_lookup_framebuffer(hdc);

+

+    /* Lazy creation of framebuffers */

+    if (c && !pwfb && hdc) {

+        struct gl_renderbuffer *rb;

+        struct gl_config *visual = &c->gl_ctx.Visual;

+        GLuint width, height;

+

+        get_window_size(hdc, &width, &height);

+

+	c->clearPen = CreatePen(PS_SOLID, 1, 0); 

+	c->clearBrush = CreateSolidBrush(0); 

+

+        pwfb = wmesa_new_framebuffer(hdc, visual);

+

+	/* Create back buffer if double buffered */

+	if (visual->doubleBufferMode == 1) {

+	    wmCreateBackingStore(pwfb, width, height);

+	}

+	

+        /* make render buffers */

+        if (visual->doubleBufferMode == 1) {

+            rb = wmesa_new_renderbuffer();

+            _mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb);

+            wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 1);

+	}

+        rb = wmesa_new_renderbuffer();

+        _mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb);

+        wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 0);

+

+	/* Let Mesa own the Depth, Stencil, and Accum buffers */

+        _mesa_add_soft_renderbuffers(&pwfb->Base,

+                                     GL_FALSE, /* color */

+                                     visual->depthBits > 0,

+                                     visual->stencilBits > 0,

+                                     visual->accumRedBits > 0,

+                                     visual->alphaBits >0, 

+                                     GL_FALSE);

+    }

+

+    if (c && pwfb)

+	_mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base);

+    else

+        _mesa_make_current(NULL, NULL, NULL);

+}

+

+

+void WMesaSwapBuffers( HDC hdc )

+{

+    GET_CURRENT_CONTEXT(ctx);

+    WMesaContext pwc = wmesa_context(ctx);

+    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);

+

+    if (!pwfb) {

+        _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");

+        return;

+    }

+

+    /* If we're swapping the buffer associated with the current context

+     * we have to flush any pending rendering commands first.

+     */

+    if (pwc->hDC == hdc) {

+	_mesa_notifySwapBuffers(ctx);

+

+	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,

+	       pwfb->dib_hDC, 0, 0, SRCCOPY);

+    }

+    else {

+        /* XXX for now only allow swapping current window */

+        _mesa_problem(NULL, "wmesa: can't swap non-current window");

+    }

+}

+

+void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx)

+{

+	_mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);	

+}

+

diff --git a/mesalib/src/mesa/drivers/windows/gldirect/dglcontext.c b/mesalib/src/mesa/drivers/windows/gldirect/dglcontext.c
index 9aedd2e3c..bc4839cfe 100644
--- a/mesalib/src/mesa/drivers/windows/gldirect/dglcontext.c
+++ b/mesalib/src/mesa/drivers/windows/gldirect/dglcontext.c
@@ -1,2212 +1,2212 @@
-/****************************************************************************
-*
-*                        Mesa 3-D graphics library
-*                        Direct3D Driver Interface
-*
-*  ========================================================================
-*
-*   Copyright (C) 1991-2004 SciTech Software, Inc. 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, sublicense,
-*   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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
-*   SCITECH SOFTWARE INC 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.
-*
-*  ======================================================================
-*
-* Language:     ANSI C
-* Environment:  Windows 9x (Win32)
-*
-* Description:  Context handling.
-*
-****************************************************************************/
-
-#include "dglcontext.h"
-
-// Get compile errors without this. KeithH
-//#include "scitech.h"	// ibool, etc.
-
-#ifdef _USE_GLD3_WGL
-#include "gld_driver.h"
-
-extern void _gld_mesa_warning(struct gl_context *, char *);
-extern void _gld_mesa_fatal(struct gl_context *, char *);
-#endif // _USE_GLD3_WGL
-
-// TODO: Clean out old DX6-specific code from GLD 2.x CAD driver
-// if it is no longer being built as part of GLDirect. (DaveM)
-
-// ***********************************************************************
-
-#define GLDERR_NONE     0
-#define GLDERR_MEM      1
-#define GLDERR_DDRAW    2
-#define GLDERR_D3D      3
-#define GLDERR_BPP      4
-
-char szResourceWarning[] =
-"GLDirect does not have enough video memory resources\n"
-"to support the requested OpenGL rendering context.\n\n"
-"You may have to reduce the current display resolution\n"
-"to obtain satisfactory OpenGL performance.\n";
-
-char szDDrawWarning[] =
-"GLDirect is unable to initialize DirectDraw for the\n"
-"requested OpenGL rendering context.\n\n"
-"You will have to check the DirectX control panel\n"
-"for further information.\n";
-
-char szD3DWarning[] =
-"GLDirect is unable to initialize Direct3D for the\n"
-"requested OpenGL rendering context.\n\n"
-"You may have to change the display mode resolution\n"
-"color depth or check the DirectX control panel for\n"
-"further information.\n";
-
-char szBPPWarning[] =
-"GLDirect is unable to use the selected color depth for\n"
-"the requested OpenGL rendering context.\n\n"
-"You will have to change the display mode resolution\n"
-"color depth with the Display Settings control panel.\n";
-
-int nContextError = GLDERR_NONE;
-
-// ***********************************************************************
-
-#define VENDORID_ATI 0x1002
-
-static DWORD devATIRagePro[] = {
-	0x4742, // 3D RAGE PRO BGA AGP 1X/2X
-	0x4744, // 3D RAGE PRO BGA AGP 1X only
-	0x4749, // 3D RAGE PRO BGA PCI 33 MHz
-	0x4750, // 3D RAGE PRO PQFP PCI 33 MHz
-	0x4751, // 3D RAGE PRO PQFP PCI 33 MHz limited 3D
-	0x4C42, // 3D RAGE LT PRO BGA-312 AGP 133 MHz
-	0x4C44, // 3D RAGE LT PRO BGA-312 AGP 66 MHz
-	0x4C49, // 3D RAGE LT PRO BGA-312 PCI 33 MHz
-	0x4C50, // 3D RAGE LT PRO BGA-256 PCI 33 MHz
-	0x4C51, // 3D RAGE LT PRO BGA-256 PCI 33 MHz limited 3D
-};
-
-static DWORD devATIRageIIplus[] = {
-	0x4755, // 3D RAGE II+
-	0x4756, // 3D RAGE IIC PQFP PCI
-	0x4757, // 3D RAGE IIC BGA AGP
-	0x475A, // 3D RAGE IIC PQFP AGP
-	0x4C47, // 3D RAGE LT-G
-};
-
-// ***********************************************************************
-
-#ifndef _USE_GLD3_WGL
-extern DGL_mesaFuncs mesaFuncs;
-#endif
-
-extern DWORD dwLogging;
-
-#ifdef GLD_THREADS
-#pragma message("compiling DGLCONTEXT.C vars for multi-threaded support")
-CRITICAL_SECTION CriticalSection;		// for serialized access
-DWORD		dwTLSCurrentContext = 0xFFFFFFFF;	// TLS index for current context
-DWORD		dwTLSPixelFormat = 0xFFFFFFFF;		// TLS index for current pixel format
-#endif
-HGLRC		iCurrentContext = 0;		// Index of current context (static)
-BOOL		bContextReady = FALSE;		// Context state ready ?
-
-DGL_ctx		ctxlist[DGL_MAX_CONTEXTS];	// Context list
-
-// ***********************************************************************
-
-static BOOL bHaveWin95 = FALSE;
-static BOOL bHaveWinNT = FALSE;
-static BOOL bHaveWin2K = FALSE;
-
-/****************************************************************************
-REMARKS:
-Detect the installed OS type.
-****************************************************************************/
-static void DetectOS(void)
-{
-    OSVERSIONINFO VersionInformation;
-    LPOSVERSIONINFO lpVersionInformation = &VersionInformation;
-
-    VersionInformation.dwOSVersionInfoSize = sizeof(VersionInformation);
-
-	GetVersionEx(lpVersionInformation);
-
-    switch (VersionInformation.dwPlatformId) {
-    	case VER_PLATFORM_WIN32_WINDOWS:
-			bHaveWin95 = TRUE;
-			bHaveWinNT = FALSE;
-			bHaveWin2K = FALSE;
-            break;
-    	case VER_PLATFORM_WIN32_NT:
-			bHaveWin95 = FALSE;
-			if (VersionInformation.dwMajorVersion <= 4) {
-				bHaveWinNT = TRUE;
-				bHaveWin2K = FALSE;
-                }
-            else {
-				bHaveWinNT = FALSE;
-				bHaveWin2K = TRUE;
-                }
-			break;
-		case VER_PLATFORM_WIN32s:
-			bHaveWin95 = FALSE;
-			bHaveWinNT = FALSE;
-			bHaveWin2K = FALSE;
-			break;
-        }
-}
-
-// ***********************************************************************
-
-HWND hWndEvent = NULL;					// event monitor window
-HWND hWndLastActive = NULL;				// last active client window
-LONG __stdcall GLD_EventWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
-
-// ***********************************************************************
-
-// Checks if the HGLRC is valid in range of context list.
-BOOL dglIsValidContext(
-	HGLRC a)
-{
-	return ((int)a > 0 && (int)a <= DGL_MAX_CONTEXTS);
-}
-
-// ***********************************************************************
-
-// Convert a HGLRC to a pointer into the context list.
-DGL_ctx* dglGetContextAddress(
-	const HGLRC a)
-{
-	if (dglIsValidContext(a))
-		return &ctxlist[(int)a-1];
-	return NULL;
-}
-
-// ***********************************************************************
-
-// Return the current HGLRC (however it may be stored for multi-threading).
-HGLRC dglGetCurrentContext(void)
-{
-#ifdef GLD_THREADS
-	HGLRC hGLRC;
-	// load from thread-specific instance
-	if (glb.bMultiThreaded) {
-		// protect against calls from arbitrary threads
-		__try {
-			hGLRC = (HGLRC)TlsGetValue(dwTLSCurrentContext);
-		}
-		__except(EXCEPTION_EXECUTE_HANDLER) {
-			hGLRC = iCurrentContext;
-		}
-	}
-	// load from global static var
-	else {
-		hGLRC = iCurrentContext;
-	}
-	return hGLRC;
-#else
-	return iCurrentContext;
-#endif
-}
-
-// ***********************************************************************
-
-// Set the current HGLRC (however it may be stored for multi-threading).
-void dglSetCurrentContext(HGLRC hGLRC)
-{
-#ifdef GLD_THREADS
-	// store in thread-specific instance
-	if (glb.bMultiThreaded) {
-		// protect against calls from arbitrary threads
-		__try {
-			TlsSetValue(dwTLSCurrentContext, (LPVOID)hGLRC);
-		}
-		__except(EXCEPTION_EXECUTE_HANDLER) {
-			iCurrentContext = hGLRC;
-		}
-	}
-	// store in global static var
-	else {
-		iCurrentContext = hGLRC;
-	}
-#else
-	iCurrentContext = hGLRC;
-#endif
-}
-
-// ***********************************************************************
-
-// Return the current HDC only for a currently active HGLRC.
-HDC dglGetCurrentDC(void)
-{
-	HGLRC hGLRC;
-	DGL_ctx* lpCtx;
-
-	hGLRC = dglGetCurrentContext();
-	if (hGLRC) {
-		lpCtx = dglGetContextAddress(hGLRC);
-		return lpCtx->hDC;
-	}
-	return 0;
-}
-
-// ***********************************************************************
-
-void dglInitContextState()
-{
-	int i;
-	WNDCLASS wc;
-
-#ifdef GLD_THREADS
-	// Allocate thread local storage indexes for current context and pixel format
-	dwTLSCurrentContext = TlsAlloc();
-	dwTLSPixelFormat = TlsAlloc();
-#endif
-
-	dglSetCurrentContext(NULL); // No current rendering context
-
-	 // Clear all context data
-	ZeroMemory(ctxlist, sizeof(ctxlist[0]) * DGL_MAX_CONTEXTS);
-
-	for (i=0; i<DGL_MAX_CONTEXTS; i++)
-		ctxlist[i].bAllocated = FALSE; // Flag context as unused
-
-	// This section of code crashes the dll in circumstances where the app
-	// creates and destroys contexts.
-/*
-	// Register the class for our event monitor window
-	wc.style = 0;
-	wc.lpfnWndProc = GLD_EventWndProc;
-	wc.cbClsExtra = 0;
-	wc.cbWndExtra = 0;
-	wc.hInstance = GetModuleHandle(NULL);
-	wc.hIcon = LoadIcon(GetModuleHandle(NULL), IDI_APPLICATION);
-	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
-	wc.lpszMenuName = NULL;
-	wc.lpszClassName = "GLDIRECT";
-	RegisterClass(&wc);
-
-	// Create the non-visible window to monitor all broadcast messages
-	hWndEvent = CreateWindowEx(
-		WS_EX_TOOLWINDOW,"GLDIRECT","GLDIRECT",WS_POPUP,
-		0,0,0,0,
-		NULL,NULL,GetModuleHandle(NULL),NULL);
-*/
-
-#ifdef GLD_THREADS
-	// Create a critical section object for serializing access to
-	// DirectDraw and DDStereo create/destroy functions in multiple threads
-	if (glb.bMultiThreaded)
-		InitializeCriticalSection(&CriticalSection);
-#endif
-
-	// Context state is now initialized and ready
-	bContextReady = TRUE;
-}
-
-// ***********************************************************************
-
-void dglDeleteContextState()
-{
-	int i;
-	static BOOL bOnceIsEnough = FALSE;
-
-	// Only call once, from either DGL_exitDriver(), or DLL_PROCESS_DETACH
-	if (bOnceIsEnough)
-		return;
-	bOnceIsEnough = TRUE;
-
-	for (i=0; i<DGL_MAX_CONTEXTS; i++) {
-		if (ctxlist[i].bAllocated == TRUE) {
-			ddlogPrintf(DDLOG_WARN, "** Context %i not deleted - cleaning up.", (i+1));
-			dglDeleteContext((HGLRC)(i+1));
-		}
-	}
-
-	// Context state is no longer ready
-	bContextReady = FALSE;
-
-    // If executed when DLL unloads, DDraw objects may be invalid.
-    // So catch any page faults with this exception handler.
-__try {
-
-	// Release final DirectDraw interfaces
-	if (glb.bDirectDrawPersistant) {
-//		RELEASE(glb.lpGlobalPalette);
-//		RELEASE(glb.lpDepth4);
-//		RELEASE(glb.lpBack4);
-//		RELEASE(glb.lpPrimary4);
-//	    RELEASE(glb.lpDD4);
-    }
-}
-__except(EXCEPTION_EXECUTE_HANDLER) {
-    ddlogPrintf(DDLOG_WARN, "Exception raised in dglDeleteContextState.");
-}
-
-	// Destroy our event monitor window
-	if (hWndEvent) {
-		DestroyWindow(hWndEvent);
-		hWndEvent = hWndLastActive = NULL;
-	}
-
-#ifdef GLD_THREADS
-	// Destroy the critical section object
-	if (glb.bMultiThreaded)
-		DeleteCriticalSection(&CriticalSection);
-
-	// Release thread local storage indexes for current HGLRC and pixel format
-	TlsFree(dwTLSPixelFormat);
-	TlsFree(dwTLSCurrentContext);
-#endif
-}
-
-// ***********************************************************************
-
-// Application Window message handler interception
-static LONG __stdcall dglWndProc(
-	HWND hwnd,
-	UINT msg,
-	WPARAM wParam,
-	LPARAM lParam)
-{
-	DGL_ctx* 	lpCtx = NULL;
-	LONG 		lpfnWndProc = 0L;
-	int  		i;
-	HGLRC 		hGLRC;
-	RECT 		rect;
-	PAINTSTRUCT	ps;
-    BOOL        bQuit = FALSE;
-    BOOL        bMain = FALSE;
-    LONG        rc;
-
-    // Get the window's message handler *before* it is unhooked in WM_DESTROY
-
-    // Is this the main window?
-    if (hwnd == glb.hWndActive) {
-        bMain = TRUE;
-        lpfnWndProc = glb.lpfnWndProc;
-    }
-    // Search for DGL context matching window handle
-    for (i=0; i<DGL_MAX_CONTEXTS; i++) {
-	    if (ctxlist[i].hWnd == hwnd) {
-	        lpCtx = &ctxlist[i];
-	        lpfnWndProc = lpCtx->lpfnWndProc;
-		    break;
-        }
-    }
-	// Not one of ours...
-	if (!lpfnWndProc)
-	    return DefWindowProc(hwnd, msg, wParam, lParam);
-
-    // Intercept messages amd process *before* passing on to window
-	switch (msg) {
-#ifdef _USE_GLD3_WGL
-	case WM_DISPLAYCHANGE:
-		glb.bPixelformatsDirty = TRUE;
-		break;
-#endif
-	case WM_ACTIVATEAPP:
-		glb.bAppActive = (BOOL)wParam;
-		ddlogPrintf(DDLOG_INFO, "Calling app has been %s", glb.bAppActive ? "activated" : "de-activated");
-		break;
-	case WM_ERASEBKGND:
-		// Eat the GDI erase event for the GL window
-        if (!lpCtx || !lpCtx->bHasBeenCurrent)
-            break;
-		lpCtx->bGDIEraseBkgnd = TRUE;
-		return TRUE;
-	case WM_PAINT:
-		// Eat the invalidated update region if render scene is in progress
-        if (!lpCtx || !lpCtx->bHasBeenCurrent)
-            break;
-		if (lpCtx->bFrameStarted) {
-			if (GetUpdateRect(hwnd, &rect, FALSE)) {
-				BeginPaint(hwnd, &ps);
-				EndPaint(hwnd, &ps);
-				ValidateRect(hwnd, &rect);
-				return TRUE;
-				}
-			}
-		break;
-	}
-	// Call the appropriate window message handler
-	rc = CallWindowProc((WNDPROC)lpfnWndProc, hwnd, msg, wParam, lParam);
-
-    // Intercept messages and process *after* passing on to window
-	switch (msg) {
-    case WM_QUIT:
-	case WM_DESTROY:
-        bQuit = TRUE;
-		if (lpCtx && lpCtx->bAllocated) {
-			ddlogPrintf(DDLOG_WARN, "WM_DESTROY detected for HWND=%X, HDC=%X, HGLRC=%d", hwnd, lpCtx->hDC, i+1);
-			dglDeleteContext((HGLRC)(i+1));
-		}
-		break;
-#if 0
-	case WM_SIZE:
-		// Resize surfaces to fit window but not viewport (in case app did not bother)
-        if (!lpCtx || !lpCtx->bHasBeenCurrent)
-            break;
-		w = LOWORD(lParam);
-		h = HIWORD(lParam);
-		if (lpCtx->dwWidth < w || lpCtx->dwHeight < h) {
-			if (!dglWglResizeBuffers(lpCtx->glCtx, TRUE))
-                 dglWglResizeBuffers(lpCtx->glCtx, FALSE);
-        }
-		break;
-#endif
-    }
-
-    // If the main window is quitting, then so should we...
-    if (bMain && bQuit) {
-		ddlogPrintf(DDLOG_SYSTEM, "shutting down after WM_DESTROY detected for main HWND=%X", hwnd);
-        dglDeleteContextState();
-        dglExitDriver();
-    }
-
-    return rc;
-}
-
-// ***********************************************************************
-
-// Driver Window message handler
-static LONG __stdcall GLD_EventWndProc(
-	HWND hwnd,
-	UINT msg,
-	WPARAM wParam,
-	LPARAM lParam)
-{
-	switch (msg) {
-        // May be sent by splash screen dialog on exit
-        case WM_ACTIVATE:
-            if (LOWORD(wParam) == WA_ACTIVE && glb.hWndActive) {
-                SetForegroundWindow(glb.hWndActive);
-                return 0;
-                }
-            break;
-	}
-	return DefWindowProc(hwnd, msg, wParam, lParam);
-}
-
-// ***********************************************************************
-
-// Intercepted Keyboard handler for detecting hot keys.
-LRESULT CALLBACK dglKeyProc(
-	int code,
-	WPARAM wParam,
-	LPARAM lParam)
-{
-	HWND hWnd, hWndFrame;
-	HGLRC hGLRC = NULL;
-	DGL_ctx* lpCtx = NULL;
-	int cmd = 0, dx1 = 0, dx2 = 0, i;
-	static BOOL bAltPressed = FALSE;
-	static BOOL bCtrlPressed = FALSE;
-	static BOOL bShiftPressed = FALSE;
-    RECT r, rf, rc;
-    POINT pt;
-    BOOL bForceReshape = FALSE;
-
-	return CallNextHookEx(hKeyHook, code, wParam, lParam);
-}
-
-// ***********************************************************************
-
-HWND hWndMatch;
-
-// Window handle enumeration procedure.
-BOOL CALLBACK dglEnumChildProc(
-    HWND hWnd,
-    LPARAM lParam)
-{
-    RECT rect;
-
-    // Find window handle with matching client rect.
-    GetClientRect(hWnd, &rect);
-    if (EqualRect(&rect, (RECT*)lParam)) {
-        hWndMatch = hWnd;
-        return FALSE;
-        }
-    // Continue with next child window.
-    return TRUE;
-}
-
-// ***********************************************************************
-
-// Find window handle with matching client rect.
-HWND dglFindWindowRect(
-    RECT* pRect)
-{
-    hWndMatch = NULL;
-    EnumChildWindows(GetForegroundWindow(), dglEnumChildProc, (LPARAM)pRect);
-    return hWndMatch;
-}
-
-// ***********************************************************************
-#ifndef _USE_GLD3_WGL
-void dglChooseDisplayMode(
-	DGL_ctx *lpCtx)
-{
-	// Note: Choose an exact match if possible.
-
-	int				i;
-	DWORD			area;
-	DWORD			bestarea;
-	DDSURFACEDESC2	*lpDDSD		= NULL;	// Mode list pointer
-	DDSURFACEDESC2	*lpBestDDSD = NULL;	// Pointer to best
-
-	lpDDSD = glb.lpDisplayModes;
-	for (i=0; i<glb.nDisplayModeCount; i++, lpDDSD++) {
-		if ((lpDDSD->dwWidth == lpCtx->dwWidth) &&
-			(lpDDSD->dwHeight == lpCtx->dwHeight))
-			goto matched; // Mode has been exactly matched
-		// Choose modes that are larger in both dimensions than
-		// the window, but smaller in area than the current best.
-		if ( (lpDDSD->dwWidth >= lpCtx->dwWidth) &&
-			 (lpDDSD->dwHeight >= lpCtx->dwHeight))
-		{
-			if (lpBestDDSD == NULL) {
-				lpBestDDSD = lpDDSD;
-				bestarea = lpDDSD->dwWidth * lpDDSD->dwHeight;
-				continue;
-			}
-			area = lpDDSD->dwWidth * lpDDSD->dwHeight;
-			if (area < bestarea) {
-				lpBestDDSD = lpDDSD;
-				bestarea = area;
-			}
-		}
-	}
-
-	// Safety check
-	if (lpBestDDSD == NULL) {
-		ddlogMessage(DDLOG_CRITICAL, "dglChooseDisplayMode");
-		return;
-	}
-
-	lpCtx->dwModeWidth = lpBestDDSD->dwWidth;
-	lpCtx->dwModeHeight = lpBestDDSD->dwHeight;
-matched:
-	ddlogPrintf(DDLOG_INFO, "Matched (%ldx%ld) to (%ldx%ld)",
-		lpCtx->dwWidth, lpCtx->dwHeight, lpCtx->dwModeWidth, lpCtx->dwModeHeight);
-}
-#endif // _USE_GLD3_WGL
-// ***********************************************************************
-
-static BOOL IsDevice(
-	DWORD *lpDeviceIdList,
-	DWORD dwDeviceId,
-	int count)
-{
-	int i;
-
-	for (i=0; i<count; i++)
-		if (dwDeviceId == lpDeviceIdList[i])
-			return TRUE;
-
-	return FALSE;
-}
-
-// ***********************************************************************
-
-void dglTestForBrokenCards(
-	DGL_ctx *lpCtx)
-{
-#ifndef _GLD3
-	DDDEVICEIDENTIFIER	dddi; // DX6 device identifier
-
-	// Sanity check.
-	if (lpCtx == NULL) {
-		// Testing for broken cards is sensitive area, so we don't want
-		// anything saying "broken cards" in the error message. ;)
-		ddlogMessage(DDLOG_ERROR, "Null context passed to TFBC\n");
-		return;
-	}
-
-	if (lpCtx->lpDD4 == NULL) {
-		// Testing for broken cards is sensitive area, so we don't want
-		// anything saying "broken cards" in the error message. ;)
-		ddlogMessage(DDLOG_ERROR, "Null DD4 passed to TFBC\n");
-		return;
-	}
-
-	// Microsoft really fucked up with the GetDeviceIdentifier function
-	// on Windows 2000, since it locks up on stock driers on the CD. Updated
-	// drivers from vendors appear to work, but we can't identify the drivers
-	// without this function!!! For now we skip these tests on Windows 2000.
-	if ((GetVersion() & 0x80000000UL) == 0)
-		return;
-
-	// Obtain device info
-	if (FAILED(IDirectDraw4_GetDeviceIdentifier(lpCtx->lpDD4, &dddi, 0)))
-		return;
-
-	// Useful info. Log it.
-	ddlogPrintf(DDLOG_INFO, "DirectDraw: VendorId=0x%x, DeviceId=0x%x", dddi.dwVendorId, dddi.dwDeviceId);
-
-	// Vendor 1: ATI
-	if (dddi.dwVendorId == VENDORID_ATI) {
-		// Test A: ATI Rage PRO
-		if (IsDevice(devATIRagePro, dddi.dwDeviceId, sizeof(devATIRagePro)))
-			glb.bUseMipmaps = FALSE;
-		// Test B: ATI Rage II+
-		if (IsDevice(devATIRageIIplus, dddi.dwDeviceId, sizeof(devATIRageIIplus)))
-			glb.bEmulateAlphaTest = TRUE;
-	}
-
-	// Vendor 2: Matrox
-	if (dddi.dwVendorId == 0x102B) {
-		// Test: Matrox G400 stencil buffer support does not work for AutoCAD
-		if (dddi.dwDeviceId == 0x0525) {
-			lpCtx->lpPF->pfd.cStencilBits = 0;
-			if (lpCtx->lpPF->iZBufferPF != -1) {
-				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwStencilBitDepth = 0;
-				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwStencilBitMask = 0;
-				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwFlags &= ~DDPF_STENCILBUFFER;
-			}
-		}
-	}
-#endif // _GLD3
-}
-
-// ***********************************************************************
-
-BOOL dglCreateContextBuffers(
-	HDC a,
-	DGL_ctx *lpCtx,
-	BOOL bFallback)
-{
-	HRESULT				hResult;
-
-	int					i;
-//	HGLRC				hGLRC;
-//	DGL_ctx*			lpCtx;
-
-#ifndef _USE_GLD3_WGL
-	DWORD				dwFlags;
-	DDSURFACEDESC2		ddsd2;
-	DDSCAPS2			ddscaps2;
-	LPDIRECTDRAWCLIPPER	lpddClipper;
-	D3DDEVICEDESC		D3DHWDevDesc;	// Direct3D Hardware description
-	D3DDEVICEDESC		D3DHELDevDesc;	// Direct3D Hardware Emulation Layer
-#endif // _USE_GLD3_WGL
-
-	float				inv_aspect;
-
-	GLenum				bDoubleBuffer;	// TRUE if double buffer required
-	GLenum				bDepthBuffer;	// TRUE if depth buffer required
-
-	const PIXELFORMATDESCRIPTOR	*lpPFD = &lpCtx->lpPF->pfd;
-
-	// Vars for Mesa visual
-	DWORD				dwDepthBits		= 0;
-	DWORD				dwStencilBits	= 0;
-	DWORD				dwAlphaBits		= 0;
-	DWORD				bAlphaSW		= GL_FALSE;
-	DWORD				bDouble			= GL_FALSE;
-
-	DDSURFACEDESC2 		ddsd2DisplayMode;
-	BOOL				bFullScrnWin	= FALSE;	// fullscreen-size window ?
-	DDBLTFX 			ddbltfx;
-	DWORD				dwMemoryType 	= (bFallback) ? DDSCAPS_SYSTEMMEMORY : glb.dwMemoryType;
-	BOOL				bBogusWindow	= FALSE;	// non-drawable window ?
-	DWORD               dwColorRef      = 0;        // GDI background color
-	RECT				rcDst;						// GDI window rect
-	POINT				pt;							// GDI window point
-
-	// Palette used for creating default global palette
-	PALETTEENTRY	ppe[256];
-
-#ifndef _USE_GLD3_WGL
-	// Vertex buffer description. Used for creation of vertex buffers
-	D3DVERTEXBUFFERDESC vbufdesc;
-#endif // _USE_GLD3_WGL
-
-#define DDLOG_CRITICAL_OR_WARN	(bFallback ? DDLOG_CRITICAL : DDLOG_WARN)
-
-	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContextBuffers for HDC=%X", a);
-    nContextError = GLDERR_NONE;
-
-#ifdef GLD_THREADS
-	// Serialize access to DirectDraw object creation or DDS start
-	if (glb.bMultiThreaded)
-		EnterCriticalSection(&CriticalSection);
-#endif
-
-	// Check for back buffer
-	bDoubleBuffer = GL_TRUE; //(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? GL_TRUE : GL_FALSE;
-	// Since we always do back buffering, check if we emulate front buffering
-	lpCtx->EmulateSingle =
-		(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? FALSE : TRUE;
-#if 0	// Don't have to mimic MS OpenGL behavior for front-buffering (DaveM)
-	lpCtx->EmulateSingle |=
-		(lpPFD->dwFlags & PFD_SUPPORT_GDI) ? TRUE : FALSE;
-#endif
-
-	// Check for depth buffer
-	bDepthBuffer = (lpPFD->cDepthBits) ? GL_TRUE : GL_FALSE;
-
-	lpCtx->bDoubleBuffer = bDoubleBuffer;
-	lpCtx->bDepthBuffer = bDepthBuffer;
-
-	// Set the Fullscreen flag for the context.
-//	lpCtx->bFullscreen = glb.bFullscreen;
-
-	// Obtain the dimensions of the rendering window
-	lpCtx->hDC = a; // Cache DC
-	lpCtx->hWnd = WindowFromDC(lpCtx->hDC);
-	// Check for non-window DC = memory DC ?
-	if (lpCtx->hWnd == NULL) {
-        // bitmap memory contexts are always single-buffered
-        lpCtx->EmulateSingle = TRUE;
-		bBogusWindow = TRUE;
-		ddlogPrintf(DDLOG_INFO, "Non-Window Memory Device Context");
-		if (GetClipBox(lpCtx->hDC, &lpCtx->rcScreenRect) == ERROR) {
-			ddlogMessage(DDLOG_WARN, "GetClipBox failed in dglCreateContext\n");
-			SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);
-		}
-	}
-	else if (!GetClientRect(lpCtx->hWnd, &lpCtx->rcScreenRect)) {
-		bBogusWindow = TRUE;
-		ddlogMessage(DDLOG_WARN, "GetClientRect failed in dglCreateContext\n");
-		SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);
-	}
-	lpCtx->dwWidth = lpCtx->rcScreenRect.right - lpCtx->rcScreenRect.left;
-	lpCtx->dwHeight = lpCtx->rcScreenRect.bottom - lpCtx->rcScreenRect.top;
-
-	ddlogPrintf(DDLOG_INFO, "Input window %X: w=%i, h=%i",
-							lpCtx->hWnd, lpCtx->dwWidth, lpCtx->dwHeight);
-
-	// What if app only zeroes one dimension instead of both? (DaveM)
-	if ( (lpCtx->dwWidth == 0) || (lpCtx->dwHeight == 0) ) {
-		// Make the buffer size something sensible
-		lpCtx->dwWidth = 8;
-		lpCtx->dwHeight = 8;
-	}
-
-	// Set defaults
-	lpCtx->dwModeWidth = lpCtx->dwWidth;
-	lpCtx->dwModeHeight = lpCtx->dwHeight;
-/*
-	// Find best display mode for fullscreen
-	if (glb.bFullscreen || !glb.bPrimary) {
-		dglChooseDisplayMode(lpCtx);
-	}
-*/
-	// Misc initialisation
-	lpCtx->bCanRender = FALSE; // No rendering allowed yet
-	lpCtx->bSceneStarted = FALSE;
-	lpCtx->bFrameStarted = FALSE;
-
-	// Detect OS (specifically 'Windows 2000' or 'Windows XP')
-	DetectOS();
-
-	// NOTE: WinNT not supported
-	ddlogPrintf(DDLOG_INFO, "OS: %s", bHaveWin95 ? "Win9x" : (bHaveWin2K ? "Win2000/XP" : "Unsupported") );
-
-	// Test for Fullscreen
-	if (bHaveWin95) { // Problems with fullscreen on Win2K/XP
-		if ((GetSystemMetrics(SM_CXSCREEN) == lpCtx->dwWidth) && 
-			(GetSystemMetrics(SM_CYSCREEN) == lpCtx->dwHeight))
-		{
-			// Workaround for some apps that crash when going fullscreen.
-			//lpCtx->bFullscreen = TRUE;
-		}
-		
-	}
-
-#ifdef _USE_GLD3_WGL
-	_gldDriver.CreateDrawable(lpCtx, glb.bDirectDrawPersistant, glb.bPersistantBuffers);
-#else
-	// Check if DirectDraw has already been created by original GLRC (DaveM)
-	if (glb.bDirectDrawPersistant && glb.bDirectDraw) {
-		lpCtx->lpDD4 = glb.lpDD4;
-		IDirectDraw4_AddRef(lpCtx->lpDD4);
-		goto SkipDirectDrawCreate;
-	}
-
-	// Create DirectDraw object
-	if (glb.bPrimary)
-		hResult = DirectDrawCreate(NULL, &lpCtx->lpDD1, NULL);
-	else {
-		// A non-primary device is to be used.
-		// Force context to be Fullscreen, secondary adaptors can not
-		// be used in a window.
-		hResult = DirectDrawCreate(&glb.ddGuid, &lpCtx->lpDD1, NULL);
-		lpCtx->bFullscreen = TRUE;
-	}
-	if (FAILED(hResult)) {
-		MessageBox(NULL, "Unable to initialize DirectDraw", "GLDirect", MB_OK);
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create DirectDraw interface", hResult);
-        nContextError = GLDERR_DDRAW;
-		goto return_with_error;
-	}
-
-	// Query for DX6 IDirectDraw4.
-	hResult = IDirectDraw_QueryInterface(lpCtx->lpDD1,
-										 &IID_IDirectDraw4,
-										 (void**)&lpCtx->lpDD4);
-	if (FAILED(hResult)) {
-		MessageBox(NULL, "GLDirect requires DirectX 6.0 or above", "GLDirect", MB_OK);
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create DirectDraw4 interface", hResult);
-        nContextError = GLDERR_DDRAW;
-		goto return_with_error;
-	}
-
-	// Cache DirectDraw interface for subsequent GLRCs
-	if (glb.bDirectDrawPersistant && !glb.bDirectDraw) {
-		glb.lpDD4 = lpCtx->lpDD4;
-		IDirectDraw4_AddRef(glb.lpDD4);
-		glb.bDirectDraw = TRUE;
-	}
-SkipDirectDrawCreate:
-
-	// Now we have a DD4 interface we can check for broken cards
-	dglTestForBrokenCards(lpCtx);
-
-	// Test if primary device can use flipping instead of blitting
-	ZeroMemory(&ddsd2DisplayMode, sizeof(ddsd2DisplayMode));
-	ddsd2DisplayMode.dwSize = sizeof(ddsd2DisplayMode);
-	hResult = IDirectDraw4_GetDisplayMode(
-					lpCtx->lpDD4,
-					&ddsd2DisplayMode);
-	if (SUCCEEDED(hResult)) {
-		if ( (lpCtx->dwWidth == ddsd2DisplayMode.dwWidth) &&
-				 (lpCtx->dwHeight == ddsd2DisplayMode.dwHeight) ) {
-			// We have a fullscreen-size window
-			bFullScrnWin = TRUE;
-			// OK to use DirectDraw fullscreen mode ?
-			if (glb.bPrimary && !glb.bFullscreenBlit && !lpCtx->EmulateSingle && !glb.bDirectDrawPersistant) {
-				lpCtx->bFullscreen = TRUE;
-				ddlogMessage(DDLOG_INFO, "Primary upgraded to page flipping.\n");
-			}
-		}
-		// Cache the display mode dimensions
-		lpCtx->dwModeWidth = ddsd2DisplayMode.dwWidth;
-		lpCtx->dwModeHeight = ddsd2DisplayMode.dwHeight;
-	}
-
-	// Clamp the effective window dimensions to primary surface.
-	// We need to do this for D3D viewport dimensions even if wide
-	// surfaces are supported. This also is a good idea for handling
-	// whacked-out window dimensions passed for non-drawable windows
-	// like Solid Edge. (DaveM)
-	if (lpCtx->dwWidth > ddsd2DisplayMode.dwWidth)
-		lpCtx->dwWidth = ddsd2DisplayMode.dwWidth;
-	if (lpCtx->dwHeight > ddsd2DisplayMode.dwHeight)
-		lpCtx->dwHeight = ddsd2DisplayMode.dwHeight;
-
-	// Check for non-RGB desktop resolution
-	if (!lpCtx->bFullscreen && ddsd2DisplayMode.ddpfPixelFormat.dwRGBBitCount <= 8) {
-		ddlogPrintf(DDLOG_CRITICAL_OR_WARN, "Desktop color depth %d bpp not supported",
-			ddsd2DisplayMode.ddpfPixelFormat.dwRGBBitCount);
-        nContextError = GLDERR_BPP;
-		goto return_with_error;
-	}
-#endif // _USE_GLD3_WGL
-
-	ddlogPrintf(DDLOG_INFO, "Window: w=%i, h=%i (%s)",
-							lpCtx->dwWidth,
-							lpCtx->dwHeight,
-							lpCtx->bFullscreen ? "fullscreen" : "windowed");
-
-#ifndef _USE_GLD3_WGL
-	// Obtain ddraw caps
-    ZeroMemory(&lpCtx->ddCaps, sizeof(DDCAPS));
-	lpCtx->ddCaps.dwSize = sizeof(DDCAPS);
-	if (glb.bHardware) {
-		// Get HAL caps
-		IDirectDraw4_GetCaps(lpCtx->lpDD4, &lpCtx->ddCaps, NULL);
-	} else {
-		// Get HEL caps
-		IDirectDraw4_GetCaps(lpCtx->lpDD4, NULL, &lpCtx->ddCaps);
-	}
-
-	// If this flag is present then we can't default to Mesa
-	// SW rendering between BeginScene() and EndScene().
-	if (lpCtx->ddCaps.dwCaps2 & DDCAPS2_NO2DDURING3DSCENE) {
-		ddlogMessage(DDLOG_INFO,
-			"Warning          : No 2D allowed during 3D scene.\n");
-	}
-
-	// Query for DX6 Direct3D3 interface
-	hResult = IDirectDraw4_QueryInterface(lpCtx->lpDD4,
-										  &IID_IDirect3D3,
-										  (void**)&lpCtx->lpD3D3);
-	if (FAILED(hResult)) {
-		MessageBox(NULL, "Unable to initialize Direct3D", "GLDirect", MB_OK);
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create Direct3D interface", hResult);
-        nContextError = GLDERR_D3D;
-		goto return_with_error;
-	}
-
-	// Context creation
-	if (lpCtx->bFullscreen) {
-		// FULLSCREEN
-
-        // Disable warning popups when in fullscreen mode
-        ddlogWarnOption(FALSE);
-
-		// Have to release persistant primary surface if fullscreen mode
-		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) {
-			RELEASE(glb.lpPrimary4);
-			glb.bDirectDrawPrimary = FALSE;
-		}
-
-		dwFlags = DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT;
-		if (glb.bFastFPU)
-			dwFlags |= DDSCL_FPUSETUP;	// fast FPU setup optional (DaveM)
-		hResult = IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, lpCtx->hWnd, dwFlags);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to set Exclusive Fullscreen mode", hResult);
-			goto return_with_error;
-		}
-
-		hResult = IDirectDraw4_SetDisplayMode(lpCtx->lpDD4,
-											  lpCtx->dwModeWidth,
-											  lpCtx->dwModeHeight,
-											  lpPFD->cColorBits,
-											  0,
-											  0);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetDisplayMode failed", hResult);
-			goto return_with_error;
-		}
-
-		// ** The display mode has changed, so dont use MessageBox! **
-
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-
-		if (bDoubleBuffer) {
-			// Double buffered
-			// Primary surface
-			ddsd2.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
-								   DDSCAPS_FLIP |
-								   DDSCAPS_COMPLEX |
-								   DDSCAPS_3DDEVICE |
-								   dwMemoryType;
-			ddsd2.dwBackBufferCount = 1;
-
-			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);
-                nContextError = GLDERR_MEM;
-				goto return_with_error;
-			}
-
-			// Render target surface
-			ZeroMemory(&ddscaps2, sizeof(ddscaps2)); // Clear the entire struct.
-			ddscaps2.dwCaps = DDSCAPS_BACKBUFFER;
-			hResult = IDirectDrawSurface4_GetAttachedSurface(lpCtx->lpFront4, &ddscaps2, &lpCtx->lpBack4);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "GetAttachedSurface failed", hResult);
-                nContextError = GLDERR_MEM;
-				goto return_with_error;
-			}
-		} else {
-			// Single buffered
-			// Primary surface
-			ddsd2.dwFlags = DDSD_CAPS;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
-								   //DDSCAPS_3DDEVICE |
-								   dwMemoryType;
-
-			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);
-                nContextError = GLDERR_MEM;
-				goto return_with_error;
-			}
-
-			lpCtx->lpBack4 = NULL;
-		}
-	} else {
-		// WINDOWED
-
-        // OK to enable warning popups in windowed mode
-        ddlogWarnOption(glb.bMessageBoxWarnings);
-
-		dwFlags = DDSCL_NORMAL;
-		if (glb.bMultiThreaded)
-			dwFlags |= DDSCL_MULTITHREADED;
-		if (glb.bFastFPU)
-			dwFlags |= DDSCL_FPUSETUP;	// fast FPU setup optional (DaveM)
-		hResult = IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4,
-												  lpCtx->hWnd,
-												  dwFlags);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to set Normal coop level", hResult);
-			goto return_with_error;
-		}
-		// Has Primary surface already been created for original GLRC ?
-		// Note this can only be applicable for windowed modes
-		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) {
-			lpCtx->lpFront4 = glb.lpPrimary4;
-			IDirectDrawSurface4_AddRef(lpCtx->lpFront4);
-			// Update the window on the default clipper
-			IDirectDrawSurface4_GetClipper(lpCtx->lpFront4, &lpddClipper);
-			IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);
-			IDirectDrawClipper_Release(lpddClipper);
-			goto SkipPrimaryCreate;
-		}
-
-		// Primary surface
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-		ddsd2.dwFlags = DDSD_CAPS;
-		ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
-		hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);
-            nContextError = GLDERR_MEM;
-			goto return_with_error;
-		}
-
-		// Cache Primary surface for subsequent GLRCs
-		// Note this can only be applicable to subsequent windowed modes
-		if (glb.bDirectDrawPersistant && !glb.bDirectDrawPrimary) {
-			glb.lpPrimary4 = lpCtx->lpFront4;
-			IDirectDrawSurface4_AddRef(glb.lpPrimary4);
-			glb.bDirectDrawPrimary = TRUE;
-		}
-
-		// Clipper object
-		hResult = DirectDrawCreateClipper(0, &lpddClipper, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateClipper failed", hResult);
-			goto return_with_error;
-		}
-		hResult = IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);
-		if (FAILED(hResult)) {
-			RELEASE(lpddClipper);
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetHWnd failed", hResult);
-			goto return_with_error;
-		}
-		hResult = IDirectDrawSurface4_SetClipper(lpCtx->lpFront4, lpddClipper);
-		RELEASE(lpddClipper); // We have finished with it.
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetClipper failed", hResult);
-			goto return_with_error;
-		}
-SkipPrimaryCreate:
-
-		if (bDoubleBuffer) {
-			// Render target surface
-			ZeroMemory(&ddsd2, sizeof(ddsd2));
-			ddsd2.dwSize = sizeof(ddsd2);
-			ddsd2.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
-			ddsd2.dwWidth        = lpCtx->dwWidth;
-			ddsd2.dwHeight       = lpCtx->dwHeight;
-			ddsd2.ddsCaps.dwCaps = DDSCAPS_3DDEVICE |
-								   DDSCAPS_OFFSCREENPLAIN |
-								   dwMemoryType;
-
-			// Reserve the entire desktop size for persistant buffers option
-			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers) {
-				ddsd2.dwWidth = ddsd2DisplayMode.dwWidth;
-				ddsd2.dwHeight = ddsd2DisplayMode.dwHeight;
-			}
-			// Re-use original back buffer if persistant buffers exist
-			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpBack4)
-				hResult = IDirectDrawSurface4_AddRef(lpCtx->lpBack4 = glb.lpBack4);
-			else
-				hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpBack4, NULL);
-			if (FAILED(hResult)) {
-				ddlogError(DDLOG_CRITICAL_OR_WARN, "Create Backbuffer failed", hResult);
-                nContextError = GLDERR_MEM;
-				goto return_with_error;
-			}
-			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpBack4)
-				IDirectDrawSurface4_AddRef(glb.lpBack4 = lpCtx->lpBack4);
-		} else {
-			lpCtx->lpBack4 = NULL;
-		}
-	}
-
-	//
-	// Now create the Z-buffer
-	//
-	lpCtx->bStencil = FALSE; // Default to no stencil buffer
-	if (bDepthBuffer && (lpCtx->lpPF->iZBufferPF != -1)) {
-		// Get z-buffer dimensions from the render target
-		// Setup the surface desc for the z-buffer.
-		ZeroMemory(&ddsd2, sizeof(ddsd2));
-		ddsd2.dwSize = sizeof(ddsd2);
-		ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
-		ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | dwMemoryType;
-		ddsd2.dwWidth = lpCtx->dwWidth;
-		ddsd2.dwHeight = lpCtx->dwHeight;
-		memcpy(&ddsd2.ddpfPixelFormat,
-			&glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF],
-			sizeof(DDPIXELFORMAT) );
-
-		// Reserve the entire desktop size for persistant buffers option
-		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers) {
-			ddsd2.dwWidth = ddsd2DisplayMode.dwWidth;
-			ddsd2.dwHeight = ddsd2DisplayMode.dwHeight;
-		}
-
-		// Create a z-buffer
-		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpDepth4)
-			hResult = IDirectDrawSurface4_AddRef(lpCtx->lpDepth4 = glb.lpDepth4);
-		else
-			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpDepth4, NULL);
-		if (FAILED(hResult)) {
-			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (ZBuffer) failed", hResult);
-            nContextError = GLDERR_MEM;
-			goto return_with_error;
-		}
-		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpDepth4)
-			IDirectDrawSurface4_AddRef(glb.lpDepth4 = lpCtx->lpDepth4);
-		else if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpDepth4 && glb.lpBack4)
-			IDirectDrawSurface4_DeleteAttachedSurface(glb.lpBack4, 0, glb.lpDepth4);
-
-		// Attach Zbuffer to render target
-		TRY(IDirectDrawSurface4_AddAttachedSurface(
-			bDoubleBuffer ? lpCtx->lpBack4 : lpCtx->lpFront4,
-			lpCtx->lpDepth4),
-			"dglCreateContext: Attach Zbuffer");
-		if (glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwFlags & DDPF_STENCILBUFFER) {
-			lpCtx->bStencil = TRUE;
-			ddlogMessage(DDLOG_INFO, "Depth buffer has stencil\n");
-		}
-	}
-
-	// Clear all back buffers and Z-buffers in case of memory recycling.
-	ZeroMemory(&ddbltfx, sizeof(ddbltfx));
-	ddbltfx.dwSize = sizeof(ddbltfx);
-	IDirectDrawSurface4_Blt(lpCtx->lpBack4, NULL, NULL, NULL,
-		DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
-	if (lpCtx->lpDepth4)
-		IDirectDrawSurface4_Blt(lpCtx->lpDepth4, NULL, NULL, NULL,
-			DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
-
-	// Now that we have a Z-buffer we can create the 3D device
-	hResult = IDirect3D3_CreateDevice(lpCtx->lpD3D3,
-									  &glb.d3dGuid,
-									  bDoubleBuffer ? lpCtx->lpBack4 : lpCtx->lpFront4,
-									  &lpCtx->lpDev3,
-									  NULL);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create Direct3D device", hResult);
-        nContextError = GLDERR_D3D;
-		goto return_with_error;
-	}
-
-	// We must do this as soon as the device is created
-	dglInitStateCaches(lpCtx);
-
-	// Obtain the D3D Device Description
-	D3DHWDevDesc.dwSize = D3DHELDevDesc.dwSize = sizeof(D3DDEVICEDESC);
-	TRY(IDirect3DDevice3_GetCaps(lpCtx->lpDev3,
-								 &D3DHWDevDesc,
-								 &D3DHELDevDesc),
-								 "dglCreateContext: GetCaps failed");
-
-	// Choose the relevant description and cache it in the context.
-	// We will use this description later for caps checking
-	memcpy(	&lpCtx->D3DDevDesc,
-			glb.bHardware ? &D3DHWDevDesc : &D3DHELDevDesc,
-			sizeof(D3DDEVICEDESC));
-
-	// Now we can examine the texture formats
-	if (!dglBuildTextureFormatList(lpCtx->lpDev3)) {
-		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "dglBuildTextureFormatList failed\n");
-		goto return_with_error;
-	}
-
-	// Get the pixel format of the back buffer
-	lpCtx->ddpfRender.dwSize = sizeof(lpCtx->ddpfRender);
-	if (bDoubleBuffer)
-		hResult = IDirectDrawSurface4_GetPixelFormat(
-					lpCtx->lpBack4,
-					&lpCtx->ddpfRender);
-	else
-		hResult = IDirectDrawSurface4_GetPixelFormat(
-					lpCtx->lpFront4,
-					&lpCtx->ddpfRender);
-
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "GetPixelFormat failed", hResult);
-		goto return_with_error;
-	}
-	// Find a pixel packing function suitable for this surface
-	pxClassifyPixelFormat(&lpCtx->ddpfRender,
-						  &lpCtx->fnPackFunc,
-						  &lpCtx->fnUnpackFunc,
-						  &lpCtx->fnPackSpanFunc);
-
-	// Viewport
-	hResult = IDirect3D3_CreateViewport(lpCtx->lpD3D3, &lpCtx->lpViewport3, NULL);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateViewport failed", hResult);
-		goto return_with_error;
-	}
-
-	hResult = IDirect3DDevice3_AddViewport(lpCtx->lpDev3, lpCtx->lpViewport3);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "AddViewport failed", hResult);
-		goto return_with_error;
-	}
-
-	// Initialise the viewport
-	// Note screen coordinates are used for viewport clipping since D3D
-	// transform operations are not used in the GLD CAD driver. (DaveM)
-	inv_aspect = (float)lpCtx->dwHeight/(float)lpCtx->dwWidth;
-
-	lpCtx->d3dViewport.dwSize = sizeof(lpCtx->d3dViewport);
-	lpCtx->d3dViewport.dwX = 0;
-	lpCtx->d3dViewport.dwY = 0;
-	lpCtx->d3dViewport.dwWidth = lpCtx->dwWidth;
-	lpCtx->d3dViewport.dwHeight = lpCtx->dwHeight;
-	lpCtx->d3dViewport.dvClipX = 0; // -1.0f;
-	lpCtx->d3dViewport.dvClipY = 0; // inv_aspect;
-	lpCtx->d3dViewport.dvClipWidth = lpCtx->dwWidth; // 2.0f;
-	lpCtx->d3dViewport.dvClipHeight = lpCtx->dwHeight; // 2.0f * inv_aspect;
-	lpCtx->d3dViewport.dvMinZ = 0.0f;
-	lpCtx->d3dViewport.dvMaxZ = 1.0f;
-	TRY(IDirect3DViewport3_SetViewport2(lpCtx->lpViewport3, &lpCtx->d3dViewport), "dglCreateContext: SetViewport2");
-
-	hResult = IDirect3DDevice3_SetCurrentViewport(lpCtx->lpDev3, lpCtx->lpViewport3);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "SetCurrentViewport failed", hResult);
-		goto return_with_error;
-	}
-
-	lpCtx->dwBPP = lpPFD->cColorBits;
-	lpCtx->iZBufferPF = lpCtx->lpPF->iZBufferPF;
-
-	// Set last texture to NULL
-	for (i=0; i<MAX_TEXTURE_UNITS; i++) {
-		lpCtx->ColorOp[i] = D3DTOP_DISABLE;
-		lpCtx->AlphaOp[i] = D3DTOP_DISABLE;
-		lpCtx->tObj[i] = NULL;
-	}
-
-	// Default to perspective correct texture mapping
-	dglSetRenderState(lpCtx, D3DRENDERSTATE_TEXTUREPERSPECTIVE, TRUE, "TexturePersp");
-
-	// Set the default culling mode
-	lpCtx->cullmode = D3DCULL_NONE;
-	dglSetRenderState(lpCtx, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE, "CullMode");
-
-	// Disable specular
-	dglSetRenderState(lpCtx, D3DRENDERSTATE_SPECULARENABLE, FALSE, "SpecularEnable");
-	// Disable subpixel correction
-//	dglSetRenderState(lpCtx, D3DRENDERSTATE_SUBPIXEL, FALSE, "SubpixelEnable");
-	// Disable dithering
-	dglSetRenderState(lpCtx, D3DRENDERSTATE_DITHERENABLE, FALSE, "DitherEnable");
-
-	// Initialise the primitive caches
-//	lpCtx->dwNextLineVert	= 0;
-//	lpCtx->dwNextTriVert	= 0;
-
-	// Init the global texture palette
-	lpCtx->lpGlobalPalette = NULL;
-
-	// Init the HW/SW usage counters
-//	lpCtx->dwHWUsageCount = lpCtx->dwSWUsageCount = 0L;
-
-	//
-	// Create two D3D vertex buffers.
-	// One will hold the pre-transformed data with the other one
-	// being used to hold the post-transformed & clipped verts.
-	//
-#if 0  // never used (DaveM)
-	vbufdesc.dwSize = sizeof(D3DVERTEXBUFFERDESC);
-	vbufdesc.dwCaps = D3DVBCAPS_WRITEONLY;
-	if (glb.bHardware == FALSE)
-		vbufdesc.dwCaps = D3DVBCAPS_SYSTEMMEMORY;
-	vbufdesc.dwNumVertices = 32768; // For the time being
-
-	// Source vertex buffer
-	vbufdesc.dwFVF = DGL_LVERTEX;
-	hResult = IDirect3D3_CreateVertexBuffer(lpCtx->lpD3D3, &vbufdesc, &lpCtx->m_vbuf, 0, NULL);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateVertexBuffer(src) failed", hResult);
-		goto return_with_error;
-	}
-
-	// Destination vertex buffer
-	vbufdesc.dwFVF = (glb.bMultitexture == FALSE) ? D3DFVF_TLVERTEX : (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX2);
-	hResult = IDirect3D3_CreateVertexBuffer(lpCtx->lpD3D3, &vbufdesc, &lpCtx->m_pvbuf, 0, NULL);
-	if(FAILED(hResult)) {
-		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateVertexBuffer(dst) failed", hResult);
-		goto return_with_error;
-	}
-#endif
-
-#endif _USE_GLD3_WGL
-
-	//
-	//	Now create the Mesa context
-	//
-
-	// Create the Mesa visual
-	if (lpPFD->cDepthBits)
-		dwDepthBits = 16;
-	if (lpPFD->cStencilBits)
-		dwStencilBits = 8;
-	if (lpPFD->cAlphaBits) {
-		dwAlphaBits = 8;
-		bAlphaSW = GL_TRUE;
-	}
-	if (lpPFD->dwFlags & PFD_DOUBLEBUFFER)
-		bDouble = GL_TRUE;
-//	lpCtx->EmulateSingle =
-//		(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? FALSE : TRUE;
-
-#ifdef _USE_GLD3_WGL
-	lpCtx->glVis = _mesa_create_visual(
-		bDouble,    /* double buffer */
-		GL_FALSE,			// stereo
-		lpPFD->cRedBits,
-		lpPFD->cGreenBits,
-		lpPFD->cBlueBits,
-		dwAlphaBits,
-		dwDepthBits,
-		dwStencilBits,
-		lpPFD->cAccumRedBits,	// accum bits
-		lpPFD->cAccumGreenBits,	// accum bits
-		lpPFD->cAccumBlueBits,	// accum bits
-		lpPFD->cAccumAlphaBits,	// accum alpha bits
-		1				// num samples
-		);
-#else // _USE_GLD3_WGL
-	lpCtx->glVis = (*mesaFuncs.gl_create_visual)(
-		GL_TRUE,			// RGB mode
-		bAlphaSW,			// Is an alpha buffer required?
-		bDouble,			// Is an double-buffering required?
-		GL_FALSE,			// stereo
-		dwDepthBits,		// depth_size
-		dwStencilBits,		// stencil_size
-		lpPFD->cAccumBits,	// accum_size
-		0,					// colour-index bits
-		lpPFD->cRedBits,	// Red bit count
-		lpPFD->cGreenBits,	// Green bit count
-		lpPFD->cBlueBits,	// Blue bit count
-		dwAlphaBits			// Alpha bit count
-		);
-#endif // _USE_GLD3_WGL
-
-	if (lpCtx->glVis == NULL) {
-		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_visual failed\n");
-		goto return_with_error;
-	}
-
-#ifdef _USE_GLD3_WGL
-	lpCtx->glCtx = _mesa_create_context(API_OPENGL, lpCtx->glVis, NULL, (void *)lpCtx, GL_TRUE);
-#else
-	// Create the Mesa context
-	lpCtx->glCtx = (*mesaFuncs.gl_create_context)(
-					lpCtx->glVis,	// Mesa visual
-					NULL,			// share list context
-					(void *)lpCtx,	// Pointer to our driver context
-					GL_TRUE			// Direct context flag
-				   );
-#endif // _USE_GLD3_WGL
-
-	if (lpCtx->glCtx == NULL) {
-		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_context failed\n");
-		goto return_with_error;
-	}
-
-	// Create the Mesa framebuffer
-#ifdef _USE_GLD3_WGL
-	lpCtx->glBuffer = _mesa_create_framebuffer(
-		lpCtx->glVis,
-		lpCtx->glVis->depthBits > 0,
-		lpCtx->glVis->stencilBits > 0,
-		lpCtx->glVis->accumRedBits > 0,
-		GL_FALSE //swalpha
-		);
-#else
-	lpCtx->glBuffer = (*mesaFuncs.gl_create_framebuffer)(lpCtx->glVis);
-#endif // _USE_GLD3_WGL
-
-	if (lpCtx->glBuffer == NULL) {
-		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_framebuffer failed\n");
-		goto return_with_error;
-	}
-
-#ifdef _USE_GLD3_WGL
-	// Init Mesa internals
-	_swrast_CreateContext( lpCtx->glCtx );
-	_vbo_CreateContext( lpCtx->glCtx );
-	_tnl_CreateContext( lpCtx->glCtx );
-	_swsetup_CreateContext( lpCtx->glCtx );
-
-	_gldDriver.InitialiseMesa(lpCtx);
-	
-	lpCtx->glCtx->imports.warning	= _gld_mesa_warning;
-	lpCtx->glCtx->imports.fatal		= _gld_mesa_fatal;
-
-#else
-	// Tell Mesa how many texture stages we have
-	glb.wMaxSimultaneousTextures = lpCtx->D3DDevDesc.wMaxSimultaneousTextures;
-	// Only use as many Units as the spec requires
-	if (glb.wMaxSimultaneousTextures > MAX_TEXTURE_UNITS)
-		glb.wMaxSimultaneousTextures = MAX_TEXTURE_UNITS;
-	lpCtx->glCtx->Const.MaxTextureUnits = glb.wMaxSimultaneousTextures;
-	ddlogPrintf(DDLOG_INFO, "Texture stages   : %d", glb.wMaxSimultaneousTextures);
-
-	// Set the max texture size.
-	// NOTE: clamped to a max of 1024 for extra performance!
-	lpCtx->dwMaxTextureSize = (lpCtx->D3DDevDesc.dwMaxTextureWidth <= 1024) ? lpCtx->D3DDevDesc.dwMaxTextureWidth : 1024;
-
-// Texture resize takes place elsewhere. KH
-// NOTE: This was added to workaround an issue with the Intel app.
-#if 0
-	lpCtx->glCtx->Const.MaxTextureSize = lpCtx->dwMaxTextureSize;
-#else
-	lpCtx->glCtx->Const.MaxTextureSize = 1024;
-#endif
-	lpCtx->glCtx->Const.MaxDrawBuffers = 1;
-
-	// Setup the Display Driver pointers
-	dglSetupDDPointers(lpCtx->glCtx);
-
-	// Initialise all the Direct3D renderstates
-	dglInitStateD3D(lpCtx->glCtx);
-
-#if 0
-	// Signal a reload of texture state on next glBegin
-	lpCtx->m_texHandleValid = FALSE;
-	lpCtx->m_mtex = FALSE;
-	lpCtx->m_texturing = FALSE;
-#else
-	// Set default texture unit state
-//	dglSetTexture(lpCtx, 0, NULL);
-//	dglSetTexture(lpCtx, 1, NULL);
-#endif
-
-	//
-	// Set the global texture palette to default values.
-	//
-
-	// Clear the entire palette
-	ZeroMemory(ppe, sizeof(PALETTEENTRY) * 256);
-
-	// Fill the palette with a default colour.
-	// A garish colour is used to catch bugs. Here Magenta is used.
-	for (i=0; i < 256; i++) {
-		ppe[i].peRed	= 255;
-		ppe[i].peGreen	= 0;
-		ppe[i].peBlue	= 255;
-	}
-
-	RELEASE(lpCtx->lpGlobalPalette);
-
-	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpGlobalPalette)
-		hResult = IDirectDrawPalette_AddRef(lpCtx->lpGlobalPalette = glb.lpGlobalPalette);
-	else
-		hResult = IDirectDraw4_CreatePalette(
-				lpCtx->lpDD4,
-				DDPCAPS_INITIALIZE | DDPCAPS_8BIT | DDPCAPS_ALLOW256,
-				ppe,
-				&(lpCtx->lpGlobalPalette),
-				NULL);
-	if (FAILED(hResult)) {
-		ddlogError(DDLOG_ERROR, "Default CreatePalette failed\n", hResult);
-		lpCtx->lpGlobalPalette = NULL;
-		goto return_with_error;
-	}
-	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpGlobalPalette)
-		IDirectDrawPalette_AddRef(glb.lpGlobalPalette = lpCtx->lpGlobalPalette);
-
-#endif // _USE_GLD3_WGL
-
-	// ** If we have made it to here then we can enable rendering **
-	lpCtx->bCanRender = TRUE;
-
-//	ddlogMessage(DDLOG_SYSTEM, "dglCreateContextBuffers succeded\n");
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	return TRUE;
-
-return_with_error:
-	// Clean up before returning.
-	// This is critical for secondary devices.
-
-	lpCtx->bCanRender = FALSE;
-
-#ifdef _USE_GLD3_WGL
-	// Destroy the Mesa context
-	if (lpCtx->glBuffer)
-		_mesa_destroy_framebuffer(lpCtx->glBuffer);
-	if (lpCtx->glCtx)
-		_mesa_destroy_context(lpCtx->glCtx);
-	if (lpCtx->glVis)
-		_mesa_destroy_visual(lpCtx->glVis);
-
-	// Destroy driver data
-	_gldDriver.DestroyDrawable(lpCtx);
-#else
-	// Destroy the Mesa context
-	if (lpCtx->glBuffer)
-		(*mesaFuncs.gl_destroy_framebuffer)(lpCtx->glBuffer);
-	if (lpCtx->glCtx)
-		(*mesaFuncs.gl_destroy_context)(lpCtx->glCtx);
-	if (lpCtx->glVis)
-		(*mesaFuncs.gl_destroy_visual)(lpCtx->glVis);
-
-	RELEASE(lpCtx->m_pvbuf); // Release D3D vertex buffer
-	RELEASE(lpCtx->m_vbuf); // Release D3D vertex buffer
-
-	if (lpCtx->lpViewport3) {
-		if (lpCtx->lpDev3) IDirect3DDevice3_DeleteViewport(lpCtx->lpDev3, lpCtx->lpViewport3);
-		RELEASE(lpCtx->lpViewport3);
-		lpCtx->lpViewport3 = NULL;
-	}
-
-	RELEASE(lpCtx->lpDev3);
-	if (lpCtx->lpDepth4) {
-		if (lpCtx->lpBack4)
-			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpBack4, 0L, lpCtx->lpDepth4);
-		else
-			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpFront4, 0L, lpCtx->lpDepth4);
-		RELEASE(lpCtx->lpDepth4);
-		lpCtx->lpDepth4 = NULL;
-	}
-	RELEASE(lpCtx->lpBack4);
-	RELEASE(lpCtx->lpFront4);
-	else
-	if (lpCtx->bFullscreen) {
-		IDirectDraw4_RestoreDisplayMode(lpCtx->lpDD4);
-		IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, NULL, DDSCL_NORMAL);
-	}
-	RELEASE(lpCtx->lpD3D3);
-	RELEASE(lpCtx->lpDD4);
-	RELEASE(lpCtx->lpDD1);
-#endif // _USE_GLD3_WGL
-
-	lpCtx->bAllocated = FALSE;
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	return FALSE;
-
-#undef DDLOG_CRITICAL_OR_WARN
-}
-
-// ***********************************************************************
-
-HGLRC dglCreateContext(
-	HDC a,
-	const DGL_pixelFormat *lpPF)
-{
-	int i;
-	HGLRC				hGLRC;
-	DGL_ctx*			lpCtx;
-	static BOOL			bWarnOnce = TRUE;
-	DWORD				dwThreadId = GetCurrentThreadId();
-    char                szMsg[256];
-    HWND                hWnd;
-    LONG                lpfnWndProc;
-
-	// Validate license
-	if (!dglValidate())
-		return NULL;
-
-	// Is context state ready ?
-	if (!bContextReady)
-		return NULL;
-
-	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContext for HDC=%X, ThreadId=%X", a, dwThreadId);
-
-	// Find next free context.
-	// Also ensure that only one Fullscreen context is created at any one time.
-	hGLRC = 0; // Default to Not Found
-	for (i=0; i<DGL_MAX_CONTEXTS; i++) {
-		if (ctxlist[i].bAllocated) {
-			if (/*glb.bFullscreen && */ctxlist[i].bFullscreen)
-				break;
-		} else {
-			hGLRC = (HGLRC)(i+1);
-			break;
-		}
-	}
-
-	// Bail if no GLRC was found
-	if (!hGLRC)
-		return NULL;
-
-	// Set the context pointer
-	lpCtx = dglGetContextAddress(hGLRC);
-	// Make sure that context is zeroed before we do anything.
-	// MFC and C++ apps call wglCreateContext() and wglDeleteContext() multiple times,
-	// even though only one context is ever used by the app, so keep it clean. (DaveM)
-	ZeroMemory(lpCtx, sizeof(DGL_ctx));
-	lpCtx->bAllocated = TRUE;
-	// Flag that buffers need creating on next wglMakeCurrent call.
-	lpCtx->bHasBeenCurrent = FALSE;
-	lpCtx->lpPF = (DGL_pixelFormat *)lpPF;	// cache pixel format
-	lpCtx->bCanRender = FALSE;
-
-	// Create all the internal resources here, not in dglMakeCurrent().
-	// We do a re-size check in dglMakeCurrent in case of re-allocations. (DaveM)
-	// We now try context allocations twice, first with video memory,
-	// then again with system memory. This is similar to technique
-	// used for dglWglResizeBuffers(). (DaveM)
-	if (lpCtx->bHasBeenCurrent == FALSE) {
-		if (!dglCreateContextBuffers(a, lpCtx, FALSE)) {
-			if (glb.bMessageBoxWarnings && bWarnOnce && dwLogging) {
-				bWarnOnce = FALSE;
-                switch (nContextError) {
-                   case GLDERR_DDRAW: strcpy(szMsg, szDDrawWarning); break;
-                   case GLDERR_D3D: strcpy(szMsg, szD3DWarning); break;
-                   case GLDERR_MEM: strcpy(szMsg, szResourceWarning); break;
-                   case GLDERR_BPP: strcpy(szMsg, szBPPWarning); break;
-                   default: strcpy(szMsg, "");
-                }
-                if (strlen(szMsg))
-                    MessageBox(NULL, szMsg, "GLDirect", MB_OK | MB_ICONWARNING);
-			}
-            // Only need to try again if memory error
-            if (nContextError == GLDERR_MEM) {
-			    ddlogPrintf(DDLOG_WARN, "dglCreateContext failed 1st time with video memory");
-            }
-            else {
-			    ddlogPrintf(DDLOG_ERROR, "dglCreateContext failed");
-                return NULL;
-            }
-		}
-	}
-
-	// Now that we have a hWnd, we can intercept the WindowProc.
-    hWnd = lpCtx->hWnd;
-    if (hWnd) {
-		// Only hook individual window handler once if not hooked before.
-		lpfnWndProc = GetWindowLong(hWnd, GWL_WNDPROC);
-		if (lpfnWndProc != (LONG)dglWndProc) {
-			lpCtx->lpfnWndProc = lpfnWndProc;
-			SetWindowLong(hWnd, GWL_WNDPROC, (LONG)dglWndProc);
-			}
-        // Find the parent window of the app too.
-        if (glb.hWndActive == NULL) {
-            while (hWnd != NULL) {
-                glb.hWndActive = hWnd;
-                hWnd = GetParent(hWnd);
-            }
-            // Hook the parent window too.
-            lpfnWndProc = GetWindowLong(glb.hWndActive, GWL_WNDPROC);
-            if (glb.hWndActive == lpCtx->hWnd)
-                glb.lpfnWndProc = lpCtx->lpfnWndProc;
-            else if (lpfnWndProc != (LONG)dglWndProc)
-                glb.lpfnWndProc = lpfnWndProc;
-            if (glb.lpfnWndProc)
-                SetWindowLong(glb.hWndActive, GWL_WNDPROC, (LONG)dglWndProc);
-        }
-    }
-
-	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContext succeeded for HGLRC=%d", (int)hGLRC);
-
-	return hGLRC;
-}
-
-// ***********************************************************************
-// Make a DirectGL context current
-// Used by wgl functions and dgl functions
-BOOL dglMakeCurrent(
-	HDC a,
-	HGLRC b)
-{
-	int context;
-	DGL_ctx* lpCtx;
-	HWND hWnd;
-	BOOL bNeedResize = FALSE;
-	BOOL bWindowChanged, bContextChanged;
-	LPDIRECTDRAWCLIPPER	lpddClipper;
-	DWORD dwThreadId = GetCurrentThreadId();
-	LONG lpfnWndProc;
-
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-
-	// Is context state ready ?
-	if (!bContextReady)
-		return FALSE;
-
-	context = (int)b; // This is as a result of STRICT!
-	ddlogPrintf(DDLOG_SYSTEM, "dglMakeCurrent: HDC=%X, HGLRC=%d, ThreadId=%X", a, context, dwThreadId);
-
-	// If the HGLRC is NULL then make no context current;
-	// Ditto if the HDC is NULL either. (DaveM)
-	if (context == 0 || a == 0) {
-		// Corresponding Mesa operation
-#ifdef _USE_GLD3_WGL
-		_mesa_make_current(NULL, NULL);
-#else
-		(*mesaFuncs.gl_make_current)(NULL, NULL);
-#endif
-		dglSetCurrentContext(0);
-		return TRUE;
-	}
-
-	// Make sure the HGLRC is in range
-	if ((context > DGL_MAX_CONTEXTS) || (context < 0)) {
-		ddlogMessage(DDLOG_ERROR, "dglMakeCurrent: HGLRC out of range\n");
-		return FALSE;
-	}
-
-	// Find address of context and make sure that it has been allocated
-	lpCtx = dglGetContextAddress(b);
-	if (!lpCtx->bAllocated) {
-		ddlogMessage(DDLOG_ERROR, "dglMakeCurrent: Context not allocated\n");
-//		return FALSE;
-		return TRUE; // HACK: Shuts up "WebLab Viewer Pro". KeithH
-	}
-
-#ifdef GLD_THREADS
-	// Serialize access to DirectDraw or DDS operations
-	if (glb.bMultiThreaded)
-		EnterCriticalSection(&CriticalSection);
-#endif
-
-	// Check if window has changed
-	hWnd = (a != lpCtx->hDC) ? WindowFromDC(a) : lpCtx->hWnd;
-	bWindowChanged = (hWnd != lpCtx->hWnd) ? TRUE : FALSE;
-	bContextChanged = (b != dglGetCurrentContext()) ? TRUE : FALSE;
-
-	// If the window has changed, make sure the clipper is updated. (DaveM)
-	if (glb.bDirectDrawPersistant && !lpCtx->bFullscreen && (bWindowChanged || bContextChanged)) {
-		lpCtx->hWnd = hWnd;
-#ifndef _USE_GLD3_WGL
-		IDirectDrawSurface4_GetClipper(lpCtx->lpFront4, &lpddClipper);
-		IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);
-		IDirectDrawClipper_Release(lpddClipper);
-#endif // _USE_GLD3_WGL
-	}
-
-	// Make sure hDC and hWnd is current. (DaveM)
-	// Obtain the dimensions of the rendering window
-	lpCtx->hDC = a; // Cache DC
-	lpCtx->hWnd = hWnd;
-	hWndLastActive = hWnd;
-
-	// Check for non-window DC = memory DC ?
-	if (hWnd == NULL) {
-		if (GetClipBox(a, &lpCtx->rcScreenRect) == ERROR) {
-			ddlogMessage(DDLOG_WARN, "GetClipBox failed in dglMakeCurrent\n");
-			SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);
-		}
-	}
-	else if (!GetClientRect(lpCtx->hWnd, &lpCtx->rcScreenRect)) {
-		ddlogMessage(DDLOG_WARN, "GetClientRect failed in dglMakeCurrent\n");
-		SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);
-	}
-	// Check if buffers need to be re-sized;
-	// If so, wait until Mesa GL stuff is setup before re-sizing;
-	if (lpCtx->dwWidth != lpCtx->rcScreenRect.right - lpCtx->rcScreenRect.left ||
-		lpCtx->dwHeight != lpCtx->rcScreenRect.bottom - lpCtx->rcScreenRect.top)
-		bNeedResize = TRUE;
-
-	// Now we can update our globals
-	dglSetCurrentContext(b);
-
-	// Corresponding Mesa operation
-#ifdef _USE_GLD3_WGL
-	_mesa_make_current(lpCtx->glCtx, lpCtx->glBuffer);
-	lpCtx->glCtx->Driver.UpdateState(lpCtx->glCtx, _NEW_ALL);
-	if (bNeedResize) {
-		// Resize buffers (Note Mesa GL needs to be setup beforehand);
-		// Resize Mesa internal buffer too via glViewport() command,
-		// which subsequently calls dglWglResizeBuffers() too.
-		lpCtx->glCtx->Driver.Viewport(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-		lpCtx->bHasBeenCurrent = TRUE;
-	}
-#else
-	(*mesaFuncs.gl_make_current)(lpCtx->glCtx, lpCtx->glBuffer);
-
-	dglSetupDDPointers(lpCtx->glCtx);
-
-	// Insure DirectDraw surfaces fit current window DC
-	if (bNeedResize) {
-		// Resize buffers (Note Mesa GL needs to be setup beforehand);
-		// Resize Mesa internal buffer too via glViewport() command,
-		// which subsequently calls dglWglResizeBuffers() too.
-		(*mesaFuncs.gl_Viewport)(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-		lpCtx->bHasBeenCurrent = TRUE;
-	}
-#endif // _USE_GLD3_WGL
-	ddlogPrintf(DDLOG_SYSTEM, "dglMakeCurrent: width = %d, height = %d", lpCtx->dwWidth, lpCtx->dwHeight);
-
-	// We have to clear D3D back buffer and render state if emulated front buffering
-	// for different window (but not context) like in Solid Edge.
-	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers
-		&& (bWindowChanged /* || bContextChanged */) && lpCtx->EmulateSingle) {
-#ifdef _USE_GLD3_WGL
-//		IDirect3DDevice8_EndScene(lpCtx->pDev);
-//		lpCtx->bSceneStarted = FALSE;
-		lpCtx->glCtx->Driver.Clear(lpCtx->glCtx, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,
-			GL_TRUE, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-#else
-		IDirect3DDevice3_EndScene(lpCtx->lpDev3);
-		lpCtx->bSceneStarted = FALSE;
-		dglClearD3D(lpCtx->glCtx, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,
-			GL_TRUE, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-#endif // _USE_GLD3_WGL
-	}
-
-	// The first time we call MakeCurrent we set the initial viewport size
-	if (lpCtx->bHasBeenCurrent == FALSE)
-#ifdef _USE_GLD3_WGL
-		lpCtx->glCtx->Driver.Viewport(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-#else
-		(*mesaFuncs.gl_Viewport)(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);
-#endif // _USE_GLD3_WGL
-	lpCtx->bHasBeenCurrent = TRUE;
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	return TRUE;
-}
-
-// ***********************************************************************
-
-BOOL dglDeleteContext(
-	HGLRC a)
-{
-	DGL_ctx* lpCtx;
-	DWORD dwThreadId = GetCurrentThreadId();
-    char argstr[256];
-
-#if 0	// We have enough trouble throwing exceptions as it is... (DaveM)
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-#endif
-
-	// Is context state ready ?
-	if (!bContextReady)
-		return FALSE;
-
-	ddlogPrintf(DDLOG_SYSTEM, "dglDeleteContext: Deleting context HGLRC=%d, ThreadId=%X", (int)a, dwThreadId);
-
-	// Make sure the HGLRC is in range
-	if (((int) a> DGL_MAX_CONTEXTS) || ((int)a < 0)) {
-		ddlogMessage(DDLOG_ERROR, "dglDeleteCurrent: HGLRC out of range\n");
-		return FALSE;
-	}
-
-	// Make sure context is valid
-	lpCtx = dglGetContextAddress(a);
-	if (!lpCtx->bAllocated) {
-		ddlogPrintf(DDLOG_WARN, "Tried to delete unallocated context HGLRC=%d", (int)a);
-//		return FALSE;
-		return TRUE; // HACK: Shuts up "WebLab Viewer Pro". KeithH
-	}
-
-	// Make sure context is de-activated
-	if (a == dglGetCurrentContext()) {
-		ddlogPrintf(DDLOG_WARN, "dglDeleteContext: context HGLRC=%d still active", (int)a);
-		dglMakeCurrent(NULL, NULL);
-	}
-
-#ifdef GLD_THREADS
-	// Serialize access to DirectDraw or DDS operations
-	if (glb.bMultiThreaded)
-		EnterCriticalSection(&CriticalSection);
-#endif
-
-	// We are about to destroy all Direct3D objects.
-	// Therefore we must disable rendering
-	lpCtx->bCanRender = FALSE;
-
-	// This exception handler was installed to catch some
-	// particularly nasty apps. Console apps that call exit()
-	// fall into this catagory (i.e. Win32 Glut).
-
-    // VC cannot successfully implement multiple exception handlers
-    // if more than one exception occurs. Therefore reverting back to
-    // single exception handler as Keith originally had it. (DaveM)
-
-#define WARN_MESSAGE(p) strcpy(argstr, (#p));
-#define SAFE_RELEASE(p) WARN_MESSAGE(p); RELEASE(p);
-
-__try {
-#ifdef _USE_GLD3_WGL
-    WARN_MESSAGE(gl_destroy_framebuffer);
-	if (lpCtx->glBuffer)
-		_mesa_destroy_framebuffer(lpCtx->glBuffer);
-    WARN_MESSAGE(gl_destroy_context);
-	if (lpCtx->glCtx)
-		_mesa_destroy_context(lpCtx->glCtx);
-    WARN_MESSAGE(gl_destroy_visual);
-	if (lpCtx->glVis)
-		_mesa_destroy_visual(lpCtx->glVis);
-
-	_gldDriver.DestroyDrawable(lpCtx);
-#else
-	// Destroy the Mesa context
-    WARN_MESSAGE(gl_destroy_framebuffer);
-	if (lpCtx->glBuffer)
-		(*mesaFuncs.gl_destroy_framebuffer)(lpCtx->glBuffer);
-    WARN_MESSAGE(gl_destroy_context);
-	if (lpCtx->glCtx)
-		(*mesaFuncs.gl_destroy_context)(lpCtx->glCtx);
-    WARN_MESSAGE(gl_destroy_visual);
-	if (lpCtx->glVis)
-		(*mesaFuncs.gl_destroy_visual)(lpCtx->glVis);
-
-	SAFE_RELEASE(lpCtx->m_pvbuf); // release D3D vertex buffer
-	SAFE_RELEASE(lpCtx->m_vbuf); // release D3D vertex buffer
-
-	// Delete the global palette
-	SAFE_RELEASE(lpCtx->lpGlobalPalette);
-
-	// Clean up.
-	if (lpCtx->lpViewport3) {
-		if (lpCtx->lpDev3) IDirect3DDevice3_DeleteViewport(lpCtx->lpDev3, lpCtx->lpViewport3);
-		SAFE_RELEASE(lpCtx->lpViewport3);
-		lpCtx->lpViewport3 = NULL;
-	}
-
-	SAFE_RELEASE(lpCtx->lpDev3);
-	if (lpCtx->lpDepth4) {
-		if (lpCtx->lpBack4)
-			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpBack4, 0L, lpCtx->lpDepth4);
-		else
-			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpFront4, 0L, lpCtx->lpDepth4);
-		SAFE_RELEASE(lpCtx->lpDepth4);
-		lpCtx->lpDepth4 = NULL;
-	}
-	SAFE_RELEASE(lpCtx->lpBack4);
-	SAFE_RELEASE(lpCtx->lpFront4);
-	if (lpCtx->bFullscreen) {
-		IDirectDraw4_RestoreDisplayMode(lpCtx->lpDD4);
-		IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, NULL, DDSCL_NORMAL);
-	}
-	SAFE_RELEASE(lpCtx->lpD3D3);
-	SAFE_RELEASE(lpCtx->lpDD4);
-	SAFE_RELEASE(lpCtx->lpDD1);
-#endif // _ULSE_GLD3_WGL
-
-}
-__except(EXCEPTION_EXECUTE_HANDLER) {
-    ddlogPrintf(DDLOG_WARN, "Exception raised in dglDeleteContext: %s", argstr);
-}
-
-	// Restore the window message handler because this context may be used
-	// again by another window with a *different* message handler. (DaveM)
-	if (lpCtx->lpfnWndProc) {
-		SetWindowLong(lpCtx->hWnd, GWL_WNDPROC, (LONG)lpCtx->lpfnWndProc);
-		lpCtx->lpfnWndProc = (LONG)NULL;
-		}
-
-	lpCtx->bAllocated = FALSE; // This context is now free for use
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-	return TRUE;
-}
-
-// ***********************************************************************
-
-BOOL dglSwapBuffers(
-	HDC hDC)
-{
-	RECT		rSrcRect;	// Source rectangle
-	RECT		rDstRect;	// Destination rectangle
-	POINT		pt;
-	HRESULT		hResult;
-
-	DDBLTFX		bltFX;
-	DWORD		dwBlitFlags;
-	DDBLTFX		*lpBltFX;
-
-//	DWORD		dwThreadId = GetCurrentThreadId();
-	HGLRC		hGLRC = dglGetCurrentContext();
-	DGL_ctx		*lpCtx = dglGetContextAddress(hGLRC);
-	HWND		hWnd;
-
-	HDC 		hDCAux;		// for memory DC
-	int 		x,y,w,h;	// for memory DC BitBlt
-
-#if 0	// Perhaps not a good idea. Called too often. KH
-	// Validate license
-	if (!dglValidate())
-		return FALSE;
-#endif
-
-	if (!lpCtx) {
-		return TRUE; //FALSE; // No current context
-	}
-
-	if (!lpCtx->bCanRender) {
-		// Don't return false else some apps will bail.
-		return TRUE;
-	}
-
-	hWnd = lpCtx->hWnd;
-	if (hDC != lpCtx->hDC) {
-		ddlogPrintf(DDLOG_WARN, "dglSwapBuffers: HDC=%X does not match HDC=%X for HGLRC=%d", hDC, lpCtx->hDC, hGLRC);
-		hWnd = WindowFromDC(hDC);
-	}
-
-#ifndef _USE_GLD3_WGL
-	// Ensure that the surfaces exist before we tell
-	// the device to render to them.
-	IDirectDraw4_RestoreAllSurfaces(lpCtx->lpDD4);
-
-	// Make sure that the vertex caches have been emptied
-//	dglStateChange(lpCtx);
-
-	// Some OpenGL programs don't issue a glFinish - check for it here.
-	if (lpCtx->bSceneStarted) {
-		IDirect3DDevice3_EndScene(lpCtx->lpDev3);
-		lpCtx->bSceneStarted = FALSE;
-	}
-#endif
-
-#if 0
-	// If the calling app is not active then we don't need to Blit/Flip.
-	// We can therefore simply return TRUE.
-	if (!glb.bAppActive)
-		return TRUE;
-	// Addendum: This is WRONG! We should bail if the app is *minimized*,
-	//           not merely if the app is just plain 'not active'.
-	//           KeithH, 27/May/2000.
-#endif
-
-	// Check for non-window DC = memory DC ?
-	if (hWnd == NULL) {
-		if (GetClipBox(hDC, &rSrcRect) == ERROR)
-			return TRUE;
-		// Use GDI BitBlt instead from compatible DirectDraw DC
-		x = rSrcRect.left;
-		y = rSrcRect.top;
-		w = rSrcRect.right - rSrcRect.left;
-		h = rSrcRect.bottom - rSrcRect.top;
-
-		// Ack. DX8 does not have a GetDC() function...
-                // TODO: Defer to DX7 or DX9 drivers... (DaveM)
-		return TRUE;
-	}
-
-	// Bail if window client region is not drawable, like in Solid Edge
-	if (!IsWindow(hWnd) /* || !IsWindowVisible(hWnd) */ || !GetClientRect(hWnd, &rSrcRect))
-		return TRUE;
-
-#ifdef GLD_THREADS
-	// Serialize access to DirectDraw or DDS operations
-	if (glb.bMultiThreaded)
-		EnterCriticalSection(&CriticalSection);
-#endif
-
-#ifdef _USE_GLD3_WGL
-	// Notify Mesa of impending swap, so Mesa can flush internal buffers.
-	_mesa_notifySwapBuffers(lpCtx->glCtx);
-	// Now perform driver buffer swap
-	_gldDriver.SwapBuffers(lpCtx, hDC, hWnd);
-#else
-	if (lpCtx->bFullscreen) {
-		// Sync with retrace if required
-		if (glb.bWaitForRetrace) {
-			IDirectDraw4_WaitForVerticalBlank(
-				lpCtx->lpDD4,
-				DDWAITVB_BLOCKBEGIN,
-				0);
-		}
-
-		// Perform the fullscreen flip
-		TRY(IDirectDrawSurface4_Flip(
-			lpCtx->lpFront4,
-			NULL,
-			DDFLIP_WAIT),
-			"dglSwapBuffers: Flip");
-	} else {
-		// Calculate current window position and size
-		pt.x = pt.y = 0;
-		ClientToScreen(hWnd, &pt);
-		GetClientRect(hWnd, &rDstRect);
-		if (rDstRect.right > lpCtx->dwModeWidth)
-			rDstRect.right = lpCtx->dwModeWidth;
-		if (rDstRect.bottom > lpCtx->dwModeHeight)
-			rDstRect.bottom = lpCtx->dwModeHeight;
-		OffsetRect(&rDstRect, pt.x, pt.y);
-		rSrcRect.left = rSrcRect.top = 0;
-		rSrcRect.right = lpCtx->dwWidth;
-		rSrcRect.bottom = lpCtx->dwHeight;
-		if (rSrcRect.right > lpCtx->dwModeWidth)
-			rSrcRect.right = lpCtx->dwModeWidth;
-		if (rSrcRect.bottom > lpCtx->dwModeHeight)
-			rSrcRect.bottom = lpCtx->dwModeHeight;
-
-		if (glb.bWaitForRetrace) {
-			// Sync the blit to the vertical retrace
-			ZeroMemory(&bltFX, sizeof(bltFX));
-			bltFX.dwSize = sizeof(bltFX);
-			bltFX.dwDDFX = DDBLTFX_NOTEARING;
-			dwBlitFlags = DDBLT_WAIT | DDBLT_DDFX;
-			lpBltFX = &bltFX;
-		} else {
-			dwBlitFlags = DDBLT_WAIT;
-			lpBltFX = NULL;
-		}
-
-		// Perform the actual blit
-		TRY(IDirectDrawSurface4_Blt(
-			lpCtx->lpFront4,
-			&rDstRect,
-			lpCtx->lpBack4, // Blit source
-			&rSrcRect,
-			dwBlitFlags,
-			lpBltFX),
-			"dglSwapBuffers: Blt");
-	}
-#endif // _USE_GLD3_WGL
-
-#ifdef GLD_THREADS
-	// Release serialized access
-	if (glb.bMultiThreaded)
-		LeaveCriticalSection(&CriticalSection);
-#endif
-
-    // TODO: Re-instate rendering bitmap snapshot feature??? (DaveM)
-
-	// Render frame is completed
-	ValidateRect(hWnd, NULL);
-	lpCtx->bFrameStarted = FALSE;
-
-	return TRUE;
-}
-
-// ***********************************************************************
+/****************************************************************************

+*

+*                        Mesa 3-D graphics library

+*                        Direct3D Driver Interface

+*

+*  ========================================================================

+*

+*   Copyright (C) 1991-2004 SciTech Software, Inc. 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, sublicense,

+*   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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+*   SCITECH SOFTWARE INC 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.

+*

+*  ======================================================================

+*

+* Language:     ANSI C

+* Environment:  Windows 9x (Win32)

+*

+* Description:  Context handling.

+*

+****************************************************************************/

+

+#include "dglcontext.h"

+

+// Get compile errors without this. KeithH

+//#include "scitech.h"	// ibool, etc.

+

+#ifdef _USE_GLD3_WGL

+#include "gld_driver.h"

+

+extern void _gld_mesa_warning(struct gl_context *, char *);

+extern void _gld_mesa_fatal(struct gl_context *, char *);

+#endif // _USE_GLD3_WGL

+

+// TODO: Clean out old DX6-specific code from GLD 2.x CAD driver

+// if it is no longer being built as part of GLDirect. (DaveM)

+

+// ***********************************************************************

+

+#define GLDERR_NONE     0

+#define GLDERR_MEM      1

+#define GLDERR_DDRAW    2

+#define GLDERR_D3D      3

+#define GLDERR_BPP      4

+

+char szResourceWarning[] =

+"GLDirect does not have enough video memory resources\n"

+"to support the requested OpenGL rendering context.\n\n"

+"You may have to reduce the current display resolution\n"

+"to obtain satisfactory OpenGL performance.\n";

+

+char szDDrawWarning[] =

+"GLDirect is unable to initialize DirectDraw for the\n"

+"requested OpenGL rendering context.\n\n"

+"You will have to check the DirectX control panel\n"

+"for further information.\n";

+

+char szD3DWarning[] =

+"GLDirect is unable to initialize Direct3D for the\n"

+"requested OpenGL rendering context.\n\n"

+"You may have to change the display mode resolution\n"

+"color depth or check the DirectX control panel for\n"

+"further information.\n";

+

+char szBPPWarning[] =

+"GLDirect is unable to use the selected color depth for\n"

+"the requested OpenGL rendering context.\n\n"

+"You will have to change the display mode resolution\n"

+"color depth with the Display Settings control panel.\n";

+

+int nContextError = GLDERR_NONE;

+

+// ***********************************************************************

+

+#define VENDORID_ATI 0x1002

+

+static DWORD devATIRagePro[] = {

+	0x4742, // 3D RAGE PRO BGA AGP 1X/2X

+	0x4744, // 3D RAGE PRO BGA AGP 1X only

+	0x4749, // 3D RAGE PRO BGA PCI 33 MHz

+	0x4750, // 3D RAGE PRO PQFP PCI 33 MHz

+	0x4751, // 3D RAGE PRO PQFP PCI 33 MHz limited 3D

+	0x4C42, // 3D RAGE LT PRO BGA-312 AGP 133 MHz

+	0x4C44, // 3D RAGE LT PRO BGA-312 AGP 66 MHz

+	0x4C49, // 3D RAGE LT PRO BGA-312 PCI 33 MHz

+	0x4C50, // 3D RAGE LT PRO BGA-256 PCI 33 MHz

+	0x4C51, // 3D RAGE LT PRO BGA-256 PCI 33 MHz limited 3D

+};

+

+static DWORD devATIRageIIplus[] = {

+	0x4755, // 3D RAGE II+

+	0x4756, // 3D RAGE IIC PQFP PCI

+	0x4757, // 3D RAGE IIC BGA AGP

+	0x475A, // 3D RAGE IIC PQFP AGP

+	0x4C47, // 3D RAGE LT-G

+};

+

+// ***********************************************************************

+

+#ifndef _USE_GLD3_WGL

+extern DGL_mesaFuncs mesaFuncs;

+#endif

+

+extern DWORD dwLogging;

+

+#ifdef GLD_THREADS

+#pragma message("compiling DGLCONTEXT.C vars for multi-threaded support")

+CRITICAL_SECTION CriticalSection;		// for serialized access

+DWORD		dwTLSCurrentContext = 0xFFFFFFFF;	// TLS index for current context

+DWORD		dwTLSPixelFormat = 0xFFFFFFFF;		// TLS index for current pixel format

+#endif

+HGLRC		iCurrentContext = 0;		// Index of current context (static)

+BOOL		bContextReady = FALSE;		// Context state ready ?

+

+DGL_ctx		ctxlist[DGL_MAX_CONTEXTS];	// Context list

+

+// ***********************************************************************

+

+static BOOL bHaveWin95 = FALSE;

+static BOOL bHaveWinNT = FALSE;

+static BOOL bHaveWin2K = FALSE;

+

+/****************************************************************************

+REMARKS:

+Detect the installed OS type.

+****************************************************************************/

+static void DetectOS(void)

+{

+    OSVERSIONINFO VersionInformation;

+    LPOSVERSIONINFO lpVersionInformation = &VersionInformation;

+

+    VersionInformation.dwOSVersionInfoSize = sizeof(VersionInformation);

+

+	GetVersionEx(lpVersionInformation);

+

+    switch (VersionInformation.dwPlatformId) {

+    	case VER_PLATFORM_WIN32_WINDOWS:

+			bHaveWin95 = TRUE;

+			bHaveWinNT = FALSE;

+			bHaveWin2K = FALSE;

+            break;

+    	case VER_PLATFORM_WIN32_NT:

+			bHaveWin95 = FALSE;

+			if (VersionInformation.dwMajorVersion <= 4) {

+				bHaveWinNT = TRUE;

+				bHaveWin2K = FALSE;

+                }

+            else {

+				bHaveWinNT = FALSE;

+				bHaveWin2K = TRUE;

+                }

+			break;

+		case VER_PLATFORM_WIN32s:

+			bHaveWin95 = FALSE;

+			bHaveWinNT = FALSE;

+			bHaveWin2K = FALSE;

+			break;

+        }

+}

+

+// ***********************************************************************

+

+HWND hWndEvent = NULL;					// event monitor window

+HWND hWndLastActive = NULL;				// last active client window

+LONG __stdcall GLD_EventWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);

+

+// ***********************************************************************

+

+// Checks if the HGLRC is valid in range of context list.

+BOOL dglIsValidContext(

+	HGLRC a)

+{

+	return ((int)a > 0 && (int)a <= DGL_MAX_CONTEXTS);

+}

+

+// ***********************************************************************

+

+// Convert a HGLRC to a pointer into the context list.

+DGL_ctx* dglGetContextAddress(

+	const HGLRC a)

+{

+	if (dglIsValidContext(a))

+		return &ctxlist[(int)a-1];

+	return NULL;

+}

+

+// ***********************************************************************

+

+// Return the current HGLRC (however it may be stored for multi-threading).

+HGLRC dglGetCurrentContext(void)

+{

+#ifdef GLD_THREADS

+	HGLRC hGLRC;

+	// load from thread-specific instance

+	if (glb.bMultiThreaded) {

+		// protect against calls from arbitrary threads

+		__try {

+			hGLRC = (HGLRC)TlsGetValue(dwTLSCurrentContext);

+		}

+		__except(EXCEPTION_EXECUTE_HANDLER) {

+			hGLRC = iCurrentContext;

+		}

+	}

+	// load from global static var

+	else {

+		hGLRC = iCurrentContext;

+	}

+	return hGLRC;

+#else

+	return iCurrentContext;

+#endif

+}

+

+// ***********************************************************************

+

+// Set the current HGLRC (however it may be stored for multi-threading).

+void dglSetCurrentContext(HGLRC hGLRC)

+{

+#ifdef GLD_THREADS

+	// store in thread-specific instance

+	if (glb.bMultiThreaded) {

+		// protect against calls from arbitrary threads

+		__try {

+			TlsSetValue(dwTLSCurrentContext, (LPVOID)hGLRC);

+		}

+		__except(EXCEPTION_EXECUTE_HANDLER) {

+			iCurrentContext = hGLRC;

+		}

+	}

+	// store in global static var

+	else {

+		iCurrentContext = hGLRC;

+	}

+#else

+	iCurrentContext = hGLRC;

+#endif

+}

+

+// ***********************************************************************

+

+// Return the current HDC only for a currently active HGLRC.

+HDC dglGetCurrentDC(void)

+{

+	HGLRC hGLRC;

+	DGL_ctx* lpCtx;

+

+	hGLRC = dglGetCurrentContext();

+	if (hGLRC) {

+		lpCtx = dglGetContextAddress(hGLRC);

+		return lpCtx->hDC;

+	}

+	return 0;

+}

+

+// ***********************************************************************

+

+void dglInitContextState()

+{

+	int i;

+	WNDCLASS wc;

+

+#ifdef GLD_THREADS

+	// Allocate thread local storage indexes for current context and pixel format

+	dwTLSCurrentContext = TlsAlloc();

+	dwTLSPixelFormat = TlsAlloc();

+#endif

+

+	dglSetCurrentContext(NULL); // No current rendering context

+

+	 // Clear all context data

+	ZeroMemory(ctxlist, sizeof(ctxlist[0]) * DGL_MAX_CONTEXTS);

+

+	for (i=0; i<DGL_MAX_CONTEXTS; i++)

+		ctxlist[i].bAllocated = FALSE; // Flag context as unused

+

+	// This section of code crashes the dll in circumstances where the app

+	// creates and destroys contexts.

+/*

+	// Register the class for our event monitor window

+	wc.style = 0;

+	wc.lpfnWndProc = GLD_EventWndProc;

+	wc.cbClsExtra = 0;

+	wc.cbWndExtra = 0;

+	wc.hInstance = GetModuleHandle(NULL);

+	wc.hIcon = LoadIcon(GetModuleHandle(NULL), IDI_APPLICATION);

+	wc.hCursor = LoadCursor(NULL, IDC_ARROW);

+	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

+	wc.lpszMenuName = NULL;

+	wc.lpszClassName = "GLDIRECT";

+	RegisterClass(&wc);

+

+	// Create the non-visible window to monitor all broadcast messages

+	hWndEvent = CreateWindowEx(

+		WS_EX_TOOLWINDOW,"GLDIRECT","GLDIRECT",WS_POPUP,

+		0,0,0,0,

+		NULL,NULL,GetModuleHandle(NULL),NULL);

+*/

+

+#ifdef GLD_THREADS

+	// Create a critical section object for serializing access to

+	// DirectDraw and DDStereo create/destroy functions in multiple threads

+	if (glb.bMultiThreaded)

+		InitializeCriticalSection(&CriticalSection);

+#endif

+

+	// Context state is now initialized and ready

+	bContextReady = TRUE;

+}

+

+// ***********************************************************************

+

+void dglDeleteContextState()

+{

+	int i;

+	static BOOL bOnceIsEnough = FALSE;

+

+	// Only call once, from either DGL_exitDriver(), or DLL_PROCESS_DETACH

+	if (bOnceIsEnough)

+		return;

+	bOnceIsEnough = TRUE;

+

+	for (i=0; i<DGL_MAX_CONTEXTS; i++) {

+		if (ctxlist[i].bAllocated == TRUE) {

+			ddlogPrintf(DDLOG_WARN, "** Context %i not deleted - cleaning up.", (i+1));

+			dglDeleteContext((HGLRC)(i+1));

+		}

+	}

+

+	// Context state is no longer ready

+	bContextReady = FALSE;

+

+    // If executed when DLL unloads, DDraw objects may be invalid.

+    // So catch any page faults with this exception handler.

+__try {

+

+	// Release final DirectDraw interfaces

+	if (glb.bDirectDrawPersistant) {

+//		RELEASE(glb.lpGlobalPalette);

+//		RELEASE(glb.lpDepth4);

+//		RELEASE(glb.lpBack4);

+//		RELEASE(glb.lpPrimary4);

+//	    RELEASE(glb.lpDD4);

+    }

+}

+__except(EXCEPTION_EXECUTE_HANDLER) {

+    ddlogPrintf(DDLOG_WARN, "Exception raised in dglDeleteContextState.");

+}

+

+	// Destroy our event monitor window

+	if (hWndEvent) {

+		DestroyWindow(hWndEvent);

+		hWndEvent = hWndLastActive = NULL;

+	}

+

+#ifdef GLD_THREADS

+	// Destroy the critical section object

+	if (glb.bMultiThreaded)

+		DeleteCriticalSection(&CriticalSection);

+

+	// Release thread local storage indexes for current HGLRC and pixel format

+	TlsFree(dwTLSPixelFormat);

+	TlsFree(dwTLSCurrentContext);

+#endif

+}

+

+// ***********************************************************************

+

+// Application Window message handler interception

+static LONG __stdcall dglWndProc(

+	HWND hwnd,

+	UINT msg,

+	WPARAM wParam,

+	LPARAM lParam)

+{

+	DGL_ctx* 	lpCtx = NULL;

+	LONG 		lpfnWndProc = 0L;

+	int  		i;

+	HGLRC 		hGLRC;

+	RECT 		rect;

+	PAINTSTRUCT	ps;

+    BOOL        bQuit = FALSE;

+    BOOL        bMain = FALSE;

+    LONG        rc;

+

+    // Get the window's message handler *before* it is unhooked in WM_DESTROY

+

+    // Is this the main window?

+    if (hwnd == glb.hWndActive) {

+        bMain = TRUE;

+        lpfnWndProc = glb.lpfnWndProc;

+    }

+    // Search for DGL context matching window handle

+    for (i=0; i<DGL_MAX_CONTEXTS; i++) {

+	    if (ctxlist[i].hWnd == hwnd) {

+	        lpCtx = &ctxlist[i];

+	        lpfnWndProc = lpCtx->lpfnWndProc;

+		    break;

+        }

+    }

+	// Not one of ours...

+	if (!lpfnWndProc)

+	    return DefWindowProc(hwnd, msg, wParam, lParam);

+

+    // Intercept messages amd process *before* passing on to window

+	switch (msg) {

+#ifdef _USE_GLD3_WGL

+	case WM_DISPLAYCHANGE:

+		glb.bPixelformatsDirty = TRUE;

+		break;

+#endif

+	case WM_ACTIVATEAPP:

+		glb.bAppActive = (BOOL)wParam;

+		ddlogPrintf(DDLOG_INFO, "Calling app has been %s", glb.bAppActive ? "activated" : "de-activated");

+		break;

+	case WM_ERASEBKGND:

+		// Eat the GDI erase event for the GL window

+        if (!lpCtx || !lpCtx->bHasBeenCurrent)

+            break;

+		lpCtx->bGDIEraseBkgnd = TRUE;

+		return TRUE;

+	case WM_PAINT:

+		// Eat the invalidated update region if render scene is in progress

+        if (!lpCtx || !lpCtx->bHasBeenCurrent)

+            break;

+		if (lpCtx->bFrameStarted) {

+			if (GetUpdateRect(hwnd, &rect, FALSE)) {

+				BeginPaint(hwnd, &ps);

+				EndPaint(hwnd, &ps);

+				ValidateRect(hwnd, &rect);

+				return TRUE;

+				}

+			}

+		break;

+	}

+	// Call the appropriate window message handler

+	rc = CallWindowProc((WNDPROC)lpfnWndProc, hwnd, msg, wParam, lParam);

+

+    // Intercept messages and process *after* passing on to window

+	switch (msg) {

+    case WM_QUIT:

+	case WM_DESTROY:

+        bQuit = TRUE;

+		if (lpCtx && lpCtx->bAllocated) {

+			ddlogPrintf(DDLOG_WARN, "WM_DESTROY detected for HWND=%X, HDC=%X, HGLRC=%d", hwnd, lpCtx->hDC, i+1);

+			dglDeleteContext((HGLRC)(i+1));

+		}

+		break;

+#if 0

+	case WM_SIZE:

+		// Resize surfaces to fit window but not viewport (in case app did not bother)

+        if (!lpCtx || !lpCtx->bHasBeenCurrent)

+            break;

+		w = LOWORD(lParam);

+		h = HIWORD(lParam);

+		if (lpCtx->dwWidth < w || lpCtx->dwHeight < h) {

+			if (!dglWglResizeBuffers(lpCtx->glCtx, TRUE))

+                 dglWglResizeBuffers(lpCtx->glCtx, FALSE);

+        }

+		break;

+#endif

+    }

+

+    // If the main window is quitting, then so should we...

+    if (bMain && bQuit) {

+		ddlogPrintf(DDLOG_SYSTEM, "shutting down after WM_DESTROY detected for main HWND=%X", hwnd);

+        dglDeleteContextState();

+        dglExitDriver();

+    }

+

+    return rc;

+}

+

+// ***********************************************************************

+

+// Driver Window message handler

+static LONG __stdcall GLD_EventWndProc(

+	HWND hwnd,

+	UINT msg,

+	WPARAM wParam,

+	LPARAM lParam)

+{

+	switch (msg) {

+        // May be sent by splash screen dialog on exit

+        case WM_ACTIVATE:

+            if (LOWORD(wParam) == WA_ACTIVE && glb.hWndActive) {

+                SetForegroundWindow(glb.hWndActive);

+                return 0;

+                }

+            break;

+	}

+	return DefWindowProc(hwnd, msg, wParam, lParam);

+}

+

+// ***********************************************************************

+

+// Intercepted Keyboard handler for detecting hot keys.

+LRESULT CALLBACK dglKeyProc(

+	int code,

+	WPARAM wParam,

+	LPARAM lParam)

+{

+	HWND hWnd, hWndFrame;

+	HGLRC hGLRC = NULL;

+	DGL_ctx* lpCtx = NULL;

+	int cmd = 0, dx1 = 0, dx2 = 0, i;

+	static BOOL bAltPressed = FALSE;

+	static BOOL bCtrlPressed = FALSE;

+	static BOOL bShiftPressed = FALSE;

+    RECT r, rf, rc;

+    POINT pt;

+    BOOL bForceReshape = FALSE;

+

+	return CallNextHookEx(hKeyHook, code, wParam, lParam);

+}

+

+// ***********************************************************************

+

+HWND hWndMatch;

+

+// Window handle enumeration procedure.

+BOOL CALLBACK dglEnumChildProc(

+    HWND hWnd,

+    LPARAM lParam)

+{

+    RECT rect;

+

+    // Find window handle with matching client rect.

+    GetClientRect(hWnd, &rect);

+    if (EqualRect(&rect, (RECT*)lParam)) {

+        hWndMatch = hWnd;

+        return FALSE;

+        }

+    // Continue with next child window.

+    return TRUE;

+}

+

+// ***********************************************************************

+

+// Find window handle with matching client rect.

+HWND dglFindWindowRect(

+    RECT* pRect)

+{

+    hWndMatch = NULL;

+    EnumChildWindows(GetForegroundWindow(), dglEnumChildProc, (LPARAM)pRect);

+    return hWndMatch;

+}

+

+// ***********************************************************************

+#ifndef _USE_GLD3_WGL

+void dglChooseDisplayMode(

+	DGL_ctx *lpCtx)

+{

+	// Note: Choose an exact match if possible.

+

+	int				i;

+	DWORD			area;

+	DWORD			bestarea;

+	DDSURFACEDESC2	*lpDDSD		= NULL;	// Mode list pointer

+	DDSURFACEDESC2	*lpBestDDSD = NULL;	// Pointer to best

+

+	lpDDSD = glb.lpDisplayModes;

+	for (i=0; i<glb.nDisplayModeCount; i++, lpDDSD++) {

+		if ((lpDDSD->dwWidth == lpCtx->dwWidth) &&

+			(lpDDSD->dwHeight == lpCtx->dwHeight))

+			goto matched; // Mode has been exactly matched

+		// Choose modes that are larger in both dimensions than

+		// the window, but smaller in area than the current best.

+		if ( (lpDDSD->dwWidth >= lpCtx->dwWidth) &&

+			 (lpDDSD->dwHeight >= lpCtx->dwHeight))

+		{

+			if (lpBestDDSD == NULL) {

+				lpBestDDSD = lpDDSD;

+				bestarea = lpDDSD->dwWidth * lpDDSD->dwHeight;

+				continue;

+			}

+			area = lpDDSD->dwWidth * lpDDSD->dwHeight;

+			if (area < bestarea) {

+				lpBestDDSD = lpDDSD;

+				bestarea = area;

+			}

+		}

+	}

+

+	// Safety check

+	if (lpBestDDSD == NULL) {

+		ddlogMessage(DDLOG_CRITICAL, "dglChooseDisplayMode");

+		return;

+	}

+

+	lpCtx->dwModeWidth = lpBestDDSD->dwWidth;

+	lpCtx->dwModeHeight = lpBestDDSD->dwHeight;

+matched:

+	ddlogPrintf(DDLOG_INFO, "Matched (%ldx%ld) to (%ldx%ld)",

+		lpCtx->dwWidth, lpCtx->dwHeight, lpCtx->dwModeWidth, lpCtx->dwModeHeight);

+}

+#endif // _USE_GLD3_WGL

+// ***********************************************************************

+

+static BOOL IsDevice(

+	DWORD *lpDeviceIdList,

+	DWORD dwDeviceId,

+	int count)

+{

+	int i;

+

+	for (i=0; i<count; i++)

+		if (dwDeviceId == lpDeviceIdList[i])

+			return TRUE;

+

+	return FALSE;

+}

+

+// ***********************************************************************

+

+void dglTestForBrokenCards(

+	DGL_ctx *lpCtx)

+{

+#ifndef _GLD3

+	DDDEVICEIDENTIFIER	dddi; // DX6 device identifier

+

+	// Sanity check.

+	if (lpCtx == NULL) {

+		// Testing for broken cards is sensitive area, so we don't want

+		// anything saying "broken cards" in the error message. ;)

+		ddlogMessage(DDLOG_ERROR, "Null context passed to TFBC\n");

+		return;

+	}

+

+	if (lpCtx->lpDD4 == NULL) {

+		// Testing for broken cards is sensitive area, so we don't want

+		// anything saying "broken cards" in the error message. ;)

+		ddlogMessage(DDLOG_ERROR, "Null DD4 passed to TFBC\n");

+		return;

+	}

+

+	// Microsoft really fucked up with the GetDeviceIdentifier function

+	// on Windows 2000, since it locks up on stock driers on the CD. Updated

+	// drivers from vendors appear to work, but we can't identify the drivers

+	// without this function!!! For now we skip these tests on Windows 2000.

+	if ((GetVersion() & 0x80000000UL) == 0)

+		return;

+

+	// Obtain device info

+	if (FAILED(IDirectDraw4_GetDeviceIdentifier(lpCtx->lpDD4, &dddi, 0)))

+		return;

+

+	// Useful info. Log it.

+	ddlogPrintf(DDLOG_INFO, "DirectDraw: VendorId=0x%x, DeviceId=0x%x", dddi.dwVendorId, dddi.dwDeviceId);

+

+	// Vendor 1: ATI

+	if (dddi.dwVendorId == VENDORID_ATI) {

+		// Test A: ATI Rage PRO

+		if (IsDevice(devATIRagePro, dddi.dwDeviceId, sizeof(devATIRagePro)))

+			glb.bUseMipmaps = FALSE;

+		// Test B: ATI Rage II+

+		if (IsDevice(devATIRageIIplus, dddi.dwDeviceId, sizeof(devATIRageIIplus)))

+			glb.bEmulateAlphaTest = TRUE;

+	}

+

+	// Vendor 2: Matrox

+	if (dddi.dwVendorId == 0x102B) {

+		// Test: Matrox G400 stencil buffer support does not work for AutoCAD

+		if (dddi.dwDeviceId == 0x0525) {

+			lpCtx->lpPF->pfd.cStencilBits = 0;

+			if (lpCtx->lpPF->iZBufferPF != -1) {

+				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwStencilBitDepth = 0;

+				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwStencilBitMask = 0;

+				glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwFlags &= ~DDPF_STENCILBUFFER;

+			}

+		}

+	}

+#endif // _GLD3

+}

+

+// ***********************************************************************

+

+BOOL dglCreateContextBuffers(

+	HDC a,

+	DGL_ctx *lpCtx,

+	BOOL bFallback)

+{

+	HRESULT				hResult;

+

+	int					i;

+//	HGLRC				hGLRC;

+//	DGL_ctx*			lpCtx;

+

+#ifndef _USE_GLD3_WGL

+	DWORD				dwFlags;

+	DDSURFACEDESC2		ddsd2;

+	DDSCAPS2			ddscaps2;

+	LPDIRECTDRAWCLIPPER	lpddClipper;

+	D3DDEVICEDESC		D3DHWDevDesc;	// Direct3D Hardware description

+	D3DDEVICEDESC		D3DHELDevDesc;	// Direct3D Hardware Emulation Layer

+#endif // _USE_GLD3_WGL

+

+	float				inv_aspect;

+

+	GLenum				bDoubleBuffer;	// TRUE if double buffer required

+	GLenum				bDepthBuffer;	// TRUE if depth buffer required

+

+	const PIXELFORMATDESCRIPTOR	*lpPFD = &lpCtx->lpPF->pfd;

+

+	// Vars for Mesa visual

+	DWORD				dwDepthBits		= 0;

+	DWORD				dwStencilBits	= 0;

+	DWORD				dwAlphaBits		= 0;

+	DWORD				bAlphaSW		= GL_FALSE;

+	DWORD				bDouble			= GL_FALSE;

+

+	DDSURFACEDESC2 		ddsd2DisplayMode;

+	BOOL				bFullScrnWin	= FALSE;	// fullscreen-size window ?

+	DDBLTFX 			ddbltfx;

+	DWORD				dwMemoryType 	= (bFallback) ? DDSCAPS_SYSTEMMEMORY : glb.dwMemoryType;

+	BOOL				bBogusWindow	= FALSE;	// non-drawable window ?

+	DWORD               dwColorRef      = 0;        // GDI background color

+	RECT				rcDst;						// GDI window rect

+	POINT				pt;							// GDI window point

+

+	// Palette used for creating default global palette

+	PALETTEENTRY	ppe[256];

+

+#ifndef _USE_GLD3_WGL

+	// Vertex buffer description. Used for creation of vertex buffers

+	D3DVERTEXBUFFERDESC vbufdesc;

+#endif // _USE_GLD3_WGL

+

+#define DDLOG_CRITICAL_OR_WARN	(bFallback ? DDLOG_CRITICAL : DDLOG_WARN)

+

+	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContextBuffers for HDC=%X", a);

+    nContextError = GLDERR_NONE;

+

+#ifdef GLD_THREADS

+	// Serialize access to DirectDraw object creation or DDS start

+	if (glb.bMultiThreaded)

+		EnterCriticalSection(&CriticalSection);

+#endif

+

+	// Check for back buffer

+	bDoubleBuffer = GL_TRUE; //(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? GL_TRUE : GL_FALSE;

+	// Since we always do back buffering, check if we emulate front buffering

+	lpCtx->EmulateSingle =

+		(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? FALSE : TRUE;

+#if 0	// Don't have to mimic MS OpenGL behavior for front-buffering (DaveM)

+	lpCtx->EmulateSingle |=

+		(lpPFD->dwFlags & PFD_SUPPORT_GDI) ? TRUE : FALSE;

+#endif

+

+	// Check for depth buffer

+	bDepthBuffer = (lpPFD->cDepthBits) ? GL_TRUE : GL_FALSE;

+

+	lpCtx->bDoubleBuffer = bDoubleBuffer;

+	lpCtx->bDepthBuffer = bDepthBuffer;

+

+	// Set the Fullscreen flag for the context.

+//	lpCtx->bFullscreen = glb.bFullscreen;

+

+	// Obtain the dimensions of the rendering window

+	lpCtx->hDC = a; // Cache DC

+	lpCtx->hWnd = WindowFromDC(lpCtx->hDC);

+	// Check for non-window DC = memory DC ?

+	if (lpCtx->hWnd == NULL) {

+        // bitmap memory contexts are always single-buffered

+        lpCtx->EmulateSingle = TRUE;

+		bBogusWindow = TRUE;

+		ddlogPrintf(DDLOG_INFO, "Non-Window Memory Device Context");

+		if (GetClipBox(lpCtx->hDC, &lpCtx->rcScreenRect) == ERROR) {

+			ddlogMessage(DDLOG_WARN, "GetClipBox failed in dglCreateContext\n");

+			SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);

+		}

+	}

+	else if (!GetClientRect(lpCtx->hWnd, &lpCtx->rcScreenRect)) {

+		bBogusWindow = TRUE;

+		ddlogMessage(DDLOG_WARN, "GetClientRect failed in dglCreateContext\n");

+		SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);

+	}

+	lpCtx->dwWidth = lpCtx->rcScreenRect.right - lpCtx->rcScreenRect.left;

+	lpCtx->dwHeight = lpCtx->rcScreenRect.bottom - lpCtx->rcScreenRect.top;

+

+	ddlogPrintf(DDLOG_INFO, "Input window %X: w=%i, h=%i",

+							lpCtx->hWnd, lpCtx->dwWidth, lpCtx->dwHeight);

+

+	// What if app only zeroes one dimension instead of both? (DaveM)

+	if ( (lpCtx->dwWidth == 0) || (lpCtx->dwHeight == 0) ) {

+		// Make the buffer size something sensible

+		lpCtx->dwWidth = 8;

+		lpCtx->dwHeight = 8;

+	}

+

+	// Set defaults

+	lpCtx->dwModeWidth = lpCtx->dwWidth;

+	lpCtx->dwModeHeight = lpCtx->dwHeight;

+/*

+	// Find best display mode for fullscreen

+	if (glb.bFullscreen || !glb.bPrimary) {

+		dglChooseDisplayMode(lpCtx);

+	}

+*/

+	// Misc initialisation

+	lpCtx->bCanRender = FALSE; // No rendering allowed yet

+	lpCtx->bSceneStarted = FALSE;

+	lpCtx->bFrameStarted = FALSE;

+

+	// Detect OS (specifically 'Windows 2000' or 'Windows XP')

+	DetectOS();

+

+	// NOTE: WinNT not supported

+	ddlogPrintf(DDLOG_INFO, "OS: %s", bHaveWin95 ? "Win9x" : (bHaveWin2K ? "Win2000/XP" : "Unsupported") );

+

+	// Test for Fullscreen

+	if (bHaveWin95) { // Problems with fullscreen on Win2K/XP

+		if ((GetSystemMetrics(SM_CXSCREEN) == lpCtx->dwWidth) && 

+			(GetSystemMetrics(SM_CYSCREEN) == lpCtx->dwHeight))

+		{

+			// Workaround for some apps that crash when going fullscreen.

+			//lpCtx->bFullscreen = TRUE;

+		}

+		

+	}

+

+#ifdef _USE_GLD3_WGL

+	_gldDriver.CreateDrawable(lpCtx, glb.bDirectDrawPersistant, glb.bPersistantBuffers);

+#else

+	// Check if DirectDraw has already been created by original GLRC (DaveM)

+	if (glb.bDirectDrawPersistant && glb.bDirectDraw) {

+		lpCtx->lpDD4 = glb.lpDD4;

+		IDirectDraw4_AddRef(lpCtx->lpDD4);

+		goto SkipDirectDrawCreate;

+	}

+

+	// Create DirectDraw object

+	if (glb.bPrimary)

+		hResult = DirectDrawCreate(NULL, &lpCtx->lpDD1, NULL);

+	else {

+		// A non-primary device is to be used.

+		// Force context to be Fullscreen, secondary adaptors can not

+		// be used in a window.

+		hResult = DirectDrawCreate(&glb.ddGuid, &lpCtx->lpDD1, NULL);

+		lpCtx->bFullscreen = TRUE;

+	}

+	if (FAILED(hResult)) {

+		MessageBox(NULL, "Unable to initialize DirectDraw", "GLDirect", MB_OK);

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create DirectDraw interface", hResult);

+        nContextError = GLDERR_DDRAW;

+		goto return_with_error;

+	}

+

+	// Query for DX6 IDirectDraw4.

+	hResult = IDirectDraw_QueryInterface(lpCtx->lpDD1,

+										 &IID_IDirectDraw4,

+										 (void**)&lpCtx->lpDD4);

+	if (FAILED(hResult)) {

+		MessageBox(NULL, "GLDirect requires DirectX 6.0 or above", "GLDirect", MB_OK);

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create DirectDraw4 interface", hResult);

+        nContextError = GLDERR_DDRAW;

+		goto return_with_error;

+	}

+

+	// Cache DirectDraw interface for subsequent GLRCs

+	if (glb.bDirectDrawPersistant && !glb.bDirectDraw) {

+		glb.lpDD4 = lpCtx->lpDD4;

+		IDirectDraw4_AddRef(glb.lpDD4);

+		glb.bDirectDraw = TRUE;

+	}

+SkipDirectDrawCreate:

+

+	// Now we have a DD4 interface we can check for broken cards

+	dglTestForBrokenCards(lpCtx);

+

+	// Test if primary device can use flipping instead of blitting

+	ZeroMemory(&ddsd2DisplayMode, sizeof(ddsd2DisplayMode));

+	ddsd2DisplayMode.dwSize = sizeof(ddsd2DisplayMode);

+	hResult = IDirectDraw4_GetDisplayMode(

+					lpCtx->lpDD4,

+					&ddsd2DisplayMode);

+	if (SUCCEEDED(hResult)) {

+		if ( (lpCtx->dwWidth == ddsd2DisplayMode.dwWidth) &&

+				 (lpCtx->dwHeight == ddsd2DisplayMode.dwHeight) ) {

+			// We have a fullscreen-size window

+			bFullScrnWin = TRUE;

+			// OK to use DirectDraw fullscreen mode ?

+			if (glb.bPrimary && !glb.bFullscreenBlit && !lpCtx->EmulateSingle && !glb.bDirectDrawPersistant) {

+				lpCtx->bFullscreen = TRUE;

+				ddlogMessage(DDLOG_INFO, "Primary upgraded to page flipping.\n");

+			}

+		}

+		// Cache the display mode dimensions

+		lpCtx->dwModeWidth = ddsd2DisplayMode.dwWidth;

+		lpCtx->dwModeHeight = ddsd2DisplayMode.dwHeight;

+	}

+

+	// Clamp the effective window dimensions to primary surface.

+	// We need to do this for D3D viewport dimensions even if wide

+	// surfaces are supported. This also is a good idea for handling

+	// whacked-out window dimensions passed for non-drawable windows

+	// like Solid Edge. (DaveM)

+	if (lpCtx->dwWidth > ddsd2DisplayMode.dwWidth)

+		lpCtx->dwWidth = ddsd2DisplayMode.dwWidth;

+	if (lpCtx->dwHeight > ddsd2DisplayMode.dwHeight)

+		lpCtx->dwHeight = ddsd2DisplayMode.dwHeight;

+

+	// Check for non-RGB desktop resolution

+	if (!lpCtx->bFullscreen && ddsd2DisplayMode.ddpfPixelFormat.dwRGBBitCount <= 8) {

+		ddlogPrintf(DDLOG_CRITICAL_OR_WARN, "Desktop color depth %d bpp not supported",

+			ddsd2DisplayMode.ddpfPixelFormat.dwRGBBitCount);

+        nContextError = GLDERR_BPP;

+		goto return_with_error;

+	}

+#endif // _USE_GLD3_WGL

+

+	ddlogPrintf(DDLOG_INFO, "Window: w=%i, h=%i (%s)",

+							lpCtx->dwWidth,

+							lpCtx->dwHeight,

+							lpCtx->bFullscreen ? "fullscreen" : "windowed");

+

+#ifndef _USE_GLD3_WGL

+	// Obtain ddraw caps

+    ZeroMemory(&lpCtx->ddCaps, sizeof(DDCAPS));

+	lpCtx->ddCaps.dwSize = sizeof(DDCAPS);

+	if (glb.bHardware) {

+		// Get HAL caps

+		IDirectDraw4_GetCaps(lpCtx->lpDD4, &lpCtx->ddCaps, NULL);

+	} else {

+		// Get HEL caps

+		IDirectDraw4_GetCaps(lpCtx->lpDD4, NULL, &lpCtx->ddCaps);

+	}

+

+	// If this flag is present then we can't default to Mesa

+	// SW rendering between BeginScene() and EndScene().

+	if (lpCtx->ddCaps.dwCaps2 & DDCAPS2_NO2DDURING3DSCENE) {

+		ddlogMessage(DDLOG_INFO,

+			"Warning          : No 2D allowed during 3D scene.\n");

+	}

+

+	// Query for DX6 Direct3D3 interface

+	hResult = IDirectDraw4_QueryInterface(lpCtx->lpDD4,

+										  &IID_IDirect3D3,

+										  (void**)&lpCtx->lpD3D3);

+	if (FAILED(hResult)) {

+		MessageBox(NULL, "Unable to initialize Direct3D", "GLDirect", MB_OK);

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create Direct3D interface", hResult);

+        nContextError = GLDERR_D3D;

+		goto return_with_error;

+	}

+

+	// Context creation

+	if (lpCtx->bFullscreen) {

+		// FULLSCREEN

+

+        // Disable warning popups when in fullscreen mode

+        ddlogWarnOption(FALSE);

+

+		// Have to release persistant primary surface if fullscreen mode

+		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) {

+			RELEASE(glb.lpPrimary4);

+			glb.bDirectDrawPrimary = FALSE;

+		}

+

+		dwFlags = DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT;

+		if (glb.bFastFPU)

+			dwFlags |= DDSCL_FPUSETUP;	// fast FPU setup optional (DaveM)

+		hResult = IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, lpCtx->hWnd, dwFlags);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to set Exclusive Fullscreen mode", hResult);

+			goto return_with_error;

+		}

+

+		hResult = IDirectDraw4_SetDisplayMode(lpCtx->lpDD4,

+											  lpCtx->dwModeWidth,

+											  lpCtx->dwModeHeight,

+											  lpPFD->cColorBits,

+											  0,

+											  0);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetDisplayMode failed", hResult);

+			goto return_with_error;

+		}

+

+		// ** The display mode has changed, so dont use MessageBox! **

+

+		ZeroMemory(&ddsd2, sizeof(ddsd2));

+		ddsd2.dwSize = sizeof(ddsd2);

+

+		if (bDoubleBuffer) {

+			// Double buffered

+			// Primary surface

+			ddsd2.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;

+			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |

+								   DDSCAPS_FLIP |

+								   DDSCAPS_COMPLEX |

+								   DDSCAPS_3DDEVICE |

+								   dwMemoryType;

+			ddsd2.dwBackBufferCount = 1;

+

+			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);

+			if (FAILED(hResult)) {

+				ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);

+                nContextError = GLDERR_MEM;

+				goto return_with_error;

+			}

+

+			// Render target surface

+			ZeroMemory(&ddscaps2, sizeof(ddscaps2)); // Clear the entire struct.

+			ddscaps2.dwCaps = DDSCAPS_BACKBUFFER;

+			hResult = IDirectDrawSurface4_GetAttachedSurface(lpCtx->lpFront4, &ddscaps2, &lpCtx->lpBack4);

+			if (FAILED(hResult)) {

+				ddlogError(DDLOG_CRITICAL_OR_WARN, "GetAttachedSurface failed", hResult);

+                nContextError = GLDERR_MEM;

+				goto return_with_error;

+			}

+		} else {

+			// Single buffered

+			// Primary surface

+			ddsd2.dwFlags = DDSD_CAPS;

+			ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |

+								   //DDSCAPS_3DDEVICE |

+								   dwMemoryType;

+

+			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);

+			if (FAILED(hResult)) {

+				ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);

+                nContextError = GLDERR_MEM;

+				goto return_with_error;

+			}

+

+			lpCtx->lpBack4 = NULL;

+		}

+	} else {

+		// WINDOWED

+

+        // OK to enable warning popups in windowed mode

+        ddlogWarnOption(glb.bMessageBoxWarnings);

+

+		dwFlags = DDSCL_NORMAL;

+		if (glb.bMultiThreaded)

+			dwFlags |= DDSCL_MULTITHREADED;

+		if (glb.bFastFPU)

+			dwFlags |= DDSCL_FPUSETUP;	// fast FPU setup optional (DaveM)

+		hResult = IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4,

+												  lpCtx->hWnd,

+												  dwFlags);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to set Normal coop level", hResult);

+			goto return_with_error;

+		}

+		// Has Primary surface already been created for original GLRC ?

+		// Note this can only be applicable for windowed modes

+		if (glb.bDirectDrawPersistant && glb.bDirectDrawPrimary) {

+			lpCtx->lpFront4 = glb.lpPrimary4;

+			IDirectDrawSurface4_AddRef(lpCtx->lpFront4);

+			// Update the window on the default clipper

+			IDirectDrawSurface4_GetClipper(lpCtx->lpFront4, &lpddClipper);

+			IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);

+			IDirectDrawClipper_Release(lpddClipper);

+			goto SkipPrimaryCreate;

+		}

+

+		// Primary surface

+		ZeroMemory(&ddsd2, sizeof(ddsd2));

+		ddsd2.dwSize = sizeof(ddsd2);

+		ddsd2.dwFlags = DDSD_CAPS;

+		ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

+		hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpFront4, NULL);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (primary) failed", hResult);

+            nContextError = GLDERR_MEM;

+			goto return_with_error;

+		}

+

+		// Cache Primary surface for subsequent GLRCs

+		// Note this can only be applicable to subsequent windowed modes

+		if (glb.bDirectDrawPersistant && !glb.bDirectDrawPrimary) {

+			glb.lpPrimary4 = lpCtx->lpFront4;

+			IDirectDrawSurface4_AddRef(glb.lpPrimary4);

+			glb.bDirectDrawPrimary = TRUE;

+		}

+

+		// Clipper object

+		hResult = DirectDrawCreateClipper(0, &lpddClipper, NULL);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateClipper failed", hResult);

+			goto return_with_error;

+		}

+		hResult = IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);

+		if (FAILED(hResult)) {

+			RELEASE(lpddClipper);

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetHWnd failed", hResult);

+			goto return_with_error;

+		}

+		hResult = IDirectDrawSurface4_SetClipper(lpCtx->lpFront4, lpddClipper);

+		RELEASE(lpddClipper); // We have finished with it.

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "SetClipper failed", hResult);

+			goto return_with_error;

+		}

+SkipPrimaryCreate:

+

+		if (bDoubleBuffer) {

+			// Render target surface

+			ZeroMemory(&ddsd2, sizeof(ddsd2));

+			ddsd2.dwSize = sizeof(ddsd2);

+			ddsd2.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;

+			ddsd2.dwWidth        = lpCtx->dwWidth;

+			ddsd2.dwHeight       = lpCtx->dwHeight;

+			ddsd2.ddsCaps.dwCaps = DDSCAPS_3DDEVICE |

+								   DDSCAPS_OFFSCREENPLAIN |

+								   dwMemoryType;

+

+			// Reserve the entire desktop size for persistant buffers option

+			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers) {

+				ddsd2.dwWidth = ddsd2DisplayMode.dwWidth;

+				ddsd2.dwHeight = ddsd2DisplayMode.dwHeight;

+			}

+			// Re-use original back buffer if persistant buffers exist

+			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpBack4)

+				hResult = IDirectDrawSurface4_AddRef(lpCtx->lpBack4 = glb.lpBack4);

+			else

+				hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpBack4, NULL);

+			if (FAILED(hResult)) {

+				ddlogError(DDLOG_CRITICAL_OR_WARN, "Create Backbuffer failed", hResult);

+                nContextError = GLDERR_MEM;

+				goto return_with_error;

+			}

+			if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpBack4)

+				IDirectDrawSurface4_AddRef(glb.lpBack4 = lpCtx->lpBack4);

+		} else {

+			lpCtx->lpBack4 = NULL;

+		}

+	}

+

+	//

+	// Now create the Z-buffer

+	//

+	lpCtx->bStencil = FALSE; // Default to no stencil buffer

+	if (bDepthBuffer && (lpCtx->lpPF->iZBufferPF != -1)) {

+		// Get z-buffer dimensions from the render target

+		// Setup the surface desc for the z-buffer.

+		ZeroMemory(&ddsd2, sizeof(ddsd2));

+		ddsd2.dwSize = sizeof(ddsd2);

+		ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;

+		ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | dwMemoryType;

+		ddsd2.dwWidth = lpCtx->dwWidth;

+		ddsd2.dwHeight = lpCtx->dwHeight;

+		memcpy(&ddsd2.ddpfPixelFormat,

+			&glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF],

+			sizeof(DDPIXELFORMAT) );

+

+		// Reserve the entire desktop size for persistant buffers option

+		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers) {

+			ddsd2.dwWidth = ddsd2DisplayMode.dwWidth;

+			ddsd2.dwHeight = ddsd2DisplayMode.dwHeight;

+		}

+

+		// Create a z-buffer

+		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpDepth4)

+			hResult = IDirectDrawSurface4_AddRef(lpCtx->lpDepth4 = glb.lpDepth4);

+		else

+			hResult = IDirectDraw4_CreateSurface(lpCtx->lpDD4, &ddsd2, &lpCtx->lpDepth4, NULL);

+		if (FAILED(hResult)) {

+			ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateSurface (ZBuffer) failed", hResult);

+            nContextError = GLDERR_MEM;

+			goto return_with_error;

+		}

+		if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpDepth4)

+			IDirectDrawSurface4_AddRef(glb.lpDepth4 = lpCtx->lpDepth4);

+		else if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpDepth4 && glb.lpBack4)

+			IDirectDrawSurface4_DeleteAttachedSurface(glb.lpBack4, 0, glb.lpDepth4);

+

+		// Attach Zbuffer to render target

+		TRY(IDirectDrawSurface4_AddAttachedSurface(

+			bDoubleBuffer ? lpCtx->lpBack4 : lpCtx->lpFront4,

+			lpCtx->lpDepth4),

+			"dglCreateContext: Attach Zbuffer");

+		if (glb.lpZBufferPF[lpCtx->lpPF->iZBufferPF].dwFlags & DDPF_STENCILBUFFER) {

+			lpCtx->bStencil = TRUE;

+			ddlogMessage(DDLOG_INFO, "Depth buffer has stencil\n");

+		}

+	}

+

+	// Clear all back buffers and Z-buffers in case of memory recycling.

+	ZeroMemory(&ddbltfx, sizeof(ddbltfx));

+	ddbltfx.dwSize = sizeof(ddbltfx);

+	IDirectDrawSurface4_Blt(lpCtx->lpBack4, NULL, NULL, NULL,

+		DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);

+	if (lpCtx->lpDepth4)

+		IDirectDrawSurface4_Blt(lpCtx->lpDepth4, NULL, NULL, NULL,

+			DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);

+

+	// Now that we have a Z-buffer we can create the 3D device

+	hResult = IDirect3D3_CreateDevice(lpCtx->lpD3D3,

+									  &glb.d3dGuid,

+									  bDoubleBuffer ? lpCtx->lpBack4 : lpCtx->lpFront4,

+									  &lpCtx->lpDev3,

+									  NULL);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "Unable to create Direct3D device", hResult);

+        nContextError = GLDERR_D3D;

+		goto return_with_error;

+	}

+

+	// We must do this as soon as the device is created

+	dglInitStateCaches(lpCtx);

+

+	// Obtain the D3D Device Description

+	D3DHWDevDesc.dwSize = D3DHELDevDesc.dwSize = sizeof(D3DDEVICEDESC);

+	TRY(IDirect3DDevice3_GetCaps(lpCtx->lpDev3,

+								 &D3DHWDevDesc,

+								 &D3DHELDevDesc),

+								 "dglCreateContext: GetCaps failed");

+

+	// Choose the relevant description and cache it in the context.

+	// We will use this description later for caps checking

+	memcpy(	&lpCtx->D3DDevDesc,

+			glb.bHardware ? &D3DHWDevDesc : &D3DHELDevDesc,

+			sizeof(D3DDEVICEDESC));

+

+	// Now we can examine the texture formats

+	if (!dglBuildTextureFormatList(lpCtx->lpDev3)) {

+		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "dglBuildTextureFormatList failed\n");

+		goto return_with_error;

+	}

+

+	// Get the pixel format of the back buffer

+	lpCtx->ddpfRender.dwSize = sizeof(lpCtx->ddpfRender);

+	if (bDoubleBuffer)

+		hResult = IDirectDrawSurface4_GetPixelFormat(

+					lpCtx->lpBack4,

+					&lpCtx->ddpfRender);

+	else

+		hResult = IDirectDrawSurface4_GetPixelFormat(

+					lpCtx->lpFront4,

+					&lpCtx->ddpfRender);

+

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "GetPixelFormat failed", hResult);

+		goto return_with_error;

+	}

+	// Find a pixel packing function suitable for this surface

+	pxClassifyPixelFormat(&lpCtx->ddpfRender,

+						  &lpCtx->fnPackFunc,

+						  &lpCtx->fnUnpackFunc,

+						  &lpCtx->fnPackSpanFunc);

+

+	// Viewport

+	hResult = IDirect3D3_CreateViewport(lpCtx->lpD3D3, &lpCtx->lpViewport3, NULL);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateViewport failed", hResult);

+		goto return_with_error;

+	}

+

+	hResult = IDirect3DDevice3_AddViewport(lpCtx->lpDev3, lpCtx->lpViewport3);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "AddViewport failed", hResult);

+		goto return_with_error;

+	}

+

+	// Initialise the viewport

+	// Note screen coordinates are used for viewport clipping since D3D

+	// transform operations are not used in the GLD CAD driver. (DaveM)

+	inv_aspect = (float)lpCtx->dwHeight/(float)lpCtx->dwWidth;

+

+	lpCtx->d3dViewport.dwSize = sizeof(lpCtx->d3dViewport);

+	lpCtx->d3dViewport.dwX = 0;

+	lpCtx->d3dViewport.dwY = 0;

+	lpCtx->d3dViewport.dwWidth = lpCtx->dwWidth;

+	lpCtx->d3dViewport.dwHeight = lpCtx->dwHeight;

+	lpCtx->d3dViewport.dvClipX = 0; // -1.0f;

+	lpCtx->d3dViewport.dvClipY = 0; // inv_aspect;

+	lpCtx->d3dViewport.dvClipWidth = lpCtx->dwWidth; // 2.0f;

+	lpCtx->d3dViewport.dvClipHeight = lpCtx->dwHeight; // 2.0f * inv_aspect;

+	lpCtx->d3dViewport.dvMinZ = 0.0f;

+	lpCtx->d3dViewport.dvMaxZ = 1.0f;

+	TRY(IDirect3DViewport3_SetViewport2(lpCtx->lpViewport3, &lpCtx->d3dViewport), "dglCreateContext: SetViewport2");

+

+	hResult = IDirect3DDevice3_SetCurrentViewport(lpCtx->lpDev3, lpCtx->lpViewport3);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "SetCurrentViewport failed", hResult);

+		goto return_with_error;

+	}

+

+	lpCtx->dwBPP = lpPFD->cColorBits;

+	lpCtx->iZBufferPF = lpCtx->lpPF->iZBufferPF;

+

+	// Set last texture to NULL

+	for (i=0; i<MAX_TEXTURE_UNITS; i++) {

+		lpCtx->ColorOp[i] = D3DTOP_DISABLE;

+		lpCtx->AlphaOp[i] = D3DTOP_DISABLE;

+		lpCtx->tObj[i] = NULL;

+	}

+

+	// Default to perspective correct texture mapping

+	dglSetRenderState(lpCtx, D3DRENDERSTATE_TEXTUREPERSPECTIVE, TRUE, "TexturePersp");

+

+	// Set the default culling mode

+	lpCtx->cullmode = D3DCULL_NONE;

+	dglSetRenderState(lpCtx, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE, "CullMode");

+

+	// Disable specular

+	dglSetRenderState(lpCtx, D3DRENDERSTATE_SPECULARENABLE, FALSE, "SpecularEnable");

+	// Disable subpixel correction

+//	dglSetRenderState(lpCtx, D3DRENDERSTATE_SUBPIXEL, FALSE, "SubpixelEnable");

+	// Disable dithering

+	dglSetRenderState(lpCtx, D3DRENDERSTATE_DITHERENABLE, FALSE, "DitherEnable");

+

+	// Initialise the primitive caches

+//	lpCtx->dwNextLineVert	= 0;

+//	lpCtx->dwNextTriVert	= 0;

+

+	// Init the global texture palette

+	lpCtx->lpGlobalPalette = NULL;

+

+	// Init the HW/SW usage counters

+//	lpCtx->dwHWUsageCount = lpCtx->dwSWUsageCount = 0L;

+

+	//

+	// Create two D3D vertex buffers.

+	// One will hold the pre-transformed data with the other one

+	// being used to hold the post-transformed & clipped verts.

+	//

+#if 0  // never used (DaveM)

+	vbufdesc.dwSize = sizeof(D3DVERTEXBUFFERDESC);

+	vbufdesc.dwCaps = D3DVBCAPS_WRITEONLY;

+	if (glb.bHardware == FALSE)

+		vbufdesc.dwCaps = D3DVBCAPS_SYSTEMMEMORY;

+	vbufdesc.dwNumVertices = 32768; // For the time being

+

+	// Source vertex buffer

+	vbufdesc.dwFVF = DGL_LVERTEX;

+	hResult = IDirect3D3_CreateVertexBuffer(lpCtx->lpD3D3, &vbufdesc, &lpCtx->m_vbuf, 0, NULL);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateVertexBuffer(src) failed", hResult);

+		goto return_with_error;

+	}

+

+	// Destination vertex buffer

+	vbufdesc.dwFVF = (glb.bMultitexture == FALSE) ? D3DFVF_TLVERTEX : (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX2);

+	hResult = IDirect3D3_CreateVertexBuffer(lpCtx->lpD3D3, &vbufdesc, &lpCtx->m_pvbuf, 0, NULL);

+	if(FAILED(hResult)) {

+		ddlogError(DDLOG_CRITICAL_OR_WARN, "CreateVertexBuffer(dst) failed", hResult);

+		goto return_with_error;

+	}

+#endif

+

+#endif _USE_GLD3_WGL

+

+	//

+	//	Now create the Mesa context

+	//

+

+	// Create the Mesa visual

+	if (lpPFD->cDepthBits)

+		dwDepthBits = 16;

+	if (lpPFD->cStencilBits)

+		dwStencilBits = 8;

+	if (lpPFD->cAlphaBits) {

+		dwAlphaBits = 8;

+		bAlphaSW = GL_TRUE;

+	}

+	if (lpPFD->dwFlags & PFD_DOUBLEBUFFER)

+		bDouble = GL_TRUE;

+//	lpCtx->EmulateSingle =

+//		(lpPFD->dwFlags & PFD_DOUBLEBUFFER) ? FALSE : TRUE;

+

+#ifdef _USE_GLD3_WGL

+	lpCtx->glVis = _mesa_create_visual(

+		bDouble,    /* double buffer */

+		GL_FALSE,			// stereo

+		lpPFD->cRedBits,

+		lpPFD->cGreenBits,

+		lpPFD->cBlueBits,

+		dwAlphaBits,

+		dwDepthBits,

+		dwStencilBits,

+		lpPFD->cAccumRedBits,	// accum bits

+		lpPFD->cAccumGreenBits,	// accum bits

+		lpPFD->cAccumBlueBits,	// accum bits

+		lpPFD->cAccumAlphaBits,	// accum alpha bits

+		1				// num samples

+		);

+#else // _USE_GLD3_WGL

+	lpCtx->glVis = (*mesaFuncs.gl_create_visual)(

+		GL_TRUE,			// RGB mode

+		bAlphaSW,			// Is an alpha buffer required?

+		bDouble,			// Is an double-buffering required?

+		GL_FALSE,			// stereo

+		dwDepthBits,		// depth_size

+		dwStencilBits,		// stencil_size

+		lpPFD->cAccumBits,	// accum_size

+		0,					// colour-index bits

+		lpPFD->cRedBits,	// Red bit count

+		lpPFD->cGreenBits,	// Green bit count

+		lpPFD->cBlueBits,	// Blue bit count

+		dwAlphaBits			// Alpha bit count

+		);

+#endif // _USE_GLD3_WGL

+

+	if (lpCtx->glVis == NULL) {

+		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_visual failed\n");

+		goto return_with_error;

+	}

+

+#ifdef _USE_GLD3_WGL

+	lpCtx->glCtx = _mesa_create_context(API_OPENGL, lpCtx->glVis, NULL, (void *)lpCtx, GL_TRUE);

+#else

+	// Create the Mesa context

+	lpCtx->glCtx = (*mesaFuncs.gl_create_context)(

+					lpCtx->glVis,	// Mesa visual

+					NULL,			// share list context

+					(void *)lpCtx,	// Pointer to our driver context

+					GL_TRUE			// Direct context flag

+				   );

+#endif // _USE_GLD3_WGL

+

+	if (lpCtx->glCtx == NULL) {

+		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_context failed\n");

+		goto return_with_error;

+	}

+

+	// Create the Mesa framebuffer

+#ifdef _USE_GLD3_WGL

+	lpCtx->glBuffer = _mesa_create_framebuffer(

+		lpCtx->glVis,

+		lpCtx->glVis->depthBits > 0,

+		lpCtx->glVis->stencilBits > 0,

+		lpCtx->glVis->accumRedBits > 0,

+		GL_FALSE //swalpha

+		);

+#else

+	lpCtx->glBuffer = (*mesaFuncs.gl_create_framebuffer)(lpCtx->glVis);

+#endif // _USE_GLD3_WGL

+

+	if (lpCtx->glBuffer == NULL) {

+		ddlogMessage(DDLOG_CRITICAL_OR_WARN, "gl_create_framebuffer failed\n");

+		goto return_with_error;

+	}

+

+#ifdef _USE_GLD3_WGL

+	// Init Mesa internals

+	_swrast_CreateContext( lpCtx->glCtx );

+	_vbo_CreateContext( lpCtx->glCtx );

+	_tnl_CreateContext( lpCtx->glCtx );

+	_swsetup_CreateContext( lpCtx->glCtx );

+

+	_gldDriver.InitialiseMesa(lpCtx);

+	

+	lpCtx->glCtx->imports.warning	= _gld_mesa_warning;

+	lpCtx->glCtx->imports.fatal		= _gld_mesa_fatal;

+

+#else

+	// Tell Mesa how many texture stages we have

+	glb.wMaxSimultaneousTextures = lpCtx->D3DDevDesc.wMaxSimultaneousTextures;

+	// Only use as many Units as the spec requires

+	if (glb.wMaxSimultaneousTextures > MAX_TEXTURE_UNITS)

+		glb.wMaxSimultaneousTextures = MAX_TEXTURE_UNITS;

+	lpCtx->glCtx->Const.MaxTextureUnits = glb.wMaxSimultaneousTextures;

+	ddlogPrintf(DDLOG_INFO, "Texture stages   : %d", glb.wMaxSimultaneousTextures);

+

+	// Set the max texture size.

+	// NOTE: clamped to a max of 1024 for extra performance!

+	lpCtx->dwMaxTextureSize = (lpCtx->D3DDevDesc.dwMaxTextureWidth <= 1024) ? lpCtx->D3DDevDesc.dwMaxTextureWidth : 1024;

+

+// Texture resize takes place elsewhere. KH

+// NOTE: This was added to workaround an issue with the Intel app.

+#if 0

+	lpCtx->glCtx->Const.MaxTextureSize = lpCtx->dwMaxTextureSize;

+#else

+	lpCtx->glCtx->Const.MaxTextureSize = 1024;

+#endif

+	lpCtx->glCtx->Const.MaxDrawBuffers = 1;

+

+	// Setup the Display Driver pointers

+	dglSetupDDPointers(lpCtx->glCtx);

+

+	// Initialise all the Direct3D renderstates

+	dglInitStateD3D(lpCtx->glCtx);

+

+#if 0

+	// Signal a reload of texture state on next glBegin

+	lpCtx->m_texHandleValid = FALSE;

+	lpCtx->m_mtex = FALSE;

+	lpCtx->m_texturing = FALSE;

+#else

+	// Set default texture unit state

+//	dglSetTexture(lpCtx, 0, NULL);

+//	dglSetTexture(lpCtx, 1, NULL);

+#endif

+

+	//

+	// Set the global texture palette to default values.

+	//

+

+	// Clear the entire palette

+	ZeroMemory(ppe, sizeof(PALETTEENTRY) * 256);

+

+	// Fill the palette with a default colour.

+	// A garish colour is used to catch bugs. Here Magenta is used.

+	for (i=0; i < 256; i++) {

+		ppe[i].peRed	= 255;

+		ppe[i].peGreen	= 0;

+		ppe[i].peBlue	= 255;

+	}

+

+	RELEASE(lpCtx->lpGlobalPalette);

+

+	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && glb.lpGlobalPalette)

+		hResult = IDirectDrawPalette_AddRef(lpCtx->lpGlobalPalette = glb.lpGlobalPalette);

+	else

+		hResult = IDirectDraw4_CreatePalette(

+				lpCtx->lpDD4,

+				DDPCAPS_INITIALIZE | DDPCAPS_8BIT | DDPCAPS_ALLOW256,

+				ppe,

+				&(lpCtx->lpGlobalPalette),

+				NULL);

+	if (FAILED(hResult)) {

+		ddlogError(DDLOG_ERROR, "Default CreatePalette failed\n", hResult);

+		lpCtx->lpGlobalPalette = NULL;

+		goto return_with_error;

+	}

+	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers && !glb.lpGlobalPalette)

+		IDirectDrawPalette_AddRef(glb.lpGlobalPalette = lpCtx->lpGlobalPalette);

+

+#endif // _USE_GLD3_WGL

+

+	// ** If we have made it to here then we can enable rendering **

+	lpCtx->bCanRender = TRUE;

+

+//	ddlogMessage(DDLOG_SYSTEM, "dglCreateContextBuffers succeded\n");

+

+#ifdef GLD_THREADS

+	// Release serialized access

+	if (glb.bMultiThreaded)

+		LeaveCriticalSection(&CriticalSection);

+#endif

+

+	return TRUE;

+

+return_with_error:

+	// Clean up before returning.

+	// This is critical for secondary devices.

+

+	lpCtx->bCanRender = FALSE;

+

+#ifdef _USE_GLD3_WGL

+	// Destroy the Mesa context

+	if (lpCtx->glBuffer)

+		_mesa_destroy_framebuffer(lpCtx->glBuffer);

+	if (lpCtx->glCtx)

+		_mesa_destroy_context(lpCtx->glCtx);

+	if (lpCtx->glVis)

+		_mesa_destroy_visual(lpCtx->glVis);

+

+	// Destroy driver data

+	_gldDriver.DestroyDrawable(lpCtx);

+#else

+	// Destroy the Mesa context

+	if (lpCtx->glBuffer)

+		(*mesaFuncs.gl_destroy_framebuffer)(lpCtx->glBuffer);

+	if (lpCtx->glCtx)

+		(*mesaFuncs.gl_destroy_context)(lpCtx->glCtx);

+	if (lpCtx->glVis)

+		(*mesaFuncs.gl_destroy_visual)(lpCtx->glVis);

+

+	RELEASE(lpCtx->m_pvbuf); // Release D3D vertex buffer

+	RELEASE(lpCtx->m_vbuf); // Release D3D vertex buffer

+

+	if (lpCtx->lpViewport3) {

+		if (lpCtx->lpDev3) IDirect3DDevice3_DeleteViewport(lpCtx->lpDev3, lpCtx->lpViewport3);

+		RELEASE(lpCtx->lpViewport3);

+		lpCtx->lpViewport3 = NULL;

+	}

+

+	RELEASE(lpCtx->lpDev3);

+	if (lpCtx->lpDepth4) {

+		if (lpCtx->lpBack4)

+			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpBack4, 0L, lpCtx->lpDepth4);

+		else

+			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpFront4, 0L, lpCtx->lpDepth4);

+		RELEASE(lpCtx->lpDepth4);

+		lpCtx->lpDepth4 = NULL;

+	}

+	RELEASE(lpCtx->lpBack4);

+	RELEASE(lpCtx->lpFront4);

+	else

+	if (lpCtx->bFullscreen) {

+		IDirectDraw4_RestoreDisplayMode(lpCtx->lpDD4);

+		IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, NULL, DDSCL_NORMAL);

+	}

+	RELEASE(lpCtx->lpD3D3);

+	RELEASE(lpCtx->lpDD4);

+	RELEASE(lpCtx->lpDD1);

+#endif // _USE_GLD3_WGL

+

+	lpCtx->bAllocated = FALSE;

+

+#ifdef GLD_THREADS

+	// Release serialized access

+	if (glb.bMultiThreaded)

+		LeaveCriticalSection(&CriticalSection);

+#endif

+

+	return FALSE;

+

+#undef DDLOG_CRITICAL_OR_WARN

+}

+

+// ***********************************************************************

+

+HGLRC dglCreateContext(

+	HDC a,

+	const DGL_pixelFormat *lpPF)

+{

+	int i;

+	HGLRC				hGLRC;

+	DGL_ctx*			lpCtx;

+	static BOOL			bWarnOnce = TRUE;

+	DWORD				dwThreadId = GetCurrentThreadId();

+    char                szMsg[256];

+    HWND                hWnd;

+    LONG                lpfnWndProc;

+

+	// Validate license

+	if (!dglValidate())

+		return NULL;

+

+	// Is context state ready ?

+	if (!bContextReady)

+		return NULL;

+

+	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContext for HDC=%X, ThreadId=%X", a, dwThreadId);

+

+	// Find next free context.

+	// Also ensure that only one Fullscreen context is created at any one time.

+	hGLRC = 0; // Default to Not Found

+	for (i=0; i<DGL_MAX_CONTEXTS; i++) {

+		if (ctxlist[i].bAllocated) {

+			if (/*glb.bFullscreen && */ctxlist[i].bFullscreen)

+				break;

+		} else {

+			hGLRC = (HGLRC)(i+1);

+			break;

+		}

+	}

+

+	// Bail if no GLRC was found

+	if (!hGLRC)

+		return NULL;

+

+	// Set the context pointer

+	lpCtx = dglGetContextAddress(hGLRC);

+	// Make sure that context is zeroed before we do anything.

+	// MFC and C++ apps call wglCreateContext() and wglDeleteContext() multiple times,

+	// even though only one context is ever used by the app, so keep it clean. (DaveM)

+	ZeroMemory(lpCtx, sizeof(DGL_ctx));

+	lpCtx->bAllocated = TRUE;

+	// Flag that buffers need creating on next wglMakeCurrent call.

+	lpCtx->bHasBeenCurrent = FALSE;

+	lpCtx->lpPF = (DGL_pixelFormat *)lpPF;	// cache pixel format

+	lpCtx->bCanRender = FALSE;

+

+	// Create all the internal resources here, not in dglMakeCurrent().

+	// We do a re-size check in dglMakeCurrent in case of re-allocations. (DaveM)

+	// We now try context allocations twice, first with video memory,

+	// then again with system memory. This is similar to technique

+	// used for dglWglResizeBuffers(). (DaveM)

+	if (lpCtx->bHasBeenCurrent == FALSE) {

+		if (!dglCreateContextBuffers(a, lpCtx, FALSE)) {

+			if (glb.bMessageBoxWarnings && bWarnOnce && dwLogging) {

+				bWarnOnce = FALSE;

+                switch (nContextError) {

+                   case GLDERR_DDRAW: strcpy(szMsg, szDDrawWarning); break;

+                   case GLDERR_D3D: strcpy(szMsg, szD3DWarning); break;

+                   case GLDERR_MEM: strcpy(szMsg, szResourceWarning); break;

+                   case GLDERR_BPP: strcpy(szMsg, szBPPWarning); break;

+                   default: strcpy(szMsg, "");

+                }

+                if (strlen(szMsg))

+                    MessageBox(NULL, szMsg, "GLDirect", MB_OK | MB_ICONWARNING);

+			}

+            // Only need to try again if memory error

+            if (nContextError == GLDERR_MEM) {

+			    ddlogPrintf(DDLOG_WARN, "dglCreateContext failed 1st time with video memory");

+            }

+            else {

+			    ddlogPrintf(DDLOG_ERROR, "dglCreateContext failed");

+                return NULL;

+            }

+		}

+	}

+

+	// Now that we have a hWnd, we can intercept the WindowProc.

+    hWnd = lpCtx->hWnd;

+    if (hWnd) {

+		// Only hook individual window handler once if not hooked before.

+		lpfnWndProc = GetWindowLong(hWnd, GWL_WNDPROC);

+		if (lpfnWndProc != (LONG)dglWndProc) {

+			lpCtx->lpfnWndProc = lpfnWndProc;

+			SetWindowLong(hWnd, GWL_WNDPROC, (LONG)dglWndProc);

+			}

+        // Find the parent window of the app too.

+        if (glb.hWndActive == NULL) {

+            while (hWnd != NULL) {

+                glb.hWndActive = hWnd;

+                hWnd = GetParent(hWnd);

+            }

+            // Hook the parent window too.

+            lpfnWndProc = GetWindowLong(glb.hWndActive, GWL_WNDPROC);

+            if (glb.hWndActive == lpCtx->hWnd)

+                glb.lpfnWndProc = lpCtx->lpfnWndProc;

+            else if (lpfnWndProc != (LONG)dglWndProc)

+                glb.lpfnWndProc = lpfnWndProc;

+            if (glb.lpfnWndProc)

+                SetWindowLong(glb.hWndActive, GWL_WNDPROC, (LONG)dglWndProc);

+        }

+    }

+

+	ddlogPrintf(DDLOG_SYSTEM, "dglCreateContext succeeded for HGLRC=%d", (int)hGLRC);

+

+	return hGLRC;

+}

+

+// ***********************************************************************

+// Make a DirectGL context current

+// Used by wgl functions and dgl functions

+BOOL dglMakeCurrent(

+	HDC a,

+	HGLRC b)

+{

+	int context;

+	DGL_ctx* lpCtx;

+	HWND hWnd;

+	BOOL bNeedResize = FALSE;

+	BOOL bWindowChanged, bContextChanged;

+	LPDIRECTDRAWCLIPPER	lpddClipper;

+	DWORD dwThreadId = GetCurrentThreadId();

+	LONG lpfnWndProc;

+

+	// Validate license

+	if (!dglValidate())

+		return FALSE;

+

+	// Is context state ready ?

+	if (!bContextReady)

+		return FALSE;

+

+	context = (int)b; // This is as a result of STRICT!

+	ddlogPrintf(DDLOG_SYSTEM, "dglMakeCurrent: HDC=%X, HGLRC=%d, ThreadId=%X", a, context, dwThreadId);

+

+	// If the HGLRC is NULL then make no context current;

+	// Ditto if the HDC is NULL either. (DaveM)

+	if (context == 0 || a == 0) {

+		// Corresponding Mesa operation

+#ifdef _USE_GLD3_WGL

+		_mesa_make_current(NULL, NULL);

+#else

+		(*mesaFuncs.gl_make_current)(NULL, NULL);

+#endif

+		dglSetCurrentContext(0);

+		return TRUE;

+	}

+

+	// Make sure the HGLRC is in range

+	if ((context > DGL_MAX_CONTEXTS) || (context < 0)) {

+		ddlogMessage(DDLOG_ERROR, "dglMakeCurrent: HGLRC out of range\n");

+		return FALSE;

+	}

+

+	// Find address of context and make sure that it has been allocated

+	lpCtx = dglGetContextAddress(b);

+	if (!lpCtx->bAllocated) {

+		ddlogMessage(DDLOG_ERROR, "dglMakeCurrent: Context not allocated\n");

+//		return FALSE;

+		return TRUE; // HACK: Shuts up "WebLab Viewer Pro". KeithH

+	}

+

+#ifdef GLD_THREADS

+	// Serialize access to DirectDraw or DDS operations

+	if (glb.bMultiThreaded)

+		EnterCriticalSection(&CriticalSection);

+#endif

+

+	// Check if window has changed

+	hWnd = (a != lpCtx->hDC) ? WindowFromDC(a) : lpCtx->hWnd;

+	bWindowChanged = (hWnd != lpCtx->hWnd) ? TRUE : FALSE;

+	bContextChanged = (b != dglGetCurrentContext()) ? TRUE : FALSE;

+

+	// If the window has changed, make sure the clipper is updated. (DaveM)

+	if (glb.bDirectDrawPersistant && !lpCtx->bFullscreen && (bWindowChanged || bContextChanged)) {

+		lpCtx->hWnd = hWnd;

+#ifndef _USE_GLD3_WGL

+		IDirectDrawSurface4_GetClipper(lpCtx->lpFront4, &lpddClipper);

+		IDirectDrawClipper_SetHWnd(lpddClipper, 0, lpCtx->hWnd);

+		IDirectDrawClipper_Release(lpddClipper);

+#endif // _USE_GLD3_WGL

+	}

+

+	// Make sure hDC and hWnd is current. (DaveM)

+	// Obtain the dimensions of the rendering window

+	lpCtx->hDC = a; // Cache DC

+	lpCtx->hWnd = hWnd;

+	hWndLastActive = hWnd;

+

+	// Check for non-window DC = memory DC ?

+	if (hWnd == NULL) {

+		if (GetClipBox(a, &lpCtx->rcScreenRect) == ERROR) {

+			ddlogMessage(DDLOG_WARN, "GetClipBox failed in dglMakeCurrent\n");

+			SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);

+		}

+	}

+	else if (!GetClientRect(lpCtx->hWnd, &lpCtx->rcScreenRect)) {

+		ddlogMessage(DDLOG_WARN, "GetClientRect failed in dglMakeCurrent\n");

+		SetRect(&lpCtx->rcScreenRect, 0, 0, 0, 0);

+	}

+	// Check if buffers need to be re-sized;

+	// If so, wait until Mesa GL stuff is setup before re-sizing;

+	if (lpCtx->dwWidth != lpCtx->rcScreenRect.right - lpCtx->rcScreenRect.left ||

+		lpCtx->dwHeight != lpCtx->rcScreenRect.bottom - lpCtx->rcScreenRect.top)

+		bNeedResize = TRUE;

+

+	// Now we can update our globals

+	dglSetCurrentContext(b);

+

+	// Corresponding Mesa operation

+#ifdef _USE_GLD3_WGL

+	_mesa_make_current(lpCtx->glCtx, lpCtx->glBuffer);

+	lpCtx->glCtx->Driver.UpdateState(lpCtx->glCtx, _NEW_ALL);

+	if (bNeedResize) {

+		// Resize buffers (Note Mesa GL needs to be setup beforehand);

+		// Resize Mesa internal buffer too via glViewport() command,

+		// which subsequently calls dglWglResizeBuffers() too.

+		lpCtx->glCtx->Driver.Viewport(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+		lpCtx->bHasBeenCurrent = TRUE;

+	}

+#else

+	(*mesaFuncs.gl_make_current)(lpCtx->glCtx, lpCtx->glBuffer);

+

+	dglSetupDDPointers(lpCtx->glCtx);

+

+	// Insure DirectDraw surfaces fit current window DC

+	if (bNeedResize) {

+		// Resize buffers (Note Mesa GL needs to be setup beforehand);

+		// Resize Mesa internal buffer too via glViewport() command,

+		// which subsequently calls dglWglResizeBuffers() too.

+		(*mesaFuncs.gl_Viewport)(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+		lpCtx->bHasBeenCurrent = TRUE;

+	}

+#endif // _USE_GLD3_WGL

+	ddlogPrintf(DDLOG_SYSTEM, "dglMakeCurrent: width = %d, height = %d", lpCtx->dwWidth, lpCtx->dwHeight);

+

+	// We have to clear D3D back buffer and render state if emulated front buffering

+	// for different window (but not context) like in Solid Edge.

+	if (glb.bDirectDrawPersistant && glb.bPersistantBuffers

+		&& (bWindowChanged /* || bContextChanged */) && lpCtx->EmulateSingle) {

+#ifdef _USE_GLD3_WGL

+//		IDirect3DDevice8_EndScene(lpCtx->pDev);

+//		lpCtx->bSceneStarted = FALSE;

+		lpCtx->glCtx->Driver.Clear(lpCtx->glCtx, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,

+			GL_TRUE, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+#else

+		IDirect3DDevice3_EndScene(lpCtx->lpDev3);

+		lpCtx->bSceneStarted = FALSE;

+		dglClearD3D(lpCtx->glCtx, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,

+			GL_TRUE, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+#endif // _USE_GLD3_WGL

+	}

+

+	// The first time we call MakeCurrent we set the initial viewport size

+	if (lpCtx->bHasBeenCurrent == FALSE)

+#ifdef _USE_GLD3_WGL

+		lpCtx->glCtx->Driver.Viewport(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+#else

+		(*mesaFuncs.gl_Viewport)(lpCtx->glCtx, 0, 0, lpCtx->dwWidth, lpCtx->dwHeight);

+#endif // _USE_GLD3_WGL

+	lpCtx->bHasBeenCurrent = TRUE;

+

+#ifdef GLD_THREADS

+	// Release serialized access

+	if (glb.bMultiThreaded)

+		LeaveCriticalSection(&CriticalSection);

+#endif

+

+	return TRUE;

+}

+

+// ***********************************************************************

+

+BOOL dglDeleteContext(

+	HGLRC a)

+{

+	DGL_ctx* lpCtx;

+	DWORD dwThreadId = GetCurrentThreadId();

+    char argstr[256];

+

+#if 0	// We have enough trouble throwing exceptions as it is... (DaveM)

+	// Validate license

+	if (!dglValidate())

+		return FALSE;

+#endif

+

+	// Is context state ready ?

+	if (!bContextReady)

+		return FALSE;

+

+	ddlogPrintf(DDLOG_SYSTEM, "dglDeleteContext: Deleting context HGLRC=%d, ThreadId=%X", (int)a, dwThreadId);

+

+	// Make sure the HGLRC is in range

+	if (((int) a> DGL_MAX_CONTEXTS) || ((int)a < 0)) {

+		ddlogMessage(DDLOG_ERROR, "dglDeleteCurrent: HGLRC out of range\n");

+		return FALSE;

+	}

+

+	// Make sure context is valid

+	lpCtx = dglGetContextAddress(a);

+	if (!lpCtx->bAllocated) {

+		ddlogPrintf(DDLOG_WARN, "Tried to delete unallocated context HGLRC=%d", (int)a);

+//		return FALSE;

+		return TRUE; // HACK: Shuts up "WebLab Viewer Pro". KeithH

+	}

+

+	// Make sure context is de-activated

+	if (a == dglGetCurrentContext()) {

+		ddlogPrintf(DDLOG_WARN, "dglDeleteContext: context HGLRC=%d still active", (int)a);

+		dglMakeCurrent(NULL, NULL);

+	}

+

+#ifdef GLD_THREADS

+	// Serialize access to DirectDraw or DDS operations

+	if (glb.bMultiThreaded)

+		EnterCriticalSection(&CriticalSection);

+#endif

+

+	// We are about to destroy all Direct3D objects.

+	// Therefore we must disable rendering

+	lpCtx->bCanRender = FALSE;

+

+	// This exception handler was installed to catch some

+	// particularly nasty apps. Console apps that call exit()

+	// fall into this catagory (i.e. Win32 Glut).

+

+    // VC cannot successfully implement multiple exception handlers

+    // if more than one exception occurs. Therefore reverting back to

+    // single exception handler as Keith originally had it. (DaveM)

+

+#define WARN_MESSAGE(p) strcpy(argstr, (#p));

+#define SAFE_RELEASE(p) WARN_MESSAGE(p); RELEASE(p);

+

+__try {

+#ifdef _USE_GLD3_WGL

+    WARN_MESSAGE(gl_destroy_framebuffer);

+	if (lpCtx->glBuffer)

+		_mesa_destroy_framebuffer(lpCtx->glBuffer);

+    WARN_MESSAGE(gl_destroy_context);

+	if (lpCtx->glCtx)

+		_mesa_destroy_context(lpCtx->glCtx);

+    WARN_MESSAGE(gl_destroy_visual);

+	if (lpCtx->glVis)

+		_mesa_destroy_visual(lpCtx->glVis);

+

+	_gldDriver.DestroyDrawable(lpCtx);

+#else

+	// Destroy the Mesa context

+    WARN_MESSAGE(gl_destroy_framebuffer);

+	if (lpCtx->glBuffer)

+		(*mesaFuncs.gl_destroy_framebuffer)(lpCtx->glBuffer);

+    WARN_MESSAGE(gl_destroy_context);

+	if (lpCtx->glCtx)

+		(*mesaFuncs.gl_destroy_context)(lpCtx->glCtx);

+    WARN_MESSAGE(gl_destroy_visual);

+	if (lpCtx->glVis)

+		(*mesaFuncs.gl_destroy_visual)(lpCtx->glVis);

+

+	SAFE_RELEASE(lpCtx->m_pvbuf); // release D3D vertex buffer

+	SAFE_RELEASE(lpCtx->m_vbuf); // release D3D vertex buffer

+

+	// Delete the global palette

+	SAFE_RELEASE(lpCtx->lpGlobalPalette);

+

+	// Clean up.

+	if (lpCtx->lpViewport3) {

+		if (lpCtx->lpDev3) IDirect3DDevice3_DeleteViewport(lpCtx->lpDev3, lpCtx->lpViewport3);

+		SAFE_RELEASE(lpCtx->lpViewport3);

+		lpCtx->lpViewport3 = NULL;

+	}

+

+	SAFE_RELEASE(lpCtx->lpDev3);

+	if (lpCtx->lpDepth4) {

+		if (lpCtx->lpBack4)

+			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpBack4, 0L, lpCtx->lpDepth4);

+		else

+			IDirectDrawSurface4_DeleteAttachedSurface(lpCtx->lpFront4, 0L, lpCtx->lpDepth4);

+		SAFE_RELEASE(lpCtx->lpDepth4);

+		lpCtx->lpDepth4 = NULL;

+	}

+	SAFE_RELEASE(lpCtx->lpBack4);

+	SAFE_RELEASE(lpCtx->lpFront4);

+	if (lpCtx->bFullscreen) {

+		IDirectDraw4_RestoreDisplayMode(lpCtx->lpDD4);

+		IDirectDraw4_SetCooperativeLevel(lpCtx->lpDD4, NULL, DDSCL_NORMAL);

+	}

+	SAFE_RELEASE(lpCtx->lpD3D3);

+	SAFE_RELEASE(lpCtx->lpDD4);

+	SAFE_RELEASE(lpCtx->lpDD1);

+#endif // _ULSE_GLD3_WGL

+

+}

+__except(EXCEPTION_EXECUTE_HANDLER) {

+    ddlogPrintf(DDLOG_WARN, "Exception raised in dglDeleteContext: %s", argstr);

+}

+

+	// Restore the window message handler because this context may be used

+	// again by another window with a *different* message handler. (DaveM)

+	if (lpCtx->lpfnWndProc) {

+		SetWindowLong(lpCtx->hWnd, GWL_WNDPROC, (LONG)lpCtx->lpfnWndProc);

+		lpCtx->lpfnWndProc = (LONG)NULL;

+		}

+

+	lpCtx->bAllocated = FALSE; // This context is now free for use

+

+#ifdef GLD_THREADS

+	// Release serialized access

+	if (glb.bMultiThreaded)

+		LeaveCriticalSection(&CriticalSection);

+#endif

+

+	return TRUE;

+}

+

+// ***********************************************************************

+

+BOOL dglSwapBuffers(

+	HDC hDC)

+{

+	RECT		rSrcRect;	// Source rectangle

+	RECT		rDstRect;	// Destination rectangle

+	POINT		pt;

+	HRESULT		hResult;

+

+	DDBLTFX		bltFX;

+	DWORD		dwBlitFlags;

+	DDBLTFX		*lpBltFX;

+

+//	DWORD		dwThreadId = GetCurrentThreadId();

+	HGLRC		hGLRC = dglGetCurrentContext();

+	DGL_ctx		*lpCtx = dglGetContextAddress(hGLRC);

+	HWND		hWnd;

+

+	HDC 		hDCAux;		// for memory DC

+	int 		x,y,w,h;	// for memory DC BitBlt

+

+#if 0	// Perhaps not a good idea. Called too often. KH

+	// Validate license

+	if (!dglValidate())

+		return FALSE;

+#endif

+

+	if (!lpCtx) {

+		return TRUE; //FALSE; // No current context

+	}

+

+	if (!lpCtx->bCanRender) {

+		// Don't return false else some apps will bail.

+		return TRUE;

+	}

+

+	hWnd = lpCtx->hWnd;

+	if (hDC != lpCtx->hDC) {

+		ddlogPrintf(DDLOG_WARN, "dglSwapBuffers: HDC=%X does not match HDC=%X for HGLRC=%d", hDC, lpCtx->hDC, hGLRC);

+		hWnd = WindowFromDC(hDC);

+	}

+

+#ifndef _USE_GLD3_WGL

+	// Ensure that the surfaces exist before we tell

+	// the device to render to them.

+	IDirectDraw4_RestoreAllSurfaces(lpCtx->lpDD4);

+

+	// Make sure that the vertex caches have been emptied

+//	dglStateChange(lpCtx);

+

+	// Some OpenGL programs don't issue a glFinish - check for it here.

+	if (lpCtx->bSceneStarted) {

+		IDirect3DDevice3_EndScene(lpCtx->lpDev3);

+		lpCtx->bSceneStarted = FALSE;

+	}

+#endif

+

+#if 0

+	// If the calling app is not active then we don't need to Blit/Flip.

+	// We can therefore simply return TRUE.

+	if (!glb.bAppActive)

+		return TRUE;

+	// Addendum: This is WRONG! We should bail if the app is *minimized*,

+	//           not merely if the app is just plain 'not active'.

+	//           KeithH, 27/May/2000.

+#endif

+

+	// Check for non-window DC = memory DC ?

+	if (hWnd == NULL) {

+		if (GetClipBox(hDC, &rSrcRect) == ERROR)

+			return TRUE;

+		// Use GDI BitBlt instead from compatible DirectDraw DC

+		x = rSrcRect.left;

+		y = rSrcRect.top;

+		w = rSrcRect.right - rSrcRect.left;

+		h = rSrcRect.bottom - rSrcRect.top;

+

+		// Ack. DX8 does not have a GetDC() function...

+                // TODO: Defer to DX7 or DX9 drivers... (DaveM)

+		return TRUE;

+	}

+

+	// Bail if window client region is not drawable, like in Solid Edge

+	if (!IsWindow(hWnd) /* || !IsWindowVisible(hWnd) */ || !GetClientRect(hWnd, &rSrcRect))

+		return TRUE;

+

+#ifdef GLD_THREADS

+	// Serialize access to DirectDraw or DDS operations

+	if (glb.bMultiThreaded)

+		EnterCriticalSection(&CriticalSection);

+#endif

+

+#ifdef _USE_GLD3_WGL

+	// Notify Mesa of impending swap, so Mesa can flush internal buffers.

+	_mesa_notifySwapBuffers(lpCtx->glCtx);

+	// Now perform driver buffer swap

+	_gldDriver.SwapBuffers(lpCtx, hDC, hWnd);

+#else

+	if (lpCtx->bFullscreen) {

+		// Sync with retrace if required

+		if (glb.bWaitForRetrace) {

+			IDirectDraw4_WaitForVerticalBlank(

+				lpCtx->lpDD4,

+				DDWAITVB_BLOCKBEGIN,

+				0);

+		}

+

+		// Perform the fullscreen flip

+		TRY(IDirectDrawSurface4_Flip(

+			lpCtx->lpFront4,

+			NULL,

+			DDFLIP_WAIT),

+			"dglSwapBuffers: Flip");

+	} else {

+		// Calculate current window position and size

+		pt.x = pt.y = 0;

+		ClientToScreen(hWnd, &pt);

+		GetClientRect(hWnd, &rDstRect);

+		if (rDstRect.right > lpCtx->dwModeWidth)

+			rDstRect.right = lpCtx->dwModeWidth;

+		if (rDstRect.bottom > lpCtx->dwModeHeight)

+			rDstRect.bottom = lpCtx->dwModeHeight;

+		OffsetRect(&rDstRect, pt.x, pt.y);

+		rSrcRect.left = rSrcRect.top = 0;

+		rSrcRect.right = lpCtx->dwWidth;

+		rSrcRect.bottom = lpCtx->dwHeight;

+		if (rSrcRect.right > lpCtx->dwModeWidth)

+			rSrcRect.right = lpCtx->dwModeWidth;

+		if (rSrcRect.bottom > lpCtx->dwModeHeight)

+			rSrcRect.bottom = lpCtx->dwModeHeight;

+

+		if (glb.bWaitForRetrace) {

+			// Sync the blit to the vertical retrace

+			ZeroMemory(&bltFX, sizeof(bltFX));

+			bltFX.dwSize = sizeof(bltFX);

+			bltFX.dwDDFX = DDBLTFX_NOTEARING;

+			dwBlitFlags = DDBLT_WAIT | DDBLT_DDFX;

+			lpBltFX = &bltFX;

+		} else {

+			dwBlitFlags = DDBLT_WAIT;

+			lpBltFX = NULL;

+		}

+

+		// Perform the actual blit

+		TRY(IDirectDrawSurface4_Blt(

+			lpCtx->lpFront4,

+			&rDstRect,

+			lpCtx->lpBack4, // Blit source

+			&rSrcRect,

+			dwBlitFlags,

+			lpBltFX),

+			"dglSwapBuffers: Blt");

+	}

+#endif // _USE_GLD3_WGL

+

+#ifdef GLD_THREADS

+	// Release serialized access

+	if (glb.bMultiThreaded)

+		LeaveCriticalSection(&CriticalSection);

+#endif

+

+    // TODO: Re-instate rendering bitmap snapshot feature??? (DaveM)

+

+	// Render frame is completed

+	ValidateRect(hWnd, NULL);

+	lpCtx->bFrameStarted = FALSE;

+

+	return TRUE;

+}

+

+// ***********************************************************************

diff --git a/mesalib/src/mesa/main/api_arrayelt.c b/mesalib/src/mesa/main/api_arrayelt.c
index 080c20606..3c59e9be3 100644
--- a/mesalib/src/mesa/main/api_arrayelt.c
+++ b/mesalib/src/mesa/main/api_arrayelt.c
@@ -51,7 +51,7 @@ typedef struct {
    int offset;

 } AEarray;

 

-typedef void (GLAPIENTRY *attrib_func)( GLuint indx, const void *data );

+typedef void (*attrib_func)( GLuint indx, const void *data );

 

 typedef struct {

    const struct gl_client_array *array;

diff --git a/mesalib/src/mesa/main/api_exec.c b/mesalib/src/mesa/main/api_exec.c
index d7a4c90d7..02e39c189 100644
--- a/mesalib/src/mesa/main/api_exec.c
+++ b/mesalib/src/mesa/main/api_exec.c
@@ -104,7 +104,6 @@
 

 #if FEATURE_GL

 

-

 /**

  * Initialize a dispatch table with pointers to Mesa's immediate-mode

  * commands.

diff --git a/mesalib/src/mesa/main/attrib.c b/mesalib/src/mesa/main/attrib.c
index ae7f633b8..3a6239afd 100644
--- a/mesalib/src/mesa/main/attrib.c
+++ b/mesalib/src/mesa/main/attrib.c
@@ -1,1555 +1,1555 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "glheader.h"
-#include "imports.h"
-#include "accum.h"
-#include "arrayobj.h"
-#include "attrib.h"
-#include "blend.h"
-#include "buffers.h"
-#include "bufferobj.h"
-#include "clear.h"
-#include "colormac.h"
-#include "context.h"
-#include "depth.h"
-#include "enable.h"
-#include "enums.h"
-#include "fog.h"
-#include "hint.h"
-#include "light.h"
-#include "lines.h"
-#include "macros.h"
-#include "matrix.h"
-#include "mfeatures.h"
-#include "multisample.h"
-#include "points.h"
-#include "polygon.h"
-#include "scissor.h"
-#include "stencil.h"
-#include "texenv.h"
-#include "texgen.h"
-#include "texobj.h"
-#include "texparam.h"
-#include "texstate.h"
-#include "varray.h"
-#include "viewport.h"
-#include "mtypes.h"
-#include "main/dispatch.h"
-
-
-/**
- * glEnable()/glDisable() attribute group (GL_ENABLE_BIT).
- */
-struct gl_enable_attrib
-{
-   GLboolean AlphaTest;
-   GLboolean AutoNormal;
-   GLboolean Blend;
-   GLbitfield ClipPlanes;
-   GLboolean ColorMaterial;
-   GLboolean CullFace;
-   GLboolean DepthClamp;
-   GLboolean DepthTest;
-   GLboolean Dither;
-   GLboolean Fog;
-   GLboolean Light[MAX_LIGHTS];
-   GLboolean Lighting;
-   GLboolean LineSmooth;
-   GLboolean LineStipple;
-   GLboolean IndexLogicOp;
-   GLboolean ColorLogicOp;
-
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
-
-   GLboolean Normalize;
-   GLboolean PixelTexture;
-   GLboolean PointSmooth;
-   GLboolean PolygonOffsetPoint;
-   GLboolean PolygonOffsetLine;
-   GLboolean PolygonOffsetFill;
-   GLboolean PolygonSmooth;
-   GLboolean PolygonStipple;
-   GLboolean RescaleNormals;
-   GLboolean Scissor;
-   GLboolean Stencil;
-   GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */
-   GLboolean MultisampleEnabled;      /* GL_ARB_multisample */
-   GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */
-   GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */
-   GLboolean SampleCoverage;          /* GL_ARB_multisample */
-   GLboolean SampleCoverageInvert;    /* GL_ARB_multisample */
-   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
-
-   GLbitfield Texture[MAX_TEXTURE_UNITS];
-   GLbitfield TexGen[MAX_TEXTURE_UNITS];
-
-   /* GL_ARB_vertex_program / GL_NV_vertex_program */
-   GLboolean VertexProgram;
-   GLboolean VertexProgramPointSize;
-   GLboolean VertexProgramTwoSide;
-
-   /* GL_ARB_point_sprite / GL_NV_point_sprite */
-   GLboolean PointSprite;
-   GLboolean FragmentShaderATI;
-};
-
-
-/**
- * Node for the attribute stack.
- */
-struct gl_attrib_node
-{
-   GLbitfield kind;
-   void *data;
-   struct gl_attrib_node *next;
-};
-
-
-
-/**
- * Special struct for saving/restoring texture state (GL_TEXTURE_BIT)
- */
-struct texture_state
-{
-   struct gl_texture_attrib Texture;  /**< The usual context state */
-
-   /** to save per texture object state (wrap modes, filters, etc): */
-   struct gl_texture_object SavedObj[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];
-
-   /**
-    * To save references to texture objects (so they don't get accidentally
-    * deleted while saved in the attribute stack).
-    */
-   struct gl_texture_object *SavedTexRef[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];
-};
-
-
-#if FEATURE_attrib_stack
-
-
-/**
- * Allocate new attribute node of given type/kind.  Attach payload data.
- * Insert it into the linked list named by 'head'.
- */
-static void
-save_attrib_data(struct gl_attrib_node **head,
-                 GLbitfield kind, void *payload)
-{
-   struct gl_attrib_node *n = MALLOC_STRUCT(gl_attrib_node);
-   if (n) {
-      n->kind = kind;
-      n->data = payload;
-      /* insert at head */
-      n->next = *head;
-      *head = n;
-   }
-   else {
-      /* out of memory! */
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_PushAttrib(GLbitfield mask)
-{
-   struct gl_attrib_node *head;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glPushAttrib %x\n", (int) mask);
-
-   if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) {
-      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" );
-      return;
-   }
-
-   /* Build linked list of attribute nodes which save all attribute */
-   /* groups specified by the mask. */
-   head = NULL;
-
-   if (mask & GL_ACCUM_BUFFER_BIT) {
-      struct gl_accum_attrib *attr;
-      attr = MALLOC_STRUCT( gl_accum_attrib );
-      memcpy( attr, &ctx->Accum, sizeof(struct gl_accum_attrib) );
-      save_attrib_data(&head, GL_ACCUM_BUFFER_BIT, attr);
-   }
-
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      GLuint i;
-      struct gl_colorbuffer_attrib *attr;
-      attr = MALLOC_STRUCT( gl_colorbuffer_attrib );
-      memcpy( attr, &ctx->Color, sizeof(struct gl_colorbuffer_attrib) );
-      /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */
-      for (i = 0; i < ctx->Const.MaxDrawBuffers; i ++)
-         attr->DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i];
-      save_attrib_data(&head, GL_COLOR_BUFFER_BIT, attr);
-   }
-
-   if (mask & GL_CURRENT_BIT) {
-      struct gl_current_attrib *attr;
-      FLUSH_CURRENT( ctx, 0 );
-      attr = MALLOC_STRUCT( gl_current_attrib );
-      memcpy( attr, &ctx->Current, sizeof(struct gl_current_attrib) );
-      save_attrib_data(&head, GL_CURRENT_BIT, attr);
-   }
-
-   if (mask & GL_DEPTH_BUFFER_BIT) {
-      struct gl_depthbuffer_attrib *attr;
-      attr = MALLOC_STRUCT( gl_depthbuffer_attrib );
-      memcpy( attr, &ctx->Depth, sizeof(struct gl_depthbuffer_attrib) );
-      save_attrib_data(&head, GL_DEPTH_BUFFER_BIT, attr);
-   }
-
-   if (mask & GL_ENABLE_BIT) {
-      struct gl_enable_attrib *attr;
-      GLuint i;
-      attr = MALLOC_STRUCT( gl_enable_attrib );
-      /* Copy enable flags from all other attributes into the enable struct. */
-      attr->AlphaTest = ctx->Color.AlphaEnabled;
-      attr->AutoNormal = ctx->Eval.AutoNormal;
-      attr->Blend = ctx->Color.BlendEnabled;
-      attr->ClipPlanes = ctx->Transform.ClipPlanesEnabled;
-      attr->ColorMaterial = ctx->Light.ColorMaterialEnabled;
-      attr->CullFace = ctx->Polygon.CullFlag;
-      attr->DepthClamp = ctx->Transform.DepthClamp;
-      attr->DepthTest = ctx->Depth.Test;
-      attr->Dither = ctx->Color.DitherFlag;
-      attr->Fog = ctx->Fog.Enabled;
-      for (i = 0; i < ctx->Const.MaxLights; i++) {
-         attr->Light[i] = ctx->Light.Light[i].Enabled;
-      }
-      attr->Lighting = ctx->Light.Enabled;
-      attr->LineSmooth = ctx->Line.SmoothFlag;
-      attr->LineStipple = ctx->Line.StippleFlag;
-      attr->IndexLogicOp = ctx->Color.IndexLogicOpEnabled;
-      attr->ColorLogicOp = ctx->Color.ColorLogicOpEnabled;
-      attr->Map1Color4 = ctx->Eval.Map1Color4;
-      attr->Map1Index = ctx->Eval.Map1Index;
-      attr->Map1Normal = ctx->Eval.Map1Normal;
-      attr->Map1TextureCoord1 = ctx->Eval.Map1TextureCoord1;
-      attr->Map1TextureCoord2 = ctx->Eval.Map1TextureCoord2;
-      attr->Map1TextureCoord3 = ctx->Eval.Map1TextureCoord3;
-      attr->Map1TextureCoord4 = ctx->Eval.Map1TextureCoord4;
-      attr->Map1Vertex3 = ctx->Eval.Map1Vertex3;
-      attr->Map1Vertex4 = ctx->Eval.Map1Vertex4;
-      memcpy(attr->Map1Attrib, ctx->Eval.Map1Attrib, sizeof(ctx->Eval.Map1Attrib));
-      attr->Map2Color4 = ctx->Eval.Map2Color4;
-      attr->Map2Index = ctx->Eval.Map2Index;
-      attr->Map2Normal = ctx->Eval.Map2Normal;
-      attr->Map2TextureCoord1 = ctx->Eval.Map2TextureCoord1;
-      attr->Map2TextureCoord2 = ctx->Eval.Map2TextureCoord2;
-      attr->Map2TextureCoord3 = ctx->Eval.Map2TextureCoord3;
-      attr->Map2TextureCoord4 = ctx->Eval.Map2TextureCoord4;
-      attr->Map2Vertex3 = ctx->Eval.Map2Vertex3;
-      attr->Map2Vertex4 = ctx->Eval.Map2Vertex4;
-      memcpy(attr->Map2Attrib, ctx->Eval.Map2Attrib, sizeof(ctx->Eval.Map2Attrib));
-      attr->Normalize = ctx->Transform.Normalize;
-      attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped;
-      attr->PointSmooth = ctx->Point.SmoothFlag;
-      attr->PointSprite = ctx->Point.PointSprite;
-      attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint;
-      attr->PolygonOffsetLine = ctx->Polygon.OffsetLine;
-      attr->PolygonOffsetFill = ctx->Polygon.OffsetFill;
-      attr->PolygonSmooth = ctx->Polygon.SmoothFlag;
-      attr->PolygonStipple = ctx->Polygon.StippleFlag;
-      attr->RescaleNormals = ctx->Transform.RescaleNormals;
-      attr->Scissor = ctx->Scissor.Enabled;
-      attr->Stencil = ctx->Stencil.Enabled;
-      attr->StencilTwoSide = ctx->Stencil.TestTwoSide;
-      attr->MultisampleEnabled = ctx->Multisample.Enabled;
-      attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage;
-      attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne;
-      attr->SampleCoverage = ctx->Multisample.SampleCoverage;
-      attr->SampleCoverageInvert = ctx->Multisample.SampleCoverageInvert;
-      for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-         attr->Texture[i] = ctx->Texture.Unit[i].Enabled;
-         attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;
-      }
-      /* GL_NV_vertex_program */
-      attr->VertexProgram = ctx->VertexProgram.Enabled;
-      attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled;
-      attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled;
-      save_attrib_data(&head, GL_ENABLE_BIT, attr);
-   }
-
-   if (mask & GL_EVAL_BIT) {
-      struct gl_eval_attrib *attr;
-      attr = MALLOC_STRUCT( gl_eval_attrib );
-      memcpy( attr, &ctx->Eval, sizeof(struct gl_eval_attrib) );
-      save_attrib_data(&head, GL_EVAL_BIT, attr);
-   }
-
-   if (mask & GL_FOG_BIT) {
-      struct gl_fog_attrib *attr;
-      attr = MALLOC_STRUCT( gl_fog_attrib );
-      memcpy( attr, &ctx->Fog, sizeof(struct gl_fog_attrib) );
-      save_attrib_data(&head, GL_FOG_BIT, attr);
-   }
-
-   if (mask & GL_HINT_BIT) {
-      struct gl_hint_attrib *attr;
-      attr = MALLOC_STRUCT( gl_hint_attrib );
-      memcpy( attr, &ctx->Hint, sizeof(struct gl_hint_attrib) );
-      save_attrib_data(&head, GL_HINT_BIT, attr);
-   }
-
-   if (mask & GL_LIGHTING_BIT) {
-      struct gl_light_attrib *attr;
-      FLUSH_CURRENT(ctx, 0);	/* flush material changes */
-      attr = MALLOC_STRUCT( gl_light_attrib );
-      memcpy( attr, &ctx->Light, sizeof(struct gl_light_attrib) );
-      save_attrib_data(&head, GL_LIGHTING_BIT, attr);
-   }
-
-   if (mask & GL_LINE_BIT) {
-      struct gl_line_attrib *attr;
-      attr = MALLOC_STRUCT( gl_line_attrib );
-      memcpy( attr, &ctx->Line, sizeof(struct gl_line_attrib) );
-      save_attrib_data(&head, GL_LINE_BIT, attr);
-   }
-
-   if (mask & GL_LIST_BIT) {
-      struct gl_list_attrib *attr;
-      attr = MALLOC_STRUCT( gl_list_attrib );
-      memcpy( attr, &ctx->List, sizeof(struct gl_list_attrib) );
-      save_attrib_data(&head, GL_LIST_BIT, attr);
-   }
-
-   if (mask & GL_PIXEL_MODE_BIT) {
-      struct gl_pixel_attrib *attr;
-      attr = MALLOC_STRUCT( gl_pixel_attrib );
-      memcpy( attr, &ctx->Pixel, sizeof(struct gl_pixel_attrib) );
-      /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */
-      attr->ReadBuffer = ctx->ReadBuffer->ColorReadBuffer;
-      save_attrib_data(&head, GL_PIXEL_MODE_BIT, attr);
-   }
-
-   if (mask & GL_POINT_BIT) {
-      struct gl_point_attrib *attr;
-      attr = MALLOC_STRUCT( gl_point_attrib );
-      memcpy( attr, &ctx->Point, sizeof(struct gl_point_attrib) );
-      save_attrib_data(&head, GL_POINT_BIT, attr);
-   }
-
-   if (mask & GL_POLYGON_BIT) {
-      struct gl_polygon_attrib *attr;
-      attr = MALLOC_STRUCT( gl_polygon_attrib );
-      memcpy( attr, &ctx->Polygon, sizeof(struct gl_polygon_attrib) );
-      save_attrib_data(&head, GL_POLYGON_BIT, attr);
-   }
-
-   if (mask & GL_POLYGON_STIPPLE_BIT) {
-      GLuint *stipple;
-      stipple = (GLuint *) MALLOC( 32*sizeof(GLuint) );
-      memcpy( stipple, ctx->PolygonStipple, 32*sizeof(GLuint) );
-      save_attrib_data(&head, GL_POLYGON_STIPPLE_BIT, stipple);
-   }
-
-   if (mask & GL_SCISSOR_BIT) {
-      struct gl_scissor_attrib *attr;
-      attr = MALLOC_STRUCT( gl_scissor_attrib );
-      memcpy( attr, &ctx->Scissor, sizeof(struct gl_scissor_attrib) );
-      save_attrib_data(&head, GL_SCISSOR_BIT, attr);
-   }
-
-   if (mask & GL_STENCIL_BUFFER_BIT) {
-      struct gl_stencil_attrib *attr;
-      attr = MALLOC_STRUCT( gl_stencil_attrib );
-      memcpy( attr, &ctx->Stencil, sizeof(struct gl_stencil_attrib) );
-      save_attrib_data(&head, GL_STENCIL_BUFFER_BIT, attr);
-   }
-
-   if (mask & GL_TEXTURE_BIT) {
-      struct texture_state *texstate = CALLOC_STRUCT(texture_state);
-      GLuint u, tex;
-
-      if (!texstate) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)");
-         goto end;
-      }
-
-      _mesa_lock_context_textures(ctx);
-
-      /* copy/save the bulk of texture state here */
-      memcpy(&texstate->Texture, &ctx->Texture, sizeof(ctx->Texture));
-
-      /* Save references to the currently bound texture objects so they don't
-       * accidentally get deleted while referenced in the attribute stack.
-       */
-      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
-            _mesa_reference_texobj(&texstate->SavedTexRef[u][tex],
-                                   ctx->Texture.Unit[u].CurrentTex[tex]);
-         }
-      }
-
-      /* copy state/contents of the currently bound texture objects */
-      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
-            _mesa_copy_texture_object(&texstate->SavedObj[u][tex],
-                                      ctx->Texture.Unit[u].CurrentTex[tex]);
-         }
-      }
-
-      _mesa_unlock_context_textures(ctx);
-
-      save_attrib_data(&head, GL_TEXTURE_BIT, texstate);
-   }
-
-   if (mask & GL_TRANSFORM_BIT) {
-      struct gl_transform_attrib *attr;
-      attr = MALLOC_STRUCT( gl_transform_attrib );
-      memcpy( attr, &ctx->Transform, sizeof(struct gl_transform_attrib) );
-      save_attrib_data(&head, GL_TRANSFORM_BIT, attr);
-   }
-
-   if (mask & GL_VIEWPORT_BIT) {
-      struct gl_viewport_attrib *attr;
-      attr = MALLOC_STRUCT( gl_viewport_attrib );
-      memcpy( attr, &ctx->Viewport, sizeof(struct gl_viewport_attrib) );
-      save_attrib_data(&head, GL_VIEWPORT_BIT, attr);
-   }
-
-   /* GL_ARB_multisample */
-   if (mask & GL_MULTISAMPLE_BIT_ARB) {
-      struct gl_multisample_attrib *attr;
-      attr = MALLOC_STRUCT( gl_multisample_attrib );
-      memcpy( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) );
-      save_attrib_data(&head, GL_MULTISAMPLE_BIT_ARB, attr);
-   }
-
-end:
-   ctx->AttribStack[ctx->AttribStackDepth] = head;
-   ctx->AttribStackDepth++;
-}
-
-
-
-static void
-pop_enable_group(struct gl_context *ctx, const struct gl_enable_attrib *enable)
-{
-   const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;
-   GLuint i;
-
-#define TEST_AND_UPDATE(VALUE, NEWVALUE, ENUM)		\
-	if ((VALUE) != (NEWVALUE)) {			\
-	   _mesa_set_enable( ctx, ENUM, (NEWVALUE) );	\
-	}
-
-   TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST);
-   if (ctx->Color.BlendEnabled != enable->Blend) {
-      if (ctx->Extensions.EXT_draw_buffers2) {
-         GLuint i;
-         for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-            _mesa_set_enablei(ctx, GL_BLEND, i, (enable->Blend >> i) & 1);
-         }
-      }
-      else {
-         _mesa_set_enable(ctx, GL_BLEND, (enable->Blend & 1));
-      }
-   }
-
-   for (i=0;i<MAX_CLIP_PLANES;i++) {
-      const GLuint mask = 1 << i;
-      if ((ctx->Transform.ClipPlanesEnabled & mask) != (enable->ClipPlanes & mask))
-	  _mesa_set_enable(ctx, (GLenum) (GL_CLIP_PLANE0 + i),
-			   (GLboolean) ((enable->ClipPlanes & mask) ? GL_TRUE : GL_FALSE));
-   }
-
-   TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, enable->ColorMaterial,
-                   GL_COLOR_MATERIAL);
-   TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);
-   TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,
-		   GL_DEPTH_CLAMP);
-   TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);
-   TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);
-   TEST_AND_UPDATE(ctx->Fog.Enabled, enable->Fog, GL_FOG);
-   TEST_AND_UPDATE(ctx->Light.Enabled, enable->Lighting, GL_LIGHTING);
-   TEST_AND_UPDATE(ctx->Line.SmoothFlag, enable->LineSmooth, GL_LINE_SMOOTH);
-   TEST_AND_UPDATE(ctx->Line.StippleFlag, enable->LineStipple,
-                   GL_LINE_STIPPLE);
-   TEST_AND_UPDATE(ctx->Color.IndexLogicOpEnabled, enable->IndexLogicOp,
-                   GL_INDEX_LOGIC_OP);
-   TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, enable->ColorLogicOp,
-                   GL_COLOR_LOGIC_OP);
-
-   TEST_AND_UPDATE(ctx->Eval.Map1Color4, enable->Map1Color4, GL_MAP1_COLOR_4);
-   TEST_AND_UPDATE(ctx->Eval.Map1Index, enable->Map1Index, GL_MAP1_INDEX);
-   TEST_AND_UPDATE(ctx->Eval.Map1Normal, enable->Map1Normal, GL_MAP1_NORMAL);
-   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord1, enable->Map1TextureCoord1,
-                   GL_MAP1_TEXTURE_COORD_1);
-   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord2, enable->Map1TextureCoord2,
-                   GL_MAP1_TEXTURE_COORD_2);
-   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord3, enable->Map1TextureCoord3,
-                   GL_MAP1_TEXTURE_COORD_3);
-   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord4, enable->Map1TextureCoord4,
-                   GL_MAP1_TEXTURE_COORD_4);
-   TEST_AND_UPDATE(ctx->Eval.Map1Vertex3, enable->Map1Vertex3,
-                   GL_MAP1_VERTEX_3);
-   TEST_AND_UPDATE(ctx->Eval.Map1Vertex4, enable->Map1Vertex4,
-                   GL_MAP1_VERTEX_4);
-   for (i = 0; i < 16; i++) {
-      TEST_AND_UPDATE(ctx->Eval.Map1Attrib[i], enable->Map1Attrib[i],
-                      GL_MAP1_VERTEX_ATTRIB0_4_NV + i);
-   }
-
-   TEST_AND_UPDATE(ctx->Eval.Map2Color4, enable->Map2Color4, GL_MAP2_COLOR_4);
-   TEST_AND_UPDATE(ctx->Eval.Map2Index, enable->Map2Index, GL_MAP2_INDEX);
-   TEST_AND_UPDATE(ctx->Eval.Map2Normal, enable->Map2Normal, GL_MAP2_NORMAL);
-   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord1, enable->Map2TextureCoord1,
-                   GL_MAP2_TEXTURE_COORD_1);
-   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord2, enable->Map2TextureCoord2,
-                   GL_MAP2_TEXTURE_COORD_2);
-   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord3, enable->Map2TextureCoord3,
-                   GL_MAP2_TEXTURE_COORD_3);
-   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord4, enable->Map2TextureCoord4,
-                   GL_MAP2_TEXTURE_COORD_4);
-   TEST_AND_UPDATE(ctx->Eval.Map2Vertex3, enable->Map2Vertex3,
-                   GL_MAP2_VERTEX_3);
-   TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4,
-                   GL_MAP2_VERTEX_4);
-   for (i = 0; i < 16; i++) {
-      TEST_AND_UPDATE(ctx->Eval.Map2Attrib[i], enable->Map2Attrib[i],
-                      GL_MAP2_VERTEX_ATTRIB0_4_NV + i);
-   }
-
-   TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL);
-   TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE);
-   TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals,
-                   GL_RESCALE_NORMAL_EXT);
-   TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped,
-                   enable->RasterPositionUnclipped,
-                   GL_RASTER_POSITION_UNCLIPPED_IBM);
-   TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth,
-                   GL_POINT_SMOOTH);
-   if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite) {
-      TEST_AND_UPDATE(ctx->Point.PointSprite, enable->PointSprite,
-                      GL_POINT_SPRITE_NV);
-   }
-   TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, enable->PolygonOffsetPoint,
-                   GL_POLYGON_OFFSET_POINT);
-   TEST_AND_UPDATE(ctx->Polygon.OffsetLine, enable->PolygonOffsetLine,
-                   GL_POLYGON_OFFSET_LINE);
-   TEST_AND_UPDATE(ctx->Polygon.OffsetFill, enable->PolygonOffsetFill,
-                   GL_POLYGON_OFFSET_FILL);
-   TEST_AND_UPDATE(ctx->Polygon.SmoothFlag, enable->PolygonSmooth,
-                   GL_POLYGON_SMOOTH);
-   TEST_AND_UPDATE(ctx->Polygon.StippleFlag, enable->PolygonStipple,
-                   GL_POLYGON_STIPPLE);
-   TEST_AND_UPDATE(ctx->Scissor.Enabled, enable->Scissor, GL_SCISSOR_TEST);
-   TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST);
-   if (ctx->Extensions.EXT_stencil_two_side) {
-      TEST_AND_UPDATE(ctx->Stencil.TestTwoSide, enable->StencilTwoSide, GL_STENCIL_TEST_TWO_SIDE_EXT);
-   }
-   TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled,
-                   GL_MULTISAMPLE_ARB);
-   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage,
-                   enable->SampleAlphaToCoverage,
-                   GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
-   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne,
-                   enable->SampleAlphaToOne,
-                   GL_SAMPLE_ALPHA_TO_ONE_ARB);
-   TEST_AND_UPDATE(ctx->Multisample.SampleCoverage,
-                   enable->SampleCoverage,
-                   GL_SAMPLE_COVERAGE_ARB);
-   TEST_AND_UPDATE(ctx->Multisample.SampleCoverageInvert,
-                   enable->SampleCoverageInvert,
-                   GL_SAMPLE_COVERAGE_INVERT_ARB);
-   /* GL_ARB_vertex_program, GL_NV_vertex_program */
-   TEST_AND_UPDATE(ctx->VertexProgram.Enabled,
-                   enable->VertexProgram,
-                   GL_VERTEX_PROGRAM_ARB);
-   TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled,
-                   enable->VertexProgramPointSize,
-                   GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
-   TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled,
-                   enable->VertexProgramTwoSide,
-                   GL_VERTEX_PROGRAM_TWO_SIDE_ARB);
-
-#undef TEST_AND_UPDATE
-
-   /* texture unit enables */
-   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-      const GLbitfield enabled = enable->Texture[i];
-      const GLbitfield genEnabled = enable->TexGen[i];
-
-      if (ctx->Texture.Unit[i].Enabled != enabled) {
-         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);
-
-         _mesa_set_enable(ctx, GL_TEXTURE_1D,
-                          (enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_2D,
-                          (enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_3D,
-                          (enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE);
-         if (ctx->Extensions.NV_texture_rectangle) {
-            _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_ARB,
-                             (enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);
-         }
-         if (ctx->Extensions.ARB_texture_cube_map) {
-            _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP,
-                             (enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE);
-         }
-         if (ctx->Extensions.MESA_texture_array) {
-            _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,
-                           (enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
-            _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,
-                           (enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
-         }
-      }
-
-      if (ctx->Texture.Unit[i].TexGenEnabled != genEnabled) {
-         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);
-         _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,
-                          (genEnabled & S_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_GEN_T,
-                          (genEnabled & T_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_GEN_R,
-                          (genEnabled & R_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q,
-                          (genEnabled & Q_BIT) ? GL_TRUE : GL_FALSE);
-      }
-   }
-
-   _mesa_ActiveTextureARB(GL_TEXTURE0 + curTexUnitSave);
-}
-
-
-/**
- * Pop/restore texture attribute/group state.
- */
-static void
-pop_texture_group(struct gl_context *ctx, struct texture_state *texstate)
-{
-   GLuint u;
-
-   _mesa_lock_context_textures(ctx);
-
-   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-      const struct gl_texture_unit *unit = &texstate->Texture.Unit[u];
-      GLuint tgt;
-
-      _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + u);
-      _mesa_set_enable(ctx, GL_TEXTURE_1D,
-                       (unit->Enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE);
-      _mesa_set_enable(ctx, GL_TEXTURE_2D,
-                       (unit->Enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE);
-      _mesa_set_enable(ctx, GL_TEXTURE_3D,
-                       (unit->Enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE);
-      if (ctx->Extensions.ARB_texture_cube_map) {
-         _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP_ARB,
-                     (unit->Enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE);
-      }
-      if (ctx->Extensions.NV_texture_rectangle) {
-         _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV,
-                     (unit->Enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);
-      }
-      if (ctx->Extensions.MESA_texture_array) {
-         _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,
-                 (unit->Enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
-         _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,
-                 (unit->Enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
-      }
-
-      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode);
-      _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor);
-      _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenS.Mode);
-      _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenT.Mode);
-      _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenR.Mode);
-      _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenQ.Mode);
-      _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->GenS.ObjectPlane);
-      _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->GenT.ObjectPlane);
-      _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->GenR.ObjectPlane);
-      _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane);
-      /* Eye plane done differently to avoid re-transformation */
-      {
-         struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u];
-         COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane);
-         COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane);
-         COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane);
-         COPY_4FV(destUnit->GenQ.EyePlane, unit->GenQ.EyePlane);
-         if (ctx->Driver.TexGen) {
-            ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->GenS.EyePlane);
-            ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->GenT.EyePlane);
-            ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->GenR.EyePlane);
-            ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->GenQ.EyePlane);
-         }
-      }
-      _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,
-                       ((unit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE));
-      _mesa_set_enable(ctx, GL_TEXTURE_GEN_T,
-                       ((unit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE));
-      _mesa_set_enable(ctx, GL_TEXTURE_GEN_R,
-                       ((unit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE));
-      _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q,
-                       ((unit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE));
-      if (ctx->Extensions.EXT_texture_lod_bias) {
-         _mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
-                       GL_TEXTURE_LOD_BIAS_EXT, unit->LodBias);
-      }
-      if (ctx->Extensions.EXT_texture_env_combine ||
-          ctx->Extensions.ARB_texture_env_combine) {
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,
-                       unit->Combine.ModeRGB);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,
-                       unit->Combine.ModeA);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB,
-                       unit->Combine.SourceRGB[0]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB,
-                       unit->Combine.SourceRGB[1]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB,
-                       unit->Combine.SourceRGB[2]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA,
-                       unit->Combine.SourceA[0]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA,
-                       unit->Combine.SourceA[1]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA,
-                       unit->Combine.SourceA[2]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB,
-                       unit->Combine.OperandRGB[0]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB,
-                       unit->Combine.OperandRGB[1]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,
-                       unit->Combine.OperandRGB[2]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA,
-                       unit->Combine.OperandA[0]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA,
-                       unit->Combine.OperandA[1]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA,
-                       unit->Combine.OperandA[2]);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,
-                       1 << unit->Combine.ScaleShiftRGB);
-         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE,
-                       1 << unit->Combine.ScaleShiftA);
-      }
-
-      /* Restore texture object state for each target */
-      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-         const struct gl_texture_object *obj = NULL;
-         GLenum target;
-
-         obj = &texstate->SavedObj[u][tgt];
-
-         /* don't restore state for unsupported targets to prevent
-          * raising GL errors.
-          */
-         if (obj->Target == GL_TEXTURE_CUBE_MAP_ARB &&
-             !ctx->Extensions.ARB_texture_cube_map) {
-            continue;
-         }
-         else if (obj->Target == GL_TEXTURE_RECTANGLE_NV &&
-                  !ctx->Extensions.NV_texture_rectangle) {
-            continue;
-         }
-         else if ((obj->Target == GL_TEXTURE_1D_ARRAY_EXT ||
-                   obj->Target == GL_TEXTURE_2D_ARRAY_EXT) &&
-                  !ctx->Extensions.MESA_texture_array) {
-            continue;
-         }
-
-         target = obj->Target;
-
-         _mesa_BindTexture(target, obj->Name);
-
-         _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, obj->BorderColor.f);
-         _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS);
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT);
-         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, obj->WrapR);
-         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, obj->MinFilter);
-         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, obj->MagFilter);
-         _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod);
-         _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod);
-         _mesa_TexParameterf(target, GL_TEXTURE_LOD_BIAS, obj->LodBias);
-         _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);
-         if (target != GL_TEXTURE_RECTANGLE_ARB)
-            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-            _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
-                                obj->MaxAnisotropy);
-         }
-         if (ctx->Extensions.ARB_shadow_ambient) {
-            _mesa_TexParameterf(target, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB,
-                                obj->CompareFailValue);
-         }
-      }
-
-      /* remove saved references to the texture objects */
-      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);
-      }
-   }
-
-   _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + texstate->Texture.CurrentUnit);
-
-   _mesa_unlock_context_textures(ctx);
-}
-
-
-/*
- * This function is kind of long just because we have to call a lot
- * of device driver functions to update device driver state.
- *
- * XXX As it is now, most of the pop-code calls immediate-mode Mesa functions
- * in order to restore GL state.  This isn't terribly efficient but it
- * ensures that dirty flags and any derived state gets updated correctly.
- * We could at least check if the value to restore equals the current value
- * and then skip the Mesa call.
- */
-void GLAPIENTRY
-_mesa_PopAttrib(void)
-{
-   struct gl_attrib_node *attr, *next;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (ctx->AttribStackDepth == 0) {
-      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );
-      return;
-   }
-
-   ctx->AttribStackDepth--;
-   attr = ctx->AttribStack[ctx->AttribStackDepth];
-
-   while (attr) {
-
-      if (MESA_VERBOSE & VERBOSE_API) {
-         _mesa_debug(ctx, "glPopAttrib %s\n",
-                     _mesa_lookup_enum_by_nr(attr->kind));
-      }
-
-      switch (attr->kind) {
-         case GL_ACCUM_BUFFER_BIT:
-            {
-               const struct gl_accum_attrib *accum;
-               accum = (const struct gl_accum_attrib *) attr->data;
-               _mesa_ClearAccum(accum->ClearColor[0],
-                                accum->ClearColor[1],
-                                accum->ClearColor[2],
-                                accum->ClearColor[3]);
-            }
-            break;
-         case GL_COLOR_BUFFER_BIT:
-            {
-               const struct gl_colorbuffer_attrib *color;
-
-               color = (const struct gl_colorbuffer_attrib *) attr->data;
-               _mesa_ClearIndex((GLfloat) color->ClearIndex);
-               _mesa_ClearColor(color->ClearColor[0],
-                                color->ClearColor[1],
-                                color->ClearColor[2],
-                                color->ClearColor[3]);
-               _mesa_IndexMask(color->IndexMask);
-               if (!ctx->Extensions.EXT_draw_buffers2) {
-                  _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),
-                                  (GLboolean) (color->ColorMask[0][1] != 0),
-                                  (GLboolean) (color->ColorMask[0][2] != 0),
-                                  (GLboolean) (color->ColorMask[0][3] != 0));
-               }
-               else {
-                  GLuint i;
-                  for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-                     _mesa_ColorMaskIndexed(i, 
-                                  (GLboolean) (color->ColorMask[i][0] != 0),
-                                  (GLboolean) (color->ColorMask[i][1] != 0),
-                                  (GLboolean) (color->ColorMask[i][2] != 0),
-                                  (GLboolean) (color->ColorMask[i][3] != 0));
-                  }
-               }
-               {
-                  /* Need to determine if more than one color output is
-                   * specified.  If so, call glDrawBuffersARB, else call
-                   * glDrawBuffer().  This is a subtle, but essential point
-                   * since GL_FRONT (for example) is illegal for the former
-                   * function, but legal for the later.
-                   */
-                  GLboolean multipleBuffers = GL_FALSE;
-		  GLuint i;
-
-		  for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
-		     if (color->DrawBuffer[i] != GL_NONE) {
-			multipleBuffers = GL_TRUE;
-			break;
-		     }
-                  }
-                  /* Call the API_level functions, not _mesa_drawbuffers()
-                   * since we need to do error checking on the pop'd
-                   * GL_DRAW_BUFFER.
-                   * Ex: if GL_FRONT were pushed, but we're popping with a
-                   * user FBO bound, GL_FRONT will be illegal and we'll need
-                   * to record that error.  Per OpenGL ARB decision.
-                   */
-                  if (multipleBuffers)
-                     _mesa_DrawBuffersARB(ctx->Const.MaxDrawBuffers,
-                                          color->DrawBuffer);
-                  else
-                     _mesa_DrawBuffer(color->DrawBuffer[0]);
-               }
-               _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);
-               _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRef);
-               if (ctx->Color.BlendEnabled != color->BlendEnabled) {
-                  if (ctx->Extensions.EXT_draw_buffers2) {
-                     GLuint i;
-                     for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-                        _mesa_set_enablei(ctx, GL_BLEND, i,
-                                          (color->BlendEnabled >> i) & 1);
-                     }
-                  }
-                  else {
-                     _mesa_set_enable(ctx, GL_BLEND, (color->BlendEnabled & 1));
-                  }
-               }
-               if (ctx->Color._BlendFuncPerBuffer ||
-                   ctx->Color._BlendEquationPerBuffer) {
-                  /* set blend per buffer */
-                  GLuint buf;
-                  for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) {
-                     _mesa_BlendFuncSeparatei(buf, color->Blend[buf].SrcRGB,
-                                              color->Blend[buf].DstRGB,
-                                              color->Blend[buf].SrcA,
-                                              color->Blend[buf].DstA);
-                     _mesa_BlendEquationSeparatei(buf,
-                                                  color->Blend[buf].EquationRGB,
-                                                  color->Blend[buf].EquationA);
-                  }
-               }
-               else {
-                  /* set same blend modes for all buffers */
-                  _mesa_BlendFuncSeparateEXT(color->Blend[0].SrcRGB,
-                                             color->Blend[0].DstRGB,
-                                             color->Blend[0].SrcA,
-                                             color->Blend[0].DstA);
-                  /* This special case is because glBlendEquationSeparateEXT
-                   * cannot take GL_LOGIC_OP as a parameter.
-                   */
-                  if (color->Blend[0].EquationRGB ==
-                      color->Blend[0].EquationA) {
-                     _mesa_BlendEquation(color->Blend[0].EquationRGB);
-                  }
-                  else {
-                     _mesa_BlendEquationSeparateEXT(
-                                                 color->Blend[0].EquationRGB,
-                                                 color->Blend[0].EquationA);
-                  }
-               }
-               _mesa_BlendColor(color->BlendColor[0],
-                                color->BlendColor[1],
-                                color->BlendColor[2],
-                                color->BlendColor[3]);
-               _mesa_LogicOp(color->LogicOp);
-               _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP,
-                                color->ColorLogicOpEnabled);
-               _mesa_set_enable(ctx, GL_INDEX_LOGIC_OP,
-                                color->IndexLogicOpEnabled);
-               _mesa_set_enable(ctx, GL_DITHER, color->DitherFlag);
-            }
-            break;
-         case GL_CURRENT_BIT:
-	    FLUSH_CURRENT( ctx, 0 );
-            memcpy( &ctx->Current, attr->data,
-		    sizeof(struct gl_current_attrib) );
-            break;
-         case GL_DEPTH_BUFFER_BIT:
-            {
-               const struct gl_depthbuffer_attrib *depth;
-               depth = (const struct gl_depthbuffer_attrib *) attr->data;
-               _mesa_DepthFunc(depth->Func);
-               _mesa_ClearDepth(depth->Clear);
-               _mesa_set_enable(ctx, GL_DEPTH_TEST, depth->Test);
-               _mesa_DepthMask(depth->Mask);
-            }
-            break;
-         case GL_ENABLE_BIT:
-            {
-               const struct gl_enable_attrib *enable;
-               enable = (const struct gl_enable_attrib *) attr->data;
-               pop_enable_group(ctx, enable);
-	       ctx->NewState |= _NEW_ALL;
-            }
-            break;
-         case GL_EVAL_BIT:
-            memcpy( &ctx->Eval, attr->data, sizeof(struct gl_eval_attrib) );
-	    ctx->NewState |= _NEW_EVAL;
-            break;
-         case GL_FOG_BIT:
-            {
-               const struct gl_fog_attrib *fog;
-               fog = (const struct gl_fog_attrib *) attr->data;
-               _mesa_set_enable(ctx, GL_FOG, fog->Enabled);
-               _mesa_Fogfv(GL_FOG_COLOR, fog->Color);
-               _mesa_Fogf(GL_FOG_DENSITY, fog->Density);
-               _mesa_Fogf(GL_FOG_START, fog->Start);
-               _mesa_Fogf(GL_FOG_END, fog->End);
-               _mesa_Fogf(GL_FOG_INDEX, fog->Index);
-               _mesa_Fogi(GL_FOG_MODE, fog->Mode);
-            }
-            break;
-         case GL_HINT_BIT:
-            {
-               const struct gl_hint_attrib *hint;
-               hint = (const struct gl_hint_attrib *) attr->data;
-               _mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT,
-                          hint->PerspectiveCorrection );
-               _mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth);
-               _mesa_Hint(GL_LINE_SMOOTH_HINT, hint->LineSmooth);
-               _mesa_Hint(GL_POLYGON_SMOOTH_HINT, hint->PolygonSmooth);
-               _mesa_Hint(GL_FOG_HINT, hint->Fog);
-               _mesa_Hint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT,
-                          hint->ClipVolumeClipping);
-	       _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
-			  hint->TextureCompression);
-            }
-            break;
-         case GL_LIGHTING_BIT:
-            {
-               GLuint i;
-               const struct gl_light_attrib *light;
-               light = (const struct gl_light_attrib *) attr->data;
-               /* lighting enable */
-               _mesa_set_enable(ctx, GL_LIGHTING, light->Enabled);
-               /* per-light state */
-               if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top))
-                  _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
-	       
-               for (i = 0; i < ctx->Const.MaxLights; i++) {
-                  const struct gl_light *l = &light->Light[i];
-                  _mesa_set_enable(ctx, GL_LIGHT0 + i, l->Enabled);
-                  _mesa_light(ctx, i, GL_AMBIENT, l->Ambient);
-                  _mesa_light(ctx, i, GL_DIFFUSE, l->Diffuse);
-                  _mesa_light(ctx, i, GL_SPECULAR, l->Specular );
-                  _mesa_light(ctx, i, GL_POSITION, l->EyePosition);
-                  _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->SpotDirection);
-                  {
-                     GLfloat p[4] = { 0 };
-                     p[0] = l->SpotExponent;
-                     _mesa_light(ctx, i, GL_SPOT_EXPONENT, p);
-                  }
-                  {
-                     GLfloat p[4] = { 0 };
-                     p[0] = l->SpotCutoff;
-                     _mesa_light(ctx, i, GL_SPOT_CUTOFF, p);
-                  }
-                  {
-                     GLfloat p[4] = { 0 };
-                     p[0] = l->ConstantAttenuation;
-                     _mesa_light(ctx, i, GL_CONSTANT_ATTENUATION, p);
-                  }
-                  {
-                     GLfloat p[4] = { 0 };
-                     p[0] = l->LinearAttenuation;
-                     _mesa_light(ctx, i, GL_LINEAR_ATTENUATION, p);
-                  }
-                  {
-                     GLfloat p[4] = { 0 };
-                     p[0] = l->QuadraticAttenuation;
-                     _mesa_light(ctx, i, GL_QUADRATIC_ATTENUATION, p);
-                  }
-                }
-               /* light model */
-               _mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT,
-                                  light->Model.Ambient);
-               _mesa_LightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,
-                                 (GLfloat) light->Model.LocalViewer);
-               _mesa_LightModelf(GL_LIGHT_MODEL_TWO_SIDE,
-                                 (GLfloat) light->Model.TwoSide);
-               _mesa_LightModelf(GL_LIGHT_MODEL_COLOR_CONTROL,
-                                 (GLfloat) light->Model.ColorControl);
-               /* shade model */
-               _mesa_ShadeModel(light->ShadeModel);
-               /* color material */
-               _mesa_ColorMaterial(light->ColorMaterialFace,
-                                   light->ColorMaterialMode);
-               _mesa_set_enable(ctx, GL_COLOR_MATERIAL,
-                                light->ColorMaterialEnabled);
-               /* materials */
-               memcpy(&ctx->Light.Material, &light->Material,
-                      sizeof(struct gl_material));
-            }
-            break;
-         case GL_LINE_BIT:
-            {
-               const struct gl_line_attrib *line;
-               line = (const struct gl_line_attrib *) attr->data;
-               _mesa_set_enable(ctx, GL_LINE_SMOOTH, line->SmoothFlag);
-               _mesa_set_enable(ctx, GL_LINE_STIPPLE, line->StippleFlag);
-               _mesa_LineStipple(line->StippleFactor, line->StipplePattern);
-               _mesa_LineWidth(line->Width);
-            }
-            break;
-         case GL_LIST_BIT:
-            memcpy( &ctx->List, attr->data, sizeof(struct gl_list_attrib) );
-            break;
-         case GL_PIXEL_MODE_BIT:
-            memcpy( &ctx->Pixel, attr->data, sizeof(struct gl_pixel_attrib) );
-            /* XXX what other pixel state needs to be set by function calls? */
-            _mesa_ReadBuffer(ctx->Pixel.ReadBuffer);
-	    ctx->NewState |= _NEW_PIXEL;
-            break;
-         case GL_POINT_BIT:
-            {
-               const struct gl_point_attrib *point;
-               point = (const struct gl_point_attrib *) attr->data;
-               _mesa_PointSize(point->Size);
-               _mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag);
-               if (ctx->Extensions.EXT_point_parameters) {
-                  _mesa_PointParameterfv(GL_DISTANCE_ATTENUATION_EXT,
-                                         point->Params);
-                  _mesa_PointParameterf(GL_POINT_SIZE_MIN_EXT,
-                                        point->MinSize);
-                  _mesa_PointParameterf(GL_POINT_SIZE_MAX_EXT,
-                                        point->MaxSize);
-                  _mesa_PointParameterf(GL_POINT_FADE_THRESHOLD_SIZE_EXT,
-                                        point->Threshold);
-               }
-               if (ctx->Extensions.NV_point_sprite
-		   || ctx->Extensions.ARB_point_sprite) {
-                  GLuint u;
-                  for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-                     _mesa_TexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV,
-                                   (GLint) point->CoordReplace[u]);
-                  }
-                  _mesa_set_enable(ctx, GL_POINT_SPRITE_NV,point->PointSprite);
-                  if (ctx->Extensions.NV_point_sprite)
-                     _mesa_PointParameteri(GL_POINT_SPRITE_R_MODE_NV,
-                                           ctx->Point.SpriteRMode);
-                  _mesa_PointParameterf(GL_POINT_SPRITE_COORD_ORIGIN,
-                                        (GLfloat)ctx->Point.SpriteOrigin);
-               }
-            }
-            break;
-         case GL_POLYGON_BIT:
-            {
-               const struct gl_polygon_attrib *polygon;
-               polygon = (const struct gl_polygon_attrib *) attr->data;
-               _mesa_CullFace(polygon->CullFaceMode);
-               _mesa_FrontFace(polygon->FrontFace);
-               _mesa_PolygonMode(GL_FRONT, polygon->FrontMode);
-               _mesa_PolygonMode(GL_BACK, polygon->BackMode);
-               _mesa_PolygonOffset(polygon->OffsetFactor,
-                                   polygon->OffsetUnits);
-               _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, polygon->SmoothFlag);
-               _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, polygon->StippleFlag);
-               _mesa_set_enable(ctx, GL_CULL_FACE, polygon->CullFlag);
-               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_POINT,
-                                polygon->OffsetPoint);
-               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_LINE,
-                                polygon->OffsetLine);
-               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL,
-                                polygon->OffsetFill);
-            }
-            break;
-	 case GL_POLYGON_STIPPLE_BIT:
-	    memcpy( ctx->PolygonStipple, attr->data, 32*sizeof(GLuint) );
-	    ctx->NewState |= _NEW_POLYGONSTIPPLE;
-	    if (ctx->Driver.PolygonStipple)
-	       ctx->Driver.PolygonStipple( ctx, (const GLubyte *) attr->data );
-	    break;
-         case GL_SCISSOR_BIT:
-            {
-               const struct gl_scissor_attrib *scissor;
-               scissor = (const struct gl_scissor_attrib *) attr->data;
-               _mesa_Scissor(scissor->X, scissor->Y,
-                             scissor->Width, scissor->Height);
-               _mesa_set_enable(ctx, GL_SCISSOR_TEST, scissor->Enabled);
-            }
-            break;
-         case GL_STENCIL_BUFFER_BIT:
-            {
-               const struct gl_stencil_attrib *stencil;
-               stencil = (const struct gl_stencil_attrib *) attr->data;
-               _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
-               _mesa_ClearStencil(stencil->Clear);
-               if (ctx->Extensions.EXT_stencil_two_side) {
-                  _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
-                                   stencil->TestTwoSide);
-                  _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
-                                             ? GL_BACK : GL_FRONT);
-               }
-               /* front state */
-               _mesa_StencilFuncSeparate(GL_FRONT,
-                                         stencil->Function[0],
-                                         stencil->Ref[0],
-                                         stencil->ValueMask[0]);
-               _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
-               _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
-                                       stencil->ZFailFunc[0],
-                                       stencil->ZPassFunc[0]);
-               /* back state */
-               _mesa_StencilFuncSeparate(GL_BACK,
-                                         stencil->Function[1],
-                                         stencil->Ref[1],
-                                         stencil->ValueMask[1]);
-               _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
-               _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
-                                       stencil->ZFailFunc[1],
-                                       stencil->ZPassFunc[1]);
-            }
-            break;
-         case GL_TRANSFORM_BIT:
-            {
-               GLuint i;
-               const struct gl_transform_attrib *xform;
-               xform = (const struct gl_transform_attrib *) attr->data;
-               _mesa_MatrixMode(xform->MatrixMode);
-               if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))
-                  _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
-
-               /* restore clip planes */
-               for (i = 0; i < MAX_CLIP_PLANES; i++) {
-                  const GLuint mask = 1 << i;
-                  const GLfloat *eyePlane = xform->EyeUserPlane[i];
-                  COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);
-                  if (xform->ClipPlanesEnabled & mask) {
-                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
-                  }
-                  else {
-                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
-                  }
-                  if (ctx->Driver.ClipPlane)
-                     ctx->Driver.ClipPlane( ctx, GL_CLIP_PLANE0 + i, eyePlane );
-               }
-
-               /* normalize/rescale */
-               if (xform->Normalize != ctx->Transform.Normalize)
-                  _mesa_set_enable(ctx, GL_NORMALIZE,ctx->Transform.Normalize);
-               if (xform->RescaleNormals != ctx->Transform.RescaleNormals)
-                  _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
-                                   ctx->Transform.RescaleNormals);
-               if (xform->DepthClamp != ctx->Transform.DepthClamp)
-                  _mesa_set_enable(ctx, GL_DEPTH_CLAMP,
-                                   ctx->Transform.DepthClamp);
-            }
-            break;
-         case GL_TEXTURE_BIT:
-            /* Take care of texture object reference counters */
-            {
-               struct texture_state *texstate
-                  = (struct texture_state *) attr->data;
-               pop_texture_group(ctx, texstate);
-	       ctx->NewState |= _NEW_TEXTURE;
-            }
-            break;
-         case GL_VIEWPORT_BIT:
-            {
-               const struct gl_viewport_attrib *vp;
-               vp = (const struct gl_viewport_attrib *) attr->data;
-               _mesa_Viewport(vp->X, vp->Y, vp->Width, vp->Height);
-               _mesa_DepthRange(vp->Near, vp->Far);
-            }
-            break;
-         case GL_MULTISAMPLE_BIT_ARB:
-            {
-               const struct gl_multisample_attrib *ms;
-               ms = (const struct gl_multisample_attrib *) attr->data;
-               _mesa_SampleCoverageARB(ms->SampleCoverageValue,
-                                       ms->SampleCoverageInvert);
-            }
-            break;
-
-         default:
-            _mesa_problem( ctx, "Bad attrib flag in PopAttrib");
-            break;
-      }
-
-      next = attr->next;
-      FREE( attr->data );
-      FREE( attr );
-      attr = next;
-   }
-}
-
-
-/**
- * Helper for incrementing/decrementing vertex buffer object reference
- * counts when pushing/popping the GL_CLIENT_VERTEX_ARRAY_BIT attribute group.
- */
-static void
-adjust_buffer_object_ref_counts(struct gl_array_object *arrayObj, GLint step)
-{
-   GLuint i;
-
-   arrayObj->Vertex.BufferObj->RefCount += step;
-   arrayObj->Weight.BufferObj->RefCount += step;
-   arrayObj->Normal.BufferObj->RefCount += step;
-   arrayObj->Color.BufferObj->RefCount += step;
-   arrayObj->SecondaryColor.BufferObj->RefCount += step;
-   arrayObj->FogCoord.BufferObj->RefCount += step;
-   arrayObj->Index.BufferObj->RefCount += step;
-   arrayObj->EdgeFlag.BufferObj->RefCount += step;
-   for (i = 0; i < Elements(arrayObj->TexCoord); i++)
-      arrayObj->TexCoord[i].BufferObj->RefCount += step;
-   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
-      arrayObj->VertexAttrib[i].BufferObj->RefCount += step;
-}
-
-
-/**
- * Copy gl_pixelstore_attrib from src to dst, updating buffer
- * object refcounts.
- */
-static void
-copy_pixelstore(struct gl_context *ctx,
-                struct gl_pixelstore_attrib *dst,
-                const struct gl_pixelstore_attrib *src)
-{
-   dst->Alignment = src->Alignment;
-   dst->RowLength = src->RowLength;
-   dst->SkipPixels = src->SkipPixels;
-   dst->SkipRows = src->SkipRows;
-   dst->ImageHeight = src->ImageHeight;
-   dst->SkipImages = src->SkipImages;
-   dst->SwapBytes = src->SwapBytes;
-   dst->LsbFirst = src->LsbFirst;
-   dst->ClientStorage = src->ClientStorage;
-   dst->Invert = src->Invert;
-   _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
-}
-
-
-#define GL_CLIENT_PACK_BIT (1<<20)
-#define GL_CLIENT_UNPACK_BIT (1<<21)
-
-
-void GLAPIENTRY
-_mesa_PushClientAttrib(GLbitfield mask)
-{
-   struct gl_attrib_node *head;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (ctx->ClientAttribStackDepth >= MAX_CLIENT_ATTRIB_STACK_DEPTH) {
-      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushClientAttrib" );
-      return;
-   }
-
-   /* Build linked list of attribute nodes which save all attribute
-    * groups specified by the mask.
-    */
-   head = NULL;
-
-   if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
-      struct gl_pixelstore_attrib *attr;
-      /* packing attribs */
-      attr = CALLOC_STRUCT( gl_pixelstore_attrib );
-      copy_pixelstore(ctx, attr, &ctx->Pack);
-      save_attrib_data(&head, GL_CLIENT_PACK_BIT, attr);
-      /* unpacking attribs */
-      attr = CALLOC_STRUCT( gl_pixelstore_attrib );
-      copy_pixelstore(ctx, attr, &ctx->Unpack);
-      save_attrib_data(&head, GL_CLIENT_UNPACK_BIT, attr);
-   }
-
-   if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
-      struct gl_array_attrib *attr;
-      struct gl_array_object *obj;
-
-      attr = MALLOC_STRUCT( gl_array_attrib );
-      obj = MALLOC_STRUCT( gl_array_object );
-
-#if FEATURE_ARB_vertex_buffer_object
-      /* increment ref counts since we're copying pointers to these objects */
-      ctx->Array.ArrayBufferObj->RefCount++;
-      ctx->Array.ElementArrayBufferObj->RefCount++;
-#endif
-
-      memcpy( attr, &ctx->Array, sizeof(struct gl_array_attrib) );
-      memcpy( obj, ctx->Array.ArrayObj, sizeof(struct gl_array_object) );
-
-      attr->ArrayObj = obj;
-
-      save_attrib_data(&head, GL_CLIENT_VERTEX_ARRAY_BIT, attr);
-
-      /* bump reference counts on buffer objects */
-      adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, 1);
-   }
-
-   ctx->ClientAttribStack[ctx->ClientAttribStackDepth] = head;
-   ctx->ClientAttribStackDepth++;
-}
-
-
-
-
-void GLAPIENTRY
-_mesa_PopClientAttrib(void)
-{
-   struct gl_attrib_node *node, *next;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (ctx->ClientAttribStackDepth == 0) {
-      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib" );
-      return;
-   }
-
-   ctx->ClientAttribStackDepth--;
-   node = ctx->ClientAttribStack[ctx->ClientAttribStackDepth];
-
-   while (node) {
-      switch (node->kind) {
-         case GL_CLIENT_PACK_BIT:
-            {
-               struct gl_pixelstore_attrib *store =
-                  (struct gl_pixelstore_attrib *) node->data;
-               copy_pixelstore(ctx, &ctx->Pack, store);
-               _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);
-            }
-	    ctx->NewState |= _NEW_PACKUNPACK;
-            break;
-         case GL_CLIENT_UNPACK_BIT:
-            {
-               struct gl_pixelstore_attrib *store =
-                  (struct gl_pixelstore_attrib *) node->data;
-               copy_pixelstore(ctx, &ctx->Unpack, store);
-               _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);
-            }
-	    ctx->NewState |= _NEW_PACKUNPACK;
-            break;
-         case GL_CLIENT_VERTEX_ARRAY_BIT: {
-	    struct gl_array_attrib * data =
-	      (struct gl_array_attrib *) node->data;
-
-            adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, -1);
-	 
-            ctx->Array.ActiveTexture = data->ActiveTexture;
-	    if (data->LockCount != 0)
-	       _mesa_LockArraysEXT(data->LockFirst, data->LockCount);
-	    else if (ctx->Array.LockCount)
-	       _mesa_UnlockArraysEXT();
-
-	    _mesa_BindVertexArrayAPPLE( data->ArrayObj->Name );
-	    
-#if FEATURE_ARB_vertex_buffer_object
-            _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB,
-                                data->ArrayBufferObj->Name);
-            _mesa_BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
-                                data->ElementArrayBufferObj->Name);
-#endif
-
-	    memcpy( ctx->Array.ArrayObj, data->ArrayObj,
-		    sizeof( struct gl_array_object ) );
-
-	    FREE( data->ArrayObj );
-	    
-	    /* FIXME: Should some bits in ctx->Array->NewState also be set
-	     * FIXME: here?  It seems like it should be set to inclusive-or
-	     * FIXME: of the old ArrayObj->_Enabled and the new _Enabled.
-	     */
-
-	    ctx->NewState |= _NEW_ARRAY;
-            break;
-	 }
-         default:
-            _mesa_problem( ctx, "Bad attrib flag in PopClientAttrib");
-            break;
-      }
-
-      next = node->next;
-      FREE( node->data );
-      FREE( node );
-      node = next;
-   }
-}
-
-
-void
-_mesa_init_attrib_dispatch(struct _glapi_table *disp)
-{
-   SET_PopAttrib(disp, _mesa_PopAttrib);
-   SET_PushAttrib(disp, _mesa_PushAttrib);
-   SET_PopClientAttrib(disp, _mesa_PopClientAttrib);
-   SET_PushClientAttrib(disp, _mesa_PushClientAttrib);
-}
-
-
-#endif /* FEATURE_attrib_stack */
-
-
-/**
- * Free any attribute state data that might be attached to the context.
- */
-void
-_mesa_free_attrib_data(struct gl_context *ctx)
-{
-   while (ctx->AttribStackDepth > 0) {
-      struct gl_attrib_node *attr, *next;
-
-      ctx->AttribStackDepth--;
-      attr = ctx->AttribStack[ctx->AttribStackDepth];
-
-      while (attr) {
-         if (attr->kind == GL_TEXTURE_BIT) {
-            struct texture_state *texstate = (struct texture_state*)attr->data;
-            GLuint u, tgt;
-            /* clear references to the saved texture objects */
-            for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-               for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-                  _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);
-               }
-            }
-         }
-         else {
-            /* any other chunks of state that requires special handling? */
-         }
-
-         next = attr->next;
-         free(attr->data);
-         free(attr);
-         attr = next;
-      }
-   }
-}
-
-
-void _mesa_init_attrib( struct gl_context *ctx )
-{
-   /* Renderer and client attribute stacks */
-   ctx->AttribStackDepth = 0;
-   ctx->ClientAttribStackDepth = 0;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+#include "glheader.h"

+#include "imports.h"

+#include "accum.h"

+#include "arrayobj.h"

+#include "attrib.h"

+#include "blend.h"

+#include "buffers.h"

+#include "bufferobj.h"

+#include "clear.h"

+#include "colormac.h"

+#include "context.h"

+#include "depth.h"

+#include "enable.h"

+#include "enums.h"

+#include "fog.h"

+#include "hint.h"

+#include "light.h"

+#include "lines.h"

+#include "macros.h"

+#include "matrix.h"

+#include "mfeatures.h"

+#include "multisample.h"

+#include "points.h"

+#include "polygon.h"

+#include "scissor.h"

+#include "stencil.h"

+#include "texenv.h"

+#include "texgen.h"

+#include "texobj.h"

+#include "texparam.h"

+#include "texstate.h"

+#include "varray.h"

+#include "viewport.h"

+#include "mtypes.h"

+#include "main/dispatch.h"

+

+

+/**

+ * glEnable()/glDisable() attribute group (GL_ENABLE_BIT).

+ */

+struct gl_enable_attrib

+{

+   GLboolean AlphaTest;

+   GLboolean AutoNormal;

+   GLboolean Blend;

+   GLbitfield ClipPlanes;

+   GLboolean ColorMaterial;

+   GLboolean CullFace;

+   GLboolean DepthClamp;

+   GLboolean DepthTest;

+   GLboolean Dither;

+   GLboolean Fog;

+   GLboolean Light[MAX_LIGHTS];

+   GLboolean Lighting;

+   GLboolean LineSmooth;

+   GLboolean LineStipple;

+   GLboolean IndexLogicOp;

+   GLboolean ColorLogicOp;

+

+   GLboolean Map1Color4;

+   GLboolean Map1Index;

+   GLboolean Map1Normal;

+   GLboolean Map1TextureCoord1;

+   GLboolean Map1TextureCoord2;

+   GLboolean Map1TextureCoord3;

+   GLboolean Map1TextureCoord4;

+   GLboolean Map1Vertex3;

+   GLboolean Map1Vertex4;

+   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */

+   GLboolean Map2Color4;

+   GLboolean Map2Index;

+   GLboolean Map2Normal;

+   GLboolean Map2TextureCoord1;

+   GLboolean Map2TextureCoord2;

+   GLboolean Map2TextureCoord3;

+   GLboolean Map2TextureCoord4;

+   GLboolean Map2Vertex3;

+   GLboolean Map2Vertex4;

+   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */

+

+   GLboolean Normalize;

+   GLboolean PixelTexture;

+   GLboolean PointSmooth;

+   GLboolean PolygonOffsetPoint;

+   GLboolean PolygonOffsetLine;

+   GLboolean PolygonOffsetFill;

+   GLboolean PolygonSmooth;

+   GLboolean PolygonStipple;

+   GLboolean RescaleNormals;

+   GLboolean Scissor;

+   GLboolean Stencil;

+   GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */

+   GLboolean MultisampleEnabled;      /* GL_ARB_multisample */

+   GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */

+   GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */

+   GLboolean SampleCoverage;          /* GL_ARB_multisample */

+   GLboolean SampleCoverageInvert;    /* GL_ARB_multisample */

+   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */

+

+   GLbitfield Texture[MAX_TEXTURE_UNITS];

+   GLbitfield TexGen[MAX_TEXTURE_UNITS];

+

+   /* GL_ARB_vertex_program / GL_NV_vertex_program */

+   GLboolean VertexProgram;

+   GLboolean VertexProgramPointSize;

+   GLboolean VertexProgramTwoSide;

+

+   /* GL_ARB_point_sprite / GL_NV_point_sprite */

+   GLboolean PointSprite;

+   GLboolean FragmentShaderATI;

+};

+

+

+/**

+ * Node for the attribute stack.

+ */

+struct gl_attrib_node

+{

+   GLbitfield kind;

+   void *data;

+   struct gl_attrib_node *next;

+};

+

+

+

+/**

+ * Special struct for saving/restoring texture state (GL_TEXTURE_BIT)

+ */

+struct texture_state

+{

+   struct gl_texture_attrib Texture;  /**< The usual context state */

+

+   /** to save per texture object state (wrap modes, filters, etc): */

+   struct gl_texture_object SavedObj[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];

+

+   /**

+    * To save references to texture objects (so they don't get accidentally

+    * deleted while saved in the attribute stack).

+    */

+   struct gl_texture_object *SavedTexRef[MAX_TEXTURE_UNITS][NUM_TEXTURE_TARGETS];

+};

+

+

+#if FEATURE_attrib_stack

+

+

+/**

+ * Allocate new attribute node of given type/kind.  Attach payload data.

+ * Insert it into the linked list named by 'head'.

+ */

+static void

+save_attrib_data(struct gl_attrib_node **head,

+                 GLbitfield kind, void *payload)

+{

+   struct gl_attrib_node *n = MALLOC_STRUCT(gl_attrib_node);

+   if (n) {

+      n->kind = kind;

+      n->data = payload;

+      /* insert at head */

+      n->next = *head;

+      *head = n;

+   }

+   else {

+      /* out of memory! */

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_PushAttrib(GLbitfield mask)

+{

+   struct gl_attrib_node *head;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glPushAttrib %x\n", (int) mask);

+

+   if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) {

+      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" );

+      return;

+   }

+

+   /* Build linked list of attribute nodes which save all attribute */

+   /* groups specified by the mask. */

+   head = NULL;

+

+   if (mask & GL_ACCUM_BUFFER_BIT) {

+      struct gl_accum_attrib *attr;

+      attr = MALLOC_STRUCT( gl_accum_attrib );

+      memcpy( attr, &ctx->Accum, sizeof(struct gl_accum_attrib) );

+      save_attrib_data(&head, GL_ACCUM_BUFFER_BIT, attr);

+   }

+

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      GLuint i;

+      struct gl_colorbuffer_attrib *attr;

+      attr = MALLOC_STRUCT( gl_colorbuffer_attrib );

+      memcpy( attr, &ctx->Color, sizeof(struct gl_colorbuffer_attrib) );

+      /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */

+      for (i = 0; i < ctx->Const.MaxDrawBuffers; i ++)

+         attr->DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i];

+      save_attrib_data(&head, GL_COLOR_BUFFER_BIT, attr);

+   }

+

+   if (mask & GL_CURRENT_BIT) {

+      struct gl_current_attrib *attr;

+      FLUSH_CURRENT( ctx, 0 );

+      attr = MALLOC_STRUCT( gl_current_attrib );

+      memcpy( attr, &ctx->Current, sizeof(struct gl_current_attrib) );

+      save_attrib_data(&head, GL_CURRENT_BIT, attr);

+   }

+

+   if (mask & GL_DEPTH_BUFFER_BIT) {

+      struct gl_depthbuffer_attrib *attr;

+      attr = MALLOC_STRUCT( gl_depthbuffer_attrib );

+      memcpy( attr, &ctx->Depth, sizeof(struct gl_depthbuffer_attrib) );

+      save_attrib_data(&head, GL_DEPTH_BUFFER_BIT, attr);

+   }

+

+   if (mask & GL_ENABLE_BIT) {

+      struct gl_enable_attrib *attr;

+      GLuint i;

+      attr = MALLOC_STRUCT( gl_enable_attrib );

+      /* Copy enable flags from all other attributes into the enable struct. */

+      attr->AlphaTest = ctx->Color.AlphaEnabled;

+      attr->AutoNormal = ctx->Eval.AutoNormal;

+      attr->Blend = ctx->Color.BlendEnabled;

+      attr->ClipPlanes = ctx->Transform.ClipPlanesEnabled;

+      attr->ColorMaterial = ctx->Light.ColorMaterialEnabled;

+      attr->CullFace = ctx->Polygon.CullFlag;

+      attr->DepthClamp = ctx->Transform.DepthClamp;

+      attr->DepthTest = ctx->Depth.Test;

+      attr->Dither = ctx->Color.DitherFlag;

+      attr->Fog = ctx->Fog.Enabled;

+      for (i = 0; i < ctx->Const.MaxLights; i++) {

+         attr->Light[i] = ctx->Light.Light[i].Enabled;

+      }

+      attr->Lighting = ctx->Light.Enabled;

+      attr->LineSmooth = ctx->Line.SmoothFlag;

+      attr->LineStipple = ctx->Line.StippleFlag;

+      attr->IndexLogicOp = ctx->Color.IndexLogicOpEnabled;

+      attr->ColorLogicOp = ctx->Color.ColorLogicOpEnabled;

+      attr->Map1Color4 = ctx->Eval.Map1Color4;

+      attr->Map1Index = ctx->Eval.Map1Index;

+      attr->Map1Normal = ctx->Eval.Map1Normal;

+      attr->Map1TextureCoord1 = ctx->Eval.Map1TextureCoord1;

+      attr->Map1TextureCoord2 = ctx->Eval.Map1TextureCoord2;

+      attr->Map1TextureCoord3 = ctx->Eval.Map1TextureCoord3;

+      attr->Map1TextureCoord4 = ctx->Eval.Map1TextureCoord4;

+      attr->Map1Vertex3 = ctx->Eval.Map1Vertex3;

+      attr->Map1Vertex4 = ctx->Eval.Map1Vertex4;

+      memcpy(attr->Map1Attrib, ctx->Eval.Map1Attrib, sizeof(ctx->Eval.Map1Attrib));

+      attr->Map2Color4 = ctx->Eval.Map2Color4;

+      attr->Map2Index = ctx->Eval.Map2Index;

+      attr->Map2Normal = ctx->Eval.Map2Normal;

+      attr->Map2TextureCoord1 = ctx->Eval.Map2TextureCoord1;

+      attr->Map2TextureCoord2 = ctx->Eval.Map2TextureCoord2;

+      attr->Map2TextureCoord3 = ctx->Eval.Map2TextureCoord3;

+      attr->Map2TextureCoord4 = ctx->Eval.Map2TextureCoord4;

+      attr->Map2Vertex3 = ctx->Eval.Map2Vertex3;

+      attr->Map2Vertex4 = ctx->Eval.Map2Vertex4;

+      memcpy(attr->Map2Attrib, ctx->Eval.Map2Attrib, sizeof(ctx->Eval.Map2Attrib));

+      attr->Normalize = ctx->Transform.Normalize;

+      attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped;

+      attr->PointSmooth = ctx->Point.SmoothFlag;

+      attr->PointSprite = ctx->Point.PointSprite;

+      attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint;

+      attr->PolygonOffsetLine = ctx->Polygon.OffsetLine;

+      attr->PolygonOffsetFill = ctx->Polygon.OffsetFill;

+      attr->PolygonSmooth = ctx->Polygon.SmoothFlag;

+      attr->PolygonStipple = ctx->Polygon.StippleFlag;

+      attr->RescaleNormals = ctx->Transform.RescaleNormals;

+      attr->Scissor = ctx->Scissor.Enabled;

+      attr->Stencil = ctx->Stencil.Enabled;

+      attr->StencilTwoSide = ctx->Stencil.TestTwoSide;

+      attr->MultisampleEnabled = ctx->Multisample.Enabled;

+      attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage;

+      attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne;

+      attr->SampleCoverage = ctx->Multisample.SampleCoverage;

+      attr->SampleCoverageInvert = ctx->Multisample.SampleCoverageInvert;

+      for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

+         attr->Texture[i] = ctx->Texture.Unit[i].Enabled;

+         attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;

+      }

+      /* GL_NV_vertex_program */

+      attr->VertexProgram = ctx->VertexProgram.Enabled;

+      attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled;

+      attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled;

+      save_attrib_data(&head, GL_ENABLE_BIT, attr);

+   }

+

+   if (mask & GL_EVAL_BIT) {

+      struct gl_eval_attrib *attr;

+      attr = MALLOC_STRUCT( gl_eval_attrib );

+      memcpy( attr, &ctx->Eval, sizeof(struct gl_eval_attrib) );

+      save_attrib_data(&head, GL_EVAL_BIT, attr);

+   }

+

+   if (mask & GL_FOG_BIT) {

+      struct gl_fog_attrib *attr;

+      attr = MALLOC_STRUCT( gl_fog_attrib );

+      memcpy( attr, &ctx->Fog, sizeof(struct gl_fog_attrib) );

+      save_attrib_data(&head, GL_FOG_BIT, attr);

+   }

+

+   if (mask & GL_HINT_BIT) {

+      struct gl_hint_attrib *attr;

+      attr = MALLOC_STRUCT( gl_hint_attrib );

+      memcpy( attr, &ctx->Hint, sizeof(struct gl_hint_attrib) );

+      save_attrib_data(&head, GL_HINT_BIT, attr);

+   }

+

+   if (mask & GL_LIGHTING_BIT) {

+      struct gl_light_attrib *attr;

+      FLUSH_CURRENT(ctx, 0);	/* flush material changes */

+      attr = MALLOC_STRUCT( gl_light_attrib );

+      memcpy( attr, &ctx->Light, sizeof(struct gl_light_attrib) );

+      save_attrib_data(&head, GL_LIGHTING_BIT, attr);

+   }

+

+   if (mask & GL_LINE_BIT) {

+      struct gl_line_attrib *attr;

+      attr = MALLOC_STRUCT( gl_line_attrib );

+      memcpy( attr, &ctx->Line, sizeof(struct gl_line_attrib) );

+      save_attrib_data(&head, GL_LINE_BIT, attr);

+   }

+

+   if (mask & GL_LIST_BIT) {

+      struct gl_list_attrib *attr;

+      attr = MALLOC_STRUCT( gl_list_attrib );

+      memcpy( attr, &ctx->List, sizeof(struct gl_list_attrib) );

+      save_attrib_data(&head, GL_LIST_BIT, attr);

+   }

+

+   if (mask & GL_PIXEL_MODE_BIT) {

+      struct gl_pixel_attrib *attr;

+      attr = MALLOC_STRUCT( gl_pixel_attrib );

+      memcpy( attr, &ctx->Pixel, sizeof(struct gl_pixel_attrib) );

+      /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */

+      attr->ReadBuffer = ctx->ReadBuffer->ColorReadBuffer;

+      save_attrib_data(&head, GL_PIXEL_MODE_BIT, attr);

+   }

+

+   if (mask & GL_POINT_BIT) {

+      struct gl_point_attrib *attr;

+      attr = MALLOC_STRUCT( gl_point_attrib );

+      memcpy( attr, &ctx->Point, sizeof(struct gl_point_attrib) );

+      save_attrib_data(&head, GL_POINT_BIT, attr);

+   }

+

+   if (mask & GL_POLYGON_BIT) {

+      struct gl_polygon_attrib *attr;

+      attr = MALLOC_STRUCT( gl_polygon_attrib );

+      memcpy( attr, &ctx->Polygon, sizeof(struct gl_polygon_attrib) );

+      save_attrib_data(&head, GL_POLYGON_BIT, attr);

+   }

+

+   if (mask & GL_POLYGON_STIPPLE_BIT) {

+      GLuint *stipple;

+      stipple = (GLuint *) MALLOC( 32*sizeof(GLuint) );

+      memcpy( stipple, ctx->PolygonStipple, 32*sizeof(GLuint) );

+      save_attrib_data(&head, GL_POLYGON_STIPPLE_BIT, stipple);

+   }

+

+   if (mask & GL_SCISSOR_BIT) {

+      struct gl_scissor_attrib *attr;

+      attr = MALLOC_STRUCT( gl_scissor_attrib );

+      memcpy( attr, &ctx->Scissor, sizeof(struct gl_scissor_attrib) );

+      save_attrib_data(&head, GL_SCISSOR_BIT, attr);

+   }

+

+   if (mask & GL_STENCIL_BUFFER_BIT) {

+      struct gl_stencil_attrib *attr;

+      attr = MALLOC_STRUCT( gl_stencil_attrib );

+      memcpy( attr, &ctx->Stencil, sizeof(struct gl_stencil_attrib) );

+      save_attrib_data(&head, GL_STENCIL_BUFFER_BIT, attr);

+   }

+

+   if (mask & GL_TEXTURE_BIT) {

+      struct texture_state *texstate = CALLOC_STRUCT(texture_state);

+      GLuint u, tex;

+

+      if (!texstate) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)");

+         goto end;

+      }

+

+      _mesa_lock_context_textures(ctx);

+

+      /* copy/save the bulk of texture state here */

+      memcpy(&texstate->Texture, &ctx->Texture, sizeof(ctx->Texture));

+

+      /* Save references to the currently bound texture objects so they don't

+       * accidentally get deleted while referenced in the attribute stack.

+       */

+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {

+            _mesa_reference_texobj(&texstate->SavedTexRef[u][tex],

+                                   ctx->Texture.Unit[u].CurrentTex[tex]);

+         }

+      }

+

+      /* copy state/contents of the currently bound texture objects */

+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {

+            _mesa_copy_texture_object(&texstate->SavedObj[u][tex],

+                                      ctx->Texture.Unit[u].CurrentTex[tex]);

+         }

+      }

+

+      _mesa_unlock_context_textures(ctx);

+

+      save_attrib_data(&head, GL_TEXTURE_BIT, texstate);

+   }

+

+   if (mask & GL_TRANSFORM_BIT) {

+      struct gl_transform_attrib *attr;

+      attr = MALLOC_STRUCT( gl_transform_attrib );

+      memcpy( attr, &ctx->Transform, sizeof(struct gl_transform_attrib) );

+      save_attrib_data(&head, GL_TRANSFORM_BIT, attr);

+   }

+

+   if (mask & GL_VIEWPORT_BIT) {

+      struct gl_viewport_attrib *attr;

+      attr = MALLOC_STRUCT( gl_viewport_attrib );

+      memcpy( attr, &ctx->Viewport, sizeof(struct gl_viewport_attrib) );

+      save_attrib_data(&head, GL_VIEWPORT_BIT, attr);

+   }

+

+   /* GL_ARB_multisample */

+   if (mask & GL_MULTISAMPLE_BIT_ARB) {

+      struct gl_multisample_attrib *attr;

+      attr = MALLOC_STRUCT( gl_multisample_attrib );

+      memcpy( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) );

+      save_attrib_data(&head, GL_MULTISAMPLE_BIT_ARB, attr);

+   }

+

+end:

+   ctx->AttribStack[ctx->AttribStackDepth] = head;

+   ctx->AttribStackDepth++;

+}

+

+

+

+static void

+pop_enable_group(struct gl_context *ctx, const struct gl_enable_attrib *enable)

+{

+   const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;

+   GLuint i;

+

+#define TEST_AND_UPDATE(VALUE, NEWVALUE, ENUM)		\

+	if ((VALUE) != (NEWVALUE)) {			\

+	   _mesa_set_enable( ctx, ENUM, (NEWVALUE) );	\

+	}

+

+   TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST);

+   if (ctx->Color.BlendEnabled != enable->Blend) {

+      if (ctx->Extensions.EXT_draw_buffers2) {

+         GLuint i;

+         for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+            _mesa_set_enablei(ctx, GL_BLEND, i, (enable->Blend >> i) & 1);

+         }

+      }

+      else {

+         _mesa_set_enable(ctx, GL_BLEND, (enable->Blend & 1));

+      }

+   }

+

+   for (i=0;i<MAX_CLIP_PLANES;i++) {

+      const GLuint mask = 1 << i;

+      if ((ctx->Transform.ClipPlanesEnabled & mask) != (enable->ClipPlanes & mask))

+	  _mesa_set_enable(ctx, (GLenum) (GL_CLIP_PLANE0 + i),

+			   (GLboolean) ((enable->ClipPlanes & mask) ? GL_TRUE : GL_FALSE));

+   }

+

+   TEST_AND_UPDATE(ctx->Light.ColorMaterialEnabled, enable->ColorMaterial,

+                   GL_COLOR_MATERIAL);

+   TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);

+   TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,

+		   GL_DEPTH_CLAMP);

+   TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);

+   TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);

+   TEST_AND_UPDATE(ctx->Fog.Enabled, enable->Fog, GL_FOG);

+   TEST_AND_UPDATE(ctx->Light.Enabled, enable->Lighting, GL_LIGHTING);

+   TEST_AND_UPDATE(ctx->Line.SmoothFlag, enable->LineSmooth, GL_LINE_SMOOTH);

+   TEST_AND_UPDATE(ctx->Line.StippleFlag, enable->LineStipple,

+                   GL_LINE_STIPPLE);

+   TEST_AND_UPDATE(ctx->Color.IndexLogicOpEnabled, enable->IndexLogicOp,

+                   GL_INDEX_LOGIC_OP);

+   TEST_AND_UPDATE(ctx->Color.ColorLogicOpEnabled, enable->ColorLogicOp,

+                   GL_COLOR_LOGIC_OP);

+

+   TEST_AND_UPDATE(ctx->Eval.Map1Color4, enable->Map1Color4, GL_MAP1_COLOR_4);

+   TEST_AND_UPDATE(ctx->Eval.Map1Index, enable->Map1Index, GL_MAP1_INDEX);

+   TEST_AND_UPDATE(ctx->Eval.Map1Normal, enable->Map1Normal, GL_MAP1_NORMAL);

+   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord1, enable->Map1TextureCoord1,

+                   GL_MAP1_TEXTURE_COORD_1);

+   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord2, enable->Map1TextureCoord2,

+                   GL_MAP1_TEXTURE_COORD_2);

+   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord3, enable->Map1TextureCoord3,

+                   GL_MAP1_TEXTURE_COORD_3);

+   TEST_AND_UPDATE(ctx->Eval.Map1TextureCoord4, enable->Map1TextureCoord4,

+                   GL_MAP1_TEXTURE_COORD_4);

+   TEST_AND_UPDATE(ctx->Eval.Map1Vertex3, enable->Map1Vertex3,

+                   GL_MAP1_VERTEX_3);

+   TEST_AND_UPDATE(ctx->Eval.Map1Vertex4, enable->Map1Vertex4,

+                   GL_MAP1_VERTEX_4);

+   for (i = 0; i < 16; i++) {

+      TEST_AND_UPDATE(ctx->Eval.Map1Attrib[i], enable->Map1Attrib[i],

+                      GL_MAP1_VERTEX_ATTRIB0_4_NV + i);

+   }

+

+   TEST_AND_UPDATE(ctx->Eval.Map2Color4, enable->Map2Color4, GL_MAP2_COLOR_4);

+   TEST_AND_UPDATE(ctx->Eval.Map2Index, enable->Map2Index, GL_MAP2_INDEX);

+   TEST_AND_UPDATE(ctx->Eval.Map2Normal, enable->Map2Normal, GL_MAP2_NORMAL);

+   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord1, enable->Map2TextureCoord1,

+                   GL_MAP2_TEXTURE_COORD_1);

+   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord2, enable->Map2TextureCoord2,

+                   GL_MAP2_TEXTURE_COORD_2);

+   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord3, enable->Map2TextureCoord3,

+                   GL_MAP2_TEXTURE_COORD_3);

+   TEST_AND_UPDATE(ctx->Eval.Map2TextureCoord4, enable->Map2TextureCoord4,

+                   GL_MAP2_TEXTURE_COORD_4);

+   TEST_AND_UPDATE(ctx->Eval.Map2Vertex3, enable->Map2Vertex3,

+                   GL_MAP2_VERTEX_3);

+   TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4,

+                   GL_MAP2_VERTEX_4);

+   for (i = 0; i < 16; i++) {

+      TEST_AND_UPDATE(ctx->Eval.Map2Attrib[i], enable->Map2Attrib[i],

+                      GL_MAP2_VERTEX_ATTRIB0_4_NV + i);

+   }

+

+   TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL);

+   TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE);

+   TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals,

+                   GL_RESCALE_NORMAL_EXT);

+   TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped,

+                   enable->RasterPositionUnclipped,

+                   GL_RASTER_POSITION_UNCLIPPED_IBM);

+   TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth,

+                   GL_POINT_SMOOTH);

+   if (ctx->Extensions.NV_point_sprite || ctx->Extensions.ARB_point_sprite) {

+      TEST_AND_UPDATE(ctx->Point.PointSprite, enable->PointSprite,

+                      GL_POINT_SPRITE_NV);

+   }

+   TEST_AND_UPDATE(ctx->Polygon.OffsetPoint, enable->PolygonOffsetPoint,

+                   GL_POLYGON_OFFSET_POINT);

+   TEST_AND_UPDATE(ctx->Polygon.OffsetLine, enable->PolygonOffsetLine,

+                   GL_POLYGON_OFFSET_LINE);

+   TEST_AND_UPDATE(ctx->Polygon.OffsetFill, enable->PolygonOffsetFill,

+                   GL_POLYGON_OFFSET_FILL);

+   TEST_AND_UPDATE(ctx->Polygon.SmoothFlag, enable->PolygonSmooth,

+                   GL_POLYGON_SMOOTH);

+   TEST_AND_UPDATE(ctx->Polygon.StippleFlag, enable->PolygonStipple,

+                   GL_POLYGON_STIPPLE);

+   TEST_AND_UPDATE(ctx->Scissor.Enabled, enable->Scissor, GL_SCISSOR_TEST);

+   TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST);

+   if (ctx->Extensions.EXT_stencil_two_side) {

+      TEST_AND_UPDATE(ctx->Stencil.TestTwoSide, enable->StencilTwoSide, GL_STENCIL_TEST_TWO_SIDE_EXT);

+   }

+   TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled,

+                   GL_MULTISAMPLE_ARB);

+   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage,

+                   enable->SampleAlphaToCoverage,

+                   GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);

+   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne,

+                   enable->SampleAlphaToOne,

+                   GL_SAMPLE_ALPHA_TO_ONE_ARB);

+   TEST_AND_UPDATE(ctx->Multisample.SampleCoverage,

+                   enable->SampleCoverage,

+                   GL_SAMPLE_COVERAGE_ARB);

+   TEST_AND_UPDATE(ctx->Multisample.SampleCoverageInvert,

+                   enable->SampleCoverageInvert,

+                   GL_SAMPLE_COVERAGE_INVERT_ARB);

+   /* GL_ARB_vertex_program, GL_NV_vertex_program */

+   TEST_AND_UPDATE(ctx->VertexProgram.Enabled,

+                   enable->VertexProgram,

+                   GL_VERTEX_PROGRAM_ARB);

+   TEST_AND_UPDATE(ctx->VertexProgram.PointSizeEnabled,

+                   enable->VertexProgramPointSize,

+                   GL_VERTEX_PROGRAM_POINT_SIZE_ARB);

+   TEST_AND_UPDATE(ctx->VertexProgram.TwoSideEnabled,

+                   enable->VertexProgramTwoSide,

+                   GL_VERTEX_PROGRAM_TWO_SIDE_ARB);

+

+#undef TEST_AND_UPDATE

+

+   /* texture unit enables */

+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

+      const GLbitfield enabled = enable->Texture[i];

+      const GLbitfield genEnabled = enable->TexGen[i];

+

+      if (ctx->Texture.Unit[i].Enabled != enabled) {

+         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);

+

+         _mesa_set_enable(ctx, GL_TEXTURE_1D,

+                          (enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_2D,

+                          (enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_3D,

+                          (enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE);

+         if (ctx->Extensions.NV_texture_rectangle) {

+            _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_ARB,

+                             (enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);

+         }

+         if (ctx->Extensions.ARB_texture_cube_map) {

+            _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP,

+                             (enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE);

+         }

+         if (ctx->Extensions.MESA_texture_array) {

+            _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,

+                           (enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);

+            _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,

+                           (enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);

+         }

+      }

+

+      if (ctx->Texture.Unit[i].TexGenEnabled != genEnabled) {

+         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);

+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,

+                          (genEnabled & S_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_T,

+                          (genEnabled & T_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_R,

+                          (genEnabled & R_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q,

+                          (genEnabled & Q_BIT) ? GL_TRUE : GL_FALSE);

+      }

+   }

+

+   _mesa_ActiveTextureARB(GL_TEXTURE0 + curTexUnitSave);

+}

+

+

+/**

+ * Pop/restore texture attribute/group state.

+ */

+static void

+pop_texture_group(struct gl_context *ctx, struct texture_state *texstate)

+{

+   GLuint u;

+

+   _mesa_lock_context_textures(ctx);

+

+   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+      const struct gl_texture_unit *unit = &texstate->Texture.Unit[u];

+      GLuint tgt;

+

+      _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + u);

+      _mesa_set_enable(ctx, GL_TEXTURE_1D,

+                       (unit->Enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE);

+      _mesa_set_enable(ctx, GL_TEXTURE_2D,

+                       (unit->Enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE);

+      _mesa_set_enable(ctx, GL_TEXTURE_3D,

+                       (unit->Enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE);

+      if (ctx->Extensions.ARB_texture_cube_map) {

+         _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP_ARB,

+                     (unit->Enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE);

+      }

+      if (ctx->Extensions.NV_texture_rectangle) {

+         _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV,

+                     (unit->Enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);

+      }

+      if (ctx->Extensions.MESA_texture_array) {

+         _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,

+                 (unit->Enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);

+         _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,

+                 (unit->Enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);

+      }

+

+      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode);

+      _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor);

+      _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenS.Mode);

+      _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenT.Mode);

+      _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenR.Mode);

+      _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenQ.Mode);

+      _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->GenS.ObjectPlane);

+      _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->GenT.ObjectPlane);

+      _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->GenR.ObjectPlane);

+      _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane);

+      /* Eye plane done differently to avoid re-transformation */

+      {

+         struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u];

+         COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane);

+         COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane);

+         COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane);

+         COPY_4FV(destUnit->GenQ.EyePlane, unit->GenQ.EyePlane);

+         if (ctx->Driver.TexGen) {

+            ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->GenS.EyePlane);

+            ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->GenT.EyePlane);

+            ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->GenR.EyePlane);

+            ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->GenQ.EyePlane);

+         }

+      }

+      _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,

+                       ((unit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE));

+      _mesa_set_enable(ctx, GL_TEXTURE_GEN_T,

+                       ((unit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE));

+      _mesa_set_enable(ctx, GL_TEXTURE_GEN_R,

+                       ((unit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE));

+      _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q,

+                       ((unit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE));

+      if (ctx->Extensions.EXT_texture_lod_bias) {

+         _mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,

+                       GL_TEXTURE_LOD_BIAS_EXT, unit->LodBias);

+      }

+      if (ctx->Extensions.EXT_texture_env_combine ||

+          ctx->Extensions.ARB_texture_env_combine) {

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,

+                       unit->Combine.ModeRGB);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,

+                       unit->Combine.ModeA);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB,

+                       unit->Combine.SourceRGB[0]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB,

+                       unit->Combine.SourceRGB[1]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB,

+                       unit->Combine.SourceRGB[2]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA,

+                       unit->Combine.SourceA[0]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA,

+                       unit->Combine.SourceA[1]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA,

+                       unit->Combine.SourceA[2]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB,

+                       unit->Combine.OperandRGB[0]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB,

+                       unit->Combine.OperandRGB[1]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,

+                       unit->Combine.OperandRGB[2]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA,

+                       unit->Combine.OperandA[0]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA,

+                       unit->Combine.OperandA[1]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA,

+                       unit->Combine.OperandA[2]);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,

+                       1 << unit->Combine.ScaleShiftRGB);

+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE,

+                       1 << unit->Combine.ScaleShiftA);

+      }

+

+      /* Restore texture object state for each target */

+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+         const struct gl_texture_object *obj = NULL;

+         GLenum target;

+

+         obj = &texstate->SavedObj[u][tgt];

+

+         /* don't restore state for unsupported targets to prevent

+          * raising GL errors.

+          */

+         if (obj->Target == GL_TEXTURE_CUBE_MAP_ARB &&

+             !ctx->Extensions.ARB_texture_cube_map) {

+            continue;

+         }

+         else if (obj->Target == GL_TEXTURE_RECTANGLE_NV &&

+                  !ctx->Extensions.NV_texture_rectangle) {

+            continue;

+         }

+         else if ((obj->Target == GL_TEXTURE_1D_ARRAY_EXT ||

+                   obj->Target == GL_TEXTURE_2D_ARRAY_EXT) &&

+                  !ctx->Extensions.MESA_texture_array) {

+            continue;

+         }

+

+         target = obj->Target;

+

+         _mesa_BindTexture(target, obj->Name);

+

+         _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, obj->BorderColor.f);

+         _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS);

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT);

+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, obj->WrapR);

+         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, obj->MinFilter);

+         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, obj->MagFilter);

+         _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod);

+         _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod);

+         _mesa_TexParameterf(target, GL_TEXTURE_LOD_BIAS, obj->LodBias);

+         _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);

+         if (target != GL_TEXTURE_RECTANGLE_ARB)

+            _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);

+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {

+            _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,

+                                obj->MaxAnisotropy);

+         }

+         if (ctx->Extensions.ARB_shadow_ambient) {

+            _mesa_TexParameterf(target, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB,

+                                obj->CompareFailValue);

+         }

+      }

+

+      /* remove saved references to the texture objects */

+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+         _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);

+      }

+   }

+

+   _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + texstate->Texture.CurrentUnit);

+

+   _mesa_unlock_context_textures(ctx);

+}

+

+

+/*

+ * This function is kind of long just because we have to call a lot

+ * of device driver functions to update device driver state.

+ *

+ * XXX As it is now, most of the pop-code calls immediate-mode Mesa functions

+ * in order to restore GL state.  This isn't terribly efficient but it

+ * ensures that dirty flags and any derived state gets updated correctly.

+ * We could at least check if the value to restore equals the current value

+ * and then skip the Mesa call.

+ */

+void GLAPIENTRY

+_mesa_PopAttrib(void)

+{

+   struct gl_attrib_node *attr, *next;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (ctx->AttribStackDepth == 0) {

+      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );

+      return;

+   }

+

+   ctx->AttribStackDepth--;

+   attr = ctx->AttribStack[ctx->AttribStackDepth];

+

+   while (attr) {

+

+      if (MESA_VERBOSE & VERBOSE_API) {

+         _mesa_debug(ctx, "glPopAttrib %s\n",

+                     _mesa_lookup_enum_by_nr(attr->kind));

+      }

+

+      switch (attr->kind) {

+         case GL_ACCUM_BUFFER_BIT:

+            {

+               const struct gl_accum_attrib *accum;

+               accum = (const struct gl_accum_attrib *) attr->data;

+               _mesa_ClearAccum(accum->ClearColor[0],

+                                accum->ClearColor[1],

+                                accum->ClearColor[2],

+                                accum->ClearColor[3]);

+            }

+            break;

+         case GL_COLOR_BUFFER_BIT:

+            {

+               const struct gl_colorbuffer_attrib *color;

+

+               color = (const struct gl_colorbuffer_attrib *) attr->data;

+               _mesa_ClearIndex((GLfloat) color->ClearIndex);

+               _mesa_ClearColor(color->ClearColor[0],

+                                color->ClearColor[1],

+                                color->ClearColor[2],

+                                color->ClearColor[3]);

+               _mesa_IndexMask(color->IndexMask);

+               if (!ctx->Extensions.EXT_draw_buffers2) {

+                  _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),

+                                  (GLboolean) (color->ColorMask[0][1] != 0),

+                                  (GLboolean) (color->ColorMask[0][2] != 0),

+                                  (GLboolean) (color->ColorMask[0][3] != 0));

+               }

+               else {

+                  GLuint i;

+                  for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+                     _mesa_ColorMaskIndexed(i, 

+                                  (GLboolean) (color->ColorMask[i][0] != 0),

+                                  (GLboolean) (color->ColorMask[i][1] != 0),

+                                  (GLboolean) (color->ColorMask[i][2] != 0),

+                                  (GLboolean) (color->ColorMask[i][3] != 0));

+                  }

+               }

+               {

+                  /* Need to determine if more than one color output is

+                   * specified.  If so, call glDrawBuffersARB, else call

+                   * glDrawBuffer().  This is a subtle, but essential point

+                   * since GL_FRONT (for example) is illegal for the former

+                   * function, but legal for the later.

+                   */

+                  GLboolean multipleBuffers = GL_FALSE;

+		  GLuint i;

+

+		  for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {

+		     if (color->DrawBuffer[i] != GL_NONE) {

+			multipleBuffers = GL_TRUE;

+			break;

+		     }

+                  }

+                  /* Call the API_level functions, not _mesa_drawbuffers()

+                   * since we need to do error checking on the pop'd

+                   * GL_DRAW_BUFFER.

+                   * Ex: if GL_FRONT were pushed, but we're popping with a

+                   * user FBO bound, GL_FRONT will be illegal and we'll need

+                   * to record that error.  Per OpenGL ARB decision.

+                   */

+                  if (multipleBuffers)

+                     _mesa_DrawBuffersARB(ctx->Const.MaxDrawBuffers,

+                                          color->DrawBuffer);

+                  else

+                     _mesa_DrawBuffer(color->DrawBuffer[0]);

+               }

+               _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);

+               _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRef);

+               if (ctx->Color.BlendEnabled != color->BlendEnabled) {

+                  if (ctx->Extensions.EXT_draw_buffers2) {

+                     GLuint i;

+                     for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+                        _mesa_set_enablei(ctx, GL_BLEND, i,

+                                          (color->BlendEnabled >> i) & 1);

+                     }

+                  }

+                  else {

+                     _mesa_set_enable(ctx, GL_BLEND, (color->BlendEnabled & 1));

+                  }

+               }

+               if (ctx->Color._BlendFuncPerBuffer ||

+                   ctx->Color._BlendEquationPerBuffer) {

+                  /* set blend per buffer */

+                  GLuint buf;

+                  for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) {

+                     _mesa_BlendFuncSeparatei(buf, color->Blend[buf].SrcRGB,

+                                              color->Blend[buf].DstRGB,

+                                              color->Blend[buf].SrcA,

+                                              color->Blend[buf].DstA);

+                     _mesa_BlendEquationSeparatei(buf,

+                                                  color->Blend[buf].EquationRGB,

+                                                  color->Blend[buf].EquationA);

+                  }

+               }

+               else {

+                  /* set same blend modes for all buffers */

+                  _mesa_BlendFuncSeparateEXT(color->Blend[0].SrcRGB,

+                                             color->Blend[0].DstRGB,

+                                             color->Blend[0].SrcA,

+                                             color->Blend[0].DstA);

+                  /* This special case is because glBlendEquationSeparateEXT

+                   * cannot take GL_LOGIC_OP as a parameter.

+                   */

+                  if (color->Blend[0].EquationRGB ==

+                      color->Blend[0].EquationA) {

+                     _mesa_BlendEquation(color->Blend[0].EquationRGB);

+                  }

+                  else {

+                     _mesa_BlendEquationSeparateEXT(

+                                                 color->Blend[0].EquationRGB,

+                                                 color->Blend[0].EquationA);

+                  }

+               }

+               _mesa_BlendColor(color->BlendColor[0],

+                                color->BlendColor[1],

+                                color->BlendColor[2],

+                                color->BlendColor[3]);

+               _mesa_LogicOp(color->LogicOp);

+               _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP,

+                                color->ColorLogicOpEnabled);

+               _mesa_set_enable(ctx, GL_INDEX_LOGIC_OP,

+                                color->IndexLogicOpEnabled);

+               _mesa_set_enable(ctx, GL_DITHER, color->DitherFlag);

+            }

+            break;

+         case GL_CURRENT_BIT:

+	    FLUSH_CURRENT( ctx, 0 );

+            memcpy( &ctx->Current, attr->data,

+		    sizeof(struct gl_current_attrib) );

+            break;

+         case GL_DEPTH_BUFFER_BIT:

+            {

+               const struct gl_depthbuffer_attrib *depth;

+               depth = (const struct gl_depthbuffer_attrib *) attr->data;

+               _mesa_DepthFunc(depth->Func);

+               _mesa_ClearDepth(depth->Clear);

+               _mesa_set_enable(ctx, GL_DEPTH_TEST, depth->Test);

+               _mesa_DepthMask(depth->Mask);

+            }

+            break;

+         case GL_ENABLE_BIT:

+            {

+               const struct gl_enable_attrib *enable;

+               enable = (const struct gl_enable_attrib *) attr->data;

+               pop_enable_group(ctx, enable);

+	       ctx->NewState |= _NEW_ALL;

+            }

+            break;

+         case GL_EVAL_BIT:

+            memcpy( &ctx->Eval, attr->data, sizeof(struct gl_eval_attrib) );

+	    ctx->NewState |= _NEW_EVAL;

+            break;

+         case GL_FOG_BIT:

+            {

+               const struct gl_fog_attrib *fog;

+               fog = (const struct gl_fog_attrib *) attr->data;

+               _mesa_set_enable(ctx, GL_FOG, fog->Enabled);

+               _mesa_Fogfv(GL_FOG_COLOR, fog->Color);

+               _mesa_Fogf(GL_FOG_DENSITY, fog->Density);

+               _mesa_Fogf(GL_FOG_START, fog->Start);

+               _mesa_Fogf(GL_FOG_END, fog->End);

+               _mesa_Fogf(GL_FOG_INDEX, fog->Index);

+               _mesa_Fogi(GL_FOG_MODE, fog->Mode);

+            }

+            break;

+         case GL_HINT_BIT:

+            {

+               const struct gl_hint_attrib *hint;

+               hint = (const struct gl_hint_attrib *) attr->data;

+               _mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT,

+                          hint->PerspectiveCorrection );

+               _mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth);

+               _mesa_Hint(GL_LINE_SMOOTH_HINT, hint->LineSmooth);

+               _mesa_Hint(GL_POLYGON_SMOOTH_HINT, hint->PolygonSmooth);

+               _mesa_Hint(GL_FOG_HINT, hint->Fog);

+               _mesa_Hint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT,

+                          hint->ClipVolumeClipping);

+	       _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,

+			  hint->TextureCompression);

+            }

+            break;

+         case GL_LIGHTING_BIT:

+            {

+               GLuint i;

+               const struct gl_light_attrib *light;

+               light = (const struct gl_light_attrib *) attr->data;

+               /* lighting enable */

+               _mesa_set_enable(ctx, GL_LIGHTING, light->Enabled);

+               /* per-light state */

+               if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top))

+                  _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );

+	       

+               for (i = 0; i < ctx->Const.MaxLights; i++) {

+                  const struct gl_light *l = &light->Light[i];

+                  _mesa_set_enable(ctx, GL_LIGHT0 + i, l->Enabled);

+                  _mesa_light(ctx, i, GL_AMBIENT, l->Ambient);

+                  _mesa_light(ctx, i, GL_DIFFUSE, l->Diffuse);

+                  _mesa_light(ctx, i, GL_SPECULAR, l->Specular );

+                  _mesa_light(ctx, i, GL_POSITION, l->EyePosition);

+                  _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->SpotDirection);

+                  {

+                     GLfloat p[4] = { 0 };

+                     p[0] = l->SpotExponent;

+                     _mesa_light(ctx, i, GL_SPOT_EXPONENT, p);

+                  }

+                  {

+                     GLfloat p[4] = { 0 };

+                     p[0] = l->SpotCutoff;

+                     _mesa_light(ctx, i, GL_SPOT_CUTOFF, p);

+                  }

+                  {

+                     GLfloat p[4] = { 0 };

+                     p[0] = l->ConstantAttenuation;

+                     _mesa_light(ctx, i, GL_CONSTANT_ATTENUATION, p);

+                  }

+                  {

+                     GLfloat p[4] = { 0 };

+                     p[0] = l->LinearAttenuation;

+                     _mesa_light(ctx, i, GL_LINEAR_ATTENUATION, p);

+                  }

+                  {

+                     GLfloat p[4] = { 0 };

+                     p[0] = l->QuadraticAttenuation;

+                     _mesa_light(ctx, i, GL_QUADRATIC_ATTENUATION, p);

+                  }

+                }

+               /* light model */

+               _mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT,

+                                  light->Model.Ambient);

+               _mesa_LightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,

+                                 (GLfloat) light->Model.LocalViewer);

+               _mesa_LightModelf(GL_LIGHT_MODEL_TWO_SIDE,

+                                 (GLfloat) light->Model.TwoSide);

+               _mesa_LightModelf(GL_LIGHT_MODEL_COLOR_CONTROL,

+                                 (GLfloat) light->Model.ColorControl);

+               /* shade model */

+               _mesa_ShadeModel(light->ShadeModel);

+               /* color material */

+               _mesa_ColorMaterial(light->ColorMaterialFace,

+                                   light->ColorMaterialMode);

+               _mesa_set_enable(ctx, GL_COLOR_MATERIAL,

+                                light->ColorMaterialEnabled);

+               /* materials */

+               memcpy(&ctx->Light.Material, &light->Material,

+                      sizeof(struct gl_material));

+            }

+            break;

+         case GL_LINE_BIT:

+            {

+               const struct gl_line_attrib *line;

+               line = (const struct gl_line_attrib *) attr->data;

+               _mesa_set_enable(ctx, GL_LINE_SMOOTH, line->SmoothFlag);

+               _mesa_set_enable(ctx, GL_LINE_STIPPLE, line->StippleFlag);

+               _mesa_LineStipple(line->StippleFactor, line->StipplePattern);

+               _mesa_LineWidth(line->Width);

+            }

+            break;

+         case GL_LIST_BIT:

+            memcpy( &ctx->List, attr->data, sizeof(struct gl_list_attrib) );

+            break;

+         case GL_PIXEL_MODE_BIT:

+            memcpy( &ctx->Pixel, attr->data, sizeof(struct gl_pixel_attrib) );

+            /* XXX what other pixel state needs to be set by function calls? */

+            _mesa_ReadBuffer(ctx->Pixel.ReadBuffer);

+	    ctx->NewState |= _NEW_PIXEL;

+            break;

+         case GL_POINT_BIT:

+            {

+               const struct gl_point_attrib *point;

+               point = (const struct gl_point_attrib *) attr->data;

+               _mesa_PointSize(point->Size);

+               _mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag);

+               if (ctx->Extensions.EXT_point_parameters) {

+                  _mesa_PointParameterfv(GL_DISTANCE_ATTENUATION_EXT,

+                                         point->Params);

+                  _mesa_PointParameterf(GL_POINT_SIZE_MIN_EXT,

+                                        point->MinSize);

+                  _mesa_PointParameterf(GL_POINT_SIZE_MAX_EXT,

+                                        point->MaxSize);

+                  _mesa_PointParameterf(GL_POINT_FADE_THRESHOLD_SIZE_EXT,

+                                        point->Threshold);

+               }

+               if (ctx->Extensions.NV_point_sprite

+		   || ctx->Extensions.ARB_point_sprite) {

+                  GLuint u;

+                  for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+                     _mesa_TexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV,

+                                   (GLint) point->CoordReplace[u]);

+                  }

+                  _mesa_set_enable(ctx, GL_POINT_SPRITE_NV,point->PointSprite);

+                  if (ctx->Extensions.NV_point_sprite)

+                     _mesa_PointParameteri(GL_POINT_SPRITE_R_MODE_NV,

+                                           ctx->Point.SpriteRMode);

+                  _mesa_PointParameterf(GL_POINT_SPRITE_COORD_ORIGIN,

+                                        (GLfloat)ctx->Point.SpriteOrigin);

+               }

+            }

+            break;

+         case GL_POLYGON_BIT:

+            {

+               const struct gl_polygon_attrib *polygon;

+               polygon = (const struct gl_polygon_attrib *) attr->data;

+               _mesa_CullFace(polygon->CullFaceMode);

+               _mesa_FrontFace(polygon->FrontFace);

+               _mesa_PolygonMode(GL_FRONT, polygon->FrontMode);

+               _mesa_PolygonMode(GL_BACK, polygon->BackMode);

+               _mesa_PolygonOffset(polygon->OffsetFactor,

+                                   polygon->OffsetUnits);

+               _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, polygon->SmoothFlag);

+               _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, polygon->StippleFlag);

+               _mesa_set_enable(ctx, GL_CULL_FACE, polygon->CullFlag);

+               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_POINT,

+                                polygon->OffsetPoint);

+               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_LINE,

+                                polygon->OffsetLine);

+               _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL,

+                                polygon->OffsetFill);

+            }

+            break;

+	 case GL_POLYGON_STIPPLE_BIT:

+	    memcpy( ctx->PolygonStipple, attr->data, 32*sizeof(GLuint) );

+	    ctx->NewState |= _NEW_POLYGONSTIPPLE;

+	    if (ctx->Driver.PolygonStipple)

+	       ctx->Driver.PolygonStipple( ctx, (const GLubyte *) attr->data );

+	    break;

+         case GL_SCISSOR_BIT:

+            {

+               const struct gl_scissor_attrib *scissor;

+               scissor = (const struct gl_scissor_attrib *) attr->data;

+               _mesa_Scissor(scissor->X, scissor->Y,

+                             scissor->Width, scissor->Height);

+               _mesa_set_enable(ctx, GL_SCISSOR_TEST, scissor->Enabled);

+            }

+            break;

+         case GL_STENCIL_BUFFER_BIT:

+            {

+               const struct gl_stencil_attrib *stencil;

+               stencil = (const struct gl_stencil_attrib *) attr->data;

+               _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);

+               _mesa_ClearStencil(stencil->Clear);

+               if (ctx->Extensions.EXT_stencil_two_side) {

+                  _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,

+                                   stencil->TestTwoSide);

+                  _mesa_ActiveStencilFaceEXT(stencil->ActiveFace

+                                             ? GL_BACK : GL_FRONT);

+               }

+               /* front state */

+               _mesa_StencilFuncSeparate(GL_FRONT,

+                                         stencil->Function[0],

+                                         stencil->Ref[0],

+                                         stencil->ValueMask[0]);

+               _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);

+               _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],

+                                       stencil->ZFailFunc[0],

+                                       stencil->ZPassFunc[0]);

+               /* back state */

+               _mesa_StencilFuncSeparate(GL_BACK,

+                                         stencil->Function[1],

+                                         stencil->Ref[1],

+                                         stencil->ValueMask[1]);

+               _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);

+               _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],

+                                       stencil->ZFailFunc[1],

+                                       stencil->ZPassFunc[1]);

+            }

+            break;

+         case GL_TRANSFORM_BIT:

+            {

+               GLuint i;

+               const struct gl_transform_attrib *xform;

+               xform = (const struct gl_transform_attrib *) attr->data;

+               _mesa_MatrixMode(xform->MatrixMode);

+               if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))

+                  _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );

+

+               /* restore clip planes */

+               for (i = 0; i < MAX_CLIP_PLANES; i++) {

+                  const GLuint mask = 1 << i;

+                  const GLfloat *eyePlane = xform->EyeUserPlane[i];

+                  COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);

+                  if (xform->ClipPlanesEnabled & mask) {

+                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);

+                  }

+                  else {

+                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);

+                  }

+                  if (ctx->Driver.ClipPlane)

+                     ctx->Driver.ClipPlane( ctx, GL_CLIP_PLANE0 + i, eyePlane );

+               }

+

+               /* normalize/rescale */

+               if (xform->Normalize != ctx->Transform.Normalize)

+                  _mesa_set_enable(ctx, GL_NORMALIZE,ctx->Transform.Normalize);

+               if (xform->RescaleNormals != ctx->Transform.RescaleNormals)

+                  _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,

+                                   ctx->Transform.RescaleNormals);

+               if (xform->DepthClamp != ctx->Transform.DepthClamp)

+                  _mesa_set_enable(ctx, GL_DEPTH_CLAMP,

+                                   ctx->Transform.DepthClamp);

+            }

+            break;

+         case GL_TEXTURE_BIT:

+            /* Take care of texture object reference counters */

+            {

+               struct texture_state *texstate

+                  = (struct texture_state *) attr->data;

+               pop_texture_group(ctx, texstate);

+	       ctx->NewState |= _NEW_TEXTURE;

+            }

+            break;

+         case GL_VIEWPORT_BIT:

+            {

+               const struct gl_viewport_attrib *vp;

+               vp = (const struct gl_viewport_attrib *) attr->data;

+               _mesa_Viewport(vp->X, vp->Y, vp->Width, vp->Height);

+               _mesa_DepthRange(vp->Near, vp->Far);

+            }

+            break;

+         case GL_MULTISAMPLE_BIT_ARB:

+            {

+               const struct gl_multisample_attrib *ms;

+               ms = (const struct gl_multisample_attrib *) attr->data;

+               _mesa_SampleCoverageARB(ms->SampleCoverageValue,

+                                       ms->SampleCoverageInvert);

+            }

+            break;

+

+         default:

+            _mesa_problem( ctx, "Bad attrib flag in PopAttrib");

+            break;

+      }

+

+      next = attr->next;

+      FREE( attr->data );

+      FREE( attr );

+      attr = next;

+   }

+}

+

+

+/**

+ * Helper for incrementing/decrementing vertex buffer object reference

+ * counts when pushing/popping the GL_CLIENT_VERTEX_ARRAY_BIT attribute group.

+ */

+static void

+adjust_buffer_object_ref_counts(struct gl_array_object *arrayObj, GLint step)

+{

+   GLuint i;

+

+   arrayObj->Vertex.BufferObj->RefCount += step;

+   arrayObj->Weight.BufferObj->RefCount += step;

+   arrayObj->Normal.BufferObj->RefCount += step;

+   arrayObj->Color.BufferObj->RefCount += step;

+   arrayObj->SecondaryColor.BufferObj->RefCount += step;

+   arrayObj->FogCoord.BufferObj->RefCount += step;

+   arrayObj->Index.BufferObj->RefCount += step;

+   arrayObj->EdgeFlag.BufferObj->RefCount += step;

+   for (i = 0; i < Elements(arrayObj->TexCoord); i++)

+      arrayObj->TexCoord[i].BufferObj->RefCount += step;

+   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)

+      arrayObj->VertexAttrib[i].BufferObj->RefCount += step;

+}

+

+

+/**

+ * Copy gl_pixelstore_attrib from src to dst, updating buffer

+ * object refcounts.

+ */

+static void

+copy_pixelstore(struct gl_context *ctx,

+                struct gl_pixelstore_attrib *dst,

+                const struct gl_pixelstore_attrib *src)

+{

+   dst->Alignment = src->Alignment;

+   dst->RowLength = src->RowLength;

+   dst->SkipPixels = src->SkipPixels;

+   dst->SkipRows = src->SkipRows;

+   dst->ImageHeight = src->ImageHeight;

+   dst->SkipImages = src->SkipImages;

+   dst->SwapBytes = src->SwapBytes;

+   dst->LsbFirst = src->LsbFirst;

+   dst->ClientStorage = src->ClientStorage;

+   dst->Invert = src->Invert;

+   _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);

+}

+

+

+#define GL_CLIENT_PACK_BIT (1<<20)

+#define GL_CLIENT_UNPACK_BIT (1<<21)

+

+

+void GLAPIENTRY

+_mesa_PushClientAttrib(GLbitfield mask)

+{

+   struct gl_attrib_node *head;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (ctx->ClientAttribStackDepth >= MAX_CLIENT_ATTRIB_STACK_DEPTH) {

+      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushClientAttrib" );

+      return;

+   }

+

+   /* Build linked list of attribute nodes which save all attribute

+    * groups specified by the mask.

+    */

+   head = NULL;

+

+   if (mask & GL_CLIENT_PIXEL_STORE_BIT) {

+      struct gl_pixelstore_attrib *attr;

+      /* packing attribs */

+      attr = CALLOC_STRUCT( gl_pixelstore_attrib );

+      copy_pixelstore(ctx, attr, &ctx->Pack);

+      save_attrib_data(&head, GL_CLIENT_PACK_BIT, attr);

+      /* unpacking attribs */

+      attr = CALLOC_STRUCT( gl_pixelstore_attrib );

+      copy_pixelstore(ctx, attr, &ctx->Unpack);

+      save_attrib_data(&head, GL_CLIENT_UNPACK_BIT, attr);

+   }

+

+   if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {

+      struct gl_array_attrib *attr;

+      struct gl_array_object *obj;

+

+      attr = MALLOC_STRUCT( gl_array_attrib );

+      obj = MALLOC_STRUCT( gl_array_object );

+

+#if FEATURE_ARB_vertex_buffer_object

+      /* increment ref counts since we're copying pointers to these objects */

+      ctx->Array.ArrayBufferObj->RefCount++;

+      ctx->Array.ElementArrayBufferObj->RefCount++;

+#endif

+

+      memcpy( attr, &ctx->Array, sizeof(struct gl_array_attrib) );

+      memcpy( obj, ctx->Array.ArrayObj, sizeof(struct gl_array_object) );

+

+      attr->ArrayObj = obj;

+

+      save_attrib_data(&head, GL_CLIENT_VERTEX_ARRAY_BIT, attr);

+

+      /* bump reference counts on buffer objects */

+      adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, 1);

+   }

+

+   ctx->ClientAttribStack[ctx->ClientAttribStackDepth] = head;

+   ctx->ClientAttribStackDepth++;

+}

+

+

+

+

+void GLAPIENTRY

+_mesa_PopClientAttrib(void)

+{

+   struct gl_attrib_node *node, *next;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (ctx->ClientAttribStackDepth == 0) {

+      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib" );

+      return;

+   }

+

+   ctx->ClientAttribStackDepth--;

+   node = ctx->ClientAttribStack[ctx->ClientAttribStackDepth];

+

+   while (node) {

+      switch (node->kind) {

+         case GL_CLIENT_PACK_BIT:

+            {

+               struct gl_pixelstore_attrib *store =

+                  (struct gl_pixelstore_attrib *) node->data;

+               copy_pixelstore(ctx, &ctx->Pack, store);

+               _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);

+            }

+	    ctx->NewState |= _NEW_PACKUNPACK;

+            break;

+         case GL_CLIENT_UNPACK_BIT:

+            {

+               struct gl_pixelstore_attrib *store =

+                  (struct gl_pixelstore_attrib *) node->data;

+               copy_pixelstore(ctx, &ctx->Unpack, store);

+               _mesa_reference_buffer_object(ctx, &store->BufferObj, NULL);

+            }

+	    ctx->NewState |= _NEW_PACKUNPACK;

+            break;

+         case GL_CLIENT_VERTEX_ARRAY_BIT: {

+	    struct gl_array_attrib * data =

+	      (struct gl_array_attrib *) node->data;

+

+            adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, -1);

+	 

+            ctx->Array.ActiveTexture = data->ActiveTexture;

+	    if (data->LockCount != 0)

+	       _mesa_LockArraysEXT(data->LockFirst, data->LockCount);

+	    else if (ctx->Array.LockCount)

+	       _mesa_UnlockArraysEXT();

+

+	    _mesa_BindVertexArrayAPPLE( data->ArrayObj->Name );

+	    

+#if FEATURE_ARB_vertex_buffer_object

+            _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB,

+                                data->ArrayBufferObj->Name);

+            _mesa_BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,

+                                data->ElementArrayBufferObj->Name);

+#endif

+

+	    memcpy( ctx->Array.ArrayObj, data->ArrayObj,

+		    sizeof( struct gl_array_object ) );

+

+	    FREE( data->ArrayObj );

+	    

+	    /* FIXME: Should some bits in ctx->Array->NewState also be set

+	     * FIXME: here?  It seems like it should be set to inclusive-or

+	     * FIXME: of the old ArrayObj->_Enabled and the new _Enabled.

+	     */

+

+	    ctx->NewState |= _NEW_ARRAY;

+            break;

+	 }

+         default:

+            _mesa_problem( ctx, "Bad attrib flag in PopClientAttrib");

+            break;

+      }

+

+      next = node->next;

+      FREE( node->data );

+      FREE( node );

+      node = next;

+   }

+}

+

+

+void

+_mesa_init_attrib_dispatch(struct _glapi_table *disp)

+{

+   SET_PopAttrib(disp, _mesa_PopAttrib);

+   SET_PushAttrib(disp, _mesa_PushAttrib);

+   SET_PopClientAttrib(disp, _mesa_PopClientAttrib);

+   SET_PushClientAttrib(disp, _mesa_PushClientAttrib);

+}

+

+

+#endif /* FEATURE_attrib_stack */

+

+

+/**

+ * Free any attribute state data that might be attached to the context.

+ */

+void

+_mesa_free_attrib_data(struct gl_context *ctx)

+{

+   while (ctx->AttribStackDepth > 0) {

+      struct gl_attrib_node *attr, *next;

+

+      ctx->AttribStackDepth--;

+      attr = ctx->AttribStack[ctx->AttribStackDepth];

+

+      while (attr) {

+         if (attr->kind == GL_TEXTURE_BIT) {

+            struct texture_state *texstate = (struct texture_state*)attr->data;

+            GLuint u, tgt;

+            /* clear references to the saved texture objects */

+            for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {

+               for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+                  _mesa_reference_texobj(&texstate->SavedTexRef[u][tgt], NULL);

+               }

+            }

+         }

+         else {

+            /* any other chunks of state that requires special handling? */

+         }

+

+         next = attr->next;

+         free(attr->data);

+         free(attr);

+         attr = next;

+      }

+   }

+}

+

+

+void _mesa_init_attrib( struct gl_context *ctx )

+{

+   /* Renderer and client attribute stacks */

+   ctx->AttribStackDepth = 0;

+   ctx->ClientAttribStackDepth = 0;

+}

diff --git a/mesalib/src/mesa/main/blend.c b/mesalib/src/mesa/main/blend.c
index c74a16803..22031fd2a 100644
--- a/mesalib/src/mesa/main/blend.c
+++ b/mesalib/src/mesa/main/blend.c
@@ -1,822 +1,822 @@
-/**
- * \file blend.c
- * Blending operations.
- */
-
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-#include "glheader.h"
-#include "blend.h"
-#include "context.h"
-#include "enums.h"
-#include "macros.h"
-#include "mtypes.h"
-
-
-
-/**
- * Check if given blend source factor is legal.
- * \return GL_TRUE if legal, GL_FALSE otherwise.
- */
-static GLboolean
-legal_src_factor(const struct gl_context *ctx, GLenum factor)
-{
-   switch (factor) {
-   case GL_SRC_COLOR:
-   case GL_ONE_MINUS_SRC_COLOR:
-      return ctx->Extensions.NV_blend_square;
-   case GL_ZERO:
-   case GL_ONE:
-   case GL_DST_COLOR:
-   case GL_ONE_MINUS_DST_COLOR:
-   case GL_SRC_ALPHA:
-   case GL_ONE_MINUS_SRC_ALPHA:
-   case GL_DST_ALPHA:
-   case GL_ONE_MINUS_DST_ALPHA:
-   case GL_SRC_ALPHA_SATURATE:
-   case GL_CONSTANT_COLOR:
-   case GL_ONE_MINUS_CONSTANT_COLOR:
-   case GL_CONSTANT_ALPHA:
-   case GL_ONE_MINUS_CONSTANT_ALPHA:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if given blend destination factor is legal.
- * \return GL_TRUE if legal, GL_FALSE otherwise.
- */
-static GLboolean
-legal_dst_factor(const struct gl_context *ctx, GLenum factor)
-{
-   switch (factor) {
-   case GL_DST_COLOR:
-   case GL_ONE_MINUS_DST_COLOR:
-      return ctx->Extensions.NV_blend_square;
-   case GL_ZERO:
-   case GL_ONE:
-   case GL_SRC_COLOR:
-   case GL_ONE_MINUS_SRC_COLOR:
-   case GL_SRC_ALPHA:
-   case GL_ONE_MINUS_SRC_ALPHA:
-   case GL_DST_ALPHA:
-   case GL_ONE_MINUS_DST_ALPHA:
-   case GL_CONSTANT_COLOR:
-   case GL_ONE_MINUS_CONSTANT_COLOR:
-   case GL_CONSTANT_ALPHA:
-   case GL_ONE_MINUS_CONSTANT_ALPHA:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if src/dest RGB/A blend factors are legal.  If not generate
- * a GL error.
- * \return GL_TRUE if factors are legal, GL_FALSE otherwise.
- */
-static GLboolean
-validate_blend_factors(struct gl_context *ctx, const char *func,
-                       GLenum sfactorRGB, GLenum dfactorRGB,
-                       GLenum sfactorA, GLenum dfactorA)
-{
-   if (!legal_src_factor(ctx, sfactorRGB)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "%s(sfactorRGB = %s)", func,
-                  _mesa_lookup_enum_by_nr(sfactorRGB));
-      return GL_FALSE;
-   }
-
-   if (!legal_dst_factor(ctx, dfactorRGB)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "%s(dfactorRGB = %s)", func,
-                  _mesa_lookup_enum_by_nr(dfactorRGB));
-      return GL_FALSE;
-   }
-
-   if (sfactorA != sfactorRGB && !legal_src_factor(ctx, sfactorA)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "%s(sfactorA = %s)", func,
-                  _mesa_lookup_enum_by_nr(sfactorA));
-      return GL_FALSE;
-   }
-
-   if (dfactorA != dfactorRGB && !legal_dst_factor(ctx, dfactorA)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "%s(dfactorA = %s)", func,
-                  _mesa_lookup_enum_by_nr(dfactorA));
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Specify the blending operation.
- *
- * \param sfactor source factor operator.
- * \param dfactor destination factor operator.
- *
- * \sa glBlendFunc, glBlendFuncSeparateEXT
- */
-void GLAPIENTRY
-_mesa_BlendFunc( GLenum sfactor, GLenum dfactor )
-{
-   _mesa_BlendFuncSeparateEXT(sfactor, dfactor, sfactor, dfactor);
-}
-
-
-/**
- * Set the separate blend source/dest factors for all draw buffers.
- *
- * \param sfactorRGB RGB source factor operator.
- * \param dfactorRGB RGB destination factor operator.
- * \param sfactorA alpha source factor operator.
- * \param dfactorA alpha destination factor operator.
- */
-void GLAPIENTRY
-_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
-                            GLenum sfactorA, GLenum dfactorA )
-{
-   GLuint buf, numBuffers;
-   GLboolean changed;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBlendFuncSeparate %s %s %s %s\n",
-                  _mesa_lookup_enum_by_nr(sfactorRGB),
-                  _mesa_lookup_enum_by_nr(dfactorRGB),
-                  _mesa_lookup_enum_by_nr(sfactorA),
-                  _mesa_lookup_enum_by_nr(dfactorA));
-
-   if (!validate_blend_factors(ctx, "glBlendFuncSeparate",
-                               sfactorRGB, dfactorRGB,
-                               sfactorA, dfactorA)) {
-      return;
-   }
-
-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
-      ? ctx->Const.MaxDrawBuffers : 1;
-
-   changed = GL_FALSE;
-   for (buf = 0; buf < numBuffers; buf++) {
-      if (ctx->Color.Blend[buf].SrcRGB != sfactorRGB ||
-          ctx->Color.Blend[buf].DstRGB != dfactorRGB ||
-          ctx->Color.Blend[buf].SrcA != sfactorA ||
-          ctx->Color.Blend[buf].DstA != dfactorA) {
-         changed = GL_TRUE;
-         break;
-      }
-   }
-   if (!changed)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-
-   for (buf = 0; buf < numBuffers; buf++) {
-      ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
-      ctx->Color.Blend[buf].DstRGB = dfactorRGB;
-      ctx->Color.Blend[buf].SrcA = sfactorA;
-      ctx->Color.Blend[buf].DstA = dfactorA;
-   }
-   ctx->Color._BlendFuncPerBuffer = GL_FALSE;
-
-   if (ctx->Driver.BlendFuncSeparate) {
-      ctx->Driver.BlendFuncSeparate(ctx, sfactorRGB, dfactorRGB,
-                                    sfactorA, dfactorA);
-   }
-}
-
-
-#if _HAVE_FULL_GL
-
-
-/**
- * Set blend source/dest factors for one color buffer/target.
- */
-void GLAPIENTRY
-_mesa_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
-{
-   _mesa_BlendFuncSeparatei(buf, sfactor, dfactor, sfactor, dfactor);
-}
-
-
-/**
- * Set separate blend source/dest factors for one color buffer/target.
- */
-void GLAPIENTRY
-_mesa_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
-                         GLenum sfactorA, GLenum dfactorA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!ctx->Extensions.ARB_draw_buffers_blend) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendFunc[Separate]i()");
-      return;
-   }
-
-   if (buf >= ctx->Const.MaxDrawBuffers) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
-                  buf);
-      return;
-   }
-
-   if (!validate_blend_factors(ctx, "glBlendFuncSeparatei",
-                               sfactorRGB, dfactorRGB,
-                               sfactorA, dfactorA)) {
-      return;
-   }
-
-   if (ctx->Color.Blend[buf].SrcRGB == sfactorRGB &&
-       ctx->Color.Blend[buf].DstRGB == dfactorRGB &&
-       ctx->Color.Blend[buf].SrcA == sfactorA &&
-       ctx->Color.Blend[buf].DstA == dfactorA)
-      return; /* no change */
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-
-   ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
-   ctx->Color.Blend[buf].DstRGB = dfactorRGB;
-   ctx->Color.Blend[buf].SrcA = sfactorA;
-   ctx->Color.Blend[buf].DstA = dfactorA;
-   ctx->Color._BlendFuncPerBuffer = GL_TRUE;
-
-   if (ctx->Driver.BlendFuncSeparatei) {
-      ctx->Driver.BlendFuncSeparatei(ctx, buf, sfactorRGB, dfactorRGB,
-                                     sfactorA, dfactorA);
-   }
-}
-
-
-/**
- * Check if given blend equation is legal.
- * \return GL_TRUE if legal, GL_FALSE otherwise.
- */
-static GLboolean
-legal_blend_equation(const struct gl_context *ctx,
-                     GLenum mode, GLboolean is_separate)
-{
-   switch (mode) {
-   case GL_FUNC_ADD:
-      return GL_TRUE;
-   case GL_MIN:
-   case GL_MAX:
-      return ctx->Extensions.EXT_blend_minmax;
-   case GL_LOGIC_OP:
-      /* glBlendEquationSeparate cannot take GL_LOGIC_OP as a parameter.
-       */
-      return ctx->Extensions.EXT_blend_logic_op && !is_separate;
-   case GL_FUNC_SUBTRACT:
-   case GL_FUNC_REVERSE_SUBTRACT:
-      return ctx->Extensions.EXT_blend_subtract;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/* This is really an extension function! */
-void GLAPIENTRY
-_mesa_BlendEquation( GLenum mode )
-{
-   GLuint buf, numBuffers;
-   GLboolean changed;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBlendEquation(%s)\n",
-                  _mesa_lookup_enum_by_nr(mode));
-
-   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
-      return;
-   }
-
-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
-      ? ctx->Const.MaxDrawBuffers : 1;
-
-   changed = GL_FALSE;
-   for (buf = 0; buf < numBuffers; buf++) {
-      if (ctx->Color.Blend[buf].EquationRGB != mode ||
-          ctx->Color.Blend[buf].EquationA != mode) {
-         changed = GL_TRUE;
-         break;
-      }
-   }
-   if (!changed)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   for (buf = 0; buf < numBuffers; buf++) {
-      ctx->Color.Blend[buf].EquationRGB = mode;
-      ctx->Color.Blend[buf].EquationA = mode;
-   }
-   ctx->Color._BlendEquationPerBuffer = GL_FALSE;
-
-   if (ctx->Driver.BlendEquationSeparate)
-      (*ctx->Driver.BlendEquationSeparate)( ctx, mode, mode );
-}
-
-
-/**
- * Set blend equation for one color buffer/target.
- */
-void GLAPIENTRY
-_mesa_BlendEquationi(GLuint buf, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBlendEquationi(%u, %s)\n",
-                  buf, _mesa_lookup_enum_by_nr(mode));
-
-   if (buf >= ctx->Const.MaxDrawBuffers) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
-                  buf);
-      return;
-   }
-
-   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationi");
-      return;
-   }
-
-   if (ctx->Color.Blend[buf].EquationRGB == mode &&
-       ctx->Color.Blend[buf].EquationA == mode)
-      return;  /* no change */
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   ctx->Color.Blend[buf].EquationRGB = mode;
-   ctx->Color.Blend[buf].EquationA = mode;
-   ctx->Color._BlendEquationPerBuffer = GL_TRUE;
-
-   if (ctx->Driver.BlendEquationSeparatei)
-      ctx->Driver.BlendEquationSeparatei(ctx, buf, mode, mode);
-}
-
-
-void GLAPIENTRY
-_mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )
-{
-   GLuint buf, numBuffers;
-   GLboolean changed;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBlendEquationSeparateEXT(%s %s)\n",
-                  _mesa_lookup_enum_by_nr(modeRGB),
-                  _mesa_lookup_enum_by_nr(modeA));
-
-   if ( (modeRGB != modeA) && !ctx->Extensions.EXT_blend_equation_separate ) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-		  "glBlendEquationSeparateEXT not supported by driver");
-      return;
-   }
-
-   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeRGB)");
-      return;
-   }
-
-   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeA)");
-      return;
-   }
-
-   numBuffers = ctx->Extensions.ARB_draw_buffers_blend
-      ? ctx->Const.MaxDrawBuffers : 1;
-
-   changed = GL_FALSE;
-   for (buf = 0; buf < numBuffers; buf++) {
-      if (ctx->Color.Blend[buf].EquationRGB != modeRGB ||
-          ctx->Color.Blend[buf].EquationA != modeA) {
-         changed = GL_TRUE;
-         break;
-      }
-   }
-   if (!changed)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   for (buf = 0; buf < numBuffers; buf++) {
-      ctx->Color.Blend[buf].EquationRGB = modeRGB;
-      ctx->Color.Blend[buf].EquationA = modeA;
-   }
-   ctx->Color._BlendEquationPerBuffer = GL_FALSE;
-
-   if (ctx->Driver.BlendEquationSeparate)
-      ctx->Driver.BlendEquationSeparate(ctx, modeRGB, modeA);
-}
-
-
-/**
- * Set separate blend equations for one color buffer/target.
- */
-void
-_mesa_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBlendEquationSeparatei(%u, %s %s)\n", buf,
-                  _mesa_lookup_enum_by_nr(modeRGB),
-                  _mesa_lookup_enum_by_nr(modeA));
-
-   if (buf >= ctx->Const.MaxDrawBuffers) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendEquationSeparatei(buffer=%u)",
-                  buf);
-      return;
-   }
-
-   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeRGB)");
-      return;
-   }
-
-   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeA)");
-      return;
-   }
-
-   if (ctx->Color.Blend[buf].EquationRGB == modeRGB &&
-       ctx->Color.Blend[buf].EquationA == modeA)
-      return;  /* no change */
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   ctx->Color.Blend[buf].EquationRGB = modeRGB;
-   ctx->Color.Blend[buf].EquationA = modeA;
-   ctx->Color._BlendEquationPerBuffer = GL_TRUE;
-
-   if (ctx->Driver.BlendEquationSeparatei)
-      ctx->Driver.BlendEquationSeparatei(ctx, buf, modeRGB, modeA);
-}
-
-
-
-#endif /* _HAVE_FULL_GL */
-
-
-/**
- * Set the blending color.
- *
- * \param red red color component.
- * \param green green color component.
- * \param blue blue color component.
- * \param alpha alpha color component.
- *
- * \sa glBlendColor().
- *
- * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor.  On a
- * change, flushes the vertices and notifies the driver via
- * dd_function_table::BlendColor callback.
- */
-void GLAPIENTRY
-_mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
-{
-   GLfloat tmp[4];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   tmp[0] = CLAMP( red,   0.0F, 1.0F );
-   tmp[1] = CLAMP( green, 0.0F, 1.0F );
-   tmp[2] = CLAMP( blue,  0.0F, 1.0F );
-   tmp[3] = CLAMP( alpha, 0.0F, 1.0F );
-
-   if (TEST_EQ_4V(tmp, ctx->Color.BlendColor))
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   COPY_4FV( ctx->Color.BlendColor, tmp );
-
-   if (ctx->Driver.BlendColor)
-      (*ctx->Driver.BlendColor)(ctx, tmp);
-}
-
-
-/**
- * Specify the alpha test function.
- *
- * \param func alpha comparison function.
- * \param ref reference value.
- *
- * Verifies the parameters and updates gl_colorbuffer_attrib. 
- * On a change, flushes the vertices and notifies the driver via
- * dd_function_table::AlphaFunc callback.
- */
-void GLAPIENTRY
-_mesa_AlphaFunc( GLenum func, GLclampf ref )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glAlphaFunc(%s, %f)\n",
-                  _mesa_lookup_enum_by_nr(func), ref);
-
-   switch (func) {
-   case GL_NEVER:
-   case GL_LESS:
-   case GL_EQUAL:
-   case GL_LEQUAL:
-   case GL_GREATER:
-   case GL_NOTEQUAL:
-   case GL_GEQUAL:
-   case GL_ALWAYS:
-      ref = CLAMP(ref, 0.0F, 1.0F);
-
-      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRef == ref)
-         return; /* no change */
-
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.AlphaFunc = func;
-      ctx->Color.AlphaRef = ref;
-
-      if (ctx->Driver.AlphaFunc)
-         ctx->Driver.AlphaFunc(ctx, func, ref);
-      return;
-
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );
-      return;
-   }
-}
-
-
-/**
- * Specify a logic pixel operation for color index rendering.
- *
- * \param opcode operation.
- *
- * Verifies that \p opcode is a valid enum and updates
-gl_colorbuffer_attrib::LogicOp.
- * On a change, flushes the vertices and notifies the driver via the
- * dd_function_table::LogicOpcode callback.
- */
-void GLAPIENTRY
-_mesa_LogicOp( GLenum opcode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glLogicOp(%s)\n", _mesa_lookup_enum_by_nr(opcode));
-
-   switch (opcode) {
-      case GL_CLEAR:
-      case GL_SET:
-      case GL_COPY:
-      case GL_COPY_INVERTED:
-      case GL_NOOP:
-      case GL_INVERT:
-      case GL_AND:
-      case GL_NAND:
-      case GL_OR:
-      case GL_NOR:
-      case GL_XOR:
-      case GL_EQUIV:
-      case GL_AND_REVERSE:
-      case GL_AND_INVERTED:
-      case GL_OR_REVERSE:
-      case GL_OR_INVERTED:
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
-	 return;
-   }
-
-   if (ctx->Color.LogicOp == opcode)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   ctx->Color.LogicOp = opcode;
-
-   if (ctx->Driver.LogicOpcode)
-      ctx->Driver.LogicOpcode( ctx, opcode );
-}
-
-#if _HAVE_FULL_GL
-void GLAPIENTRY
-_mesa_IndexMask( GLuint mask )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (ctx->Color.IndexMask == mask)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   ctx->Color.IndexMask = mask;
-}
-#endif
-
-
-/**
- * Enable or disable writing of frame buffer color components.
- *
- * \param red whether to mask writing of the red color component.
- * \param green whether to mask writing of the green color component.
- * \param blue whether to mask writing of the blue color component.
- * \param alpha whether to mask writing of the alpha color component.
- *
- * \sa glColorMask().
- *
- * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask.  On a
- * change, flushes the vertices and notifies the driver via the
- * dd_function_table::ColorMask callback.
- */
-void GLAPIENTRY
-_mesa_ColorMask( GLboolean red, GLboolean green,
-                 GLboolean blue, GLboolean alpha )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLubyte tmp[4];
-   GLuint i;
-   GLboolean flushed;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glColorMask(%d, %d, %d, %d)\n",
-                  red, green, blue, alpha);
-
-   /* Shouldn't have any information about channel depth in core mesa
-    * -- should probably store these as the native booleans:
-    */
-   tmp[RCOMP] = red    ? 0xff : 0x0;
-   tmp[GCOMP] = green  ? 0xff : 0x0;
-   tmp[BCOMP] = blue   ? 0xff : 0x0;
-   tmp[ACOMP] = alpha  ? 0xff : 0x0;
-
-   flushed = GL_FALSE;
-   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
-      if (!TEST_EQ_4V(tmp, ctx->Color.ColorMask[i])) {
-         if (!flushed) {
-            FLUSH_VERTICES(ctx, _NEW_COLOR);
-         }
-         flushed = GL_TRUE;
-         COPY_4UBV(ctx->Color.ColorMask[i], tmp);
-      }
-   }
-
-   if (ctx->Driver.ColorMask)
-      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );
-}
-
-
-/**
- * For GL_EXT_draw_buffers2 and GL3
- */
-void GLAPIENTRY
-_mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,
-                        GLboolean blue, GLboolean alpha )
-{
-   GLubyte tmp[4];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glColorMaskIndexed %u %d %d %d %d\n",
-                  buf, red, green, blue, alpha);
-
-   if (buf >= ctx->Const.MaxDrawBuffers) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glColorMaskIndexed(buf=%u)", buf);
-      return;
-   }
-
-   /* Shouldn't have any information about channel depth in core mesa
-    * -- should probably store these as the native booleans:
-    */
-   tmp[RCOMP] = red    ? 0xff : 0x0;
-   tmp[GCOMP] = green  ? 0xff : 0x0;
-   tmp[BCOMP] = blue   ? 0xff : 0x0;
-   tmp[ACOMP] = alpha  ? 0xff : 0x0;
-
-   if (TEST_EQ_4V(tmp, ctx->Color.ColorMask[buf]))
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_COLOR);
-   COPY_4UBV(ctx->Color.ColorMask[buf], tmp);
-
-   if (ctx->Driver.ColorMaskIndexed)
-      ctx->Driver.ColorMaskIndexed(ctx, buf, red, green, blue, alpha);
-}
-
-
-extern void GLAPIENTRY
-_mesa_ClampColorARB(GLenum target, GLenum clamp)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (clamp != GL_TRUE && clamp != GL_FALSE && clamp != GL_FIXED_ONLY_ARB) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(clamp)");
-      return;
-   }
-
-   switch (target) {
-   case GL_CLAMP_VERTEX_COLOR_ARB:
-      ctx->Light.ClampVertexColor = clamp;
-      break;
-   case GL_CLAMP_FRAGMENT_COLOR_ARB:
-      ctx->Color.ClampFragmentColor = clamp;
-      break;
-   case GL_CLAMP_READ_COLOR_ARB:
-      ctx->Color.ClampReadColor = clamp;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(target)");
-      return;
-   }
-}
-
-
-
-
-/**********************************************************************/
-/** \name Initialization */
-/*@{*/
-
-/**
- * Initialization of the context's Color attribute group.
- *
- * \param ctx GL context.
- *
- * Initializes the related fields in the context color attribute group,
- * __struct gl_contextRec::Color.
- */
-void _mesa_init_color( struct gl_context * ctx )
-{
-   GLuint i;
-
-   /* Color buffer group */
-   ctx->Color.IndexMask = ~0u;
-   memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));
-   ctx->Color.ClearIndex = 0;
-   ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
-   ctx->Color.AlphaEnabled = GL_FALSE;
-   ctx->Color.AlphaFunc = GL_ALWAYS;
-   ctx->Color.AlphaRef = 0;
-   ctx->Color.BlendEnabled = 0x0;
-   for (i = 0; i < Elements(ctx->Color.Blend); i++) {
-      ctx->Color.Blend[i].SrcRGB = GL_ONE;
-      ctx->Color.Blend[i].DstRGB = GL_ZERO;
-      ctx->Color.Blend[i].SrcA = GL_ONE;
-      ctx->Color.Blend[i].DstA = GL_ZERO;
-      ctx->Color.Blend[i].EquationRGB = GL_FUNC_ADD;
-      ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;
-   }
-   ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
-   ctx->Color.IndexLogicOpEnabled = GL_FALSE;
-   ctx->Color.ColorLogicOpEnabled = GL_FALSE;
-   ctx->Color._LogicOpEnabled = GL_FALSE;
-   ctx->Color.LogicOp = GL_COPY;
-   ctx->Color.DitherFlag = GL_TRUE;
-
-   if (ctx->Visual.doubleBufferMode) {
-      ctx->Color.DrawBuffer[0] = GL_BACK;
-   }
-   else {
-      ctx->Color.DrawBuffer[0] = GL_FRONT;
-   }
-
-   ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;
-   ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;
-}
-
-/*@}*/
+/**

+ * \file blend.c

+ * Blending operations.

+ */

+

+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+

+#include "glheader.h"

+#include "blend.h"

+#include "context.h"

+#include "enums.h"

+#include "macros.h"

+#include "mtypes.h"

+

+

+

+/**

+ * Check if given blend source factor is legal.

+ * \return GL_TRUE if legal, GL_FALSE otherwise.

+ */

+static GLboolean

+legal_src_factor(const struct gl_context *ctx, GLenum factor)

+{

+   switch (factor) {

+   case GL_SRC_COLOR:

+   case GL_ONE_MINUS_SRC_COLOR:

+      return ctx->Extensions.NV_blend_square;

+   case GL_ZERO:

+   case GL_ONE:

+   case GL_DST_COLOR:

+   case GL_ONE_MINUS_DST_COLOR:

+   case GL_SRC_ALPHA:

+   case GL_ONE_MINUS_SRC_ALPHA:

+   case GL_DST_ALPHA:

+   case GL_ONE_MINUS_DST_ALPHA:

+   case GL_SRC_ALPHA_SATURATE:

+   case GL_CONSTANT_COLOR:

+   case GL_ONE_MINUS_CONSTANT_COLOR:

+   case GL_CONSTANT_ALPHA:

+   case GL_ONE_MINUS_CONSTANT_ALPHA:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if given blend destination factor is legal.

+ * \return GL_TRUE if legal, GL_FALSE otherwise.

+ */

+static GLboolean

+legal_dst_factor(const struct gl_context *ctx, GLenum factor)

+{

+   switch (factor) {

+   case GL_DST_COLOR:

+   case GL_ONE_MINUS_DST_COLOR:

+      return ctx->Extensions.NV_blend_square;

+   case GL_ZERO:

+   case GL_ONE:

+   case GL_SRC_COLOR:

+   case GL_ONE_MINUS_SRC_COLOR:

+   case GL_SRC_ALPHA:

+   case GL_ONE_MINUS_SRC_ALPHA:

+   case GL_DST_ALPHA:

+   case GL_ONE_MINUS_DST_ALPHA:

+   case GL_CONSTANT_COLOR:

+   case GL_ONE_MINUS_CONSTANT_COLOR:

+   case GL_CONSTANT_ALPHA:

+   case GL_ONE_MINUS_CONSTANT_ALPHA:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if src/dest RGB/A blend factors are legal.  If not generate

+ * a GL error.

+ * \return GL_TRUE if factors are legal, GL_FALSE otherwise.

+ */

+static GLboolean

+validate_blend_factors(struct gl_context *ctx, const char *func,

+                       GLenum sfactorRGB, GLenum dfactorRGB,

+                       GLenum sfactorA, GLenum dfactorA)

+{

+   if (!legal_src_factor(ctx, sfactorRGB)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "%s(sfactorRGB = %s)", func,

+                  _mesa_lookup_enum_by_nr(sfactorRGB));

+      return GL_FALSE;

+   }

+

+   if (!legal_dst_factor(ctx, dfactorRGB)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "%s(dfactorRGB = %s)", func,

+                  _mesa_lookup_enum_by_nr(dfactorRGB));

+      return GL_FALSE;

+   }

+

+   if (sfactorA != sfactorRGB && !legal_src_factor(ctx, sfactorA)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "%s(sfactorA = %s)", func,

+                  _mesa_lookup_enum_by_nr(sfactorA));

+      return GL_FALSE;

+   }

+

+   if (dfactorA != dfactorRGB && !legal_dst_factor(ctx, dfactorA)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "%s(dfactorA = %s)", func,

+                  _mesa_lookup_enum_by_nr(dfactorA));

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Specify the blending operation.

+ *

+ * \param sfactor source factor operator.

+ * \param dfactor destination factor operator.

+ *

+ * \sa glBlendFunc, glBlendFuncSeparateEXT

+ */

+void GLAPIENTRY

+_mesa_BlendFunc( GLenum sfactor, GLenum dfactor )

+{

+   _mesa_BlendFuncSeparateEXT(sfactor, dfactor, sfactor, dfactor);

+}

+

+

+/**

+ * Set the separate blend source/dest factors for all draw buffers.

+ *

+ * \param sfactorRGB RGB source factor operator.

+ * \param dfactorRGB RGB destination factor operator.

+ * \param sfactorA alpha source factor operator.

+ * \param dfactorA alpha destination factor operator.

+ */

+void GLAPIENTRY

+_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,

+                            GLenum sfactorA, GLenum dfactorA )

+{

+   GLuint buf, numBuffers;

+   GLboolean changed;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBlendFuncSeparate %s %s %s %s\n",

+                  _mesa_lookup_enum_by_nr(sfactorRGB),

+                  _mesa_lookup_enum_by_nr(dfactorRGB),

+                  _mesa_lookup_enum_by_nr(sfactorA),

+                  _mesa_lookup_enum_by_nr(dfactorA));

+

+   if (!validate_blend_factors(ctx, "glBlendFuncSeparate",

+                               sfactorRGB, dfactorRGB,

+                               sfactorA, dfactorA)) {

+      return;

+   }

+

+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

+      ? ctx->Const.MaxDrawBuffers : 1;

+

+   changed = GL_FALSE;

+   for (buf = 0; buf < numBuffers; buf++) {

+      if (ctx->Color.Blend[buf].SrcRGB != sfactorRGB ||

+          ctx->Color.Blend[buf].DstRGB != dfactorRGB ||

+          ctx->Color.Blend[buf].SrcA != sfactorA ||

+          ctx->Color.Blend[buf].DstA != dfactorA) {

+         changed = GL_TRUE;

+         break;

+      }

+   }

+   if (!changed)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+

+   for (buf = 0; buf < numBuffers; buf++) {

+      ctx->Color.Blend[buf].SrcRGB = sfactorRGB;

+      ctx->Color.Blend[buf].DstRGB = dfactorRGB;

+      ctx->Color.Blend[buf].SrcA = sfactorA;

+      ctx->Color.Blend[buf].DstA = dfactorA;

+   }

+   ctx->Color._BlendFuncPerBuffer = GL_FALSE;

+

+   if (ctx->Driver.BlendFuncSeparate) {

+      ctx->Driver.BlendFuncSeparate(ctx, sfactorRGB, dfactorRGB,

+                                    sfactorA, dfactorA);

+   }

+}

+

+

+#if _HAVE_FULL_GL

+

+

+/**

+ * Set blend source/dest factors for one color buffer/target.

+ */

+void GLAPIENTRY

+_mesa_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)

+{

+   _mesa_BlendFuncSeparatei(buf, sfactor, dfactor, sfactor, dfactor);

+}

+

+

+/**

+ * Set separate blend source/dest factors for one color buffer/target.

+ */

+void GLAPIENTRY

+_mesa_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,

+                         GLenum sfactorA, GLenum dfactorA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!ctx->Extensions.ARB_draw_buffers_blend) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendFunc[Separate]i()");

+      return;

+   }

+

+   if (buf >= ctx->Const.MaxDrawBuffers) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",

+                  buf);

+      return;

+   }

+

+   if (!validate_blend_factors(ctx, "glBlendFuncSeparatei",

+                               sfactorRGB, dfactorRGB,

+                               sfactorA, dfactorA)) {

+      return;

+   }

+

+   if (ctx->Color.Blend[buf].SrcRGB == sfactorRGB &&

+       ctx->Color.Blend[buf].DstRGB == dfactorRGB &&

+       ctx->Color.Blend[buf].SrcA == sfactorA &&

+       ctx->Color.Blend[buf].DstA == dfactorA)

+      return; /* no change */

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+

+   ctx->Color.Blend[buf].SrcRGB = sfactorRGB;

+   ctx->Color.Blend[buf].DstRGB = dfactorRGB;

+   ctx->Color.Blend[buf].SrcA = sfactorA;

+   ctx->Color.Blend[buf].DstA = dfactorA;

+   ctx->Color._BlendFuncPerBuffer = GL_TRUE;

+

+   if (ctx->Driver.BlendFuncSeparatei) {

+      ctx->Driver.BlendFuncSeparatei(ctx, buf, sfactorRGB, dfactorRGB,

+                                     sfactorA, dfactorA);

+   }

+}

+

+

+/**

+ * Check if given blend equation is legal.

+ * \return GL_TRUE if legal, GL_FALSE otherwise.

+ */

+static GLboolean

+legal_blend_equation(const struct gl_context *ctx,

+                     GLenum mode, GLboolean is_separate)

+{

+   switch (mode) {

+   case GL_FUNC_ADD:

+      return GL_TRUE;

+   case GL_MIN:

+   case GL_MAX:

+      return ctx->Extensions.EXT_blend_minmax;

+   case GL_LOGIC_OP:

+      /* glBlendEquationSeparate cannot take GL_LOGIC_OP as a parameter.

+       */

+      return ctx->Extensions.EXT_blend_logic_op && !is_separate;

+   case GL_FUNC_SUBTRACT:

+   case GL_FUNC_REVERSE_SUBTRACT:

+      return ctx->Extensions.EXT_blend_subtract;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/* This is really an extension function! */

+void GLAPIENTRY

+_mesa_BlendEquation( GLenum mode )

+{

+   GLuint buf, numBuffers;

+   GLboolean changed;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBlendEquation(%s)\n",

+                  _mesa_lookup_enum_by_nr(mode));

+

+   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");

+      return;

+   }

+

+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

+      ? ctx->Const.MaxDrawBuffers : 1;

+

+   changed = GL_FALSE;

+   for (buf = 0; buf < numBuffers; buf++) {

+      if (ctx->Color.Blend[buf].EquationRGB != mode ||

+          ctx->Color.Blend[buf].EquationA != mode) {

+         changed = GL_TRUE;

+         break;

+      }

+   }

+   if (!changed)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   for (buf = 0; buf < numBuffers; buf++) {

+      ctx->Color.Blend[buf].EquationRGB = mode;

+      ctx->Color.Blend[buf].EquationA = mode;

+   }

+   ctx->Color._BlendEquationPerBuffer = GL_FALSE;

+

+   if (ctx->Driver.BlendEquationSeparate)

+      (*ctx->Driver.BlendEquationSeparate)( ctx, mode, mode );

+}

+

+

+/**

+ * Set blend equation for one color buffer/target.

+ */

+void GLAPIENTRY

+_mesa_BlendEquationi(GLuint buf, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBlendEquationi(%u, %s)\n",

+                  buf, _mesa_lookup_enum_by_nr(mode));

+

+   if (buf >= ctx->Const.MaxDrawBuffers) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",

+                  buf);

+      return;

+   }

+

+   if (!legal_blend_equation(ctx, mode, GL_FALSE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationi");

+      return;

+   }

+

+   if (ctx->Color.Blend[buf].EquationRGB == mode &&

+       ctx->Color.Blend[buf].EquationA == mode)

+      return;  /* no change */

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   ctx->Color.Blend[buf].EquationRGB = mode;

+   ctx->Color.Blend[buf].EquationA = mode;

+   ctx->Color._BlendEquationPerBuffer = GL_TRUE;

+

+   if (ctx->Driver.BlendEquationSeparatei)

+      ctx->Driver.BlendEquationSeparatei(ctx, buf, mode, mode);

+}

+

+

+void GLAPIENTRY

+_mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )

+{

+   GLuint buf, numBuffers;

+   GLboolean changed;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBlendEquationSeparateEXT(%s %s)\n",

+                  _mesa_lookup_enum_by_nr(modeRGB),

+                  _mesa_lookup_enum_by_nr(modeA));

+

+   if ( (modeRGB != modeA) && !ctx->Extensions.EXT_blend_equation_separate ) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+		  "glBlendEquationSeparateEXT not supported by driver");

+      return;

+   }

+

+   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeRGB)");

+      return;

+   }

+

+   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeA)");

+      return;

+   }

+

+   numBuffers = ctx->Extensions.ARB_draw_buffers_blend

+      ? ctx->Const.MaxDrawBuffers : 1;

+

+   changed = GL_FALSE;

+   for (buf = 0; buf < numBuffers; buf++) {

+      if (ctx->Color.Blend[buf].EquationRGB != modeRGB ||

+          ctx->Color.Blend[buf].EquationA != modeA) {

+         changed = GL_TRUE;

+         break;

+      }

+   }

+   if (!changed)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   for (buf = 0; buf < numBuffers; buf++) {

+      ctx->Color.Blend[buf].EquationRGB = modeRGB;

+      ctx->Color.Blend[buf].EquationA = modeA;

+   }

+   ctx->Color._BlendEquationPerBuffer = GL_FALSE;

+

+   if (ctx->Driver.BlendEquationSeparate)

+      ctx->Driver.BlendEquationSeparate(ctx, modeRGB, modeA);

+}

+

+

+/**

+ * Set separate blend equations for one color buffer/target.

+ */

+void

+_mesa_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBlendEquationSeparatei(%u, %s %s)\n", buf,

+                  _mesa_lookup_enum_by_nr(modeRGB),

+                  _mesa_lookup_enum_by_nr(modeA));

+

+   if (buf >= ctx->Const.MaxDrawBuffers) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBlendEquationSeparatei(buffer=%u)",

+                  buf);

+      return;

+   }

+

+   if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeRGB)");

+      return;

+   }

+

+   if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeA)");

+      return;

+   }

+

+   if (ctx->Color.Blend[buf].EquationRGB == modeRGB &&

+       ctx->Color.Blend[buf].EquationA == modeA)

+      return;  /* no change */

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   ctx->Color.Blend[buf].EquationRGB = modeRGB;

+   ctx->Color.Blend[buf].EquationA = modeA;

+   ctx->Color._BlendEquationPerBuffer = GL_TRUE;

+

+   if (ctx->Driver.BlendEquationSeparatei)

+      ctx->Driver.BlendEquationSeparatei(ctx, buf, modeRGB, modeA);

+}

+

+

+

+#endif /* _HAVE_FULL_GL */

+

+

+/**

+ * Set the blending color.

+ *

+ * \param red red color component.

+ * \param green green color component.

+ * \param blue blue color component.

+ * \param alpha alpha color component.

+ *

+ * \sa glBlendColor().

+ *

+ * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor.  On a

+ * change, flushes the vertices and notifies the driver via

+ * dd_function_table::BlendColor callback.

+ */

+void GLAPIENTRY

+_mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )

+{

+   GLfloat tmp[4];

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   tmp[0] = CLAMP( red,   0.0F, 1.0F );

+   tmp[1] = CLAMP( green, 0.0F, 1.0F );

+   tmp[2] = CLAMP( blue,  0.0F, 1.0F );

+   tmp[3] = CLAMP( alpha, 0.0F, 1.0F );

+

+   if (TEST_EQ_4V(tmp, ctx->Color.BlendColor))

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   COPY_4FV( ctx->Color.BlendColor, tmp );

+

+   if (ctx->Driver.BlendColor)

+      (*ctx->Driver.BlendColor)(ctx, tmp);

+}

+

+

+/**

+ * Specify the alpha test function.

+ *

+ * \param func alpha comparison function.

+ * \param ref reference value.

+ *

+ * Verifies the parameters and updates gl_colorbuffer_attrib. 

+ * On a change, flushes the vertices and notifies the driver via

+ * dd_function_table::AlphaFunc callback.

+ */

+void GLAPIENTRY

+_mesa_AlphaFunc( GLenum func, GLclampf ref )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glAlphaFunc(%s, %f)\n",

+                  _mesa_lookup_enum_by_nr(func), ref);

+

+   switch (func) {

+   case GL_NEVER:

+   case GL_LESS:

+   case GL_EQUAL:

+   case GL_LEQUAL:

+   case GL_GREATER:

+   case GL_NOTEQUAL:

+   case GL_GEQUAL:

+   case GL_ALWAYS:

+      ref = CLAMP(ref, 0.0F, 1.0F);

+

+      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRef == ref)

+         return; /* no change */

+

+      FLUSH_VERTICES(ctx, _NEW_COLOR);

+      ctx->Color.AlphaFunc = func;

+      ctx->Color.AlphaRef = ref;

+

+      if (ctx->Driver.AlphaFunc)

+         ctx->Driver.AlphaFunc(ctx, func, ref);

+      return;

+

+   default:

+      _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );

+      return;

+   }

+}

+

+

+/**

+ * Specify a logic pixel operation for color index rendering.

+ *

+ * \param opcode operation.

+ *

+ * Verifies that \p opcode is a valid enum and updates

+gl_colorbuffer_attrib::LogicOp.

+ * On a change, flushes the vertices and notifies the driver via the

+ * dd_function_table::LogicOpcode callback.

+ */

+void GLAPIENTRY

+_mesa_LogicOp( GLenum opcode )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glLogicOp(%s)\n", _mesa_lookup_enum_by_nr(opcode));

+

+   switch (opcode) {

+      case GL_CLEAR:

+      case GL_SET:

+      case GL_COPY:

+      case GL_COPY_INVERTED:

+      case GL_NOOP:

+      case GL_INVERT:

+      case GL_AND:

+      case GL_NAND:

+      case GL_OR:

+      case GL_NOR:

+      case GL_XOR:

+      case GL_EQUIV:

+      case GL_AND_REVERSE:

+      case GL_AND_INVERTED:

+      case GL_OR_REVERSE:

+      case GL_OR_INVERTED:

+	 break;

+      default:

+         _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );

+	 return;

+   }

+

+   if (ctx->Color.LogicOp == opcode)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   ctx->Color.LogicOp = opcode;

+

+   if (ctx->Driver.LogicOpcode)

+      ctx->Driver.LogicOpcode( ctx, opcode );

+}

+

+#if _HAVE_FULL_GL

+void GLAPIENTRY

+_mesa_IndexMask( GLuint mask )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (ctx->Color.IndexMask == mask)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   ctx->Color.IndexMask = mask;

+}

+#endif

+

+

+/**

+ * Enable or disable writing of frame buffer color components.

+ *

+ * \param red whether to mask writing of the red color component.

+ * \param green whether to mask writing of the green color component.

+ * \param blue whether to mask writing of the blue color component.

+ * \param alpha whether to mask writing of the alpha color component.

+ *

+ * \sa glColorMask().

+ *

+ * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask.  On a

+ * change, flushes the vertices and notifies the driver via the

+ * dd_function_table::ColorMask callback.

+ */

+void GLAPIENTRY

+_mesa_ColorMask( GLboolean red, GLboolean green,

+                 GLboolean blue, GLboolean alpha )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLubyte tmp[4];

+   GLuint i;

+   GLboolean flushed;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glColorMask(%d, %d, %d, %d)\n",

+                  red, green, blue, alpha);

+

+   /* Shouldn't have any information about channel depth in core mesa

+    * -- should probably store these as the native booleans:

+    */

+   tmp[RCOMP] = red    ? 0xff : 0x0;

+   tmp[GCOMP] = green  ? 0xff : 0x0;

+   tmp[BCOMP] = blue   ? 0xff : 0x0;

+   tmp[ACOMP] = alpha  ? 0xff : 0x0;

+

+   flushed = GL_FALSE;

+   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

+      if (!TEST_EQ_4V(tmp, ctx->Color.ColorMask[i])) {

+         if (!flushed) {

+            FLUSH_VERTICES(ctx, _NEW_COLOR);

+         }

+         flushed = GL_TRUE;

+         COPY_4UBV(ctx->Color.ColorMask[i], tmp);

+      }

+   }

+

+   if (ctx->Driver.ColorMask)

+      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );

+}

+

+

+/**

+ * For GL_EXT_draw_buffers2 and GL3

+ */

+void GLAPIENTRY

+_mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,

+                        GLboolean blue, GLboolean alpha )

+{

+   GLubyte tmp[4];

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glColorMaskIndexed %u %d %d %d %d\n",

+                  buf, red, green, blue, alpha);

+

+   if (buf >= ctx->Const.MaxDrawBuffers) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorMaskIndexed(buf=%u)", buf);

+      return;

+   }

+

+   /* Shouldn't have any information about channel depth in core mesa

+    * -- should probably store these as the native booleans:

+    */

+   tmp[RCOMP] = red    ? 0xff : 0x0;

+   tmp[GCOMP] = green  ? 0xff : 0x0;

+   tmp[BCOMP] = blue   ? 0xff : 0x0;

+   tmp[ACOMP] = alpha  ? 0xff : 0x0;

+

+   if (TEST_EQ_4V(tmp, ctx->Color.ColorMask[buf]))

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_COLOR);

+   COPY_4UBV(ctx->Color.ColorMask[buf], tmp);

+

+   if (ctx->Driver.ColorMaskIndexed)

+      ctx->Driver.ColorMaskIndexed(ctx, buf, red, green, blue, alpha);

+}

+

+

+extern void GLAPIENTRY

+_mesa_ClampColorARB(GLenum target, GLenum clamp)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (clamp != GL_TRUE && clamp != GL_FALSE && clamp != GL_FIXED_ONLY_ARB) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(clamp)");

+      return;

+   }

+

+   switch (target) {

+   case GL_CLAMP_VERTEX_COLOR_ARB:

+      ctx->Light.ClampVertexColor = clamp;

+      break;

+   case GL_CLAMP_FRAGMENT_COLOR_ARB:

+      ctx->Color.ClampFragmentColor = clamp;

+      break;

+   case GL_CLAMP_READ_COLOR_ARB:

+      ctx->Color.ClampReadColor = clamp;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(target)");

+      return;

+   }

+}

+

+

+

+

+/**********************************************************************/

+/** \name Initialization */

+/*@{*/

+

+/**

+ * Initialization of the context's Color attribute group.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes the related fields in the context color attribute group,

+ * __struct gl_contextRec::Color.

+ */

+void _mesa_init_color( struct gl_context * ctx )

+{

+   GLuint i;

+

+   /* Color buffer group */

+   ctx->Color.IndexMask = ~0u;

+   memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));

+   ctx->Color.ClearIndex = 0;

+   ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );

+   ctx->Color.AlphaEnabled = GL_FALSE;

+   ctx->Color.AlphaFunc = GL_ALWAYS;

+   ctx->Color.AlphaRef = 0;

+   ctx->Color.BlendEnabled = 0x0;

+   for (i = 0; i < Elements(ctx->Color.Blend); i++) {

+      ctx->Color.Blend[i].SrcRGB = GL_ONE;

+      ctx->Color.Blend[i].DstRGB = GL_ZERO;

+      ctx->Color.Blend[i].SrcA = GL_ONE;

+      ctx->Color.Blend[i].DstA = GL_ZERO;

+      ctx->Color.Blend[i].EquationRGB = GL_FUNC_ADD;

+      ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;

+   }

+   ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );

+   ctx->Color.IndexLogicOpEnabled = GL_FALSE;

+   ctx->Color.ColorLogicOpEnabled = GL_FALSE;

+   ctx->Color._LogicOpEnabled = GL_FALSE;

+   ctx->Color.LogicOp = GL_COPY;

+   ctx->Color.DitherFlag = GL_TRUE;

+

+   if (ctx->Visual.doubleBufferMode) {

+      ctx->Color.DrawBuffer[0] = GL_BACK;

+   }

+   else {

+      ctx->Color.DrawBuffer[0] = GL_FRONT;

+   }

+

+   ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;

+   ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;

+}

+

+/*@}*/

diff --git a/mesalib/src/mesa/main/bufferobj.c b/mesalib/src/mesa/main/bufferobj.c
index 44072fbc5..afb7999de 100644
--- a/mesalib/src/mesa/main/bufferobj.c
+++ b/mesalib/src/mesa/main/bufferobj.c
@@ -1,1917 +1,1917 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file bufferobj.c
- * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.
- * \author Brian Paul, Ian Romanick
- */
-
-
-#include "glheader.h"
-#include "enums.h"
-#include "hash.h"
-#include "imports.h"
-#include "image.h"
-#include "context.h"
-#include "bufferobj.h"
-#include "fbobject.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "texobj.h"
-
-
-/* Debug flags */
-/*#define VBO_DEBUG*/
-/*#define BOUNDS_CHECK*/
-
-
-#if FEATURE_OES_mapbuffer
-#define DEFAULT_ACCESS GL_MAP_WRITE_BIT
-#else
-#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)
-#endif
-
-
-/**
- * Used as a placeholder for buffer objects between glGenBuffers() and
- * glBindBuffer() so that glIsBuffer() can work correctly.
- */
-static struct gl_buffer_object DummyBufferObject;
-
-
-/**
- * Return pointer to address of a buffer object target.
- * \param ctx  the GL context
- * \param target  the buffer object target to be retrieved.
- * \return   pointer to pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if \c target is invalid.
- */
-static INLINE struct gl_buffer_object **
-get_buffer_target(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_ARRAY_BUFFER_ARB:
-      return &ctx->Array.ArrayBufferObj;
-   case GL_ELEMENT_ARRAY_BUFFER_ARB:
-      return &ctx->Array.ElementArrayBufferObj;
-   case GL_PIXEL_PACK_BUFFER_EXT:
-      return &ctx->Pack.BufferObj;
-   case GL_PIXEL_UNPACK_BUFFER_EXT:
-      return &ctx->Unpack.BufferObj;
-   case GL_COPY_READ_BUFFER:
-      return &ctx->CopyReadBuffer;
-   case GL_COPY_WRITE_BUFFER:
-      return &ctx->CopyWriteBuffer;
-#if FEATURE_EXT_transform_feedback
-   case GL_TRANSFORM_FEEDBACK_BUFFER:
-      if (ctx->Extensions.EXT_transform_feedback) {
-         return &ctx->TransformFeedback.CurrentBuffer;
-      }
-      break;
-#endif
-   default:
-      return NULL;
-   }
-   return NULL;
-}
-
-
-/**
- * Get the buffer object bound to the specified target in a GL context.
- * \param ctx  the GL context
- * \param target  the buffer object target to be retrieved.
- * \return   pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if \c target is invalid.
- */
-static INLINE struct gl_buffer_object *
-get_buffer(struct gl_context *ctx, GLenum target)
-{
-   struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
-   if (bufObj)
-      return *bufObj;
-   return NULL;
-}
-
-
-/**
- * Convert a GLbitfield describing the mapped buffer access flags
- * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.
- */
-static GLenum
-simplified_access_mode(GLbitfield access)
-{
-   const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
-   if ((access & rwFlags) == rwFlags)
-      return GL_READ_WRITE;
-   if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)
-      return GL_READ_ONLY;
-   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)
-      return GL_WRITE_ONLY;
-   return GL_READ_WRITE; /* this should never happen, but no big deal */
-}
-
-
-/**
- * Tests the subdata range parameters and sets the GL error code for
- * \c glBufferSubDataARB and \c glGetBufferSubDataARB.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte of the subdata range.
- * \param size    Size, in bytes, of the subdata range.
- * \param caller  Name of calling function for recording errors.
- * \return   A pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if any of the parameter or state
- *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB
- *           are invalid.
- *
- * \sa glBufferSubDataARB, glGetBufferSubDataARB
- */
-static struct gl_buffer_object *
-buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target, 
-                                  GLintptrARB offset, GLsizeiptrARB size,
-                                  const char *caller )
-{
-   struct gl_buffer_object *bufObj;
-
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);
-      return NULL;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);
-      return NULL;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-      return NULL;
-   }
-   if (offset + size > bufObj->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-		  "%s(size + offset > buffer size)", caller);
-      return NULL;
-   }
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* Buffer is currently mapped */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-      return NULL;
-   }
-
-   return bufObj;
-}
-
-
-/**
- * Allocate and initialize a new buffer object.
- * 
- * Default callback for the \c dd_function_table::NewBufferObject() hook.
- */
-static struct gl_buffer_object *
-_mesa_new_buffer_object( struct gl_context *ctx, GLuint name, GLenum target )
-{
-   struct gl_buffer_object *obj;
-
-   (void) ctx;
-
-   obj = MALLOC_STRUCT(gl_buffer_object);
-   _mesa_initialize_buffer_object(obj, name, target);
-   return obj;
-}
-
-
-/**
- * Delete a buffer object.
- * 
- * Default callback for the \c dd_function_table::DeleteBuffer() hook.
- */
-static void
-_mesa_delete_buffer_object( struct gl_context *ctx, struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-
-   if (bufObj->Data)
-      free(bufObj->Data);
-
-   /* assign strange values here to help w/ debugging */
-   bufObj->RefCount = -1000;
-   bufObj->Name = ~0;
-
-   _glthread_DESTROY_MUTEX(bufObj->Mutex);
-   free(bufObj);
-}
-
-
-
-/**
- * Set ptr to bufObj w/ reference counting.
- */
-void
-_mesa_reference_buffer_object(struct gl_context *ctx,
-                              struct gl_buffer_object **ptr,
-                              struct gl_buffer_object *bufObj)
-{
-   if (*ptr == bufObj)
-      return;
-
-   if (*ptr) {
-      /* Unreference the old buffer */
-      GLboolean deleteFlag = GL_FALSE;
-      struct gl_buffer_object *oldObj = *ptr;
-
-      _glthread_LOCK_MUTEX(oldObj->Mutex);
-      ASSERT(oldObj->RefCount > 0);
-      oldObj->RefCount--;
-#if 0
-      printf("BufferObj %p %d DECR to %d\n",
-             (void *) oldObj, oldObj->Name, oldObj->RefCount);
-#endif
-      deleteFlag = (oldObj->RefCount == 0);
-      _glthread_UNLOCK_MUTEX(oldObj->Mutex);
-
-      if (deleteFlag) {
-
-         /* some sanity checking: don't delete a buffer still in use */
-#if 0
-         /* unfortunately, these tests are invalid during context tear-down */
-	 ASSERT(ctx->Array.ArrayBufferObj != bufObj);
-	 ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);
-	 ASSERT(ctx->Array.ArrayObj->Vertex.BufferObj != bufObj);
-#endif
-
-	 ASSERT(ctx->Driver.DeleteBuffer);
-         ctx->Driver.DeleteBuffer(ctx, oldObj);
-      }
-
-      *ptr = NULL;
-   }
-   ASSERT(!*ptr);
-
-   if (bufObj) {
-      /* reference new buffer */
-      _glthread_LOCK_MUTEX(bufObj->Mutex);
-      if (bufObj->RefCount == 0) {
-         /* this buffer's being deleted (look just above) */
-         /* Not sure this can every really happen.  Warn if it does. */
-         _mesa_problem(NULL, "referencing deleted buffer object");
-         *ptr = NULL;
-      }
-      else {
-         bufObj->RefCount++;
-#if 0
-         printf("BufferObj %p %d INCR to %d\n",
-                (void *) bufObj, bufObj->Name, bufObj->RefCount);
-#endif
-         *ptr = bufObj;
-      }
-      _glthread_UNLOCK_MUTEX(bufObj->Mutex);
-   }
-}
-
-
-/**
- * Initialize a buffer object to default values.
- */
-void
-_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
-				GLuint name, GLenum target )
-{
-   (void) target;
-
-   memset(obj, 0, sizeof(struct gl_buffer_object));
-   _glthread_INIT_MUTEX(obj->Mutex);
-   obj->RefCount = 1;
-   obj->Name = name;
-   obj->Usage = GL_STATIC_DRAW_ARB;
-   obj->AccessFlags = DEFAULT_ACCESS;
-}
-
-
-/**
- * Allocate space for and store data in a buffer object.  Any data that was
- * previously stored in the buffer object is lost.  If \c data is \c NULL,
- * memory will be allocated, but no copy will occur.
- *
- * This is the default callback for \c dd_function_table::BufferData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param size    Size, in bytes, of the new data store.
- * \param data    Pointer to the data to store in the buffer object.  This
- *                pointer may be \c NULL.
- * \param usage   Hints about how the data will be used.
- * \param bufObj  Object to be used.
- *
- * \return GL_TRUE for success, GL_FALSE for failure
- * \sa glBufferDataARB, dd_function_table::BufferData.
- */
-static GLboolean
-_mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
-		   const GLvoid * data, GLenum usage,
-		   struct gl_buffer_object * bufObj )
-{
-   void * new_data;
-
-   (void) ctx; (void) target;
-
-   new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );
-   if (new_data) {
-      bufObj->Data = (GLubyte *) new_data;
-      bufObj->Size = size;
-      bufObj->Usage = usage;
-
-      if (data) {
-	 memcpy( bufObj->Data, data, size );
-      }
-
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Replace data in a subrange of buffer object.  If the data range
- * specified by \c size + \c offset extends beyond the end of the buffer or
- * if \c data is \c NULL, no copy is performed.
- *
- * This is the default callback for \c dd_function_table::BufferSubData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte to be modified.
- * \param size    Size, in bytes, of the data range.
- * \param data    Pointer to the data to store in the buffer object.
- * \param bufObj  Object to be used.
- *
- * \sa glBufferSubDataARB, dd_function_table::BufferSubData.
- */
-static void
-_mesa_buffer_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,
-		      GLsizeiptrARB size, const GLvoid * data,
-		      struct gl_buffer_object * bufObj )
-{
-   (void) ctx; (void) target;
-
-   /* this should have been caught in _mesa_BufferSubData() */
-   ASSERT(size + offset <= bufObj->Size);
-
-   if (bufObj->Data) {
-      memcpy( (GLubyte *) bufObj->Data + offset, data, size );
-   }
-}
-
-
-/**
- * Retrieve data from a subrange of buffer object.  If the data range
- * specified by \c size + \c offset extends beyond the end of the buffer or
- * if \c data is \c NULL, no copy is performed.
- *
- * This is the default callback for \c dd_function_table::GetBufferSubData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte to be fetched.
- * \param size    Size, in bytes, of the data range.
- * \param data    Destination for data
- * \param bufObj  Object to be used.
- *
- * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
- */
-static void
-_mesa_buffer_get_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,
-			  GLsizeiptrARB size, GLvoid * data,
-			  struct gl_buffer_object * bufObj )
-{
-   (void) ctx; (void) target;
-
-   if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {
-      memcpy( data, (GLubyte *) bufObj->Data + offset, size );
-   }
-}
-
-
-/**
- * Default callback for \c dd_function_tabel::MapBuffer().
- *
- * The function parameters will have been already tested for errors.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param access  Information about how the buffer will be accessed.
- * \param bufObj  Object to be mapped.
- * \return  A pointer to the object's internal data store that can be accessed
- *          by the processor
- *
- * \sa glMapBufferARB, dd_function_table::MapBuffer
- */
-static void *
-_mesa_buffer_map( struct gl_context *ctx, GLenum target, GLenum access,
-		  struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   (void) access;
-   /* Just return a direct pointer to the data */
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* already mapped! */
-      return NULL;
-   }
-   bufObj->Pointer = bufObj->Data;
-   bufObj->Length = bufObj->Size;
-   bufObj->Offset = 0;
-   return bufObj->Pointer;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::MapBufferRange().
- * Called via glMapBufferRange().
- */
-static void *
-_mesa_buffer_map_range( struct gl_context *ctx, GLenum target, GLintptr offset,
-                        GLsizeiptr length, GLbitfield access,
-                        struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   assert(!_mesa_bufferobj_mapped(bufObj));
-   /* Just return a direct pointer to the data */
-   bufObj->Pointer = bufObj->Data + offset;
-   bufObj->Length = length;
-   bufObj->Offset = offset;
-   bufObj->AccessFlags = access;
-   return bufObj->Pointer;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::FlushMappedBufferRange().
- * Called via glFlushMappedBufferRange().
- */
-static void
-_mesa_buffer_flush_mapped_range( struct gl_context *ctx, GLenum target, 
-                                 GLintptr offset, GLsizeiptr length,
-                                 struct gl_buffer_object *obj )
-{
-   (void) ctx;
-   (void) target;
-   (void) offset;
-   (void) length;
-   (void) obj;
-   /* no-op */
-}
-
-
-/**
- * Default callback for \c dd_function_table::MapBuffer().
- *
- * The input parameters will have been already tested for errors.
- *
- * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer
- */
-static GLboolean
-_mesa_buffer_unmap( struct gl_context *ctx, GLenum target,
-                    struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   /* XXX we might assert here that bufObj->Pointer is non-null */
-   bufObj->Pointer = NULL;
-   bufObj->Length = 0;
-   bufObj->Offset = 0;
-   bufObj->AccessFlags = 0x0;
-   return GL_TRUE;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::CopyBufferSubData().
- * Called via glCopyBuffserSubData().
- */
-static void
-_mesa_copy_buffer_subdata(struct gl_context *ctx,
-                          struct gl_buffer_object *src,
-                          struct gl_buffer_object *dst,
-                          GLintptr readOffset, GLintptr writeOffset,
-                          GLsizeiptr size)
-{
-   GLubyte *srcPtr, *dstPtr;
-
-   /* buffer should not already be mapped */
-   assert(!_mesa_bufferobj_mapped(src));
-   assert(!_mesa_bufferobj_mapped(dst));
-
-   srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER,
-                                              GL_READ_ONLY, src);
-   dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER,
-                                              GL_WRITE_ONLY, dst);
-
-   if (srcPtr && dstPtr)
-      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
-
-   ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src);
-   ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst);
-}
-
-
-
-/**
- * Initialize the state associated with buffer objects
- */
-void
-_mesa_init_buffer_objects( struct gl_context *ctx )
-{
-   memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));
-   _glthread_INIT_MUTEX(DummyBufferObject.Mutex);
-   DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */
-
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,
-                                 ctx->Shared->NullBufferObj);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj,
-                                 ctx->Shared->NullBufferObj);
-
-   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,
-                                 ctx->Shared->NullBufferObj);
-   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
-                                 ctx->Shared->NullBufferObj);
-}
-
-
-void
-_mesa_free_buffer_objects( struct gl_context *ctx )
-{
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
-
-   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL);
-}
-
-
-/**
- * Bind the specified target to buffer for the specified context.
- * Called by glBindBuffer() and other functions.
- */
-static void
-bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)
-{
-   struct gl_buffer_object *oldBufObj;
-   struct gl_buffer_object *newBufObj = NULL;
-   struct gl_buffer_object **bindTarget = NULL;
-
-   bindTarget = get_buffer_target(ctx, target);
-   if (!bindTarget) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);
-      return;
-   }
-
-   /* Get pointer to old buffer object (to be unbound) */
-   oldBufObj = *bindTarget;
-   if (oldBufObj && oldBufObj->Name == buffer)
-      return;   /* rebinding the same buffer object- no change */
-
-   /*
-    * Get pointer to new buffer object (newBufObj)
-    */
-   if (buffer == 0) {
-      /* The spec says there's not a buffer object named 0, but we use
-       * one internally because it simplifies things.
-       */
-      newBufObj = ctx->Shared->NullBufferObj;
-   }
-   else {
-      /* non-default buffer object */
-      newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
-      if (!newBufObj || newBufObj == &DummyBufferObject) {
-         /* If this is a new buffer object id, or one which was generated but
-          * never used before, allocate a buffer object now.
-          */
-         ASSERT(ctx->Driver.NewBufferObject);
-         newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target);
-         if (!newBufObj) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");
-            return;
-         }
-         _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, newBufObj);
-      }
-   }
-   
-   /* bind new buffer */
-   _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);
-
-   /* Pass BindBuffer call to device driver */
-   if (ctx->Driver.BindBuffer)
-      ctx->Driver.BindBuffer( ctx, target, newBufObj );
-}
-
-
-/**
- * Update the default buffer objects in the given context to reference those
- * specified in the shared state and release those referencing the old 
- * shared state.
- */
-void
-_mesa_update_default_objects_buffer_objects(struct gl_context *ctx)
-{
-   /* Bind the NullBufferObj to remove references to those
-    * in the shared context hash table.
-    */
-   bind_buffer_object( ctx, GL_ARRAY_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_PIXEL_PACK_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-}
-
-
-
-/**
- * Return the gl_buffer_object for the given ID.
- * Always return NULL for ID 0.
- */
-struct gl_buffer_object *
-_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer)
-{
-   if (buffer == 0)
-      return NULL;
-   else
-      return (struct gl_buffer_object *)
-         _mesa_HashLookup(ctx->Shared->BufferObjects, buffer);
-}
-
-
-/**
- * If *ptr points to obj, set ptr = the Null/default buffer object.
- * This is a helper for buffer object deletion.
- * The GL spec says that deleting a buffer object causes it to get
- * unbound from all arrays in the current context.
- */
-static void
-unbind(struct gl_context *ctx,
-       struct gl_buffer_object **ptr,
-       struct gl_buffer_object *obj)
-{
-   if (*ptr == obj) {
-      _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);
-   }
-}
-
-
-/**
- * Plug default/fallback buffer object functions into the device
- * driver hooks.
- */
-void
-_mesa_init_buffer_object_functions(struct dd_function_table *driver)
-{
-   /* GL_ARB_vertex/pixel_buffer_object */
-   driver->NewBufferObject = _mesa_new_buffer_object;
-   driver->DeleteBuffer = _mesa_delete_buffer_object;
-   driver->BindBuffer = NULL;
-   driver->BufferData = _mesa_buffer_data;
-   driver->BufferSubData = _mesa_buffer_subdata;
-   driver->GetBufferSubData = _mesa_buffer_get_subdata;
-   driver->MapBuffer = _mesa_buffer_map;
-   driver->UnmapBuffer = _mesa_buffer_unmap;
-
-   /* GL_ARB_map_buffer_range */
-   driver->MapBufferRange = _mesa_buffer_map_range;
-   driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;
-
-   /* GL_ARB_copy_buffer */
-   driver->CopyBufferSubData = _mesa_copy_buffer_subdata;
-}
-
-
-
-/**********************************************************************/
-/* API Functions                                                      */
-/**********************************************************************/
-
-void GLAPIENTRY
-_mesa_BindBufferARB(GLenum target, GLuint buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBindBuffer(%s, %u)\n",
-                  _mesa_lookup_enum_by_nr(target), buffer);
-
-   bind_buffer_object(ctx, target, buffer);
-}
-
-
-/**
- * Delete a set of buffer objects.
- * 
- * \param n      Number of buffer objects to delete.
- * \param ids    Array of \c n buffer object IDs.
- */
-void GLAPIENTRY
-_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLsizei i;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");
-      return;
-   }
-
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   for (i = 0; i < n; i++) {
-      struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);
-      if (bufObj) {
-         struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-         GLuint j;
-
-         ASSERT(bufObj->Name == ids[i] || bufObj == &DummyBufferObject);
-
-         if (_mesa_bufferobj_mapped(bufObj)) {
-            /* if mapped, unmap it now */
-            ctx->Driver.UnmapBuffer(ctx, 0, bufObj);
-            bufObj->AccessFlags = DEFAULT_ACCESS;
-            bufObj->Pointer = NULL;
-         }
-
-         /* unbind any vertex pointers bound to this buffer */
-         unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Color.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Index.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);
-         for (j = 0; j < Elements(arrayObj->TexCoord); j++) {
-            unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);
-         }
-         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {
-            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);
-         }
-
-         if (ctx->Array.ArrayBufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
-         }
-         if (ctx->Array.ElementArrayBufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
-         }
-
-         /* unbind any pixel pack/unpack pointers bound to this buffer */
-         if (ctx->Pack.BufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );
-         }
-         if (ctx->Unpack.BufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );
-         }
-
-         /* The ID is immediately freed for re-use */
-         _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]);
-         _mesa_reference_buffer_object(ctx, &bufObj, NULL);
-      }
-   }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-}
-
-
-/**
- * Generate a set of unique buffer object IDs and store them in \c buffer.
- * 
- * \param n       Number of IDs to generate.
- * \param buffer  Array of \c n locations to store the IDs.
- */
-void GLAPIENTRY
-_mesa_GenBuffersARB(GLsizei n, GLuint *buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint first;
-   GLint i;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGenBuffers(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");
-      return;
-   }
-
-   if (!buffer) {
-      return;
-   }
-
-   /*
-    * This must be atomic (generation and allocation of buffer object IDs)
-    */
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
-
-   /* Insert the ID and pointer to dummy buffer object into hash table */
-   for (i = 0; i < n; i++) {
-      _mesa_HashInsert(ctx->Shared->BufferObjects, first + i,
-                       &DummyBufferObject);
-      buffer[i] = first + i;
-   }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-}
-
-
-/**
- * Determine if ID is the name of a buffer object.
- * 
- * \param id  ID of the potential buffer object.
- * \return  \c GL_TRUE if \c id is the name of a buffer object, 
- *          \c GL_FALSE otherwise.
- */
-GLboolean GLAPIENTRY
-_mesa_IsBufferARB(GLuint id)
-{
-   struct gl_buffer_object *bufObj;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-   bufObj = _mesa_lookup_bufferobj(ctx, id);
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
-   return bufObj && bufObj != &DummyBufferObject;
-}
-
-
-void GLAPIENTRY
-_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
-                    const GLvoid * data, GLenum usage)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBufferData(%s, %ld, %p, %s)\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  (long int) size, data,
-                  _mesa_lookup_enum_by_nr(usage));
-
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)");
-      return;
-   }
-
-   switch (usage) {
-   case GL_STREAM_DRAW_ARB:
-   case GL_STREAM_READ_ARB:
-   case GL_STREAM_COPY_ARB:
-   case GL_STATIC_DRAW_ARB:
-   case GL_STATIC_READ_ARB:
-   case GL_STATIC_COPY_ARB:
-   case GL_DYNAMIC_DRAW_ARB:
-   case GL_DYNAMIC_READ_ARB:
-   case GL_DYNAMIC_COPY_ARB:
-      /* OK */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)");
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" );
-      return;
-   }
-   
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* Unmap the existing buffer.  We'll replace it now.  Not an error. */
-      ctx->Driver.UnmapBuffer(ctx, target, bufObj);
-      bufObj->AccessFlags = DEFAULT_ACCESS;
-      ASSERT(bufObj->Pointer == NULL);
-   }  
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
-
-   bufObj->Written = GL_TRUE;
-
-#ifdef VBO_DEBUG
-   printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
-                bufObj->Name, size, data, usage);
-#endif
-
-#ifdef BOUNDS_CHECK
-   size += 100;
-#endif
-
-   ASSERT(ctx->Driver.BufferData);
-   if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB()");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,
-                       GLsizeiptrARB size, const GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
-                                              "glBufferSubDataARB" );
-   if (!bufObj) {
-      /* error already recorded */
-      return;
-   }
-
-   if (size == 0)
-      return;
-
-   bufObj->Written = GL_TRUE;
-
-   ASSERT(ctx->Driver.BufferSubData);
-   ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,
-                          GLsizeiptrARB size, void * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
-                                              "glGetBufferSubDataARB" );
-   if (!bufObj) {
-      /* error already recorded */
-      return;
-   }
-
-   ASSERT(ctx->Driver.GetBufferSubData);
-   ctx->Driver.GetBufferSubData( ctx, target, offset, size, data, bufObj );
-}
-
-
-void * GLAPIENTRY
-_mesa_MapBufferARB(GLenum target, GLenum access)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object * bufObj;
-   GLbitfield accessFlags;
-   void *map;
-
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
-
-   switch (access) {
-   case GL_READ_ONLY_ARB:
-      accessFlags = GL_MAP_READ_BIT;
-      break;
-   case GL_WRITE_ONLY_ARB:
-      accessFlags = GL_MAP_WRITE_BIT;
-      break;
-   case GL_READ_WRITE_ARB:
-      accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );
-      return NULL;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" );
-      return NULL;
-   }
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");
-      return NULL;
-   }
-
-   ASSERT(ctx->Driver.MapBuffer);
-   map = ctx->Driver.MapBuffer( ctx, target, access, bufObj );
-   if (!map) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");
-      return NULL;
-   }
-   else {
-      /* The driver callback should have set these fields.
-       * This is important because other modules (like VBO) might call
-       * the driver function directly.
-       */
-      ASSERT(bufObj->Pointer == map);
-      ASSERT(bufObj->Length == bufObj->Size);
-      ASSERT(bufObj->Offset == 0);
-      bufObj->AccessFlags = accessFlags;
-   }
-
-   if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB)
-      bufObj->Written = GL_TRUE;
-
-#ifdef VBO_DEBUG
-   printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",
-	  bufObj->Name, bufObj->Size, access);
-   if (access == GL_WRITE_ONLY_ARB) {
-      GLuint i;
-      GLubyte *b = (GLubyte *) bufObj->Pointer;
-      for (i = 0; i < bufObj->Size; i++)
-         b[i] = i & 0xff;
-   }
-#endif
-
-#ifdef BOUNDS_CHECK
-   {
-      GLubyte *buf = (GLubyte *) bufObj->Pointer;
-      GLuint i;
-      /* buffer is 100 bytes larger than requested, fill with magic value */
-      for (i = 0; i < 100; i++) {
-         buf[bufObj->Size - i - 1] = 123;
-      }
-   }
-#endif
-
-   return bufObj->Pointer;
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_UnmapBufferARB(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   GLboolean status = GL_TRUE;
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );
-      return GL_FALSE;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );
-      return GL_FALSE;
-   }
-   if (!_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
-      return GL_FALSE;
-   }
-
-#ifdef BOUNDS_CHECK
-   if (bufObj->Access != GL_READ_ONLY_ARB) {
-      GLubyte *buf = (GLubyte *) bufObj->Pointer;
-      GLuint i;
-      /* check that last 100 bytes are still = magic value */
-      for (i = 0; i < 100; i++) {
-         GLuint pos = bufObj->Size - i - 1;
-         if (buf[pos] != 123) {
-            _mesa_warning(ctx, "Out of bounds buffer object write detected"
-                          " at position %d (value = %u)\n",
-                          pos, buf[pos]);
-         }
-      }
-   }
-#endif
-
-#ifdef VBO_DEBUG
-   if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {
-      GLuint i, unchanged = 0;
-      GLubyte *b = (GLubyte *) bufObj->Pointer;
-      GLint pos = -1;
-      /* check which bytes changed */
-      for (i = 0; i < bufObj->Size - 1; i++) {
-         if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {
-            unchanged++;
-            if (pos == -1)
-               pos = i;
-         }
-      }
-      if (unchanged) {
-         printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
-                      bufObj->Name, unchanged, bufObj->Size, pos);
-      }
-   }
-#endif
-
-   status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );
-   bufObj->AccessFlags = DEFAULT_ACCESS;
-   ASSERT(bufObj->Pointer == NULL);
-   ASSERT(bufObj->Offset == 0);
-   ASSERT(bufObj->Length == 0);
-
-   return status;
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameterivARB" );
-      return;
-   }
-
-   switch (pname) {
-   case GL_BUFFER_SIZE_ARB:
-      *params = (GLint) bufObj->Size;
-      return;
-   case GL_BUFFER_USAGE_ARB:
-      *params = bufObj->Usage;
-      return;
-   case GL_BUFFER_ACCESS_ARB:
-      *params = simplified_access_mode(bufObj->AccessFlags);
-      return;
-   case GL_BUFFER_MAPPED_ARB:
-      *params = _mesa_bufferobj_mapped(bufObj);
-      return;
-   case GL_BUFFER_ACCESS_FLAGS:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->AccessFlags;
-      return;
-   case GL_BUFFER_MAP_OFFSET:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = (GLint) bufObj->Offset;
-      return;
-   case GL_BUFFER_MAP_LENGTH:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = (GLint) bufObj->Length;
-      return;
-   default:
-      ; /* fall-through */
-   }
-
-invalid_pname:
-   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname=%s)",
-               _mesa_lookup_enum_by_nr(pname));
-}
-
-
-/**
- * New in GL 3.2
- * This is pretty much a duplicate of GetBufferParameteriv() but the
- * GL_BUFFER_SIZE_ARB attribute will be 64-bits on a 64-bit system.
- */
-void GLAPIENTRY
-_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameteri64v" );
-      return;
-   }
-
-   switch (pname) {
-   case GL_BUFFER_SIZE_ARB:
-      *params = bufObj->Size;
-      return;
-   case GL_BUFFER_USAGE_ARB:
-      *params = bufObj->Usage;
-      return;
-   case GL_BUFFER_ACCESS_ARB:
-      *params = simplified_access_mode(bufObj->AccessFlags);
-      return;
-   case GL_BUFFER_ACCESS_FLAGS:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->AccessFlags;
-      return;
-   case GL_BUFFER_MAPPED_ARB:
-      *params = _mesa_bufferobj_mapped(bufObj);
-      return;
-   case GL_BUFFER_MAP_OFFSET:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->Offset;
-      return;
-   case GL_BUFFER_MAP_LENGTH:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->Length;
-      return;
-   default:
-      ; /* fall-through */
-   }
-
-invalid_pname:
-   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname=%s)",
-               _mesa_lookup_enum_by_nr(pname));
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object * bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (pname != GL_BUFFER_MAP_POINTER_ARB) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(pname)");
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );
-      return;
-   }
-
-   *params = bufObj->Pointer;
-}
-
-
-void GLAPIENTRY
-_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
-                        GLintptr readOffset, GLintptr writeOffset,
-                        GLsizeiptr size)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *src, *dst;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   src = get_buffer(ctx, readTarget);
-   if (!src || !_mesa_is_bufferobj(src)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glCopyBuffserSubData(readTarget = 0x%x)", readTarget);
-      return;
-   }
-
-   dst = get_buffer(ctx, writeTarget);
-   if (!dst || !_mesa_is_bufferobj(dst)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget);
-      return;
-   }
-
-   if (_mesa_bufferobj_mapped(src)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyBuffserSubData(readBuffer is mapped)");
-      return;
-   }
-
-   if (_mesa_bufferobj_mapped(dst)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyBuffserSubData(writeBuffer is mapped)");
-      return;
-   }
-
-   if (readOffset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(readOffset = %d)", (int) readOffset);
-      return;
-   }
-
-   if (writeOffset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset);
-      return;
-   }
-
-   if (readOffset + size > src->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(readOffset + size = %d)",
-                  (int) (readOffset + size));
-      return;
-   }
-
-   if (writeOffset + size > dst->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(writeOffset + size = %d)",
-                  (int) (writeOffset + size));
-      return;
-   }
-
-   if (src == dst) {
-      if (readOffset + size <= writeOffset) {
-         /* OK */
-      }
-      else if (writeOffset + size <= readOffset) {
-         /* OK */
-      }
-      else {
-         /* overlapping src/dst is illegal */
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyBuffserSubData(overlapping src/dst)");
-         return;
-      }
-   }
-
-   ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);
-}
-
-
-/**
- * See GL_ARB_map_buffer_range spec
- */
-void * GLAPIENTRY
-_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-                     GLbitfield access)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   void *map;
-
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
-
-   if (!ctx->Extensions.ARB_map_buffer_range) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(extension not supported)");
-      return NULL;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset = %ld)", (long)offset);
-      return NULL;
-   }
-
-   if (length < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(length = %ld)", (long)length);
-      return NULL;
-   }
-
-   if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(access indicates neither read or write)");
-      return NULL;
-   }
-
-   if (access & GL_MAP_READ_BIT) {
-      if ((access & GL_MAP_INVALIDATE_RANGE_BIT) ||
-          (access & GL_MAP_INVALIDATE_BUFFER_BIT) ||
-          (access & GL_MAP_UNSYNCHRONIZED_BIT)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glMapBufferRange(invalid access flags)");
-         return NULL;
-      }
-   }
-
-   if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&
-       ((access & GL_MAP_WRITE_BIT) == 0)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(invalid access flags)");
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj || !_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glMapBufferRange(target = 0x%x)", target);
-      return NULL;
-   }
-
-   if (offset + length > bufObj->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset + length > size)");
-      return NULL;
-   }
-
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(buffer already mapped)");
-      return NULL;
-   }
-      
-   ASSERT(ctx->Driver.MapBufferRange);
-   map = ctx->Driver.MapBufferRange(ctx, target, offset, length,
-                                    access, bufObj);
-   if (!map) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");
-   }
-   else {
-      /* The driver callback should have set all these fields.
-       * This is important because other modules (like VBO) might call
-       * the driver function directly.
-       */
-      ASSERT(bufObj->Pointer == map);
-      ASSERT(bufObj->Length == length);
-      ASSERT(bufObj->Offset == offset);
-      ASSERT(bufObj->AccessFlags == access);
-   }
-
-   return map;
-}
-
-
-/**
- * See GL_ARB_map_buffer_range spec
- */
-void GLAPIENTRY
-_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!ctx->Extensions.ARB_map_buffer_range) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(extension not supported)");
-      return;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset = %ld)", (long)offset);
-      return;
-   }
-
-   if (length < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(length = %ld)", (long)length);
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glMapBufferRange(target = 0x%x)", target);
-      return;
-   }
-
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(current buffer is 0)");
-      return;
-   }
-
-   if (!_mesa_bufferobj_mapped(bufObj)) {
-      /* buffer is not mapped */
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(buffer is not mapped)");
-      return;
-   }
-
-   if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)");
-      return;
-   }
-
-   if (offset + length > bufObj->Length) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-		  "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",
-		  (long)offset, (long)length, (long)bufObj->Length);
-      return;
-   }
-
-   ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT);
-
-   if (ctx->Driver.FlushMappedBufferRange)
-      ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj);
-}
-
-
-#if FEATURE_APPLE_object_purgeable
-static GLenum
-_mesa_BufferObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_buffer_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glObjectPurgeable(buffer 0)" );
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.BufferObjectPurgeable)
-      retval = ctx->Driver.BufferObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_RenderObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_renderbuffer *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.RenderObjectPurgeable)
-      retval = ctx->Driver.RenderObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_TextureObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_texture_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.TextureObjectPurgeable)
-      retval = ctx->Driver.TextureObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-GLenum GLAPIENTRY
-_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
-{
-   GLenum retval;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   switch (option) {
-   case GL_VOLATILE_APPLE:
-   case GL_RELEASED_APPLE:
-      /* legal */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectPurgeable(name = 0x%x) invalid option: %d",
-                  name, option);
-      return 0;
-   }
-
-   switch (objectType) {
-   case GL_TEXTURE:
-      retval = _mesa_TextureObjectPurgeable (ctx, name, option);
-      break;
-   case GL_RENDERBUFFER_EXT:
-      retval = _mesa_RenderObjectPurgeable (ctx, name, option);
-      break;
-   case GL_BUFFER_OBJECT_APPLE:
-      retval = _mesa_BufferObjectPurgeable (ctx, name, option);
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectPurgeable(name = 0x%x) invalid type: %d",
-                  name, objectType);
-      return 0;
-   }
-
-   /* In strict conformance to the spec, we must only return VOLATILE when
-    * when passed the VOLATILE option. Madness.
-    *
-    * XXX First fix the spec, then fix me.
-    */
-   return option == GL_VOLATILE_APPLE ? GL_VOLATILE_APPLE : retval;
-}
-
-
-static GLenum
-_mesa_BufferObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_buffer_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is "
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.BufferObjectUnpurgeable)
-      retval = ctx->Driver.BufferObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_RenderObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_renderbuffer *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is "
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.RenderObjectUnpurgeable)
-      retval = ctx->Driver.RenderObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_TextureObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_texture_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is"
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.TextureObjectUnpurgeable)
-      retval = ctx->Driver.TextureObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-GLenum GLAPIENTRY
-_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   switch (option) {
-   case GL_RETAINED_APPLE:
-   case GL_UNDEFINED_APPLE:
-      /* legal */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectUnpurgeable(name = 0x%x) invalid option: %d",
-                  name, option);
-      return 0;
-   }
-
-   switch (objectType) {
-   case GL_BUFFER_OBJECT_APPLE:
-      return _mesa_BufferObjectUnpurgeable(ctx, name, option);
-   case GL_TEXTURE:
-      return _mesa_TextureObjectUnpurgeable(ctx, name, option);
-   case GL_RENDERBUFFER_EXT:
-      return _mesa_RenderObjectUnpurgeable(ctx, name, option);
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectUnpurgeable(name = 0x%x) invalid type: %d",
-                  name, objectType);
-      return 0;
-   }
-}
-
-
-static void
-_mesa_GetBufferObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                      GLenum pname, GLint* params)
-{
-   struct gl_buffer_object *bufObj;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetObjectParameteriv(name = 0x%x) invalid object", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-static void
-_mesa_GetRenderObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                      GLenum pname, GLint* params)
-{
-   struct gl_renderbuffer *bufObj;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-static void
-_mesa_GetTextureObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                       GLenum pname, GLint* params)
-{
-   struct gl_texture_object *bufObj;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname,
-                                GLint* params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetObjectParameteriv(name = 0x%x)", name);
-      return;
-   }
-
-   switch (objectType) {
-   case GL_TEXTURE:
-      _mesa_GetTextureObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   case GL_BUFFER_OBJECT_APPLE:
-      _mesa_GetBufferObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   case GL_RENDERBUFFER_EXT:
-      _mesa_GetRenderObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid type: %d",
-                  name, objectType);
-   }
-}
-
-#endif /* FEATURE_APPLE_object_purgeable */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file bufferobj.c

+ * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.

+ * \author Brian Paul, Ian Romanick

+ */

+

+

+#include "glheader.h"

+#include "enums.h"

+#include "hash.h"

+#include "imports.h"

+#include "image.h"

+#include "context.h"

+#include "bufferobj.h"

+#include "fbobject.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "texobj.h"

+

+

+/* Debug flags */

+/*#define VBO_DEBUG*/

+/*#define BOUNDS_CHECK*/

+

+

+#if FEATURE_OES_mapbuffer

+#define DEFAULT_ACCESS GL_MAP_WRITE_BIT

+#else

+#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)

+#endif

+

+

+/**

+ * Used as a placeholder for buffer objects between glGenBuffers() and

+ * glBindBuffer() so that glIsBuffer() can work correctly.

+ */

+static struct gl_buffer_object DummyBufferObject;

+

+

+/**

+ * Return pointer to address of a buffer object target.

+ * \param ctx  the GL context

+ * \param target  the buffer object target to be retrieved.

+ * \return   pointer to pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if \c target is invalid.

+ */

+static INLINE struct gl_buffer_object **

+get_buffer_target(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_ARRAY_BUFFER_ARB:

+      return &ctx->Array.ArrayBufferObj;

+   case GL_ELEMENT_ARRAY_BUFFER_ARB:

+      return &ctx->Array.ElementArrayBufferObj;

+   case GL_PIXEL_PACK_BUFFER_EXT:

+      return &ctx->Pack.BufferObj;

+   case GL_PIXEL_UNPACK_BUFFER_EXT:

+      return &ctx->Unpack.BufferObj;

+   case GL_COPY_READ_BUFFER:

+      return &ctx->CopyReadBuffer;

+   case GL_COPY_WRITE_BUFFER:

+      return &ctx->CopyWriteBuffer;

+#if FEATURE_EXT_transform_feedback

+   case GL_TRANSFORM_FEEDBACK_BUFFER:

+      if (ctx->Extensions.EXT_transform_feedback) {

+         return &ctx->TransformFeedback.CurrentBuffer;

+      }

+      break;

+#endif

+   default:

+      return NULL;

+   }

+   return NULL;

+}

+

+

+/**

+ * Get the buffer object bound to the specified target in a GL context.

+ * \param ctx  the GL context

+ * \param target  the buffer object target to be retrieved.

+ * \return   pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if \c target is invalid.

+ */

+static INLINE struct gl_buffer_object *

+get_buffer(struct gl_context *ctx, GLenum target)

+{

+   struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);

+   if (bufObj)

+      return *bufObj;

+   return NULL;

+}

+

+

+/**

+ * Convert a GLbitfield describing the mapped buffer access flags

+ * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.

+ */

+static GLenum

+simplified_access_mode(GLbitfield access)

+{

+   const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;

+   if ((access & rwFlags) == rwFlags)

+      return GL_READ_WRITE;

+   if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)

+      return GL_READ_ONLY;

+   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)

+      return GL_WRITE_ONLY;

+   return GL_READ_WRITE; /* this should never happen, but no big deal */

+}

+

+

+/**

+ * Tests the subdata range parameters and sets the GL error code for

+ * \c glBufferSubDataARB and \c glGetBufferSubDataARB.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte of the subdata range.

+ * \param size    Size, in bytes, of the subdata range.

+ * \param caller  Name of calling function for recording errors.

+ * \return   A pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if any of the parameter or state

+ *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB

+ *           are invalid.

+ *

+ * \sa glBufferSubDataARB, glGetBufferSubDataARB

+ */

+static struct gl_buffer_object *

+buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target, 

+                                  GLintptrARB offset, GLsizeiptrARB size,

+                                  const char *caller )

+{

+   struct gl_buffer_object *bufObj;

+

+   if (size < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);

+      return NULL;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);

+      return NULL;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+      return NULL;

+   }

+   if (offset + size > bufObj->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+		  "%s(size + offset > buffer size)", caller);

+      return NULL;

+   }

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* Buffer is currently mapped */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+      return NULL;

+   }

+

+   return bufObj;

+}

+

+

+/**

+ * Allocate and initialize a new buffer object.

+ * 

+ * Default callback for the \c dd_function_table::NewBufferObject() hook.

+ */

+struct gl_buffer_object *

+_mesa_new_buffer_object( struct gl_context *ctx, GLuint name, GLenum target )

+{

+   struct gl_buffer_object *obj;

+

+   (void) ctx;

+

+   obj = MALLOC_STRUCT(gl_buffer_object);

+   _mesa_initialize_buffer_object(obj, name, target);

+   return obj;

+}

+

+

+/**

+ * Delete a buffer object.

+ * 

+ * Default callback for the \c dd_function_table::DeleteBuffer() hook.

+ */

+void

+_mesa_delete_buffer_object( struct gl_context *ctx, struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+

+   if (bufObj->Data)

+      free(bufObj->Data);

+

+   /* assign strange values here to help w/ debugging */

+   bufObj->RefCount = -1000;

+   bufObj->Name = ~0;

+

+   _glthread_DESTROY_MUTEX(bufObj->Mutex);

+   free(bufObj);

+}

+

+

+

+/**

+ * Set ptr to bufObj w/ reference counting.

+ */

+void

+_mesa_reference_buffer_object(struct gl_context *ctx,

+                              struct gl_buffer_object **ptr,

+                              struct gl_buffer_object *bufObj)

+{

+   if (*ptr == bufObj)

+      return;

+

+   if (*ptr) {

+      /* Unreference the old buffer */

+      GLboolean deleteFlag = GL_FALSE;

+      struct gl_buffer_object *oldObj = *ptr;

+

+      _glthread_LOCK_MUTEX(oldObj->Mutex);

+      ASSERT(oldObj->RefCount > 0);

+      oldObj->RefCount--;

+#if 0

+      printf("BufferObj %p %d DECR to %d\n",

+             (void *) oldObj, oldObj->Name, oldObj->RefCount);

+#endif

+      deleteFlag = (oldObj->RefCount == 0);

+      _glthread_UNLOCK_MUTEX(oldObj->Mutex);

+

+      if (deleteFlag) {

+

+         /* some sanity checking: don't delete a buffer still in use */

+#if 0

+         /* unfortunately, these tests are invalid during context tear-down */

+	 ASSERT(ctx->Array.ArrayBufferObj != bufObj);

+	 ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);

+	 ASSERT(ctx->Array.ArrayObj->Vertex.BufferObj != bufObj);

+#endif

+

+	 ASSERT(ctx->Driver.DeleteBuffer);

+         ctx->Driver.DeleteBuffer(ctx, oldObj);

+      }

+

+      *ptr = NULL;

+   }

+   ASSERT(!*ptr);

+

+   if (bufObj) {

+      /* reference new buffer */

+      _glthread_LOCK_MUTEX(bufObj->Mutex);

+      if (bufObj->RefCount == 0) {

+         /* this buffer's being deleted (look just above) */

+         /* Not sure this can every really happen.  Warn if it does. */

+         _mesa_problem(NULL, "referencing deleted buffer object");

+         *ptr = NULL;

+      }

+      else {

+         bufObj->RefCount++;

+#if 0

+         printf("BufferObj %p %d INCR to %d\n",

+                (void *) bufObj, bufObj->Name, bufObj->RefCount);

+#endif

+         *ptr = bufObj;

+      }

+      _glthread_UNLOCK_MUTEX(bufObj->Mutex);

+   }

+}

+

+

+/**

+ * Initialize a buffer object to default values.

+ */

+void

+_mesa_initialize_buffer_object( struct gl_buffer_object *obj,

+				GLuint name, GLenum target )

+{

+   (void) target;

+

+   memset(obj, 0, sizeof(struct gl_buffer_object));

+   _glthread_INIT_MUTEX(obj->Mutex);

+   obj->RefCount = 1;

+   obj->Name = name;

+   obj->Usage = GL_STATIC_DRAW_ARB;

+   obj->AccessFlags = DEFAULT_ACCESS;

+}

+

+

+/**

+ * Allocate space for and store data in a buffer object.  Any data that was

+ * previously stored in the buffer object is lost.  If \c data is \c NULL,

+ * memory will be allocated, but no copy will occur.

+ *

+ * This is the default callback for \c dd_function_table::BufferData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param size    Size, in bytes, of the new data store.

+ * \param data    Pointer to the data to store in the buffer object.  This

+ *                pointer may be \c NULL.

+ * \param usage   Hints about how the data will be used.

+ * \param bufObj  Object to be used.

+ *

+ * \return GL_TRUE for success, GL_FALSE for failure

+ * \sa glBufferDataARB, dd_function_table::BufferData.

+ */

+GLboolean

+_mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,

+		   const GLvoid * data, GLenum usage,

+		   struct gl_buffer_object * bufObj )

+{

+   void * new_data;

+

+   (void) ctx; (void) target;

+

+   new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );

+   if (new_data) {

+      bufObj->Data = (GLubyte *) new_data;

+      bufObj->Size = size;

+      bufObj->Usage = usage;

+

+      if (data) {

+	 memcpy( bufObj->Data, data, size );

+      }

+

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Replace data in a subrange of buffer object.  If the data range

+ * specified by \c size + \c offset extends beyond the end of the buffer or

+ * if \c data is \c NULL, no copy is performed.

+ *

+ * This is the default callback for \c dd_function_table::BufferSubData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte to be modified.

+ * \param size    Size, in bytes, of the data range.

+ * \param data    Pointer to the data to store in the buffer object.

+ * \param bufObj  Object to be used.

+ *

+ * \sa glBufferSubDataARB, dd_function_table::BufferSubData.

+ */

+void

+_mesa_buffer_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,

+		      GLsizeiptrARB size, const GLvoid * data,

+		      struct gl_buffer_object * bufObj )

+{

+   (void) ctx; (void) target;

+

+   /* this should have been caught in _mesa_BufferSubData() */

+   ASSERT(size + offset <= bufObj->Size);

+

+   if (bufObj->Data) {

+      memcpy( (GLubyte *) bufObj->Data + offset, data, size );

+   }

+}

+

+

+/**

+ * Retrieve data from a subrange of buffer object.  If the data range

+ * specified by \c size + \c offset extends beyond the end of the buffer or

+ * if \c data is \c NULL, no copy is performed.

+ *

+ * This is the default callback for \c dd_function_table::GetBufferSubData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte to be fetched.

+ * \param size    Size, in bytes, of the data range.

+ * \param data    Destination for data

+ * \param bufObj  Object to be used.

+ *

+ * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.

+ */

+void

+_mesa_buffer_get_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,

+			  GLsizeiptrARB size, GLvoid * data,

+			  struct gl_buffer_object * bufObj )

+{

+   (void) ctx; (void) target;

+

+   if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {

+      memcpy( data, (GLubyte *) bufObj->Data + offset, size );

+   }

+}

+

+

+/**

+ * Default callback for \c dd_function_tabel::MapBuffer().

+ *

+ * The function parameters will have been already tested for errors.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param access  Information about how the buffer will be accessed.

+ * \param bufObj  Object to be mapped.

+ * \return  A pointer to the object's internal data store that can be accessed

+ *          by the processor

+ *

+ * \sa glMapBufferARB, dd_function_table::MapBuffer

+ */

+void *

+_mesa_buffer_map( struct gl_context *ctx, GLenum target, GLenum access,

+		  struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   (void) access;

+   /* Just return a direct pointer to the data */

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* already mapped! */

+      return NULL;

+   }

+   bufObj->Pointer = bufObj->Data;

+   bufObj->Length = bufObj->Size;

+   bufObj->Offset = 0;

+   return bufObj->Pointer;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::MapBufferRange().

+ * Called via glMapBufferRange().

+ */

+static void *

+_mesa_buffer_map_range( struct gl_context *ctx, GLenum target, GLintptr offset,

+                        GLsizeiptr length, GLbitfield access,

+                        struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   assert(!_mesa_bufferobj_mapped(bufObj));

+   /* Just return a direct pointer to the data */

+   bufObj->Pointer = bufObj->Data + offset;

+   bufObj->Length = length;

+   bufObj->Offset = offset;

+   bufObj->AccessFlags = access;

+   return bufObj->Pointer;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::FlushMappedBufferRange().

+ * Called via glFlushMappedBufferRange().

+ */

+static void

+_mesa_buffer_flush_mapped_range( struct gl_context *ctx, GLenum target, 

+                                 GLintptr offset, GLsizeiptr length,

+                                 struct gl_buffer_object *obj )

+{

+   (void) ctx;

+   (void) target;

+   (void) offset;

+   (void) length;

+   (void) obj;

+   /* no-op */

+}

+

+

+/**

+ * Default callback for \c dd_function_table::MapBuffer().

+ *

+ * The input parameters will have been already tested for errors.

+ *

+ * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer

+ */

+GLboolean

+_mesa_buffer_unmap( struct gl_context *ctx, GLenum target,

+                    struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   /* XXX we might assert here that bufObj->Pointer is non-null */

+   bufObj->Pointer = NULL;

+   bufObj->Length = 0;

+   bufObj->Offset = 0;

+   bufObj->AccessFlags = 0x0;

+   return GL_TRUE;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::CopyBufferSubData().

+ * Called via glCopyBuffserSubData().

+ */

+static void

+_mesa_copy_buffer_subdata(struct gl_context *ctx,

+                          struct gl_buffer_object *src,

+                          struct gl_buffer_object *dst,

+                          GLintptr readOffset, GLintptr writeOffset,

+                          GLsizeiptr size)

+{

+   GLubyte *srcPtr, *dstPtr;

+

+   /* buffer should not already be mapped */

+   assert(!_mesa_bufferobj_mapped(src));

+   assert(!_mesa_bufferobj_mapped(dst));

+

+   srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER,

+                                              GL_READ_ONLY, src);

+   dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER,

+                                              GL_WRITE_ONLY, dst);

+

+   if (srcPtr && dstPtr)

+      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);

+

+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src);

+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst);

+}

+

+

+

+/**

+ * Initialize the state associated with buffer objects

+ */

+void

+_mesa_init_buffer_objects( struct gl_context *ctx )

+{

+   memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));

+   _glthread_INIT_MUTEX(DummyBufferObject.Mutex);

+   DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */

+

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,

+                                 ctx->Shared->NullBufferObj);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj,

+                                 ctx->Shared->NullBufferObj);

+

+   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,

+                                 ctx->Shared->NullBufferObj);

+   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,

+                                 ctx->Shared->NullBufferObj);

+}

+

+

+void

+_mesa_free_buffer_objects( struct gl_context *ctx )

+{

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);

+

+   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL);

+}

+

+

+/**

+ * Bind the specified target to buffer for the specified context.

+ * Called by glBindBuffer() and other functions.

+ */

+static void

+bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)

+{

+   struct gl_buffer_object *oldBufObj;

+   struct gl_buffer_object *newBufObj = NULL;

+   struct gl_buffer_object **bindTarget = NULL;

+

+   bindTarget = get_buffer_target(ctx, target);

+   if (!bindTarget) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);

+      return;

+   }

+

+   /* Get pointer to old buffer object (to be unbound) */

+   oldBufObj = *bindTarget;

+   if (oldBufObj && oldBufObj->Name == buffer)

+      return;   /* rebinding the same buffer object- no change */

+

+   /*

+    * Get pointer to new buffer object (newBufObj)

+    */

+   if (buffer == 0) {

+      /* The spec says there's not a buffer object named 0, but we use

+       * one internally because it simplifies things.

+       */

+      newBufObj = ctx->Shared->NullBufferObj;

+   }

+   else {

+      /* non-default buffer object */

+      newBufObj = _mesa_lookup_bufferobj(ctx, buffer);

+      if (!newBufObj || newBufObj == &DummyBufferObject) {

+         /* If this is a new buffer object id, or one which was generated but

+          * never used before, allocate a buffer object now.

+          */

+         ASSERT(ctx->Driver.NewBufferObject);

+         newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target);

+         if (!newBufObj) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");

+            return;

+         }

+         _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, newBufObj);

+      }

+   }

+   

+   /* bind new buffer */

+   _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);

+

+   /* Pass BindBuffer call to device driver */

+   if (ctx->Driver.BindBuffer)

+      ctx->Driver.BindBuffer( ctx, target, newBufObj );

+}

+

+

+/**

+ * Update the default buffer objects in the given context to reference those

+ * specified in the shared state and release those referencing the old 

+ * shared state.

+ */

+void

+_mesa_update_default_objects_buffer_objects(struct gl_context *ctx)

+{

+   /* Bind the NullBufferObj to remove references to those

+    * in the shared context hash table.

+    */

+   bind_buffer_object( ctx, GL_ARRAY_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_PIXEL_PACK_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_PIXEL_UNPACK_BUFFER_ARB, 0);

+}

+

+

+

+/**

+ * Return the gl_buffer_object for the given ID.

+ * Always return NULL for ID 0.

+ */

+struct gl_buffer_object *

+_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer)

+{

+   if (buffer == 0)

+      return NULL;

+   else

+      return (struct gl_buffer_object *)

+         _mesa_HashLookup(ctx->Shared->BufferObjects, buffer);

+}

+

+

+/**

+ * If *ptr points to obj, set ptr = the Null/default buffer object.

+ * This is a helper for buffer object deletion.

+ * The GL spec says that deleting a buffer object causes it to get

+ * unbound from all arrays in the current context.

+ */

+static void

+unbind(struct gl_context *ctx,

+       struct gl_buffer_object **ptr,

+       struct gl_buffer_object *obj)

+{

+   if (*ptr == obj) {

+      _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);

+   }

+}

+

+

+/**

+ * Plug default/fallback buffer object functions into the device

+ * driver hooks.

+ */

+void

+_mesa_init_buffer_object_functions(struct dd_function_table *driver)

+{

+   /* GL_ARB_vertex/pixel_buffer_object */

+   driver->NewBufferObject = _mesa_new_buffer_object;

+   driver->DeleteBuffer = _mesa_delete_buffer_object;

+   driver->BindBuffer = NULL;

+   driver->BufferData = _mesa_buffer_data;

+   driver->BufferSubData = _mesa_buffer_subdata;

+   driver->GetBufferSubData = _mesa_buffer_get_subdata;

+   driver->MapBuffer = _mesa_buffer_map;

+   driver->UnmapBuffer = _mesa_buffer_unmap;

+

+   /* GL_ARB_map_buffer_range */

+   driver->MapBufferRange = _mesa_buffer_map_range;

+   driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;

+

+   /* GL_ARB_copy_buffer */

+   driver->CopyBufferSubData = _mesa_copy_buffer_subdata;

+}

+

+

+

+/**********************************************************************/

+/* API Functions                                                      */

+/**********************************************************************/

+

+void GLAPIENTRY

+_mesa_BindBufferARB(GLenum target, GLuint buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBindBuffer(%s, %u)\n",

+                  _mesa_lookup_enum_by_nr(target), buffer);

+

+   bind_buffer_object(ctx, target, buffer);

+}

+

+

+/**

+ * Delete a set of buffer objects.

+ * 

+ * \param n      Number of buffer objects to delete.

+ * \param ids    Array of \c n buffer object IDs.

+ */

+void GLAPIENTRY

+_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLsizei i;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");

+      return;

+   }

+

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+

+   for (i = 0; i < n; i++) {

+      struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);

+      if (bufObj) {

+         struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+         GLuint j;

+

+         ASSERT(bufObj->Name == ids[i] || bufObj == &DummyBufferObject);

+

+         if (_mesa_bufferobj_mapped(bufObj)) {

+            /* if mapped, unmap it now */

+            ctx->Driver.UnmapBuffer(ctx, 0, bufObj);

+            bufObj->AccessFlags = DEFAULT_ACCESS;

+            bufObj->Pointer = NULL;

+         }

+

+         /* unbind any vertex pointers bound to this buffer */

+         unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Color.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Index.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);

+         for (j = 0; j < Elements(arrayObj->TexCoord); j++) {

+            unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);

+         }

+         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {

+            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);

+         }

+

+         if (ctx->Array.ArrayBufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );

+         }

+         if (ctx->Array.ElementArrayBufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );

+         }

+

+         /* unbind any pixel pack/unpack pointers bound to this buffer */

+         if (ctx->Pack.BufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );

+         }

+         if (ctx->Unpack.BufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );

+         }

+

+         /* The ID is immediately freed for re-use */

+         _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]);

+         _mesa_reference_buffer_object(ctx, &bufObj, NULL);

+      }

+   }

+

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+}

+

+

+/**

+ * Generate a set of unique buffer object IDs and store them in \c buffer.

+ * 

+ * \param n       Number of IDs to generate.

+ * \param buffer  Array of \c n locations to store the IDs.

+ */

+void GLAPIENTRY

+_mesa_GenBuffersARB(GLsizei n, GLuint *buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint first;

+   GLint i;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGenBuffers(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");

+      return;

+   }

+

+   if (!buffer) {

+      return;

+   }

+

+   /*

+    * This must be atomic (generation and allocation of buffer object IDs)

+    */

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);

+

+   /* Insert the ID and pointer to dummy buffer object into hash table */

+   for (i = 0; i < n; i++) {

+      _mesa_HashInsert(ctx->Shared->BufferObjects, first + i,

+                       &DummyBufferObject);

+      buffer[i] = first + i;

+   }

+

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+}

+

+

+/**

+ * Determine if ID is the name of a buffer object.

+ * 

+ * \param id  ID of the potential buffer object.

+ * \return  \c GL_TRUE if \c id is the name of a buffer object, 

+ *          \c GL_FALSE otherwise.

+ */

+GLboolean GLAPIENTRY

+_mesa_IsBufferARB(GLuint id)

+{

+   struct gl_buffer_object *bufObj;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+   bufObj = _mesa_lookup_bufferobj(ctx, id);

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+

+   return bufObj && bufObj != &DummyBufferObject;

+}

+

+

+void GLAPIENTRY

+_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,

+                    const GLvoid * data, GLenum usage)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBufferData(%s, %ld, %p, %s)\n",

+                  _mesa_lookup_enum_by_nr(target),

+                  (long int) size, data,

+                  _mesa_lookup_enum_by_nr(usage));

+

+   if (size < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)");

+      return;

+   }

+

+   switch (usage) {

+   case GL_STREAM_DRAW_ARB:

+   case GL_STREAM_READ_ARB:

+   case GL_STREAM_COPY_ARB:

+   case GL_STATIC_DRAW_ARB:

+   case GL_STATIC_READ_ARB:

+   case GL_STATIC_COPY_ARB:

+   case GL_DYNAMIC_DRAW_ARB:

+   case GL_DYNAMIC_READ_ARB:

+   case GL_DYNAMIC_COPY_ARB:

+      /* OK */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)");

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" );

+      return;

+   }

+   

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* Unmap the existing buffer.  We'll replace it now.  Not an error. */

+      ctx->Driver.UnmapBuffer(ctx, target, bufObj);

+      bufObj->AccessFlags = DEFAULT_ACCESS;

+      ASSERT(bufObj->Pointer == NULL);

+   }  

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);

+

+   bufObj->Written = GL_TRUE;

+

+#ifdef VBO_DEBUG

+   printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",

+                bufObj->Name, size, data, usage);

+#endif

+

+#ifdef BOUNDS_CHECK

+   size += 100;

+#endif

+

+   ASSERT(ctx->Driver.BufferData);

+   if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB()");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,

+                       GLsizeiptrARB size, const GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,

+                                              "glBufferSubDataARB" );

+   if (!bufObj) {

+      /* error already recorded */

+      return;

+   }

+

+   if (size == 0)

+      return;

+

+   bufObj->Written = GL_TRUE;

+

+   ASSERT(ctx->Driver.BufferSubData);

+   ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,

+                          GLsizeiptrARB size, void * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,

+                                              "glGetBufferSubDataARB" );

+   if (!bufObj) {

+      /* error already recorded */

+      return;

+   }

+

+   ASSERT(ctx->Driver.GetBufferSubData);

+   ctx->Driver.GetBufferSubData( ctx, target, offset, size, data, bufObj );

+}

+

+

+void * GLAPIENTRY

+_mesa_MapBufferARB(GLenum target, GLenum access)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object * bufObj;

+   GLbitfield accessFlags;

+   void *map;

+

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);

+

+   switch (access) {

+   case GL_READ_ONLY_ARB:

+      accessFlags = GL_MAP_READ_BIT;

+      break;

+   case GL_WRITE_ONLY_ARB:

+      accessFlags = GL_MAP_WRITE_BIT;

+      break;

+   case GL_READ_WRITE_ARB:

+      accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );

+      return NULL;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" );

+      return NULL;

+   }

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");

+      return NULL;

+   }

+

+   ASSERT(ctx->Driver.MapBuffer);

+   map = ctx->Driver.MapBuffer( ctx, target, access, bufObj );

+   if (!map) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");

+      return NULL;

+   }

+   else {

+      /* The driver callback should have set these fields.

+       * This is important because other modules (like VBO) might call

+       * the driver function directly.

+       */

+      ASSERT(bufObj->Pointer == map);

+      ASSERT(bufObj->Length == bufObj->Size);

+      ASSERT(bufObj->Offset == 0);

+      bufObj->AccessFlags = accessFlags;

+   }

+

+   if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB)

+      bufObj->Written = GL_TRUE;

+

+#ifdef VBO_DEBUG

+   printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",

+	  bufObj->Name, bufObj->Size, access);

+   if (access == GL_WRITE_ONLY_ARB) {

+      GLuint i;

+      GLubyte *b = (GLubyte *) bufObj->Pointer;

+      for (i = 0; i < bufObj->Size; i++)

+         b[i] = i & 0xff;

+   }

+#endif

+

+#ifdef BOUNDS_CHECK

+   {

+      GLubyte *buf = (GLubyte *) bufObj->Pointer;

+      GLuint i;

+      /* buffer is 100 bytes larger than requested, fill with magic value */

+      for (i = 0; i < 100; i++) {

+         buf[bufObj->Size - i - 1] = 123;

+      }

+   }

+#endif

+

+   return bufObj->Pointer;

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_UnmapBufferARB(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   GLboolean status = GL_TRUE;

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );

+      return GL_FALSE;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );

+      return GL_FALSE;

+   }

+   if (!_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");

+      return GL_FALSE;

+   }

+

+#ifdef BOUNDS_CHECK

+   if (bufObj->Access != GL_READ_ONLY_ARB) {

+      GLubyte *buf = (GLubyte *) bufObj->Pointer;

+      GLuint i;

+      /* check that last 100 bytes are still = magic value */

+      for (i = 0; i < 100; i++) {

+         GLuint pos = bufObj->Size - i - 1;

+         if (buf[pos] != 123) {

+            _mesa_warning(ctx, "Out of bounds buffer object write detected"

+                          " at position %d (value = %u)\n",

+                          pos, buf[pos]);

+         }

+      }

+   }

+#endif

+

+#ifdef VBO_DEBUG

+   if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {

+      GLuint i, unchanged = 0;

+      GLubyte *b = (GLubyte *) bufObj->Pointer;

+      GLint pos = -1;

+      /* check which bytes changed */

+      for (i = 0; i < bufObj->Size - 1; i++) {

+         if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {

+            unchanged++;

+            if (pos == -1)

+               pos = i;

+         }

+      }

+      if (unchanged) {

+         printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",

+                      bufObj->Name, unchanged, bufObj->Size, pos);

+      }

+   }

+#endif

+

+   status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );

+   bufObj->AccessFlags = DEFAULT_ACCESS;

+   ASSERT(bufObj->Pointer == NULL);

+   ASSERT(bufObj->Offset == 0);

+   ASSERT(bufObj->Length == 0);

+

+   return status;

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameterivARB" );

+      return;

+   }

+

+   switch (pname) {

+   case GL_BUFFER_SIZE_ARB:

+      *params = (GLint) bufObj->Size;

+      return;

+   case GL_BUFFER_USAGE_ARB:

+      *params = bufObj->Usage;

+      return;

+   case GL_BUFFER_ACCESS_ARB:

+      *params = simplified_access_mode(bufObj->AccessFlags);

+      return;

+   case GL_BUFFER_MAPPED_ARB:

+      *params = _mesa_bufferobj_mapped(bufObj);

+      return;

+   case GL_BUFFER_ACCESS_FLAGS:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->AccessFlags;

+      return;

+   case GL_BUFFER_MAP_OFFSET:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = (GLint) bufObj->Offset;

+      return;

+   case GL_BUFFER_MAP_LENGTH:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = (GLint) bufObj->Length;

+      return;

+   default:

+      ; /* fall-through */

+   }

+

+invalid_pname:

+   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname=%s)",

+               _mesa_lookup_enum_by_nr(pname));

+}

+

+

+/**

+ * New in GL 3.2

+ * This is pretty much a duplicate of GetBufferParameteriv() but the

+ * GL_BUFFER_SIZE_ARB attribute will be 64-bits on a 64-bit system.

+ */

+void GLAPIENTRY

+_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameteri64v" );

+      return;

+   }

+

+   switch (pname) {

+   case GL_BUFFER_SIZE_ARB:

+      *params = bufObj->Size;

+      return;

+   case GL_BUFFER_USAGE_ARB:

+      *params = bufObj->Usage;

+      return;

+   case GL_BUFFER_ACCESS_ARB:

+      *params = simplified_access_mode(bufObj->AccessFlags);

+      return;

+   case GL_BUFFER_ACCESS_FLAGS:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->AccessFlags;

+      return;

+   case GL_BUFFER_MAPPED_ARB:

+      *params = _mesa_bufferobj_mapped(bufObj);

+      return;

+   case GL_BUFFER_MAP_OFFSET:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->Offset;

+      return;

+   case GL_BUFFER_MAP_LENGTH:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->Length;

+      return;

+   default:

+      ; /* fall-through */

+   }

+

+invalid_pname:

+   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname=%s)",

+               _mesa_lookup_enum_by_nr(pname));

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object * bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (pname != GL_BUFFER_MAP_POINTER_ARB) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(pname)");

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );

+      return;

+   }

+

+   *params = bufObj->Pointer;

+}

+

+

+void GLAPIENTRY

+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,

+                        GLintptr readOffset, GLintptr writeOffset,

+                        GLsizeiptr size)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *src, *dst;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   src = get_buffer(ctx, readTarget);

+   if (!src || !_mesa_is_bufferobj(src)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glCopyBuffserSubData(readTarget = 0x%x)", readTarget);

+      return;

+   }

+

+   dst = get_buffer(ctx, writeTarget);

+   if (!dst || !_mesa_is_bufferobj(dst)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget);

+      return;

+   }

+

+   if (_mesa_bufferobj_mapped(src)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyBuffserSubData(readBuffer is mapped)");

+      return;

+   }

+

+   if (_mesa_bufferobj_mapped(dst)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyBuffserSubData(writeBuffer is mapped)");

+      return;

+   }

+

+   if (readOffset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(readOffset = %d)", (int) readOffset);

+      return;

+   }

+

+   if (writeOffset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset);

+      return;

+   }

+

+   if (readOffset + size > src->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(readOffset + size = %d)",

+                  (int) (readOffset + size));

+      return;

+   }

+

+   if (writeOffset + size > dst->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(writeOffset + size = %d)",

+                  (int) (writeOffset + size));

+      return;

+   }

+

+   if (src == dst) {

+      if (readOffset + size <= writeOffset) {

+         /* OK */

+      }

+      else if (writeOffset + size <= readOffset) {

+         /* OK */

+      }

+      else {

+         /* overlapping src/dst is illegal */

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyBuffserSubData(overlapping src/dst)");

+         return;

+      }

+   }

+

+   ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);

+}

+

+

+/**

+ * See GL_ARB_map_buffer_range spec

+ */

+void * GLAPIENTRY

+_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,

+                     GLbitfield access)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   void *map;

+

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);

+

+   if (!ctx->Extensions.ARB_map_buffer_range) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(extension not supported)");

+      return NULL;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset = %ld)", (long)offset);

+      return NULL;

+   }

+

+   if (length < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(length = %ld)", (long)length);

+      return NULL;

+   }

+

+   if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(access indicates neither read or write)");

+      return NULL;

+   }

+

+   if (access & GL_MAP_READ_BIT) {

+      if ((access & GL_MAP_INVALIDATE_RANGE_BIT) ||

+          (access & GL_MAP_INVALIDATE_BUFFER_BIT) ||

+          (access & GL_MAP_UNSYNCHRONIZED_BIT)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glMapBufferRange(invalid access flags)");

+         return NULL;

+      }

+   }

+

+   if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&

+       ((access & GL_MAP_WRITE_BIT) == 0)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(invalid access flags)");

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj || !_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glMapBufferRange(target = 0x%x)", target);

+      return NULL;

+   }

+

+   if (offset + length > bufObj->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset + length > size)");

+      return NULL;

+   }

+

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(buffer already mapped)");

+      return NULL;

+   }

+      

+   ASSERT(ctx->Driver.MapBufferRange);

+   map = ctx->Driver.MapBufferRange(ctx, target, offset, length,

+                                    access, bufObj);

+   if (!map) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");

+   }

+   else {

+      /* The driver callback should have set all these fields.

+       * This is important because other modules (like VBO) might call

+       * the driver function directly.

+       */

+      ASSERT(bufObj->Pointer == map);

+      ASSERT(bufObj->Length == length);

+      ASSERT(bufObj->Offset == offset);

+      ASSERT(bufObj->AccessFlags == access);

+   }

+

+   return map;

+}

+

+

+/**

+ * See GL_ARB_map_buffer_range spec

+ */

+void GLAPIENTRY

+_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!ctx->Extensions.ARB_map_buffer_range) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(extension not supported)");

+      return;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset = %ld)", (long)offset);

+      return;

+   }

+

+   if (length < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(length = %ld)", (long)length);

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glMapBufferRange(target = 0x%x)", target);

+      return;

+   }

+

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(current buffer is 0)");

+      return;

+   }

+

+   if (!_mesa_bufferobj_mapped(bufObj)) {

+      /* buffer is not mapped */

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(buffer is not mapped)");

+      return;

+   }

+

+   if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)");

+      return;

+   }

+

+   if (offset + length > bufObj->Length) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+		  "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",

+		  (long)offset, (long)length, (long)bufObj->Length);

+      return;

+   }

+

+   ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT);

+

+   if (ctx->Driver.FlushMappedBufferRange)

+      ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj);

+}

+

+

+#if FEATURE_APPLE_object_purgeable

+static GLenum

+_mesa_BufferObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_buffer_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glObjectPurgeable(buffer 0)" );

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.BufferObjectPurgeable)

+      retval = ctx->Driver.BufferObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_RenderObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_renderbuffer *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.RenderObjectPurgeable)

+      retval = ctx->Driver.RenderObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_TextureObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_texture_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.TextureObjectPurgeable)

+      retval = ctx->Driver.TextureObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+GLenum GLAPIENTRY

+_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)

+{

+   GLenum retval;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   switch (option) {

+   case GL_VOLATILE_APPLE:

+   case GL_RELEASED_APPLE:

+      /* legal */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectPurgeable(name = 0x%x) invalid option: %d",

+                  name, option);

+      return 0;

+   }

+

+   switch (objectType) {

+   case GL_TEXTURE:

+      retval = _mesa_TextureObjectPurgeable (ctx, name, option);

+      break;

+   case GL_RENDERBUFFER_EXT:

+      retval = _mesa_RenderObjectPurgeable (ctx, name, option);

+      break;

+   case GL_BUFFER_OBJECT_APPLE:

+      retval = _mesa_BufferObjectPurgeable (ctx, name, option);

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectPurgeable(name = 0x%x) invalid type: %d",

+                  name, objectType);

+      return 0;

+   }

+

+   /* In strict conformance to the spec, we must only return VOLATILE when

+    * when passed the VOLATILE option. Madness.

+    *

+    * XXX First fix the spec, then fix me.

+    */

+   return option == GL_VOLATILE_APPLE ? GL_VOLATILE_APPLE : retval;

+}

+

+

+static GLenum

+_mesa_BufferObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_buffer_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is "

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.BufferObjectUnpurgeable)

+      retval = ctx->Driver.BufferObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_RenderObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_renderbuffer *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is "

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.RenderObjectUnpurgeable)

+      retval = ctx->Driver.RenderObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_TextureObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_texture_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is"

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.TextureObjectUnpurgeable)

+      retval = ctx->Driver.TextureObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+GLenum GLAPIENTRY

+_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   switch (option) {

+   case GL_RETAINED_APPLE:

+   case GL_UNDEFINED_APPLE:

+      /* legal */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectUnpurgeable(name = 0x%x) invalid option: %d",

+                  name, option);

+      return 0;

+   }

+

+   switch (objectType) {

+   case GL_BUFFER_OBJECT_APPLE:

+      return _mesa_BufferObjectUnpurgeable(ctx, name, option);

+   case GL_TEXTURE:

+      return _mesa_TextureObjectUnpurgeable(ctx, name, option);

+   case GL_RENDERBUFFER_EXT:

+      return _mesa_RenderObjectUnpurgeable(ctx, name, option);

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectUnpurgeable(name = 0x%x) invalid type: %d",

+                  name, objectType);

+      return 0;

+   }

+}

+

+

+static void

+_mesa_GetBufferObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                      GLenum pname, GLint* params)

+{

+   struct gl_buffer_object *bufObj;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetObjectParameteriv(name = 0x%x) invalid object", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+static void

+_mesa_GetRenderObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                      GLenum pname, GLint* params)

+{

+   struct gl_renderbuffer *bufObj;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+static void

+_mesa_GetTextureObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                       GLenum pname, GLint* params)

+{

+   struct gl_texture_object *bufObj;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname,

+                                GLint* params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetObjectParameteriv(name = 0x%x)", name);

+      return;

+   }

+

+   switch (objectType) {

+   case GL_TEXTURE:

+      _mesa_GetTextureObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   case GL_BUFFER_OBJECT_APPLE:

+      _mesa_GetBufferObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   case GL_RENDERBUFFER_EXT:

+      _mesa_GetRenderObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid type: %d",

+                  name, objectType);

+   }

+}

+

+#endif /* FEATURE_APPLE_object_purgeable */

diff --git a/mesalib/src/mesa/main/bufferobj.h b/mesalib/src/mesa/main/bufferobj.h
index 91fa073b6..f673f431f 100644
--- a/mesalib/src/mesa/main/bufferobj.h
+++ b/mesalib/src/mesa/main/bufferobj.h
@@ -1,149 +1,149 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-#ifndef BUFFEROBJ_H
-#define BUFFEROBJ_H
-
-
-#include "mfeatures.h"
-#include "mtypes.h"
-
-
-/*
- * Internal functions
- */
-
-
-/** Is the given buffer object currently mapped? */
-static INLINE GLboolean
-_mesa_bufferobj_mapped(const struct gl_buffer_object *obj)
-{
-   return obj->Pointer != NULL;
-}
-
-/**
- * Is the given buffer object a user-created buffer object?
- * Mesa uses default buffer objects in several places.  Default buffers
- * always have Name==0.  User created buffers have Name!=0.
- */
-static INLINE GLboolean
-_mesa_is_bufferobj(const struct gl_buffer_object *obj)
-{
-   return obj->Name != 0;
-}
-
-
-extern void
-_mesa_init_buffer_objects( struct gl_context *ctx );
-
-extern void
-_mesa_free_buffer_objects( struct gl_context *ctx );
-
-extern void
-_mesa_update_default_objects_buffer_objects(struct gl_context *ctx);
-
-
-extern struct gl_buffer_object *
-_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer);
-
-extern void
-_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
-				GLuint name, GLenum target );
-
-extern void
-_mesa_reference_buffer_object(struct gl_context *ctx,
-                              struct gl_buffer_object **ptr,
-                              struct gl_buffer_object *bufObj);
-
-extern void
-_mesa_init_buffer_object_functions(struct dd_function_table *driver);
-
-
-/*
- * API functions
- */
-
-extern void GLAPIENTRY
-_mesa_BindBufferARB(GLenum target, GLuint buffer);
-
-extern void GLAPIENTRY
-_mesa_DeleteBuffersARB(GLsizei n, const GLuint * buffer);
-
-extern void GLAPIENTRY
-_mesa_GenBuffersARB(GLsizei n, GLuint * buffer);
-
-extern GLboolean GLAPIENTRY
-_mesa_IsBufferARB(GLuint buffer);
-
-extern void GLAPIENTRY
-_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage);
-
-extern void GLAPIENTRY
-_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data);
-
-extern void GLAPIENTRY
-_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data);
-
-extern void * GLAPIENTRY
-_mesa_MapBufferARB(GLenum target, GLenum access);
-
-extern GLboolean GLAPIENTRY
-_mesa_UnmapBufferARB(GLenum target);
-
-extern void GLAPIENTRY
-_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params);
-
-extern void GLAPIENTRY
-_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
-
-extern void GLAPIENTRY
-_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params);
-
-extern void GLAPIENTRY
-_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
-                        GLintptr readOffset, GLintptr writeOffset,
-                        GLsizeiptr size);
-
-extern void * GLAPIENTRY
-_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-                     GLbitfield access);
-
-extern void GLAPIENTRY
-_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
-
-#if FEATURE_APPLE_object_purgeable
-extern GLenum GLAPIENTRY
-_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option);
-
-extern GLenum GLAPIENTRY
-_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option);
-
-extern void GLAPIENTRY
-_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint* params);
-#endif
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+

+#ifndef BUFFEROBJ_H

+#define BUFFEROBJ_H

+

+

+#include "mfeatures.h"

+#include "mtypes.h"

+

+

+/*

+ * Internal functions

+ */

+

+

+/** Is the given buffer object currently mapped? */

+static INLINE GLboolean

+_mesa_bufferobj_mapped(const struct gl_buffer_object *obj)

+{

+   return obj->Pointer != NULL;

+}

+

+/**

+ * Is the given buffer object a user-created buffer object?

+ * Mesa uses default buffer objects in several places.  Default buffers

+ * always have Name==0.  User created buffers have Name!=0.

+ */

+static INLINE GLboolean

+_mesa_is_bufferobj(const struct gl_buffer_object *obj)

+{

+   return obj->Name != 0;

+}

+

+

+extern void

+_mesa_init_buffer_objects( struct gl_context *ctx );

+

+extern void

+_mesa_free_buffer_objects( struct gl_context *ctx );

+

+extern void

+_mesa_update_default_objects_buffer_objects(struct gl_context *ctx);

+

+

+extern struct gl_buffer_object *

+_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer);

+

+extern void

+_mesa_initialize_buffer_object( struct gl_buffer_object *obj,

+				GLuint name, GLenum target );

+

+extern void

+_mesa_reference_buffer_object(struct gl_context *ctx,

+                              struct gl_buffer_object **ptr,

+                              struct gl_buffer_object *bufObj);

+

+extern void

+_mesa_init_buffer_object_functions(struct dd_function_table *driver);

+

+

+/*

+ * API functions

+ */

+

+extern void GLAPIENTRY

+_mesa_BindBufferARB(GLenum target, GLuint buffer);

+

+extern void GLAPIENTRY

+_mesa_DeleteBuffersARB(GLsizei n, const GLuint * buffer);

+

+extern void GLAPIENTRY

+_mesa_GenBuffersARB(GLsizei n, GLuint * buffer);

+

+extern GLboolean GLAPIENTRY

+_mesa_IsBufferARB(GLuint buffer);

+

+extern void GLAPIENTRY

+_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage);

+

+extern void GLAPIENTRY

+_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data);

+

+extern void GLAPIENTRY

+_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data);

+

+extern void * GLAPIENTRY

+_mesa_MapBufferARB(GLenum target, GLenum access);

+

+extern GLboolean GLAPIENTRY

+_mesa_UnmapBufferARB(GLenum target);

+

+extern void GLAPIENTRY

+_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params);

+

+extern void GLAPIENTRY

+_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);

+

+extern void GLAPIENTRY

+_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params);

+

+extern void GLAPIENTRY

+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,

+                        GLintptr readOffset, GLintptr writeOffset,

+                        GLsizeiptr size);

+

+extern void * GLAPIENTRY

+_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,

+                     GLbitfield access);

+

+extern void GLAPIENTRY

+_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);

+

+#if FEATURE_APPLE_object_purgeable

+extern GLenum GLAPIENTRY

+_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option);

+

+extern GLenum GLAPIENTRY

+_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option);

+

+extern void GLAPIENTRY

+_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint* params);

+#endif

+

+#endif

diff --git a/mesalib/src/mesa/main/colortab.c b/mesalib/src/mesa/main/colortab.c
index d0c865735..48318248e 100644
--- a/mesalib/src/mesa/main/colortab.c
+++ b/mesalib/src/mesa/main/colortab.c
@@ -1,821 +1,821 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "colortab.h"
-#include "context.h"
-#include "image.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "pack.h"
-#include "pbo.h"
-#include "state.h"
-#include "teximage.h"
-#include "texstate.h"
-#include "main/dispatch.h"
-
-
-#if FEATURE_colortable
-
-
-/**
- * Given an internalFormat token passed to glColorTable,
- * return the corresponding base format.
- * Return -1 if invalid token.
- */
-static GLint
-base_colortab_format( GLenum format )
-{
-   switch (format) {
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-         return GL_ALPHA;
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-         return GL_LUMINANCE;
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-         return GL_LUMINANCE_ALPHA;
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-         return GL_INTENSITY;
-      case GL_RGB:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-         return GL_RGB;
-      case GL_RGBA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-         return GL_RGBA;
-      default:
-         return -1;  /* error */
-   }
-}
-
-
-
-/**
- * Examine table's format and set the component sizes accordingly.
- */
-static void
-set_component_sizes( struct gl_color_table *table )
-{
-   /* assuming the ubyte table */
-   const GLubyte sz = 8;
-
-   switch (table->_BaseFormat) {
-      case GL_ALPHA:
-         table->RedSize = 0;
-         table->GreenSize = 0;
-         table->BlueSize = 0;
-         table->AlphaSize = sz;
-         table->IntensitySize = 0;
-         table->LuminanceSize = 0;
-         break;
-      case GL_LUMINANCE:
-         table->RedSize = 0;
-         table->GreenSize = 0;
-         table->BlueSize = 0;
-         table->AlphaSize = 0;
-         table->IntensitySize = 0;
-         table->LuminanceSize = sz;
-         break;
-      case GL_LUMINANCE_ALPHA:
-         table->RedSize = 0;
-         table->GreenSize = 0;
-         table->BlueSize = 0;
-         table->AlphaSize = sz;
-         table->IntensitySize = 0;
-         table->LuminanceSize = sz;
-         break;
-      case GL_INTENSITY:
-         table->RedSize = 0;
-         table->GreenSize = 0;
-         table->BlueSize = 0;
-         table->AlphaSize = 0;
-         table->IntensitySize = sz;
-         table->LuminanceSize = 0;
-         break;
-      case GL_RGB:
-         table->RedSize = sz;
-         table->GreenSize = sz;
-         table->BlueSize = sz;
-         table->AlphaSize = 0;
-         table->IntensitySize = 0;
-         table->LuminanceSize = 0;
-         break;
-      case GL_RGBA:
-         table->RedSize = sz;
-         table->GreenSize = sz;
-         table->BlueSize = sz;
-         table->AlphaSize = sz;
-         table->IntensitySize = 0;
-         table->LuminanceSize = 0;
-         break;
-      default:
-         _mesa_problem(NULL, "unexpected format in set_component_sizes");
-   }
-}
-
-
-
-/**
- * Update/replace all or part of a color table.  Helper function
- * used by _mesa_ColorTable() and _mesa_ColorSubTable().
- * The table->Table buffer should already be allocated.
- * \param start first entry to update
- * \param count number of entries to update
- * \param format format of user-provided table data
- * \param type datatype of user-provided table data
- * \param data user-provided table data
- * \param [rgba]Scale - RGBA scale factors
- * \param [rgba]Bias - RGBA bias factors
- */
-static void
-store_colortable_entries(struct gl_context *ctx, struct gl_color_table *table,
-			 GLsizei start, GLsizei count,
-			 GLenum format, GLenum type, const GLvoid *data,
-			 GLfloat rScale, GLfloat rBias,
-			 GLfloat gScale, GLfloat gBias,
-			 GLfloat bScale, GLfloat bBias,
-			 GLfloat aScale, GLfloat aBias)
-{
-   data = _mesa_map_validate_pbo_source(ctx, 
-                                        1, &ctx->Unpack, count, 1, 1,
-                                        format, type, data,
-                                        "glColor[Sub]Table");
-   if (!data)
-      return;
-
-   {
-      /* convert user-provided data to GLfloat values */
-      GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
-      GLfloat *tableF;
-      GLint i;
-
-      _mesa_unpack_color_span_float(ctx,
-                                    count,         /* number of pixels */
-                                    table->_BaseFormat, /* dest format */
-                                    tempTab,       /* dest address */
-                                    format, type,  /* src format/type */
-                                    data,          /* src data */
-                                    &ctx->Unpack,
-                                    IMAGE_CLAMP_BIT); /* transfer ops */
-
-      /* the destination */
-      tableF = table->TableF;
-
-      /* Apply scale & bias & clamp now */
-      switch (table->_BaseFormat) {
-         case GL_INTENSITY:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
-            }
-            break;
-         case GL_LUMINANCE:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
-            }
-            break;
-         case GL_ALPHA:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);
-            }
-            break;
-         case GL_LUMINANCE_ALPHA:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);
-               tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);
-            }
-            break;
-         case GL_RGB:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);
-               tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);
-               tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);
-            }
-            break;
-         case GL_RGBA:
-            for (i = 0; i < count; i++) {
-               GLuint j = start + i;
-               tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);
-               tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);
-               tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);
-               tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);
-            }
-            break;
-         default:
-            _mesa_problem(ctx, "Bad format in store_colortable_entries");
-            return;
-         }
-   }
-
-   /* update the ubyte table */
-   {
-      const GLint comps = _mesa_components_in_format(table->_BaseFormat);
-      const GLfloat *tableF = table->TableF + start * comps;
-      GLubyte *tableUB = table->TableUB + start * comps;
-      GLint i;
-      for (i = 0; i < count * comps; i++) {
-         CLAMPED_FLOAT_TO_UBYTE(tableUB[i], tableF[i]);
-      }
-   }
-
-   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
-}
-
-
-
-void GLAPIENTRY
-_mesa_ColorTable( GLenum target, GLenum internalFormat,
-                  GLsizei width, GLenum format, GLenum type,
-                  const GLvoid *data )
-{
-   static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };
-   static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_texture_object *texObj = NULL;
-   struct gl_color_table *table = NULL;
-   GLboolean proxy = GL_FALSE;
-   GLint baseFormat;
-   const GLfloat *scale = one, *bias = zero;
-   GLint comps;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
-
-   switch (target) {
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         table = &ctx->Texture.Palette;
-         break;
-      default:
-         /* try texture targets */
-         {
-            struct gl_texture_object *texobj
-               = _mesa_select_tex_object(ctx, texUnit, target);
-            if (texobj) {
-               table = &texobj->Palette;
-               proxy = _mesa_is_proxy_texture(target);
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
-               return;
-            }
-         }
-   }
-
-   assert(table);
-
-   if (!_mesa_is_legal_format_and_type(ctx, format, type) ||
-       format == GL_INTENSITY) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)");
-      return;
-   }
-
-   baseFormat = base_colortab_format(internalFormat);
-   if (baseFormat < 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || (width != 0 && !_mesa_is_pow_two(width))) {
-      /* error */
-      if (proxy) {
-         table->Size = 0;
-         table->InternalFormat = (GLenum) 0;
-         table->_BaseFormat = (GLenum) 0;
-      }
-      else {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glColorTable(width=%d)", width);
-      }
-      return;
-   }
-
-   if (width > (GLsizei) ctx->Const.MaxColorTableSize) {
-      if (proxy) {
-         table->Size = 0;
-         table->InternalFormat = (GLenum) 0;
-         table->_BaseFormat = (GLenum) 0;
-      }
-      else {
-         _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
-      }
-      return;
-   }
-
-   table->Size = width;
-   table->InternalFormat = internalFormat;
-   table->_BaseFormat = (GLenum) baseFormat;
-
-   comps = _mesa_components_in_format(table->_BaseFormat);
-   assert(comps > 0);  /* error should have been caught sooner */
-
-   if (!proxy) {
-      _mesa_free_colortable_data(table);
-
-      if (width > 0) {
-         table->TableF = (GLfloat *) malloc(comps * width * sizeof(GLfloat));
-         table->TableUB = (GLubyte *) malloc(comps * width * sizeof(GLubyte));
-
-	 if (!table->TableF || !table->TableUB) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
-	    return;
-	 }
-
-	 store_colortable_entries(ctx, table,
-				  0, width,  /* start, count */
-				  format, type, data,
-				  scale[0], bias[0],
-				  scale[1], bias[1],
-				  scale[2], bias[2],
-				  scale[3], bias[3]);
-      }
-   } /* proxy */
-
-   /* do this after the table's Type and Format are set */
-   set_component_sizes(table);
-
-   if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
-      /* texture object palette, texObj==NULL means the shared palette */
-      if (ctx->Driver.UpdateTexturePalette) {
-         (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
-      }
-   }
-
-   ctx->NewState |= _NEW_PIXEL;
-}
-
-
-
-void GLAPIENTRY
-_mesa_ColorSubTable( GLenum target, GLsizei start,
-                     GLsizei count, GLenum format, GLenum type,
-                     const GLvoid *data )
-{
-   static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };
-   static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_texture_object *texObj = NULL;
-   struct gl_color_table *table = NULL;
-   const GLfloat *scale = one, *bias = zero;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   switch (target) {
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         table = &ctx->Texture.Palette;
-         break;
-      default:
-         /* try texture targets */
-         texObj = _mesa_select_tex_object(ctx, texUnit, target);
-         if (texObj && !_mesa_is_proxy_texture(target)) {
-            table = &texObj->Palette;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
-            return;
-         }
-   }
-
-   assert(table);
-
-   if (!_mesa_is_legal_format_and_type(ctx, format, type) ||
-       format == GL_INTENSITY) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)");
-      return;
-   }
-
-   if (count < 1) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
-      return;
-   }
-
-   /* error should have been caught sooner */
-   assert(_mesa_components_in_format(table->_BaseFormat) > 0);
-
-   if (start + count > (GLint) table->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
-      return;
-   }
-
-   if (!table->TableF || !table->TableUB) {
-      /* a GL_OUT_OF_MEMORY error would have been recorded previously */
-      return;
-   }
-
-   store_colortable_entries(ctx, table, start, count,
-			    format, type, data,
-                            scale[0], bias[0],
-                            scale[1], bias[1],
-                            scale[2], bias[2],
-                            scale[3], bias[3]);
-
-   if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
-      /* per-texture object palette */
-      if (ctx->Driver.UpdateTexturePalette) {
-         (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
-      }
-   }
-
-   ctx->NewState |= _NEW_PIXEL;
-}
-
-
-
-static void GLAPIENTRY
-_mesa_CopyColorTable(GLenum target, GLenum internalformat,
-                     GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      return;      /* no readbuffer - OK */
-   }
-
-   ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width );
-}
-
-
-
-static void GLAPIENTRY
-_mesa_CopyColorSubTable(GLenum target, GLsizei start,
-                        GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (!ctx->ReadBuffer->_ColorReadBuffer) {
-      return;      /* no readbuffer - OK */
-   }
-
-   ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width );
-}
-
-
-
-static void GLAPIENTRY
-_mesa_GetColorTable( GLenum target, GLenum format,
-                     GLenum type, GLvoid *data )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_color_table *table = NULL;
-   GLfloat rgba[MAX_COLOR_TABLE_SIZE][4];
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (ctx->NewState) {
-      _mesa_update_state(ctx);
-   }
-
-   switch (target) {
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         table = &ctx->Texture.Palette;
-         break;
-      default:
-         /* try texture targets */
-         {
-            struct gl_texture_object *texobj
-               = _mesa_select_tex_object(ctx, texUnit, target);
-            if (texobj && !_mesa_is_proxy_texture(target)) {
-               table = &texobj->Palette;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
-               return;
-            }
-         }
-   }
-
-   ASSERT(table);
-
-   if (table->Size <= 0) {
-      return;
-   }
-
-   switch (table->_BaseFormat) {
-   case GL_ALPHA:
-      {
-         GLuint i;
-         for (i = 0; i < table->Size; i++) {
-            rgba[i][RCOMP] = 0;
-            rgba[i][GCOMP] = 0;
-            rgba[i][BCOMP] = 0;
-            rgba[i][ACOMP] = table->TableF[i];
-         }
-      }
-      break;
-   case GL_LUMINANCE:
-      {
-         GLuint i;
-         for (i = 0; i < table->Size; i++) {
-            rgba[i][RCOMP] =
-            rgba[i][GCOMP] =
-            rgba[i][BCOMP] = table->TableF[i];
-            rgba[i][ACOMP] = 1.0F;
-         }
-      }
-      break;
-   case GL_LUMINANCE_ALPHA:
-      {
-         GLuint i;
-         for (i = 0; i < table->Size; i++) {
-            rgba[i][RCOMP] =
-            rgba[i][GCOMP] =
-            rgba[i][BCOMP] = table->TableF[i*2+0];
-            rgba[i][ACOMP] = table->TableF[i*2+1];
-         }
-      }
-      break;
-   case GL_INTENSITY:
-      {
-         GLuint i;
-         for (i = 0; i < table->Size; i++) {
-            rgba[i][RCOMP] =
-            rgba[i][GCOMP] =
-            rgba[i][BCOMP] =
-            rgba[i][ACOMP] = table->TableF[i];
-         }
-      }
-      break;
-   case GL_RGB:
-      {
-         GLuint i;
-         for (i = 0; i < table->Size; i++) {
-            rgba[i][RCOMP] = table->TableF[i*3+0];
-            rgba[i][GCOMP] = table->TableF[i*3+1];
-            rgba[i][BCOMP] = table->TableF[i*3+2];
-            rgba[i][ACOMP] = 1.0F;
-         }
-      }
-      break;
-   case GL_RGBA:
-      memcpy(rgba, table->TableF, 4 * table->Size * sizeof(GLfloat));
-      break;
-   default:
-      _mesa_problem(ctx, "bad table format in glGetColorTable");
-      return;
-   }
-
-   data = _mesa_map_validate_pbo_dest(ctx, 
-                                      1, &ctx->Pack, table->Size, 1, 1,
-                                      format, type, data,
-                                      "glGetColorTable");
-   if (!data)
-      return;
-
-   _mesa_pack_rgba_span_float(ctx, table->Size, rgba,
-                              format, type, data, &ctx->Pack, 0x0);
-
-   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
-}
-
-
-
-static void GLAPIENTRY
-_mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-   /* no extensions use this function */
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(target)");
-}
-
-
-
-static void GLAPIENTRY
-_mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-   /* no extensions use this function */
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameteriv(target)");
-}
-
-
-
-static void GLAPIENTRY
-_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_color_table *table = NULL;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   switch (target) {
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         table = &ctx->Texture.Palette;
-         break;
-      default:
-         /* try texture targets */
-         {
-            struct gl_texture_object *texobj
-               = _mesa_select_tex_object(ctx, texUnit, target);
-            if (texobj) {
-               table = &texobj->Palette;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM,
-                           "glGetColorTableParameterfv(target)");
-               return;
-            }
-         }
-   }
-
-   assert(table);
-
-   switch (pname) {
-      case GL_COLOR_TABLE_FORMAT:
-         *params = (GLfloat) table->InternalFormat;
-         break;
-      case GL_COLOR_TABLE_WIDTH:
-         *params = (GLfloat) table->Size;
-         break;
-      case GL_COLOR_TABLE_RED_SIZE:
-         *params = (GLfloat) table->RedSize;
-         break;
-      case GL_COLOR_TABLE_GREEN_SIZE:
-         *params = (GLfloat) table->GreenSize;
-         break;
-      case GL_COLOR_TABLE_BLUE_SIZE:
-         *params = (GLfloat) table->BlueSize;
-         break;
-      case GL_COLOR_TABLE_ALPHA_SIZE:
-         *params = (GLfloat) table->AlphaSize;
-         break;
-      case GL_COLOR_TABLE_LUMINANCE_SIZE:
-         *params = (GLfloat) table->LuminanceSize;
-         break;
-      case GL_COLOR_TABLE_INTENSITY_SIZE:
-         *params = (GLfloat) table->IntensitySize;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
-         return;
-   }
-}
-
-
-
-static void GLAPIENTRY
-_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_color_table *table = NULL;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   switch (target) {
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         table = &ctx->Texture.Palette;
-         break;
-      default:
-         /* Try texture targets */
-         {
-            struct gl_texture_object *texobj
-               = _mesa_select_tex_object(ctx, texUnit, target);
-            if (texobj) {
-               table = &texobj->Palette;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM,
-                           "glGetColorTableParameteriv(target)");
-               return;
-            }
-         }
-   }
-
-   assert(table);
-
-   switch (pname) {
-      case GL_COLOR_TABLE_FORMAT:
-         *params = table->InternalFormat;
-         break;
-      case GL_COLOR_TABLE_WIDTH:
-         *params = table->Size;
-         break;
-      case GL_COLOR_TABLE_RED_SIZE:
-         *params = table->RedSize;
-         break;
-      case GL_COLOR_TABLE_GREEN_SIZE:
-         *params = table->GreenSize;
-         break;
-      case GL_COLOR_TABLE_BLUE_SIZE:
-         *params = table->BlueSize;
-         break;
-      case GL_COLOR_TABLE_ALPHA_SIZE:
-         *params = table->AlphaSize;
-         break;
-      case GL_COLOR_TABLE_LUMINANCE_SIZE:
-         *params = table->LuminanceSize;
-         break;
-      case GL_COLOR_TABLE_INTENSITY_SIZE:
-         *params = table->IntensitySize;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
-         return;
-   }
-}
-
-
-void
-_mesa_init_colortable_dispatch(struct _glapi_table *disp)
-{
-   SET_ColorSubTable(disp, _mesa_ColorSubTable);
-   SET_ColorTable(disp, _mesa_ColorTable);
-   SET_ColorTableParameterfv(disp, _mesa_ColorTableParameterfv);
-   SET_ColorTableParameteriv(disp, _mesa_ColorTableParameteriv);
-   SET_CopyColorSubTable(disp, _mesa_CopyColorSubTable);
-   SET_CopyColorTable(disp, _mesa_CopyColorTable);
-   SET_GetColorTable(disp, _mesa_GetColorTable);
-   SET_GetColorTableParameterfv(disp, _mesa_GetColorTableParameterfv);
-   SET_GetColorTableParameteriv(disp, _mesa_GetColorTableParameteriv);
-}
-
-
-#endif /* FEATURE_colortable */
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-
-void
-_mesa_init_colortable( struct gl_color_table *p )
-{
-   p->TableF = NULL;
-   p->TableUB = NULL;
-   p->Size = 0;
-   p->InternalFormat = GL_RGBA;
-}
-
-
-
-void
-_mesa_free_colortable_data( struct gl_color_table *p )
-{
-   if (p->TableF) {
-      free(p->TableF);
-      p->TableF = NULL;
-   }
-   if (p->TableUB) {
-      free(p->TableUB);
-      p->TableUB = NULL;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "colortab.h"

+#include "context.h"

+#include "image.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "pack.h"

+#include "pbo.h"

+#include "state.h"

+#include "teximage.h"

+#include "texstate.h"

+#include "main/dispatch.h"

+

+

+#if FEATURE_colortable

+

+

+/**

+ * Given an internalFormat token passed to glColorTable,

+ * return the corresponding base format.

+ * Return -1 if invalid token.

+ */

+static GLint

+base_colortab_format( GLenum format )

+{

+   switch (format) {

+      case GL_ALPHA:

+      case GL_ALPHA4:

+      case GL_ALPHA8:

+      case GL_ALPHA12:

+      case GL_ALPHA16:

+         return GL_ALPHA;

+      case GL_LUMINANCE:

+      case GL_LUMINANCE4:

+      case GL_LUMINANCE8:

+      case GL_LUMINANCE12:

+      case GL_LUMINANCE16:

+         return GL_LUMINANCE;

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE4_ALPHA4:

+      case GL_LUMINANCE6_ALPHA2:

+      case GL_LUMINANCE8_ALPHA8:

+      case GL_LUMINANCE12_ALPHA4:

+      case GL_LUMINANCE12_ALPHA12:

+      case GL_LUMINANCE16_ALPHA16:

+         return GL_LUMINANCE_ALPHA;

+      case GL_INTENSITY:

+      case GL_INTENSITY4:

+      case GL_INTENSITY8:

+      case GL_INTENSITY12:

+      case GL_INTENSITY16:

+         return GL_INTENSITY;

+      case GL_RGB:

+      case GL_R3_G3_B2:

+      case GL_RGB4:

+      case GL_RGB5:

+      case GL_RGB8:

+      case GL_RGB10:

+      case GL_RGB12:

+      case GL_RGB16:

+         return GL_RGB;

+      case GL_RGBA:

+      case GL_RGBA2:

+      case GL_RGBA4:

+      case GL_RGB5_A1:

+      case GL_RGBA8:

+      case GL_RGB10_A2:

+      case GL_RGBA12:

+      case GL_RGBA16:

+         return GL_RGBA;

+      default:

+         return -1;  /* error */

+   }

+}

+

+

+

+/**

+ * Examine table's format and set the component sizes accordingly.

+ */

+static void

+set_component_sizes( struct gl_color_table *table )

+{

+   /* assuming the ubyte table */

+   const GLubyte sz = 8;

+

+   switch (table->_BaseFormat) {

+      case GL_ALPHA:

+         table->RedSize = 0;

+         table->GreenSize = 0;

+         table->BlueSize = 0;

+         table->AlphaSize = sz;

+         table->IntensitySize = 0;

+         table->LuminanceSize = 0;

+         break;

+      case GL_LUMINANCE:

+         table->RedSize = 0;

+         table->GreenSize = 0;

+         table->BlueSize = 0;

+         table->AlphaSize = 0;

+         table->IntensitySize = 0;

+         table->LuminanceSize = sz;

+         break;

+      case GL_LUMINANCE_ALPHA:

+         table->RedSize = 0;

+         table->GreenSize = 0;

+         table->BlueSize = 0;

+         table->AlphaSize = sz;

+         table->IntensitySize = 0;

+         table->LuminanceSize = sz;

+         break;

+      case GL_INTENSITY:

+         table->RedSize = 0;

+         table->GreenSize = 0;

+         table->BlueSize = 0;

+         table->AlphaSize = 0;

+         table->IntensitySize = sz;

+         table->LuminanceSize = 0;

+         break;

+      case GL_RGB:

+         table->RedSize = sz;

+         table->GreenSize = sz;

+         table->BlueSize = sz;

+         table->AlphaSize = 0;

+         table->IntensitySize = 0;

+         table->LuminanceSize = 0;

+         break;

+      case GL_RGBA:

+         table->RedSize = sz;

+         table->GreenSize = sz;

+         table->BlueSize = sz;

+         table->AlphaSize = sz;

+         table->IntensitySize = 0;

+         table->LuminanceSize = 0;

+         break;

+      default:

+         _mesa_problem(NULL, "unexpected format in set_component_sizes");

+   }

+}

+

+

+

+/**

+ * Update/replace all or part of a color table.  Helper function

+ * used by _mesa_ColorTable() and _mesa_ColorSubTable().

+ * The table->Table buffer should already be allocated.

+ * \param start first entry to update

+ * \param count number of entries to update

+ * \param format format of user-provided table data

+ * \param type datatype of user-provided table data

+ * \param data user-provided table data

+ * \param [rgba]Scale - RGBA scale factors

+ * \param [rgba]Bias - RGBA bias factors

+ */

+static void

+store_colortable_entries(struct gl_context *ctx, struct gl_color_table *table,

+			 GLsizei start, GLsizei count,

+			 GLenum format, GLenum type, const GLvoid *data,

+			 GLfloat rScale, GLfloat rBias,

+			 GLfloat gScale, GLfloat gBias,

+			 GLfloat bScale, GLfloat bBias,

+			 GLfloat aScale, GLfloat aBias)

+{

+   data = _mesa_map_validate_pbo_source(ctx, 

+                                        1, &ctx->Unpack, count, 1, 1,

+                                        format, type, data,

+                                        "glColor[Sub]Table");

+   if (!data)

+      return;

+

+   {

+      /* convert user-provided data to GLfloat values */

+      GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];

+      GLfloat *tableF;

+      GLint i;

+

+      _mesa_unpack_color_span_float(ctx,

+                                    count,         /* number of pixels */

+                                    table->_BaseFormat, /* dest format */

+                                    tempTab,       /* dest address */

+                                    format, type,  /* src format/type */

+                                    data,          /* src data */

+                                    &ctx->Unpack,

+                                    IMAGE_CLAMP_BIT); /* transfer ops */

+

+      /* the destination */

+      tableF = table->TableF;

+

+      /* Apply scale & bias & clamp now */

+      switch (table->_BaseFormat) {

+         case GL_INTENSITY:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);

+            }

+            break;

+         case GL_LUMINANCE:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);

+            }

+            break;

+         case GL_ALPHA:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);

+            }

+            break;

+         case GL_LUMINANCE_ALPHA:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);

+               tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);

+            }

+            break;

+         case GL_RGB:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);

+               tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);

+               tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);

+            }

+            break;

+         case GL_RGBA:

+            for (i = 0; i < count; i++) {

+               GLuint j = start + i;

+               tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);

+               tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);

+               tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);

+               tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);

+            }

+            break;

+         default:

+            _mesa_problem(ctx, "Bad format in store_colortable_entries");

+            return;

+         }

+   }

+

+   /* update the ubyte table */

+   {

+      const GLint comps = _mesa_components_in_format(table->_BaseFormat);

+      const GLfloat *tableF = table->TableF + start * comps;

+      GLubyte *tableUB = table->TableUB + start * comps;

+      GLint i;

+      for (i = 0; i < count * comps; i++) {

+         CLAMPED_FLOAT_TO_UBYTE(tableUB[i], tableF[i]);

+      }

+   }

+

+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);

+}

+

+

+

+void GLAPIENTRY

+_mesa_ColorTable( GLenum target, GLenum internalFormat,

+                  GLsizei width, GLenum format, GLenum type,

+                  const GLvoid *data )

+{

+   static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };

+   static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_texture_object *texObj = NULL;

+   struct gl_color_table *table = NULL;

+   GLboolean proxy = GL_FALSE;

+   GLint baseFormat;

+   const GLfloat *scale = one, *bias = zero;

+   GLint comps;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */

+

+   switch (target) {

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         table = &ctx->Texture.Palette;

+         break;

+      default:

+         /* try texture targets */

+         {

+            struct gl_texture_object *texobj

+               = _mesa_select_tex_object(ctx, texUnit, target);

+            if (texobj) {

+               table = &texobj->Palette;

+               proxy = _mesa_is_proxy_texture(target);

+            }

+            else {

+               _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");

+               return;

+            }

+         }

+   }

+

+   assert(table);

+

+   if (!_mesa_is_legal_format_and_type(ctx, format, type) ||

+       format == GL_INTENSITY) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)");

+      return;

+   }

+

+   baseFormat = base_colortab_format(internalFormat);

+   if (baseFormat < 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");

+      return;

+   }

+

+   if (width < 0 || (width != 0 && !_mesa_is_pow_two(width))) {

+      /* error */

+      if (proxy) {

+         table->Size = 0;

+         table->InternalFormat = (GLenum) 0;

+         table->_BaseFormat = (GLenum) 0;

+      }

+      else {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glColorTable(width=%d)", width);

+      }

+      return;

+   }

+

+   if (width > (GLsizei) ctx->Const.MaxColorTableSize) {

+      if (proxy) {

+         table->Size = 0;

+         table->InternalFormat = (GLenum) 0;

+         table->_BaseFormat = (GLenum) 0;

+      }

+      else {

+         _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");

+      }

+      return;

+   }

+

+   table->Size = width;

+   table->InternalFormat = internalFormat;

+   table->_BaseFormat = (GLenum) baseFormat;

+

+   comps = _mesa_components_in_format(table->_BaseFormat);

+   assert(comps > 0);  /* error should have been caught sooner */

+

+   if (!proxy) {

+      _mesa_free_colortable_data(table);

+

+      if (width > 0) {

+         table->TableF = (GLfloat *) malloc(comps * width * sizeof(GLfloat));

+         table->TableUB = (GLubyte *) malloc(comps * width * sizeof(GLubyte));

+

+	 if (!table->TableF || !table->TableUB) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");

+	    return;

+	 }

+

+	 store_colortable_entries(ctx, table,

+				  0, width,  /* start, count */

+				  format, type, data,

+				  scale[0], bias[0],

+				  scale[1], bias[1],

+				  scale[2], bias[2],

+				  scale[3], bias[3]);

+      }

+   } /* proxy */

+

+   /* do this after the table's Type and Format are set */

+   set_component_sizes(table);

+

+   if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {

+      /* texture object palette, texObj==NULL means the shared palette */

+      if (ctx->Driver.UpdateTexturePalette) {

+         (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );

+      }

+   }

+

+   ctx->NewState |= _NEW_PIXEL;

+}

+

+

+

+void GLAPIENTRY

+_mesa_ColorSubTable( GLenum target, GLsizei start,

+                     GLsizei count, GLenum format, GLenum type,

+                     const GLvoid *data )

+{

+   static const GLfloat one[4] = { 1.0, 1.0, 1.0, 1.0 };

+   static const GLfloat zero[4] = { 0.0, 0.0, 0.0, 0.0 };

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_texture_object *texObj = NULL;

+   struct gl_color_table *table = NULL;

+   const GLfloat *scale = one, *bias = zero;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   switch (target) {

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         table = &ctx->Texture.Palette;

+         break;

+      default:

+         /* try texture targets */

+         texObj = _mesa_select_tex_object(ctx, texUnit, target);

+         if (texObj && !_mesa_is_proxy_texture(target)) {

+            table = &texObj->Palette;

+         }

+         else {

+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");

+            return;

+         }

+   }

+

+   assert(table);

+

+   if (!_mesa_is_legal_format_and_type(ctx, format, type) ||

+       format == GL_INTENSITY) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)");

+      return;

+   }

+

+   if (count < 1) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");

+      return;

+   }

+

+   /* error should have been caught sooner */

+   assert(_mesa_components_in_format(table->_BaseFormat) > 0);

+

+   if (start + count > (GLint) table->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");

+      return;

+   }

+

+   if (!table->TableF || !table->TableUB) {

+      /* a GL_OUT_OF_MEMORY error would have been recorded previously */

+      return;

+   }

+

+   store_colortable_entries(ctx, table, start, count,

+			    format, type, data,

+                            scale[0], bias[0],

+                            scale[1], bias[1],

+                            scale[2], bias[2],

+                            scale[3], bias[3]);

+

+   if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {

+      /* per-texture object palette */

+      if (ctx->Driver.UpdateTexturePalette) {

+         (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );

+      }

+   }

+

+   ctx->NewState |= _NEW_PIXEL;

+}

+

+

+

+static void GLAPIENTRY

+_mesa_CopyColorTable(GLenum target, GLenum internalformat,

+                     GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      return;      /* no readbuffer - OK */

+   }

+

+   ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width );

+}

+

+

+

+static void GLAPIENTRY

+_mesa_CopyColorSubTable(GLenum target, GLsizei start,

+                        GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (!ctx->ReadBuffer->_ColorReadBuffer) {

+      return;      /* no readbuffer - OK */

+   }

+

+   ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width );

+}

+

+

+

+static void GLAPIENTRY

+_mesa_GetColorTable( GLenum target, GLenum format,

+                     GLenum type, GLvoid *data )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_color_table *table = NULL;

+   GLfloat rgba[MAX_COLOR_TABLE_SIZE][4];

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (ctx->NewState) {

+      _mesa_update_state(ctx);

+   }

+

+   switch (target) {

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         table = &ctx->Texture.Palette;

+         break;

+      default:

+         /* try texture targets */

+         {

+            struct gl_texture_object *texobj

+               = _mesa_select_tex_object(ctx, texUnit, target);

+            if (texobj && !_mesa_is_proxy_texture(target)) {

+               table = &texobj->Palette;

+            }

+            else {

+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");

+               return;

+            }

+         }

+   }

+

+   ASSERT(table);

+

+   if (table->Size <= 0) {

+      return;

+   }

+

+   switch (table->_BaseFormat) {

+   case GL_ALPHA:

+      {

+         GLuint i;

+         for (i = 0; i < table->Size; i++) {

+            rgba[i][RCOMP] = 0;

+            rgba[i][GCOMP] = 0;

+            rgba[i][BCOMP] = 0;

+            rgba[i][ACOMP] = table->TableF[i];

+         }

+      }

+      break;

+   case GL_LUMINANCE:

+      {

+         GLuint i;

+         for (i = 0; i < table->Size; i++) {

+            rgba[i][RCOMP] =

+            rgba[i][GCOMP] =

+            rgba[i][BCOMP] = table->TableF[i];

+            rgba[i][ACOMP] = 1.0F;

+         }

+      }

+      break;

+   case GL_LUMINANCE_ALPHA:

+      {

+         GLuint i;

+         for (i = 0; i < table->Size; i++) {

+            rgba[i][RCOMP] =

+            rgba[i][GCOMP] =

+            rgba[i][BCOMP] = table->TableF[i*2+0];

+            rgba[i][ACOMP] = table->TableF[i*2+1];

+         }

+      }

+      break;

+   case GL_INTENSITY:

+      {

+         GLuint i;

+         for (i = 0; i < table->Size; i++) {

+            rgba[i][RCOMP] =

+            rgba[i][GCOMP] =

+            rgba[i][BCOMP] =

+            rgba[i][ACOMP] = table->TableF[i];

+         }

+      }

+      break;

+   case GL_RGB:

+      {

+         GLuint i;

+         for (i = 0; i < table->Size; i++) {

+            rgba[i][RCOMP] = table->TableF[i*3+0];

+            rgba[i][GCOMP] = table->TableF[i*3+1];

+            rgba[i][BCOMP] = table->TableF[i*3+2];

+            rgba[i][ACOMP] = 1.0F;

+         }

+      }

+      break;

+   case GL_RGBA:

+      memcpy(rgba, table->TableF, 4 * table->Size * sizeof(GLfloat));

+      break;

+   default:

+      _mesa_problem(ctx, "bad table format in glGetColorTable");

+      return;

+   }

+

+   data = _mesa_map_validate_pbo_dest(ctx, 

+                                      1, &ctx->Pack, table->Size, 1, 1,

+                                      format, type, data,

+                                      "glGetColorTable");

+   if (!data)

+      return;

+

+   _mesa_pack_rgba_span_float(ctx, table->Size, rgba,

+                              format, type, data, &ctx->Pack, 0x0);

+

+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);

+}

+

+

+

+static void GLAPIENTRY

+_mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)

+{

+   /* no extensions use this function */

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(target)");

+}

+

+

+

+static void GLAPIENTRY

+_mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)

+{

+   /* no extensions use this function */

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameteriv(target)");

+}

+

+

+

+static void GLAPIENTRY

+_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_color_table *table = NULL;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   switch (target) {

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         table = &ctx->Texture.Palette;

+         break;

+      default:

+         /* try texture targets */

+         {

+            struct gl_texture_object *texobj

+               = _mesa_select_tex_object(ctx, texUnit, target);

+            if (texobj) {

+               table = &texobj->Palette;

+            }

+            else {

+               _mesa_error(ctx, GL_INVALID_ENUM,

+                           "glGetColorTableParameterfv(target)");

+               return;

+            }

+         }

+   }

+

+   assert(table);

+

+   switch (pname) {

+      case GL_COLOR_TABLE_FORMAT:

+         *params = (GLfloat) table->InternalFormat;

+         break;

+      case GL_COLOR_TABLE_WIDTH:

+         *params = (GLfloat) table->Size;

+         break;

+      case GL_COLOR_TABLE_RED_SIZE:

+         *params = (GLfloat) table->RedSize;

+         break;

+      case GL_COLOR_TABLE_GREEN_SIZE:

+         *params = (GLfloat) table->GreenSize;

+         break;

+      case GL_COLOR_TABLE_BLUE_SIZE:

+         *params = (GLfloat) table->BlueSize;

+         break;

+      case GL_COLOR_TABLE_ALPHA_SIZE:

+         *params = (GLfloat) table->AlphaSize;

+         break;

+      case GL_COLOR_TABLE_LUMINANCE_SIZE:

+         *params = (GLfloat) table->LuminanceSize;

+         break;

+      case GL_COLOR_TABLE_INTENSITY_SIZE:

+         *params = (GLfloat) table->IntensitySize;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );

+         return;

+   }

+}

+

+

+

+static void GLAPIENTRY

+_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_color_table *table = NULL;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   switch (target) {

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         table = &ctx->Texture.Palette;

+         break;

+      default:

+         /* Try texture targets */

+         {

+            struct gl_texture_object *texobj

+               = _mesa_select_tex_object(ctx, texUnit, target);

+            if (texobj) {

+               table = &texobj->Palette;

+            }

+            else {

+               _mesa_error(ctx, GL_INVALID_ENUM,

+                           "glGetColorTableParameteriv(target)");

+               return;

+            }

+         }

+   }

+

+   assert(table);

+

+   switch (pname) {

+      case GL_COLOR_TABLE_FORMAT:

+         *params = table->InternalFormat;

+         break;

+      case GL_COLOR_TABLE_WIDTH:

+         *params = table->Size;

+         break;

+      case GL_COLOR_TABLE_RED_SIZE:

+         *params = table->RedSize;

+         break;

+      case GL_COLOR_TABLE_GREEN_SIZE:

+         *params = table->GreenSize;

+         break;

+      case GL_COLOR_TABLE_BLUE_SIZE:

+         *params = table->BlueSize;

+         break;

+      case GL_COLOR_TABLE_ALPHA_SIZE:

+         *params = table->AlphaSize;

+         break;

+      case GL_COLOR_TABLE_LUMINANCE_SIZE:

+         *params = table->LuminanceSize;

+         break;

+      case GL_COLOR_TABLE_INTENSITY_SIZE:

+         *params = table->IntensitySize;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );

+         return;

+   }

+}

+

+

+void

+_mesa_init_colortable_dispatch(struct _glapi_table *disp)

+{

+   SET_ColorSubTable(disp, _mesa_ColorSubTable);

+   SET_ColorTable(disp, _mesa_ColorTable);

+   SET_ColorTableParameterfv(disp, _mesa_ColorTableParameterfv);

+   SET_ColorTableParameteriv(disp, _mesa_ColorTableParameteriv);

+   SET_CopyColorSubTable(disp, _mesa_CopyColorSubTable);

+   SET_CopyColorTable(disp, _mesa_CopyColorTable);

+   SET_GetColorTable(disp, _mesa_GetColorTable);

+   SET_GetColorTableParameterfv(disp, _mesa_GetColorTableParameterfv);

+   SET_GetColorTableParameteriv(disp, _mesa_GetColorTableParameteriv);

+}

+

+

+#endif /* FEATURE_colortable */

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+

+void

+_mesa_init_colortable( struct gl_color_table *p )

+{

+   p->TableF = NULL;

+   p->TableUB = NULL;

+   p->Size = 0;

+   p->InternalFormat = GL_RGBA;

+}

+

+

+

+void

+_mesa_free_colortable_data( struct gl_color_table *p )

+{

+   if (p->TableF) {

+      free(p->TableF);

+      p->TableF = NULL;

+   }

+   if (p->TableUB) {

+      free(p->TableUB);

+      p->TableUB = NULL;

+   }

+}

diff --git a/mesalib/src/mesa/main/compiler.h b/mesalib/src/mesa/main/compiler.h
index 41cd48bc6..c1d773b18 100644
--- a/mesalib/src/mesa/main/compiler.h
+++ b/mesalib/src/mesa/main/compiler.h
@@ -60,29 +60,7 @@ extern "C" {
 /**

  * Get standard integer types

  */

-#if defined(_MSC_VER)

-   typedef __int8             int8_t;

-   typedef unsigned __int8    uint8_t;

-   typedef __int16            int16_t;

-   typedef unsigned __int16   uint16_t;

-   typedef __int32            int32_t;

-   typedef unsigned __int32   uint32_t;

-   typedef __int64            int64_t;

-   typedef unsigned __int64   uint64_t;

-

-#  if defined(_WIN64)

-     typedef __int64            intptr_t;

-     typedef unsigned __int64   uintptr_t;

-#  else

-     typedef __int32            intptr_t;

-     typedef unsigned __int32   uintptr_t;

-#  endif

-

-#  define INT64_C(__val) __val##i64

-#  define UINT64_C(__val) __val##ui64

-#else

-#  include <stdint.h>

-#endif

+#include <stdint.h>

 

 

 /**

diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index 5d581c840..8db8ed865 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -1,1883 +1,1883 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- * Copyright (C) 2008  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file context.c
- * Mesa context/visual/framebuffer management functions.
- * \author Brian Paul
- */
-
-/**
- * \mainpage Mesa Main Module
- *
- * \section MainIntroduction Introduction
- *
- * The Mesa Main module consists of all the files in the main/ directory.
- * Among the features of this module are:
- * <UL>
- * <LI> Structures to represent most GL state </LI>
- * <LI> State set/get functions </LI>
- * <LI> Display lists </LI>
- * <LI> Texture unit, object and image handling </LI>
- * <LI> Matrix and attribute stacks </LI>
- * </UL>
- *
- * Other modules are responsible for API dispatch, vertex transformation,
- * point/line/triangle setup, rasterization, vertex array caching,
- * vertex/fragment programs/shaders, etc.
- *
- *
- * \section AboutDoxygen About Doxygen
- *
- * If you're viewing this information as Doxygen-generated HTML you'll
- * see the documentation index at the top of this page.
- *
- * The first line lists the Mesa source code modules.
- * The second line lists the indexes available for viewing the documentation
- * for each module.
- *
- * Selecting the <b>Main page</b> link will display a summary of the module
- * (this page).
- *
- * Selecting <b>Data Structures</b> will list all C structures.
- *
- * Selecting the <b>File List</b> link will list all the source files in
- * the module.
- * Selecting a filename will show a list of all functions defined in that file.
- *
- * Selecting the <b>Data Fields</b> link will display a list of all
- * documented structure members.
- *
- * Selecting the <b>Globals</b> link will display a list
- * of all functions, structures, global variables and macros in the module.
- *
- */
-
-
-#include "glheader.h"
-#include "mfeatures.h"
-#include "imports.h"
-#include "accum.h"
-#include "api_exec.h"
-#include "arrayobj.h"
-#include "attrib.h"
-#include "blend.h"
-#include "buffers.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "cpuinfo.h"
-#include "debug.h"
-#include "depth.h"
-#include "dlist.h"
-#include "eval.h"
-#include "extensions.h"
-#include "fbobject.h"
-#include "feedback.h"
-#include "fog.h"
-#include "formats.h"
-#include "framebuffer.h"
-#include "hint.h"
-#include "hash.h"
-#include "light.h"
-#include "lines.h"
-#include "macros.h"
-#include "matrix.h"
-#include "multisample.h"
-#include "pixel.h"
-#include "pixelstore.h"
-#include "points.h"
-#include "polygon.h"
-#include "queryobj.h"
-#include "syncobj.h"
-#include "rastpos.h"
-#include "remap.h"
-#include "scissor.h"
-#include "shared.h"
-#include "shaderobj.h"
-#include "simple_list.h"
-#include "state.h"
-#include "stencil.h"
-#include "texcompress_s3tc.h"
-#include "texstate.h"
-#include "transformfeedback.h"
-#include "mtypes.h"
-#include "varray.h"
-#include "version.h"
-#include "viewport.h"
-#include "vtxfmt.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-#if _HAVE_FULL_GL
-#include "math/m_matrix.h"
-#endif
-#include "main/dispatch.h" /* for _gloffset_COUNT */
-
-#ifdef USE_SPARC_ASM
-#include "sparc/sparc.h"
-#endif
-
-#include "glsl_parser_extras.h"
-#include <stdbool.h>
-
-
-#ifndef MESA_VERBOSE
-int MESA_VERBOSE = 0;
-#endif
-
-#ifndef MESA_DEBUG_FLAGS
-int MESA_DEBUG_FLAGS = 0;
-#endif
-
-
-/* ubyte -> float conversion */
-GLfloat _mesa_ubyte_to_float_color_tab[256];
-
-
-
-/**
- * Swap buffers notification callback.
- * 
- * \param ctx GL context.
- *
- * Called by window system just before swapping buffers.
- * We have to finish any pending rendering.
- */
-void
-_mesa_notifySwapBuffers(struct gl_context *ctx)
-{
-   if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
-      _mesa_debug(ctx, "SwapBuffers\n");
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Flush) {
-      ctx->Driver.Flush(ctx);
-   }
-}
-
-
-/**********************************************************************/
-/** \name GL Visual allocation/destruction                            */
-/**********************************************************************/
-/*@{*/
-
-/**
- * Allocates a struct gl_config structure and initializes it via
- * _mesa_initialize_visual().
- * 
- * \param dbFlag double buffering
- * \param stereoFlag stereo buffer
- * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
- * is acceptable but the actual depth type will be GLushort or GLuint as
- * needed.
- * \param stencilBits requested minimum bits per stencil buffer value
- * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
- * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
- * \param redBits number of bits per color component in frame buffer for RGB(A)
- * mode.  We always use 8 in core Mesa though.
- * \param greenBits same as above.
- * \param blueBits same as above.
- * \param alphaBits same as above.
- * \param numSamples not really used.
- * 
- * \return pointer to new struct gl_config or NULL if requested parameters can't be
- * met.
- *
- * \note Need to add params for level and numAuxBuffers (at least)
- */
-struct gl_config *
-_mesa_create_visual( GLboolean dbFlag,
-                     GLboolean stereoFlag,
-                     GLint redBits,
-                     GLint greenBits,
-                     GLint blueBits,
-                     GLint alphaBits,
-                     GLint depthBits,
-                     GLint stencilBits,
-                     GLint accumRedBits,
-                     GLint accumGreenBits,
-                     GLint accumBlueBits,
-                     GLint accumAlphaBits,
-                     GLint numSamples )
-{
-   struct gl_config *vis = CALLOC_STRUCT(gl_config);
-   if (vis) {
-      if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
-                                   redBits, greenBits, blueBits, alphaBits,
-                                   depthBits, stencilBits,
-                                   accumRedBits, accumGreenBits,
-                                   accumBlueBits, accumAlphaBits,
-                                   numSamples)) {
-         free(vis);
-         return NULL;
-      }
-   }
-   return vis;
-}
-
-
-/**
- * Makes some sanity checks and fills in the fields of the struct
- * gl_config object with the given parameters.  If the caller needs to
- * set additional fields, he should just probably init the whole
- * gl_config object himself.
- *
- * \return GL_TRUE on success, or GL_FALSE on failure.
- *
- * \sa _mesa_create_visual() above for the parameter description.
- */
-GLboolean
-_mesa_initialize_visual( struct gl_config *vis,
-                         GLboolean dbFlag,
-                         GLboolean stereoFlag,
-                         GLint redBits,
-                         GLint greenBits,
-                         GLint blueBits,
-                         GLint alphaBits,
-                         GLint depthBits,
-                         GLint stencilBits,
-                         GLint accumRedBits,
-                         GLint accumGreenBits,
-                         GLint accumBlueBits,
-                         GLint accumAlphaBits,
-                         GLint numSamples )
-{
-   assert(vis);
-
-   if (depthBits < 0 || depthBits > 32) {
-      return GL_FALSE;
-   }
-   if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
-      return GL_FALSE;
-   }
-   assert(accumRedBits >= 0);
-   assert(accumGreenBits >= 0);
-   assert(accumBlueBits >= 0);
-   assert(accumAlphaBits >= 0);
-
-   vis->rgbMode          = GL_TRUE;
-   vis->doubleBufferMode = dbFlag;
-   vis->stereoMode       = stereoFlag;
-
-   vis->redBits          = redBits;
-   vis->greenBits        = greenBits;
-   vis->blueBits         = blueBits;
-   vis->alphaBits        = alphaBits;
-   vis->rgbBits          = redBits + greenBits + blueBits;
-
-   vis->indexBits      = 0;
-   vis->depthBits      = depthBits;
-   vis->stencilBits    = stencilBits;
-
-   vis->accumRedBits   = accumRedBits;
-   vis->accumGreenBits = accumGreenBits;
-   vis->accumBlueBits  = accumBlueBits;
-   vis->accumAlphaBits = accumAlphaBits;
-
-   vis->haveAccumBuffer   = accumRedBits > 0;
-   vis->haveDepthBuffer   = depthBits > 0;
-   vis->haveStencilBuffer = stencilBits > 0;
-
-   vis->numAuxBuffers = 0;
-   vis->level = 0;
-   vis->sampleBuffers = numSamples > 0 ? 1 : 0;
-   vis->samples = numSamples;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Destroy a visual and free its memory.
- *
- * \param vis visual.
- * 
- * Frees the visual structure.
- */
-void
-_mesa_destroy_visual( struct gl_config *vis )
-{
-   free(vis);
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Context allocation, initialization, destroying
- *
- * The purpose of the most initialization functions here is to provide the
- * default state values according to the OpenGL specification.
- */
-/**********************************************************************/
-/*@{*/
-
-
-/**
- * This is lame.  gdb only seems to recognize enum types that are
- * actually used somewhere.  We want to be able to print/use enum
- * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
- * the gl_texture_index type anywhere.  Thus, this lame function.
- */
-static void
-dummy_enum_func(void)
-{
-   gl_buffer_index bi = BUFFER_FRONT_LEFT;
-   gl_face_index fi = FACE_POS_X;
-   gl_frag_attrib fa = FRAG_ATTRIB_WPOS;
-   gl_frag_result fr = FRAG_RESULT_DEPTH;
-   gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
-   gl_vert_attrib va = VERT_ATTRIB_POS;
-   gl_vert_result vr = VERT_RESULT_HPOS;
-   gl_geom_attrib ga = GEOM_ATTRIB_POSITION;
-   gl_geom_result gr = GEOM_RESULT_POS;
-
-   (void) bi;
-   (void) fi;
-   (void) fa;
-   (void) fr;
-   (void) ti;
-   (void) va;
-   (void) vr;
-   (void) ga;
-   (void) gr;
-}
-
-
-/**
- * One-time initialization mutex lock.
- *
- * \sa Used by one_time_init().
- */
-_glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
-
-
-
-/**
- * Calls all the various one-time-init functions in Mesa.
- *
- * While holding a global mutex lock, calls several initialization functions,
- * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
- * defined.
- *
- * \sa _math_init().
- */
-static void
-one_time_init( struct gl_context *ctx )
-{
-   static GLbitfield api_init_mask = 0x0;
-
-   _glthread_LOCK_MUTEX(OneTimeLock);
-
-   /* truly one-time init */
-   if (!api_init_mask) {
-      GLuint i;
-
-      /* do some implementation tests */
-      assert( sizeof(GLbyte) == 1 );
-      assert( sizeof(GLubyte) == 1 );
-      assert( sizeof(GLshort) == 2 );
-      assert( sizeof(GLushort) == 2 );
-      assert( sizeof(GLint) == 4 );
-      assert( sizeof(GLuint) == 4 );
-
-      _mesa_get_cpu_features();
-
-      _mesa_init_sqrt_table();
-
-      /* context dependence is never a one-time thing... */
-      _mesa_init_get_hash(ctx);
-
-      for (i = 0; i < 256; i++) {
-         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
-      }
-
-#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
-      if (MESA_VERBOSE != 0) {
-	 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
-		     MESA_VERSION_STRING, __DATE__, __TIME__);
-      }
-#endif
-
-#ifdef DEBUG
-      _mesa_test_formats();
-#endif
-   }
-
-   /* per-API one-time init */
-   if (!(api_init_mask & (1 << ctx->API))) {
-      /*
-       * This is fine as ES does not use the remap table, but it may not be
-       * future-proof.  We cannot always initialize the remap table because
-       * when an app is linked to libGLES*, there are not enough dynamic
-       * entries.
-       */
-      if (ctx->API == API_OPENGL)
-         _mesa_init_remap_table();
-   }
-
-   api_init_mask |= 1 << ctx->API;
-
-   _glthread_UNLOCK_MUTEX(OneTimeLock);
-
-   /* Hopefully atexit() is widely available.  If not, we may need some
-    * #ifdef tests here.
-    */
-   atexit(_mesa_destroy_shader_compiler);
-
-   dummy_enum_func();
-}
-
-
-/**
- * Initialize fields of gl_current_attrib (aka ctx->Current.*)
- */
-static void
-_mesa_init_current(struct gl_context *ctx)
-{
-   GLuint i;
-
-   /* Init all to (0,0,0,1) */
-   for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
-      ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
-   }
-
-   /* redo special cases: */
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
-}
-
-
-/**
- * Init vertex/fragment/geometry program limits.
- * Important: drivers should override these with actual limits.
- */
-static void
-init_program_limits(GLenum type, struct gl_program_constants *prog)
-{
-   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTemps = MAX_PROGRAM_TEMPS;
-   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
-   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
-   prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
-   prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
-
-   switch (type) {
-   case GL_VERTEX_PROGRAM_ARB:
-      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
-      break;
-   case GL_FRAGMENT_PROGRAM_ARB:
-      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
-
-      prog->MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;
-      prog->MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;
-      prog->MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;
-      prog->MaxGeometryUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;
-      prog->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
-      prog->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
-      break;
-   default:
-      assert(0 && "Bad program type in init_program_limits()");
-   }
-
-   /* Set the native limits to zero.  This implies that there is no native
-    * support for shaders.  Let the drivers fill in the actual values.
-    */
-   prog->MaxNativeInstructions = 0;
-   prog->MaxNativeAluInstructions = 0;
-   prog->MaxNativeTexInstructions = 0;
-   prog->MaxNativeTexIndirections = 0;
-   prog->MaxNativeAttribs = 0;
-   prog->MaxNativeTemps = 0;
-   prog->MaxNativeAddressRegs = 0;
-   prog->MaxNativeParameters = 0;
-
-   /* Set GLSL datatype range/precision info assuming IEEE float values.
-    * Drivers should override these defaults as needed.
-    */
-   prog->MediumFloat.RangeMin = 127;
-   prog->MediumFloat.RangeMax = 127;
-   prog->MediumFloat.Precision = 23;
-   prog->LowFloat = prog->HighFloat = prog->MediumFloat;
-
-   /* Assume ints are stored as floats for now, since this is the least-common
-    * denominator.  The OpenGL ES spec implies (page 132) that the precision
-    * of integer types should be 0.  Practically speaking, IEEE
-    * single-precision floating point values can only store integers in the
-    * range [-0x01000000, 0x01000000] without loss of precision.
-    */
-   prog->MediumInt.RangeMin = 24;
-   prog->MediumInt.RangeMax = 24;
-   prog->MediumInt.Precision = 0;
-   prog->LowInt = prog->HighInt = prog->MediumInt;
-}
-
-
-/**
- * Initialize fields of gl_constants (aka ctx->Const.*).
- * Use defaults from config.h.  The device drivers will often override
- * some of these values (such as number of texture units).
- */
-static void 
-_mesa_init_constants(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   /* Constants, may be overriden (usually only reduced) by device drivers */
-   ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;
-   ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
-   ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
-   ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
-   ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
-   ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
-   ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
-   ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
-                                     ctx->Const.MaxTextureImageUnits);
-   ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
-   ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
-   ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
-   ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
-   ctx->Const.MinPointSize = MIN_POINT_SIZE;
-   ctx->Const.MaxPointSize = MAX_POINT_SIZE;
-   ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
-   ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
-   ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
-   ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
-   ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
-   ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
-   ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
-   ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
-   ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
-   ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
-   ctx->Const.MaxLights = MAX_LIGHTS;
-   ctx->Const.MaxShininess = 128.0;
-   ctx->Const.MaxSpotExponent = 128.0;
-   ctx->Const.MaxViewportWidth = MAX_WIDTH;
-   ctx->Const.MaxViewportHeight = MAX_HEIGHT;
-#if FEATURE_ARB_vertex_program
-   init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
-#endif
-#if FEATURE_ARB_fragment_program
-   init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
-#endif
-#if FEATURE_ARB_geometry_shader4
-   init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);
-#endif
-   ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
-   ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
-
-   /* CheckArrayBounds is overriden by drivers/x11 for X server */
-   ctx->Const.CheckArrayBounds = GL_FALSE;
-
-   /* GL_ARB_draw_buffers */
-   ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
-
-#if FEATURE_EXT_framebuffer_object
-   ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
-   ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
-#endif
-
-#if FEATURE_ARB_vertex_shader
-   ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxVarying = MAX_VARYING;
-#endif
-
-   /* Shading language version */
-   if (ctx->API == API_OPENGL) {
-      ctx->Const.GLSLVersion = 120;
-   }
-   else if (ctx->API == API_OPENGLES2) {
-      ctx->Const.GLSLVersion = 100;
-   }
-   else if (ctx->API == API_OPENGLES) {
-      ctx->Const.GLSLVersion = 0; /* GLSL not supported */
-   }
-
-   /* GL_ARB_framebuffer_object */
-   ctx->Const.MaxSamples = 0;
-
-   /* GL_ARB_sync */
-   ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
-
-   /* GL_ATI_envmap_bumpmap */
-   ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
-
-   /* GL_EXT_provoking_vertex */
-   ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
-
-   /* GL_EXT_transform_feedback */
-   ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;
-   ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
-   ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
-
-   /* GL 3.2: hard-coded for now: */
-   ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
-
-   /** GL_EXT_gpu_shader4 */
-   ctx->Const.MinProgramTexelOffset = -8;
-   ctx->Const.MaxProgramTexelOffset = 7;
-}
-
-
-/**
- * Do some sanity checks on the limits/constants for the given context.
- * Only called the first time a context is bound.
- */
-static void
-check_context_limits(struct gl_context *ctx)
-{
-   /* check that we don't exceed the size of various bitfields */
-   assert(VERT_RESULT_MAX <=
-	  (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
-   assert(FRAG_ATTRIB_MAX <=
-	  (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
-
-   assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));
-
-   /* shader-related checks */
-   assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
-   assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
-
-   assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
-   assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
-   assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
-   assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
-
-   /* Texture unit checks */
-   assert(ctx->Const.MaxTextureImageUnits > 0);
-   assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureCoordUnits > 0);
-   assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
-   assert(ctx->Const.MaxTextureUnits > 0);
-   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
-   assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
-                                             ctx->Const.MaxTextureCoordUnits));
-   assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
-   assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-   /* number of coord units cannot be greater than number of image units */
-   assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
-
-
-   /* Texture size checks */
-   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
-   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
-   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
-   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
-
-   /* make sure largest texture image is <= MAX_WIDTH in size */
-   assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
-
-   /* Texture level checks */
-   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
-   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
-
-   /* Max texture size should be <= max viewport size (render to texture) */
-   assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
-
-   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
-   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
-
-   assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
-
-   /* if this fails, add more enum values to gl_buffer_index */
-   assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
-
-   /* XXX probably add more tests */
-}
-
-
-/**
- * Initialize the attribute groups in a GL context.
- *
- * \param ctx GL context.
- *
- * Initializes all the attributes, calling the respective <tt>init*</tt>
- * functions for the more complex data structures.
- */
-static GLboolean
-init_attrib_groups(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   /* Constants */
-   _mesa_init_constants( ctx );
-
-   /* Extensions */
-   _mesa_init_extensions( ctx );
-
-   /* Attribute Groups */
-   _mesa_init_accum( ctx );
-   _mesa_init_attrib( ctx );
-   _mesa_init_buffer_objects( ctx );
-   _mesa_init_color( ctx );
-   _mesa_init_current( ctx );
-   _mesa_init_depth( ctx );
-   _mesa_init_debug( ctx );
-   _mesa_init_display_list( ctx );
-   _mesa_init_eval( ctx );
-   _mesa_init_fbobjects( ctx );
-   _mesa_init_feedback( ctx );
-   _mesa_init_fog( ctx );
-   _mesa_init_hint( ctx );
-   _mesa_init_line( ctx );
-   _mesa_init_lighting( ctx );
-   _mesa_init_matrix( ctx );
-   _mesa_init_multisample( ctx );
-   _mesa_init_pixel( ctx );
-   _mesa_init_pixelstore( ctx );
-   _mesa_init_point( ctx );
-   _mesa_init_polygon( ctx );
-   _mesa_init_program( ctx );
-   _mesa_init_queryobj( ctx );
-   _mesa_init_sync( ctx );
-   _mesa_init_rastpos( ctx );
-   _mesa_init_scissor( ctx );
-   _mesa_init_shader_state( ctx );
-   _mesa_init_stencil( ctx );
-   _mesa_init_transform( ctx );
-   _mesa_init_transform_feedback( ctx );
-   _mesa_init_varray( ctx );
-   _mesa_init_viewport( ctx );
-
-   if (!_mesa_init_texture( ctx ))
-      return GL_FALSE;
-
-   _mesa_init_texture_s3tc( ctx );
-
-   /* Miscellaneous */
-   ctx->NewState = _NEW_ALL;
-   ctx->ErrorValue = (GLenum) GL_NO_ERROR;
-   ctx->varying_vp_inputs = ~0;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Update default objects in a GL context with respect to shared state.
- *
- * \param ctx GL context.
- *
- * Removes references to old default objects, (texture objects, program
- * objects, etc.) and changes to reference those from the current shared
- * state.
- */
-static GLboolean
-update_default_objects(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   _mesa_update_default_objects_program(ctx);
-   _mesa_update_default_objects_texture(ctx);
-   _mesa_update_default_objects_buffer_objects(ctx);
-
-   return GL_TRUE;
-}
-
-
-/**
- * This is the default function we plug into all dispatch table slots
- * This helps prevents a segfault when someone calls a GL function without
- * first checking if the extension's supported.
- */
-static int
-generic_nop(void)
-{
-   _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
-   return 0;
-}
-
-
-/**
- * Allocate and initialize a new dispatch table.
- */
-struct _glapi_table *
-_mesa_alloc_dispatch_table(int size)
-{
-   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
-    * In practice, this'll be the same for stand-alone Mesa.  But for DRI
-    * Mesa we do this to accomodate different versions of libGL and various
-    * DRI drivers.
-    */
-   GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
-   struct _glapi_table *table;
-
-   /* should never happen, but just in case */
-   numEntries = MAX2(numEntries, size);
-
-   table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
-   if (table) {
-      _glapi_proc *entry = (_glapi_proc *) table;
-      GLint i;
-      for (i = 0; i < numEntries; i++) {
-         entry[i] = (_glapi_proc) generic_nop;
-      }
-   }
-   return table;
-}
-
-
-/**
- * Initialize a struct gl_context struct (rendering context).
- *
- * This includes allocating all the other structs and arrays which hang off of
- * the context by pointers.
- * Note that the driver needs to pass in its dd_function_table here since
- * we need to at least call driverFunctions->NewTextureObject to create the
- * default texture objects.
- * 
- * Called by _mesa_create_context().
- *
- * Performs the imports and exports callback tables initialization, and
- * miscellaneous one-time initializations. If no shared context is supplied one
- * is allocated, and increase its reference count.  Setups the GL API dispatch
- * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
- * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
- * for debug flags.
- *
- * \param ctx the context to initialize
- * \param api the GL API type to create the context for
- * \param visual describes the visual attributes for this context
- * \param share_list points to context to share textures, display lists,
- *        etc with, or NULL
- * \param driverFunctions table of device driver functions for this context
- *        to use
- * \param driverContext pointer to driver-specific context data
- */
-GLboolean
-_mesa_initialize_context(struct gl_context *ctx,
-                         gl_api api,
-                         const struct gl_config *visual,
-                         struct gl_context *share_list,
-                         const struct dd_function_table *driverFunctions,
-                         void *driverContext)
-{
-   struct gl_shared_state *shared;
-   int i;
-
-   /*ASSERT(driverContext);*/
-   assert(driverFunctions->NewTextureObject);
-   assert(driverFunctions->FreeTexImageData);
-
-   ctx->API = api;
-   ctx->Visual = *visual;
-   ctx->DrawBuffer = NULL;
-   ctx->ReadBuffer = NULL;
-   ctx->WinSysDrawBuffer = NULL;
-   ctx->WinSysReadBuffer = NULL;
-
-   /* misc one-time initializations */
-   one_time_init(ctx);
-
-   /* Plug in driver functions and context pointer here.
-    * This is important because when we call alloc_shared_state() below
-    * we'll call ctx->Driver.NewTextureObject() to create the default
-    * textures.
-    */
-   ctx->Driver = *driverFunctions;
-   ctx->DriverCtx = driverContext;
-
-   if (share_list) {
-      /* share state with another context */
-      shared = share_list->Shared;
-   }
-   else {
-      /* allocate new, unshared state */
-      shared = _mesa_alloc_shared_state(ctx);
-      if (!shared)
-         return GL_FALSE;
-   }
-
-   _glthread_LOCK_MUTEX(shared->Mutex);
-   ctx->Shared = shared;
-   shared->RefCount++;
-   _glthread_UNLOCK_MUTEX(shared->Mutex);
-
-   if (!init_attrib_groups( ctx )) {
-      _mesa_release_shared_state(ctx, ctx->Shared);
-      return GL_FALSE;
-   }
-
-#if FEATURE_dispatch
-   /* setup the API dispatch tables */
-   switch (ctx->API) {
-#if FEATURE_GL
-   case API_OPENGL:
-      ctx->Exec = _mesa_create_exec_table();
-      break;
-#endif
-#if FEATURE_ES1
-   case API_OPENGLES:
-      ctx->Exec = _mesa_create_exec_table_es1();
-      break;
-#endif
-#if FEATURE_ES2
-   case API_OPENGLES2:
-      ctx->Exec = _mesa_create_exec_table_es2();
-      break;
-#endif
-   default:
-      _mesa_problem(ctx, "unknown or unsupported API");
-      break;
-   }
-
-   if (!ctx->Exec) {
-      _mesa_release_shared_state(ctx, ctx->Shared);
-      return GL_FALSE;
-   }
-#endif
-   ctx->CurrentDispatch = ctx->Exec;
-
-   ctx->FragmentProgram._MaintainTexEnvProgram
-      = (_mesa_getenv("MESA_TEX_PROG") != NULL);
-
-   ctx->VertexProgram._MaintainTnlProgram
-      = (_mesa_getenv("MESA_TNL_PROG") != NULL);
-   if (ctx->VertexProgram._MaintainTnlProgram) {
-      /* this is required... */
-      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-   }
-
-   /* Mesa core handles all the formats that mesa core knows about.
-    * Drivers will want to override this list with just the formats
-    * they can handle, and confirm that appropriate fallbacks exist in
-    * _mesa_choose_tex_format().
-    */
-   memset(&ctx->TextureFormatSupported, GL_TRUE,
-	  sizeof(ctx->TextureFormatSupported));
-
-   switch (ctx->API) {
-   case API_OPENGL:
-#if FEATURE_dlist
-      ctx->Save = _mesa_create_save_table();
-      if (!ctx->Save) {
-	 _mesa_release_shared_state(ctx, ctx->Shared);
-	 free(ctx->Exec);
-	 return GL_FALSE;
-      }
-
-      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-#endif
-      break;
-   case API_OPENGLES:
-      /**
-       * GL_OES_texture_cube_map says
-       * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
-       */
-      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-	 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-	 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-	 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-	 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-      }
-      break;
-   case API_OPENGLES2:
-      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-      ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
-      ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */
-      break;
-   }
-
-   ctx->FirstTimeCurrent = GL_TRUE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Allocate and initialize a struct gl_context structure.
- * Note that the driver needs to pass in its dd_function_table here since
- * we need to at least call driverFunctions->NewTextureObject to initialize
- * the rendering context.
- *
- * \param api the GL API type to create the context for
- * \param visual a struct gl_config pointer (we copy the struct contents)
- * \param share_list another context to share display lists with or NULL
- * \param driverFunctions points to the dd_function_table into which the
- *        driver has plugged in all its special functions.
- * \param driverContext points to the device driver's private context state
- * 
- * \return pointer to a new __struct gl_contextRec or NULL if error.
- */
-struct gl_context *
-_mesa_create_context(gl_api api,
-                     const struct gl_config *visual,
-                     struct gl_context *share_list,
-                     const struct dd_function_table *driverFunctions,
-                     void *driverContext)
-{
-   struct gl_context *ctx;
-
-   ASSERT(visual);
-   /*ASSERT(driverContext);*/
-
-   ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));
-   if (!ctx)
-      return NULL;
-
-   if (_mesa_initialize_context(ctx, api, visual, share_list,
-                                driverFunctions, driverContext)) {
-      return ctx;
-   }
-   else {
-      free(ctx);
-      return NULL;
-   }
-}
-
-
-/**
- * Free the data associated with the given context.
- * 
- * But doesn't free the struct gl_context struct itself.
- *
- * \sa _mesa_initialize_context() and init_attrib_groups().
- */
-void
-_mesa_free_context_data( struct gl_context *ctx )
-{
-   if (!_mesa_get_current_context()){
-      /* No current context, but we may need one in order to delete
-       * texture objs, etc.  So temporarily bind the context now.
-       */
-      _mesa_make_current(ctx, NULL, NULL);
-   }
-
-   /* unreference WinSysDraw/Read buffers */
-   _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
-
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
-
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
-
-   _mesa_free_attrib_data(ctx);
-   _mesa_free_buffer_objects(ctx);
-   _mesa_free_lighting_data( ctx );
-   _mesa_free_eval_data( ctx );
-   _mesa_free_texture_data( ctx );
-   _mesa_free_matrix_data( ctx );
-   _mesa_free_viewport_data( ctx );
-   _mesa_free_program_data(ctx);
-   _mesa_free_shader_state(ctx);
-   _mesa_free_queryobj_data(ctx);
-   _mesa_free_sync_data(ctx);
-   _mesa_free_varray_data(ctx);
-   _mesa_free_transform_feedback(ctx);
-
-   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
-
-#if FEATURE_ARB_pixel_buffer_object
-   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
-#endif
-
-   /* free dispatch tables */
-   free(ctx->Exec);
-   free(ctx->Save);
-
-   /* Shared context state (display lists, textures, etc) */
-   _mesa_release_shared_state( ctx, ctx->Shared );
-
-   /* needs to be after freeing shared state */
-   _mesa_free_display_list_data(ctx);
-
-   if (ctx->Extensions.String)
-      free((void *) ctx->Extensions.String);
-
-   if (ctx->VersionString)
-      free(ctx->VersionString);
-
-   /* unbind the context if it's currently bound */
-   if (ctx == _mesa_get_current_context()) {
-      _mesa_make_current(NULL, NULL, NULL);
-   }
-}
-
-
-/**
- * Destroy a struct gl_context structure.
- *
- * \param ctx GL context.
- * 
- * Calls _mesa_free_context_data() and frees the gl_context object itself.
- */
-void
-_mesa_destroy_context( struct gl_context *ctx )
-{
-   if (ctx) {
-      _mesa_free_context_data(ctx);
-      free( (void *) ctx );
-   }
-}
-
-
-#if _HAVE_FULL_GL
-/**
- * Copy attribute groups from one context to another.
- * 
- * \param src source context
- * \param dst destination context
- * \param mask bitwise OR of GL_*_BIT flags
- *
- * According to the bits specified in \p mask, copies the corresponding
- * attributes from \p src into \p dst.  For many of the attributes a simple \c
- * memcpy is not enough due to the existence of internal pointers in their data
- * structures.
- */
-void
-_mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask )
-{
-   if (mask & GL_ACCUM_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Accum = src->Accum;
-   }
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Color = src->Color;
-   }
-   if (mask & GL_CURRENT_BIT) {
-      /* OK to memcpy */
-      dst->Current = src->Current;
-   }
-   if (mask & GL_DEPTH_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Depth = src->Depth;
-   }
-   if (mask & GL_ENABLE_BIT) {
-      /* no op */
-   }
-   if (mask & GL_EVAL_BIT) {
-      /* OK to memcpy */
-      dst->Eval = src->Eval;
-   }
-   if (mask & GL_FOG_BIT) {
-      /* OK to memcpy */
-      dst->Fog = src->Fog;
-   }
-   if (mask & GL_HINT_BIT) {
-      /* OK to memcpy */
-      dst->Hint = src->Hint;
-   }
-   if (mask & GL_LIGHTING_BIT) {
-      GLuint i;
-      /* begin with memcpy */
-      dst->Light = src->Light;
-      /* fixup linked lists to prevent pointer insanity */
-      make_empty_list( &(dst->Light.EnabledList) );
-      for (i = 0; i < MAX_LIGHTS; i++) {
-         if (dst->Light.Light[i].Enabled) {
-            insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
-         }
-      }
-   }
-   if (mask & GL_LINE_BIT) {
-      /* OK to memcpy */
-      dst->Line = src->Line;
-   }
-   if (mask & GL_LIST_BIT) {
-      /* OK to memcpy */
-      dst->List = src->List;
-   }
-   if (mask & GL_PIXEL_MODE_BIT) {
-      /* OK to memcpy */
-      dst->Pixel = src->Pixel;
-   }
-   if (mask & GL_POINT_BIT) {
-      /* OK to memcpy */
-      dst->Point = src->Point;
-   }
-   if (mask & GL_POLYGON_BIT) {
-      /* OK to memcpy */
-      dst->Polygon = src->Polygon;
-   }
-   if (mask & GL_POLYGON_STIPPLE_BIT) {
-      /* Use loop instead of memcpy due to problem with Portland Group's
-       * C compiler.  Reported by John Stone.
-       */
-      GLuint i;
-      for (i = 0; i < 32; i++) {
-         dst->PolygonStipple[i] = src->PolygonStipple[i];
-      }
-   }
-   if (mask & GL_SCISSOR_BIT) {
-      /* OK to memcpy */
-      dst->Scissor = src->Scissor;
-   }
-   if (mask & GL_STENCIL_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Stencil = src->Stencil;
-   }
-   if (mask & GL_TEXTURE_BIT) {
-      /* Cannot memcpy because of pointers */
-      _mesa_copy_texture_state(src, dst);
-   }
-   if (mask & GL_TRANSFORM_BIT) {
-      /* OK to memcpy */
-      dst->Transform = src->Transform;
-   }
-   if (mask & GL_VIEWPORT_BIT) {
-      /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
-      dst->Viewport.X = src->Viewport.X;
-      dst->Viewport.Y = src->Viewport.Y;
-      dst->Viewport.Width = src->Viewport.Width;
-      dst->Viewport.Height = src->Viewport.Height;
-      dst->Viewport.Near = src->Viewport.Near;
-      dst->Viewport.Far = src->Viewport.Far;
-      _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
-   }
-
-   /* XXX FIXME:  Call callbacks?
-    */
-   dst->NewState = _NEW_ALL;
-}
-#endif
-
-
-/**
- * Check if the given context can render into the given framebuffer
- * by checking visual attributes.
- *
- * Most of these tests could go away because Mesa is now pretty flexible
- * in terms of mixing rendering contexts with framebuffers.  As long
- * as RGB vs. CI mode agree, we're probably good.
- *
- * \return GL_TRUE if compatible, GL_FALSE otherwise.
- */
-static GLboolean 
-check_compatible(const struct gl_context *ctx,
-                 const struct gl_framebuffer *buffer)
-{
-   const struct gl_config *ctxvis = &ctx->Visual;
-   const struct gl_config *bufvis = &buffer->Visual;
-
-   if (buffer == _mesa_get_incomplete_framebuffer())
-      return GL_TRUE;
-
-#if 0
-   /* disabling this fixes the fgl_glxgears pbuffer demo */
-   if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
-      return GL_FALSE;
-#endif
-   if (ctxvis->stereoMode && !bufvis->stereoMode)
-      return GL_FALSE;
-   if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
-      return GL_FALSE;
-   if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
-      return GL_FALSE;
-   if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
-      return GL_FALSE;
-   if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
-      return GL_FALSE;
-   if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
-      return GL_FALSE;
-   if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
-      return GL_FALSE;
-#if 0
-   /* disabled (see bug 11161) */
-   if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
-      return GL_FALSE;
-#endif
-   if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do one-time initialization for the given framebuffer.  Specifically,
- * ask the driver for the window's current size and update the framebuffer
- * object to match.
- * Really, the device driver should totally take care of this.
- */
-static void
-initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   GLuint width, height;
-   if (ctx->Driver.GetBufferSize) {
-      ctx->Driver.GetBufferSize(fb, &width, &height);
-      if (ctx->Driver.ResizeBuffers)
-         ctx->Driver.ResizeBuffers(ctx, fb, width, height);
-      fb->Initialized = GL_TRUE;
-   }
-}
-
-
-/**
- * Check if the viewport/scissor size has not yet been initialized.
- * Initialize the size if the given width and height are non-zero.
- */
-void
-_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
-{
-   if (!ctx->ViewportInitialized && width > 0 && height > 0) {
-      /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
-       * potential infinite recursion.
-       */
-      ctx->ViewportInitialized = GL_TRUE;
-      _mesa_set_viewport(ctx, 0, 0, width, height);
-      _mesa_set_scissor(ctx, 0, 0, width, height);
-   }
-}
-
-
-/**
- * Bind the given context to the given drawBuffer and readBuffer and
- * make it the current context for the calling thread.
- * We'll render into the drawBuffer and read pixels from the
- * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
- *
- * We check that the context's and framebuffer's visuals are compatible
- * and return immediately if they're not.
- *
- * \param newCtx  the new GL context. If NULL then there will be no current GL
- *                context.
- * \param drawBuffer  the drawing framebuffer
- * \param readBuffer  the reading framebuffer
- */
-GLboolean
-_mesa_make_current( struct gl_context *newCtx,
-                    struct gl_framebuffer *drawBuffer,
-                    struct gl_framebuffer *readBuffer )
-{
-   GET_CURRENT_CONTEXT(curCtx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(newCtx, "_mesa_make_current()\n");
-
-   /* Check that the context's and framebuffer's visuals are compatible.
-    */
-   if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
-      if (!check_compatible(newCtx, drawBuffer)) {
-         _mesa_warning(newCtx,
-              "MakeCurrent: incompatible visuals for context and drawbuffer");
-         return GL_FALSE;
-      }
-   }
-   if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
-      if (!check_compatible(newCtx, readBuffer)) {
-         _mesa_warning(newCtx,
-              "MakeCurrent: incompatible visuals for context and readbuffer");
-         return GL_FALSE;
-      }
-   }
-
-   if (curCtx && 
-      (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */
-      curCtx != newCtx)
-      _mesa_flush(curCtx);
-
-   /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
-   _glapi_set_context((void *) newCtx);
-   ASSERT(_mesa_get_current_context() == newCtx);
-
-   if (!newCtx) {
-      _glapi_set_dispatch(NULL);  /* none current */
-   }
-   else {
-      _glapi_set_dispatch(newCtx->CurrentDispatch);
-
-      if (drawBuffer && readBuffer) {
-	 /* TODO: check if newCtx and buffer's visual match??? */
-
-         ASSERT(drawBuffer->Name == 0);
-         ASSERT(readBuffer->Name == 0);
-         _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
-         _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
-
-         /*
-          * Only set the context's Draw/ReadBuffer fields if they're NULL
-          * or not bound to a user-created FBO.
-          */
-         if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
-            /* KW: merge conflict here, revisit. 
-             */
-            /* fix up the fb fields - these will end up wrong otherwise
-             * if the DRIdrawable changes, and everything relies on them.
-             * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
-             */
-            unsigned int i;
-            GLenum buffers[MAX_DRAW_BUFFERS];
-
-            _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
-
-            for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
-               buffers[i] = newCtx->Color.DrawBuffer[i];
-            }
-
-            _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers,
-                              buffers, NULL);
-         }
-         if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
-            _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
-         }
-
-         /* XXX only set this flag if we're really changing the draw/read
-          * framebuffer bindings.
-          */
-	 newCtx->NewState |= _NEW_BUFFERS;
-
-#if 1
-         /* We want to get rid of these lines: */
-
-#if _HAVE_FULL_GL
-         if (!drawBuffer->Initialized) {
-            initialize_framebuffer_size(newCtx, drawBuffer);
-         }
-         if (readBuffer != drawBuffer && !readBuffer->Initialized) {
-            initialize_framebuffer_size(newCtx, readBuffer);
-         }
-
-	 _mesa_resizebuffers(newCtx);
-#endif
-
-#else
-         /* We want the drawBuffer and readBuffer to be initialized by
-          * the driver.
-          * This generally means the Width and Height match the actual
-          * window size and the renderbuffers (both hardware and software
-          * based) are allocated to match.  The later can generally be
-          * done with a call to _mesa_resize_framebuffer().
-          *
-          * It's theoretically possible for a buffer to have zero width
-          * or height, but for now, assert check that the driver did what's
-          * expected of it.
-          */
-         ASSERT(drawBuffer->Width > 0);
-         ASSERT(drawBuffer->Height > 0);
-#endif
-
-         if (drawBuffer) {
-            _mesa_check_init_viewport(newCtx,
-                                      drawBuffer->Width, drawBuffer->Height);
-         }
-      }
-
-      if (newCtx->FirstTimeCurrent) {
-         _mesa_compute_version(newCtx);
-
-         newCtx->Extensions.String = _mesa_make_extension_string(newCtx);
-
-         check_context_limits(newCtx);
-
-         /* We can use this to help debug user's problems.  Tell them to set
-          * the MESA_INFO env variable before running their app.  Then the
-          * first time each context is made current we'll print some useful
-          * information.
-          */
-	 if (_mesa_getenv("MESA_INFO")) {
-	    _mesa_print_info();
-	 }
-
-	 newCtx->FirstTimeCurrent = GL_FALSE;
-      }
-   }
-   
-   return GL_TRUE;
-}
-
-
-/**
- * Make context 'ctx' share the display lists, textures and programs
- * that are associated with 'ctxToShare'.
- * Any display lists, textures or programs associated with 'ctx' will
- * be deleted if nobody else is sharing them.
- */
-GLboolean
-_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
-{
-   if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
-      struct gl_shared_state *oldSharedState = ctx->Shared;
-
-      ctx->Shared = ctxToShare->Shared;
-      
-      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-      ctx->Shared->RefCount++;
-      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
-      update_default_objects(ctx);
-
-      _mesa_release_shared_state(ctx, oldSharedState);
-
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-
-/**
- * \return pointer to the current GL context for this thread.
- * 
- * Calls _glapi_get_context(). This isn't the fastest way to get the current
- * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
- * context.h.
- */
-struct gl_context *
-_mesa_get_current_context( void )
-{
-   return (struct gl_context *) _glapi_get_context();
-}
-
-
-/**
- * Get context's current API dispatch table.
- *
- * It'll either be the immediate-mode execute dispatcher or the display list
- * compile dispatcher.
- * 
- * \param ctx GL context.
- *
- * \return pointer to dispatch_table.
- *
- * Simply returns __struct gl_contextRec::CurrentDispatch.
- */
-struct _glapi_table *
-_mesa_get_dispatch(struct gl_context *ctx)
-{
-   return ctx->CurrentDispatch;
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Miscellaneous functions                                     */
-/**********************************************************************/
-/*@{*/
-
-/**
- * Record an error.
- *
- * \param ctx GL context.
- * \param error error code.
- * 
- * Records the given error code and call the driver's dd_function_table::Error
- * function if defined.
- *
- * \sa
- * This is called via _mesa_error().
- */
-void
-_mesa_record_error(struct gl_context *ctx, GLenum error)
-{
-   if (!ctx)
-      return;
-
-   if (ctx->ErrorValue == GL_NO_ERROR) {
-      ctx->ErrorValue = error;
-   }
-
-   /* Call device driver's error handler, if any.  This is used on the Mac. */
-   if (ctx->Driver.Error) {
-      ctx->Driver.Error(ctx);
-   }
-}
-
-
-/**
- * Flush commands and wait for completion.
- */
-void
-_mesa_finish(struct gl_context *ctx)
-{
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Finish) {
-      ctx->Driver.Finish(ctx);
-   }
-}
-
-
-/**
- * Flush commands.
- */
-void
-_mesa_flush(struct gl_context *ctx)
-{
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Flush) {
-      ctx->Driver.Flush(ctx);
-   }
-}
-
-
-
-/**
- * Execute glFinish().
- *
- * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
- * dd_function_table::Finish driver callback, if not NULL.
- */
-void GLAPIENTRY
-_mesa_Finish(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_finish(ctx);
-}
-
-
-/**
- * Execute glFlush().
- *
- * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
- * dd_function_table::Flush driver callback, if not NULL.
- */
-void GLAPIENTRY
-_mesa_Flush(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_flush(ctx);
-}
-
-
-/**
- * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
- * MUL/MAD, or vice versa, call this function to register that.
- * Otherwise we default to MUL/MAD.
- */
-void
-_mesa_set_mvp_with_dp4( struct gl_context *ctx,
-                        GLboolean flag )
-{
-   ctx->mvp_with_dp4 = flag;
-}
-
-
-
-/**
- * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
- * is called to see if it's valid to render.  This involves checking that
- * the current shader is valid and the framebuffer is complete.
- * If an error is detected it'll be recorded here.
- * \return GL_TRUE if OK to render, GL_FALSE if not
- */
-GLboolean
-_mesa_valid_to_render(struct gl_context *ctx, const char *where)
-{
-   bool vert_from_glsl_shader = false;
-   bool geom_from_glsl_shader = false;
-   bool frag_from_glsl_shader = false;
-
-   /* This depends on having up to date derived state (shaders) */
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   if (ctx->Shader.CurrentVertexProgram) {
-      vert_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentVertexProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentVertexProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   if (ctx->Shader.CurrentGeometryProgram) {
-      geom_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentGeometryProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentGeometryProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   if (ctx->Shader.CurrentFragmentProgram) {
-      frag_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentFragmentProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentFragmentProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   /* Any shader stages that are not supplied by the GLSL shader and have
-    * assembly shaders enabled must now be validated.
-    */
-   if (!vert_from_glsl_shader
-       && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-		  "%s(vertex program not valid)", where);
-      return GL_FALSE;
-   }
-
-   /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current
-    * FINISHME: geometry program should validated here.
-    */
-   (void) geom_from_glsl_shader;
-
-   if (!frag_from_glsl_shader) {
-      if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION,
-		     "%s(fragment program not valid)", where);
-	 return GL_FALSE;
-      }
-
-      /* If drawing to integer-valued color buffers, there must be an
-       * active fragment shader (GL_EXT_texture_integer).
-       */
-      if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(integer format but no fragment shader)", where);
-         return GL_FALSE;
-      }
-   }
-
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "%s(incomplete framebuffer)", where);
-      return GL_FALSE;
-   }
-
-#ifdef DEBUG
-   if (ctx->Shader.Flags & GLSL_LOG) {
-      struct gl_shader_program *shProg[MESA_SHADER_TYPES];
-      gl_shader_type i;
-
-      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;
-      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;
-      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
-
-      for (i = 0; i < MESA_SHADER_TYPES; i++) {
-	 struct gl_shader *sh;
-
-	 if (shProg[i] == NULL || shProg[i]->_Used
-	     || shProg[i]->_LinkedShaders[i] == NULL)
-	    continue;
-
-	 /* This is the first time this shader is being used.
-	  * Append shader's constants/uniforms to log file.
-	  *
-	  * The logic is a little odd here.  We only want to log data for each
-	  * shader target that will actually be used, and we only want to log
-	  * it once.  It's possible to have a program bound to the vertex
-	  * shader target that also supplied a fragment shader.  If that
-	  * program isn't also bound to the fragment shader target we don't
-	  * want to log its fragment data.
-	  */
-	 sh = shProg[i]->_LinkedShaders[i];
-	 switch (sh->Type) {
-	 case GL_VERTEX_SHADER:
-	    _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base);
-	    break;
-
-	 case GL_GEOMETRY_SHADER_ARB:
-	    _mesa_append_uniforms_to_file(sh,
-					  &shProg[i]->GeometryProgram->Base);
-	    break;
-
-	 case GL_FRAGMENT_SHADER:
-	    _mesa_append_uniforms_to_file(sh,
-					  &shProg[i]->FragmentProgram->Base);
-	    break;
-	 }
-      }
-
-      for (i = 0; i < MESA_SHADER_TYPES; i++) {
-	 if (shProg[i] != NULL)
-	    shProg[i]->_Used = GL_TRUE;
-      }
-   }
-#endif
-
-   return GL_TRUE;
-}
-
-
-/*@}*/
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2008  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file context.c

+ * Mesa context/visual/framebuffer management functions.

+ * \author Brian Paul

+ */

+

+/**

+ * \mainpage Mesa Main Module

+ *

+ * \section MainIntroduction Introduction

+ *

+ * The Mesa Main module consists of all the files in the main/ directory.

+ * Among the features of this module are:

+ * <UL>

+ * <LI> Structures to represent most GL state </LI>

+ * <LI> State set/get functions </LI>

+ * <LI> Display lists </LI>

+ * <LI> Texture unit, object and image handling </LI>

+ * <LI> Matrix and attribute stacks </LI>

+ * </UL>

+ *

+ * Other modules are responsible for API dispatch, vertex transformation,

+ * point/line/triangle setup, rasterization, vertex array caching,

+ * vertex/fragment programs/shaders, etc.

+ *

+ *

+ * \section AboutDoxygen About Doxygen

+ *

+ * If you're viewing this information as Doxygen-generated HTML you'll

+ * see the documentation index at the top of this page.

+ *

+ * The first line lists the Mesa source code modules.

+ * The second line lists the indexes available for viewing the documentation

+ * for each module.

+ *

+ * Selecting the <b>Main page</b> link will display a summary of the module

+ * (this page).

+ *

+ * Selecting <b>Data Structures</b> will list all C structures.

+ *

+ * Selecting the <b>File List</b> link will list all the source files in

+ * the module.

+ * Selecting a filename will show a list of all functions defined in that file.

+ *

+ * Selecting the <b>Data Fields</b> link will display a list of all

+ * documented structure members.

+ *

+ * Selecting the <b>Globals</b> link will display a list

+ * of all functions, structures, global variables and macros in the module.

+ *

+ */

+

+

+#include "glheader.h"

+#include "mfeatures.h"

+#include "imports.h"

+#include "accum.h"

+#include "api_exec.h"

+#include "arrayobj.h"

+#include "attrib.h"

+#include "blend.h"

+#include "buffers.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "cpuinfo.h"

+#include "debug.h"

+#include "depth.h"

+#include "dlist.h"

+#include "eval.h"

+#include "extensions.h"

+#include "fbobject.h"

+#include "feedback.h"

+#include "fog.h"

+#include "formats.h"

+#include "framebuffer.h"

+#include "hint.h"

+#include "hash.h"

+#include "light.h"

+#include "lines.h"

+#include "macros.h"

+#include "matrix.h"

+#include "multisample.h"

+#include "pixel.h"

+#include "pixelstore.h"

+#include "points.h"

+#include "polygon.h"

+#include "queryobj.h"

+#include "syncobj.h"

+#include "rastpos.h"

+#include "remap.h"

+#include "scissor.h"

+#include "shared.h"

+#include "shaderobj.h"

+#include "simple_list.h"

+#include "state.h"

+#include "stencil.h"

+#include "texcompress_s3tc.h"

+#include "texstate.h"

+#include "transformfeedback.h"

+#include "mtypes.h"

+#include "varray.h"

+#include "version.h"

+#include "viewport.h"

+#include "vtxfmt.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+#if _HAVE_FULL_GL

+#include "math/m_matrix.h"

+#endif

+#include "main/dispatch.h" /* for _gloffset_COUNT */

+

+#ifdef USE_SPARC_ASM

+#include "sparc/sparc.h"

+#endif

+

+#include "glsl_parser_extras.h"

+#include <stdbool.h>

+

+

+#ifndef MESA_VERBOSE

+int MESA_VERBOSE = 0;

+#endif

+

+#ifndef MESA_DEBUG_FLAGS

+int MESA_DEBUG_FLAGS = 0;

+#endif

+

+

+/* ubyte -> float conversion */

+GLfloat _mesa_ubyte_to_float_color_tab[256];

+

+

+

+/**

+ * Swap buffers notification callback.

+ * 

+ * \param ctx GL context.

+ *

+ * Called by window system just before swapping buffers.

+ * We have to finish any pending rendering.

+ */

+void

+_mesa_notifySwapBuffers(struct gl_context *ctx)

+{

+   if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)

+      _mesa_debug(ctx, "SwapBuffers\n");

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Flush) {

+      ctx->Driver.Flush(ctx);

+   }

+}

+

+

+/**********************************************************************/

+/** \name GL Visual allocation/destruction                            */

+/**********************************************************************/

+/*@{*/

+

+/**

+ * Allocates a struct gl_config structure and initializes it via

+ * _mesa_initialize_visual().

+ * 

+ * \param dbFlag double buffering

+ * \param stereoFlag stereo buffer

+ * \param depthBits requested bits per depth buffer value. Any value in [0, 32]

+ * is acceptable but the actual depth type will be GLushort or GLuint as

+ * needed.

+ * \param stencilBits requested minimum bits per stencil buffer value

+ * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.

+ * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE

+ * \param redBits number of bits per color component in frame buffer for RGB(A)

+ * mode.  We always use 8 in core Mesa though.

+ * \param greenBits same as above.

+ * \param blueBits same as above.

+ * \param alphaBits same as above.

+ * \param numSamples not really used.

+ * 

+ * \return pointer to new struct gl_config or NULL if requested parameters can't be

+ * met.

+ *

+ * \note Need to add params for level and numAuxBuffers (at least)

+ */

+struct gl_config *

+_mesa_create_visual( GLboolean dbFlag,

+                     GLboolean stereoFlag,

+                     GLint redBits,

+                     GLint greenBits,

+                     GLint blueBits,

+                     GLint alphaBits,

+                     GLint depthBits,

+                     GLint stencilBits,

+                     GLint accumRedBits,

+                     GLint accumGreenBits,

+                     GLint accumBlueBits,

+                     GLint accumAlphaBits,

+                     GLint numSamples )

+{

+   struct gl_config *vis = CALLOC_STRUCT(gl_config);

+   if (vis) {

+      if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,

+                                   redBits, greenBits, blueBits, alphaBits,

+                                   depthBits, stencilBits,

+                                   accumRedBits, accumGreenBits,

+                                   accumBlueBits, accumAlphaBits,

+                                   numSamples)) {

+         free(vis);

+         return NULL;

+      }

+   }

+   return vis;

+}

+

+

+/**

+ * Makes some sanity checks and fills in the fields of the struct

+ * gl_config object with the given parameters.  If the caller needs to

+ * set additional fields, he should just probably init the whole

+ * gl_config object himself.

+ *

+ * \return GL_TRUE on success, or GL_FALSE on failure.

+ *

+ * \sa _mesa_create_visual() above for the parameter description.

+ */

+GLboolean

+_mesa_initialize_visual( struct gl_config *vis,

+                         GLboolean dbFlag,

+                         GLboolean stereoFlag,

+                         GLint redBits,

+                         GLint greenBits,

+                         GLint blueBits,

+                         GLint alphaBits,

+                         GLint depthBits,

+                         GLint stencilBits,

+                         GLint accumRedBits,

+                         GLint accumGreenBits,

+                         GLint accumBlueBits,

+                         GLint accumAlphaBits,

+                         GLint numSamples )

+{

+   assert(vis);

+

+   if (depthBits < 0 || depthBits > 32) {

+      return GL_FALSE;

+   }

+   if (stencilBits < 0 || stencilBits > STENCIL_BITS) {

+      return GL_FALSE;

+   }

+   assert(accumRedBits >= 0);

+   assert(accumGreenBits >= 0);

+   assert(accumBlueBits >= 0);

+   assert(accumAlphaBits >= 0);

+

+   vis->rgbMode          = GL_TRUE;

+   vis->doubleBufferMode = dbFlag;

+   vis->stereoMode       = stereoFlag;

+

+   vis->redBits          = redBits;

+   vis->greenBits        = greenBits;

+   vis->blueBits         = blueBits;

+   vis->alphaBits        = alphaBits;

+   vis->rgbBits          = redBits + greenBits + blueBits;

+

+   vis->indexBits      = 0;

+   vis->depthBits      = depthBits;

+   vis->stencilBits    = stencilBits;

+

+   vis->accumRedBits   = accumRedBits;

+   vis->accumGreenBits = accumGreenBits;

+   vis->accumBlueBits  = accumBlueBits;

+   vis->accumAlphaBits = accumAlphaBits;

+

+   vis->haveAccumBuffer   = accumRedBits > 0;

+   vis->haveDepthBuffer   = depthBits > 0;

+   vis->haveStencilBuffer = stencilBits > 0;

+

+   vis->numAuxBuffers = 0;

+   vis->level = 0;

+   vis->sampleBuffers = numSamples > 0 ? 1 : 0;

+   vis->samples = numSamples;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Destroy a visual and free its memory.

+ *

+ * \param vis visual.

+ * 

+ * Frees the visual structure.

+ */

+void

+_mesa_destroy_visual( struct gl_config *vis )

+{

+   free(vis);

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Context allocation, initialization, destroying

+ *

+ * The purpose of the most initialization functions here is to provide the

+ * default state values according to the OpenGL specification.

+ */

+/**********************************************************************/

+/*@{*/

+

+

+/**

+ * This is lame.  gdb only seems to recognize enum types that are

+ * actually used somewhere.  We want to be able to print/use enum

+ * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use

+ * the gl_texture_index type anywhere.  Thus, this lame function.

+ */

+static void

+dummy_enum_func(void)

+{

+   gl_buffer_index bi = BUFFER_FRONT_LEFT;

+   gl_face_index fi = FACE_POS_X;

+   gl_frag_attrib fa = FRAG_ATTRIB_WPOS;

+   gl_frag_result fr = FRAG_RESULT_DEPTH;

+   gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;

+   gl_vert_attrib va = VERT_ATTRIB_POS;

+   gl_vert_result vr = VERT_RESULT_HPOS;

+   gl_geom_attrib ga = GEOM_ATTRIB_POSITION;

+   gl_geom_result gr = GEOM_RESULT_POS;

+

+   (void) bi;

+   (void) fi;

+   (void) fa;

+   (void) fr;

+   (void) ti;

+   (void) va;

+   (void) vr;

+   (void) ga;

+   (void) gr;

+}

+

+

+/**

+ * One-time initialization mutex lock.

+ *

+ * \sa Used by one_time_init().

+ */

+_glthread_DECLARE_STATIC_MUTEX(OneTimeLock);

+

+

+

+/**

+ * Calls all the various one-time-init functions in Mesa.

+ *

+ * While holding a global mutex lock, calls several initialization functions,

+ * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is

+ * defined.

+ *

+ * \sa _math_init().

+ */

+static void

+one_time_init( struct gl_context *ctx )

+{

+   static GLbitfield api_init_mask = 0x0;

+

+   _glthread_LOCK_MUTEX(OneTimeLock);

+

+   /* truly one-time init */

+   if (!api_init_mask) {

+      GLuint i;

+

+      /* do some implementation tests */

+      assert( sizeof(GLbyte) == 1 );

+      assert( sizeof(GLubyte) == 1 );

+      assert( sizeof(GLshort) == 2 );

+      assert( sizeof(GLushort) == 2 );

+      assert( sizeof(GLint) == 4 );

+      assert( sizeof(GLuint) == 4 );

+

+      _mesa_get_cpu_features();

+

+      _mesa_init_sqrt_table();

+

+      /* context dependence is never a one-time thing... */

+      _mesa_init_get_hash(ctx);

+

+      for (i = 0; i < 256; i++) {

+         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;

+      }

+

+#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)

+      if (MESA_VERBOSE != 0) {

+	 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",

+		     MESA_VERSION_STRING, __DATE__, __TIME__);

+      }

+#endif

+

+#ifdef DEBUG

+      _mesa_test_formats();

+#endif

+   }

+

+   /* per-API one-time init */

+   if (!(api_init_mask & (1 << ctx->API))) {

+      /*

+       * This is fine as ES does not use the remap table, but it may not be

+       * future-proof.  We cannot always initialize the remap table because

+       * when an app is linked to libGLES*, there are not enough dynamic

+       * entries.

+       */

+      if (ctx->API == API_OPENGL)

+         _mesa_init_remap_table();

+   }

+

+   api_init_mask |= 1 << ctx->API;

+

+   _glthread_UNLOCK_MUTEX(OneTimeLock);

+

+   /* Hopefully atexit() is widely available.  If not, we may need some

+    * #ifdef tests here.

+    */

+   atexit(_mesa_destroy_shader_compiler);

+

+   dummy_enum_func();

+}

+

+

+/**

+ * Initialize fields of gl_current_attrib (aka ctx->Current.*)

+ */

+static void

+_mesa_init_current(struct gl_context *ctx)

+{

+   GLuint i;

+

+   /* Init all to (0,0,0,1) */

+   for (i = 0; i < Elements(ctx->Current.Attrib); i++) {

+      ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );

+   }

+

+   /* redo special cases: */

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );

+}

+

+

+/**

+ * Init vertex/fragment/geometry program limits.

+ * Important: drivers should override these with actual limits.

+ */

+static void

+init_program_limits(GLenum type, struct gl_program_constants *prog)

+{

+   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTemps = MAX_PROGRAM_TEMPS;

+   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;

+   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;

+   prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

+   prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;

+

+   switch (type) {

+   case GL_VERTEX_PROGRAM_ARB:

+      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

+

+      prog->MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;

+      prog->MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;

+      prog->MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;

+      prog->MaxGeometryUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;

+      prog->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;

+      prog->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;

+      break;

+   default:

+      assert(0 && "Bad program type in init_program_limits()");

+   }

+

+   /* Set the native limits to zero.  This implies that there is no native

+    * support for shaders.  Let the drivers fill in the actual values.

+    */

+   prog->MaxNativeInstructions = 0;

+   prog->MaxNativeAluInstructions = 0;

+   prog->MaxNativeTexInstructions = 0;

+   prog->MaxNativeTexIndirections = 0;

+   prog->MaxNativeAttribs = 0;

+   prog->MaxNativeTemps = 0;

+   prog->MaxNativeAddressRegs = 0;

+   prog->MaxNativeParameters = 0;

+

+   /* Set GLSL datatype range/precision info assuming IEEE float values.

+    * Drivers should override these defaults as needed.

+    */

+   prog->MediumFloat.RangeMin = 127;

+   prog->MediumFloat.RangeMax = 127;

+   prog->MediumFloat.Precision = 23;

+   prog->LowFloat = prog->HighFloat = prog->MediumFloat;

+

+   /* Assume ints are stored as floats for now, since this is the least-common

+    * denominator.  The OpenGL ES spec implies (page 132) that the precision

+    * of integer types should be 0.  Practically speaking, IEEE

+    * single-precision floating point values can only store integers in the

+    * range [-0x01000000, 0x01000000] without loss of precision.

+    */

+   prog->MediumInt.RangeMin = 24;

+   prog->MediumInt.RangeMax = 24;

+   prog->MediumInt.Precision = 0;

+   prog->LowInt = prog->HighInt = prog->MediumInt;

+}

+

+

+/**

+ * Initialize fields of gl_constants (aka ctx->Const.*).

+ * Use defaults from config.h.  The device drivers will often override

+ * some of these values (such as number of texture units).

+ */

+static void 

+_mesa_init_constants(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   /* Constants, may be overriden (usually only reduced) by device drivers */

+   ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;

+   ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;

+   ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;

+   ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;

+   ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;

+   ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;

+   ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;

+   ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,

+                                     ctx->Const.MaxTextureImageUnits);

+   ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;

+   ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;

+   ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;

+   ctx->Const.SubPixelBits = SUB_PIXEL_BITS;

+   ctx->Const.MinPointSize = MIN_POINT_SIZE;

+   ctx->Const.MaxPointSize = MAX_POINT_SIZE;

+   ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;

+   ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;

+   ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;

+   ctx->Const.MinLineWidth = MIN_LINE_WIDTH;

+   ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;

+   ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;

+   ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;

+   ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;

+   ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;

+   ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;

+   ctx->Const.MaxLights = MAX_LIGHTS;

+   ctx->Const.MaxShininess = 128.0;

+   ctx->Const.MaxSpotExponent = 128.0;

+   ctx->Const.MaxViewportWidth = MAX_WIDTH;

+   ctx->Const.MaxViewportHeight = MAX_HEIGHT;

+#if FEATURE_ARB_vertex_program

+   init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);

+#endif

+#if FEATURE_ARB_fragment_program

+   init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);

+#endif

+#if FEATURE_ARB_geometry_shader4

+   init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);

+#endif

+   ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;

+   ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;

+

+   /* CheckArrayBounds is overriden by drivers/x11 for X server */

+   ctx->Const.CheckArrayBounds = GL_FALSE;

+

+   /* GL_ARB_draw_buffers */

+   ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;

+

+#if FEATURE_EXT_framebuffer_object

+   ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;

+   ctx->Const.MaxRenderbufferSize = MAX_WIDTH;

+#endif

+

+#if FEATURE_ARB_vertex_shader

+   ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxVarying = MAX_VARYING;

+#endif

+

+   /* Shading language version */

+   if (ctx->API == API_OPENGL) {

+      ctx->Const.GLSLVersion = 120;

+   }

+   else if (ctx->API == API_OPENGLES2) {

+      ctx->Const.GLSLVersion = 100;

+   }

+   else if (ctx->API == API_OPENGLES) {

+      ctx->Const.GLSLVersion = 0; /* GLSL not supported */

+   }

+

+   /* GL_ARB_framebuffer_object */

+   ctx->Const.MaxSamples = 0;

+

+   /* GL_ARB_sync */

+   ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;

+

+   /* GL_ATI_envmap_bumpmap */

+   ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;

+

+   /* GL_EXT_provoking_vertex */

+   ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;

+

+   /* GL_EXT_transform_feedback */

+   ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;

+   ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;

+   ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;

+

+   /* GL 3.2: hard-coded for now: */

+   ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;

+

+   /** GL_EXT_gpu_shader4 */

+   ctx->Const.MinProgramTexelOffset = -8;

+   ctx->Const.MaxProgramTexelOffset = 7;

+}

+

+

+/**

+ * Do some sanity checks on the limits/constants for the given context.

+ * Only called the first time a context is bound.

+ */

+static void

+check_context_limits(struct gl_context *ctx)

+{

+   /* check that we don't exceed the size of various bitfields */

+   assert(VERT_RESULT_MAX <=

+	  (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));

+   assert(FRAG_ATTRIB_MAX <=

+	  (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));

+

+   assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));

+

+   /* shader-related checks */

+   assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

+   assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

+

+   assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);

+   assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);

+   assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);

+   assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);

+

+   /* Texture unit checks */

+   assert(ctx->Const.MaxTextureImageUnits > 0);

+   assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureCoordUnits > 0);

+   assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);

+   assert(ctx->Const.MaxTextureUnits > 0);

+   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);

+   assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,

+                                             ctx->Const.MaxTextureCoordUnits));

+   assert(ctx->Const.MaxCombinedTextureImageUnits > 0);

+   assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+   /* number of coord units cannot be greater than number of image units */

+   assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);

+

+

+   /* Texture size checks */

+   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);

+   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);

+   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);

+   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);

+

+   /* make sure largest texture image is <= MAX_WIDTH in size */

+   assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);

+   assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);

+   assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);

+

+   /* Texture level checks */

+   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);

+   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);

+

+   /* Max texture size should be <= max viewport size (render to texture) */

+   assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);

+

+   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);

+   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);

+

+   assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);

+

+   /* if this fails, add more enum values to gl_buffer_index */

+   assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);

+

+   /* XXX probably add more tests */

+}

+

+

+/**

+ * Initialize the attribute groups in a GL context.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes all the attributes, calling the respective <tt>init*</tt>

+ * functions for the more complex data structures.

+ */

+static GLboolean

+init_attrib_groups(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   /* Constants */

+   _mesa_init_constants( ctx );

+

+   /* Extensions */

+   _mesa_init_extensions( ctx );

+

+   /* Attribute Groups */

+   _mesa_init_accum( ctx );

+   _mesa_init_attrib( ctx );

+   _mesa_init_buffer_objects( ctx );

+   _mesa_init_color( ctx );

+   _mesa_init_current( ctx );

+   _mesa_init_depth( ctx );

+   _mesa_init_debug( ctx );

+   _mesa_init_display_list( ctx );

+   _mesa_init_eval( ctx );

+   _mesa_init_fbobjects( ctx );

+   _mesa_init_feedback( ctx );

+   _mesa_init_fog( ctx );

+   _mesa_init_hint( ctx );

+   _mesa_init_line( ctx );

+   _mesa_init_lighting( ctx );

+   _mesa_init_matrix( ctx );

+   _mesa_init_multisample( ctx );

+   _mesa_init_pixel( ctx );

+   _mesa_init_pixelstore( ctx );

+   _mesa_init_point( ctx );

+   _mesa_init_polygon( ctx );

+   _mesa_init_program( ctx );

+   _mesa_init_queryobj( ctx );

+   _mesa_init_sync( ctx );

+   _mesa_init_rastpos( ctx );

+   _mesa_init_scissor( ctx );

+   _mesa_init_shader_state( ctx );

+   _mesa_init_stencil( ctx );

+   _mesa_init_transform( ctx );

+   _mesa_init_transform_feedback( ctx );

+   _mesa_init_varray( ctx );

+   _mesa_init_viewport( ctx );

+

+   if (!_mesa_init_texture( ctx ))

+      return GL_FALSE;

+

+   _mesa_init_texture_s3tc( ctx );

+

+   /* Miscellaneous */

+   ctx->NewState = _NEW_ALL;

+   ctx->ErrorValue = (GLenum) GL_NO_ERROR;

+   ctx->varying_vp_inputs = ~0;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Update default objects in a GL context with respect to shared state.

+ *

+ * \param ctx GL context.

+ *

+ * Removes references to old default objects, (texture objects, program

+ * objects, etc.) and changes to reference those from the current shared

+ * state.

+ */

+static GLboolean

+update_default_objects(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   _mesa_update_default_objects_program(ctx);

+   _mesa_update_default_objects_texture(ctx);

+   _mesa_update_default_objects_buffer_objects(ctx);

+

+   return GL_TRUE;

+}

+

+

+/**

+ * This is the default function we plug into all dispatch table slots

+ * This helps prevents a segfault when someone calls a GL function without

+ * first checking if the extension's supported.

+ */

+static int

+generic_nop(void)

+{

+   _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");

+   return 0;

+}

+

+

+/**

+ * Allocate and initialize a new dispatch table.

+ */

+struct _glapi_table *

+_mesa_alloc_dispatch_table(int size)

+{

+   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.

+    * In practice, this'll be the same for stand-alone Mesa.  But for DRI

+    * Mesa we do this to accomodate different versions of libGL and various

+    * DRI drivers.

+    */

+   GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);

+   struct _glapi_table *table;

+

+   /* should never happen, but just in case */

+   numEntries = MAX2(numEntries, size);

+

+   table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));

+   if (table) {

+      _glapi_proc *entry = (_glapi_proc *) table;

+      GLint i;

+      for (i = 0; i < numEntries; i++) {

+         entry[i] = (_glapi_proc) generic_nop;

+      }

+   }

+   return table;

+}

+

+

+/**

+ * Initialize a struct gl_context struct (rendering context).

+ *

+ * This includes allocating all the other structs and arrays which hang off of

+ * the context by pointers.

+ * Note that the driver needs to pass in its dd_function_table here since

+ * we need to at least call driverFunctions->NewTextureObject to create the

+ * default texture objects.

+ * 

+ * Called by _mesa_create_context().

+ *

+ * Performs the imports and exports callback tables initialization, and

+ * miscellaneous one-time initializations. If no shared context is supplied one

+ * is allocated, and increase its reference count.  Setups the GL API dispatch

+ * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.

+ * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables

+ * for debug flags.

+ *

+ * \param ctx the context to initialize

+ * \param api the GL API type to create the context for

+ * \param visual describes the visual attributes for this context

+ * \param share_list points to context to share textures, display lists,

+ *        etc with, or NULL

+ * \param driverFunctions table of device driver functions for this context

+ *        to use

+ * \param driverContext pointer to driver-specific context data

+ */

+GLboolean

+_mesa_initialize_context(struct gl_context *ctx,

+                         gl_api api,

+                         const struct gl_config *visual,

+                         struct gl_context *share_list,

+                         const struct dd_function_table *driverFunctions,

+                         void *driverContext)

+{

+   struct gl_shared_state *shared;

+   int i;

+

+   /*ASSERT(driverContext);*/

+   assert(driverFunctions->NewTextureObject);

+   assert(driverFunctions->FreeTexImageData);

+

+   ctx->API = api;

+   ctx->Visual = *visual;

+   ctx->DrawBuffer = NULL;

+   ctx->ReadBuffer = NULL;

+   ctx->WinSysDrawBuffer = NULL;

+   ctx->WinSysReadBuffer = NULL;

+

+   /* misc one-time initializations */

+   one_time_init(ctx);

+

+   /* Plug in driver functions and context pointer here.

+    * This is important because when we call alloc_shared_state() below

+    * we'll call ctx->Driver.NewTextureObject() to create the default

+    * textures.

+    */

+   ctx->Driver = *driverFunctions;

+   ctx->DriverCtx = driverContext;

+

+   if (share_list) {

+      /* share state with another context */

+      shared = share_list->Shared;

+   }

+   else {

+      /* allocate new, unshared state */

+      shared = _mesa_alloc_shared_state(ctx);

+      if (!shared)

+         return GL_FALSE;

+   }

+

+   _glthread_LOCK_MUTEX(shared->Mutex);

+   ctx->Shared = shared;

+   shared->RefCount++;

+   _glthread_UNLOCK_MUTEX(shared->Mutex);

+

+   if (!init_attrib_groups( ctx )) {

+      _mesa_release_shared_state(ctx, ctx->Shared);

+      return GL_FALSE;

+   }

+

+#if FEATURE_dispatch

+   /* setup the API dispatch tables */

+   switch (ctx->API) {

+#if FEATURE_GL

+   case API_OPENGL:

+      ctx->Exec = _mesa_create_exec_table();

+      break;

+#endif

+#if FEATURE_ES1

+   case API_OPENGLES:

+      ctx->Exec = _mesa_create_exec_table_es1();

+      break;

+#endif

+#if FEATURE_ES2

+   case API_OPENGLES2:

+      ctx->Exec = _mesa_create_exec_table_es2();

+      break;

+#endif

+   default:

+      _mesa_problem(ctx, "unknown or unsupported API");

+      break;

+   }

+

+   if (!ctx->Exec) {

+      _mesa_release_shared_state(ctx, ctx->Shared);

+      return GL_FALSE;

+   }

+#endif

+   ctx->CurrentDispatch = ctx->Exec;

+

+   ctx->FragmentProgram._MaintainTexEnvProgram

+      = (_mesa_getenv("MESA_TEX_PROG") != NULL);

+

+   ctx->VertexProgram._MaintainTnlProgram

+      = (_mesa_getenv("MESA_TNL_PROG") != NULL);

+   if (ctx->VertexProgram._MaintainTnlProgram) {

+      /* this is required... */

+      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;

+   }

+

+   /* Mesa core handles all the formats that mesa core knows about.

+    * Drivers will want to override this list with just the formats

+    * they can handle, and confirm that appropriate fallbacks exist in

+    * _mesa_choose_tex_format().

+    */

+   memset(&ctx->TextureFormatSupported, GL_TRUE,

+	  sizeof(ctx->TextureFormatSupported));

+

+   switch (ctx->API) {

+   case API_OPENGL:

+#if FEATURE_dlist

+      ctx->Save = _mesa_create_save_table();

+      if (!ctx->Save) {

+	 _mesa_release_shared_state(ctx, ctx->Shared);

+	 free(ctx->Exec);

+	 return GL_FALSE;

+      }

+

+      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+#endif

+      break;

+   case API_OPENGLES:

+      /**

+       * GL_OES_texture_cube_map says

+       * "Initially all texture generation modes are set to REFLECTION_MAP_OES"

+       */

+      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {

+	 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];

+	 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+	 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+	 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+      }

+      break;

+   case API_OPENGLES2:

+      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;

+      ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;

+      ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */

+      break;

+   }

+

+   ctx->FirstTimeCurrent = GL_TRUE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Allocate and initialize a struct gl_context structure.

+ * Note that the driver needs to pass in its dd_function_table here since

+ * we need to at least call driverFunctions->NewTextureObject to initialize

+ * the rendering context.

+ *

+ * \param api the GL API type to create the context for

+ * \param visual a struct gl_config pointer (we copy the struct contents)

+ * \param share_list another context to share display lists with or NULL

+ * \param driverFunctions points to the dd_function_table into which the

+ *        driver has plugged in all its special functions.

+ * \param driverContext points to the device driver's private context state

+ * 

+ * \return pointer to a new __struct gl_contextRec or NULL if error.

+ */

+struct gl_context *

+_mesa_create_context(gl_api api,

+                     const struct gl_config *visual,

+                     struct gl_context *share_list,

+                     const struct dd_function_table *driverFunctions,

+                     void *driverContext)

+{

+   struct gl_context *ctx;

+

+   ASSERT(visual);

+   /*ASSERT(driverContext);*/

+

+   ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));

+   if (!ctx)

+      return NULL;

+

+   if (_mesa_initialize_context(ctx, api, visual, share_list,

+                                driverFunctions, driverContext)) {

+      return ctx;

+   }

+   else {

+      free(ctx);

+      return NULL;

+   }

+}

+

+

+/**

+ * Free the data associated with the given context.

+ * 

+ * But doesn't free the struct gl_context struct itself.

+ *

+ * \sa _mesa_initialize_context() and init_attrib_groups().

+ */

+void

+_mesa_free_context_data( struct gl_context *ctx )

+{

+   if (!_mesa_get_current_context()){

+      /* No current context, but we may need one in order to delete

+       * texture objs, etc.  So temporarily bind the context now.

+       */

+      _mesa_make_current(ctx, NULL, NULL);

+   }

+

+   /* unreference WinSysDraw/Read buffers */

+   _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);

+

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);

+

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);

+

+   _mesa_free_attrib_data(ctx);

+   _mesa_free_buffer_objects(ctx);

+   _mesa_free_lighting_data( ctx );

+   _mesa_free_eval_data( ctx );

+   _mesa_free_texture_data( ctx );

+   _mesa_free_matrix_data( ctx );

+   _mesa_free_viewport_data( ctx );

+   _mesa_free_program_data(ctx);

+   _mesa_free_shader_state(ctx);

+   _mesa_free_queryobj_data(ctx);

+   _mesa_free_sync_data(ctx);

+   _mesa_free_varray_data(ctx);

+   _mesa_free_transform_feedback(ctx);

+

+   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);

+

+#if FEATURE_ARB_pixel_buffer_object

+   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);

+#endif

+

+#if FEATURE_ARB_vertex_buffer_object

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);

+#endif

+

+   /* free dispatch tables */

+   free(ctx->Exec);

+   free(ctx->Save);

+

+   /* Shared context state (display lists, textures, etc) */

+   _mesa_release_shared_state( ctx, ctx->Shared );

+

+   /* needs to be after freeing shared state */

+   _mesa_free_display_list_data(ctx);

+

+   if (ctx->Extensions.String)

+      free((void *) ctx->Extensions.String);

+

+   if (ctx->VersionString)

+      free(ctx->VersionString);

+

+   /* unbind the context if it's currently bound */

+   if (ctx == _mesa_get_current_context()) {

+      _mesa_make_current(NULL, NULL, NULL);

+   }

+}

+

+

+/**

+ * Destroy a struct gl_context structure.

+ *

+ * \param ctx GL context.

+ * 

+ * Calls _mesa_free_context_data() and frees the gl_context object itself.

+ */

+void

+_mesa_destroy_context( struct gl_context *ctx )

+{

+   if (ctx) {

+      _mesa_free_context_data(ctx);

+      free( (void *) ctx );

+   }

+}

+

+

+#if _HAVE_FULL_GL

+/**

+ * Copy attribute groups from one context to another.

+ * 

+ * \param src source context

+ * \param dst destination context

+ * \param mask bitwise OR of GL_*_BIT flags

+ *

+ * According to the bits specified in \p mask, copies the corresponding

+ * attributes from \p src into \p dst.  For many of the attributes a simple \c

+ * memcpy is not enough due to the existence of internal pointers in their data

+ * structures.

+ */

+void

+_mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask )

+{

+   if (mask & GL_ACCUM_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Accum = src->Accum;

+   }

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Color = src->Color;

+   }

+   if (mask & GL_CURRENT_BIT) {

+      /* OK to memcpy */

+      dst->Current = src->Current;

+   }

+   if (mask & GL_DEPTH_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Depth = src->Depth;

+   }

+   if (mask & GL_ENABLE_BIT) {

+      /* no op */

+   }

+   if (mask & GL_EVAL_BIT) {

+      /* OK to memcpy */

+      dst->Eval = src->Eval;

+   }

+   if (mask & GL_FOG_BIT) {

+      /* OK to memcpy */

+      dst->Fog = src->Fog;

+   }

+   if (mask & GL_HINT_BIT) {

+      /* OK to memcpy */

+      dst->Hint = src->Hint;

+   }

+   if (mask & GL_LIGHTING_BIT) {

+      GLuint i;

+      /* begin with memcpy */

+      dst->Light = src->Light;

+      /* fixup linked lists to prevent pointer insanity */

+      make_empty_list( &(dst->Light.EnabledList) );

+      for (i = 0; i < MAX_LIGHTS; i++) {

+         if (dst->Light.Light[i].Enabled) {

+            insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));

+         }

+      }

+   }

+   if (mask & GL_LINE_BIT) {

+      /* OK to memcpy */

+      dst->Line = src->Line;

+   }

+   if (mask & GL_LIST_BIT) {

+      /* OK to memcpy */

+      dst->List = src->List;

+   }

+   if (mask & GL_PIXEL_MODE_BIT) {

+      /* OK to memcpy */

+      dst->Pixel = src->Pixel;

+   }

+   if (mask & GL_POINT_BIT) {

+      /* OK to memcpy */

+      dst->Point = src->Point;

+   }

+   if (mask & GL_POLYGON_BIT) {

+      /* OK to memcpy */

+      dst->Polygon = src->Polygon;

+   }

+   if (mask & GL_POLYGON_STIPPLE_BIT) {

+      /* Use loop instead of memcpy due to problem with Portland Group's

+       * C compiler.  Reported by John Stone.

+       */

+      GLuint i;

+      for (i = 0; i < 32; i++) {

+         dst->PolygonStipple[i] = src->PolygonStipple[i];

+      }

+   }

+   if (mask & GL_SCISSOR_BIT) {

+      /* OK to memcpy */

+      dst->Scissor = src->Scissor;

+   }

+   if (mask & GL_STENCIL_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Stencil = src->Stencil;

+   }

+   if (mask & GL_TEXTURE_BIT) {

+      /* Cannot memcpy because of pointers */

+      _mesa_copy_texture_state(src, dst);

+   }

+   if (mask & GL_TRANSFORM_BIT) {

+      /* OK to memcpy */

+      dst->Transform = src->Transform;

+   }

+   if (mask & GL_VIEWPORT_BIT) {

+      /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */

+      dst->Viewport.X = src->Viewport.X;

+      dst->Viewport.Y = src->Viewport.Y;

+      dst->Viewport.Width = src->Viewport.Width;

+      dst->Viewport.Height = src->Viewport.Height;

+      dst->Viewport.Near = src->Viewport.Near;

+      dst->Viewport.Far = src->Viewport.Far;

+      _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);

+   }

+

+   /* XXX FIXME:  Call callbacks?

+    */

+   dst->NewState = _NEW_ALL;

+}

+#endif

+

+

+/**

+ * Check if the given context can render into the given framebuffer

+ * by checking visual attributes.

+ *

+ * Most of these tests could go away because Mesa is now pretty flexible

+ * in terms of mixing rendering contexts with framebuffers.  As long

+ * as RGB vs. CI mode agree, we're probably good.

+ *

+ * \return GL_TRUE if compatible, GL_FALSE otherwise.

+ */

+static GLboolean 

+check_compatible(const struct gl_context *ctx,

+                 const struct gl_framebuffer *buffer)

+{

+   const struct gl_config *ctxvis = &ctx->Visual;

+   const struct gl_config *bufvis = &buffer->Visual;

+

+   if (buffer == _mesa_get_incomplete_framebuffer())

+      return GL_TRUE;

+

+#if 0

+   /* disabling this fixes the fgl_glxgears pbuffer demo */

+   if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)

+      return GL_FALSE;

+#endif

+   if (ctxvis->stereoMode && !bufvis->stereoMode)

+      return GL_FALSE;

+   if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)

+      return GL_FALSE;

+   if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)

+      return GL_FALSE;

+   if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)

+      return GL_FALSE;

+   if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)

+      return GL_FALSE;

+   if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)

+      return GL_FALSE;

+   if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)

+      return GL_FALSE;

+#if 0

+   /* disabled (see bug 11161) */

+   if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)

+      return GL_FALSE;

+#endif

+   if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do one-time initialization for the given framebuffer.  Specifically,

+ * ask the driver for the window's current size and update the framebuffer

+ * object to match.

+ * Really, the device driver should totally take care of this.

+ */

+static void

+initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   GLuint width, height;

+   if (ctx->Driver.GetBufferSize) {

+      ctx->Driver.GetBufferSize(fb, &width, &height);

+      if (ctx->Driver.ResizeBuffers)

+         ctx->Driver.ResizeBuffers(ctx, fb, width, height);

+      fb->Initialized = GL_TRUE;

+   }

+}

+

+

+/**

+ * Check if the viewport/scissor size has not yet been initialized.

+ * Initialize the size if the given width and height are non-zero.

+ */

+void

+_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)

+{

+   if (!ctx->ViewportInitialized && width > 0 && height > 0) {

+      /* Note: set flag here, before calling _mesa_set_viewport(), to prevent

+       * potential infinite recursion.

+       */

+      ctx->ViewportInitialized = GL_TRUE;

+      _mesa_set_viewport(ctx, 0, 0, width, height);

+      _mesa_set_scissor(ctx, 0, 0, width, height);

+   }

+}

+

+

+/**

+ * Bind the given context to the given drawBuffer and readBuffer and

+ * make it the current context for the calling thread.

+ * We'll render into the drawBuffer and read pixels from the

+ * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).

+ *

+ * We check that the context's and framebuffer's visuals are compatible

+ * and return immediately if they're not.

+ *

+ * \param newCtx  the new GL context. If NULL then there will be no current GL

+ *                context.

+ * \param drawBuffer  the drawing framebuffer

+ * \param readBuffer  the reading framebuffer

+ */

+GLboolean

+_mesa_make_current( struct gl_context *newCtx,

+                    struct gl_framebuffer *drawBuffer,

+                    struct gl_framebuffer *readBuffer )

+{

+   GET_CURRENT_CONTEXT(curCtx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(newCtx, "_mesa_make_current()\n");

+

+   /* Check that the context's and framebuffer's visuals are compatible.

+    */

+   if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {

+      if (!check_compatible(newCtx, drawBuffer)) {

+         _mesa_warning(newCtx,

+              "MakeCurrent: incompatible visuals for context and drawbuffer");

+         return GL_FALSE;

+      }

+   }

+   if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {

+      if (!check_compatible(newCtx, readBuffer)) {

+         _mesa_warning(newCtx,

+              "MakeCurrent: incompatible visuals for context and readbuffer");

+         return GL_FALSE;

+      }

+   }

+

+   if (curCtx && 

+      (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */

+      curCtx != newCtx)

+      _mesa_flush(curCtx);

+

+   /* We used to call _glapi_check_multithread() here.  Now do it in drivers */

+   _glapi_set_context((void *) newCtx);

+   ASSERT(_mesa_get_current_context() == newCtx);

+

+   if (!newCtx) {

+      _glapi_set_dispatch(NULL);  /* none current */

+   }

+   else {

+      _glapi_set_dispatch(newCtx->CurrentDispatch);

+

+      if (drawBuffer && readBuffer) {

+	 /* TODO: check if newCtx and buffer's visual match??? */

+

+         ASSERT(drawBuffer->Name == 0);

+         ASSERT(readBuffer->Name == 0);

+         _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);

+         _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);

+

+         /*

+          * Only set the context's Draw/ReadBuffer fields if they're NULL

+          * or not bound to a user-created FBO.

+          */

+         if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {

+            /* KW: merge conflict here, revisit. 

+             */

+            /* fix up the fb fields - these will end up wrong otherwise

+             * if the DRIdrawable changes, and everything relies on them.

+             * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)

+             */

+            unsigned int i;

+            GLenum buffers[MAX_DRAW_BUFFERS];

+

+            _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);

+

+            for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {

+               buffers[i] = newCtx->Color.DrawBuffer[i];

+            }

+

+            _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers,

+                              buffers, NULL);

+         }

+         if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {

+            _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);

+         }

+

+         /* XXX only set this flag if we're really changing the draw/read

+          * framebuffer bindings.

+          */

+	 newCtx->NewState |= _NEW_BUFFERS;

+

+#if 1

+         /* We want to get rid of these lines: */

+

+#if _HAVE_FULL_GL

+         if (!drawBuffer->Initialized) {

+            initialize_framebuffer_size(newCtx, drawBuffer);

+         }

+         if (readBuffer != drawBuffer && !readBuffer->Initialized) {

+            initialize_framebuffer_size(newCtx, readBuffer);

+         }

+

+	 _mesa_resizebuffers(newCtx);

+#endif

+

+#else

+         /* We want the drawBuffer and readBuffer to be initialized by

+          * the driver.

+          * This generally means the Width and Height match the actual

+          * window size and the renderbuffers (both hardware and software

+          * based) are allocated to match.  The later can generally be

+          * done with a call to _mesa_resize_framebuffer().

+          *

+          * It's theoretically possible for a buffer to have zero width

+          * or height, but for now, assert check that the driver did what's

+          * expected of it.

+          */

+         ASSERT(drawBuffer->Width > 0);

+         ASSERT(drawBuffer->Height > 0);

+#endif

+

+         if (drawBuffer) {

+            _mesa_check_init_viewport(newCtx,

+                                      drawBuffer->Width, drawBuffer->Height);

+         }

+      }

+

+      if (newCtx->FirstTimeCurrent) {

+         _mesa_compute_version(newCtx);

+

+         newCtx->Extensions.String = _mesa_make_extension_string(newCtx);

+

+         check_context_limits(newCtx);

+

+         /* We can use this to help debug user's problems.  Tell them to set

+          * the MESA_INFO env variable before running their app.  Then the

+          * first time each context is made current we'll print some useful

+          * information.

+          */

+	 if (_mesa_getenv("MESA_INFO")) {

+	    _mesa_print_info();

+	 }

+

+	 newCtx->FirstTimeCurrent = GL_FALSE;

+      }

+   }

+   

+   return GL_TRUE;

+}

+

+

+/**

+ * Make context 'ctx' share the display lists, textures and programs

+ * that are associated with 'ctxToShare'.

+ * Any display lists, textures or programs associated with 'ctx' will

+ * be deleted if nobody else is sharing them.

+ */

+GLboolean

+_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)

+{

+   if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {

+      struct gl_shared_state *oldSharedState = ctx->Shared;

+

+      ctx->Shared = ctxToShare->Shared;

+      

+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+      ctx->Shared->RefCount++;

+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+

+      update_default_objects(ctx);

+

+      _mesa_release_shared_state(ctx, oldSharedState);

+

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * \return pointer to the current GL context for this thread.

+ * 

+ * Calls _glapi_get_context(). This isn't the fastest way to get the current

+ * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in

+ * context.h.

+ */

+struct gl_context *

+_mesa_get_current_context( void )

+{

+   return (struct gl_context *) _glapi_get_context();

+}

+

+

+/**

+ * Get context's current API dispatch table.

+ *

+ * It'll either be the immediate-mode execute dispatcher or the display list

+ * compile dispatcher.

+ * 

+ * \param ctx GL context.

+ *

+ * \return pointer to dispatch_table.

+ *

+ * Simply returns __struct gl_contextRec::CurrentDispatch.

+ */

+struct _glapi_table *

+_mesa_get_dispatch(struct gl_context *ctx)

+{

+   return ctx->CurrentDispatch;

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Miscellaneous functions                                     */

+/**********************************************************************/

+/*@{*/

+

+/**

+ * Record an error.

+ *

+ * \param ctx GL context.

+ * \param error error code.

+ * 

+ * Records the given error code and call the driver's dd_function_table::Error

+ * function if defined.

+ *

+ * \sa

+ * This is called via _mesa_error().

+ */

+void

+_mesa_record_error(struct gl_context *ctx, GLenum error)

+{

+   if (!ctx)

+      return;

+

+   if (ctx->ErrorValue == GL_NO_ERROR) {

+      ctx->ErrorValue = error;

+   }

+

+   /* Call device driver's error handler, if any.  This is used on the Mac. */

+   if (ctx->Driver.Error) {

+      ctx->Driver.Error(ctx);

+   }

+}

+

+

+/**

+ * Flush commands and wait for completion.

+ */

+void

+_mesa_finish(struct gl_context *ctx)

+{

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Finish) {

+      ctx->Driver.Finish(ctx);

+   }

+}

+

+

+/**

+ * Flush commands.

+ */

+void

+_mesa_flush(struct gl_context *ctx)

+{

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Flush) {

+      ctx->Driver.Flush(ctx);

+   }

+}

+

+

+

+/**

+ * Execute glFinish().

+ *

+ * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the

+ * dd_function_table::Finish driver callback, if not NULL.

+ */

+void GLAPIENTRY

+_mesa_Finish(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_finish(ctx);

+}

+

+

+/**

+ * Execute glFlush().

+ *

+ * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the

+ * dd_function_table::Flush driver callback, if not NULL.

+ */

+void GLAPIENTRY

+_mesa_Flush(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_flush(ctx);

+}

+

+

+/**

+ * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over

+ * MUL/MAD, or vice versa, call this function to register that.

+ * Otherwise we default to MUL/MAD.

+ */

+void

+_mesa_set_mvp_with_dp4( struct gl_context *ctx,

+                        GLboolean flag )

+{

+   ctx->mvp_with_dp4 = flag;

+}

+

+

+

+/**

+ * Prior to drawing anything with glBegin, glDrawArrays, etc. this function

+ * is called to see if it's valid to render.  This involves checking that

+ * the current shader is valid and the framebuffer is complete.

+ * If an error is detected it'll be recorded here.

+ * \return GL_TRUE if OK to render, GL_FALSE if not

+ */

+GLboolean

+_mesa_valid_to_render(struct gl_context *ctx, const char *where)

+{

+   bool vert_from_glsl_shader = false;

+   bool geom_from_glsl_shader = false;

+   bool frag_from_glsl_shader = false;

+

+   /* This depends on having up to date derived state (shaders) */

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   if (ctx->Shader.CurrentVertexProgram) {

+      vert_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentVertexProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentVertexProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   if (ctx->Shader.CurrentGeometryProgram) {

+      geom_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentGeometryProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentGeometryProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   if (ctx->Shader.CurrentFragmentProgram) {

+      frag_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentFragmentProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentFragmentProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   /* Any shader stages that are not supplied by the GLSL shader and have

+    * assembly shaders enabled must now be validated.

+    */

+   if (!vert_from_glsl_shader

+       && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+		  "%s(vertex program not valid)", where);

+      return GL_FALSE;

+   }

+

+   /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current

+    * FINISHME: geometry program should validated here.

+    */

+   (void) geom_from_glsl_shader;

+

+   if (!frag_from_glsl_shader) {

+      if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {

+	 _mesa_error(ctx, GL_INVALID_OPERATION,

+		     "%s(fragment program not valid)", where);

+	 return GL_FALSE;

+      }

+

+      /* If drawing to integer-valued color buffers, there must be an

+       * active fragment shader (GL_EXT_texture_integer).

+       */

+      if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(integer format but no fragment shader)", where);

+         return GL_FALSE;

+      }

+   }

+

+   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                  "%s(incomplete framebuffer)", where);

+      return GL_FALSE;

+   }

+

+#ifdef DEBUG

+   if (ctx->Shader.Flags & GLSL_LOG) {

+      struct gl_shader_program *shProg[MESA_SHADER_TYPES];

+      gl_shader_type i;

+

+      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;

+      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;

+      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;

+

+      for (i = 0; i < MESA_SHADER_TYPES; i++) {

+	 struct gl_shader *sh;

+

+	 if (shProg[i] == NULL || shProg[i]->_Used

+	     || shProg[i]->_LinkedShaders[i] == NULL)

+	    continue;

+

+	 /* This is the first time this shader is being used.

+	  * Append shader's constants/uniforms to log file.

+	  *

+	  * The logic is a little odd here.  We only want to log data for each

+	  * shader target that will actually be used, and we only want to log

+	  * it once.  It's possible to have a program bound to the vertex

+	  * shader target that also supplied a fragment shader.  If that

+	  * program isn't also bound to the fragment shader target we don't

+	  * want to log its fragment data.

+	  */

+	 sh = shProg[i]->_LinkedShaders[i];

+	 switch (sh->Type) {

+	 case GL_VERTEX_SHADER:

+	    _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base);

+	    break;

+

+	 case GL_GEOMETRY_SHADER_ARB:

+	    _mesa_append_uniforms_to_file(sh,

+					  &shProg[i]->GeometryProgram->Base);

+	    break;

+

+	 case GL_FRAGMENT_SHADER:

+	    _mesa_append_uniforms_to_file(sh,

+					  &shProg[i]->FragmentProgram->Base);

+	    break;

+	 }

+      }

+

+      for (i = 0; i < MESA_SHADER_TYPES; i++) {

+	 if (shProg[i] != NULL)

+	    shProg[i]->_Used = GL_TRUE;

+      }

+   }

+#endif

+

+   return GL_TRUE;

+}

+

+

+/*@}*/

diff --git a/mesalib/src/mesa/main/context.h b/mesalib/src/mesa/main/context.h
index 4e391dde4..160e795f7 100644
--- a/mesalib/src/mesa/main/context.h
+++ b/mesalib/src/mesa/main/context.h
@@ -1,313 +1,313 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file context.h
- * Mesa context and visual-related functions.
- *
- * There are three large Mesa data types/classes which are meant to be
- * used by device drivers:
- * - struct gl_context: this contains the Mesa rendering state
- * - struct gl_config:  this describes the color buffer (RGB vs. ci), whether or not
- *   there's a depth buffer, stencil buffer, etc.
- * - struct gl_framebuffer:  contains pointers to the depth buffer, stencil buffer,
- *   accum buffer and alpha buffers.
- *
- * These types should be encapsulated by corresponding device driver
- * data types.  See xmesa.h and xmesaP.h for an example.
- *
- * In OOP terms, struct gl_context, struct gl_config, and struct gl_framebuffer are base classes
- * which the device driver must derive from.
- *
- * The following functions create and destroy these data types.
- */
-
-
-#ifndef CONTEXT_H
-#define CONTEXT_H
-
-
-#include "imports.h"
-#include "mtypes.h"
-
-
-struct _glapi_table;
-
-
-/** \name Visual-related functions */
-/*@{*/
- 
-extern struct gl_config *
-_mesa_create_visual( GLboolean dbFlag,
-                     GLboolean stereoFlag,
-                     GLint redBits,
-                     GLint greenBits,
-                     GLint blueBits,
-                     GLint alphaBits,
-                     GLint depthBits,
-                     GLint stencilBits,
-                     GLint accumRedBits,
-                     GLint accumGreenBits,
-                     GLint accumBlueBits,
-                     GLint accumAlphaBits,
-                     GLint numSamples );
-
-extern GLboolean
-_mesa_initialize_visual( struct gl_config *v,
-                         GLboolean dbFlag,
-                         GLboolean stereoFlag,
-                         GLint redBits,
-                         GLint greenBits,
-                         GLint blueBits,
-                         GLint alphaBits,
-                         GLint depthBits,
-                         GLint stencilBits,
-                         GLint accumRedBits,
-                         GLint accumGreenBits,
-                         GLint accumBlueBits,
-                         GLint accumAlphaBits,
-                         GLint numSamples );
-
-extern void
-_mesa_destroy_visual( struct gl_config *vis );
-
-/*@}*/
-
-
-/** \name Context-related functions */
-/*@{*/
-
-extern GLboolean
-_mesa_initialize_context( struct gl_context *ctx,
-                          gl_api api,
-                          const struct gl_config *visual,
-                          struct gl_context *share_list,
-                          const struct dd_function_table *driverFunctions,
-                          void *driverContext );
-
-extern struct gl_context *
-_mesa_create_context(gl_api api,
-                     const struct gl_config *visual,
-                     struct gl_context *share_list,
-                     const struct dd_function_table *driverFunctions,
-                     void *driverContext);
-
-extern void
-_mesa_free_context_data( struct gl_context *ctx );
-
-extern void
-_mesa_destroy_context( struct gl_context *ctx );
-
-
-extern void
-_mesa_copy_context(const struct gl_context *src, struct gl_context *dst, GLuint mask);
-
-
-extern void
-_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height);
-
-extern GLboolean
-_mesa_make_current( struct gl_context *ctx, struct gl_framebuffer *drawBuffer,
-                    struct gl_framebuffer *readBuffer );
-
-extern GLboolean
-_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare);
-
-extern struct gl_context *
-_mesa_get_current_context(void);
-
-/*@}*/
-
-extern void
-_mesa_init_get_hash(struct gl_context *ctx);
-
-extern void
-_mesa_notifySwapBuffers(struct gl_context *gc);
-
-
-extern struct _glapi_table *
-_mesa_get_dispatch(struct gl_context *ctx);
-
-
-void
-_mesa_set_mvp_with_dp4( struct gl_context *ctx,
-                        GLboolean flag );
-
-
-extern GLboolean
-_mesa_valid_to_render(struct gl_context *ctx, const char *where);
-
-
-
-/** \name Miscellaneous */
-/*@{*/
-
-extern void
-_mesa_record_error( struct gl_context *ctx, GLenum error );
-
-
-extern void
-_mesa_finish(struct gl_context *ctx);
-
-extern void
-_mesa_flush(struct gl_context *ctx);
-
-
-extern void GLAPIENTRY
-_mesa_Finish( void );
-
-extern void GLAPIENTRY
-_mesa_Flush( void );
-
-/*@}*/
-
-
-/**
- * \name Macros for flushing buffered rendering commands before state changes,
- * checking if inside glBegin/glEnd, etc.
- */
-/*@{*/
-
-/**
- * Flush vertices.
- *
- * \param ctx GL context.
- * \param newstate new state.
- *
- * Checks if dd_function_table::NeedFlush is marked to flush stored vertices,
- * and calls dd_function_table::FlushVertices if so. Marks
- * __struct gl_contextRec::NewState with \p newstate.
- */
-#define FLUSH_VERTICES(ctx, newstate)				\
-do {								\
-   if (MESA_VERBOSE & VERBOSE_STATE)				\
-      _mesa_debug(ctx, "FLUSH_VERTICES in %s\n", MESA_FUNCTION);\
-   if (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES)		\
-      ctx->Driver.FlushVertices(ctx, FLUSH_STORED_VERTICES);	\
-   ctx->NewState |= newstate;					\
-} while (0)
-
-/**
- * Flush current state.
- *
- * \param ctx GL context.
- * \param newstate new state.
- *
- * Checks if dd_function_table::NeedFlush is marked to flush current state,
- * and calls dd_function_table::FlushVertices if so. Marks
- * __struct gl_contextRec::NewState with \p newstate.
- */
-#define FLUSH_CURRENT(ctx, newstate)				\
-do {								\
-   if (MESA_VERBOSE & VERBOSE_STATE)				\
-      _mesa_debug(ctx, "FLUSH_CURRENT in %s\n", MESA_FUNCTION);	\
-   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)		\
-      ctx->Driver.FlushVertices(ctx, FLUSH_UPDATE_CURRENT);	\
-   ctx->NewState |= newstate;					\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
-do {									\
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
-      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\
-      return retval;							\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_BEGIN_END(ctx)					\
-do {									\
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
-      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\
-      return;								\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx)				\
-do {									\
-   ASSERT_OUTSIDE_BEGIN_END(ctx);					\
-   FLUSH_VERTICES(ctx, 0);						\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)	\
-do {									\
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval);			\
-   FLUSH_VERTICES(ctx, 0);						\
-} while (0)
-
-/*@}*/
-
-
-
-/**
- * Is the secondary color needed?
- */
-#define NEED_SECONDARY_COLOR(CTX)					\
-   (((CTX)->Light.Enabled &&						\
-     (CTX)->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)	\
-    || (CTX)->Fog.ColorSumEnabled					\
-    || ((CTX)->VertexProgram._Current &&				\
-        ((CTX)->VertexProgram._Current != (CTX)->VertexProgram._TnlProgram) &&    \
-        ((CTX)->VertexProgram._Current->Base.InputsRead & VERT_BIT_COLOR1)) \
-    || ((CTX)->FragmentProgram._Current &&				\
-        ((CTX)->FragmentProgram._Current != (CTX)->FragmentProgram._TexEnvProgram) &&  \
-        ((CTX)->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL1)) \
-   )
-
-
-/**
- * Is RGBA LogicOp enabled?
- */
-#define RGBA_LOGICOP_ENABLED(CTX) \
-  ((CTX)->Color.ColorLogicOpEnabled || \
-   ((CTX)->Color.BlendEnabled && (CTX)->Color.Blend[0].EquationRGB == GL_LOGIC_OP))
-
-
-#endif /* CONTEXT_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file context.h

+ * Mesa context and visual-related functions.

+ *

+ * There are three large Mesa data types/classes which are meant to be

+ * used by device drivers:

+ * - struct gl_context: this contains the Mesa rendering state

+ * - struct gl_config:  this describes the color buffer (RGB vs. ci), whether or not

+ *   there's a depth buffer, stencil buffer, etc.

+ * - struct gl_framebuffer:  contains pointers to the depth buffer, stencil buffer,

+ *   accum buffer and alpha buffers.

+ *

+ * These types should be encapsulated by corresponding device driver

+ * data types.  See xmesa.h and xmesaP.h for an example.

+ *

+ * In OOP terms, struct gl_context, struct gl_config, and struct gl_framebuffer are base classes

+ * which the device driver must derive from.

+ *

+ * The following functions create and destroy these data types.

+ */

+

+

+#ifndef CONTEXT_H

+#define CONTEXT_H

+

+

+#include "imports.h"

+#include "mtypes.h"

+

+

+struct _glapi_table;

+

+

+/** \name Visual-related functions */

+/*@{*/

+ 

+extern struct gl_config *

+_mesa_create_visual( GLboolean dbFlag,

+                     GLboolean stereoFlag,

+                     GLint redBits,

+                     GLint greenBits,

+                     GLint blueBits,

+                     GLint alphaBits,

+                     GLint depthBits,

+                     GLint stencilBits,

+                     GLint accumRedBits,

+                     GLint accumGreenBits,

+                     GLint accumBlueBits,

+                     GLint accumAlphaBits,

+                     GLint numSamples );

+

+extern GLboolean

+_mesa_initialize_visual( struct gl_config *v,

+                         GLboolean dbFlag,

+                         GLboolean stereoFlag,

+                         GLint redBits,

+                         GLint greenBits,

+                         GLint blueBits,

+                         GLint alphaBits,

+                         GLint depthBits,

+                         GLint stencilBits,

+                         GLint accumRedBits,

+                         GLint accumGreenBits,

+                         GLint accumBlueBits,

+                         GLint accumAlphaBits,

+                         GLint numSamples );

+

+extern void

+_mesa_destroy_visual( struct gl_config *vis );

+

+/*@}*/

+

+

+/** \name Context-related functions */

+/*@{*/

+

+extern GLboolean

+_mesa_initialize_context( struct gl_context *ctx,

+                          gl_api api,

+                          const struct gl_config *visual,

+                          struct gl_context *share_list,

+                          const struct dd_function_table *driverFunctions,

+                          void *driverContext );

+

+extern struct gl_context *

+_mesa_create_context(gl_api api,

+                     const struct gl_config *visual,

+                     struct gl_context *share_list,

+                     const struct dd_function_table *driverFunctions,

+                     void *driverContext);

+

+extern void

+_mesa_free_context_data( struct gl_context *ctx );

+

+extern void

+_mesa_destroy_context( struct gl_context *ctx );

+

+

+extern void

+_mesa_copy_context(const struct gl_context *src, struct gl_context *dst, GLuint mask);

+

+

+extern void

+_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height);

+

+extern GLboolean

+_mesa_make_current( struct gl_context *ctx, struct gl_framebuffer *drawBuffer,

+                    struct gl_framebuffer *readBuffer );

+

+extern GLboolean

+_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare);

+

+extern struct gl_context *

+_mesa_get_current_context(void);

+

+/*@}*/

+

+extern void

+_mesa_init_get_hash(struct gl_context *ctx);

+

+extern void

+_mesa_notifySwapBuffers(struct gl_context *gc);

+

+

+extern struct _glapi_table *

+_mesa_get_dispatch(struct gl_context *ctx);

+

+

+void

+_mesa_set_mvp_with_dp4( struct gl_context *ctx,

+                        GLboolean flag );

+

+

+extern GLboolean

+_mesa_valid_to_render(struct gl_context *ctx, const char *where);

+

+

+

+/** \name Miscellaneous */

+/*@{*/

+

+extern void

+_mesa_record_error( struct gl_context *ctx, GLenum error );

+

+

+extern void

+_mesa_finish(struct gl_context *ctx);

+

+extern void

+_mesa_flush(struct gl_context *ctx);

+

+

+extern void GLAPIENTRY

+_mesa_Finish( void );

+

+extern void GLAPIENTRY

+_mesa_Flush( void );

+

+/*@}*/

+

+

+/**

+ * \name Macros for flushing buffered rendering commands before state changes,

+ * checking if inside glBegin/glEnd, etc.

+ */

+/*@{*/

+

+/**

+ * Flush vertices.

+ *

+ * \param ctx GL context.

+ * \param newstate new state.

+ *

+ * Checks if dd_function_table::NeedFlush is marked to flush stored vertices,

+ * and calls dd_function_table::FlushVertices if so. Marks

+ * __struct gl_contextRec::NewState with \p newstate.

+ */

+#define FLUSH_VERTICES(ctx, newstate)				\

+do {								\

+   if (MESA_VERBOSE & VERBOSE_STATE)				\

+      _mesa_debug(ctx, "FLUSH_VERTICES in %s\n", MESA_FUNCTION);\

+   if (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES)		\

+      ctx->Driver.FlushVertices(ctx, FLUSH_STORED_VERTICES);	\

+   ctx->NewState |= newstate;					\

+} while (0)

+

+/**

+ * Flush current state.

+ *

+ * \param ctx GL context.

+ * \param newstate new state.

+ *

+ * Checks if dd_function_table::NeedFlush is marked to flush current state,

+ * and calls dd_function_table::FlushVertices if so. Marks

+ * __struct gl_contextRec::NewState with \p newstate.

+ */

+#define FLUSH_CURRENT(ctx, newstate)				\

+do {								\

+   if (MESA_VERBOSE & VERBOSE_STATE)				\

+      _mesa_debug(ctx, "FLUSH_CURRENT in %s\n", MESA_FUNCTION);	\

+   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)		\

+      ctx->Driver.FlushVertices(ctx, FLUSH_UPDATE_CURRENT);	\

+   ctx->NewState |= newstate;					\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval)		\

+do {									\

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\

+      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\

+      return retval;							\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END(ctx)					\

+do {									\

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\

+      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\

+      return;								\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx)				\

+do {									\

+   ASSERT_OUTSIDE_BEGIN_END(ctx);					\

+   FLUSH_VERTICES(ctx, 0);						\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)	\

+do {									\

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval);			\

+   FLUSH_VERTICES(ctx, 0);						\

+} while (0)

+

+/*@}*/

+

+

+

+/**

+ * Is the secondary color needed?

+ */

+#define NEED_SECONDARY_COLOR(CTX)					\

+   (((CTX)->Light.Enabled &&						\

+     (CTX)->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)	\

+    || (CTX)->Fog.ColorSumEnabled					\

+    || ((CTX)->VertexProgram._Current &&				\

+        ((CTX)->VertexProgram._Current != (CTX)->VertexProgram._TnlProgram) &&    \

+        ((CTX)->VertexProgram._Current->Base.InputsRead & VERT_BIT_COLOR1)) \

+    || ((CTX)->FragmentProgram._Current &&				\

+        ((CTX)->FragmentProgram._Current != (CTX)->FragmentProgram._TexEnvProgram) &&  \

+        ((CTX)->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL1)) \

+   )

+

+

+/**

+ * Is RGBA LogicOp enabled?

+ */

+#define RGBA_LOGICOP_ENABLED(CTX) \

+  ((CTX)->Color.ColorLogicOpEnabled || \

+   ((CTX)->Color.BlendEnabled && (CTX)->Color.Blend[0].EquationRGB == GL_LOGIC_OP))

+

+

+#endif /* CONTEXT_H */

diff --git a/mesalib/src/mesa/main/depth.c b/mesalib/src/mesa/main/depth.c
index 52c69a6bc..d666ed5fe 100644
--- a/mesalib/src/mesa/main/depth.c
+++ b/mesalib/src/mesa/main/depth.c
@@ -1,174 +1,174 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "context.h"
-#include "depth.h"
-#include "enums.h"
-#include "macros.h"
-#include "mtypes.h"
-
-
-/**********************************************************************/
-/*****                          API Functions                     *****/
-/**********************************************************************/
-
-
-
-void GLAPIENTRY
-_mesa_ClearDepth( GLclampd depth )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glClearDepth(%f)\n", depth);
-
-   depth = CLAMP( depth, 0.0, 1.0 );
-
-   if (ctx->Depth.Clear == depth)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-   ctx->Depth.Clear = depth;
-   if (ctx->Driver.ClearDepth)
-      (*ctx->Driver.ClearDepth)( ctx, ctx->Depth.Clear );
-}
-
-
-void GLAPIENTRY
-_mesa_ClearDepthf( GLclampf depth )
-{
-   _mesa_ClearDepth(depth);
-}
-
-
-void GLAPIENTRY
-_mesa_DepthFunc( GLenum func )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDepthFunc %s\n", _mesa_lookup_enum_by_nr(func));
-
-   switch (func) {
-   case GL_LESS:    /* (default) pass if incoming z < stored z */
-   case GL_GEQUAL:
-   case GL_LEQUAL:
-   case GL_GREATER:
-   case GL_NOTEQUAL:
-   case GL_EQUAL:
-   case GL_ALWAYS:
-   case GL_NEVER:
-      break;
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
-      return;
-   }
-
-   if (ctx->Depth.Func == func)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-   ctx->Depth.Func = func;
-
-   if (ctx->Driver.DepthFunc)
-      ctx->Driver.DepthFunc( ctx, func );
-}
-
-
-
-void GLAPIENTRY
-_mesa_DepthMask( GLboolean flag )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDepthMask %d\n", flag);
-
-   /*
-    * GL_TRUE indicates depth buffer writing is enabled (default)
-    * GL_FALSE indicates depth buffer writing is disabled
-    */
-   if (ctx->Depth.Mask == flag)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-   ctx->Depth.Mask = flag;
-
-   if (ctx->Driver.DepthMask)
-      ctx->Driver.DepthMask( ctx, flag );
-}
-
-
-
-/**
- * Specified by the GL_EXT_depth_bounds_test extension.
- */
-void GLAPIENTRY
-_mesa_DepthBoundsEXT( GLclampd zmin, GLclampd zmax )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDepthBounds(%f, %f)\n", zmin, zmax);
-
-   if (zmin > zmax) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDepthBoundsEXT(zmin > zmax)");
-      return;
-   }
-
-   zmin = CLAMP(zmin, 0.0, 1.0);
-   zmax = CLAMP(zmax, 0.0, 1.0);
-
-   if (ctx->Depth.BoundsMin == zmin && ctx->Depth.BoundsMax == zmax)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-   ctx->Depth.BoundsMin = (GLfloat) zmin;
-   ctx->Depth.BoundsMax = (GLfloat) zmax;
-}
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-
-/**
- * Initialize the depth buffer attribute group in the given context.
- */
-void
-_mesa_init_depth(struct gl_context *ctx)
-{
-   ctx->Depth.Test = GL_FALSE;
-   ctx->Depth.Clear = 1.0;
-   ctx->Depth.Func = GL_LESS;
-   ctx->Depth.Mask = GL_TRUE;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "context.h"

+#include "depth.h"

+#include "enums.h"

+#include "macros.h"

+#include "mtypes.h"

+

+

+/**********************************************************************/

+/*****                          API Functions                     *****/

+/**********************************************************************/

+

+

+

+void GLAPIENTRY

+_mesa_ClearDepth( GLclampd depth )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glClearDepth(%f)\n", depth);

+

+   depth = CLAMP( depth, 0.0, 1.0 );

+

+   if (ctx->Depth.Clear == depth)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+   ctx->Depth.Clear = depth;

+   if (ctx->Driver.ClearDepth)

+      (*ctx->Driver.ClearDepth)( ctx, ctx->Depth.Clear );

+}

+

+

+void GLAPIENTRY

+_mesa_ClearDepthf( GLclampf depth )

+{

+   _mesa_ClearDepth(depth);

+}

+

+

+void GLAPIENTRY

+_mesa_DepthFunc( GLenum func )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDepthFunc %s\n", _mesa_lookup_enum_by_nr(func));

+

+   switch (func) {

+   case GL_LESS:    /* (default) pass if incoming z < stored z */

+   case GL_GEQUAL:

+   case GL_LEQUAL:

+   case GL_GREATER:

+   case GL_NOTEQUAL:

+   case GL_EQUAL:

+   case GL_ALWAYS:

+   case GL_NEVER:

+      break;

+   default:

+      _mesa_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );

+      return;

+   }

+

+   if (ctx->Depth.Func == func)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+   ctx->Depth.Func = func;

+

+   if (ctx->Driver.DepthFunc)

+      ctx->Driver.DepthFunc( ctx, func );

+}

+

+

+

+void GLAPIENTRY

+_mesa_DepthMask( GLboolean flag )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDepthMask %d\n", flag);

+

+   /*

+    * GL_TRUE indicates depth buffer writing is enabled (default)

+    * GL_FALSE indicates depth buffer writing is disabled

+    */

+   if (ctx->Depth.Mask == flag)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+   ctx->Depth.Mask = flag;

+

+   if (ctx->Driver.DepthMask)

+      ctx->Driver.DepthMask( ctx, flag );

+}

+

+

+

+/**

+ * Specified by the GL_EXT_depth_bounds_test extension.

+ */

+void GLAPIENTRY

+_mesa_DepthBoundsEXT( GLclampd zmin, GLclampd zmax )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDepthBounds(%f, %f)\n", zmin, zmax);

+

+   if (zmin > zmax) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDepthBoundsEXT(zmin > zmax)");

+      return;

+   }

+

+   zmin = CLAMP(zmin, 0.0, 1.0);

+   zmax = CLAMP(zmax, 0.0, 1.0);

+

+   if (ctx->Depth.BoundsMin == zmin && ctx->Depth.BoundsMax == zmax)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+   ctx->Depth.BoundsMin = (GLfloat) zmin;

+   ctx->Depth.BoundsMax = (GLfloat) zmax;

+}

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+

+/**

+ * Initialize the depth buffer attribute group in the given context.

+ */

+void

+_mesa_init_depth(struct gl_context *ctx)

+{

+   ctx->Depth.Test = GL_FALSE;

+   ctx->Depth.Clear = 1.0;

+   ctx->Depth.Func = GL_LESS;

+   ctx->Depth.Mask = GL_TRUE;

+}

diff --git a/mesalib/src/mesa/main/dlist.c b/mesalib/src/mesa/main/dlist.c
index 4e463dd06..e910296ed 100644
--- a/mesalib/src/mesa/main/dlist.c
+++ b/mesalib/src/mesa/main/dlist.c
@@ -1,10333 +1,10333 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file dlist.c
- * Display lists management functions.
- */
-
-#include "glheader.h"
-#include "imports.h"
-#include "api_arrayelt.h"
-#include "api_exec.h"
-#include "api_loopback.h"
-#if FEATURE_ATI_fragment_shader
-#include "atifragshader.h"
-#endif
-#include "config.h"
-#include "mfeatures.h"
-#if FEATURE_ARB_vertex_buffer_object
-#include "bufferobj.h"
-#endif
-#include "arrayobj.h"
-#include "context.h"
-#include "dlist.h"
-#include "enums.h"
-#include "eval.h"
-#include "framebuffer.h"
-#include "glapi/glapi.h"
-#include "hash.h"
-#include "image.h"
-#include "light.h"
-#include "macros.h"
-#include "pack.h"
-#include "pbo.h"
-#include "queryobj.h"
-#include "teximage.h"
-#include "mtypes.h"
-#include "varray.h"
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-#include "arbprogram.h"
-#endif
-#if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
-#include "nvprogram.h"
-#endif
-
-#include "math/m_matrix.h"
-
-#include "main/dispatch.h"
-
-
-
-/**
- * Other parts of Mesa (such as the VBO module) can plug into the display
- * list system.  This structure describes new display list instructions.
- */
-struct gl_list_instruction
-{
-   GLuint Size;
-   void (*Execute)( struct gl_context *ctx, void *data );
-   void (*Destroy)( struct gl_context *ctx, void *data );
-   void (*Print)( struct gl_context *ctx, void *data );
-};
-
-
-#define MAX_DLIST_EXT_OPCODES 16
-
-/**
- * Used by device drivers to hook new commands into display lists.
- */
-struct gl_list_extensions
-{
-   struct gl_list_instruction Opcode[MAX_DLIST_EXT_OPCODES];
-   GLuint NumOpcodes;
-};
-
-
-
-/**
- * Flush vertices.
- *
- * \param ctx GL context.
- *
- * Checks if dd_function_table::SaveNeedFlush is marked to flush
- * stored (save) vertices, and calls
- * dd_function_table::SaveFlushVertices if so.
- */
-#define SAVE_FLUSH_VERTICES(ctx)		\
-do {						\
-   if (ctx->Driver.SaveNeedFlush)		\
-      ctx->Driver.SaveFlushVertices(ctx);	\
-} while (0)
-
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
-do {									\
-   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
-       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
-      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\
-      return retval;							\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx)				\
-do {									\
-   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
-       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
-      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\
-      return;								\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx)			\
-do {									\
-   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);					\
-   SAVE_FLUSH_VERTICES(ctx);						\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)\
-do {									\
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval);		\
-   SAVE_FLUSH_VERTICES(ctx);						\
-} while (0)
-
-
-
-/**
- * Display list opcodes.
- *
- * The fact that these identifiers are assigned consecutive
- * integer values starting at 0 is very important, see InstSize array usage)
- */
-typedef enum
-{
-   OPCODE_INVALID = -1,         /* Force signed enum */
-   OPCODE_ACCUM,
-   OPCODE_ALPHA_FUNC,
-   OPCODE_BIND_TEXTURE,
-   OPCODE_BITMAP,
-   OPCODE_BLEND_COLOR,
-   OPCODE_BLEND_EQUATION,
-   OPCODE_BLEND_EQUATION_SEPARATE,
-   OPCODE_BLEND_FUNC_SEPARATE,
-
-   OPCODE_BLEND_EQUATION_I,
-   OPCODE_BLEND_EQUATION_SEPARATE_I,
-   OPCODE_BLEND_FUNC_I,
-   OPCODE_BLEND_FUNC_SEPARATE_I,
-
-   OPCODE_CALL_LIST,
-   OPCODE_CALL_LIST_OFFSET,
-   OPCODE_CLEAR,
-   OPCODE_CLEAR_ACCUM,
-   OPCODE_CLEAR_COLOR,
-   OPCODE_CLEAR_DEPTH,
-   OPCODE_CLEAR_INDEX,
-   OPCODE_CLEAR_STENCIL,
-   OPCODE_CLEAR_BUFFER_IV,
-   OPCODE_CLEAR_BUFFER_UIV,
-   OPCODE_CLEAR_BUFFER_FV,
-   OPCODE_CLEAR_BUFFER_FI,
-   OPCODE_CLIP_PLANE,
-   OPCODE_COLOR_MASK,
-   OPCODE_COLOR_MASK_INDEXED,
-   OPCODE_COLOR_MATERIAL,
-   OPCODE_COLOR_TABLE,
-   OPCODE_COLOR_TABLE_PARAMETER_FV,
-   OPCODE_COLOR_TABLE_PARAMETER_IV,
-   OPCODE_COLOR_SUB_TABLE,
-   OPCODE_CONVOLUTION_FILTER_1D,
-   OPCODE_CONVOLUTION_FILTER_2D,
-   OPCODE_CONVOLUTION_PARAMETER_I,
-   OPCODE_CONVOLUTION_PARAMETER_IV,
-   OPCODE_CONVOLUTION_PARAMETER_F,
-   OPCODE_CONVOLUTION_PARAMETER_FV,
-   OPCODE_COPY_COLOR_SUB_TABLE,
-   OPCODE_COPY_COLOR_TABLE,
-   OPCODE_COPY_PIXELS,
-   OPCODE_COPY_TEX_IMAGE1D,
-   OPCODE_COPY_TEX_IMAGE2D,
-   OPCODE_COPY_TEX_SUB_IMAGE1D,
-   OPCODE_COPY_TEX_SUB_IMAGE2D,
-   OPCODE_COPY_TEX_SUB_IMAGE3D,
-   OPCODE_CULL_FACE,
-   OPCODE_DEPTH_FUNC,
-   OPCODE_DEPTH_MASK,
-   OPCODE_DEPTH_RANGE,
-   OPCODE_DISABLE,
-   OPCODE_DISABLE_INDEXED,
-   OPCODE_DRAW_BUFFER,
-   OPCODE_DRAW_PIXELS,
-   OPCODE_ENABLE,
-   OPCODE_ENABLE_INDEXED,
-   OPCODE_EVALMESH1,
-   OPCODE_EVALMESH2,
-   OPCODE_FOG,
-   OPCODE_FRONT_FACE,
-   OPCODE_FRUSTUM,
-   OPCODE_HINT,
-   OPCODE_HISTOGRAM,
-   OPCODE_INDEX_MASK,
-   OPCODE_INIT_NAMES,
-   OPCODE_LIGHT,
-   OPCODE_LIGHT_MODEL,
-   OPCODE_LINE_STIPPLE,
-   OPCODE_LINE_WIDTH,
-   OPCODE_LIST_BASE,
-   OPCODE_LOAD_IDENTITY,
-   OPCODE_LOAD_MATRIX,
-   OPCODE_LOAD_NAME,
-   OPCODE_LOGIC_OP,
-   OPCODE_MAP1,
-   OPCODE_MAP2,
-   OPCODE_MAPGRID1,
-   OPCODE_MAPGRID2,
-   OPCODE_MATRIX_MODE,
-   OPCODE_MIN_MAX,
-   OPCODE_MULT_MATRIX,
-   OPCODE_ORTHO,
-   OPCODE_PASSTHROUGH,
-   OPCODE_PIXEL_MAP,
-   OPCODE_PIXEL_TRANSFER,
-   OPCODE_PIXEL_ZOOM,
-   OPCODE_POINT_SIZE,
-   OPCODE_POINT_PARAMETERS,
-   OPCODE_POLYGON_MODE,
-   OPCODE_POLYGON_STIPPLE,
-   OPCODE_POLYGON_OFFSET,
-   OPCODE_POP_ATTRIB,
-   OPCODE_POP_MATRIX,
-   OPCODE_POP_NAME,
-   OPCODE_PRIORITIZE_TEXTURE,
-   OPCODE_PUSH_ATTRIB,
-   OPCODE_PUSH_MATRIX,
-   OPCODE_PUSH_NAME,
-   OPCODE_RASTER_POS,
-   OPCODE_READ_BUFFER,
-   OPCODE_RESET_HISTOGRAM,
-   OPCODE_RESET_MIN_MAX,
-   OPCODE_ROTATE,
-   OPCODE_SCALE,
-   OPCODE_SCISSOR,
-   OPCODE_SELECT_TEXTURE_SGIS,
-   OPCODE_SELECT_TEXTURE_COORD_SET,
-   OPCODE_SHADE_MODEL,
-   OPCODE_STENCIL_FUNC,
-   OPCODE_STENCIL_MASK,
-   OPCODE_STENCIL_OP,
-   OPCODE_TEXENV,
-   OPCODE_TEXGEN,
-   OPCODE_TEXPARAMETER,
-   OPCODE_TEX_IMAGE1D,
-   OPCODE_TEX_IMAGE2D,
-   OPCODE_TEX_IMAGE3D,
-   OPCODE_TEX_SUB_IMAGE1D,
-   OPCODE_TEX_SUB_IMAGE2D,
-   OPCODE_TEX_SUB_IMAGE3D,
-   OPCODE_TRANSLATE,
-   OPCODE_VIEWPORT,
-   OPCODE_WINDOW_POS,
-   /* GL_ARB_multitexture */
-   OPCODE_ACTIVE_TEXTURE,
-   /* GL_ARB_texture_compression */
-   OPCODE_COMPRESSED_TEX_IMAGE_1D,
-   OPCODE_COMPRESSED_TEX_IMAGE_2D,
-   OPCODE_COMPRESSED_TEX_IMAGE_3D,
-   OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
-   OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
-   OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
-   /* GL_ARB_multisample */
-   OPCODE_SAMPLE_COVERAGE,
-   /* GL_ARB_window_pos */
-   OPCODE_WINDOW_POS_ARB,
-   /* GL_NV_vertex_program */
-   OPCODE_BIND_PROGRAM_NV,
-   OPCODE_EXECUTE_PROGRAM_NV,
-   OPCODE_REQUEST_RESIDENT_PROGRAMS_NV,
-   OPCODE_LOAD_PROGRAM_NV,
-   OPCODE_TRACK_MATRIX_NV,
-   /* GL_NV_fragment_program */
-   OPCODE_PROGRAM_LOCAL_PARAMETER_ARB,
-   OPCODE_PROGRAM_NAMED_PARAMETER_NV,
-   /* GL_EXT_stencil_two_side */
-   OPCODE_ACTIVE_STENCIL_FACE_EXT,
-   /* GL_EXT_depth_bounds_test */
-   OPCODE_DEPTH_BOUNDS_EXT,
-   /* GL_ARB_vertex/fragment_program */
-   OPCODE_PROGRAM_STRING_ARB,
-   OPCODE_PROGRAM_ENV_PARAMETER_ARB,
-   /* GL_ARB_occlusion_query */
-   OPCODE_BEGIN_QUERY_ARB,
-   OPCODE_END_QUERY_ARB,
-   /* GL_ARB_draw_buffers */
-   OPCODE_DRAW_BUFFERS_ARB,
-   /* GL_ATI_fragment_shader */
-   OPCODE_TEX_BUMP_PARAMETER_ATI,
-   /* GL_ATI_fragment_shader */
-   OPCODE_BIND_FRAGMENT_SHADER_ATI,
-   OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,
-   /* OpenGL 2.0 */
-   OPCODE_STENCIL_FUNC_SEPARATE,
-   OPCODE_STENCIL_OP_SEPARATE,
-   OPCODE_STENCIL_MASK_SEPARATE,
-
-   /* GL_ARB_shader_objects */
-   OPCODE_USE_PROGRAM,
-   OPCODE_UNIFORM_1F,
-   OPCODE_UNIFORM_2F,
-   OPCODE_UNIFORM_3F,
-   OPCODE_UNIFORM_4F,
-   OPCODE_UNIFORM_1FV,
-   OPCODE_UNIFORM_2FV,
-   OPCODE_UNIFORM_3FV,
-   OPCODE_UNIFORM_4FV,
-   OPCODE_UNIFORM_1I,
-   OPCODE_UNIFORM_2I,
-   OPCODE_UNIFORM_3I,
-   OPCODE_UNIFORM_4I,
-   OPCODE_UNIFORM_1IV,
-   OPCODE_UNIFORM_2IV,
-   OPCODE_UNIFORM_3IV,
-   OPCODE_UNIFORM_4IV,
-   OPCODE_UNIFORM_MATRIX22,
-   OPCODE_UNIFORM_MATRIX33,
-   OPCODE_UNIFORM_MATRIX44,
-   OPCODE_UNIFORM_MATRIX23,
-   OPCODE_UNIFORM_MATRIX32,
-   OPCODE_UNIFORM_MATRIX24,
-   OPCODE_UNIFORM_MATRIX42,
-   OPCODE_UNIFORM_MATRIX34,
-   OPCODE_UNIFORM_MATRIX43,
-
-   /* OpenGL 3.0 */
-   OPCODE_UNIFORM_1UI,
-   OPCODE_UNIFORM_2UI,
-   OPCODE_UNIFORM_3UI,
-   OPCODE_UNIFORM_4UI,
-   OPCODE_UNIFORM_1UIV,
-   OPCODE_UNIFORM_2UIV,
-   OPCODE_UNIFORM_3UIV,
-   OPCODE_UNIFORM_4UIV,
-
-   /* GL_EXT_framebuffer_blit */
-   OPCODE_BLIT_FRAMEBUFFER,
-
-   /* Vertex attributes -- fallback for when optimized display
-    * list build isn't active.
-    */
-   OPCODE_ATTR_1F_NV,
-   OPCODE_ATTR_2F_NV,
-   OPCODE_ATTR_3F_NV,
-   OPCODE_ATTR_4F_NV,
-   OPCODE_ATTR_1F_ARB,
-   OPCODE_ATTR_2F_ARB,
-   OPCODE_ATTR_3F_ARB,
-   OPCODE_ATTR_4F_ARB,
-   OPCODE_MATERIAL,
-   OPCODE_BEGIN,
-   OPCODE_END,
-   OPCODE_RECTF,
-   OPCODE_EVAL_C1,
-   OPCODE_EVAL_C2,
-   OPCODE_EVAL_P1,
-   OPCODE_EVAL_P2,
-
-   /* GL_EXT_provoking_vertex */
-   OPCODE_PROVOKING_VERTEX,
-
-   /* GL_EXT_transform_feedback */
-   OPCODE_BEGIN_TRANSFORM_FEEDBACK,
-   OPCODE_END_TRANSFORM_FEEDBACK,
-
-   /* GL_EXT_texture_integer */
-   OPCODE_CLEARCOLOR_I,
-   OPCODE_CLEARCOLOR_UI,
-   OPCODE_TEXPARAMETER_I,
-   OPCODE_TEXPARAMETER_UI,
-
-   /* GL_EXT_separate_shader_objects */
-   OPCODE_ACTIVE_PROGRAM_EXT,
-   OPCODE_USE_SHADER_PROGRAM_EXT,
-
-   /* GL_ARB_instanced_arrays */
-   OPCODE_VERTEX_ATTRIB_DIVISOR,
-
-   /* The following three are meta instructions */
-   OPCODE_ERROR,                /* raise compiled-in error */
-   OPCODE_CONTINUE,
-   OPCODE_END_OF_LIST,
-   OPCODE_EXT_0
-} OpCode;
-
-
-
-/**
- * Display list node.
- *
- * Display list instructions are stored as sequences of "nodes".  Nodes
- * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks
- * are linked together with a pointer.
- *
- * Each instruction in the display list is stored as a sequence of
- * contiguous nodes in memory.
- * Each node is the union of a variety of data types.
- */
-union gl_dlist_node
-{
-   OpCode opcode;
-   GLboolean b;
-   GLbitfield bf;
-   GLubyte ub;
-   GLshort s;
-   GLushort us;
-   GLint i;
-   GLuint ui;
-   GLenum e;
-   GLfloat f;
-   GLvoid *data;
-   void *next;                  /* If prev node's opcode==OPCODE_CONTINUE */
-};
-
-
-typedef union gl_dlist_node Node;
-
-
-/**
- * How many nodes to allocate at a time.
- *
- * \note Reduced now that we hold vertices etc. elsewhere.
- */
-#define BLOCK_SIZE 256
-
-
-
-/**
- * Number of nodes of storage needed for each instruction.
- * Sizes for dynamically allocated opcodes are stored in the context struct.
- */
-static GLuint InstSize[OPCODE_END_OF_LIST + 1];
-
-
-#if FEATURE_dlist
-
-
-void mesa_print_display_list(GLuint list);
-
-
-/**********************************************************************/
-/*****                           Private                          *****/
-/**********************************************************************/
-
-
-/**
- * Make an empty display list.  This is used by glGenLists() to
- * reserve display list IDs.
- */
-static struct gl_display_list *
-make_list(GLuint name, GLuint count)
-{
-   struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);
-   dlist->Name = name;
-   dlist->Head = (Node *) malloc(sizeof(Node) * count);
-   dlist->Head[0].opcode = OPCODE_END_OF_LIST;
-   return dlist;
-}
-
-
-/**
- * Lookup function to just encapsulate casting.
- */
-static INLINE struct gl_display_list *
-lookup_list(struct gl_context *ctx, GLuint list)
-{
-   return (struct gl_display_list *)
-      _mesa_HashLookup(ctx->Shared->DisplayList, list);
-}
-
-
-/** Is the given opcode an extension code? */
-static INLINE GLboolean
-is_ext_opcode(OpCode opcode)
-{
-   return (opcode >= OPCODE_EXT_0);
-}
-
-
-/** Destroy an extended opcode instruction */
-static GLint
-ext_opcode_destroy(struct gl_context *ctx, Node *node)
-{
-   const GLint i = node[0].opcode - OPCODE_EXT_0;
-   GLint step;
-   ctx->ListExt->Opcode[i].Destroy(ctx, &node[1]);
-   step = ctx->ListExt->Opcode[i].Size;
-   return step;
-}
-
-
-/** Execute an extended opcode instruction */
-static GLint
-ext_opcode_execute(struct gl_context *ctx, Node *node)
-{
-   const GLint i = node[0].opcode - OPCODE_EXT_0;
-   GLint step;
-   ctx->ListExt->Opcode[i].Execute(ctx, &node[1]);
-   step = ctx->ListExt->Opcode[i].Size;
-   return step;
-}
-
-
-/** Print an extended opcode instruction */
-static GLint
-ext_opcode_print(struct gl_context *ctx, Node *node)
-{
-   const GLint i = node[0].opcode - OPCODE_EXT_0;
-   GLint step;
-   ctx->ListExt->Opcode[i].Print(ctx, &node[1]);
-   step = ctx->ListExt->Opcode[i].Size;
-   return step;
-}
-
-
-/**
- * Delete the named display list, but don't remove from hash table.
- * \param dlist - display list pointer
- */
-void
-_mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)
-{
-   Node *n, *block;
-   GLboolean done;
-
-   n = block = dlist->Head;
-
-   done = block ? GL_FALSE : GL_TRUE;
-   while (!done) {
-      const OpCode opcode = n[0].opcode;
-
-      /* check for extension opcodes first */
-      if (is_ext_opcode(opcode)) {
-         n += ext_opcode_destroy(ctx, n);
-      }
-      else {
-         switch (opcode) {
-            /* for some commands, we need to free malloc'd memory */
-         case OPCODE_MAP1:
-            free(n[6].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_MAP2:
-            free(n[10].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_DRAW_PIXELS:
-            free(n[5].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_BITMAP:
-            free(n[7].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COLOR_TABLE:
-            free(n[6].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COLOR_SUB_TABLE:
-            free(n[6].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_CONVOLUTION_FILTER_1D:
-            free(n[6].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_CONVOLUTION_FILTER_2D:
-            free(n[7].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_POLYGON_STIPPLE:
-            free(n[1].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_IMAGE1D:
-            free(n[8].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_IMAGE2D:
-            free(n[9].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_IMAGE3D:
-            free(n[10].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_SUB_IMAGE1D:
-            free(n[7].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_SUB_IMAGE2D:
-            free(n[9].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_TEX_SUB_IMAGE3D:
-            free(n[11].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_1D:
-            free(n[7].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_2D:
-            free(n[8].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_3D:
-            free(n[9].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
-            free(n[7].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
-            free(n[9].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
-            free(n[11].data);
-            n += InstSize[n[0].opcode];
-            break;
-#if FEATURE_NV_vertex_program
-         case OPCODE_LOAD_PROGRAM_NV:
-            free(n[4].data);      /* program string */
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
-            free(n[2].data);      /* array of program ids */
-            n += InstSize[n[0].opcode];
-            break;
-#endif
-#if FEATURE_NV_fragment_program
-         case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
-            free(n[3].data);      /* parameter name */
-            n += InstSize[n[0].opcode];
-            break;
-#endif
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-         case OPCODE_PROGRAM_STRING_ARB:
-            free(n[4].data);      /* program string */
-            n += InstSize[n[0].opcode];
-            break;
-#endif
-         case OPCODE_UNIFORM_1FV:
-         case OPCODE_UNIFORM_2FV:
-         case OPCODE_UNIFORM_3FV:
-         case OPCODE_UNIFORM_4FV:
-         case OPCODE_UNIFORM_1IV:
-         case OPCODE_UNIFORM_2IV:
-         case OPCODE_UNIFORM_3IV:
-         case OPCODE_UNIFORM_4IV:
-         case OPCODE_UNIFORM_1UIV:
-         case OPCODE_UNIFORM_2UIV:
-         case OPCODE_UNIFORM_3UIV:
-         case OPCODE_UNIFORM_4UIV:
-            free(n[3].data);
-            n += InstSize[n[0].opcode];
-            break;
-         case OPCODE_UNIFORM_MATRIX22:
-         case OPCODE_UNIFORM_MATRIX33:
-         case OPCODE_UNIFORM_MATRIX44:
-         case OPCODE_UNIFORM_MATRIX24:
-         case OPCODE_UNIFORM_MATRIX42:
-         case OPCODE_UNIFORM_MATRIX23:
-         case OPCODE_UNIFORM_MATRIX32:
-         case OPCODE_UNIFORM_MATRIX34:
-         case OPCODE_UNIFORM_MATRIX43:
-            free(n[4].data);
-            n += InstSize[n[0].opcode];
-            break;
-
-         case OPCODE_CONTINUE:
-            n = (Node *) n[1].next;
-            free(block);
-            block = n;
-            break;
-         case OPCODE_END_OF_LIST:
-            free(block);
-            done = GL_TRUE;
-            break;
-         default:
-            /* Most frequent case */
-            n += InstSize[n[0].opcode];
-            break;
-         }
-      }
-   }
-
-   free(dlist);
-}
-
-
-/**
- * Destroy a display list and remove from hash table.
- * \param list - display list number
- */
-static void
-destroy_list(struct gl_context *ctx, GLuint list)
-{
-   struct gl_display_list *dlist;
-
-   if (list == 0)
-      return;
-
-   dlist = lookup_list(ctx, list);
-   if (!dlist)
-      return;
-
-   _mesa_delete_list(ctx, dlist);
-   _mesa_HashRemove(ctx->Shared->DisplayList, list);
-}
-
-
-/*
- * Translate the nth element of list from <type> to GLint.
- */
-static GLint
-translate_id(GLsizei n, GLenum type, const GLvoid * list)
-{
-   GLbyte *bptr;
-   GLubyte *ubptr;
-   GLshort *sptr;
-   GLushort *usptr;
-   GLint *iptr;
-   GLuint *uiptr;
-   GLfloat *fptr;
-
-   switch (type) {
-   case GL_BYTE:
-      bptr = (GLbyte *) list;
-      return (GLint) bptr[n];
-   case GL_UNSIGNED_BYTE:
-      ubptr = (GLubyte *) list;
-      return (GLint) ubptr[n];
-   case GL_SHORT:
-      sptr = (GLshort *) list;
-      return (GLint) sptr[n];
-   case GL_UNSIGNED_SHORT:
-      usptr = (GLushort *) list;
-      return (GLint) usptr[n];
-   case GL_INT:
-      iptr = (GLint *) list;
-      return iptr[n];
-   case GL_UNSIGNED_INT:
-      uiptr = (GLuint *) list;
-      return (GLint) uiptr[n];
-   case GL_FLOAT:
-      fptr = (GLfloat *) list;
-      return (GLint) FLOORF(fptr[n]);
-   case GL_2_BYTES:
-      ubptr = ((GLubyte *) list) + 2 * n;
-      return (GLint) ubptr[0] * 256
-           + (GLint) ubptr[1];
-   case GL_3_BYTES:
-      ubptr = ((GLubyte *) list) + 3 * n;
-      return (GLint) ubptr[0] * 65536
-           + (GLint) ubptr[1] * 256
-           + (GLint) ubptr[2];
-   case GL_4_BYTES:
-      ubptr = ((GLubyte *) list) + 4 * n;
-      return (GLint) ubptr[0] * 16777216
-           + (GLint) ubptr[1] * 65536
-           + (GLint) ubptr[2] * 256
-           + (GLint) ubptr[3];
-   default:
-      return 0;
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*****                        Public                              *****/
-/**********************************************************************/
-
-/**
- * Wrapper for _mesa_unpack_image() that handles pixel buffer objects.
- * If we run out of memory, GL_OUT_OF_MEMORY will be recorded.
- */
-static GLvoid *
-unpack_image(struct gl_context *ctx, GLuint dimensions,
-             GLsizei width, GLsizei height, GLsizei depth,
-             GLenum format, GLenum type, const GLvoid * pixels,
-             const struct gl_pixelstore_attrib *unpack)
-{
-   if (!_mesa_is_bufferobj(unpack->BufferObj)) {
-      /* no PBO */
-      GLvoid *image = _mesa_unpack_image(dimensions, width, height, depth,
-                                         format, type, pixels, unpack);
-      if (pixels && !image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
-      }
-      return image;
-   }
-   else if (_mesa_validate_pbo_access(dimensions, unpack, width, height, depth,
-                                      format, type, pixels)) {
-      const GLubyte *map, *src;
-      GLvoid *image;
-
-      map = (GLubyte *)
-         ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                               GL_READ_ONLY_ARB, unpack->BufferObj);
-      if (!map) {
-         /* unable to map src buffer! */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");
-         return NULL;
-      }
-
-      src = ADD_POINTERS(map, pixels);
-      image = _mesa_unpack_image(dimensions, width, height, depth,
-                                 format, type, src, unpack);
-
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              unpack->BufferObj);
-
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
-      }
-      return image;
-   }
-   /* bad access! */
-   return NULL;
-}
-
-
-/**
- * Allocate space for a display list instruction (opcode + payload space).
- * \param opcode  the instruction opcode (OPCODE_* value)
- * \param bytes   instruction payload size (not counting opcode)
- * \return pointer to allocated memory (the opcode space)
- */
-static Node *
-dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes)
-{
-   const GLuint numNodes = 1 + (bytes + sizeof(Node) - 1) / sizeof(Node);
-   Node *n;
-
-   if (opcode < (GLuint) OPCODE_EXT_0) {
-      if (InstSize[opcode] == 0) {
-         /* save instruction size now */
-         InstSize[opcode] = numNodes;
-      }
-      else {
-         /* make sure instruction size agrees */
-         ASSERT(numNodes == InstSize[opcode]);
-      }
-   }
-
-   if (ctx->ListState.CurrentPos + numNodes + 2 > BLOCK_SIZE) {
-      /* This block is full.  Allocate a new block and chain to it */
-      Node *newblock;
-      n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
-      n[0].opcode = OPCODE_CONTINUE;
-      newblock = (Node *) malloc(sizeof(Node) * BLOCK_SIZE);
-      if (!newblock) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
-         return NULL;
-      }
-      n[1].next = (Node *) newblock;
-      ctx->ListState.CurrentBlock = newblock;
-      ctx->ListState.CurrentPos = 0;
-   }
-
-   n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
-   ctx->ListState.CurrentPos += numNodes;
-
-   n[0].opcode = opcode;
-
-   return n;
-}
-
-
-
-/**
- * Allocate space for a display list instruction.  Used by callers outside
- * this file for things like VBO vertex data.
- *
- * \param opcode  the instruction opcode (OPCODE_* value)
- * \param bytes   instruction size in bytes, not counting opcode.
- * \return pointer to the usable data area (not including the internal
- *         opcode).
- */
-void *
-_mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint bytes)
-{
-   Node *n = dlist_alloc(ctx, (OpCode) opcode, bytes);
-   if (n)
-      return n + 1;  /* return pointer to payload area, after opcode */
-   else
-      return NULL;
-}
-
-
-/**
- * This function allows modules and drivers to get their own opcodes
- * for extending display list functionality.
- * \param ctx  the rendering context
- * \param size  number of bytes for storing the new display list command
- * \param execute  function to execute the new display list command
- * \param destroy  function to destroy the new display list command
- * \param print  function to print the new display list command
- * \return  the new opcode number or -1 if error
- */
-GLint
-_mesa_dlist_alloc_opcode(struct gl_context *ctx,
-                         GLuint size,
-                         void (*execute) (struct gl_context *, void *),
-                         void (*destroy) (struct gl_context *, void *),
-                         void (*print) (struct gl_context *, void *))
-{
-   if (ctx->ListExt->NumOpcodes < MAX_DLIST_EXT_OPCODES) {
-      const GLuint i = ctx->ListExt->NumOpcodes++;
-      ctx->ListExt->Opcode[i].Size =
-         1 + (size + sizeof(Node) - 1) / sizeof(Node);
-      ctx->ListExt->Opcode[i].Execute = execute;
-      ctx->ListExt->Opcode[i].Destroy = destroy;
-      ctx->ListExt->Opcode[i].Print = print;
-      return i + OPCODE_EXT_0;
-   }
-   return -1;
-}
-
-
-/**
- * Allocate space for a display list instruction.  The space is basically
- * an array of Nodes where node[0] holds the opcode, node[1] is the first
- * function parameter, node[2] is the second parameter, etc.
- *
- * \param opcode  one of OPCODE_x
- * \param nparams  number of function parameters
- * \return  pointer to start of instruction space
- */
-static INLINE Node *
-alloc_instruction(struct gl_context *ctx, OpCode opcode, GLuint nparams)
-{
-   return dlist_alloc(ctx, opcode, nparams * sizeof(Node));
-}
-
-
-
-/*
- * Display List compilation functions
- */
-static void GLAPIENTRY
-save_Accum(GLenum op, GLfloat value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ACCUM, 2);
-   if (n) {
-      n[1].e = op;
-      n[2].f = value;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Accum(ctx->Exec, (op, value));
-   }
-}
-
-
-static void GLAPIENTRY
-save_AlphaFunc(GLenum func, GLclampf ref)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ALPHA_FUNC, 2);
-   if (n) {
-      n[1].e = func;
-      n[2].f = (GLfloat) ref;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_AlphaFunc(ctx->Exec, (func, ref));
-   }
-}
-
-
-static void GLAPIENTRY
-save_BindTexture(GLenum target, GLuint texture)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BIND_TEXTURE, 2);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = texture;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BindTexture(ctx->Exec, (target, texture));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Bitmap(GLsizei width, GLsizei height,
-            GLfloat xorig, GLfloat yorig,
-            GLfloat xmove, GLfloat ymove, const GLubyte * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BITMAP, 7);
-   if (n) {
-      n[1].i = (GLint) width;
-      n[2].i = (GLint) height;
-      n[3].f = xorig;
-      n[4].f = yorig;
-      n[5].f = xmove;
-      n[6].f = ymove;
-      n[7].data = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Bitmap(ctx->Exec, (width, height,
-                              xorig, yorig, xmove, ymove, pixels));
-   }
-}
-
-
-static void GLAPIENTRY
-save_BlendEquation(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendEquation(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);
-   if (n) {
-      n[1].e = modeRGB;
-      n[2].e = modeA;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendEquationSeparateEXT(ctx->Exec, (modeRGB, modeA));
-   }
-}
-
-
-static void GLAPIENTRY
-save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
-                          GLenum sfactorA, GLenum dfactorA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);
-   if (n) {
-      n[1].e = sfactorRGB;
-      n[2].e = dfactorRGB;
-      n[3].e = sfactorA;
-      n[4].e = dfactorA;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendFuncSeparateEXT(ctx->Exec,
-                                (sfactorRGB, dfactorRGB, sfactorA, dfactorA));
-   }
-}
-
-
-static void GLAPIENTRY
-save_BlendFunc(GLenum srcfactor, GLenum dstfactor)
-{
-   save_BlendFuncSeparateEXT(srcfactor, dstfactor, srcfactor, dstfactor);
-}
-
-
-static void GLAPIENTRY
-save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_COLOR, 4);
-   if (n) {
-      n[1].f = red;
-      n[2].f = green;
-      n[3].f = blue;
-      n[4].f = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-/* GL_ARB_draw_buffers_blend */
-static void GLAPIENTRY
-save_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
-                        GLenum sfactorA, GLenum dfactorA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 5);
-   if (n) {
-      n[1].ui = buf;
-      n[2].e = sfactorRGB;
-      n[3].e = dfactorRGB;
-      n[4].e = sfactorA;
-      n[5].e = dfactorA;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendFuncSeparateiARB(ctx->Exec, (buf, sfactorRGB, dfactorRGB,
-                                             sfactorA, dfactorA));
-   }
-}
-
-/* GL_ARB_draw_buffers_blend */
-static void GLAPIENTRY
-save_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 3);
-   if (n) {
-      n[1].ui = buf;
-      n[2].e = sfactor;
-      n[3].e = dfactor;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendFunciARB(ctx->Exec, (buf, sfactor, dfactor));
-   }
-}
-
-/* GL_ARB_draw_buffers_blend */
-static void GLAPIENTRY
-save_BlendEquationi(GLuint buf, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_I, 2);
-   if (n) {
-      n[1].ui = buf;
-      n[2].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendEquationiARB(ctx->Exec, (buf, mode));
-   }
-}
-
-/* GL_ARB_draw_buffers_blend */
-static void GLAPIENTRY
-save_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE_I, 3);
-   if (n) {
-      n[1].ui = buf;
-      n[2].e = modeRGB;
-      n[3].e = modeA;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlendEquationSeparateiARB(ctx->Exec, (buf, modeRGB, modeA));
-   }
-}
-
-
-static void invalidate_saved_current_state( struct gl_context *ctx )
-{
-   GLint i;
-
-   for (i = 0; i < VERT_ATTRIB_MAX; i++)
-      ctx->ListState.ActiveAttribSize[i] = 0;
-
-   for (i = 0; i < MAT_ATTRIB_MAX; i++)
-      ctx->ListState.ActiveMaterialSize[i] = 0;
-
-   memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);
-
-   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
-}
-
-static void GLAPIENTRY
-save_CallList(GLuint list)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_CALL_LIST, 1);
-   if (n) {
-      n[1].ui = list;
-   }
-
-   /* After this, we don't know what state we're in.  Invalidate all
-    * cached information previously gathered:
-    */
-   invalidate_saved_current_state( ctx );
-
-   if (ctx->ExecuteFlag) {
-      _mesa_CallList(list);
-   }
-}
-
-
-static void GLAPIENTRY
-save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   GLboolean typeErrorFlag;
-
-   SAVE_FLUSH_VERTICES(ctx);
-
-   switch (type) {
-   case GL_BYTE:
-   case GL_UNSIGNED_BYTE:
-   case GL_SHORT:
-   case GL_UNSIGNED_SHORT:
-   case GL_INT:
-   case GL_UNSIGNED_INT:
-   case GL_FLOAT:
-   case GL_2_BYTES:
-   case GL_3_BYTES:
-   case GL_4_BYTES:
-      typeErrorFlag = GL_FALSE;
-      break;
-   default:
-      typeErrorFlag = GL_TRUE;
-   }
-
-   for (i = 0; i < num; i++) {
-      GLint list = translate_id(i, type, lists);
-      Node *n = alloc_instruction(ctx, OPCODE_CALL_LIST_OFFSET, 2);
-      if (n) {
-         n[1].i = list;
-         n[2].b = typeErrorFlag;
-      }
-   }
-
-   /* After this, we don't know what state we're in.  Invalidate all
-    * cached information previously gathered:
-    */
-   invalidate_saved_current_state( ctx );
-
-   if (ctx->ExecuteFlag) {
-      CALL_CallLists(ctx->Exec, (num, type, lists));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Clear(GLbitfield mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR, 1);
-   if (n) {
-      n[1].bf = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Clear(ctx->Exec, (mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_IV, 6);
-   if (n) {
-      n[1].e = buffer;
-      n[2].i = drawbuffer;
-      n[3].i = value[0];
-      if (buffer == GL_COLOR) {
-         n[4].i = value[1];
-         n[5].i = value[2];
-         n[6].i = value[3];
-      }
-      else {
-         n[4].i = 0;
-         n[5].i = 0;
-         n[6].i = 0;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ClearBufferiv(ctx->Exec, (buffer, drawbuffer, value));*/
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_UIV, 6);
-   if (n) {
-      n[1].e = buffer;
-      n[2].i = drawbuffer;
-      n[3].ui = value[0];
-      if (buffer == GL_COLOR) {
-         n[4].ui = value[1];
-         n[5].ui = value[2];
-         n[6].ui = value[3];
-      }
-      else {
-         n[4].ui = 0;
-         n[5].ui = 0;
-         n[6].ui = 0;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));*/
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FV, 6);
-   if (n) {
-      n[1].e = buffer;
-      n[2].i = drawbuffer;
-      n[3].f = value[0];
-      if (buffer == GL_COLOR) {
-         n[4].f = value[1];
-         n[5].f = value[2];
-         n[6].f = value[3];
-      }
-      else {
-         n[4].f = 0.0F;
-         n[5].f = 0.0F;
-         n[6].f = 0.0F;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));*/
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearBufferfi(GLenum buffer, GLint drawbuffer,
-                   GLfloat depth, GLint stencil)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FI, 4);
-   if (n) {
-      n[1].e = buffer;
-      n[2].i = drawbuffer;
-      n[3].f = depth;
-      n[4].i = stencil;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ClearBufferfi(ctx->Exec, (buffer, drawbuffer, depth, stencil));*/
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_ACCUM, 4);
-   if (n) {
-      n[1].f = red;
-      n[2].f = green;
-      n[3].f = blue;
-      n[4].f = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_COLOR, 4);
-   if (n) {
-      n[1].f = red;
-      n[2].f = green;
-      n[3].f = blue;
-      n[4].f = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearDepth(GLclampd depth)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_DEPTH, 1);
-   if (n) {
-      n[1].f = (GLfloat) depth;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearDepth(ctx->Exec, (depth));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearIndex(GLfloat c)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_INDEX, 1);
-   if (n) {
-      n[1].f = c;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearIndex(ctx->Exec, (c));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClearStencil(GLint s)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEAR_STENCIL, 1);
-   if (n) {
-      n[1].i = s;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearStencil(ctx->Exec, (s));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ClipPlane(GLenum plane, const GLdouble * equ)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLIP_PLANE, 5);
-   if (n) {
-      n[1].e = plane;
-      n[2].f = (GLfloat) equ[0];
-      n[3].f = (GLfloat) equ[1];
-      n[4].f = (GLfloat) equ[2];
-      n[5].f = (GLfloat) equ[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClipPlane(ctx->Exec, (plane, equ));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_ColorMask(GLboolean red, GLboolean green,
-               GLboolean blue, GLboolean alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COLOR_MASK, 4);
-   if (n) {
-      n[1].b = red;
-      n[2].b = green;
-      n[3].b = blue;
-      n[4].b = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ColorMaskIndexed(GLuint buf, GLboolean red, GLboolean green,
-                      GLboolean blue, GLboolean alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COLOR_MASK_INDEXED, 5);
-   if (n) {
-      n[1].ui = buf;
-      n[2].b = red;
-      n[3].b = green;
-      n[4].b = blue;
-      n[5].b = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ColorMaskIndexedEXT(ctx->Exec, (buf, red, green, blue, alpha));*/
-   }
-}
-
-
-static void GLAPIENTRY
-save_ColorMaterial(GLenum face, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_COLOR_MATERIAL, 2);
-   if (n) {
-      n[1].e = face;
-      n[2].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ColorMaterial(ctx->Exec, (face, mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ColorTable(GLenum target, GLenum internalFormat,
-                GLsizei width, GLenum format, GLenum type,
-                const GLvoid * table)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (_mesa_is_proxy_texture(target)) {
-      /* execute immediately */
-      CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
-                                  format, type, table));
-   }
-   else {
-      Node *n;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      n = alloc_instruction(ctx, OPCODE_COLOR_TABLE, 6);
-      if (n) {
-         n[1].e = target;
-         n[2].e = internalFormat;
-         n[3].i = width;
-         n[4].e = format;
-         n[5].e = type;
-         n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, table,
-                                  &ctx->Unpack);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
-                                     format, type, table));
-      }
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_ColorTableParameterfv(GLenum target, GLenum pname,
-                           const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].f = params[0];
-      if (pname == GL_COLOR_TABLE_SGI ||
-          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
-          pname == GL_TEXTURE_COLOR_TABLE_SGI) {
-         n[4].f = params[1];
-         n[5].f = params[2];
-         n[6].f = params[3];
-      }
-   }
-
-   if (ctx->ExecuteFlag) {
-      CALL_ColorTableParameterfv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].i = params[0];
-      if (pname == GL_COLOR_TABLE_SGI ||
-          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
-          pname == GL_TEXTURE_COLOR_TABLE_SGI) {
-         n[4].i = params[1];
-         n[5].i = params[2];
-         n[6].i = params[3];
-      }
-   }
-
-   if (ctx->ExecuteFlag) {
-      CALL_ColorTableParameteriv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,
-                   GLenum format, GLenum type, const GLvoid * table)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COLOR_SUB_TABLE, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].i = start;
-      n[3].i = count;
-      n[4].e = format;
-      n[5].e = type;
-      n[6].data = unpack_image(ctx, 1, count, 1, 1, format, type, table,
-                               &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ColorSubTable(ctx->Exec,
-                         (target, start, count, format, type, table));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyColorSubTable(GLenum target, GLsizei start,
-                       GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5);
-   if (n) {
-      n[1].e = target;
-      n[2].i = start;
-      n[3].i = x;
-      n[4].i = y;
-      n[5].i = width;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyColorSubTable(ctx->Exec, (target, start, x, y, width));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyColorTable(GLenum target, GLenum internalformat,
-                    GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_COLOR_TABLE, 5);
-   if (n) {
-      n[1].e = target;
-      n[2].e = internalformat;
-      n[3].i = x;
-      n[4].i = y;
-      n[5].i = width;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyColorTable(ctx->Exec, (target, internalformat, x, y, width));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
-                         GLenum format, GLenum type, const GLvoid * filter)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_1D, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = internalFormat;
-      n[3].i = width;
-      n[4].e = format;
-      n[5].e = type;
-      n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, filter,
-                               &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionFilter1D(ctx->Exec, (target, internalFormat, width,
-                                           format, type, filter));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
-                         GLsizei width, GLsizei height, GLenum format,
-                         GLenum type, const GLvoid * filter)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_2D, 7);
-   if (n) {
-      n[1].e = target;
-      n[2].e = internalFormat;
-      n[3].i = width;
-      n[4].i = height;
-      n[5].e = format;
-      n[6].e = type;
-      n[7].data = unpack_image(ctx, 2, width, height, 1, format, type, filter,
-                               &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionFilter2D(ctx->Exec,
-                               (target, internalFormat, width, height, format,
-                                type, filter));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].i = param;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionParameteri(ctx->Exec, (target, pname, param));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].i = params[0];
-      if (pname == GL_CONVOLUTION_BORDER_COLOR ||
-          pname == GL_CONVOLUTION_FILTER_SCALE ||
-          pname == GL_CONVOLUTION_FILTER_BIAS) {
-         n[4].i = params[1];
-         n[5].i = params[2];
-         n[6].i = params[3];
-      }
-      else {
-         n[4].i = n[5].i = n[6].i = 0;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionParameteriv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].f = param;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionParameterf(ctx->Exec, (target, pname, param));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ConvolutionParameterfv(GLenum target, GLenum pname,
-                            const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].f = params[0];
-      if (pname == GL_CONVOLUTION_BORDER_COLOR ||
-          pname == GL_CONVOLUTION_FILTER_SCALE ||
-          pname == GL_CONVOLUTION_FILTER_BIAS) {
-         n[4].f = params[1];
-         n[5].f = params[2];
-         n[6].f = params[3];
-      }
-      else {
-         n[4].f = n[5].f = n[6].f = 0.0F;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ConvolutionParameterfv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_PIXELS, 5);
-   if (n) {
-      n[1].i = x;
-      n[2].i = y;
-      n[3].i = (GLint) width;
-      n[4].i = (GLint) height;
-      n[5].e = type;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
-                    GLint x, GLint y, GLsizei width, GLint border)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].e = internalformat;
-      n[4].i = x;
-      n[5].i = y;
-      n[6].i = width;
-      n[7].i = border;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,
-                                      x, y, width, border));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyTexImage2D(GLenum target, GLint level,
-                    GLenum internalformat,
-                    GLint x, GLint y, GLsizei width,
-                    GLsizei height, GLint border)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].e = internalformat;
-      n[4].i = x;
-      n[5].i = y;
-      n[6].i = width;
-      n[7].i = height;
-      n[8].i = border;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,
-                                      x, y, width, height, border));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_CopyTexSubImage1D(GLenum target, GLint level,
-                       GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = x;
-      n[5].i = y;
-      n[6].i = width;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyTexSubImage1D(ctx->Exec,
-                             (target, level, xoffset, x, y, width));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyTexSubImage2D(GLenum target, GLint level,
-                       GLint xoffset, GLint yoffset,
-                       GLint x, GLint y, GLsizei width, GLint height)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = x;
-      n[6].i = y;
-      n[7].i = width;
-      n[8].i = height;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
-                                         x, y, width, height));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CopyTexSubImage3D(GLenum target, GLint level,
-                       GLint xoffset, GLint yoffset, GLint zoffset,
-                       GLint x, GLint y, GLsizei width, GLint height)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = zoffset;
-      n[6].i = x;
-      n[7].i = y;
-      n[8].i = width;
-      n[9].i = height;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CopyTexSubImage3D(ctx->Exec, (target, level,
-                                         xoffset, yoffset, zoffset,
-                                         x, y, width, height));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CullFace(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CULL_FACE, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CullFace(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DepthFunc(GLenum func)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DEPTH_FUNC, 1);
-   if (n) {
-      n[1].e = func;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DepthFunc(ctx->Exec, (func));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DepthMask(GLboolean mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DEPTH_MASK, 1);
-   if (n) {
-      n[1].b = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DepthMask(ctx->Exec, (mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DepthRange(GLclampd nearval, GLclampd farval)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DEPTH_RANGE, 2);
-   if (n) {
-      n[1].f = (GLfloat) nearval;
-      n[2].f = (GLfloat) farval;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DepthRange(ctx->Exec, (nearval, farval));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Disable(GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DISABLE, 1);
-   if (n) {
-      n[1].e = cap;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Disable(ctx->Exec, (cap));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DisableIndexed(GLuint index, GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DISABLE_INDEXED, 2);
-   if (n) {
-      n[1].ui = index;
-      n[2].e = cap;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DisableIndexedEXT(ctx->Exec, (index, cap));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DrawBuffer(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DRAW_BUFFER, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DrawBuffer(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_DrawPixels(GLsizei width, GLsizei height,
-                GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_DRAW_PIXELS, 5);
-   if (n) {
-      n[1].i = width;
-      n[2].i = height;
-      n[3].e = format;
-      n[4].e = type;
-      n[5].data = unpack_image(ctx, 2, width, height, 1, format, type,
-                               pixels, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_Enable(GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ENABLE, 1);
-   if (n) {
-      n[1].e = cap;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Enable(ctx->Exec, (cap));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_EnableIndexed(GLuint index, GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ENABLE_INDEXED, 2);
-   if (n) {
-      n[1].ui = index;
-      n[2].e = cap;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EnableIndexedEXT(ctx->Exec, (index, cap));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVALMESH1, 3);
-   if (n) {
-      n[1].e = mode;
-      n[2].i = i1;
-      n[3].i = i2;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));
-   }
-}
-
-
-static void GLAPIENTRY
-save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVALMESH2, 5);
-   if (n) {
-      n[1].e = mode;
-      n[2].i = i1;
-      n[3].i = i2;
-      n[4].i = j1;
-      n[5].i = j2;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));
-   }
-}
-
-
-
-
-static void GLAPIENTRY
-save_Fogfv(GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_FOG, 5);
-   if (n) {
-      n[1].e = pname;
-      n[2].f = params[0];
-      n[3].f = params[1];
-      n[4].f = params[2];
-      n[5].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Fogfv(ctx->Exec, (pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Fogf(GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_Fogfv(pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_Fogiv(GLenum pname, const GLint *params)
-{
-   GLfloat p[4];
-   switch (pname) {
-   case GL_FOG_MODE:
-   case GL_FOG_DENSITY:
-   case GL_FOG_START:
-   case GL_FOG_END:
-   case GL_FOG_INDEX:
-      p[0] = (GLfloat) *params;
-      p[1] = 0.0f;
-      p[2] = 0.0f;
-      p[3] = 0.0f;
-      break;
-   case GL_FOG_COLOR:
-      p[0] = INT_TO_FLOAT(params[0]);
-      p[1] = INT_TO_FLOAT(params[1]);
-      p[2] = INT_TO_FLOAT(params[2]);
-      p[3] = INT_TO_FLOAT(params[3]);
-      break;
-   default:
-      /* Error will be caught later in gl_Fogfv */
-      ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
-   }
-   save_Fogfv(pname, p);
-}
-
-
-static void GLAPIENTRY
-save_Fogi(GLenum pname, GLint param)
-{
-   GLint parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0;
-   save_Fogiv(pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_FrontFace(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_FRONT_FACE, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_FrontFace(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Frustum(GLdouble left, GLdouble right,
-             GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_FRUSTUM, 6);
-   if (n) {
-      n[1].f = (GLfloat) left;
-      n[2].f = (GLfloat) right;
-      n[3].f = (GLfloat) bottom;
-      n[4].f = (GLfloat) top;
-      n[5].f = (GLfloat) nearval;
-      n[6].f = (GLfloat) farval;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Hint(GLenum target, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_HINT, 2);
-   if (n) {
-      n[1].e = target;
-      n[2].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Hint(ctx->Exec, (target, mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Histogram(GLenum target, GLsizei width, GLenum internalFormat,
-               GLboolean sink)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_HISTOGRAM, 4);
-   if (n) {
-      n[1].e = target;
-      n[2].i = width;
-      n[3].e = internalFormat;
-      n[4].b = sink;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Histogram(ctx->Exec, (target, width, internalFormat, sink));
-   }
-}
-
-
-static void GLAPIENTRY
-save_IndexMask(GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_INDEX_MASK, 1);
-   if (n) {
-      n[1].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_IndexMask(ctx->Exec, (mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_InitNames(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_INIT_NAMES, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_InitNames(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LIGHT, 6);
-   if (n) {
-      GLint i, nParams;
-      n[1].e = light;
-      n[2].e = pname;
-      switch (pname) {
-      case GL_AMBIENT:
-         nParams = 4;
-         break;
-      case GL_DIFFUSE:
-         nParams = 4;
-         break;
-      case GL_SPECULAR:
-         nParams = 4;
-         break;
-      case GL_POSITION:
-         nParams = 4;
-         break;
-      case GL_SPOT_DIRECTION:
-         nParams = 3;
-         break;
-      case GL_SPOT_EXPONENT:
-         nParams = 1;
-         break;
-      case GL_SPOT_CUTOFF:
-         nParams = 1;
-         break;
-      case GL_CONSTANT_ATTENUATION:
-         nParams = 1;
-         break;
-      case GL_LINEAR_ATTENUATION:
-         nParams = 1;
-         break;
-      case GL_QUADRATIC_ATTENUATION:
-         nParams = 1;
-         break;
-      default:
-         nParams = 0;
-      }
-      for (i = 0; i < nParams; i++) {
-         n[3 + i].f = params[i];
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Lightfv(ctx->Exec, (light, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Lightf(GLenum light, GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_Lightfv(light, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_Lightiv(GLenum light, GLenum pname, const GLint *params)
-{
-   GLfloat fparam[4];
-   switch (pname) {
-   case GL_AMBIENT:
-   case GL_DIFFUSE:
-   case GL_SPECULAR:
-      fparam[0] = INT_TO_FLOAT(params[0]);
-      fparam[1] = INT_TO_FLOAT(params[1]);
-      fparam[2] = INT_TO_FLOAT(params[2]);
-      fparam[3] = INT_TO_FLOAT(params[3]);
-      break;
-   case GL_POSITION:
-      fparam[0] = (GLfloat) params[0];
-      fparam[1] = (GLfloat) params[1];
-      fparam[2] = (GLfloat) params[2];
-      fparam[3] = (GLfloat) params[3];
-      break;
-   case GL_SPOT_DIRECTION:
-      fparam[0] = (GLfloat) params[0];
-      fparam[1] = (GLfloat) params[1];
-      fparam[2] = (GLfloat) params[2];
-      break;
-   case GL_SPOT_EXPONENT:
-   case GL_SPOT_CUTOFF:
-   case GL_CONSTANT_ATTENUATION:
-   case GL_LINEAR_ATTENUATION:
-   case GL_QUADRATIC_ATTENUATION:
-      fparam[0] = (GLfloat) params[0];
-      break;
-   default:
-      /* error will be caught later in gl_Lightfv */
-      ;
-   }
-   save_Lightfv(light, pname, fparam);
-}
-
-
-static void GLAPIENTRY
-save_Lighti(GLenum light, GLenum pname, GLint param)
-{
-   GLint parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0;
-   save_Lightiv(light, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_LightModelfv(GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LIGHT_MODEL, 5);
-   if (n) {
-      n[1].e = pname;
-      n[2].f = params[0];
-      n[3].f = params[1];
-      n[4].f = params[2];
-      n[5].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LightModelfv(ctx->Exec, (pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_LightModelf(GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_LightModelfv(pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_LightModeliv(GLenum pname, const GLint *params)
-{
-   GLfloat fparam[4];
-   switch (pname) {
-   case GL_LIGHT_MODEL_AMBIENT:
-      fparam[0] = INT_TO_FLOAT(params[0]);
-      fparam[1] = INT_TO_FLOAT(params[1]);
-      fparam[2] = INT_TO_FLOAT(params[2]);
-      fparam[3] = INT_TO_FLOAT(params[3]);
-      break;
-   case GL_LIGHT_MODEL_LOCAL_VIEWER:
-   case GL_LIGHT_MODEL_TWO_SIDE:
-   case GL_LIGHT_MODEL_COLOR_CONTROL:
-      fparam[0] = (GLfloat) params[0];
-      fparam[1] = 0.0F;
-      fparam[2] = 0.0F;
-      fparam[3] = 0.0F;
-      break;
-   default:
-      /* Error will be caught later in gl_LightModelfv */
-      ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);
-   }
-   save_LightModelfv(pname, fparam);
-}
-
-
-static void GLAPIENTRY
-save_LightModeli(GLenum pname, GLint param)
-{
-   GLint parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0;
-   save_LightModeliv(pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_LineStipple(GLint factor, GLushort pattern)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LINE_STIPPLE, 2);
-   if (n) {
-      n[1].i = factor;
-      n[2].us = pattern;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LineStipple(ctx->Exec, (factor, pattern));
-   }
-}
-
-
-static void GLAPIENTRY
-save_LineWidth(GLfloat width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LINE_WIDTH, 1);
-   if (n) {
-      n[1].f = width;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LineWidth(ctx->Exec, (width));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ListBase(GLuint base)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LIST_BASE, 1);
-   if (n) {
-      n[1].ui = base;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ListBase(ctx->Exec, (base));
-   }
-}
-
-
-static void GLAPIENTRY
-save_LoadIdentity(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_LOAD_IDENTITY, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_LoadIdentity(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_LoadMatrixf(const GLfloat * m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LOAD_MATRIX, 16);
-   if (n) {
-      GLuint i;
-      for (i = 0; i < 16; i++) {
-         n[1 + i].f = m[i];
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LoadMatrixf(ctx->Exec, (m));
-   }
-}
-
-
-static void GLAPIENTRY
-save_LoadMatrixd(const GLdouble * m)
-{
-   GLfloat f[16];
-   GLint i;
-   for (i = 0; i < 16; i++) {
-      f[i] = (GLfloat) m[i];
-   }
-   save_LoadMatrixf(f);
-}
-
-
-static void GLAPIENTRY
-save_LoadName(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LOAD_NAME, 1);
-   if (n) {
-      n[1].ui = name;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LoadName(ctx->Exec, (name));
-   }
-}
-
-
-static void GLAPIENTRY
-save_LogicOp(GLenum opcode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_LOGIC_OP, 1);
-   if (n) {
-      n[1].e = opcode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LogicOp(ctx->Exec, (opcode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
-           GLint order, const GLdouble * points)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAP1, 6);
-   if (n) {
-      GLfloat *pnts = _mesa_copy_map_points1d(target, stride, order, points);
-      n[1].e = target;
-      n[2].f = (GLfloat) u1;
-      n[3].f = (GLfloat) u2;
-      n[4].i = _mesa_evaluator_components(target);      /* stride */
-      n[5].i = order;
-      n[6].data = (void *) pnts;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));
-   }
-}
-
-static void GLAPIENTRY
-save_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
-           GLint order, const GLfloat * points)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAP1, 6);
-   if (n) {
-      GLfloat *pnts = _mesa_copy_map_points1f(target, stride, order, points);
-      n[1].e = target;
-      n[2].f = u1;
-      n[3].f = u2;
-      n[4].i = _mesa_evaluator_components(target);      /* stride */
-      n[5].i = order;
-      n[6].data = (void *) pnts;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Map2d(GLenum target,
-           GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
-           GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
-           const GLdouble * points)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAP2, 10);
-   if (n) {
-      GLfloat *pnts = _mesa_copy_map_points2d(target, ustride, uorder,
-                                              vstride, vorder, points);
-      n[1].e = target;
-      n[2].f = (GLfloat) u1;
-      n[3].f = (GLfloat) u2;
-      n[4].f = (GLfloat) v1;
-      n[5].f = (GLfloat) v2;
-      /* XXX verify these strides are correct */
-      n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */
-      n[7].i = _mesa_evaluator_components(target);      /*vstride */
-      n[8].i = uorder;
-      n[9].i = vorder;
-      n[10].data = (void *) pnts;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Map2d(ctx->Exec, (target,
-                             u1, u2, ustride, uorder,
-                             v1, v2, vstride, vorder, points));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Map2f(GLenum target,
-           GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
-           GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
-           const GLfloat * points)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAP2, 10);
-   if (n) {
-      GLfloat *pnts = _mesa_copy_map_points2f(target, ustride, uorder,
-                                              vstride, vorder, points);
-      n[1].e = target;
-      n[2].f = u1;
-      n[3].f = u2;
-      n[4].f = v1;
-      n[5].f = v2;
-      /* XXX verify these strides are correct */
-      n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */
-      n[7].i = _mesa_evaluator_components(target);      /*vstride */
-      n[8].i = uorder;
-      n[9].i = vorder;
-      n[10].data = (void *) pnts;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
-                             v1, v2, vstride, vorder, points));
-   }
-}
-
-
-static void GLAPIENTRY
-save_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAPGRID1, 3);
-   if (n) {
-      n[1].i = un;
-      n[2].f = u1;
-      n[3].f = u2;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_MapGrid1f(ctx->Exec, (un, u1, u2));
-   }
-}
-
-
-static void GLAPIENTRY
-save_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
-{
-   save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
-}
-
-
-static void GLAPIENTRY
-save_MapGrid2f(GLint un, GLfloat u1, GLfloat u2,
-               GLint vn, GLfloat v1, GLfloat v2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MAPGRID2, 6);
-   if (n) {
-      n[1].i = un;
-      n[2].f = u1;
-      n[3].f = u2;
-      n[4].i = vn;
-      n[5].f = v1;
-      n[6].f = v2;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_MapGrid2d(GLint un, GLdouble u1, GLdouble u2,
-               GLint vn, GLdouble v1, GLdouble v2)
-{
-   save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,
-                  vn, (GLfloat) v1, (GLfloat) v2);
-}
-
-
-static void GLAPIENTRY
-save_MatrixMode(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MATRIX_MODE, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_MatrixMode(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MIN_MAX, 3);
-   if (n) {
-      n[1].e = target;
-      n[2].e = internalFormat;
-      n[3].b = sink;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Minmax(ctx->Exec, (target, internalFormat, sink));
-   }
-}
-
-
-static void GLAPIENTRY
-save_MultMatrixf(const GLfloat * m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_MULT_MATRIX, 16);
-   if (n) {
-      GLuint i;
-      for (i = 0; i < 16; i++) {
-         n[1 + i].f = m[i];
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_MultMatrixf(ctx->Exec, (m));
-   }
-}
-
-
-static void GLAPIENTRY
-save_MultMatrixd(const GLdouble * m)
-{
-   GLfloat f[16];
-   GLint i;
-   for (i = 0; i < 16; i++) {
-      f[i] = (GLfloat) m[i];
-   }
-   save_MultMatrixf(f);
-}
-
-
-static void GLAPIENTRY
-save_NewList(GLuint name, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   /* It's an error to call this function while building a display list */
-   _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
-   (void) name;
-   (void) mode;
-}
-
-
-
-static void GLAPIENTRY
-save_Ortho(GLdouble left, GLdouble right,
-           GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ORTHO, 6);
-   if (n) {
-      n[1].f = (GLfloat) left;
-      n[2].f = (GLfloat) right;
-      n[3].f = (GLfloat) bottom;
-      n[4].f = (GLfloat) top;
-      n[5].f = (GLfloat) nearval;
-      n[6].f = (GLfloat) farval;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PIXEL_MAP, 3);
-   if (n) {
-      n[1].e = map;
-      n[2].i = mapsize;
-      n[3].data = (void *) malloc(mapsize * sizeof(GLfloat));
-      memcpy(n[3].data, (void *) values, mapsize * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
-{
-   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
-   GLint i;
-   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = (GLfloat) values[i];
-      }
-   }
-   else {
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = UINT_TO_FLOAT(values[i]);
-      }
-   }
-   save_PixelMapfv(map, mapsize, fvalues);
-}
-
-
-static void GLAPIENTRY
-save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
-{
-   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
-   GLint i;
-   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = (GLfloat) values[i];
-      }
-   }
-   else {
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = USHORT_TO_FLOAT(values[i]);
-      }
-   }
-   save_PixelMapfv(map, mapsize, fvalues);
-}
-
-
-static void GLAPIENTRY
-save_PixelTransferf(GLenum pname, GLfloat param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PIXEL_TRANSFER, 2);
-   if (n) {
-      n[1].e = pname;
-      n[2].f = param;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PixelTransferf(ctx->Exec, (pname, param));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PixelTransferi(GLenum pname, GLint param)
-{
-   save_PixelTransferf(pname, (GLfloat) param);
-}
-
-
-static void GLAPIENTRY
-save_PixelZoom(GLfloat xfactor, GLfloat yfactor)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PIXEL_ZOOM, 2);
-   if (n) {
-      n[1].f = xfactor;
-      n[2].f = yfactor;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PointParameterfvEXT(GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_POINT_PARAMETERS, 4);
-   if (n) {
-      n[1].e = pname;
-      n[2].f = params[0];
-      n[3].f = params[1];
-      n[4].f = params[2];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PointParameterfvEXT(ctx->Exec, (pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PointParameterfEXT(GLenum pname, GLfloat param)
-{
-   GLfloat parray[3];
-   parray[0] = param;
-   parray[1] = parray[2] = 0.0F;
-   save_PointParameterfvEXT(pname, parray);
-}
-
-static void GLAPIENTRY
-save_PointParameteriNV(GLenum pname, GLint param)
-{
-   GLfloat parray[3];
-   parray[0] = (GLfloat) param;
-   parray[1] = parray[2] = 0.0F;
-   save_PointParameterfvEXT(pname, parray);
-}
-
-static void GLAPIENTRY
-save_PointParameterivNV(GLenum pname, const GLint * param)
-{
-   GLfloat parray[3];
-   parray[0] = (GLfloat) param[0];
-   parray[1] = parray[2] = 0.0F;
-   save_PointParameterfvEXT(pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_PointSize(GLfloat size)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_POINT_SIZE, 1);
-   if (n) {
-      n[1].f = size;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PointSize(ctx->Exec, (size));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PolygonMode(GLenum face, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_POLYGON_MODE, 2);
-   if (n) {
-      n[1].e = face;
-      n[2].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PolygonMode(ctx->Exec, (face, mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PolygonStipple(const GLubyte * pattern)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_POLYGON_STIPPLE, 1);
-   if (n) {
-      n[1].data = unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
-                               pattern, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PolygonOffset(GLfloat factor, GLfloat units)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET, 2);
-   if (n) {
-      n[1].f = factor;
-      n[2].f = units;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PolygonOffset(ctx->Exec, (factor, units));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PolygonOffsetEXT(GLfloat factor, GLfloat bias)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   /* XXX mult by DepthMaxF here??? */
-   save_PolygonOffset(factor, ctx->DrawBuffer->_DepthMaxF * bias);
-}
-
-
-static void GLAPIENTRY
-save_PopAttrib(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_POP_ATTRIB, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_PopAttrib(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_PopMatrix(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_POP_MATRIX, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_PopMatrix(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_PopName(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_POP_NAME, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_PopName(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_PrioritizeTextures(GLsizei num, const GLuint * textures,
-                        const GLclampf * priorities)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   for (i = 0; i < num; i++) {
-      Node *n;
-      n = alloc_instruction(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);
-      if (n) {
-         n[1].ui = textures[i];
-         n[2].f = priorities[i];
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PushAttrib(GLbitfield mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PUSH_ATTRIB, 1);
-   if (n) {
-      n[1].bf = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PushAttrib(ctx->Exec, (mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_PushMatrix(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_PUSH_MATRIX, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_PushMatrix(ctx->Exec, ());
-   }
-}
-
-
-static void GLAPIENTRY
-save_PushName(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PUSH_NAME, 1);
-   if (n) {
-      n[1].ui = name;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PushName(ctx->Exec, (name));
-   }
-}
-
-
-static void GLAPIENTRY
-save_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_RASTER_POS, 4);
-   if (n) {
-      n[1].f = x;
-      n[2].f = y;
-      n[3].f = z;
-      n[4].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_RasterPos4f(ctx->Exec, (x, y, z, w));
-   }
-}
-
-static void GLAPIENTRY
-save_RasterPos2d(GLdouble x, GLdouble y)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2f(GLfloat x, GLfloat y)
-{
-   save_RasterPos4f(x, y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2i(GLint x, GLint y)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2s(GLshort x, GLshort y)
-{
-   save_RasterPos4f(x, y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_RasterPos4f(x, y, z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3i(GLint x, GLint y, GLint z)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3s(GLshort x, GLshort y, GLshort z)
-{
-   save_RasterPos4f(x, y, z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
-}
-
-static void GLAPIENTRY
-save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
-{
-   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
-}
-
-static void GLAPIENTRY
-save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-   save_RasterPos4f(x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_RasterPos2dv(const GLdouble * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2fv(const GLfloat * v)
-{
-   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2iv(const GLint * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos2sv(const GLshort * v)
-{
-   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3dv(const GLdouble * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3fv(const GLfloat * v)
-{
-   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3iv(const GLint * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos3sv(const GLshort * v)
-{
-   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_RasterPos4dv(const GLdouble * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
-                    (GLfloat) v[2], (GLfloat) v[3]);
-}
-
-static void GLAPIENTRY
-save_RasterPos4fv(const GLfloat * v)
-{
-   save_RasterPos4f(v[0], v[1], v[2], v[3]);
-}
-
-static void GLAPIENTRY
-save_RasterPos4iv(const GLint * v)
-{
-   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
-                    (GLfloat) v[2], (GLfloat) v[3]);
-}
-
-static void GLAPIENTRY
-save_RasterPos4sv(const GLshort * v)
-{
-   save_RasterPos4f(v[0], v[1], v[2], v[3]);
-}
-
-
-static void GLAPIENTRY
-save_PassThrough(GLfloat token)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PASSTHROUGH, 1);
-   if (n) {
-      n[1].f = token;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_PassThrough(ctx->Exec, (token));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ReadBuffer(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_READ_BUFFER, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ReadBuffer(ctx->Exec, (mode));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ResetHistogram(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_RESET_HISTOGRAM, 1);
-   if (n) {
-      n[1].e = target;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ResetHistogram(ctx->Exec, (target));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ResetMinmax(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_RESET_MIN_MAX, 1);
-   if (n) {
-      n[1].e = target;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ResetMinmax(ctx->Exec, (target));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ROTATE, 4);
-   if (n) {
-      n[1].f = angle;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Rotatef(ctx->Exec, (angle, x, y, z));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-{
-   save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
-}
-
-
-static void GLAPIENTRY
-save_Scalef(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_SCALE, 3);
-   if (n) {
-      n[1].f = x;
-      n[2].f = y;
-      n[3].f = z;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Scalef(ctx->Exec, (x, y, z));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Scaled(GLdouble x, GLdouble y, GLdouble z)
-{
-   save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
-}
-
-
-static void GLAPIENTRY
-save_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_SCISSOR, 4);
-   if (n) {
-      n[1].i = x;
-      n[2].i = y;
-      n[3].i = width;
-      n[4].i = height;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Scissor(ctx->Exec, (x, y, width, height));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ShadeModel(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);
-
-   if (ctx->ExecuteFlag) {
-      CALL_ShadeModel(ctx->Exec, (mode));
-   }
-
-   if (ctx->ListState.Current.ShadeModel == mode)
-      return;
-
-   SAVE_FLUSH_VERTICES(ctx);
-
-   /* Only save the value if we know the statechange will take effect:
-    */
-   if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)
-      ctx->ListState.Current.ShadeModel = mode;
-
-   n = alloc_instruction(ctx, OPCODE_SHADE_MODEL, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC, 3);
-   if (n) {
-      n[1].e = func;
-      n[2].i = ref;
-      n[3].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilFunc(ctx->Exec, (func, ref, mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilMask(GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_MASK, 1);
-   if (n) {
-      n[1].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilMask(ctx->Exec, (mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_OP, 3);
-   if (n) {
-      n[1].e = fail;
-      n[2].e = zfail;
-      n[3].e = zpass;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
-   if (n) {
-      n[1].e = face;
-      n[2].e = func;
-      n[3].i = ref;
-      n[4].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref,
-                            GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   /* GL_FRONT */
-   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
-   if (n) {
-      n[1].e = GL_FRONT;
-      n[2].e = frontfunc;
-      n[3].i = ref;
-      n[4].ui = mask;
-   }
-   /* GL_BACK */
-   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
-   if (n) {
-      n[1].e = GL_BACK;
-      n[2].e = backfunc;
-      n[3].i = ref;
-      n[4].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));
-      CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilMaskSeparate(GLenum face, GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);
-   if (n) {
-      n[1].e = face;
-      n[2].ui = mask;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
-   }
-}
-
-
-static void GLAPIENTRY
-save_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);
-   if (n) {
-      n[1].e = face;
-      n[2].e = fail;
-      n[3].e = zfail;
-      n[4].e = zpass;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TEXENV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      if (pname == GL_TEXTURE_ENV_COLOR) {
-         n[3].f = params[0];
-         n[4].f = params[1];
-         n[5].f = params[2];
-         n[6].f = params[3];
-      }
-      else {
-         n[3].f = params[0];
-         n[4].f = n[5].f = n[6].f = 0.0F;
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexEnvfv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexEnvf(GLenum target, GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = (GLfloat) param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_TexEnvfv(target, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_TexEnvi(GLenum target, GLenum pname, GLint param)
-{
-   GLfloat p[4];
-   p[0] = (GLfloat) param;
-   p[1] = p[2] = p[3] = 0.0F;
-   save_TexEnvfv(target, pname, p);
-}
-
-
-static void GLAPIENTRY
-save_TexEnviv(GLenum target, GLenum pname, const GLint * param)
-{
-   GLfloat p[4];
-   if (pname == GL_TEXTURE_ENV_COLOR) {
-      p[0] = INT_TO_FLOAT(param[0]);
-      p[1] = INT_TO_FLOAT(param[1]);
-      p[2] = INT_TO_FLOAT(param[2]);
-      p[3] = INT_TO_FLOAT(param[3]);
-   }
-   else {
-      p[0] = (GLfloat) param[0];
-      p[1] = p[2] = p[3] = 0.0F;
-   }
-   save_TexEnvfv(target, pname, p);
-}
-
-
-static void GLAPIENTRY
-save_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TEXGEN, 6);
-   if (n) {
-      n[1].e = coord;
-      n[2].e = pname;
-      n[3].f = params[0];
-      n[4].f = params[1];
-      n[5].f = params[2];
-      n[6].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexGenfv(ctx->Exec, (coord, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
-{
-   GLfloat p[4];
-   p[0] = (GLfloat) params[0];
-   p[1] = (GLfloat) params[1];
-   p[2] = (GLfloat) params[2];
-   p[3] = (GLfloat) params[3];
-   save_TexGenfv(coord, pname, p);
-}
-
-
-static void GLAPIENTRY
-save_TexGend(GLenum coord, GLenum pname, GLdouble param)
-{
-   GLfloat parray[4];
-   parray[0] = (GLfloat) param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_TexGenfv(coord, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
-{
-   GLfloat p[4];
-   p[0] = (GLfloat) params[0];
-   p[1] = (GLfloat) params[1];
-   p[2] = (GLfloat) params[2];
-   p[3] = (GLfloat) params[3];
-   save_TexGenfv(coord, pname, p);
-}
-
-
-static void GLAPIENTRY
-save_TexGenf(GLenum coord, GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_TexGenfv(coord, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_TexGeni(GLenum coord, GLenum pname, GLint param)
-{
-   GLint parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0;
-   save_TexGeniv(coord, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].f = params[0];
-      n[4].f = params[1];
-      n[5].f = params[2];
-      n[6].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexParameterfv(ctx->Exec, (target, pname, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-   GLfloat parray[4];
-   parray[0] = param;
-   parray[1] = parray[2] = parray[3] = 0.0F;
-   save_TexParameterfv(target, pname, parray);
-}
-
-
-static void GLAPIENTRY
-save_TexParameteri(GLenum target, GLenum pname, GLint param)
-{
-   GLfloat fparam[4];
-   fparam[0] = (GLfloat) param;
-   fparam[1] = fparam[2] = fparam[3] = 0.0F;
-   save_TexParameterfv(target, pname, fparam);
-}
-
-
-static void GLAPIENTRY
-save_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-   GLfloat fparam[4];
-   fparam[0] = (GLfloat) params[0];
-   fparam[1] = fparam[2] = fparam[3] = 0.0F;
-   save_TexParameterfv(target, pname, fparam);
-}
-
-
-static void GLAPIENTRY
-save_TexImage1D(GLenum target,
-                GLint level, GLint components,
-                GLsizei width, GLint border,
-                GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_1D) {
-      /* don't compile, execute immediately */
-      CALL_TexImage1D(ctx->Exec, (target, level, components, width,
-                                  border, format, type, pixels));
-   }
-   else {
-      Node *n;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE1D, 8);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].i = components;
-         n[4].i = (GLint) width;
-         n[5].i = border;
-         n[6].e = format;
-         n[7].e = type;
-         n[8].data = unpack_image(ctx, 1, width, 1, 1, format, type,
-                                  pixels, &ctx->Unpack);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_TexImage1D(ctx->Exec, (target, level, components, width,
-                                     border, format, type, pixels));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexImage2D(GLenum target,
-                GLint level, GLint components,
-                GLsizei width, GLsizei height, GLint border,
-                GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_2D) {
-      /* don't compile, execute immediately */
-      CALL_TexImage2D(ctx->Exec, (target, level, components, width,
-                                  height, border, format, type, pixels));
-   }
-   else {
-      Node *n;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE2D, 9);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].i = components;
-         n[4].i = (GLint) width;
-         n[5].i = (GLint) height;
-         n[6].i = border;
-         n[7].e = format;
-         n[8].e = type;
-         n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
-                                  pixels, &ctx->Unpack);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_TexImage2D(ctx->Exec, (target, level, components, width,
-                                     height, border, format, type, pixels));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexImage3D(GLenum target,
-                GLint level, GLint internalFormat,
-                GLsizei width, GLsizei height, GLsizei depth,
-                GLint border,
-                GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_3D) {
-      /* don't compile, execute immediately */
-      CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
-                                  height, depth, border, format, type,
-                                  pixels));
-   }
-   else {
-      Node *n;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE3D, 10);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].i = (GLint) internalFormat;
-         n[4].i = (GLint) width;
-         n[5].i = (GLint) height;
-         n[6].i = (GLint) depth;
-         n[7].i = border;
-         n[8].e = format;
-         n[9].e = type;
-         n[10].data = unpack_image(ctx, 3, width, height, depth, format, type,
-                                   pixels, &ctx->Unpack);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
-                                     height, depth, border, format, type,
-                                     pixels));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
-                   GLsizei width, GLenum format, GLenum type,
-                   const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE1D, 7);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = (GLint) width;
-      n[5].e = format;
-      n[6].e = type;
-      n[7].data = unpack_image(ctx, 1, width, 1, 1, format, type,
-                               pixels, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
-                                     format, type, pixels));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexSubImage2D(GLenum target, GLint level,
-                   GLint xoffset, GLint yoffset,
-                   GLsizei width, GLsizei height,
-                   GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE2D, 9);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = (GLint) width;
-      n[6].i = (GLint) height;
-      n[7].e = format;
-      n[8].e = type;
-      n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
-                               pixels, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
-                                     width, height, format, type, pixels));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TexSubImage3D(GLenum target, GLint level,
-                   GLint xoffset, GLint yoffset, GLint zoffset,
-                   GLsizei width, GLsizei height, GLsizei depth,
-                   GLenum format, GLenum type, const GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE3D, 11);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = zoffset;
-      n[6].i = (GLint) width;
-      n[7].i = (GLint) height;
-      n[8].i = (GLint) depth;
-      n[9].e = format;
-      n[10].e = type;
-      n[11].data = unpack_image(ctx, 3, width, height, depth, format, type,
-                                pixels, &ctx->Unpack);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexSubImage3D(ctx->Exec, (target, level,
-                                     xoffset, yoffset, zoffset,
-                                     width, height, depth, format, type,
-                                     pixels));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Translatef(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TRANSLATE, 3);
-   if (n) {
-      n[1].f = x;
-      n[2].f = y;
-      n[3].f = z;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Translatef(ctx->Exec, (x, y, z));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Translated(GLdouble x, GLdouble y, GLdouble z)
-{
-   save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
-}
-
-
-
-static void GLAPIENTRY
-save_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_VIEWPORT, 4);
-   if (n) {
-      n[1].i = x;
-      n[2].i = y;
-      n[3].i = (GLint) width;
-      n[4].i = (GLint) height;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Viewport(ctx->Exec, (x, y, width, height));
-   }
-}
-
-
-static void GLAPIENTRY
-save_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_WINDOW_POS, 4);
-   if (n) {
-      n[1].f = x;
-      n[2].f = y;
-      n[3].f = z;
-      n[4].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));
-   }
-}
-
-static void GLAPIENTRY
-save_WindowPos2dMESA(GLdouble x, GLdouble y)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2fMESA(GLfloat x, GLfloat y)
-{
-   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2iMESA(GLint x, GLint y)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2sMESA(GLshort x, GLshort y)
-{
-   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3iMESA(GLint x, GLint y, GLint z)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
-{
-   save_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
-}
-
-static void GLAPIENTRY
-save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
-{
-   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
-}
-
-static void GLAPIENTRY
-save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-   save_WindowPos4fMESA(x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_WindowPos2dvMESA(const GLdouble * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2fvMESA(const GLfloat * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2ivMESA(const GLint * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos2svMESA(const GLshort * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3dvMESA(const GLdouble * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3fvMESA(const GLfloat * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3ivMESA(const GLint * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos3svMESA(const GLshort * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-static void GLAPIENTRY
-save_WindowPos4dvMESA(const GLdouble * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
-                        (GLfloat) v[2], (GLfloat) v[3]);
-}
-
-static void GLAPIENTRY
-save_WindowPos4fvMESA(const GLfloat * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-static void GLAPIENTRY
-save_WindowPos4ivMESA(const GLint * v)
-{
-   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
-                        (GLfloat) v[2], (GLfloat) v[3]);
-}
-
-static void GLAPIENTRY
-save_WindowPos4svMESA(const GLshort * v)
-{
-   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-
-
-/* GL_ARB_multitexture */
-static void GLAPIENTRY
-save_ActiveTextureARB(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ACTIVE_TEXTURE, 1);
-   if (n) {
-      n[1].e = target;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ActiveTextureARB(ctx->Exec, (target));
-   }
-}
-
-
-/* GL_ARB_transpose_matrix */
-
-static void GLAPIENTRY
-save_LoadTransposeMatrixdARB(const GLdouble m[16])
-{
-   GLfloat tm[16];
-   _math_transposefd(tm, m);
-   save_LoadMatrixf(tm);
-}
-
-
-static void GLAPIENTRY
-save_LoadTransposeMatrixfARB(const GLfloat m[16])
-{
-   GLfloat tm[16];
-   _math_transposef(tm, m);
-   save_LoadMatrixf(tm);
-}
-
-
-static void GLAPIENTRY
-save_MultTransposeMatrixdARB(const GLdouble m[16])
-{
-   GLfloat tm[16];
-   _math_transposefd(tm, m);
-   save_MultMatrixf(tm);
-}
-
-
-static void GLAPIENTRY
-save_MultTransposeMatrixfARB(const GLfloat m[16])
-{
-   GLfloat tm[16];
-   _math_transposef(tm, m);
-   save_MultMatrixf(tm);
-}
-
-
-/* GL_ARB_texture_compression */
-static void GLAPIENTRY
-save_CompressedTexImage1DARB(GLenum target, GLint level,
-                             GLenum internalFormat, GLsizei width,
-                             GLint border, GLsizei imageSize,
-                             const GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_1D) {
-      /* don't compile, execute immediately */
-      CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,
-                                               width, border, imageSize,
-                                               data));
-   }
-   else {
-      Node *n;
-      GLvoid *image;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
-      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].e = internalFormat;
-         n[4].i = (GLint) width;
-         n[5].i = border;
-         n[6].i = imageSize;
-         n[7].data = image;
-      }
-      else if (image) {
-         free(image);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_CompressedTexImage1DARB(ctx->Exec,
-                                      (target, level, internalFormat, width,
-                                       border, imageSize, data));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_CompressedTexImage2DARB(GLenum target, GLint level,
-                             GLenum internalFormat, GLsizei width,
-                             GLsizei height, GLint border, GLsizei imageSize,
-                             const GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_2D) {
-      /* don't compile, execute immediately */
-      CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,
-                                               width, height, border,
-                                               imageSize, data));
-   }
-   else {
-      Node *n;
-      GLvoid *image;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
-      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].e = internalFormat;
-         n[4].i = (GLint) width;
-         n[5].i = (GLint) height;
-         n[6].i = border;
-         n[7].i = imageSize;
-         n[8].data = image;
-      }
-      else if (image) {
-         free(image);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_CompressedTexImage2DARB(ctx->Exec,
-                                      (target, level, internalFormat, width,
-                                       height, border, imageSize, data));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_CompressedTexImage3DARB(GLenum target, GLint level,
-                             GLenum internalFormat, GLsizei width,
-                             GLsizei height, GLsizei depth, GLint border,
-                             GLsizei imageSize, const GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (target == GL_PROXY_TEXTURE_3D) {
-      /* don't compile, execute immediately */
-      CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,
-                                               width, height, depth, border,
-                                               imageSize, data));
-   }
-   else {
-      Node *n;
-      GLvoid *image;
-      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-      /* make copy of image */
-      image = malloc(imageSize);
-      if (!image) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
-         return;
-      }
-      memcpy(image, data, imageSize);
-      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9);
-      if (n) {
-         n[1].e = target;
-         n[2].i = level;
-         n[3].e = internalFormat;
-         n[4].i = (GLint) width;
-         n[5].i = (GLint) height;
-         n[6].i = (GLint) depth;
-         n[7].i = border;
-         n[8].i = imageSize;
-         n[9].data = image;
-      }
-      else if (image) {
-         free(image);
-      }
-      if (ctx->ExecuteFlag) {
-         CALL_CompressedTexImage3DARB(ctx->Exec,
-                                      (target, level, internalFormat, width,
-                                       height, depth, border, imageSize,
-                                       data));
-      }
-   }
-}
-
-
-static void GLAPIENTRY
-save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
-                                GLsizei width, GLenum format,
-                                GLsizei imageSize, const GLvoid * data)
-{
-   Node *n;
-   GLvoid *image;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
-   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = (GLint) width;
-      n[5].e = format;
-      n[6].i = imageSize;
-      n[7].data = image;
-   }
-   else if (image) {
-      free(image);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,
-                                                  width, format, imageSize,
-                                                  data));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
-                                GLint yoffset, GLsizei width, GLsizei height,
-                                GLenum format, GLsizei imageSize,
-                                const GLvoid * data)
-{
-   Node *n;
-   GLvoid *image;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
-   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = (GLint) width;
-      n[6].i = (GLint) height;
-      n[7].e = format;
-      n[8].i = imageSize;
-      n[9].data = image;
-   }
-   else if (image) {
-      free(image);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CompressedTexSubImage2DARB(ctx->Exec,
-                                      (target, level, xoffset, yoffset, width,
-                                       height, format, imageSize, data));
-   }
-}
-
-
-static void GLAPIENTRY
-save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
-                                GLint yoffset, GLint zoffset, GLsizei width,
-                                GLsizei height, GLsizei depth, GLenum format,
-                                GLsizei imageSize, const GLvoid * data)
-{
-   Node *n;
-   GLvoid *image;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   /* make copy of image */
-   image = malloc(imageSize);
-   if (!image) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
-      return;
-   }
-   memcpy(image, data, imageSize);
-   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11);
-   if (n) {
-      n[1].e = target;
-      n[2].i = level;
-      n[3].i = xoffset;
-      n[4].i = yoffset;
-      n[5].i = zoffset;
-      n[6].i = (GLint) width;
-      n[7].i = (GLint) height;
-      n[8].i = (GLint) depth;
-      n[9].e = format;
-      n[10].i = imageSize;
-      n[11].data = image;
-   }
-   else if (image) {
-      free(image);
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_CompressedTexSubImage3DARB(ctx->Exec,
-                                      (target, level, xoffset, yoffset,
-                                       zoffset, width, height, depth, format,
-                                       imageSize, data));
-   }
-}
-
-
-/* GL_ARB_multisample */
-static void GLAPIENTRY
-save_SampleCoverageARB(GLclampf value, GLboolean invert)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_SAMPLE_COVERAGE, 2);
-   if (n) {
-      n[1].f = value;
-      n[2].b = invert;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_SampleCoverageARB(ctx->Exec, (value, invert));
-   }
-}
-
-
-/*
- * GL_NV_vertex_program
- */
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-static void GLAPIENTRY
-save_BindProgramNV(GLenum target, GLuint id)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BIND_PROGRAM_NV, 2);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = id;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BindProgramNV(ctx->Exec, (target, id));
-   }
-}
-
-static void GLAPIENTRY
-save_ProgramEnvParameter4fARB(GLenum target, GLuint index,
-                              GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = index;
-      n[3].f = x;
-      n[4].f = y;
-      n[5].f = z;
-      n[6].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
-                               const GLfloat *params)
-{
-   save_ProgramEnvParameter4fARB(target, index, params[0], params[1],
-                                 params[2], params[3]);
-}
-
-
-static void GLAPIENTRY
-save_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
-				const GLfloat * params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (count > 0) {
-      GLint i;
-      const GLfloat * p = params;
-
-      for (i = 0 ; i < count ; i++) {
-	 n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
-	 if (n) {
-	    n[1].e = target;
-	    n[2].ui = index;
-	    n[3].f = p[0];
-	    n[4].f = p[1];
-	    n[5].f = p[2];
-	    n[6].f = p[3];
-	    p += 4;
-	 }
-      }
-   }
-
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramEnvParameter4dARB(GLenum target, GLuint index,
-                              GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-   save_ProgramEnvParameter4fARB(target, index,
-                                 (GLfloat) x,
-                                 (GLfloat) y, (GLfloat) z, (GLfloat) w);
-}
-
-
-static void GLAPIENTRY
-save_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
-                               const GLdouble *params)
-{
-   save_ProgramEnvParameter4fARB(target, index,
-                                 (GLfloat) params[0],
-                                 (GLfloat) params[1],
-                                 (GLfloat) params[2], (GLfloat) params[3]);
-}
-
-#endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program */
-
-#if FEATURE_NV_vertex_program
-static void GLAPIENTRY
-save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_EXECUTE_PROGRAM_NV, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = id;
-      n[3].f = params[0];
-      n[4].f = params[1];
-      n[5].f = params[2];
-      n[6].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ExecuteProgramNV(ctx->Exec, (target, id, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramParameters4dvNV(GLenum target, GLuint index,
-                            GLsizei num, const GLdouble *params)
-{
-   GLint i;
-   for (i = 0; i < num; i++) {
-      save_ProgramEnvParameter4dvARB(target, index + i, params + 4 * i);
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramParameters4fvNV(GLenum target, GLuint index,
-                            GLsizei num, const GLfloat *params)
-{
-   GLint i;
-   for (i = 0; i < num; i++) {
-      save_ProgramEnvParameter4fvARB(target, index + i, params + 4 * i);
-   }
-}
-
-
-static void GLAPIENTRY
-save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
-                   const GLubyte * program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_LOAD_PROGRAM_NV, 4);
-   if (n) {
-      GLubyte *programCopy = (GLubyte *) malloc(len);
-      if (!programCopy) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
-         return;
-      }
-      memcpy(programCopy, program, len);
-      n[1].e = target;
-      n[2].ui = id;
-      n[3].i = len;
-      n[4].data = programCopy;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_LoadProgramNV(ctx->Exec, (target, id, len, program));
-   }
-}
-
-
-static void GLAPIENTRY
-save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 2);
-   if (n) {
-      GLuint *idCopy = (GLuint *) malloc(num * sizeof(GLuint));
-      if (!idCopy) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
-         return;
-      }
-      memcpy(idCopy, ids, num * sizeof(GLuint));
-      n[1].i = num;
-      n[2].data = idCopy;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_RequestResidentProgramsNV(ctx->Exec, (num, ids));
-   }
-}
-
-
-static void GLAPIENTRY
-save_TrackMatrixNV(GLenum target, GLuint address,
-                   GLenum matrix, GLenum transform)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 4);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = address;
-      n[3].e = matrix;
-      n[4].e = transform;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TrackMatrixNV(ctx->Exec, (target, address, matrix, transform));
-   }
-}
-#endif /* FEATURE_NV_vertex_program */
-
-
-/*
- * GL_NV_fragment_program
- */
-#if FEATURE_NV_fragment_program
-static void GLAPIENTRY
-save_ProgramLocalParameter4fARB(GLenum target, GLuint index,
-                                GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = index;
-      n[3].f = x;
-      n[4].f = y;
-      n[5].f = z;
-      n[6].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
-                                 const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = index;
-      n[3].f = params[0];
-      n[4].f = params[1];
-      n[5].f = params[2];
-      n[6].f = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
-				  const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (count > 0) {
-      GLint i;
-      const GLfloat * p = params;
-
-      for (i = 0 ; i < count ; i++) {
-	 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
-	 if (n) {
-	    n[1].e = target;
-	    n[2].ui = index;
-	    n[3].f = p[0];
-	    n[4].f = p[1];
-	    n[5].f = p[2];
-	    n[6].f = p[3];
-	    p += 4;
-	 }
-      }
-   }
-
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramLocalParameter4dARB(GLenum target, GLuint index,
-                                GLdouble x, GLdouble y,
-                                GLdouble z, GLdouble w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = index;
-      n[3].f = (GLfloat) x;
-      n[4].f = (GLfloat) y;
-      n[5].f = (GLfloat) z;
-      n[6].f = (GLfloat) w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
-                                 const GLdouble *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = index;
-      n[3].f = (GLfloat) params[0];
-      n[4].f = (GLfloat) params[1];
-      n[5].f = (GLfloat) params[2];
-      n[6].f = (GLfloat) params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
-   }
-}
-
-static void GLAPIENTRY
-save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,
-                               GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);
-   if (n) {
-      GLubyte *nameCopy = (GLubyte *) malloc(len);
-      if (!nameCopy) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
-         return;
-      }
-      memcpy(nameCopy, name, len);
-      n[1].ui = id;
-      n[2].i = len;
-      n[3].data = nameCopy;
-      n[4].f = x;
-      n[5].f = y;
-      n[6].f = z;
-      n[7].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramNamedParameter4fNV(ctx->Exec, (id, len, name, x, y, z, w));
-   }
-}
-
-
-static void GLAPIENTRY
-save_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name,
-                                const float v[])
-{
-   save_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
-}
-
-
-static void GLAPIENTRY
-save_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name,
-                               GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-   save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) x, (GLfloat) y,
-                                  (GLfloat) z, (GLfloat) w);
-}
-
-
-static void GLAPIENTRY
-save_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name,
-                                const double v[])
-{
-   save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) v[0],
-                                  (GLfloat) v[1], (GLfloat) v[2],
-                                  (GLfloat) v[3]);
-}
-
-#endif /* FEATURE_NV_fragment_program */
-
-
-
-/* GL_EXT_stencil_two_side */
-static void GLAPIENTRY
-save_ActiveStencilFaceEXT(GLenum face)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);
-   if (n) {
-      n[1].e = face;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ActiveStencilFaceEXT(ctx->Exec, (face));
-   }
-}
-
-
-/* GL_EXT_depth_bounds_test */
-static void GLAPIENTRY
-save_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);
-   if (n) {
-      n[1].f = (GLfloat) zmin;
-      n[2].f = (GLfloat) zmax;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));
-   }
-}
-
-
-
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-
-static void GLAPIENTRY
-save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
-                      const GLvoid * string)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 4);
-   if (n) {
-      GLubyte *programCopy = (GLubyte *) malloc(len);
-      if (!programCopy) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
-         return;
-      }
-      memcpy(programCopy, string, len);
-      n[1].e = target;
-      n[2].e = format;
-      n[3].i = len;
-      n[4].data = programCopy;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
-   }
-}
-
-#endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */
-
-
-#if FEATURE_queryobj
-
-static void GLAPIENTRY
-save_BeginQueryARB(GLenum target, GLuint id)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_ARB, 2);
-   if (n) {
-      n[1].e = target;
-      n[2].ui = id;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BeginQueryARB(ctx->Exec, (target, id));
-   }
-}
-
-
-static void GLAPIENTRY
-save_EndQueryARB(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_END_QUERY_ARB, 1);
-   if (n) {
-      n[1].e = target;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EndQueryARB(ctx->Exec, (target));
-   }
-}
-
-#endif /* FEATURE_queryobj */
-
-
-static void GLAPIENTRY
-save_DrawBuffersARB(GLsizei count, const GLenum * buffers)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);
-   if (n) {
-      GLint i;
-      n[1].i = count;
-      if (count > MAX_DRAW_BUFFERS)
-         count = MAX_DRAW_BUFFERS;
-      for (i = 0; i < count; i++) {
-         n[2 + i].e = buffers[i];
-      }
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_DrawBuffersARB(ctx->Exec, (count, buffers));
-   }
-}
-
-static void GLAPIENTRY
-save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   n = alloc_instruction(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5);
-   if (n) {
-      n[1].ui = pname;
-      n[2].f = param[0];
-      n[3].f = param[1];
-      n[4].f = param[2];
-      n[5].f = param[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param));
-   }
-}
-
-static void GLAPIENTRY
-save_TexBumpParameterivATI(GLenum pname, const GLint *param)
-{
-   GLfloat p[4];
-   p[0] = INT_TO_FLOAT(param[0]);
-   p[1] = INT_TO_FLOAT(param[1]);
-   p[2] = INT_TO_FLOAT(param[2]);
-   p[3] = INT_TO_FLOAT(param[3]);
-   save_TexBumpParameterfvATI(pname, p);
-}
-
-#if FEATURE_ATI_fragment_shader
-static void GLAPIENTRY
-save_BindFragmentShaderATI(GLuint id)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   n = alloc_instruction(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);
-   if (n) {
-      n[1].ui = id;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BindFragmentShaderATI(ctx->Exec, (id));
-   }
-}
-
-static void GLAPIENTRY
-save_SetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-
-   n = alloc_instruction(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);
-   if (n) {
-      n[1].ui = dst;
-      n[2].f = value[0];
-      n[3].f = value[1];
-      n[4].f = value[2];
-      n[5].f = value[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
-   }
-}
-#endif
-
-static void
-save_Attr1fNV(GLenum attr, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_1F_NV, 2);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 1;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));
-   }
-}
-
-static void
-save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_2F_NV, 3);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 2;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));
-   }
-}
-
-static void
-save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_3F_NV, 4);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 3;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));
-   }
-}
-
-static void
-save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_4F_NV, 5);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-      n[5].f = w;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 4;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));
-   }
-}
-
-
-static void
-save_Attr1fARB(GLenum attr, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_1F_ARB, 2);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 1;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));
-   }
-}
-
-static void
-save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_2F_ARB, 3);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 2;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));
-   }
-}
-
-static void
-save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_3F_ARB, 4);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 3;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));
-   }
-}
-
-static void
-save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_ATTR_4F_ARB, 5);
-   if (n) {
-      n[1].e = attr;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-      n[5].f = w;
-   }
-
-   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
-   ctx->ListState.ActiveAttribSize[attr] = 4;
-   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
-
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));
-   }
-}
-
-
-static void GLAPIENTRY
-save_EvalCoord1f(GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVAL_C1, 1);
-   if (n) {
-      n[1].f = x;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalCoord1f(ctx->Exec, (x));
-   }
-}
-
-static void GLAPIENTRY
-save_EvalCoord1fv(const GLfloat * v)
-{
-   save_EvalCoord1f(v[0]);
-}
-
-static void GLAPIENTRY
-save_EvalCoord2f(GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVAL_C2, 2);
-   if (n) {
-      n[1].f = x;
-      n[2].f = y;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalCoord2f(ctx->Exec, (x, y));
-   }
-}
-
-static void GLAPIENTRY
-save_EvalCoord2fv(const GLfloat * v)
-{
-   save_EvalCoord2f(v[0], v[1]);
-}
-
-
-static void GLAPIENTRY
-save_EvalPoint1(GLint x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVAL_P1, 1);
-   if (n) {
-      n[1].i = x;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalPoint1(ctx->Exec, (x));
-   }
-}
-
-static void GLAPIENTRY
-save_EvalPoint2(GLint x, GLint y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_EVAL_P2, 2);
-   if (n) {
-      n[1].i = x;
-      n[2].i = y;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_EvalPoint2(ctx->Exec, (x, y));
-   }
-}
-
-static void GLAPIENTRY
-save_Indexf(GLfloat x)
-{
-   save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);
-}
-
-static void GLAPIENTRY
-save_Indexfv(const GLfloat * v)
-{
-   save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);
-}
-
-static void GLAPIENTRY
-save_EdgeFlag(GLboolean x)
-{
-   save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? (GLfloat)1.0 : (GLfloat)0.0);
-}
-
-static INLINE GLboolean compare4fv( const GLfloat *a,
-                                    const GLfloat *b,
-                                    GLuint count )
-{
-   return memcmp( a, b, count * sizeof(GLfloat) ) == 0;
-}
-                              
-
-static void GLAPIENTRY
-save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   int args, i;
-   GLuint bitmask;
-
-   switch (face) {
-   case GL_BACK:
-   case GL_FRONT:
-   case GL_FRONT_AND_BACK:
-      break;
-   default:
-      _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(face)");
-      return;
-   }
-
-   switch (pname) {
-   case GL_EMISSION:
-   case GL_AMBIENT:
-   case GL_DIFFUSE:
-   case GL_SPECULAR:
-   case GL_AMBIENT_AND_DIFFUSE:
-      args = 4;
-      break;
-   case GL_SHININESS:
-      args = 1;
-      break;
-   case GL_COLOR_INDEXES:
-      args = 3;
-      break;
-   default:
-      _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(pname)");
-      return;
-   }
-   
-   if (ctx->ExecuteFlag) {
-      CALL_Materialfv(ctx->Exec, (face, pname, param));
-   }
-
-   bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
-
-   /* Try to eliminate redundant statechanges.  Because it is legal to
-    * call glMaterial even inside begin/end calls, don't need to worry
-    * about ctx->Driver.CurrentSavePrimitive here.
-    */
-   for (i = 0; i < MAT_ATTRIB_MAX; i++) {
-      if (bitmask & (1 << i)) {
-         if (ctx->ListState.ActiveMaterialSize[i] == args &&
-             compare4fv(ctx->ListState.CurrentMaterial[i], param, args)) {
-            bitmask &= ~(1 << i);
-         }
-         else {
-            ctx->ListState.ActiveMaterialSize[i] = args;
-            COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
-         }
-      }
-   }
-
-   /* If this call has effect, return early:
-    */
-   if (bitmask == 0)
-      return;
-
-   SAVE_FLUSH_VERTICES(ctx);
-
-   n = alloc_instruction(ctx, OPCODE_MATERIAL, 6);
-   if (n) {
-      n[1].e = face;
-      n[2].e = pname;
-      for (i = 0; i < args; i++)
-         n[3 + i].f = param[i];
-   }
-}
-
-static void GLAPIENTRY
-save_Begin(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   GLboolean error = GL_FALSE;
-
-   if ( /*mode < GL_POINTS || */ mode > GL_POLYGON) {
-      _mesa_compile_error(ctx, GL_INVALID_ENUM, "Begin (mode)");
-      error = GL_TRUE;
-   }
-   else if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN) {
-      /* Typically the first begin.  This may raise an error on
-       * playback, depending on whether CallList is issued from inside
-       * a begin/end or not.
-       */
-      ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;
-   }
-   else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END) {
-      ctx->Driver.CurrentSavePrimitive = mode;
-   }
-   else {
-      _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive begin");
-      error = GL_TRUE;
-   }
-
-   if (!error) {
-      /* Give the driver an opportunity to hook in an optimized
-       * display list compiler.
-       */
-      if (ctx->Driver.NotifySaveBegin(ctx, mode))
-         return;
-
-      SAVE_FLUSH_VERTICES(ctx);
-      n = alloc_instruction(ctx, OPCODE_BEGIN, 1);
-      if (n) {
-         n[1].e = mode;
-      }
-   }
-
-   if (ctx->ExecuteFlag) {
-      CALL_Begin(ctx->Exec, (mode));
-   }
-}
-
-static void GLAPIENTRY
-save_End(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   SAVE_FLUSH_VERTICES(ctx);
-   (void) alloc_instruction(ctx, OPCODE_END, 0);
-   ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
-   if (ctx->ExecuteFlag) {
-      CALL_End(ctx->Exec, ());
-   }
-}
-
-static void GLAPIENTRY
-save_Rectf(GLfloat a, GLfloat b, GLfloat c, GLfloat d)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   SAVE_FLUSH_VERTICES(ctx);
-   n = alloc_instruction(ctx, OPCODE_RECTF, 4);
-   if (n) {
-      n[1].f = a;
-      n[2].f = b;
-      n[3].f = c;
-      n[4].f = d;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Rectf(ctx->Exec, (a, b, c, d));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Vertex2f(GLfloat x, GLfloat y)
-{
-   save_Attr2fNV(VERT_ATTRIB_POS, x, y);
-}
-
-static void GLAPIENTRY
-save_Vertex2fv(const GLfloat * v)
-{
-   save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);
-}
-
-static void GLAPIENTRY
-save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);
-}
-
-static void GLAPIENTRY
-save_Vertex3fv(const GLfloat * v)
-{
-   save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);
-}
-
-static void GLAPIENTRY
-save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_Vertex4fv(const GLfloat * v)
-{
-   save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);
-}
-
-static void GLAPIENTRY
-save_TexCoord1f(GLfloat x)
-{
-   save_Attr1fNV(VERT_ATTRIB_TEX0, x);
-}
-
-static void GLAPIENTRY
-save_TexCoord1fv(const GLfloat * v)
-{
-   save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);
-}
-
-static void GLAPIENTRY
-save_TexCoord2f(GLfloat x, GLfloat y)
-{
-   save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);
-}
-
-static void GLAPIENTRY
-save_TexCoord2fv(const GLfloat * v)
-{
-   save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);
-}
-
-static void GLAPIENTRY
-save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);
-}
-
-static void GLAPIENTRY
-save_TexCoord3fv(const GLfloat * v)
-{
-   save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);
-}
-
-static void GLAPIENTRY
-save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_TexCoord4fv(const GLfloat * v)
-{
-   save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);
-}
-
-static void GLAPIENTRY
-save_Normal3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);
-}
-
-static void GLAPIENTRY
-save_Normal3fv(const GLfloat * v)
-{
-   save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);
-}
-
-static void GLAPIENTRY
-save_FogCoordfEXT(GLfloat x)
-{
-   save_Attr1fNV(VERT_ATTRIB_FOG, x);
-}
-
-static void GLAPIENTRY
-save_FogCoordfvEXT(const GLfloat * v)
-{
-   save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);
-}
-
-static void GLAPIENTRY
-save_Color3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);
-}
-
-static void GLAPIENTRY
-save_Color3fv(const GLfloat * v)
-{
-   save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);
-}
-
-static void GLAPIENTRY
-save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_Color4fv(const GLfloat * v)
-{
-   save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);
-}
-
-static void GLAPIENTRY
-save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)
-{
-   save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);
-}
-
-static void GLAPIENTRY
-save_SecondaryColor3fvEXT(const GLfloat * v)
-{
-   save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);
-}
-
-
-/* Just call the respective ATTR for texcoord
- */
-static void GLAPIENTRY
-save_MultiTexCoord1f(GLenum target, GLfloat x)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr1fNV(attr, x);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord1fv(GLenum target, const GLfloat * v)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr1fNV(attr, v[0]);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr2fNV(attr, x, y);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord2fv(GLenum target, const GLfloat * v)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr2fNV(attr, v[0], v[1]);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr3fNV(attr, x, y, z);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord3fv(GLenum target, const GLfloat * v)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr3fNV(attr, v[0], v[1], v[2]);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,
-                     GLfloat z, GLfloat w)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr4fNV(attr, x, y, z, w);
-}
-
-static void GLAPIENTRY
-save_MultiTexCoord4fv(GLenum target, const GLfloat * v)
-{
-   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
-   save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);
-}
-
-
-/**
- * Record a GL_INVALID_VALUE error when a invalid vertex attribute
- * index is found.
- */
-static void
-index_error(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");
-}
-
-
-/* First level for NV_vertex_program:
- *
- * Check for errors at compile time?.
- */
-static void GLAPIENTRY
-save_VertexAttrib1fNV(GLuint index, GLfloat x)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr1fNV(index, x);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr1fNV(index, v[0]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr2fNV(index, x, y);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr2fNV(index, v[0], v[1]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr3fNV(index, x, y, z);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr3fNV(index, v[0], v[1], v[2]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
-                      GLfloat z, GLfloat w)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr4fNV(index, x, y, z, w);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
-      save_Attr4fNV(index, v[0], v[1], v[2], v[3]);
-   else
-      index_error();
-}
-
-
-
-
-static void GLAPIENTRY
-save_VertexAttrib1fARB(GLuint index, GLfloat x)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr1fARB(index, x);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr1fARB(index, v[0]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr2fARB(index, x, y);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr2fARB(index, v[0], v[1]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr3fARB(index, x, y, z);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr3fARB(index, v[0], v[1], v[2]);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
-                       GLfloat w)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr4fARB(index, x, y, z, w);
-   else
-      index_error();
-}
-
-static void GLAPIENTRY
-save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
-{
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
-   else
-      index_error();
-}
-
-
-/* GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
-
-static void GLAPIENTRY
-exec_BindAttribLocationARB(GLuint program, GLuint index, const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_BindAttribLocationARB(ctx->Exec, (program, index, name));
-}
-
-static GLint GLAPIENTRY
-exec_GetAttribLocationARB(GLuint program, const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_GetAttribLocationARB(ctx->Exec, (program, name));
-}
-
-static GLint GLAPIENTRY
-exec_GetUniformLocationARB(GLuint program, const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_GetUniformLocationARB(ctx->Exec, (program, name));
-}
-/* XXX more shader functions needed here */
-
-
-#if FEATURE_EXT_framebuffer_blit
-static void GLAPIENTRY
-save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                        GLbitfield mask, GLenum filter)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
-   if (n) {
-      n[1].i = srcX0;
-      n[2].i = srcY0;
-      n[3].i = srcX1;
-      n[4].i = srcY1;
-      n[5].i = dstX0;
-      n[6].i = dstY0;
-      n[7].i = dstX1;
-      n[8].i = dstY1;
-      n[9].i = mask;
-      n[10].e = filter;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BlitFramebufferEXT(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
-                                          dstX0, dstY0, dstX1, dstY1,
-                                          mask, filter));
-   }
-}
-#endif
-
-
-/** GL_EXT_provoking_vertex */
-static void GLAPIENTRY
-save_ProvokingVertexEXT(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_ProvokingVertexEXT(ctx->Exec, (mode));*/
-      _mesa_ProvokingVertexEXT(mode);
-   }
-}
-
-
-/** GL_EXT_transform_feedback */
-static void GLAPIENTRY
-save_BeginTransformFeedback(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
-   if (n) {
-      n[1].e = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_BeginTransformFeedbackEXT(ctx->Exec, (mode));
-   }
-}
-
-
-/** GL_EXT_transform_feedback */
-static void GLAPIENTRY
-save_EndTransformFeedback(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
-   if (ctx->ExecuteFlag) {
-      CALL_EndTransformFeedbackEXT(ctx->Exec, ());
-   }
-}
-
-
-/* aka UseProgram() */
-static void GLAPIENTRY
-save_UseProgramObjectARB(GLhandleARB program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
-   if (n) {
-      n[1].ui = program;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UseProgramObjectARB(ctx->Exec, (program));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Uniform1fARB(GLint location, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
-   if (n) {
-      n[1].i = location;
-      n[2].f = x;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform1fARB(ctx->Exec, (location, x));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].f = x;
-      n[3].f = y;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform2fARB(ctx->Exec, (location, x, y));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform3fARB(ctx->Exec, (location, x, y, z));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
-   if (n) {
-      n[1].i = location;
-      n[2].f = x;
-      n[3].f = y;
-      n[4].f = z;
-      n[5].f = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform4fARB(ctx->Exec, (location, x, y, z, w));
-   }
-}
-
-
-/** Return copy of memory */
-static void *
-memdup(const void *src, GLsizei bytes)
-{
-   void *b = bytes >= 0 ? malloc(bytes) : NULL;
-   if (b)
-      memcpy(b, src, bytes);
-   return b;
-}
-
-
-static void GLAPIENTRY
-save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 1 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform1fvARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 2 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform2fvARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 3 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform3fvARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform4fvARB(ctx->Exec, (location, count, v));
-   }
-}
-
-
-static void GLAPIENTRY
-save_Uniform1iARB(GLint location, GLint x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform1iARB(ctx->Exec, (location, x));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform2iARB(GLint location, GLint x, GLint y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform2iARB(ctx->Exec, (location, x, y));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-      n[4].i = z;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform3iARB(ctx->Exec, (location, x, y, z));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-      n[4].i = z;
-      n[5].i = w;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform4iARB(ctx->Exec, (location, x, y, z, w));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 1 * sizeof(GLint));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform1ivARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 2 * sizeof(GLint));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform2ivARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 3 * sizeof(GLint));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform3ivARB(ctx->Exec, (location, count, v));
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_Uniform4ivARB(ctx->Exec, (location, count, v));
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_Uniform1ui(GLint location, GLuint x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform1ui(ctx->Exec, (location, x));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform2ui(GLint location, GLuint x, GLuint y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform2ui(ctx->Exec, (location, x, y));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-      n[4].i = z;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform3ui(ctx->Exec, (location, x, y, z));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
-   if (n) {
-      n[1].i = location;
-      n[2].i = x;
-      n[3].i = y;
-      n[4].i = z;
-      n[5].i = w;
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));*/
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 1 * sizeof(*v));
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform1uiv(ctx->Exec, (location, count, v));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 2 * sizeof(*v));
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform2uiv(ctx->Exec, (location, count, v));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 3 * sizeof(*v));
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform3uiv(ctx->Exec, (location, count, v));*/
-   }
-}
-
-static void GLAPIENTRY
-save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 3);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].data = memdup(v, count * 4 * sizeof(*v));
-   }
-   if (ctx->ExecuteFlag) {
-      /*CALL_Uniform4uiv(ctx->Exec, (location, count, v));*/
-   }
-}
-
-
-
-static void GLAPIENTRY
-save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 2 * 2 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix2fvARB(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 3 * 3 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix3fvARB(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 4 * 4 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix4fvARB(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-
-static void GLAPIENTRY
-save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 2 * 3 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 3 * 2 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-
-static void GLAPIENTRY
-save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 2 * 4 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 4 * 2 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-
-static void GLAPIENTRY
-save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 3 * 4 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *m)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 4);
-   if (n) {
-      n[1].i = location;
-      n[2].i = count;
-      n[3].b = transpose;
-      n[4].data = memdup(m, count * 4 * 3 * sizeof(GLfloat));
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
-   }
-}
-
-static void GLAPIENTRY
-save_UseShaderProgramEXT(GLenum type, GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_USE_SHADER_PROGRAM_EXT, 2);
-   if (n) {
-      n[1].ui = type;
-      n[2].ui = program;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_UseShaderProgramEXT(ctx->Exec, (type, program));
-   }
-}
-
-static void GLAPIENTRY
-save_ActiveProgramEXT(GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_ACTIVE_PROGRAM_EXT, 1);
-   if (n) {
-      n[1].ui = program;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ActiveProgramEXT(ctx->Exec, (program));
-   }
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-save_ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_I, 4);
-   if (n) {
-      n[1].i = red;
-      n[2].i = green;
-      n[3].i = blue;
-      n[4].i = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearColorIiEXT(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-save_ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_UI, 4);
-   if (n) {
-      n[1].ui = red;
-      n[2].ui = green;
-      n[3].ui = blue;
-      n[4].ui = alpha;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_ClearColorIuiEXT(ctx->Exec, (red, green, blue, alpha));
-   }
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-save_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_I, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].i = params[0];
-      n[4].i = params[1];
-      n[5].i = params[2];
-      n[6].i = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexParameterIivEXT(ctx->Exec, (target, pname, params));
-   }
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-save_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_UI, 6);
-   if (n) {
-      n[1].e = target;
-      n[2].e = pname;
-      n[3].ui = params[0];
-      n[4].ui = params[1];
-      n[5].ui = params[2];
-      n[6].ui = params[3];
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_TexParameterIuivEXT(ctx->Exec, (target, pname, params));
-   }
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-exec_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexParameterIivEXT(ctx->Exec, (target, pname, params));
-}
-
-/** GL_EXT_texture_integer */
-static void GLAPIENTRY
-exec_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexParameterIuivEXT(ctx->Exec, (target, pname, params));
-}
-
-
-/* GL_ARB_instanced_arrays */
-static void
-save_VertexAttribDivisor(GLuint index, GLuint divisor)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
-   n = alloc_instruction(ctx, OPCODE_VERTEX_ATTRIB_DIVISOR, 2);
-   if (n) {
-      n[1].ui = index;
-      n[2].ui = divisor;
-   }
-   if (ctx->ExecuteFlag) {
-      CALL_VertexAttribDivisorARB(ctx->Exec, (index, divisor));
-   }
-}
-
-
-
-/**
- * Save an error-generating command into display list.
- *
- * KW: Will appear in the list before the vertex buffer containing the
- * command that provoked the error.  I don't see this as a problem.
- */
-static void
-save_error(struct gl_context *ctx, GLenum error, const char *s)
-{
-   Node *n;
-   n = alloc_instruction(ctx, OPCODE_ERROR, 2);
-   if (n) {
-      n[1].e = error;
-      n[2].data = (void *) s;
-   }
-}
-
-
-/**
- * Compile an error into current display list.
- */
-void
-_mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s)
-{
-   if (ctx->CompileFlag)
-      save_error(ctx, error, s);
-   if (ctx->ExecuteFlag)
-      _mesa_error(ctx, error, "%s", s);
-}
-
-
-/**
- * Test if ID names a display list.
- */
-static GLboolean
-islist(struct gl_context *ctx, GLuint list)
-{
-   if (list > 0 && lookup_list(ctx, list)) {
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-
-/**********************************************************************/
-/*                     Display list execution                         */
-/**********************************************************************/
-
-
-/*
- * Execute a display list.  Note that the ListBase offset must have already
- * been added before calling this function.  I.e. the list argument is
- * the absolute list number, not relative to ListBase.
- * \param list - display list number
- */
-static void
-execute_list(struct gl_context *ctx, GLuint list)
-{
-   struct gl_display_list *dlist;
-   Node *n;
-   GLboolean done;
-
-   if (list == 0 || !islist(ctx, list))
-      return;
-
-   if (ctx->ListState.CallDepth == MAX_LIST_NESTING) {
-      /* raise an error? */
-      return;
-   }
-
-   dlist = lookup_list(ctx, list);
-   if (!dlist)
-      return;
-
-   ctx->ListState.CallDepth++;
-
-   if (ctx->Driver.BeginCallList)
-      ctx->Driver.BeginCallList(ctx, dlist);
-
-   n = dlist->Head;
-
-   done = GL_FALSE;
-   while (!done) {
-      const OpCode opcode = n[0].opcode;
-
-      if (is_ext_opcode(opcode)) {
-         n += ext_opcode_execute(ctx, n);
-      }
-      else {
-         switch (opcode) {
-         case OPCODE_ERROR:
-            _mesa_error(ctx, n[1].e, "%s", (const char *) n[2].data);
-            break;
-         case OPCODE_ACCUM:
-            CALL_Accum(ctx->Exec, (n[1].e, n[2].f));
-            break;
-         case OPCODE_ALPHA_FUNC:
-            CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));
-            break;
-         case OPCODE_BIND_TEXTURE:
-            CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));
-            break;
-         case OPCODE_BITMAP:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,
-                                       n[3].f, n[4].f, n[5].f, n[6].f,
-                                       (const GLubyte *) n[7].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_BLEND_COLOR:
-            CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_BLEND_EQUATION:
-            CALL_BlendEquation(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_BLEND_EQUATION_SEPARATE:
-            CALL_BlendEquationSeparateEXT(ctx->Exec, (n[1].e, n[2].e));
-            break;
-         case OPCODE_BLEND_FUNC_SEPARATE:
-            CALL_BlendFuncSeparateEXT(ctx->Exec,
-                                      (n[1].e, n[2].e, n[3].e, n[4].e));
-            break;
-
-         case OPCODE_BLEND_FUNC_I:
-            /* GL_ARB_draw_buffers_blend */
-            CALL_BlendFunciARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e));
-            break;
-         case OPCODE_BLEND_FUNC_SEPARATE_I:
-            /* GL_ARB_draw_buffers_blend */
-            CALL_BlendFuncSeparateiARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e,
-                                                   n[4].e, n[5].e));
-            break;
-         case OPCODE_BLEND_EQUATION_I:
-            /* GL_ARB_draw_buffers_blend */
-            CALL_BlendEquationiARB(ctx->Exec, (n[1].ui, n[2].e));
-            break;
-         case OPCODE_BLEND_EQUATION_SEPARATE_I:
-            /* GL_ARB_draw_buffers_blend */
-            CALL_BlendEquationSeparateiARB(ctx->Exec,
-                                           (n[1].ui, n[2].e, n[3].e));
-            break;
-
-         case OPCODE_CALL_LIST:
-            /* Generated by glCallList(), don't add ListBase */
-            if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
-               execute_list(ctx, n[1].ui);
-            }
-            break;
-         case OPCODE_CALL_LIST_OFFSET:
-            /* Generated by glCallLists() so we must add ListBase */
-            if (n[2].b) {
-               /* user specified a bad data type at compile time */
-               _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
-            }
-            else if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
-               GLuint list = (GLuint) (ctx->List.ListBase + n[1].i);
-               execute_list(ctx, list);
-            }
-            break;
-         case OPCODE_CLEAR:
-            CALL_Clear(ctx->Exec, (n[1].bf));
-            break;
-         case OPCODE_CLEAR_BUFFER_IV:
-            {
-               GLint value[4];
-               value[0] = n[3].i;
-               value[1] = n[4].i;
-               value[2] = n[5].i;
-               value[3] = n[6].i;
-               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
-            }
-            break;
-         case OPCODE_CLEAR_BUFFER_UIV:
-            {
-               GLuint value[4];
-               value[0] = n[3].ui;
-               value[1] = n[4].ui;
-               value[2] = n[5].ui;
-               value[3] = n[6].ui;
-               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
-            }
-            break;
-         case OPCODE_CLEAR_BUFFER_FV:
-            {
-               GLfloat value[4];
-               value[0] = n[3].f;
-               value[1] = n[4].f;
-               value[2] = n[5].f;
-               value[3] = n[6].f;
-               /*CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));*/
-            }
-            break;
-         case OPCODE_CLEAR_BUFFER_FI:
-            /*CALL_ClearBufferfi(ctx->Exec, (n[1].e, n[2].i, n[3].f, n[4].i));*/
-            break;
-         case OPCODE_CLEAR_COLOR:
-            CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_CLEAR_ACCUM:
-            CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_CLEAR_DEPTH:
-            CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));
-            break;
-         case OPCODE_CLEAR_INDEX:
-            CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));
-            break;
-         case OPCODE_CLEAR_STENCIL:
-            CALL_ClearStencil(ctx->Exec, (n[1].i));
-            break;
-         case OPCODE_CLIP_PLANE:
-            {
-               GLdouble eq[4];
-               eq[0] = n[2].f;
-               eq[1] = n[3].f;
-               eq[2] = n[4].f;
-               eq[3] = n[5].f;
-               CALL_ClipPlane(ctx->Exec, (n[1].e, eq));
-            }
-            break;
-         case OPCODE_COLOR_MASK:
-            CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));
-            break;
-         case OPCODE_COLOR_MASK_INDEXED:
-            CALL_ColorMaskIndexedEXT(ctx->Exec, (n[1].ui, n[2].b, n[3].b,
-                                                 n[4].b, n[5].b));
-            break;
-         case OPCODE_COLOR_MATERIAL:
-            CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));
-            break;
-         case OPCODE_COLOR_TABLE:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_ColorTable(ctx->Exec, (n[1].e, n[2].e, n[3].i, n[4].e,
-                                           n[5].e, n[6].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_COLOR_TABLE_PARAMETER_FV:
-            {
-               GLfloat params[4];
-               params[0] = n[3].f;
-               params[1] = n[4].f;
-               params[2] = n[5].f;
-               params[3] = n[6].f;
-               CALL_ColorTableParameterfv(ctx->Exec,
-                                          (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_COLOR_TABLE_PARAMETER_IV:
-            {
-               GLint params[4];
-               params[0] = n[3].i;
-               params[1] = n[4].i;
-               params[2] = n[5].i;
-               params[3] = n[6].i;
-               CALL_ColorTableParameteriv(ctx->Exec,
-                                          (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_COLOR_SUB_TABLE:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_ColorSubTable(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                              n[4].e, n[5].e, n[6].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_CONVOLUTION_FILTER_1D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_ConvolutionFilter1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                                    n[4].e, n[5].e,
-                                                    n[6].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_CONVOLUTION_FILTER_2D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_ConvolutionFilter2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                                    n[4].i, n[5].e, n[6].e,
-                                                    n[7].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_CONVOLUTION_PARAMETER_I:
-            CALL_ConvolutionParameteri(ctx->Exec, (n[1].e, n[2].e, n[3].i));
-            break;
-         case OPCODE_CONVOLUTION_PARAMETER_IV:
-            {
-               GLint params[4];
-               params[0] = n[3].i;
-               params[1] = n[4].i;
-               params[2] = n[5].i;
-               params[3] = n[6].i;
-               CALL_ConvolutionParameteriv(ctx->Exec,
-                                           (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_CONVOLUTION_PARAMETER_F:
-            CALL_ConvolutionParameterf(ctx->Exec, (n[1].e, n[2].e, n[3].f));
-            break;
-         case OPCODE_CONVOLUTION_PARAMETER_FV:
-            {
-               GLfloat params[4];
-               params[0] = n[3].f;
-               params[1] = n[4].f;
-               params[2] = n[5].f;
-               params[3] = n[6].f;
-               CALL_ConvolutionParameterfv(ctx->Exec,
-                                           (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_COPY_COLOR_SUB_TABLE:
-            CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
-                                               n[3].i, n[4].i, n[5].i));
-            break;
-         case OPCODE_COPY_COLOR_TABLE:
-            CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
-                                               n[3].i, n[4].i, n[5].i));
-            break;
-         case OPCODE_COPY_PIXELS:
-            CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,
-                                        (GLsizei) n[3].i, (GLsizei) n[4].i,
-                                        n[5].e));
-            break;
-         case OPCODE_COPY_TEX_IMAGE1D:
-            CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
-                                            n[5].i, n[6].i, n[7].i));
-            break;
-         case OPCODE_COPY_TEX_IMAGE2D:
-            CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
-                                            n[5].i, n[6].i, n[7].i, n[8].i));
-            break;
-         case OPCODE_COPY_TEX_SUB_IMAGE1D:
-            CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                               n[4].i, n[5].i, n[6].i));
-            break;
-         case OPCODE_COPY_TEX_SUB_IMAGE2D:
-            CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                               n[4].i, n[5].i, n[6].i, n[7].i,
-                                               n[8].i));
-            break;
-         case OPCODE_COPY_TEX_SUB_IMAGE3D:
-            CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                               n[4].i, n[5].i, n[6].i, n[7].i,
-                                               n[8].i, n[9].i));
-            break;
-         case OPCODE_CULL_FACE:
-            CALL_CullFace(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_DEPTH_FUNC:
-            CALL_DepthFunc(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_DEPTH_MASK:
-            CALL_DepthMask(ctx->Exec, (n[1].b));
-            break;
-         case OPCODE_DEPTH_RANGE:
-            CALL_DepthRange(ctx->Exec,
-                            ((GLclampd) n[1].f, (GLclampd) n[2].f));
-            break;
-         case OPCODE_DISABLE:
-            CALL_Disable(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_DISABLE_INDEXED:
-            CALL_DisableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));
-            break;
-         case OPCODE_DRAW_BUFFER:
-            CALL_DrawBuffer(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_DRAW_PIXELS:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,
-                                           n[5].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_ENABLE:
-            CALL_Enable(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_ENABLE_INDEXED:
-            CALL_EnableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));
-            break;
-         case OPCODE_EVALMESH1:
-            CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));
-            break;
-         case OPCODE_EVALMESH2:
-            CALL_EvalMesh2(ctx->Exec,
-                           (n[1].e, n[2].i, n[3].i, n[4].i, n[5].i));
-            break;
-         case OPCODE_FOG:
-            {
-               GLfloat p[4];
-               p[0] = n[2].f;
-               p[1] = n[3].f;
-               p[2] = n[4].f;
-               p[3] = n[5].f;
-               CALL_Fogfv(ctx->Exec, (n[1].e, p));
-            }
-            break;
-         case OPCODE_FRONT_FACE:
-            CALL_FrontFace(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_FRUSTUM:
-            CALL_Frustum(ctx->Exec,
-                         (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
-            break;
-         case OPCODE_HINT:
-            CALL_Hint(ctx->Exec, (n[1].e, n[2].e));
-            break;
-         case OPCODE_HISTOGRAM:
-            CALL_Histogram(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].b));
-            break;
-         case OPCODE_INDEX_MASK:
-            CALL_IndexMask(ctx->Exec, (n[1].ui));
-            break;
-         case OPCODE_INIT_NAMES:
-            CALL_InitNames(ctx->Exec, ());
-            break;
-         case OPCODE_LIGHT:
-            {
-               GLfloat p[4];
-               p[0] = n[3].f;
-               p[1] = n[4].f;
-               p[2] = n[5].f;
-               p[3] = n[6].f;
-               CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));
-            }
-            break;
-         case OPCODE_LIGHT_MODEL:
-            {
-               GLfloat p[4];
-               p[0] = n[2].f;
-               p[1] = n[3].f;
-               p[2] = n[4].f;
-               p[3] = n[5].f;
-               CALL_LightModelfv(ctx->Exec, (n[1].e, p));
-            }
-            break;
-         case OPCODE_LINE_STIPPLE:
-            CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));
-            break;
-         case OPCODE_LINE_WIDTH:
-            CALL_LineWidth(ctx->Exec, (n[1].f));
-            break;
-         case OPCODE_LIST_BASE:
-            CALL_ListBase(ctx->Exec, (n[1].ui));
-            break;
-         case OPCODE_LOAD_IDENTITY:
-            CALL_LoadIdentity(ctx->Exec, ());
-            break;
-         case OPCODE_LOAD_MATRIX:
-            if (sizeof(Node) == sizeof(GLfloat)) {
-               CALL_LoadMatrixf(ctx->Exec, (&n[1].f));
-            }
-            else {
-               GLfloat m[16];
-               GLuint i;
-               for (i = 0; i < 16; i++) {
-                  m[i] = n[1 + i].f;
-               }
-               CALL_LoadMatrixf(ctx->Exec, (m));
-            }
-            break;
-         case OPCODE_LOAD_NAME:
-            CALL_LoadName(ctx->Exec, (n[1].ui));
-            break;
-         case OPCODE_LOGIC_OP:
-            CALL_LogicOp(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_MAP1:
-            {
-               GLenum target = n[1].e;
-               GLint ustride = _mesa_evaluator_components(target);
-               GLint uorder = n[5].i;
-               GLfloat u1 = n[2].f;
-               GLfloat u2 = n[3].f;
-               CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,
-                                      (GLfloat *) n[6].data));
-            }
-            break;
-         case OPCODE_MAP2:
-            {
-               GLenum target = n[1].e;
-               GLfloat u1 = n[2].f;
-               GLfloat u2 = n[3].f;
-               GLfloat v1 = n[4].f;
-               GLfloat v2 = n[5].f;
-               GLint ustride = n[6].i;
-               GLint vstride = n[7].i;
-               GLint uorder = n[8].i;
-               GLint vorder = n[9].i;
-               CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
-                                      v1, v2, vstride, vorder,
-                                      (GLfloat *) n[10].data));
-            }
-            break;
-         case OPCODE_MAPGRID1:
-            CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
-            break;
-         case OPCODE_MAPGRID2:
-            CALL_MapGrid2f(ctx->Exec,
-                           (n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));
-            break;
-         case OPCODE_MATRIX_MODE:
-            CALL_MatrixMode(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_MIN_MAX:
-            CALL_Minmax(ctx->Exec, (n[1].e, n[2].e, n[3].b));
-            break;
-         case OPCODE_MULT_MATRIX:
-            if (sizeof(Node) == sizeof(GLfloat)) {
-               CALL_MultMatrixf(ctx->Exec, (&n[1].f));
-            }
-            else {
-               GLfloat m[16];
-               GLuint i;
-               for (i = 0; i < 16; i++) {
-                  m[i] = n[1 + i].f;
-               }
-               CALL_MultMatrixf(ctx->Exec, (m));
-            }
-            break;
-         case OPCODE_ORTHO:
-            CALL_Ortho(ctx->Exec,
-                       (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
-            break;
-         case OPCODE_PASSTHROUGH:
-            CALL_PassThrough(ctx->Exec, (n[1].f));
-            break;
-         case OPCODE_PIXEL_MAP:
-            CALL_PixelMapfv(ctx->Exec,
-                            (n[1].e, n[2].i, (GLfloat *) n[3].data));
-            break;
-         case OPCODE_PIXEL_TRANSFER:
-            CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));
-            break;
-         case OPCODE_PIXEL_ZOOM:
-            CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));
-            break;
-         case OPCODE_POINT_SIZE:
-            CALL_PointSize(ctx->Exec, (n[1].f));
-            break;
-         case OPCODE_POINT_PARAMETERS:
-            {
-               GLfloat params[3];
-               params[0] = n[2].f;
-               params[1] = n[3].f;
-               params[2] = n[4].f;
-               CALL_PointParameterfvEXT(ctx->Exec, (n[1].e, params));
-            }
-            break;
-         case OPCODE_POLYGON_MODE:
-            CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));
-            break;
-         case OPCODE_POLYGON_STIPPLE:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_PolygonStipple(ctx->Exec, ((GLubyte *) n[1].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_POLYGON_OFFSET:
-            CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));
-            break;
-         case OPCODE_POP_ATTRIB:
-            CALL_PopAttrib(ctx->Exec, ());
-            break;
-         case OPCODE_POP_MATRIX:
-            CALL_PopMatrix(ctx->Exec, ());
-            break;
-         case OPCODE_POP_NAME:
-            CALL_PopName(ctx->Exec, ());
-            break;
-         case OPCODE_PRIORITIZE_TEXTURE:
-            CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));
-            break;
-         case OPCODE_PUSH_ATTRIB:
-            CALL_PushAttrib(ctx->Exec, (n[1].bf));
-            break;
-         case OPCODE_PUSH_MATRIX:
-            CALL_PushMatrix(ctx->Exec, ());
-            break;
-         case OPCODE_PUSH_NAME:
-            CALL_PushName(ctx->Exec, (n[1].ui));
-            break;
-         case OPCODE_RASTER_POS:
-            CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_READ_BUFFER:
-            CALL_ReadBuffer(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_RESET_HISTOGRAM:
-            CALL_ResetHistogram(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_RESET_MIN_MAX:
-            CALL_ResetMinmax(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_ROTATE:
-            CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_SCALE:
-            CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
-            break;
-         case OPCODE_SCISSOR:
-            CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
-            break;
-         case OPCODE_SHADE_MODEL:
-            CALL_ShadeModel(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_PROVOKING_VERTEX:
-            CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_BEGIN_TRANSFORM_FEEDBACK:
-            CALL_BeginTransformFeedbackEXT(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_END_TRANSFORM_FEEDBACK:
-            CALL_EndTransformFeedbackEXT(ctx->Exec, ());
-            break;
-         case OPCODE_STENCIL_FUNC:
-            CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
-            break;
-         case OPCODE_STENCIL_MASK:
-            CALL_StencilMask(ctx->Exec, (n[1].ui));
-            break;
-         case OPCODE_STENCIL_OP:
-            CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));
-            break;
-         case OPCODE_STENCIL_FUNC_SEPARATE:
-            CALL_StencilFuncSeparate(ctx->Exec,
-                                     (n[1].e, n[2].e, n[3].i, n[4].ui));
-            break;
-         case OPCODE_STENCIL_MASK_SEPARATE:
-            CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));
-            break;
-         case OPCODE_STENCIL_OP_SEPARATE:
-            CALL_StencilOpSeparate(ctx->Exec,
-                                   (n[1].e, n[2].e, n[3].e, n[4].e));
-            break;
-         case OPCODE_TEXENV:
-            {
-               GLfloat params[4];
-               params[0] = n[3].f;
-               params[1] = n[4].f;
-               params[2] = n[5].f;
-               params[3] = n[6].f;
-               CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_TEXGEN:
-            {
-               GLfloat params[4];
-               params[0] = n[3].f;
-               params[1] = n[4].f;
-               params[2] = n[5].f;
-               params[3] = n[6].f;
-               CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_TEXPARAMETER:
-            {
-               GLfloat params[4];
-               params[0] = n[3].f;
-               params[1] = n[4].f;
-               params[2] = n[5].f;
-               params[3] = n[6].f;
-               CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_TEX_IMAGE1D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexImage1D(ctx->Exec, (n[1].e,      /* target */
-                                           n[2].i,      /* level */
-                                           n[3].i,      /* components */
-                                           n[4].i,      /* width */
-                                           n[5].e,      /* border */
-                                           n[6].e,      /* format */
-                                           n[7].e,      /* type */
-                                           n[8].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TEX_IMAGE2D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexImage2D(ctx->Exec, (n[1].e,      /* target */
-                                           n[2].i,      /* level */
-                                           n[3].i,      /* components */
-                                           n[4].i,      /* width */
-                                           n[5].i,      /* height */
-                                           n[6].e,      /* border */
-                                           n[7].e,      /* format */
-                                           n[8].e,      /* type */
-                                           n[9].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TEX_IMAGE3D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexImage3D(ctx->Exec, (n[1].e,      /* target */
-                                           n[2].i,      /* level */
-                                           n[3].i,      /* components */
-                                           n[4].i,      /* width */
-                                           n[5].i,      /* height */
-                                           n[6].i,      /* depth  */
-                                           n[7].e,      /* border */
-                                           n[8].e,      /* format */
-                                           n[9].e,      /* type */
-                                           n[10].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TEX_SUB_IMAGE1D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                              n[4].i, n[5].e,
-                                              n[6].e, n[7].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TEX_SUB_IMAGE2D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                              n[4].i, n[5].e,
-                                              n[6].i, n[7].e, n[8].e,
-                                              n[9].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TEX_SUB_IMAGE3D:
-            {
-               const struct gl_pixelstore_attrib save = ctx->Unpack;
-               ctx->Unpack = ctx->DefaultPacking;
-               CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
-                                              n[4].i, n[5].i, n[6].i, n[7].i,
-                                              n[8].i, n[9].e, n[10].e,
-                                              n[11].data));
-               ctx->Unpack = save;      /* restore */
-            }
-            break;
-         case OPCODE_TRANSLATE:
-            CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
-            break;
-         case OPCODE_VIEWPORT:
-            CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
-                                      (GLsizei) n[3].i, (GLsizei) n[4].i));
-            break;
-         case OPCODE_WINDOW_POS:
-            CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_ACTIVE_TEXTURE:   /* GL_ARB_multitexture */
-            CALL_ActiveTextureARB(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_1D:  /* GL_ARB_texture_compression */
-            CALL_CompressedTexImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
-                                                     n[4].i, n[5].i, n[6].i,
-                                                     n[7].data));
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_2D:  /* GL_ARB_texture_compression */
-            CALL_CompressedTexImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
-                                                     n[4].i, n[5].i, n[6].i,
-                                                     n[7].i, n[8].data));
-            break;
-         case OPCODE_COMPRESSED_TEX_IMAGE_3D:  /* GL_ARB_texture_compression */
-            CALL_CompressedTexImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
-                                                     n[4].i, n[5].i, n[6].i,
-                                                     n[7].i, n[8].i,
-                                                     n[9].data));
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:      /* GL_ARB_texture_compress */
-            CALL_CompressedTexSubImage1DARB(ctx->Exec,
-                                            (n[1].e, n[2].i, n[3].i, n[4].i,
-                                             n[5].e, n[6].i, n[7].data));
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:      /* GL_ARB_texture_compress */
-            CALL_CompressedTexSubImage2DARB(ctx->Exec,
-                                            (n[1].e, n[2].i, n[3].i, n[4].i,
-                                             n[5].i, n[6].i, n[7].e, n[8].i,
-                                             n[9].data));
-            break;
-         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:      /* GL_ARB_texture_compress */
-            CALL_CompressedTexSubImage3DARB(ctx->Exec,
-                                            (n[1].e, n[2].i, n[3].i, n[4].i,
-                                             n[5].i, n[6].i, n[7].i, n[8].i,
-                                             n[9].e, n[10].i, n[11].data));
-            break;
-         case OPCODE_SAMPLE_COVERAGE:  /* GL_ARB_multisample */
-            CALL_SampleCoverageARB(ctx->Exec, (n[1].f, n[2].b));
-            break;
-         case OPCODE_WINDOW_POS_ARB:   /* GL_ARB_window_pos */
-            CALL_WindowPos3fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f));
-            break;
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-         case OPCODE_BIND_PROGRAM_NV:  /* GL_NV_vertex_program */
-            CALL_BindProgramNV(ctx->Exec, (n[1].e, n[2].ui));
-            break;
-#endif
-#if FEATURE_NV_vertex_program
-         case OPCODE_EXECUTE_PROGRAM_NV:
-            {
-               GLfloat v[4];
-               v[0] = n[3].f;
-               v[1] = n[4].f;
-               v[2] = n[5].f;
-               v[3] = n[6].f;
-               CALL_ExecuteProgramNV(ctx->Exec, (n[1].e, n[2].ui, v));
-            }
-            break;
-         case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
-            CALL_RequestResidentProgramsNV(ctx->Exec, (n[1].ui,
-                                                       (GLuint *) n[2].data));
-            break;
-         case OPCODE_LOAD_PROGRAM_NV:
-            CALL_LoadProgramNV(ctx->Exec, (n[1].e, n[2].ui, n[3].i,
-                                           (const GLubyte *) n[4].data));
-            break;
-         case OPCODE_TRACK_MATRIX_NV:
-            CALL_TrackMatrixNV(ctx->Exec, (n[1].e, n[2].ui, n[3].e, n[4].e));
-            break;
-#endif
-
-#if FEATURE_NV_fragment_program
-         case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:
-            CALL_ProgramLocalParameter4fARB(ctx->Exec,
-                                            (n[1].e, n[2].ui, n[3].f, n[4].f,
-                                             n[5].f, n[6].f));
-            break;
-         case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
-            CALL_ProgramNamedParameter4fNV(ctx->Exec, (n[1].ui, n[2].i,
-                                                       (const GLubyte *) n[3].
-                                                       data, n[4].f, n[5].f,
-                                                       n[6].f, n[7].f));
-            break;
-#endif
-
-         case OPCODE_ACTIVE_STENCIL_FACE_EXT:
-            CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_DEPTH_BOUNDS_EXT:
-            CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
-            break;
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-         case OPCODE_PROGRAM_STRING_ARB:
-            CALL_ProgramStringARB(ctx->Exec,
-                                  (n[1].e, n[2].e, n[3].i, n[4].data));
-            break;
-#endif
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program
-         case OPCODE_PROGRAM_ENV_PARAMETER_ARB:
-            CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
-                                                      n[4].f, n[5].f,
-                                                      n[6].f));
-            break;
-#endif
-#if FEATURE_queryobj
-         case OPCODE_BEGIN_QUERY_ARB:
-            CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));
-            break;
-         case OPCODE_END_QUERY_ARB:
-            CALL_EndQueryARB(ctx->Exec, (n[1].e));
-            break;
-#endif
-         case OPCODE_DRAW_BUFFERS_ARB:
-            {
-               GLenum buffers[MAX_DRAW_BUFFERS];
-               GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);
-               for (i = 0; i < count; i++)
-                  buffers[i] = n[2 + i].e;
-               CALL_DrawBuffersARB(ctx->Exec, (n[1].i, buffers));
-            }
-            break;
-#if FEATURE_EXT_framebuffer_blit
-	 case OPCODE_BLIT_FRAMEBUFFER:
-	    CALL_BlitFramebufferEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,
-                                                n[5].i, n[6].i, n[7].i, n[8].i,
-                                                n[9].i, n[10].e));
-	    break;
-#endif
-
-	 case OPCODE_USE_PROGRAM:
-	    CALL_UseProgramObjectARB(ctx->Exec, (n[1].ui));
-	    break;
-	 case OPCODE_USE_SHADER_PROGRAM_EXT:
-	    CALL_UseShaderProgramEXT(ctx->Exec, (n[1].ui, n[2].ui));
-	    break;
-	 case OPCODE_ACTIVE_PROGRAM_EXT:
-	    CALL_ActiveProgramEXT(ctx->Exec, (n[1].ui));
-	    break;
-	 case OPCODE_UNIFORM_1F:
-	    CALL_Uniform1fARB(ctx->Exec, (n[1].i, n[2].f));
-	    break;
-	 case OPCODE_UNIFORM_2F:
-	    CALL_Uniform2fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f));
-	    break;
-	 case OPCODE_UNIFORM_3F:
-	    CALL_Uniform3fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));
-	    break;
-	 case OPCODE_UNIFORM_4F:
-	    CALL_Uniform4fARB(ctx->Exec,
-                              (n[1].i, n[2].f, n[3].f, n[4].f, n[5].f));
-	    break;
-	 case OPCODE_UNIFORM_1FV:
-	    CALL_Uniform1fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_2FV:
-	    CALL_Uniform2fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_3FV:
-	    CALL_Uniform3fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_4FV:
-	    CALL_Uniform4fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_1I:
-	    CALL_Uniform1iARB(ctx->Exec, (n[1].i, n[2].i));
-	    break;
-	 case OPCODE_UNIFORM_2I:
-	    CALL_Uniform2iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));
-	    break;
-	 case OPCODE_UNIFORM_3I:
-	    CALL_Uniform3iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
-	    break;
-	 case OPCODE_UNIFORM_4I:
-	    CALL_Uniform4iARB(ctx->Exec,
-                              (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
-	    break;
-	 case OPCODE_UNIFORM_1IV:
-	    CALL_Uniform1ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_2IV:
-	    CALL_Uniform2ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_3IV:
-	    CALL_Uniform3ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_4IV:
-	    CALL_Uniform4ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));
-	    break;
-	 case OPCODE_UNIFORM_1UI:
-	    /*CALL_Uniform1uiARB(ctx->Exec, (n[1].i, n[2].i));*/
-	    break;
-	 case OPCODE_UNIFORM_2UI:
-	    /*CALL_Uniform2uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));*/
-	    break;
-	 case OPCODE_UNIFORM_3UI:
-	    /*CALL_Uniform3uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));*/
-	    break;
-	 case OPCODE_UNIFORM_4UI:
-	    /*CALL_Uniform4uiARB(ctx->Exec,
-                              (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
-            */
-	    break;
-	 case OPCODE_UNIFORM_1UIV:
-	    /*CALL_Uniform1uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
-	    break;
-	 case OPCODE_UNIFORM_2UIV:
-	    /*CALL_Uniform2uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
-	    break;
-	 case OPCODE_UNIFORM_3UIV:
-	    /*CALL_Uniform3uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
-	    break;
-	 case OPCODE_UNIFORM_4UIV:
-	    /*CALL_Uniform4uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/
-	    break;
-	 case OPCODE_UNIFORM_MATRIX22:
-	    CALL_UniformMatrix2fvARB(ctx->Exec,
-                                     (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX33:
-	    CALL_UniformMatrix3fvARB(ctx->Exec,
-                                     (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX44:
-	    CALL_UniformMatrix4fvARB(ctx->Exec,
-                                     (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX23:
-	    CALL_UniformMatrix2x3fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX32:
-	    CALL_UniformMatrix3x2fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX24:
-	    CALL_UniformMatrix2x4fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX42:
-	    CALL_UniformMatrix4x2fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX34:
-	    CALL_UniformMatrix3x4fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-	 case OPCODE_UNIFORM_MATRIX43:
-	    CALL_UniformMatrix4x3fv(ctx->Exec,
-                                    (n[1].i, n[2].i, n[3].b, n[4].data));
-	    break;
-
-         case OPCODE_TEX_BUMP_PARAMETER_ATI:
-            {
-               GLfloat values[4];
-               GLuint i, pname = n[1].ui;
-
-               for (i = 0; i < 4; i++)
-                  values[i] = n[1 + i].f;
-               CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values));
-            }
-            break;
-#if FEATURE_ATI_fragment_shader
-         case OPCODE_BIND_FRAGMENT_SHADER_ATI:
-            CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
-            break;
-         case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:
-            {
-               GLfloat values[4];
-               GLuint i, dst = n[1].ui;
-
-               for (i = 0; i < 4; i++)
-                  values[i] = n[1 + i].f;
-               CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, values));
-            }
-            break;
-#endif
-         case OPCODE_ATTR_1F_NV:
-            CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
-            break;
-         case OPCODE_ATTR_2F_NV:
-            /* Really shouldn't have to do this - the Node structure
-             * is convenient, but it would be better to store the data
-             * packed appropriately so that it can be sent directly
-             * on.  With x86_64 becoming common, this will start to
-             * matter more.
-             */
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib2fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f));
-            break;
-         case OPCODE_ATTR_3F_NV:
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib3fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
-                                                 n[4].f));
-            break;
-         case OPCODE_ATTR_4F_NV:
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib4fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
-                                                 n[4].f, n[5].f));
-            break;
-         case OPCODE_ATTR_1F_ARB:
-            CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
-            break;
-         case OPCODE_ATTR_2F_ARB:
-            /* Really shouldn't have to do this - the Node structure
-             * is convenient, but it would be better to store the data
-             * packed appropriately so that it can be sent directly
-             * on.  With x86_64 becoming common, this will start to
-             * matter more.
-             */
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib2fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f));
-            break;
-         case OPCODE_ATTR_3F_ARB:
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib3fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
-                                                  n[4].f));
-            break;
-         case OPCODE_ATTR_4F_ARB:
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
-            else
-               CALL_VertexAttrib4fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
-                                                  n[4].f, n[5].f));
-            break;
-         case OPCODE_MATERIAL:
-            if (sizeof(Node) == sizeof(GLfloat))
-               CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
-            else {
-               GLfloat f[4];
-               f[0] = n[3].f;
-               f[1] = n[4].f;
-               f[2] = n[5].f;
-               f[3] = n[6].f;
-               CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, f));
-            }
-            break;
-         case OPCODE_BEGIN:
-            CALL_Begin(ctx->Exec, (n[1].e));
-            break;
-         case OPCODE_END:
-            CALL_End(ctx->Exec, ());
-            break;
-         case OPCODE_RECTF:
-            CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
-            break;
-         case OPCODE_EVAL_C1:
-            CALL_EvalCoord1f(ctx->Exec, (n[1].f));
-            break;
-         case OPCODE_EVAL_C2:
-            CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
-            break;
-         case OPCODE_EVAL_P1:
-            CALL_EvalPoint1(ctx->Exec, (n[1].i));
-            break;
-         case OPCODE_EVAL_P2:
-            CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
-            break;
-
-         /* GL_EXT_texture_integer */
-         case OPCODE_CLEARCOLOR_I:
-            CALL_ClearColorIiEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
-            break;
-         case OPCODE_CLEARCOLOR_UI:
-            CALL_ClearColorIuiEXT(ctx->Exec,
-                                  (n[1].ui, n[2].ui, n[3].ui, n[4].ui));
-            break;
-         case OPCODE_TEXPARAMETER_I:
-            {
-               GLint params[4];
-               params[0] = n[3].i;
-               params[1] = n[4].i;
-               params[2] = n[5].i;
-               params[3] = n[6].i;
-               CALL_TexParameterIivEXT(ctx->Exec, (n[1].e, n[2].e, params));
-            }
-            break;
-         case OPCODE_TEXPARAMETER_UI:
-            {
-               GLuint params[4];
-               params[0] = n[3].ui;
-               params[1] = n[4].ui;
-               params[2] = n[5].ui;
-               params[3] = n[6].ui;
-               CALL_TexParameterIuivEXT(ctx->Exec, (n[1].e, n[2].e, params));
-            }
-            break;
-
-         case OPCODE_VERTEX_ATTRIB_DIVISOR:
-            /* GL_ARB_instanced_arrays */
-            CALL_VertexAttribDivisorARB(ctx->Exec, (n[1].ui, n[2].ui));
-            break;
-
-         case OPCODE_CONTINUE:
-            n = (Node *) n[1].next;
-            break;
-         case OPCODE_END_OF_LIST:
-            done = GL_TRUE;
-            break;
-         default:
-            {
-               char msg[1000];
-               _mesa_snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",
-                             (int) opcode);
-               _mesa_problem(ctx, "%s", msg);
-            }
-            done = GL_TRUE;
-         }
-
-         /* increment n to point to next compiled command */
-         if (opcode != OPCODE_CONTINUE) {
-            n += InstSize[opcode];
-         }
-      }
-   }
-
-   if (ctx->Driver.EndCallList)
-      ctx->Driver.EndCallList(ctx);
-
-   ctx->ListState.CallDepth--;
-}
-
-
-
-/**********************************************************************/
-/*                           GL functions                             */
-/**********************************************************************/
-
-/**
- * Test if a display list number is valid.
- */
-static GLboolean GLAPIENTRY
-_mesa_IsList(GLuint list)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-   return islist(ctx, list);
-}
-
-
-/**
- * Delete a sequence of consecutive display lists.
- */
-static void GLAPIENTRY
-_mesa_DeleteLists(GLuint list, GLsizei range)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint i;
-   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (range < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");
-      return;
-   }
-   for (i = list; i < list + range; i++) {
-      destroy_list(ctx, i);
-   }
-}
-
-
-/**
- * Return a display list number, n, such that lists n through n+range-1
- * are free.
- */
-static GLuint GLAPIENTRY
-_mesa_GenLists(GLsizei range)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint base;
-   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   if (range < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");
-      return 0;
-   }
-   if (range == 0) {
-      return 0;
-   }
-
-   /*
-    * Make this an atomic operation
-    */
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
-   if (base) {
-      /* reserve the list IDs by with empty/dummy lists */
-      GLint i;
-      for (i = 0; i < range; i++) {
-         _mesa_HashInsert(ctx->Shared->DisplayList, base + i,
-                          make_list(base + i, 1));
-      }
-   }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
-   return base;
-}
-
-
-/**
- * Begin a new display list.
- */
-static void GLAPIENTRY
-_mesa_NewList(GLuint name, GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glNewList %u %s\n", name,
-                  _mesa_lookup_enum_by_nr(mode));
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
-      return;
-   }
-
-   if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");
-      return;
-   }
-
-   if (ctx->ListState.CurrentList) {
-      /* already compiling a display list */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
-      return;
-   }
-
-   ctx->CompileFlag = GL_TRUE;
-   ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
-
-   /* Reset acumulated list state:
-    */
-   invalidate_saved_current_state( ctx );
-
-   /* Allocate new display list */
-   ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);
-   ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;
-   ctx->ListState.CurrentPos = 0;
-
-   ctx->Driver.NewList(ctx, name, mode);
-
-   ctx->CurrentDispatch = ctx->Save;
-   _glapi_set_dispatch(ctx->CurrentDispatch);
-}
-
-
-/**
- * End definition of current display list. 
- */
-static void GLAPIENTRY
-_mesa_EndList(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   SAVE_FLUSH_VERTICES(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glEndList\n");
-
-   /* Check that a list is under construction */
-   if (!ctx->ListState.CurrentList) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
-      return;
-   }
-   
-   /* Call before emitting END_OF_LIST, in case the driver wants to
-    * emit opcodes itself.
-    */
-   ctx->Driver.EndList(ctx);
-
-   (void) alloc_instruction(ctx, OPCODE_END_OF_LIST, 0);
-
-   /* Destroy old list, if any */
-   destroy_list(ctx, ctx->ListState.CurrentList->Name);
-
-   /* Install the new list */
-   _mesa_HashInsert(ctx->Shared->DisplayList,
-                    ctx->ListState.CurrentList->Name,
-                    ctx->ListState.CurrentList);
-
-
-   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
-      mesa_print_display_list(ctx->ListState.CurrentList->Name);
-
-   ctx->ListState.CurrentList = NULL;
-   ctx->ExecuteFlag = GL_TRUE;
-   ctx->CompileFlag = GL_FALSE;
-
-   ctx->CurrentDispatch = ctx->Exec;
-   _glapi_set_dispatch(ctx->CurrentDispatch);
-}
-
-
-void GLAPIENTRY
-_mesa_CallList(GLuint list)
-{
-   GLboolean save_compile_flag;
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_CURRENT(ctx, 0);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCallList %d\n", list);
-
-   if (list == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");
-      return;
-   }
-
-   if (0)
-      mesa_print_display_list( list );
-
-   /* VERY IMPORTANT:  Save the CompileFlag status, turn it off,
-    * execute the display list, and restore the CompileFlag.
-    */
-   save_compile_flag = ctx->CompileFlag;
-   if (save_compile_flag) {
-      ctx->CompileFlag = GL_FALSE;
-   }
-
-   execute_list(ctx, list);
-   ctx->CompileFlag = save_compile_flag;
-
-   /* also restore API function pointers to point to "save" versions */
-   if (save_compile_flag) {
-      ctx->CurrentDispatch = ctx->Save;
-      _glapi_set_dispatch(ctx->CurrentDispatch);
-   }
-}
-
-
-/**
- * Execute glCallLists:  call multiple display lists.
- */
-void GLAPIENTRY
-_mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   GLboolean save_compile_flag;
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCallLists %d\n", n);
-
-   switch (type) {
-   case GL_BYTE:
-   case GL_UNSIGNED_BYTE:
-   case GL_SHORT:
-   case GL_UNSIGNED_SHORT:
-   case GL_INT:
-   case GL_UNSIGNED_INT:
-   case GL_FLOAT:
-   case GL_2_BYTES:
-   case GL_3_BYTES:
-   case GL_4_BYTES:
-      /* OK */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
-      return;
-   }
-
-   /* Save the CompileFlag status, turn it off, execute display list,
-    * and restore the CompileFlag.
-    */
-   save_compile_flag = ctx->CompileFlag;
-   ctx->CompileFlag = GL_FALSE;
-
-   for (i = 0; i < n; i++) {
-      GLuint list = (GLuint) (ctx->List.ListBase + translate_id(i, type, lists));
-      execute_list(ctx, list);
-   }
-
-   ctx->CompileFlag = save_compile_flag;
-
-   /* also restore API function pointers to point to "save" versions */
-   if (save_compile_flag) {
-      ctx->CurrentDispatch = ctx->Save;
-      _glapi_set_dispatch(ctx->CurrentDispatch);
-   }
-}
-
-
-/**
- * Set the offset added to list numbers in glCallLists.
- */
-static void GLAPIENTRY
-_mesa_ListBase(GLuint base)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   ctx->List.ListBase = base;
-}
-
-
-/* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
- */
-static void GLAPIENTRY
-exec_Finish(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_Finish(ctx->Exec, ());
-}
-
-static void GLAPIENTRY
-exec_Flush(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_Flush(ctx->Exec, ());
-}
-
-static void GLAPIENTRY
-exec_GetBooleanv(GLenum pname, GLboolean *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetBooleanv(ctx->Exec, (pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetClipPlane(GLenum plane, GLdouble * equation)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetClipPlane(ctx->Exec, (plane, equation));
-}
-
-static void GLAPIENTRY
-exec_GetDoublev(GLenum pname, GLdouble *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetDoublev(ctx->Exec, (pname, params));
-}
-
-static GLenum GLAPIENTRY
-exec_GetError(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_GetError(ctx->Exec, ());
-}
-
-static void GLAPIENTRY
-exec_GetFloatv(GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetFloatv(ctx->Exec, (pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetIntegerv(GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetIntegerv(ctx->Exec, (pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetLightfv(GLenum light, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetLightfv(ctx->Exec, (light, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetLightiv(GLenum light, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetLightiv(ctx->Exec, (light, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetMapdv(GLenum target, GLenum query, GLdouble * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMapdv(ctx->Exec, (target, query, v));
-}
-
-static void GLAPIENTRY
-exec_GetMapfv(GLenum target, GLenum query, GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMapfv(ctx->Exec, (target, query, v));
-}
-
-static void GLAPIENTRY
-exec_GetMapiv(GLenum target, GLenum query, GLint * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMapiv(ctx->Exec, (target, query, v));
-}
-
-static void GLAPIENTRY
-exec_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMaterialfv(ctx->Exec, (face, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetMaterialiv(GLenum face, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMaterialiv(ctx->Exec, (face, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetPixelMapfv(GLenum map, GLfloat *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetPixelMapfv(ctx->Exec, (map, values));
-}
-
-static void GLAPIENTRY
-exec_GetPixelMapuiv(GLenum map, GLuint *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetPixelMapuiv(ctx->Exec, (map, values));
-}
-
-static void GLAPIENTRY
-exec_GetPixelMapusv(GLenum map, GLushort *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetPixelMapusv(ctx->Exec, (map, values));
-}
-
-static void GLAPIENTRY
-exec_GetPolygonStipple(GLubyte * dest)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetPolygonStipple(ctx->Exec, (dest));
-}
-
-static const GLubyte *GLAPIENTRY
-exec_GetString(GLenum name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_GetString(ctx->Exec, (name));
-}
-
-static void GLAPIENTRY
-exec_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexEnvfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexEnviv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexEnviv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexGendv(ctx->Exec, (coord, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexGenfv(ctx->Exec, (coord, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexGeniv(ctx->Exec, (coord, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexImage(GLenum target, GLint level, GLenum format,
-                 GLenum type, GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexImage(ctx->Exec, (target, level, format, type, pixels));
-}
-
-static void GLAPIENTRY
-exec_GetTexLevelParameterfv(GLenum target, GLint level,
-                            GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexLevelParameterfv(ctx->Exec, (target, level, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexLevelParameteriv(GLenum target, GLint level,
-                            GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexLevelParameteriv(ctx->Exec, (target, level, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexParameterfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetTexParameteriv(ctx->Exec, (target, pname, params));
-}
-
-static GLboolean GLAPIENTRY
-exec_IsEnabled(GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_IsEnabled(ctx->Exec, (cap));
-}
-
-static void GLAPIENTRY
-exec_PixelStoref(GLenum pname, GLfloat param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_PixelStoref(ctx->Exec, (pname, param));
-}
-
-static void GLAPIENTRY
-exec_PixelStorei(GLenum pname, GLint param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_PixelStorei(ctx->Exec, (pname, param));
-}
-
-static void GLAPIENTRY
-exec_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
-                GLenum format, GLenum type, GLvoid * pixels)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_ReadPixels(ctx->Exec, (x, y, width, height, format, type, pixels));
-}
-
-static GLint GLAPIENTRY
-exec_RenderMode(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_RenderMode(ctx->Exec, (mode));
-}
-
-static void GLAPIENTRY
-exec_FeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_FeedbackBuffer(ctx->Exec, (size, type, buffer));
-}
-
-static void GLAPIENTRY
-exec_SelectBuffer(GLsizei size, GLuint * buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_SelectBuffer(ctx->Exec, (size, buffer));
-}
-
-static GLboolean GLAPIENTRY
-exec_AreTexturesResident(GLsizei n, const GLuint * texName,
-                         GLboolean * residences)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_AreTexturesResident(ctx->Exec, (n, texName, residences));
-}
-
-static void GLAPIENTRY
-exec_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_ColorPointer(ctx->Exec, (size, type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_DeleteTextures(GLsizei n, const GLuint * texName)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_DeleteTextures(ctx->Exec, (n, texName));
-}
-
-static void GLAPIENTRY
-exec_DisableClientState(GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_DisableClientState(ctx->Exec, (cap));
-}
-
-static void GLAPIENTRY
-exec_EdgeFlagPointer(GLsizei stride, const GLvoid * vptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_EdgeFlagPointer(ctx->Exec, (stride, vptr));
-}
-
-static void GLAPIENTRY
-exec_EnableClientState(GLenum cap)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_EnableClientState(ctx->Exec, (cap));
-}
-
-static void GLAPIENTRY
-exec_GenTextures(GLsizei n, GLuint * texName)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GenTextures(ctx->Exec, (n, texName));
-}
-
-static void GLAPIENTRY
-exec_GetPointerv(GLenum pname, GLvoid **params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetPointerv(ctx->Exec, (pname, params));
-}
-
-static void GLAPIENTRY
-exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_IndexPointer(ctx->Exec, (type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_InterleavedArrays(ctx->Exec, (format, stride, pointer));
-}
-
-static GLboolean GLAPIENTRY
-exec_IsTexture(GLuint texture)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   return CALL_IsTexture(ctx->Exec, (texture));
-}
-
-static void GLAPIENTRY
-exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_NormalPointer(ctx->Exec, (type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_PopClientAttrib(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_PopClientAttrib(ctx->Exec, ());
-}
-
-static void GLAPIENTRY
-exec_PushClientAttrib(GLbitfield mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_PushClientAttrib(ctx->Exec, (mask));
-}
-
-static void GLAPIENTRY
-exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
-                     const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_TexCoordPointer(ctx->Exec, (size, type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetCompressedTexImageARB(ctx->Exec, (target, level, img));
-}
-
-static void GLAPIENTRY
-exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
-                   const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_VertexPointer(ctx->Exec, (size, type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
-                             GLint x, GLint y, GLsizei width)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_CopyConvolutionFilter1D(ctx->Exec,
-                                (target, internalFormat, x, y, width));
-}
-
-static void GLAPIENTRY
-exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
-                             GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_CopyConvolutionFilter2D(ctx->Exec,
-                                (target, internalFormat, x, y, width,
-                                 height));
-}
-
-static void GLAPIENTRY
-exec_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetColorTable(ctx->Exec, (target, format, type, data));
-}
-
-static void GLAPIENTRY
-exec_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetColorTableParameterfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetColorTableParameteriv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
-                          GLvoid * image)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetConvolutionFilter(ctx->Exec, (target, format, type, image));
-}
-
-static void GLAPIENTRY
-exec_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetConvolutionParameterfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetConvolutionParameteriv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
-                  GLenum type, GLvoid *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetHistogram(ctx->Exec, (target, reset, format, type, values));
-}
-
-static void GLAPIENTRY
-exec_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetHistogramParameterfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetHistogramParameteriv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
-               GLenum type, GLvoid *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMinmax(ctx->Exec, (target, reset, format, type, values));
-}
-
-static void GLAPIENTRY
-exec_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMinmaxParameterfv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetMinmaxParameteriv(ctx->Exec, (target, pname, params));
-}
-
-static void GLAPIENTRY
-exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
-                        GLvoid *row, GLvoid *column, GLvoid *span)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_GetSeparableFilter(ctx->Exec,
-                           (target, format, type, row, column, span));
-}
-
-static void GLAPIENTRY
-exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
-                       GLsizei width, GLsizei height, GLenum format,
-                       GLenum type, const GLvoid *row, const GLvoid *column)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_SeparableFilter2D(ctx->Exec,
-                          (target, internalFormat, width, height, format,
-                           type, row, column));
-}
-
-static void GLAPIENTRY
-exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
-                     GLsizei count, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_ColorPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_EdgeFlagPointerEXT(ctx->Exec, (stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
-                     const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_IndexPointerEXT(ctx->Exec, (type, stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
-                      const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_NormalPointerEXT(ctx->Exec, (type, stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
-                        GLsizei count, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_TexCoordPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
-                      GLsizei count, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_VertexPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
-}
-
-static void GLAPIENTRY
-exec_LockArraysEXT(GLint first, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_LockArraysEXT(ctx->Exec, (first, count));
-}
-
-static void GLAPIENTRY
-exec_UnlockArraysEXT(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_UnlockArraysEXT(ctx->Exec, ());
-}
-
-static void GLAPIENTRY
-exec_ClientActiveTextureARB(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_ClientActiveTextureARB(ctx->Exec, (target));
-}
-
-static void GLAPIENTRY
-exec_SecondaryColorPointerEXT(GLint size, GLenum type,
-                              GLsizei stride, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_SecondaryColorPointerEXT(ctx->Exec, (size, type, stride, ptr));
-}
-
-static void GLAPIENTRY
-exec_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_FogCoordPointerEXT(ctx->Exec, (type, stride, ptr));
-}
-
-/* GL_EXT_multi_draw_arrays */
-static void GLAPIENTRY
-exec_MultiDrawArraysEXT(GLenum mode, const GLint *first,
-                        const GLsizei *count, GLsizei primcount)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount));
-}
-
-/* GL_IBM_multimode_draw_arrays */
-static void GLAPIENTRY
-exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first,
-                            const GLsizei * count, GLsizei primcount,
-                            GLint modestride)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_MultiModeDrawArraysIBM(ctx->Exec,
-                               (mode, first, count, primcount, modestride));
-}
-
-/* GL_IBM_multimode_draw_arrays */
-static void GLAPIENTRY
-exec_MultiModeDrawElementsIBM(const GLenum * mode,
-                              const GLsizei * count,
-                              GLenum type,
-                              const GLvoid * const *indices,
-                              GLsizei primcount, GLint modestride)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_MultiModeDrawElementsIBM(ctx->Exec,
-                                 (mode, count, type, indices, primcount,
-                                  modestride));
-}
-
-
-
-/**
- * Setup the given dispatch table to point to Mesa's display list
- * building functions.
- *
- * This does not include any of the tnl functions - they are
- * initialized from _mesa_init_api_defaults and from the active vtxfmt
- * struct.
- */
-struct _glapi_table *
-_mesa_create_save_table(void)
-{
-   struct _glapi_table *table;
-
-   table = _mesa_alloc_dispatch_table(_gloffset_COUNT);
-   if (table == NULL)
-      return NULL;
-
-   _mesa_loopback_init_api_table(table);
-
-   /* GL 1.0 */
-   SET_Accum(table, save_Accum);
-   SET_AlphaFunc(table, save_AlphaFunc);
-   SET_Bitmap(table, save_Bitmap);
-   SET_BlendFunc(table, save_BlendFunc);
-   SET_CallList(table, save_CallList);
-   SET_CallLists(table, save_CallLists);
-   SET_Clear(table, save_Clear);
-   SET_ClearAccum(table, save_ClearAccum);
-   SET_ClearColor(table, save_ClearColor);
-   SET_ClearDepth(table, save_ClearDepth);
-   SET_ClearIndex(table, save_ClearIndex);
-   SET_ClearStencil(table, save_ClearStencil);
-   SET_ClipPlane(table, save_ClipPlane);
-   SET_ColorMask(table, save_ColorMask);
-   SET_ColorMaskIndexedEXT(table, save_ColorMaskIndexed);
-   SET_ColorMaterial(table, save_ColorMaterial);
-   SET_CopyPixels(table, save_CopyPixels);
-   SET_CullFace(table, save_CullFace);
-   SET_DeleteLists(table, _mesa_DeleteLists);
-   SET_DepthFunc(table, save_DepthFunc);
-   SET_DepthMask(table, save_DepthMask);
-   SET_DepthRange(table, save_DepthRange);
-   SET_Disable(table, save_Disable);
-   SET_DisableIndexedEXT(table, save_DisableIndexed);
-   SET_DrawBuffer(table, save_DrawBuffer);
-   SET_DrawPixels(table, save_DrawPixels);
-   SET_Enable(table, save_Enable);
-   SET_EnableIndexedEXT(table, save_EnableIndexed);
-   SET_EndList(table, _mesa_EndList);
-   SET_EvalMesh1(table, save_EvalMesh1);
-   SET_EvalMesh2(table, save_EvalMesh2);
-   SET_Finish(table, exec_Finish);
-   SET_Flush(table, exec_Flush);
-   SET_Fogf(table, save_Fogf);
-   SET_Fogfv(table, save_Fogfv);
-   SET_Fogi(table, save_Fogi);
-   SET_Fogiv(table, save_Fogiv);
-   SET_FrontFace(table, save_FrontFace);
-   SET_Frustum(table, save_Frustum);
-   SET_GenLists(table, _mesa_GenLists);
-   SET_GetBooleanv(table, exec_GetBooleanv);
-   SET_GetClipPlane(table, exec_GetClipPlane);
-   SET_GetDoublev(table, exec_GetDoublev);
-   SET_GetError(table, exec_GetError);
-   SET_GetFloatv(table, exec_GetFloatv);
-   SET_GetIntegerv(table, exec_GetIntegerv);
-   SET_GetLightfv(table, exec_GetLightfv);
-   SET_GetLightiv(table, exec_GetLightiv);
-   SET_GetMapdv(table, exec_GetMapdv);
-   SET_GetMapfv(table, exec_GetMapfv);
-   SET_GetMapiv(table, exec_GetMapiv);
-   SET_GetMaterialfv(table, exec_GetMaterialfv);
-   SET_GetMaterialiv(table, exec_GetMaterialiv);
-   SET_GetPixelMapfv(table, exec_GetPixelMapfv);
-   SET_GetPixelMapuiv(table, exec_GetPixelMapuiv);
-   SET_GetPixelMapusv(table, exec_GetPixelMapusv);
-   SET_GetPolygonStipple(table, exec_GetPolygonStipple);
-   SET_GetString(table, exec_GetString);
-   SET_GetTexEnvfv(table, exec_GetTexEnvfv);
-   SET_GetTexEnviv(table, exec_GetTexEnviv);
-   SET_GetTexGendv(table, exec_GetTexGendv);
-   SET_GetTexGenfv(table, exec_GetTexGenfv);
-   SET_GetTexGeniv(table, exec_GetTexGeniv);
-   SET_GetTexImage(table, exec_GetTexImage);
-   SET_GetTexLevelParameterfv(table, exec_GetTexLevelParameterfv);
-   SET_GetTexLevelParameteriv(table, exec_GetTexLevelParameteriv);
-   SET_GetTexParameterfv(table, exec_GetTexParameterfv);
-   SET_GetTexParameteriv(table, exec_GetTexParameteriv);
-   SET_Hint(table, save_Hint);
-   SET_IndexMask(table, save_IndexMask);
-   SET_InitNames(table, save_InitNames);
-   SET_IsEnabled(table, exec_IsEnabled);
-   SET_IsList(table, _mesa_IsList);
-   SET_LightModelf(table, save_LightModelf);
-   SET_LightModelfv(table, save_LightModelfv);
-   SET_LightModeli(table, save_LightModeli);
-   SET_LightModeliv(table, save_LightModeliv);
-   SET_Lightf(table, save_Lightf);
-   SET_Lightfv(table, save_Lightfv);
-   SET_Lighti(table, save_Lighti);
-   SET_Lightiv(table, save_Lightiv);
-   SET_LineStipple(table, save_LineStipple);
-   SET_LineWidth(table, save_LineWidth);
-   SET_ListBase(table, save_ListBase);
-   SET_LoadIdentity(table, save_LoadIdentity);
-   SET_LoadMatrixd(table, save_LoadMatrixd);
-   SET_LoadMatrixf(table, save_LoadMatrixf);
-   SET_LoadName(table, save_LoadName);
-   SET_LogicOp(table, save_LogicOp);
-   SET_Map1d(table, save_Map1d);
-   SET_Map1f(table, save_Map1f);
-   SET_Map2d(table, save_Map2d);
-   SET_Map2f(table, save_Map2f);
-   SET_MapGrid1d(table, save_MapGrid1d);
-   SET_MapGrid1f(table, save_MapGrid1f);
-   SET_MapGrid2d(table, save_MapGrid2d);
-   SET_MapGrid2f(table, save_MapGrid2f);
-   SET_MatrixMode(table, save_MatrixMode);
-   SET_MultMatrixd(table, save_MultMatrixd);
-   SET_MultMatrixf(table, save_MultMatrixf);
-   SET_NewList(table, save_NewList);
-   SET_Ortho(table, save_Ortho);
-   SET_PassThrough(table, save_PassThrough);
-   SET_PixelMapfv(table, save_PixelMapfv);
-   SET_PixelMapuiv(table, save_PixelMapuiv);
-   SET_PixelMapusv(table, save_PixelMapusv);
-   SET_PixelStoref(table, exec_PixelStoref);
-   SET_PixelStorei(table, exec_PixelStorei);
-   SET_PixelTransferf(table, save_PixelTransferf);
-   SET_PixelTransferi(table, save_PixelTransferi);
-   SET_PixelZoom(table, save_PixelZoom);
-   SET_PointSize(table, save_PointSize);
-   SET_PolygonMode(table, save_PolygonMode);
-   SET_PolygonOffset(table, save_PolygonOffset);
-   SET_PolygonStipple(table, save_PolygonStipple);
-   SET_PopAttrib(table, save_PopAttrib);
-   SET_PopMatrix(table, save_PopMatrix);
-   SET_PopName(table, save_PopName);
-   SET_PushAttrib(table, save_PushAttrib);
-   SET_PushMatrix(table, save_PushMatrix);
-   SET_PushName(table, save_PushName);
-   SET_RasterPos2d(table, save_RasterPos2d);
-   SET_RasterPos2dv(table, save_RasterPos2dv);
-   SET_RasterPos2f(table, save_RasterPos2f);
-   SET_RasterPos2fv(table, save_RasterPos2fv);
-   SET_RasterPos2i(table, save_RasterPos2i);
-   SET_RasterPos2iv(table, save_RasterPos2iv);
-   SET_RasterPos2s(table, save_RasterPos2s);
-   SET_RasterPos2sv(table, save_RasterPos2sv);
-   SET_RasterPos3d(table, save_RasterPos3d);
-   SET_RasterPos3dv(table, save_RasterPos3dv);
-   SET_RasterPos3f(table, save_RasterPos3f);
-   SET_RasterPos3fv(table, save_RasterPos3fv);
-   SET_RasterPos3i(table, save_RasterPos3i);
-   SET_RasterPos3iv(table, save_RasterPos3iv);
-   SET_RasterPos3s(table, save_RasterPos3s);
-   SET_RasterPos3sv(table, save_RasterPos3sv);
-   SET_RasterPos4d(table, save_RasterPos4d);
-   SET_RasterPos4dv(table, save_RasterPos4dv);
-   SET_RasterPos4f(table, save_RasterPos4f);
-   SET_RasterPos4fv(table, save_RasterPos4fv);
-   SET_RasterPos4i(table, save_RasterPos4i);
-   SET_RasterPos4iv(table, save_RasterPos4iv);
-   SET_RasterPos4s(table, save_RasterPos4s);
-   SET_RasterPos4sv(table, save_RasterPos4sv);
-   SET_ReadBuffer(table, save_ReadBuffer);
-   SET_ReadPixels(table, exec_ReadPixels);
-   SET_RenderMode(table, exec_RenderMode);
-   SET_Rotated(table, save_Rotated);
-   SET_Rotatef(table, save_Rotatef);
-   SET_Scaled(table, save_Scaled);
-   SET_Scalef(table, save_Scalef);
-   SET_Scissor(table, save_Scissor);
-   SET_FeedbackBuffer(table, exec_FeedbackBuffer);
-   SET_SelectBuffer(table, exec_SelectBuffer);
-   SET_ShadeModel(table, save_ShadeModel);
-   SET_StencilFunc(table, save_StencilFunc);
-   SET_StencilMask(table, save_StencilMask);
-   SET_StencilOp(table, save_StencilOp);
-   SET_TexEnvf(table, save_TexEnvf);
-   SET_TexEnvfv(table, save_TexEnvfv);
-   SET_TexEnvi(table, save_TexEnvi);
-   SET_TexEnviv(table, save_TexEnviv);
-   SET_TexGend(table, save_TexGend);
-   SET_TexGendv(table, save_TexGendv);
-   SET_TexGenf(table, save_TexGenf);
-   SET_TexGenfv(table, save_TexGenfv);
-   SET_TexGeni(table, save_TexGeni);
-   SET_TexGeniv(table, save_TexGeniv);
-   SET_TexImage1D(table, save_TexImage1D);
-   SET_TexImage2D(table, save_TexImage2D);
-   SET_TexParameterf(table, save_TexParameterf);
-   SET_TexParameterfv(table, save_TexParameterfv);
-   SET_TexParameteri(table, save_TexParameteri);
-   SET_TexParameteriv(table, save_TexParameteriv);
-   SET_Translated(table, save_Translated);
-   SET_Translatef(table, save_Translatef);
-   SET_Viewport(table, save_Viewport);
-
-   /* GL 1.1 */
-   SET_AreTexturesResident(table, exec_AreTexturesResident);
-   SET_BindTexture(table, save_BindTexture);
-   SET_ColorPointer(table, exec_ColorPointer);
-   SET_CopyTexImage1D(table, save_CopyTexImage1D);
-   SET_CopyTexImage2D(table, save_CopyTexImage2D);
-   SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);
-   SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);
-   SET_DeleteTextures(table, exec_DeleteTextures);
-   SET_DisableClientState(table, exec_DisableClientState);
-   SET_EdgeFlagPointer(table, exec_EdgeFlagPointer);
-   SET_EnableClientState(table, exec_EnableClientState);
-   SET_GenTextures(table, exec_GenTextures);
-   SET_GetPointerv(table, exec_GetPointerv);
-   SET_IndexPointer(table, exec_IndexPointer);
-   SET_InterleavedArrays(table, exec_InterleavedArrays);
-   SET_IsTexture(table, exec_IsTexture);
-   SET_NormalPointer(table, exec_NormalPointer);
-   SET_PopClientAttrib(table, exec_PopClientAttrib);
-   SET_PrioritizeTextures(table, save_PrioritizeTextures);
-   SET_PushClientAttrib(table, exec_PushClientAttrib);
-   SET_TexCoordPointer(table, exec_TexCoordPointer);
-   SET_TexSubImage1D(table, save_TexSubImage1D);
-   SET_TexSubImage2D(table, save_TexSubImage2D);
-   SET_VertexPointer(table, exec_VertexPointer);
-
-   /* GL 1.2 */
-   SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);
-   SET_TexImage3D(table, save_TexImage3D);
-   SET_TexSubImage3D(table, save_TexSubImage3D);
-
-   /* GL 2.0 */
-   SET_StencilFuncSeparate(table, save_StencilFuncSeparate);
-   SET_StencilMaskSeparate(table, save_StencilMaskSeparate);
-   SET_StencilOpSeparate(table, save_StencilOpSeparate);
-
-   /* ATI_separate_stencil */ 
-   SET_StencilFuncSeparateATI(table, save_StencilFuncSeparateATI);
-
-   /* GL_ARB_imaging */
-   /* Not all are supported */
-   SET_BlendColor(table, save_BlendColor);
-   SET_BlendEquation(table, save_BlendEquation);
-   SET_ColorSubTable(table, save_ColorSubTable);
-   SET_ColorTable(table, save_ColorTable);
-   SET_ColorTableParameterfv(table, save_ColorTableParameterfv);
-   SET_ColorTableParameteriv(table, save_ColorTableParameteriv);
-   SET_ConvolutionFilter1D(table, save_ConvolutionFilter1D);
-   SET_ConvolutionFilter2D(table, save_ConvolutionFilter2D);
-   SET_ConvolutionParameterf(table, save_ConvolutionParameterf);
-   SET_ConvolutionParameterfv(table, save_ConvolutionParameterfv);
-   SET_ConvolutionParameteri(table, save_ConvolutionParameteri);
-   SET_ConvolutionParameteriv(table, save_ConvolutionParameteriv);
-   SET_CopyColorSubTable(table, save_CopyColorSubTable);
-   SET_CopyColorTable(table, save_CopyColorTable);
-   SET_CopyConvolutionFilter1D(table, exec_CopyConvolutionFilter1D);
-   SET_CopyConvolutionFilter2D(table, exec_CopyConvolutionFilter2D);
-   SET_GetColorTable(table, exec_GetColorTable);
-   SET_GetColorTableParameterfv(table, exec_GetColorTableParameterfv);
-   SET_GetColorTableParameteriv(table, exec_GetColorTableParameteriv);
-   SET_GetConvolutionFilter(table, exec_GetConvolutionFilter);
-   SET_GetConvolutionParameterfv(table, exec_GetConvolutionParameterfv);
-   SET_GetConvolutionParameteriv(table, exec_GetConvolutionParameteriv);
-   SET_GetHistogram(table, exec_GetHistogram);
-   SET_GetHistogramParameterfv(table, exec_GetHistogramParameterfv);
-   SET_GetHistogramParameteriv(table, exec_GetHistogramParameteriv);
-   SET_GetMinmax(table, exec_GetMinmax);
-   SET_GetMinmaxParameterfv(table, exec_GetMinmaxParameterfv);
-   SET_GetMinmaxParameteriv(table, exec_GetMinmaxParameteriv);
-   SET_GetSeparableFilter(table, exec_GetSeparableFilter);
-   SET_Histogram(table, save_Histogram);
-   SET_Minmax(table, save_Minmax);
-   SET_ResetHistogram(table, save_ResetHistogram);
-   SET_ResetMinmax(table, save_ResetMinmax);
-   SET_SeparableFilter2D(table, exec_SeparableFilter2D);
-
-   /* 2. GL_EXT_blend_color */
-#if 0
-   SET_BlendColorEXT(table, save_BlendColorEXT);
-#endif
-
-   /* 3. GL_EXT_polygon_offset */
-   SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);
-
-   /* 6. GL_EXT_texture3d */
-#if 0
-   SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);
-   SET_TexImage3DEXT(table, save_TexImage3DEXT);
-   SET_TexSubImage3DEXT(table, save_TexSubImage3D);
-#endif
-
-   /* 14. GL_SGI_color_table */
-#if 0
-   SET_ColorTableSGI(table, save_ColorTable);
-   SET_ColorSubTableSGI(table, save_ColorSubTable);
-   SET_GetColorTableSGI(table, exec_GetColorTable);
-   SET_GetColorTableParameterfvSGI(table, exec_GetColorTableParameterfv);
-   SET_GetColorTableParameterivSGI(table, exec_GetColorTableParameteriv);
-#endif
-
-   /* 30. GL_EXT_vertex_array */
-   SET_ColorPointerEXT(table, exec_ColorPointerEXT);
-   SET_EdgeFlagPointerEXT(table, exec_EdgeFlagPointerEXT);
-   SET_IndexPointerEXT(table, exec_IndexPointerEXT);
-   SET_NormalPointerEXT(table, exec_NormalPointerEXT);
-   SET_TexCoordPointerEXT(table, exec_TexCoordPointerEXT);
-   SET_VertexPointerEXT(table, exec_VertexPointerEXT);
-
-   /* 37. GL_EXT_blend_minmax */
-#if 0
-   SET_BlendEquationEXT(table, save_BlendEquationEXT);
-#endif
-
-   /* 54. GL_EXT_point_parameters */
-   SET_PointParameterfEXT(table, save_PointParameterfEXT);
-   SET_PointParameterfvEXT(table, save_PointParameterfvEXT);
-
-   /* 97. GL_EXT_compiled_vertex_array */
-   SET_LockArraysEXT(table, exec_LockArraysEXT);
-   SET_UnlockArraysEXT(table, exec_UnlockArraysEXT);
-
-   /* 145. GL_EXT_secondary_color */
-   SET_SecondaryColorPointerEXT(table, exec_SecondaryColorPointerEXT);
-
-   /* 148. GL_EXT_multi_draw_arrays */
-   SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);
-
-   /* 149. GL_EXT_fog_coord */
-   SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);
-
-   /* 173. GL_EXT_blend_func_separate */
-   SET_BlendFuncSeparateEXT(table, save_BlendFuncSeparateEXT);
-
-   /* 196. GL_MESA_resize_buffers */
-   SET_ResizeBuffersMESA(table, _mesa_ResizeBuffersMESA);
-
-   /* 197. GL_MESA_window_pos */
-   SET_WindowPos2dMESA(table, save_WindowPos2dMESA);
-   SET_WindowPos2dvMESA(table, save_WindowPos2dvMESA);
-   SET_WindowPos2fMESA(table, save_WindowPos2fMESA);
-   SET_WindowPos2fvMESA(table, save_WindowPos2fvMESA);
-   SET_WindowPos2iMESA(table, save_WindowPos2iMESA);
-   SET_WindowPos2ivMESA(table, save_WindowPos2ivMESA);
-   SET_WindowPos2sMESA(table, save_WindowPos2sMESA);
-   SET_WindowPos2svMESA(table, save_WindowPos2svMESA);
-   SET_WindowPos3dMESA(table, save_WindowPos3dMESA);
-   SET_WindowPos3dvMESA(table, save_WindowPos3dvMESA);
-   SET_WindowPos3fMESA(table, save_WindowPos3fMESA);
-   SET_WindowPos3fvMESA(table, save_WindowPos3fvMESA);
-   SET_WindowPos3iMESA(table, save_WindowPos3iMESA);
-   SET_WindowPos3ivMESA(table, save_WindowPos3ivMESA);
-   SET_WindowPos3sMESA(table, save_WindowPos3sMESA);
-   SET_WindowPos3svMESA(table, save_WindowPos3svMESA);
-   SET_WindowPos4dMESA(table, save_WindowPos4dMESA);
-   SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);
-   SET_WindowPos4fMESA(table, save_WindowPos4fMESA);
-   SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);
-   SET_WindowPos4iMESA(table, save_WindowPos4iMESA);
-   SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);
-   SET_WindowPos4sMESA(table, save_WindowPos4sMESA);
-   SET_WindowPos4svMESA(table, save_WindowPos4svMESA);
-
-   /* 200. GL_IBM_multimode_draw_arrays */
-   SET_MultiModeDrawArraysIBM(table, exec_MultiModeDrawArraysIBM);
-   SET_MultiModeDrawElementsIBM(table, exec_MultiModeDrawElementsIBM);
-
-#if FEATURE_NV_vertex_program
-   /* 233. GL_NV_vertex_program */
-   /* The following commands DO NOT go into display lists:
-    * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
-    * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
-    */
-   SET_BindProgramNV(table, save_BindProgramNV);
-   SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
-   SET_ExecuteProgramNV(table, save_ExecuteProgramNV);
-   SET_GenProgramsNV(table, _mesa_GenPrograms);
-   SET_AreProgramsResidentNV(table, _mesa_AreProgramsResidentNV);
-   SET_RequestResidentProgramsNV(table, save_RequestResidentProgramsNV);
-   SET_GetProgramParameterfvNV(table, _mesa_GetProgramParameterfvNV);
-   SET_GetProgramParameterdvNV(table, _mesa_GetProgramParameterdvNV);
-   SET_GetProgramivNV(table, _mesa_GetProgramivNV);
-   SET_GetProgramStringNV(table, _mesa_GetProgramStringNV);
-   SET_GetTrackMatrixivNV(table, _mesa_GetTrackMatrixivNV);
-   SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
-   SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
-   SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
-   SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
-   SET_IsProgramNV(table, _mesa_IsProgramARB);
-   SET_LoadProgramNV(table, save_LoadProgramNV);
-   SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
-   SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
-   SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
-   SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
-   SET_ProgramParameters4dvNV(table, save_ProgramParameters4dvNV);
-   SET_ProgramParameters4fvNV(table, save_ProgramParameters4fvNV);
-   SET_TrackMatrixNV(table, save_TrackMatrixNV);
-   SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);
-#endif
-
-   /* 244. GL_ATI_envmap_bumpmap */
-   SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI);
-   SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI);
-
-   /* 245. GL_ATI_fragment_shader */
-#if FEATURE_ATI_fragment_shader
-   SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
-   SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);
-#endif
-
-   /* 282. GL_NV_fragment_program */
-#if FEATURE_NV_fragment_program
-   SET_ProgramNamedParameter4fNV(table, save_ProgramNamedParameter4fNV);
-   SET_ProgramNamedParameter4dNV(table, save_ProgramNamedParameter4dNV);
-   SET_ProgramNamedParameter4fvNV(table, save_ProgramNamedParameter4fvNV);
-   SET_ProgramNamedParameter4dvNV(table, save_ProgramNamedParameter4dvNV);
-   SET_GetProgramNamedParameterfvNV(table,
-                                    _mesa_GetProgramNamedParameterfvNV);
-   SET_GetProgramNamedParameterdvNV(table,
-                                    _mesa_GetProgramNamedParameterdvNV);
-   SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
-   SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
-   SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
-   SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
-   SET_GetProgramLocalParameterdvARB(table,
-                                     _mesa_GetProgramLocalParameterdvARB);
-   SET_GetProgramLocalParameterfvARB(table,
-                                     _mesa_GetProgramLocalParameterfvARB);
-#endif
-
-   /* 262. GL_NV_point_sprite */
-   SET_PointParameteriNV(table, save_PointParameteriNV);
-   SET_PointParameterivNV(table, save_PointParameterivNV);
-
-   /* 268. GL_EXT_stencil_two_side */
-   SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);
-
-   /* 273. GL_APPLE_vertex_array_object */
-   SET_BindVertexArrayAPPLE(table, _mesa_BindVertexArrayAPPLE);
-   SET_DeleteVertexArraysAPPLE(table, _mesa_DeleteVertexArraysAPPLE);
-   SET_GenVertexArraysAPPLE(table, _mesa_GenVertexArraysAPPLE);
-   SET_IsVertexArrayAPPLE(table, _mesa_IsVertexArrayAPPLE);
-
-   /* ???. GL_EXT_depth_bounds_test */
-   SET_DepthBoundsEXT(table, save_DepthBoundsEXT);
-
-   /* ARB 1. GL_ARB_multitexture */
-   SET_ActiveTextureARB(table, save_ActiveTextureARB);
-   SET_ClientActiveTextureARB(table, exec_ClientActiveTextureARB);
-
-   /* ARB 3. GL_ARB_transpose_matrix */
-   SET_LoadTransposeMatrixdARB(table, save_LoadTransposeMatrixdARB);
-   SET_LoadTransposeMatrixfARB(table, save_LoadTransposeMatrixfARB);
-   SET_MultTransposeMatrixdARB(table, save_MultTransposeMatrixdARB);
-   SET_MultTransposeMatrixfARB(table, save_MultTransposeMatrixfARB);
-
-   /* ARB 5. GL_ARB_multisample */
-   SET_SampleCoverageARB(table, save_SampleCoverageARB);
-
-   /* ARB 12. GL_ARB_texture_compression */
-   SET_CompressedTexImage3DARB(table, save_CompressedTexImage3DARB);
-   SET_CompressedTexImage2DARB(table, save_CompressedTexImage2DARB);
-   SET_CompressedTexImage1DARB(table, save_CompressedTexImage1DARB);
-   SET_CompressedTexSubImage3DARB(table, save_CompressedTexSubImage3DARB);
-   SET_CompressedTexSubImage2DARB(table, save_CompressedTexSubImage2DARB);
-   SET_CompressedTexSubImage1DARB(table, save_CompressedTexSubImage1DARB);
-   SET_GetCompressedTexImageARB(table, exec_GetCompressedTexImageARB);
-
-   /* ARB 14. GL_ARB_point_parameters */
-   /* aliased with EXT_point_parameters functions */
-
-   /* ARB 25. GL_ARB_window_pos */
-   /* aliased with MESA_window_pos functions */
-
-   /* ARB 26. GL_ARB_vertex_program */
-   /* ARB 27. GL_ARB_fragment_program */
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-   /* glVertexAttrib* functions alias the NV ones, handled elsewhere */
-   SET_VertexAttribPointerARB(table, _mesa_VertexAttribPointerARB);
-   SET_EnableVertexAttribArrayARB(table, _mesa_EnableVertexAttribArrayARB);
-   SET_DisableVertexAttribArrayARB(table, _mesa_DisableVertexAttribArrayARB);
-   SET_ProgramStringARB(table, save_ProgramStringARB);
-   SET_BindProgramNV(table, save_BindProgramNV);
-   SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
-   SET_GenProgramsNV(table, _mesa_GenPrograms);
-   SET_IsProgramNV(table, _mesa_IsProgramARB);
-   SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
-   SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
-   SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
-   SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
-   SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
-   SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
-   SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
-   SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
-   SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
-   SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
-   SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
-   SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
-   SET_GetProgramEnvParameterdvARB(table, _mesa_GetProgramEnvParameterdvARB);
-   SET_GetProgramEnvParameterfvARB(table, _mesa_GetProgramEnvParameterfvARB);
-   SET_GetProgramLocalParameterdvARB(table,
-                                     _mesa_GetProgramLocalParameterdvARB);
-   SET_GetProgramLocalParameterfvARB(table,
-                                     _mesa_GetProgramLocalParameterfvARB);
-   SET_GetProgramivARB(table, _mesa_GetProgramivARB);
-   SET_GetProgramStringARB(table, _mesa_GetProgramStringARB);
-#endif
-
-   /* ARB 28. GL_ARB_vertex_buffer_object */
-#if FEATURE_ARB_vertex_buffer_object
-   /* None of the extension's functions get compiled */
-   SET_BindBufferARB(table, _mesa_BindBufferARB);
-   SET_BufferDataARB(table, _mesa_BufferDataARB);
-   SET_BufferSubDataARB(table, _mesa_BufferSubDataARB);
-   SET_DeleteBuffersARB(table, _mesa_DeleteBuffersARB);
-   SET_GenBuffersARB(table, _mesa_GenBuffersARB);
-   SET_GetBufferParameterivARB(table, _mesa_GetBufferParameterivARB);
-   SET_GetBufferPointervARB(table, _mesa_GetBufferPointervARB);
-   SET_GetBufferSubDataARB(table, _mesa_GetBufferSubDataARB);
-   SET_IsBufferARB(table, _mesa_IsBufferARB);
-   SET_MapBufferARB(table, _mesa_MapBufferARB);
-   SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);
-#endif
-
-#if FEATURE_queryobj
-   SET_BeginQueryARB(table, save_BeginQueryARB);
-   SET_EndQueryARB(table, save_EndQueryARB);
-   SET_GenQueriesARB(table, _mesa_GenQueriesARB);
-   SET_DeleteQueriesARB(table, _mesa_DeleteQueriesARB);
-   SET_IsQueryARB(table, _mesa_IsQueryARB);
-   SET_GetQueryivARB(table, _mesa_GetQueryivARB);
-   SET_GetQueryObjectivARB(table, _mesa_GetQueryObjectivARB);
-   SET_GetQueryObjectuivARB(table, _mesa_GetQueryObjectuivARB);
-#endif
-   SET_DrawBuffersARB(table, save_DrawBuffersARB);
-
-#if FEATURE_EXT_framebuffer_blit
-   SET_BlitFramebufferEXT(table, save_BlitFramebufferEXT);
-#endif
-
-   /* GL_ARB_shader_objects */
-   SET_UseProgramObjectARB(table, save_UseProgramObjectARB);
-   SET_Uniform1fARB(table, save_Uniform1fARB);
-   SET_Uniform2fARB(table, save_Uniform2fARB);
-   SET_Uniform3fARB(table, save_Uniform3fARB);
-   SET_Uniform4fARB(table, save_Uniform4fARB);
-   SET_Uniform1fvARB(table, save_Uniform1fvARB);
-   SET_Uniform2fvARB(table, save_Uniform2fvARB);
-   SET_Uniform3fvARB(table, save_Uniform3fvARB);
-   SET_Uniform4fvARB(table, save_Uniform4fvARB);
-   SET_Uniform1iARB(table, save_Uniform1iARB);
-   SET_Uniform2iARB(table, save_Uniform2iARB);
-   SET_Uniform3iARB(table, save_Uniform3iARB);
-   SET_Uniform4iARB(table, save_Uniform4iARB);
-   SET_Uniform1ivARB(table, save_Uniform1ivARB);
-   SET_Uniform2ivARB(table, save_Uniform2ivARB);
-   SET_Uniform3ivARB(table, save_Uniform3ivARB);
-   SET_Uniform4ivARB(table, save_Uniform4ivARB);
-   SET_UniformMatrix2fvARB(table, save_UniformMatrix2fvARB);
-   SET_UniformMatrix3fvARB(table, save_UniformMatrix3fvARB);
-   SET_UniformMatrix4fvARB(table, save_UniformMatrix4fvARB);
-   SET_UniformMatrix2x3fv(table, save_UniformMatrix2x3fv);
-   SET_UniformMatrix3x2fv(table, save_UniformMatrix3x2fv);
-   SET_UniformMatrix2x4fv(table, save_UniformMatrix2x4fv);
-   SET_UniformMatrix4x2fv(table, save_UniformMatrix4x2fv);
-   SET_UniformMatrix3x4fv(table, save_UniformMatrix3x4fv);
-   SET_UniformMatrix4x3fv(table, save_UniformMatrix4x3fv);
-
-   /* ARB 30/31/32. GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
-   SET_BindAttribLocationARB(table, exec_BindAttribLocationARB);
-   SET_GetAttribLocationARB(table, exec_GetAttribLocationARB);
-   SET_GetUniformLocationARB(table, exec_GetUniformLocationARB);
-   /* XXX additional functions need to be implemented here! */
-
-   /* 299. GL_EXT_blend_equation_separate */
-   SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);
-
-   /* GL_EXT_gpu_program_parameters */
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-   SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
-   SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
-#endif
-
-   /* ARB 50. GL_ARB_map_buffer_range */
-#if FEATURE_ARB_map_buffer_range
-   SET_MapBufferRange(table, _mesa_MapBufferRange); /* no dlist save */
-   SET_FlushMappedBufferRange(table, _mesa_FlushMappedBufferRange); /* no dl */
-#endif
-
-   /* ARB 59. GL_ARB_copy_buffer */
-   SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */
-
-   /* 352. GL_EXT_transform_feedback */
-#if FEATURE_EXT_transform_feedback
-   SET_BeginTransformFeedbackEXT(table, save_BeginTransformFeedback);
-   SET_EndTransformFeedbackEXT(table, save_EndTransformFeedback);
-#endif
-
-   /* 364. GL_EXT_provoking_vertex */
-   SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT);
-
-   /* 371. GL_APPLE_object_purgeable */
-#if FEATURE_APPLE_object_purgeable
-   SET_ObjectPurgeableAPPLE(table, _mesa_ObjectPurgeableAPPLE);
-   SET_ObjectUnpurgeableAPPLE(table, _mesa_ObjectUnpurgeableAPPLE);
-#endif
-
-   /* GL_EXT_texture_integer */
-   SET_ClearColorIiEXT(table, save_ClearColorIi);
-   SET_ClearColorIuiEXT(table, save_ClearColorIui);
-   SET_TexParameterIivEXT(table, save_TexParameterIiv);
-   SET_TexParameterIuivEXT(table, save_TexParameterIuiv);
-   SET_GetTexParameterIivEXT(table, exec_GetTexParameterIiv);
-   SET_GetTexParameterIuivEXT(table, exec_GetTexParameterIuiv);
-
-   /* 377. GL_EXT_separate_shader_objects */
-   SET_UseShaderProgramEXT(table, save_UseShaderProgramEXT);
-   SET_ActiveProgramEXT(table, save_ActiveProgramEXT);
-
-   /* GL 3.0 */
-#if 0
-   SET_ClearBufferiv(table, save_ClearBufferiv);
-   SET_ClearBufferuiv(table, save_ClearBufferuiv);
-   SET_ClearBufferfv(table, save_ClearBufferfv);
-   SET_ClearBufferfi(table, save_ClearBufferfi);
-   SET_Uniform1ui(table, save_Uniform1ui);
-   SET_Uniform2ui(table, save_Uniform2ui);
-   SET_Uniform3ui(table, save_Uniform3ui);
-   SET_Uniform4ui(table, save_Uniform4ui);
-   SET_Uniform1uiv(table, save_Uniform1uiv);
-   SET_Uniform2uiv(table, save_Uniform2uiv);
-   SET_Uniform3uiv(table, save_Uniform3uiv);
-   SET_Uniform4uiv(table, save_Uniform4uiv);
-#else
-   (void) save_ClearBufferiv;
-   (void) save_ClearBufferuiv;
-   (void) save_ClearBufferfv;
-   (void) save_ClearBufferfi;
-   (void) save_Uniform1ui;
-   (void) save_Uniform2ui;
-   (void) save_Uniform3ui;
-   (void) save_Uniform4ui;
-   (void) save_Uniform1uiv;
-   (void) save_Uniform2uiv;
-   (void) save_Uniform3uiv;
-   (void) save_Uniform4uiv;
-#endif
-
-   /* GL_ARB_instanced_arrays */
-   SET_VertexAttribDivisorARB(table, save_VertexAttribDivisor);
-
-   /* GL_ARB_draw_buffer_blend */
-   SET_BlendFunciARB(table, save_BlendFunci);
-   SET_BlendFuncSeparateiARB(table, save_BlendFuncSeparatei);
-   SET_BlendEquationiARB(table, save_BlendEquationi);
-   SET_BlendEquationSeparateiARB(table, save_BlendEquationSeparatei);
-
-   return table;
-}
-
-
-
-static const char *
-enum_string(GLenum k)
-{
-   return _mesa_lookup_enum_by_nr(k);
-}
-
-
-/**
- * Print the commands in a display list.  For debugging only.
- * TODO: many commands aren't handled yet.
- */
-static void GLAPIENTRY
-print_list(struct gl_context *ctx, GLuint list)
-{
-   struct gl_display_list *dlist;
-   Node *n;
-   GLboolean done;
-
-   if (!islist(ctx, list)) {
-      printf("%u is not a display list ID\n", list);
-      return;
-   }
-
-   dlist = lookup_list(ctx, list);
-   if (!dlist)
-      return;
-
-   n = dlist->Head;
-
-   printf("START-LIST %u, address %p\n", list, (void *) n);
-
-   done = n ? GL_FALSE : GL_TRUE;
-   while (!done) {
-      const OpCode opcode = n[0].opcode;
-
-      if (is_ext_opcode(opcode)) {
-         n += ext_opcode_print(ctx, n);
-      }
-      else {
-         switch (opcode) {
-         case OPCODE_ACCUM:
-            printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);
-            break;
-         case OPCODE_BITMAP:
-            printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
-                         n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data);
-            break;
-         case OPCODE_CALL_LIST:
-            printf("CallList %d\n", (int) n[1].ui);
-            break;
-         case OPCODE_CALL_LIST_OFFSET:
-            printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
-                         ctx->List.ListBase, ctx->List.ListBase + n[1].ui);
-            break;
-         case OPCODE_COLOR_TABLE_PARAMETER_FV:
-            printf("ColorTableParameterfv %s %s %f %f %f %f\n",
-                         enum_string(n[1].e), enum_string(n[2].e),
-                         n[3].f, n[4].f, n[5].f, n[6].f);
-            break;
-         case OPCODE_COLOR_TABLE_PARAMETER_IV:
-            printf("ColorTableParameteriv %s %s %d %d %d %d\n",
-                         enum_string(n[1].e), enum_string(n[2].e),
-                         n[3].i, n[4].i, n[5].i, n[6].i);
-            break;
-         case OPCODE_DISABLE:
-            printf("Disable %s\n", enum_string(n[1].e));
-            break;
-         case OPCODE_ENABLE:
-            printf("Enable %s\n", enum_string(n[1].e));
-            break;
-         case OPCODE_FRUSTUM:
-            printf("Frustum %g %g %g %g %g %g\n",
-                         n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
-            break;
-         case OPCODE_LINE_STIPPLE:
-            printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);
-            break;
-         case OPCODE_LOAD_IDENTITY:
-            printf("LoadIdentity\n");
-            break;
-         case OPCODE_LOAD_MATRIX:
-            printf("LoadMatrix\n");
-            printf("  %8f %8f %8f %8f\n",
-                         n[1].f, n[5].f, n[9].f, n[13].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[2].f, n[6].f, n[10].f, n[14].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[3].f, n[7].f, n[11].f, n[15].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[4].f, n[8].f, n[12].f, n[16].f);
-            break;
-         case OPCODE_MULT_MATRIX:
-            printf("MultMatrix (or Rotate)\n");
-            printf("  %8f %8f %8f %8f\n",
-                         n[1].f, n[5].f, n[9].f, n[13].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[2].f, n[6].f, n[10].f, n[14].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[3].f, n[7].f, n[11].f, n[15].f);
-            printf("  %8f %8f %8f %8f\n",
-                         n[4].f, n[8].f, n[12].f, n[16].f);
-            break;
-         case OPCODE_ORTHO:
-            printf("Ortho %g %g %g %g %g %g\n",
-                         n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
-            break;
-         case OPCODE_POP_ATTRIB:
-            printf("PopAttrib\n");
-            break;
-         case OPCODE_POP_MATRIX:
-            printf("PopMatrix\n");
-            break;
-         case OPCODE_POP_NAME:
-            printf("PopName\n");
-            break;
-         case OPCODE_PUSH_ATTRIB:
-            printf("PushAttrib %x\n", n[1].bf);
-            break;
-         case OPCODE_PUSH_MATRIX:
-            printf("PushMatrix\n");
-            break;
-         case OPCODE_PUSH_NAME:
-            printf("PushName %d\n", (int) n[1].ui);
-            break;
-         case OPCODE_RASTER_POS:
-            printf("RasterPos %g %g %g %g\n",
-                         n[1].f, n[2].f, n[3].f, n[4].f);
-            break;
-         case OPCODE_ROTATE:
-            printf("Rotate %g %g %g %g\n",
-                         n[1].f, n[2].f, n[3].f, n[4].f);
-            break;
-         case OPCODE_SCALE:
-            printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
-            break;
-         case OPCODE_TRANSLATE:
-            printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
-            break;
-         case OPCODE_BIND_TEXTURE:
-            printf("BindTexture %s %d\n",
-                         _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
-            break;
-         case OPCODE_SHADE_MODEL:
-            printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
-            break;
-         case OPCODE_MAP1:
-            printf("Map1 %s %.3f %.3f %d %d\n",
-                         _mesa_lookup_enum_by_nr(n[1].ui),
-                         n[2].f, n[3].f, n[4].i, n[5].i);
-            break;
-         case OPCODE_MAP2:
-            printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
-                         _mesa_lookup_enum_by_nr(n[1].ui),
-                         n[2].f, n[3].f, n[4].f, n[5].f,
-                         n[6].i, n[7].i, n[8].i, n[9].i);
-            break;
-         case OPCODE_MAPGRID1:
-            printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
-            break;
-         case OPCODE_MAPGRID2:
-            printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
-                         n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
-            break;
-         case OPCODE_EVALMESH1:
-            printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
-            break;
-         case OPCODE_EVALMESH2:
-            printf("EvalMesh2 %d %d %d %d\n",
-                         n[1].i, n[2].i, n[3].i, n[4].i);
-            break;
-
-         case OPCODE_ATTR_1F_NV:
-            printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
-            break;
-         case OPCODE_ATTR_2F_NV:
-            printf("ATTR_2F_NV attr %d: %f %f\n",
-                         n[1].i, n[2].f, n[3].f);
-            break;
-         case OPCODE_ATTR_3F_NV:
-            printf("ATTR_3F_NV attr %d: %f %f %f\n",
-                         n[1].i, n[2].f, n[3].f, n[4].f);
-            break;
-         case OPCODE_ATTR_4F_NV:
-            printf("ATTR_4F_NV attr %d: %f %f %f %f\n",
-                         n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
-            break;
-         case OPCODE_ATTR_1F_ARB:
-            printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
-            break;
-         case OPCODE_ATTR_2F_ARB:
-            printf("ATTR_2F_ARB attr %d: %f %f\n",
-                         n[1].i, n[2].f, n[3].f);
-            break;
-         case OPCODE_ATTR_3F_ARB:
-            printf("ATTR_3F_ARB attr %d: %f %f %f\n",
-                         n[1].i, n[2].f, n[3].f, n[4].f);
-            break;
-         case OPCODE_ATTR_4F_ARB:
-            printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",
-                         n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
-            break;
-
-         case OPCODE_MATERIAL:
-            printf("MATERIAL %x %x: %f %f %f %f\n",
-                         n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);
-            break;
-         case OPCODE_BEGIN:
-            printf("BEGIN %x\n", n[1].i);
-            break;
-         case OPCODE_END:
-            printf("END\n");
-            break;
-         case OPCODE_RECTF:
-            printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
-                         n[4].f);
-            break;
-         case OPCODE_EVAL_C1:
-            printf("EVAL_C1 %f\n", n[1].f);
-            break;
-         case OPCODE_EVAL_C2:
-            printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);
-            break;
-         case OPCODE_EVAL_P1:
-            printf("EVAL_P1 %d\n", n[1].i);
-            break;
-         case OPCODE_EVAL_P2:
-            printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
-            break;
-
-         case OPCODE_PROVOKING_VERTEX:
-            printf("ProvokingVertex %s\n",
-                         _mesa_lookup_enum_by_nr(n[1].ui));
-            break;
-
-            /*
-             * meta opcodes/commands
-             */
-         case OPCODE_ERROR:
-            printf("Error: %s %s\n",
-                         enum_string(n[1].e), (const char *) n[2].data);
-            break;
-         case OPCODE_CONTINUE:
-            printf("DISPLAY-LIST-CONTINUE\n");
-            n = (Node *) n[1].next;
-            break;
-         case OPCODE_END_OF_LIST:
-            printf("END-LIST %u\n", list);
-            done = GL_TRUE;
-            break;
-         default:
-            if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
-               printf
-                  ("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
-                   opcode, (void *) n);
-               return;
-            }
-            else {
-               printf("command %d, %u operands\n", opcode,
-                            InstSize[opcode]);
-            }
-         }
-         /* increment n to point to next compiled command */
-         if (opcode != OPCODE_CONTINUE) {
-            n += InstSize[opcode];
-         }
-      }
-   }
-}
-
-
-
-/**
- * Clients may call this function to help debug display list problems.
- * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,
- * changed, or break in the future without notice.
- */
-void
-mesa_print_display_list(GLuint list)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   print_list(ctx, list);
-}
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-void
-_mesa_save_vtxfmt_init(GLvertexformat * vfmt)
-{
-   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
-
-   vfmt->Begin = save_Begin;
-
-   _MESA_INIT_DLIST_VTXFMT(vfmt, save_);
-
-   vfmt->Color3f = save_Color3f;
-   vfmt->Color3fv = save_Color3fv;
-   vfmt->Color4f = save_Color4f;
-   vfmt->Color4fv = save_Color4fv;
-   vfmt->EdgeFlag = save_EdgeFlag;
-   vfmt->End = save_End;
-
-   _MESA_INIT_EVAL_VTXFMT(vfmt, save_);
-
-   vfmt->FogCoordfEXT = save_FogCoordfEXT;
-   vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
-   vfmt->Indexf = save_Indexf;
-   vfmt->Indexfv = save_Indexfv;
-   vfmt->Materialfv = save_Materialfv;
-   vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;
-   vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;
-   vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;
-   vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;
-   vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;
-   vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;
-   vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;
-   vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;
-   vfmt->Normal3f = save_Normal3f;
-   vfmt->Normal3fv = save_Normal3fv;
-   vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;
-   vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;
-   vfmt->TexCoord1f = save_TexCoord1f;
-   vfmt->TexCoord1fv = save_TexCoord1fv;
-   vfmt->TexCoord2f = save_TexCoord2f;
-   vfmt->TexCoord2fv = save_TexCoord2fv;
-   vfmt->TexCoord3f = save_TexCoord3f;
-   vfmt->TexCoord3fv = save_TexCoord3fv;
-   vfmt->TexCoord4f = save_TexCoord4f;
-   vfmt->TexCoord4fv = save_TexCoord4fv;
-   vfmt->Vertex2f = save_Vertex2f;
-   vfmt->Vertex2fv = save_Vertex2fv;
-   vfmt->Vertex3f = save_Vertex3f;
-   vfmt->Vertex3fv = save_Vertex3fv;
-   vfmt->Vertex4f = save_Vertex4f;
-   vfmt->Vertex4fv = save_Vertex4fv;
-   vfmt->VertexAttrib1fNV = save_VertexAttrib1fNV;
-   vfmt->VertexAttrib1fvNV = save_VertexAttrib1fvNV;
-   vfmt->VertexAttrib2fNV = save_VertexAttrib2fNV;
-   vfmt->VertexAttrib2fvNV = save_VertexAttrib2fvNV;
-   vfmt->VertexAttrib3fNV = save_VertexAttrib3fNV;
-   vfmt->VertexAttrib3fvNV = save_VertexAttrib3fvNV;
-   vfmt->VertexAttrib4fNV = save_VertexAttrib4fNV;
-   vfmt->VertexAttrib4fvNV = save_VertexAttrib4fvNV;
-   vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;
-   vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;
-   vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;
-   vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;
-   vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;
-   vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;
-   vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
-   vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
-
-   vfmt->Rectf = save_Rectf;
-
-   /* The driver is required to implement these as
-    * 1) They can probably do a better job.
-    * 2) A lot of new mechanisms would have to be added to this module
-    *     to support it.  That code would probably never get used,
-    *     because of (1).
-    */
-#if 0
-   vfmt->DrawArrays = 0;
-   vfmt->DrawElements = 0;
-   vfmt->DrawRangeElements = 0;
-   vfmt->MultiDrawElemementsEXT = 0;
-   vfmt->DrawElementsBaseVertex = 0;
-   vfmt->DrawRangeElementsBaseVertex = 0;
-   vfmt->MultiDrawElemementsBaseVertex = 0;
-#endif
-}
-
-
-void
-_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
-                           const GLvertexformat *vfmt)
-{
-   SET_CallList(disp, vfmt->CallList);
-   SET_CallLists(disp, vfmt->CallLists);
-}
-
-
-void _mesa_init_dlist_dispatch(struct _glapi_table *disp)
-{
-   SET_CallList(disp, _mesa_CallList);
-   SET_CallLists(disp, _mesa_CallLists);
-
-   SET_DeleteLists(disp, _mesa_DeleteLists);
-   SET_EndList(disp, _mesa_EndList);
-   SET_GenLists(disp, _mesa_GenLists);
-   SET_IsList(disp, _mesa_IsList);
-   SET_ListBase(disp, _mesa_ListBase);
-   SET_NewList(disp, _mesa_NewList);
-}
-
-
-#endif /* FEATURE_dlist */
-
-
-/**
- * Initialize display list state for given context.
- */
-void
-_mesa_init_display_list(struct gl_context *ctx)
-{
-   static GLboolean tableInitialized = GL_FALSE;
-
-   /* zero-out the instruction size table, just once */
-   if (!tableInitialized) {
-      memset(InstSize, 0, sizeof(InstSize));
-      tableInitialized = GL_TRUE;
-   }
-
-   /* extension info */
-   ctx->ListExt = CALLOC_STRUCT(gl_list_extensions);
-
-   /* Display list */
-   ctx->ListState.CallDepth = 0;
-   ctx->ExecuteFlag = GL_TRUE;
-   ctx->CompileFlag = GL_FALSE;
-   ctx->ListState.CurrentBlock = NULL;
-   ctx->ListState.CurrentPos = 0;
-
-   /* Display List group */
-   ctx->List.ListBase = 0;
-
-#if FEATURE_dlist
-   _mesa_save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
-#endif
-}
-
-
-void
-_mesa_free_display_list_data(struct gl_context *ctx)
-{
-   free(ctx->ListExt);
-   ctx->ListExt = NULL;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file dlist.c

+ * Display lists management functions.

+ */

+

+#include "glheader.h"

+#include "imports.h"

+#include "api_arrayelt.h"

+#include "api_exec.h"

+#include "api_loopback.h"

+#if FEATURE_ATI_fragment_shader

+#include "atifragshader.h"

+#endif

+#include "config.h"

+#include "mfeatures.h"

+#if FEATURE_ARB_vertex_buffer_object

+#include "bufferobj.h"

+#endif

+#include "arrayobj.h"

+#include "context.h"

+#include "dlist.h"

+#include "enums.h"

+#include "eval.h"

+#include "framebuffer.h"

+#include "glapi/glapi.h"

+#include "hash.h"

+#include "image.h"

+#include "light.h"

+#include "macros.h"

+#include "pack.h"

+#include "pbo.h"

+#include "queryobj.h"

+#include "teximage.h"

+#include "mtypes.h"

+#include "varray.h"

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+#include "arbprogram.h"

+#endif

+#if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program

+#include "nvprogram.h"

+#endif

+

+#include "math/m_matrix.h"

+

+#include "main/dispatch.h"

+

+

+

+/**

+ * Other parts of Mesa (such as the VBO module) can plug into the display

+ * list system.  This structure describes new display list instructions.

+ */

+struct gl_list_instruction

+{

+   GLuint Size;

+   void (*Execute)( struct gl_context *ctx, void *data );

+   void (*Destroy)( struct gl_context *ctx, void *data );

+   void (*Print)( struct gl_context *ctx, void *data );

+};

+

+

+#define MAX_DLIST_EXT_OPCODES 16

+

+/**

+ * Used by device drivers to hook new commands into display lists.

+ */

+struct gl_list_extensions

+{

+   struct gl_list_instruction Opcode[MAX_DLIST_EXT_OPCODES];

+   GLuint NumOpcodes;

+};

+

+

+

+/**

+ * Flush vertices.

+ *

+ * \param ctx GL context.

+ *

+ * Checks if dd_function_table::SaveNeedFlush is marked to flush

+ * stored (save) vertices, and calls

+ * dd_function_table::SaveFlushVertices if so.

+ */

+#define SAVE_FLUSH_VERTICES(ctx)		\

+do {						\

+   if (ctx->Driver.SaveNeedFlush)		\

+      ctx->Driver.SaveFlushVertices(ctx);	\

+} while (0)

+

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval)		\

+do {									\

+   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\

+       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\

+      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\

+      return retval;							\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx)				\

+do {									\

+   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\

+       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\

+      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\

+      return;								\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx)			\

+do {									\

+   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);					\

+   SAVE_FLUSH_VERTICES(ctx);						\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)\

+do {									\

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval);		\

+   SAVE_FLUSH_VERTICES(ctx);						\

+} while (0)

+

+

+

+/**

+ * Display list opcodes.

+ *

+ * The fact that these identifiers are assigned consecutive

+ * integer values starting at 0 is very important, see InstSize array usage)

+ */

+typedef enum

+{

+   OPCODE_INVALID = -1,         /* Force signed enum */

+   OPCODE_ACCUM,

+   OPCODE_ALPHA_FUNC,

+   OPCODE_BIND_TEXTURE,

+   OPCODE_BITMAP,

+   OPCODE_BLEND_COLOR,

+   OPCODE_BLEND_EQUATION,

+   OPCODE_BLEND_EQUATION_SEPARATE,

+   OPCODE_BLEND_FUNC_SEPARATE,

+

+   OPCODE_BLEND_EQUATION_I,

+   OPCODE_BLEND_EQUATION_SEPARATE_I,

+   OPCODE_BLEND_FUNC_I,

+   OPCODE_BLEND_FUNC_SEPARATE_I,

+

+   OPCODE_CALL_LIST,

+   OPCODE_CALL_LIST_OFFSET,

+   OPCODE_CLEAR,

+   OPCODE_CLEAR_ACCUM,

+   OPCODE_CLEAR_COLOR,

+   OPCODE_CLEAR_DEPTH,

+   OPCODE_CLEAR_INDEX,

+   OPCODE_CLEAR_STENCIL,

+   OPCODE_CLEAR_BUFFER_IV,

+   OPCODE_CLEAR_BUFFER_UIV,

+   OPCODE_CLEAR_BUFFER_FV,

+   OPCODE_CLEAR_BUFFER_FI,

+   OPCODE_CLIP_PLANE,

+   OPCODE_COLOR_MASK,

+   OPCODE_COLOR_MASK_INDEXED,

+   OPCODE_COLOR_MATERIAL,

+   OPCODE_COLOR_TABLE,

+   OPCODE_COLOR_TABLE_PARAMETER_FV,

+   OPCODE_COLOR_TABLE_PARAMETER_IV,

+   OPCODE_COLOR_SUB_TABLE,

+   OPCODE_CONVOLUTION_FILTER_1D,

+   OPCODE_CONVOLUTION_FILTER_2D,

+   OPCODE_CONVOLUTION_PARAMETER_I,

+   OPCODE_CONVOLUTION_PARAMETER_IV,

+   OPCODE_CONVOLUTION_PARAMETER_F,

+   OPCODE_CONVOLUTION_PARAMETER_FV,

+   OPCODE_COPY_COLOR_SUB_TABLE,

+   OPCODE_COPY_COLOR_TABLE,

+   OPCODE_COPY_PIXELS,

+   OPCODE_COPY_TEX_IMAGE1D,

+   OPCODE_COPY_TEX_IMAGE2D,

+   OPCODE_COPY_TEX_SUB_IMAGE1D,

+   OPCODE_COPY_TEX_SUB_IMAGE2D,

+   OPCODE_COPY_TEX_SUB_IMAGE3D,

+   OPCODE_CULL_FACE,

+   OPCODE_DEPTH_FUNC,

+   OPCODE_DEPTH_MASK,

+   OPCODE_DEPTH_RANGE,

+   OPCODE_DISABLE,

+   OPCODE_DISABLE_INDEXED,

+   OPCODE_DRAW_BUFFER,

+   OPCODE_DRAW_PIXELS,

+   OPCODE_ENABLE,

+   OPCODE_ENABLE_INDEXED,

+   OPCODE_EVALMESH1,

+   OPCODE_EVALMESH2,

+   OPCODE_FOG,

+   OPCODE_FRONT_FACE,

+   OPCODE_FRUSTUM,

+   OPCODE_HINT,

+   OPCODE_HISTOGRAM,

+   OPCODE_INDEX_MASK,

+   OPCODE_INIT_NAMES,

+   OPCODE_LIGHT,

+   OPCODE_LIGHT_MODEL,

+   OPCODE_LINE_STIPPLE,

+   OPCODE_LINE_WIDTH,

+   OPCODE_LIST_BASE,

+   OPCODE_LOAD_IDENTITY,

+   OPCODE_LOAD_MATRIX,

+   OPCODE_LOAD_NAME,

+   OPCODE_LOGIC_OP,

+   OPCODE_MAP1,

+   OPCODE_MAP2,

+   OPCODE_MAPGRID1,

+   OPCODE_MAPGRID2,

+   OPCODE_MATRIX_MODE,

+   OPCODE_MIN_MAX,

+   OPCODE_MULT_MATRIX,

+   OPCODE_ORTHO,

+   OPCODE_PASSTHROUGH,

+   OPCODE_PIXEL_MAP,

+   OPCODE_PIXEL_TRANSFER,

+   OPCODE_PIXEL_ZOOM,

+   OPCODE_POINT_SIZE,

+   OPCODE_POINT_PARAMETERS,

+   OPCODE_POLYGON_MODE,

+   OPCODE_POLYGON_STIPPLE,

+   OPCODE_POLYGON_OFFSET,

+   OPCODE_POP_ATTRIB,

+   OPCODE_POP_MATRIX,

+   OPCODE_POP_NAME,

+   OPCODE_PRIORITIZE_TEXTURE,

+   OPCODE_PUSH_ATTRIB,

+   OPCODE_PUSH_MATRIX,

+   OPCODE_PUSH_NAME,

+   OPCODE_RASTER_POS,

+   OPCODE_READ_BUFFER,

+   OPCODE_RESET_HISTOGRAM,

+   OPCODE_RESET_MIN_MAX,

+   OPCODE_ROTATE,

+   OPCODE_SCALE,

+   OPCODE_SCISSOR,

+   OPCODE_SELECT_TEXTURE_SGIS,

+   OPCODE_SELECT_TEXTURE_COORD_SET,

+   OPCODE_SHADE_MODEL,

+   OPCODE_STENCIL_FUNC,

+   OPCODE_STENCIL_MASK,

+   OPCODE_STENCIL_OP,

+   OPCODE_TEXENV,

+   OPCODE_TEXGEN,

+   OPCODE_TEXPARAMETER,

+   OPCODE_TEX_IMAGE1D,

+   OPCODE_TEX_IMAGE2D,

+   OPCODE_TEX_IMAGE3D,

+   OPCODE_TEX_SUB_IMAGE1D,

+   OPCODE_TEX_SUB_IMAGE2D,

+   OPCODE_TEX_SUB_IMAGE3D,

+   OPCODE_TRANSLATE,

+   OPCODE_VIEWPORT,

+   OPCODE_WINDOW_POS,

+   /* GL_ARB_multitexture */

+   OPCODE_ACTIVE_TEXTURE,

+   /* GL_ARB_texture_compression */

+   OPCODE_COMPRESSED_TEX_IMAGE_1D,

+   OPCODE_COMPRESSED_TEX_IMAGE_2D,

+   OPCODE_COMPRESSED_TEX_IMAGE_3D,

+   OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,

+   OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,

+   OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,

+   /* GL_ARB_multisample */

+   OPCODE_SAMPLE_COVERAGE,

+   /* GL_ARB_window_pos */

+   OPCODE_WINDOW_POS_ARB,

+   /* GL_NV_vertex_program */

+   OPCODE_BIND_PROGRAM_NV,

+   OPCODE_EXECUTE_PROGRAM_NV,

+   OPCODE_REQUEST_RESIDENT_PROGRAMS_NV,

+   OPCODE_LOAD_PROGRAM_NV,

+   OPCODE_TRACK_MATRIX_NV,

+   /* GL_NV_fragment_program */

+   OPCODE_PROGRAM_LOCAL_PARAMETER_ARB,

+   OPCODE_PROGRAM_NAMED_PARAMETER_NV,

+   /* GL_EXT_stencil_two_side */

+   OPCODE_ACTIVE_STENCIL_FACE_EXT,

+   /* GL_EXT_depth_bounds_test */

+   OPCODE_DEPTH_BOUNDS_EXT,

+   /* GL_ARB_vertex/fragment_program */

+   OPCODE_PROGRAM_STRING_ARB,

+   OPCODE_PROGRAM_ENV_PARAMETER_ARB,

+   /* GL_ARB_occlusion_query */

+   OPCODE_BEGIN_QUERY_ARB,

+   OPCODE_END_QUERY_ARB,

+   /* GL_ARB_draw_buffers */

+   OPCODE_DRAW_BUFFERS_ARB,

+   /* GL_ATI_fragment_shader */

+   OPCODE_TEX_BUMP_PARAMETER_ATI,

+   /* GL_ATI_fragment_shader */

+   OPCODE_BIND_FRAGMENT_SHADER_ATI,

+   OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,

+   /* OpenGL 2.0 */

+   OPCODE_STENCIL_FUNC_SEPARATE,

+   OPCODE_STENCIL_OP_SEPARATE,

+   OPCODE_STENCIL_MASK_SEPARATE,

+

+   /* GL_ARB_shader_objects */

+   OPCODE_USE_PROGRAM,

+   OPCODE_UNIFORM_1F,

+   OPCODE_UNIFORM_2F,

+   OPCODE_UNIFORM_3F,

+   OPCODE_UNIFORM_4F,

+   OPCODE_UNIFORM_1FV,

+   OPCODE_UNIFORM_2FV,

+   OPCODE_UNIFORM_3FV,

+   OPCODE_UNIFORM_4FV,

+   OPCODE_UNIFORM_1I,

+   OPCODE_UNIFORM_2I,

+   OPCODE_UNIFORM_3I,

+   OPCODE_UNIFORM_4I,

+   OPCODE_UNIFORM_1IV,

+   OPCODE_UNIFORM_2IV,

+   OPCODE_UNIFORM_3IV,

+   OPCODE_UNIFORM_4IV,

+   OPCODE_UNIFORM_MATRIX22,

+   OPCODE_UNIFORM_MATRIX33,

+   OPCODE_UNIFORM_MATRIX44,

+   OPCODE_UNIFORM_MATRIX23,

+   OPCODE_UNIFORM_MATRIX32,

+   OPCODE_UNIFORM_MATRIX24,

+   OPCODE_UNIFORM_MATRIX42,

+   OPCODE_UNIFORM_MATRIX34,

+   OPCODE_UNIFORM_MATRIX43,

+

+   /* OpenGL 3.0 */

+   OPCODE_UNIFORM_1UI,

+   OPCODE_UNIFORM_2UI,

+   OPCODE_UNIFORM_3UI,

+   OPCODE_UNIFORM_4UI,

+   OPCODE_UNIFORM_1UIV,

+   OPCODE_UNIFORM_2UIV,

+   OPCODE_UNIFORM_3UIV,

+   OPCODE_UNIFORM_4UIV,

+

+   /* GL_EXT_framebuffer_blit */

+   OPCODE_BLIT_FRAMEBUFFER,

+

+   /* Vertex attributes -- fallback for when optimized display

+    * list build isn't active.

+    */

+   OPCODE_ATTR_1F_NV,

+   OPCODE_ATTR_2F_NV,

+   OPCODE_ATTR_3F_NV,

+   OPCODE_ATTR_4F_NV,

+   OPCODE_ATTR_1F_ARB,

+   OPCODE_ATTR_2F_ARB,

+   OPCODE_ATTR_3F_ARB,

+   OPCODE_ATTR_4F_ARB,

+   OPCODE_MATERIAL,

+   OPCODE_BEGIN,

+   OPCODE_END,

+   OPCODE_RECTF,

+   OPCODE_EVAL_C1,

+   OPCODE_EVAL_C2,

+   OPCODE_EVAL_P1,

+   OPCODE_EVAL_P2,

+

+   /* GL_EXT_provoking_vertex */

+   OPCODE_PROVOKING_VERTEX,

+

+   /* GL_EXT_transform_feedback */

+   OPCODE_BEGIN_TRANSFORM_FEEDBACK,

+   OPCODE_END_TRANSFORM_FEEDBACK,

+

+   /* GL_EXT_texture_integer */

+   OPCODE_CLEARCOLOR_I,

+   OPCODE_CLEARCOLOR_UI,

+   OPCODE_TEXPARAMETER_I,

+   OPCODE_TEXPARAMETER_UI,

+

+   /* GL_EXT_separate_shader_objects */

+   OPCODE_ACTIVE_PROGRAM_EXT,

+   OPCODE_USE_SHADER_PROGRAM_EXT,

+

+   /* GL_ARB_instanced_arrays */

+   OPCODE_VERTEX_ATTRIB_DIVISOR,

+

+   /* The following three are meta instructions */

+   OPCODE_ERROR,                /* raise compiled-in error */

+   OPCODE_CONTINUE,

+   OPCODE_END_OF_LIST,

+   OPCODE_EXT_0

+} OpCode;

+

+

+

+/**

+ * Display list node.

+ *

+ * Display list instructions are stored as sequences of "nodes".  Nodes

+ * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks

+ * are linked together with a pointer.

+ *

+ * Each instruction in the display list is stored as a sequence of

+ * contiguous nodes in memory.

+ * Each node is the union of a variety of data types.

+ */

+union gl_dlist_node

+{

+   OpCode opcode;

+   GLboolean b;

+   GLbitfield bf;

+   GLubyte ub;

+   GLshort s;

+   GLushort us;

+   GLint i;

+   GLuint ui;

+   GLenum e;

+   GLfloat f;

+   GLvoid *data;

+   void *next;                  /* If prev node's opcode==OPCODE_CONTINUE */

+};

+

+

+typedef union gl_dlist_node Node;

+

+

+/**

+ * How many nodes to allocate at a time.

+ *

+ * \note Reduced now that we hold vertices etc. elsewhere.

+ */

+#define BLOCK_SIZE 256

+

+

+

+/**

+ * Number of nodes of storage needed for each instruction.

+ * Sizes for dynamically allocated opcodes are stored in the context struct.

+ */

+static GLuint InstSize[OPCODE_END_OF_LIST + 1];

+

+

+#if FEATURE_dlist

+

+

+void mesa_print_display_list(GLuint list);

+

+

+/**********************************************************************/

+/*****                           Private                          *****/

+/**********************************************************************/

+

+

+/**

+ * Make an empty display list.  This is used by glGenLists() to

+ * reserve display list IDs.

+ */

+static struct gl_display_list *

+make_list(GLuint name, GLuint count)

+{

+   struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);

+   dlist->Name = name;

+   dlist->Head = (Node *) malloc(sizeof(Node) * count);

+   dlist->Head[0].opcode = OPCODE_END_OF_LIST;

+   return dlist;

+}

+

+

+/**

+ * Lookup function to just encapsulate casting.

+ */

+static INLINE struct gl_display_list *

+lookup_list(struct gl_context *ctx, GLuint list)

+{

+   return (struct gl_display_list *)

+      _mesa_HashLookup(ctx->Shared->DisplayList, list);

+}

+

+

+/** Is the given opcode an extension code? */

+static INLINE GLboolean

+is_ext_opcode(OpCode opcode)

+{

+   return (opcode >= OPCODE_EXT_0);

+}

+

+

+/** Destroy an extended opcode instruction */

+static GLint

+ext_opcode_destroy(struct gl_context *ctx, Node *node)

+{

+   const GLint i = node[0].opcode - OPCODE_EXT_0;

+   GLint step;

+   ctx->ListExt->Opcode[i].Destroy(ctx, &node[1]);

+   step = ctx->ListExt->Opcode[i].Size;

+   return step;

+}

+

+

+/** Execute an extended opcode instruction */

+static GLint

+ext_opcode_execute(struct gl_context *ctx, Node *node)

+{

+   const GLint i = node[0].opcode - OPCODE_EXT_0;

+   GLint step;

+   ctx->ListExt->Opcode[i].Execute(ctx, &node[1]);

+   step = ctx->ListExt->Opcode[i].Size;

+   return step;

+}

+

+

+/** Print an extended opcode instruction */

+static GLint

+ext_opcode_print(struct gl_context *ctx, Node *node)

+{

+   const GLint i = node[0].opcode - OPCODE_EXT_0;

+   GLint step;

+   ctx->ListExt->Opcode[i].Print(ctx, &node[1]);

+   step = ctx->ListExt->Opcode[i].Size;

+   return step;

+}

+

+

+/**

+ * Delete the named display list, but don't remove from hash table.

+ * \param dlist - display list pointer

+ */

+void

+_mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)

+{

+   Node *n, *block;

+   GLboolean done;

+

+   n = block = dlist->Head;

+

+   done = block ? GL_FALSE : GL_TRUE;

+   while (!done) {

+      const OpCode opcode = n[0].opcode;

+

+      /* check for extension opcodes first */

+      if (is_ext_opcode(opcode)) {

+         n += ext_opcode_destroy(ctx, n);

+      }

+      else {

+         switch (opcode) {

+            /* for some commands, we need to free malloc'd memory */

+         case OPCODE_MAP1:

+            free(n[6].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_MAP2:

+            free(n[10].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_DRAW_PIXELS:

+            free(n[5].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_BITMAP:

+            free(n[7].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COLOR_TABLE:

+            free(n[6].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COLOR_SUB_TABLE:

+            free(n[6].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_CONVOLUTION_FILTER_1D:

+            free(n[6].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_CONVOLUTION_FILTER_2D:

+            free(n[7].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_POLYGON_STIPPLE:

+            free(n[1].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_IMAGE1D:

+            free(n[8].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_IMAGE2D:

+            free(n[9].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_IMAGE3D:

+            free(n[10].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_SUB_IMAGE1D:

+            free(n[7].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_SUB_IMAGE2D:

+            free(n[9].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_TEX_SUB_IMAGE3D:

+            free(n[11].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_1D:

+            free(n[7].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_2D:

+            free(n[8].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_3D:

+            free(n[9].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:

+            free(n[7].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:

+            free(n[9].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:

+            free(n[11].data);

+            n += InstSize[n[0].opcode];

+            break;

+#if FEATURE_NV_vertex_program

+         case OPCODE_LOAD_PROGRAM_NV:

+            free(n[4].data);      /* program string */

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:

+            free(n[2].data);      /* array of program ids */

+            n += InstSize[n[0].opcode];

+            break;

+#endif

+#if FEATURE_NV_fragment_program

+         case OPCODE_PROGRAM_NAMED_PARAMETER_NV:

+            free(n[3].data);      /* parameter name */

+            n += InstSize[n[0].opcode];

+            break;

+#endif

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+         case OPCODE_PROGRAM_STRING_ARB:

+            free(n[4].data);      /* program string */

+            n += InstSize[n[0].opcode];

+            break;

+#endif

+         case OPCODE_UNIFORM_1FV:

+         case OPCODE_UNIFORM_2FV:

+         case OPCODE_UNIFORM_3FV:

+         case OPCODE_UNIFORM_4FV:

+         case OPCODE_UNIFORM_1IV:

+         case OPCODE_UNIFORM_2IV:

+         case OPCODE_UNIFORM_3IV:

+         case OPCODE_UNIFORM_4IV:

+         case OPCODE_UNIFORM_1UIV:

+         case OPCODE_UNIFORM_2UIV:

+         case OPCODE_UNIFORM_3UIV:

+         case OPCODE_UNIFORM_4UIV:

+            free(n[3].data);

+            n += InstSize[n[0].opcode];

+            break;

+         case OPCODE_UNIFORM_MATRIX22:

+         case OPCODE_UNIFORM_MATRIX33:

+         case OPCODE_UNIFORM_MATRIX44:

+         case OPCODE_UNIFORM_MATRIX24:

+         case OPCODE_UNIFORM_MATRIX42:

+         case OPCODE_UNIFORM_MATRIX23:

+         case OPCODE_UNIFORM_MATRIX32:

+         case OPCODE_UNIFORM_MATRIX34:

+         case OPCODE_UNIFORM_MATRIX43:

+            free(n[4].data);

+            n += InstSize[n[0].opcode];

+            break;

+

+         case OPCODE_CONTINUE:

+            n = (Node *) n[1].next;

+            free(block);

+            block = n;

+            break;

+         case OPCODE_END_OF_LIST:

+            free(block);

+            done = GL_TRUE;

+            break;

+         default:

+            /* Most frequent case */

+            n += InstSize[n[0].opcode];

+            break;

+         }

+      }

+   }

+

+   free(dlist);

+}

+

+

+/**

+ * Destroy a display list and remove from hash table.

+ * \param list - display list number

+ */

+static void

+destroy_list(struct gl_context *ctx, GLuint list)

+{

+   struct gl_display_list *dlist;

+

+   if (list == 0)

+      return;

+

+   dlist = lookup_list(ctx, list);

+   if (!dlist)

+      return;

+

+   _mesa_delete_list(ctx, dlist);

+   _mesa_HashRemove(ctx->Shared->DisplayList, list);

+}

+

+

+/*

+ * Translate the nth element of list from <type> to GLint.

+ */

+static GLint

+translate_id(GLsizei n, GLenum type, const GLvoid * list)

+{

+   GLbyte *bptr;

+   GLubyte *ubptr;

+   GLshort *sptr;

+   GLushort *usptr;

+   GLint *iptr;

+   GLuint *uiptr;

+   GLfloat *fptr;

+

+   switch (type) {

+   case GL_BYTE:

+      bptr = (GLbyte *) list;

+      return (GLint) bptr[n];

+   case GL_UNSIGNED_BYTE:

+      ubptr = (GLubyte *) list;

+      return (GLint) ubptr[n];

+   case GL_SHORT:

+      sptr = (GLshort *) list;

+      return (GLint) sptr[n];

+   case GL_UNSIGNED_SHORT:

+      usptr = (GLushort *) list;

+      return (GLint) usptr[n];

+   case GL_INT:

+      iptr = (GLint *) list;

+      return iptr[n];

+   case GL_UNSIGNED_INT:

+      uiptr = (GLuint *) list;

+      return (GLint) uiptr[n];

+   case GL_FLOAT:

+      fptr = (GLfloat *) list;

+      return (GLint) FLOORF(fptr[n]);

+   case GL_2_BYTES:

+      ubptr = ((GLubyte *) list) + 2 * n;

+      return (GLint) ubptr[0] * 256

+           + (GLint) ubptr[1];

+   case GL_3_BYTES:

+      ubptr = ((GLubyte *) list) + 3 * n;

+      return (GLint) ubptr[0] * 65536

+           + (GLint) ubptr[1] * 256

+           + (GLint) ubptr[2];

+   case GL_4_BYTES:

+      ubptr = ((GLubyte *) list) + 4 * n;

+      return (GLint) ubptr[0] * 16777216

+           + (GLint) ubptr[1] * 65536

+           + (GLint) ubptr[2] * 256

+           + (GLint) ubptr[3];

+   default:

+      return 0;

+   }

+}

+

+

+

+

+/**********************************************************************/

+/*****                        Public                              *****/

+/**********************************************************************/

+

+/**

+ * Wrapper for _mesa_unpack_image() that handles pixel buffer objects.

+ * If we run out of memory, GL_OUT_OF_MEMORY will be recorded.

+ */

+static GLvoid *

+unpack_image(struct gl_context *ctx, GLuint dimensions,

+             GLsizei width, GLsizei height, GLsizei depth,

+             GLenum format, GLenum type, const GLvoid * pixels,

+             const struct gl_pixelstore_attrib *unpack)

+{

+   if (!_mesa_is_bufferobj(unpack->BufferObj)) {

+      /* no PBO */

+      GLvoid *image = _mesa_unpack_image(dimensions, width, height, depth,

+                                         format, type, pixels, unpack);

+      if (pixels && !image) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");

+      }

+      return image;

+   }

+   else if (_mesa_validate_pbo_access(dimensions, unpack, width, height, depth,

+                                      format, type, pixels)) {

+      const GLubyte *map, *src;

+      GLvoid *image;

+

+      map = (GLubyte *)

+         ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,

+                               GL_READ_ONLY_ARB, unpack->BufferObj);

+      if (!map) {

+         /* unable to map src buffer! */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");

+         return NULL;

+      }

+

+      src = ADD_POINTERS(map, pixels);

+      image = _mesa_unpack_image(dimensions, width, height, depth,

+                                 format, type, src, unpack);

+

+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,

+                              unpack->BufferObj);

+

+      if (!image) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");

+      }

+      return image;

+   }

+   /* bad access! */

+   return NULL;

+}

+

+

+/**

+ * Allocate space for a display list instruction (opcode + payload space).

+ * \param opcode  the instruction opcode (OPCODE_* value)

+ * \param bytes   instruction payload size (not counting opcode)

+ * \return pointer to allocated memory (the opcode space)

+ */

+static Node *

+dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes)

+{

+   const GLuint numNodes = 1 + (bytes + sizeof(Node) - 1) / sizeof(Node);

+   Node *n;

+

+   if (opcode < (GLuint) OPCODE_EXT_0) {

+      if (InstSize[opcode] == 0) {

+         /* save instruction size now */

+         InstSize[opcode] = numNodes;

+      }

+      else {

+         /* make sure instruction size agrees */

+         ASSERT(numNodes == InstSize[opcode]);

+      }

+   }

+

+   if (ctx->ListState.CurrentPos + numNodes + 2 > BLOCK_SIZE) {

+      /* This block is full.  Allocate a new block and chain to it */

+      Node *newblock;

+      n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;

+      n[0].opcode = OPCODE_CONTINUE;

+      newblock = (Node *) malloc(sizeof(Node) * BLOCK_SIZE);

+      if (!newblock) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");

+         return NULL;

+      }

+      n[1].next = (Node *) newblock;

+      ctx->ListState.CurrentBlock = newblock;

+      ctx->ListState.CurrentPos = 0;

+   }

+

+   n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;

+   ctx->ListState.CurrentPos += numNodes;

+

+   n[0].opcode = opcode;

+

+   return n;

+}

+

+

+

+/**

+ * Allocate space for a display list instruction.  Used by callers outside

+ * this file for things like VBO vertex data.

+ *

+ * \param opcode  the instruction opcode (OPCODE_* value)

+ * \param bytes   instruction size in bytes, not counting opcode.

+ * \return pointer to the usable data area (not including the internal

+ *         opcode).

+ */

+void *

+_mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint bytes)

+{

+   Node *n = dlist_alloc(ctx, (OpCode) opcode, bytes);

+   if (n)

+      return n + 1;  /* return pointer to payload area, after opcode */

+   else

+      return NULL;

+}

+

+

+/**

+ * This function allows modules and drivers to get their own opcodes

+ * for extending display list functionality.

+ * \param ctx  the rendering context

+ * \param size  number of bytes for storing the new display list command

+ * \param execute  function to execute the new display list command

+ * \param destroy  function to destroy the new display list command

+ * \param print  function to print the new display list command

+ * \return  the new opcode number or -1 if error

+ */

+GLint

+_mesa_dlist_alloc_opcode(struct gl_context *ctx,

+                         GLuint size,

+                         void (*execute) (struct gl_context *, void *),

+                         void (*destroy) (struct gl_context *, void *),

+                         void (*print) (struct gl_context *, void *))

+{

+   if (ctx->ListExt->NumOpcodes < MAX_DLIST_EXT_OPCODES) {

+      const GLuint i = ctx->ListExt->NumOpcodes++;

+      ctx->ListExt->Opcode[i].Size =

+         1 + (size + sizeof(Node) - 1) / sizeof(Node);

+      ctx->ListExt->Opcode[i].Execute = execute;

+      ctx->ListExt->Opcode[i].Destroy = destroy;

+      ctx->ListExt->Opcode[i].Print = print;

+      return i + OPCODE_EXT_0;

+   }

+   return -1;

+}

+

+

+/**

+ * Allocate space for a display list instruction.  The space is basically

+ * an array of Nodes where node[0] holds the opcode, node[1] is the first

+ * function parameter, node[2] is the second parameter, etc.

+ *

+ * \param opcode  one of OPCODE_x

+ * \param nparams  number of function parameters

+ * \return  pointer to start of instruction space

+ */

+static INLINE Node *

+alloc_instruction(struct gl_context *ctx, OpCode opcode, GLuint nparams)

+{

+   return dlist_alloc(ctx, opcode, nparams * sizeof(Node));

+}

+

+

+

+/*

+ * Display List compilation functions

+ */

+static void GLAPIENTRY

+save_Accum(GLenum op, GLfloat value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ACCUM, 2);

+   if (n) {

+      n[1].e = op;

+      n[2].f = value;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Accum(ctx->Exec, (op, value));

+   }

+}

+

+

+static void GLAPIENTRY

+save_AlphaFunc(GLenum func, GLclampf ref)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ALPHA_FUNC, 2);

+   if (n) {

+      n[1].e = func;

+      n[2].f = (GLfloat) ref;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_AlphaFunc(ctx->Exec, (func, ref));

+   }

+}

+

+

+static void GLAPIENTRY

+save_BindTexture(GLenum target, GLuint texture)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BIND_TEXTURE, 2);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = texture;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BindTexture(ctx->Exec, (target, texture));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Bitmap(GLsizei width, GLsizei height,

+            GLfloat xorig, GLfloat yorig,

+            GLfloat xmove, GLfloat ymove, const GLubyte * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BITMAP, 7);

+   if (n) {

+      n[1].i = (GLint) width;

+      n[2].i = (GLint) height;

+      n[3].f = xorig;

+      n[4].f = yorig;

+      n[5].f = xmove;

+      n[6].f = ymove;

+      n[7].data = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Bitmap(ctx->Exec, (width, height,

+                              xorig, yorig, xmove, ymove, pixels));

+   }

+}

+

+

+static void GLAPIENTRY

+save_BlendEquation(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendEquation(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);

+   if (n) {

+      n[1].e = modeRGB;

+      n[2].e = modeA;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendEquationSeparateEXT(ctx->Exec, (modeRGB, modeA));

+   }

+}

+

+

+static void GLAPIENTRY

+save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,

+                          GLenum sfactorA, GLenum dfactorA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);

+   if (n) {

+      n[1].e = sfactorRGB;

+      n[2].e = dfactorRGB;

+      n[3].e = sfactorA;

+      n[4].e = dfactorA;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendFuncSeparateEXT(ctx->Exec,

+                                (sfactorRGB, dfactorRGB, sfactorA, dfactorA));

+   }

+}

+

+

+static void GLAPIENTRY

+save_BlendFunc(GLenum srcfactor, GLenum dstfactor)

+{

+   save_BlendFuncSeparateEXT(srcfactor, dstfactor, srcfactor, dstfactor);

+}

+

+

+static void GLAPIENTRY

+save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_COLOR, 4);

+   if (n) {

+      n[1].f = red;

+      n[2].f = green;

+      n[3].f = blue;

+      n[4].f = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+/* GL_ARB_draw_buffers_blend */

+static void GLAPIENTRY

+save_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,

+                        GLenum sfactorA, GLenum dfactorA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 5);

+   if (n) {

+      n[1].ui = buf;

+      n[2].e = sfactorRGB;

+      n[3].e = dfactorRGB;

+      n[4].e = sfactorA;

+      n[5].e = dfactorA;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendFuncSeparateiARB(ctx->Exec, (buf, sfactorRGB, dfactorRGB,

+                                             sfactorA, dfactorA));

+   }

+}

+

+/* GL_ARB_draw_buffers_blend */

+static void GLAPIENTRY

+save_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 3);

+   if (n) {

+      n[1].ui = buf;

+      n[2].e = sfactor;

+      n[3].e = dfactor;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendFunciARB(ctx->Exec, (buf, sfactor, dfactor));

+   }

+}

+

+/* GL_ARB_draw_buffers_blend */

+static void GLAPIENTRY

+save_BlendEquationi(GLuint buf, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_I, 2);

+   if (n) {

+      n[1].ui = buf;

+      n[2].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendEquationiARB(ctx->Exec, (buf, mode));

+   }

+}

+

+/* GL_ARB_draw_buffers_blend */

+static void GLAPIENTRY

+save_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE_I, 3);

+   if (n) {

+      n[1].ui = buf;

+      n[2].e = modeRGB;

+      n[3].e = modeA;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlendEquationSeparateiARB(ctx->Exec, (buf, modeRGB, modeA));

+   }

+}

+

+

+static void invalidate_saved_current_state( struct gl_context *ctx )

+{

+   GLint i;

+

+   for (i = 0; i < VERT_ATTRIB_MAX; i++)

+      ctx->ListState.ActiveAttribSize[i] = 0;

+

+   for (i = 0; i < MAT_ATTRIB_MAX; i++)

+      ctx->ListState.ActiveMaterialSize[i] = 0;

+

+   memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);

+

+   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;

+}

+

+static void GLAPIENTRY

+save_CallList(GLuint list)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_CALL_LIST, 1);

+   if (n) {

+      n[1].ui = list;

+   }

+

+   /* After this, we don't know what state we're in.  Invalidate all

+    * cached information previously gathered:

+    */

+   invalidate_saved_current_state( ctx );

+

+   if (ctx->ExecuteFlag) {

+      _mesa_CallList(list);

+   }

+}

+

+

+static void GLAPIENTRY

+save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+   GLboolean typeErrorFlag;

+

+   SAVE_FLUSH_VERTICES(ctx);

+

+   switch (type) {

+   case GL_BYTE:

+   case GL_UNSIGNED_BYTE:

+   case GL_SHORT:

+   case GL_UNSIGNED_SHORT:

+   case GL_INT:

+   case GL_UNSIGNED_INT:

+   case GL_FLOAT:

+   case GL_2_BYTES:

+   case GL_3_BYTES:

+   case GL_4_BYTES:

+      typeErrorFlag = GL_FALSE;

+      break;

+   default:

+      typeErrorFlag = GL_TRUE;

+   }

+

+   for (i = 0; i < num; i++) {

+      GLint list = translate_id(i, type, lists);

+      Node *n = alloc_instruction(ctx, OPCODE_CALL_LIST_OFFSET, 2);

+      if (n) {

+         n[1].i = list;

+         n[2].b = typeErrorFlag;

+      }

+   }

+

+   /* After this, we don't know what state we're in.  Invalidate all

+    * cached information previously gathered:

+    */

+   invalidate_saved_current_state( ctx );

+

+   if (ctx->ExecuteFlag) {

+      CALL_CallLists(ctx->Exec, (num, type, lists));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Clear(GLbitfield mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR, 1);

+   if (n) {

+      n[1].bf = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Clear(ctx->Exec, (mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_IV, 6);

+   if (n) {

+      n[1].e = buffer;

+      n[2].i = drawbuffer;

+      n[3].i = value[0];

+      if (buffer == GL_COLOR) {

+         n[4].i = value[1];

+         n[5].i = value[2];

+         n[6].i = value[3];

+      }

+      else {

+         n[4].i = 0;

+         n[5].i = 0;

+         n[6].i = 0;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ClearBufferiv(ctx->Exec, (buffer, drawbuffer, value));*/

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_UIV, 6);

+   if (n) {

+      n[1].e = buffer;

+      n[2].i = drawbuffer;

+      n[3].ui = value[0];

+      if (buffer == GL_COLOR) {

+         n[4].ui = value[1];

+         n[5].ui = value[2];

+         n[6].ui = value[3];

+      }

+      else {

+         n[4].ui = 0;

+         n[5].ui = 0;

+         n[6].ui = 0;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));*/

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FV, 6);

+   if (n) {

+      n[1].e = buffer;

+      n[2].i = drawbuffer;

+      n[3].f = value[0];

+      if (buffer == GL_COLOR) {

+         n[4].f = value[1];

+         n[5].f = value[2];

+         n[6].f = value[3];

+      }

+      else {

+         n[4].f = 0.0F;

+         n[5].f = 0.0F;

+         n[6].f = 0.0F;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));*/

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearBufferfi(GLenum buffer, GLint drawbuffer,

+                   GLfloat depth, GLint stencil)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FI, 4);

+   if (n) {

+      n[1].e = buffer;

+      n[2].i = drawbuffer;

+      n[3].f = depth;

+      n[4].i = stencil;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ClearBufferfi(ctx->Exec, (buffer, drawbuffer, depth, stencil));*/

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_ACCUM, 4);

+   if (n) {

+      n[1].f = red;

+      n[2].f = green;

+      n[3].f = blue;

+      n[4].f = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_COLOR, 4);

+   if (n) {

+      n[1].f = red;

+      n[2].f = green;

+      n[3].f = blue;

+      n[4].f = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearDepth(GLclampd depth)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_DEPTH, 1);

+   if (n) {

+      n[1].f = (GLfloat) depth;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearDepth(ctx->Exec, (depth));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearIndex(GLfloat c)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_INDEX, 1);

+   if (n) {

+      n[1].f = c;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearIndex(ctx->Exec, (c));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClearStencil(GLint s)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEAR_STENCIL, 1);

+   if (n) {

+      n[1].i = s;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearStencil(ctx->Exec, (s));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ClipPlane(GLenum plane, const GLdouble * equ)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLIP_PLANE, 5);

+   if (n) {

+      n[1].e = plane;

+      n[2].f = (GLfloat) equ[0];

+      n[3].f = (GLfloat) equ[1];

+      n[4].f = (GLfloat) equ[2];

+      n[5].f = (GLfloat) equ[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClipPlane(ctx->Exec, (plane, equ));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_ColorMask(GLboolean red, GLboolean green,

+               GLboolean blue, GLboolean alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COLOR_MASK, 4);

+   if (n) {

+      n[1].b = red;

+      n[2].b = green;

+      n[3].b = blue;

+      n[4].b = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ColorMaskIndexed(GLuint buf, GLboolean red, GLboolean green,

+                      GLboolean blue, GLboolean alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COLOR_MASK_INDEXED, 5);

+   if (n) {

+      n[1].ui = buf;

+      n[2].b = red;

+      n[3].b = green;

+      n[4].b = blue;

+      n[5].b = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ColorMaskIndexedEXT(ctx->Exec, (buf, red, green, blue, alpha));*/

+   }

+}

+

+

+static void GLAPIENTRY

+save_ColorMaterial(GLenum face, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_COLOR_MATERIAL, 2);

+   if (n) {

+      n[1].e = face;

+      n[2].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ColorMaterial(ctx->Exec, (face, mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ColorTable(GLenum target, GLenum internalFormat,

+                GLsizei width, GLenum format, GLenum type,

+                const GLvoid * table)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (_mesa_is_proxy_texture(target)) {

+      /* execute immediately */

+      CALL_ColorTable(ctx->Exec, (target, internalFormat, width,

+                                  format, type, table));

+   }

+   else {

+      Node *n;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      n = alloc_instruction(ctx, OPCODE_COLOR_TABLE, 6);

+      if (n) {

+         n[1].e = target;

+         n[2].e = internalFormat;

+         n[3].i = width;

+         n[4].e = format;

+         n[5].e = type;

+         n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, table,

+                                  &ctx->Unpack);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_ColorTable(ctx->Exec, (target, internalFormat, width,

+                                     format, type, table));

+      }

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_ColorTableParameterfv(GLenum target, GLenum pname,

+                           const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].f = params[0];

+      if (pname == GL_COLOR_TABLE_SGI ||

+          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||

+          pname == GL_TEXTURE_COLOR_TABLE_SGI) {

+         n[4].f = params[1];

+         n[5].f = params[2];

+         n[6].f = params[3];

+      }

+   }

+

+   if (ctx->ExecuteFlag) {

+      CALL_ColorTableParameterfv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].i = params[0];

+      if (pname == GL_COLOR_TABLE_SGI ||

+          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||

+          pname == GL_TEXTURE_COLOR_TABLE_SGI) {

+         n[4].i = params[1];

+         n[5].i = params[2];

+         n[6].i = params[3];

+      }

+   }

+

+   if (ctx->ExecuteFlag) {

+      CALL_ColorTableParameteriv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,

+                   GLenum format, GLenum type, const GLvoid * table)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COLOR_SUB_TABLE, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].i = start;

+      n[3].i = count;

+      n[4].e = format;

+      n[5].e = type;

+      n[6].data = unpack_image(ctx, 1, count, 1, 1, format, type, table,

+                               &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ColorSubTable(ctx->Exec,

+                         (target, start, count, format, type, table));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyColorSubTable(GLenum target, GLsizei start,

+                       GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5);

+   if (n) {

+      n[1].e = target;

+      n[2].i = start;

+      n[3].i = x;

+      n[4].i = y;

+      n[5].i = width;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyColorSubTable(ctx->Exec, (target, start, x, y, width));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyColorTable(GLenum target, GLenum internalformat,

+                    GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_COLOR_TABLE, 5);

+   if (n) {

+      n[1].e = target;

+      n[2].e = internalformat;

+      n[3].i = x;

+      n[4].i = y;

+      n[5].i = width;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyColorTable(ctx->Exec, (target, internalformat, x, y, width));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,

+                         GLenum format, GLenum type, const GLvoid * filter)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_1D, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = internalFormat;

+      n[3].i = width;

+      n[4].e = format;

+      n[5].e = type;

+      n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, filter,

+                               &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionFilter1D(ctx->Exec, (target, internalFormat, width,

+                                           format, type, filter));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,

+                         GLsizei width, GLsizei height, GLenum format,

+                         GLenum type, const GLvoid * filter)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_FILTER_2D, 7);

+   if (n) {

+      n[1].e = target;

+      n[2].e = internalFormat;

+      n[3].i = width;

+      n[4].i = height;

+      n[5].e = format;

+      n[6].e = type;

+      n[7].data = unpack_image(ctx, 2, width, height, 1, format, type, filter,

+                               &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionFilter2D(ctx->Exec,

+                               (target, internalFormat, width, height, format,

+                                type, filter));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].i = param;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionParameteri(ctx->Exec, (target, pname, param));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].i = params[0];

+      if (pname == GL_CONVOLUTION_BORDER_COLOR ||

+          pname == GL_CONVOLUTION_FILTER_SCALE ||

+          pname == GL_CONVOLUTION_FILTER_BIAS) {

+         n[4].i = params[1];

+         n[5].i = params[2];

+         n[6].i = params[3];

+      }

+      else {

+         n[4].i = n[5].i = n[6].i = 0;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionParameteriv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].f = param;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionParameterf(ctx->Exec, (target, pname, param));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ConvolutionParameterfv(GLenum target, GLenum pname,

+                            const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].f = params[0];

+      if (pname == GL_CONVOLUTION_BORDER_COLOR ||

+          pname == GL_CONVOLUTION_FILTER_SCALE ||

+          pname == GL_CONVOLUTION_FILTER_BIAS) {

+         n[4].f = params[1];

+         n[5].f = params[2];

+         n[6].f = params[3];

+      }

+      else {

+         n[4].f = n[5].f = n[6].f = 0.0F;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ConvolutionParameterfv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_PIXELS, 5);

+   if (n) {

+      n[1].i = x;

+      n[2].i = y;

+      n[3].i = (GLint) width;

+      n[4].i = (GLint) height;

+      n[5].e = type;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat,

+                    GLint x, GLint y, GLsizei width, GLint border)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].e = internalformat;

+      n[4].i = x;

+      n[5].i = y;

+      n[6].i = width;

+      n[7].i = border;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,

+                                      x, y, width, border));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyTexImage2D(GLenum target, GLint level,

+                    GLenum internalformat,

+                    GLint x, GLint y, GLsizei width,

+                    GLsizei height, GLint border)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].e = internalformat;

+      n[4].i = x;

+      n[5].i = y;

+      n[6].i = width;

+      n[7].i = height;

+      n[8].i = border;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,

+                                      x, y, width, height, border));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_CopyTexSubImage1D(GLenum target, GLint level,

+                       GLint xoffset, GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = x;

+      n[5].i = y;

+      n[6].i = width;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyTexSubImage1D(ctx->Exec,

+                             (target, level, xoffset, x, y, width));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyTexSubImage2D(GLenum target, GLint level,

+                       GLint xoffset, GLint yoffset,

+                       GLint x, GLint y, GLsizei width, GLint height)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = x;

+      n[6].i = y;

+      n[7].i = width;

+      n[8].i = height;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,

+                                         x, y, width, height));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CopyTexSubImage3D(GLenum target, GLint level,

+                       GLint xoffset, GLint yoffset, GLint zoffset,

+                       GLint x, GLint y, GLsizei width, GLint height)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = zoffset;

+      n[6].i = x;

+      n[7].i = y;

+      n[8].i = width;

+      n[9].i = height;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CopyTexSubImage3D(ctx->Exec, (target, level,

+                                         xoffset, yoffset, zoffset,

+                                         x, y, width, height));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CullFace(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CULL_FACE, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CullFace(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DepthFunc(GLenum func)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DEPTH_FUNC, 1);

+   if (n) {

+      n[1].e = func;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DepthFunc(ctx->Exec, (func));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DepthMask(GLboolean mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DEPTH_MASK, 1);

+   if (n) {

+      n[1].b = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DepthMask(ctx->Exec, (mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DepthRange(GLclampd nearval, GLclampd farval)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DEPTH_RANGE, 2);

+   if (n) {

+      n[1].f = (GLfloat) nearval;

+      n[2].f = (GLfloat) farval;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DepthRange(ctx->Exec, (nearval, farval));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Disable(GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DISABLE, 1);

+   if (n) {

+      n[1].e = cap;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Disable(ctx->Exec, (cap));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DisableIndexed(GLuint index, GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DISABLE_INDEXED, 2);

+   if (n) {

+      n[1].ui = index;

+      n[2].e = cap;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DisableIndexedEXT(ctx->Exec, (index, cap));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DrawBuffer(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DRAW_BUFFER, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DrawBuffer(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_DrawPixels(GLsizei width, GLsizei height,

+                GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_DRAW_PIXELS, 5);

+   if (n) {

+      n[1].i = width;

+      n[2].i = height;

+      n[3].e = format;

+      n[4].e = type;

+      n[5].data = unpack_image(ctx, 2, width, height, 1, format, type,

+                               pixels, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_Enable(GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ENABLE, 1);

+   if (n) {

+      n[1].e = cap;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Enable(ctx->Exec, (cap));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_EnableIndexed(GLuint index, GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ENABLE_INDEXED, 2);

+   if (n) {

+      n[1].ui = index;

+      n[2].e = cap;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EnableIndexedEXT(ctx->Exec, (index, cap));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_EvalMesh1(GLenum mode, GLint i1, GLint i2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVALMESH1, 3);

+   if (n) {

+      n[1].e = mode;

+      n[2].i = i1;

+      n[3].i = i2;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));

+   }

+}

+

+

+static void GLAPIENTRY

+save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVALMESH2, 5);

+   if (n) {

+      n[1].e = mode;

+      n[2].i = i1;

+      n[3].i = i2;

+      n[4].i = j1;

+      n[5].i = j2;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));

+   }

+}

+

+

+

+

+static void GLAPIENTRY

+save_Fogfv(GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_FOG, 5);

+   if (n) {

+      n[1].e = pname;

+      n[2].f = params[0];

+      n[3].f = params[1];

+      n[4].f = params[2];

+      n[5].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Fogfv(ctx->Exec, (pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Fogf(GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_Fogfv(pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_Fogiv(GLenum pname, const GLint *params)

+{

+   GLfloat p[4];

+   switch (pname) {

+   case GL_FOG_MODE:

+   case GL_FOG_DENSITY:

+   case GL_FOG_START:

+   case GL_FOG_END:

+   case GL_FOG_INDEX:

+      p[0] = (GLfloat) *params;

+      p[1] = 0.0f;

+      p[2] = 0.0f;

+      p[3] = 0.0f;

+      break;

+   case GL_FOG_COLOR:

+      p[0] = INT_TO_FLOAT(params[0]);

+      p[1] = INT_TO_FLOAT(params[1]);

+      p[2] = INT_TO_FLOAT(params[2]);

+      p[3] = INT_TO_FLOAT(params[3]);

+      break;

+   default:

+      /* Error will be caught later in gl_Fogfv */

+      ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);

+   }

+   save_Fogfv(pname, p);

+}

+

+

+static void GLAPIENTRY

+save_Fogi(GLenum pname, GLint param)

+{

+   GLint parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0;

+   save_Fogiv(pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_FrontFace(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_FRONT_FACE, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_FrontFace(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Frustum(GLdouble left, GLdouble right,

+             GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_FRUSTUM, 6);

+   if (n) {

+      n[1].f = (GLfloat) left;

+      n[2].f = (GLfloat) right;

+      n[3].f = (GLfloat) bottom;

+      n[4].f = (GLfloat) top;

+      n[5].f = (GLfloat) nearval;

+      n[6].f = (GLfloat) farval;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Hint(GLenum target, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_HINT, 2);

+   if (n) {

+      n[1].e = target;

+      n[2].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Hint(ctx->Exec, (target, mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Histogram(GLenum target, GLsizei width, GLenum internalFormat,

+               GLboolean sink)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_HISTOGRAM, 4);

+   if (n) {

+      n[1].e = target;

+      n[2].i = width;

+      n[3].e = internalFormat;

+      n[4].b = sink;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Histogram(ctx->Exec, (target, width, internalFormat, sink));

+   }

+}

+

+

+static void GLAPIENTRY

+save_IndexMask(GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_INDEX_MASK, 1);

+   if (n) {

+      n[1].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_IndexMask(ctx->Exec, (mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_InitNames(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_INIT_NAMES, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_InitNames(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LIGHT, 6);

+   if (n) {

+      GLint i, nParams;

+      n[1].e = light;

+      n[2].e = pname;

+      switch (pname) {

+      case GL_AMBIENT:

+         nParams = 4;

+         break;

+      case GL_DIFFUSE:

+         nParams = 4;

+         break;

+      case GL_SPECULAR:

+         nParams = 4;

+         break;

+      case GL_POSITION:

+         nParams = 4;

+         break;

+      case GL_SPOT_DIRECTION:

+         nParams = 3;

+         break;

+      case GL_SPOT_EXPONENT:

+         nParams = 1;

+         break;

+      case GL_SPOT_CUTOFF:

+         nParams = 1;

+         break;

+      case GL_CONSTANT_ATTENUATION:

+         nParams = 1;

+         break;

+      case GL_LINEAR_ATTENUATION:

+         nParams = 1;

+         break;

+      case GL_QUADRATIC_ATTENUATION:

+         nParams = 1;

+         break;

+      default:

+         nParams = 0;

+      }

+      for (i = 0; i < nParams; i++) {

+         n[3 + i].f = params[i];

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Lightfv(ctx->Exec, (light, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Lightf(GLenum light, GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_Lightfv(light, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_Lightiv(GLenum light, GLenum pname, const GLint *params)

+{

+   GLfloat fparam[4];

+   switch (pname) {

+   case GL_AMBIENT:

+   case GL_DIFFUSE:

+   case GL_SPECULAR:

+      fparam[0] = INT_TO_FLOAT(params[0]);

+      fparam[1] = INT_TO_FLOAT(params[1]);

+      fparam[2] = INT_TO_FLOAT(params[2]);

+      fparam[3] = INT_TO_FLOAT(params[3]);

+      break;

+   case GL_POSITION:

+      fparam[0] = (GLfloat) params[0];

+      fparam[1] = (GLfloat) params[1];

+      fparam[2] = (GLfloat) params[2];

+      fparam[3] = (GLfloat) params[3];

+      break;

+   case GL_SPOT_DIRECTION:

+      fparam[0] = (GLfloat) params[0];

+      fparam[1] = (GLfloat) params[1];

+      fparam[2] = (GLfloat) params[2];

+      break;

+   case GL_SPOT_EXPONENT:

+   case GL_SPOT_CUTOFF:

+   case GL_CONSTANT_ATTENUATION:

+   case GL_LINEAR_ATTENUATION:

+   case GL_QUADRATIC_ATTENUATION:

+      fparam[0] = (GLfloat) params[0];

+      break;

+   default:

+      /* error will be caught later in gl_Lightfv */

+      ;

+   }

+   save_Lightfv(light, pname, fparam);

+}

+

+

+static void GLAPIENTRY

+save_Lighti(GLenum light, GLenum pname, GLint param)

+{

+   GLint parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0;

+   save_Lightiv(light, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_LightModelfv(GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LIGHT_MODEL, 5);

+   if (n) {

+      n[1].e = pname;

+      n[2].f = params[0];

+      n[3].f = params[1];

+      n[4].f = params[2];

+      n[5].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LightModelfv(ctx->Exec, (pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_LightModelf(GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_LightModelfv(pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_LightModeliv(GLenum pname, const GLint *params)

+{

+   GLfloat fparam[4];

+   switch (pname) {

+   case GL_LIGHT_MODEL_AMBIENT:

+      fparam[0] = INT_TO_FLOAT(params[0]);

+      fparam[1] = INT_TO_FLOAT(params[1]);

+      fparam[2] = INT_TO_FLOAT(params[2]);

+      fparam[3] = INT_TO_FLOAT(params[3]);

+      break;

+   case GL_LIGHT_MODEL_LOCAL_VIEWER:

+   case GL_LIGHT_MODEL_TWO_SIDE:

+   case GL_LIGHT_MODEL_COLOR_CONTROL:

+      fparam[0] = (GLfloat) params[0];

+      fparam[1] = 0.0F;

+      fparam[2] = 0.0F;

+      fparam[3] = 0.0F;

+      break;

+   default:

+      /* Error will be caught later in gl_LightModelfv */

+      ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);

+   }

+   save_LightModelfv(pname, fparam);

+}

+

+

+static void GLAPIENTRY

+save_LightModeli(GLenum pname, GLint param)

+{

+   GLint parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0;

+   save_LightModeliv(pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_LineStipple(GLint factor, GLushort pattern)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LINE_STIPPLE, 2);

+   if (n) {

+      n[1].i = factor;

+      n[2].us = pattern;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LineStipple(ctx->Exec, (factor, pattern));

+   }

+}

+

+

+static void GLAPIENTRY

+save_LineWidth(GLfloat width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LINE_WIDTH, 1);

+   if (n) {

+      n[1].f = width;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LineWidth(ctx->Exec, (width));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ListBase(GLuint base)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LIST_BASE, 1);

+   if (n) {

+      n[1].ui = base;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ListBase(ctx->Exec, (base));

+   }

+}

+

+

+static void GLAPIENTRY

+save_LoadIdentity(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_LOAD_IDENTITY, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_LoadIdentity(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_LoadMatrixf(const GLfloat * m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LOAD_MATRIX, 16);

+   if (n) {

+      GLuint i;

+      for (i = 0; i < 16; i++) {

+         n[1 + i].f = m[i];

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LoadMatrixf(ctx->Exec, (m));

+   }

+}

+

+

+static void GLAPIENTRY

+save_LoadMatrixd(const GLdouble * m)

+{

+   GLfloat f[16];

+   GLint i;

+   for (i = 0; i < 16; i++) {

+      f[i] = (GLfloat) m[i];

+   }

+   save_LoadMatrixf(f);

+}

+

+

+static void GLAPIENTRY

+save_LoadName(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LOAD_NAME, 1);

+   if (n) {

+      n[1].ui = name;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LoadName(ctx->Exec, (name));

+   }

+}

+

+

+static void GLAPIENTRY

+save_LogicOp(GLenum opcode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_LOGIC_OP, 1);

+   if (n) {

+      n[1].e = opcode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LogicOp(ctx->Exec, (opcode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,

+           GLint order, const GLdouble * points)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAP1, 6);

+   if (n) {

+      GLfloat *pnts = _mesa_copy_map_points1d(target, stride, order, points);

+      n[1].e = target;

+      n[2].f = (GLfloat) u1;

+      n[3].f = (GLfloat) u2;

+      n[4].i = _mesa_evaluator_components(target);      /* stride */

+      n[5].i = order;

+      n[6].data = (void *) pnts;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));

+   }

+}

+

+static void GLAPIENTRY

+save_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,

+           GLint order, const GLfloat * points)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAP1, 6);

+   if (n) {

+      GLfloat *pnts = _mesa_copy_map_points1f(target, stride, order, points);

+      n[1].e = target;

+      n[2].f = u1;

+      n[3].f = u2;

+      n[4].i = _mesa_evaluator_components(target);      /* stride */

+      n[5].i = order;

+      n[6].data = (void *) pnts;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Map2d(GLenum target,

+           GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,

+           GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,

+           const GLdouble * points)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAP2, 10);

+   if (n) {

+      GLfloat *pnts = _mesa_copy_map_points2d(target, ustride, uorder,

+                                              vstride, vorder, points);

+      n[1].e = target;

+      n[2].f = (GLfloat) u1;

+      n[3].f = (GLfloat) u2;

+      n[4].f = (GLfloat) v1;

+      n[5].f = (GLfloat) v2;

+      /* XXX verify these strides are correct */

+      n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */

+      n[7].i = _mesa_evaluator_components(target);      /*vstride */

+      n[8].i = uorder;

+      n[9].i = vorder;

+      n[10].data = (void *) pnts;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Map2d(ctx->Exec, (target,

+                             u1, u2, ustride, uorder,

+                             v1, v2, vstride, vorder, points));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Map2f(GLenum target,

+           GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,

+           GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,

+           const GLfloat * points)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAP2, 10);

+   if (n) {

+      GLfloat *pnts = _mesa_copy_map_points2f(target, ustride, uorder,

+                                              vstride, vorder, points);

+      n[1].e = target;

+      n[2].f = u1;

+      n[3].f = u2;

+      n[4].f = v1;

+      n[5].f = v2;

+      /* XXX verify these strides are correct */

+      n[6].i = _mesa_evaluator_components(target) * vorder;     /*ustride */

+      n[7].i = _mesa_evaluator_components(target);      /*vstride */

+      n[8].i = uorder;

+      n[9].i = vorder;

+      n[10].data = (void *) pnts;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,

+                             v1, v2, vstride, vorder, points));

+   }

+}

+

+

+static void GLAPIENTRY

+save_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAPGRID1, 3);

+   if (n) {

+      n[1].i = un;

+      n[2].f = u1;

+      n[3].f = u2;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_MapGrid1f(ctx->Exec, (un, u1, u2));

+   }

+}

+

+

+static void GLAPIENTRY

+save_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)

+{

+   save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);

+}

+

+

+static void GLAPIENTRY

+save_MapGrid2f(GLint un, GLfloat u1, GLfloat u2,

+               GLint vn, GLfloat v1, GLfloat v2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MAPGRID2, 6);

+   if (n) {

+      n[1].i = un;

+      n[2].f = u1;

+      n[3].f = u2;

+      n[4].i = vn;

+      n[5].f = v1;

+      n[6].f = v2;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_MapGrid2d(GLint un, GLdouble u1, GLdouble u2,

+               GLint vn, GLdouble v1, GLdouble v2)

+{

+   save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,

+                  vn, (GLfloat) v1, (GLfloat) v2);

+}

+

+

+static void GLAPIENTRY

+save_MatrixMode(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MATRIX_MODE, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_MatrixMode(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MIN_MAX, 3);

+   if (n) {

+      n[1].e = target;

+      n[2].e = internalFormat;

+      n[3].b = sink;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Minmax(ctx->Exec, (target, internalFormat, sink));

+   }

+}

+

+

+static void GLAPIENTRY

+save_MultMatrixf(const GLfloat * m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_MULT_MATRIX, 16);

+   if (n) {

+      GLuint i;

+      for (i = 0; i < 16; i++) {

+         n[1 + i].f = m[i];

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_MultMatrixf(ctx->Exec, (m));

+   }

+}

+

+

+static void GLAPIENTRY

+save_MultMatrixd(const GLdouble * m)

+{

+   GLfloat f[16];

+   GLint i;

+   for (i = 0; i < 16; i++) {

+      f[i] = (GLfloat) m[i];

+   }

+   save_MultMatrixf(f);

+}

+

+

+static void GLAPIENTRY

+save_NewList(GLuint name, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   /* It's an error to call this function while building a display list */

+   _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");

+   (void) name;

+   (void) mode;

+}

+

+

+

+static void GLAPIENTRY

+save_Ortho(GLdouble left, GLdouble right,

+           GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ORTHO, 6);

+   if (n) {

+      n[1].f = (GLfloat) left;

+      n[2].f = (GLfloat) right;

+      n[3].f = (GLfloat) bottom;

+      n[4].f = (GLfloat) top;

+      n[5].f = (GLfloat) nearval;

+      n[6].f = (GLfloat) farval;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PIXEL_MAP, 3);

+   if (n) {

+      n[1].e = map;

+      n[2].i = mapsize;

+      n[3].data = (void *) malloc(mapsize * sizeof(GLfloat));

+      memcpy(n[3].data, (void *) values, mapsize * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)

+{

+   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];

+   GLint i;

+   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = (GLfloat) values[i];

+      }

+   }

+   else {

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = UINT_TO_FLOAT(values[i]);

+      }

+   }

+   save_PixelMapfv(map, mapsize, fvalues);

+}

+

+

+static void GLAPIENTRY

+save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)

+{

+   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];

+   GLint i;

+   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = (GLfloat) values[i];

+      }

+   }

+   else {

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = USHORT_TO_FLOAT(values[i]);

+      }

+   }

+   save_PixelMapfv(map, mapsize, fvalues);

+}

+

+

+static void GLAPIENTRY

+save_PixelTransferf(GLenum pname, GLfloat param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PIXEL_TRANSFER, 2);

+   if (n) {

+      n[1].e = pname;

+      n[2].f = param;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PixelTransferf(ctx->Exec, (pname, param));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PixelTransferi(GLenum pname, GLint param)

+{

+   save_PixelTransferf(pname, (GLfloat) param);

+}

+

+

+static void GLAPIENTRY

+save_PixelZoom(GLfloat xfactor, GLfloat yfactor)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PIXEL_ZOOM, 2);

+   if (n) {

+      n[1].f = xfactor;

+      n[2].f = yfactor;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PointParameterfvEXT(GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_POINT_PARAMETERS, 4);

+   if (n) {

+      n[1].e = pname;

+      n[2].f = params[0];

+      n[3].f = params[1];

+      n[4].f = params[2];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PointParameterfvEXT(ctx->Exec, (pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PointParameterfEXT(GLenum pname, GLfloat param)

+{

+   GLfloat parray[3];

+   parray[0] = param;

+   parray[1] = parray[2] = 0.0F;

+   save_PointParameterfvEXT(pname, parray);

+}

+

+static void GLAPIENTRY

+save_PointParameteriNV(GLenum pname, GLint param)

+{

+   GLfloat parray[3];

+   parray[0] = (GLfloat) param;

+   parray[1] = parray[2] = 0.0F;

+   save_PointParameterfvEXT(pname, parray);

+}

+

+static void GLAPIENTRY

+save_PointParameterivNV(GLenum pname, const GLint * param)

+{

+   GLfloat parray[3];

+   parray[0] = (GLfloat) param[0];

+   parray[1] = parray[2] = 0.0F;

+   save_PointParameterfvEXT(pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_PointSize(GLfloat size)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_POINT_SIZE, 1);

+   if (n) {

+      n[1].f = size;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PointSize(ctx->Exec, (size));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PolygonMode(GLenum face, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_POLYGON_MODE, 2);

+   if (n) {

+      n[1].e = face;

+      n[2].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PolygonMode(ctx->Exec, (face, mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PolygonStipple(const GLubyte * pattern)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_POLYGON_STIPPLE, 1);

+   if (n) {

+      n[1].data = unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,

+                               pattern, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PolygonOffset(GLfloat factor, GLfloat units)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET, 2);

+   if (n) {

+      n[1].f = factor;

+      n[2].f = units;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PolygonOffset(ctx->Exec, (factor, units));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PolygonOffsetEXT(GLfloat factor, GLfloat bias)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   /* XXX mult by DepthMaxF here??? */

+   save_PolygonOffset(factor, ctx->DrawBuffer->_DepthMaxF * bias);

+}

+

+

+static void GLAPIENTRY

+save_PopAttrib(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_POP_ATTRIB, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_PopAttrib(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_PopMatrix(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_POP_MATRIX, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_PopMatrix(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_PopName(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_POP_NAME, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_PopName(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_PrioritizeTextures(GLsizei num, const GLuint * textures,

+                        const GLclampf * priorities)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   for (i = 0; i < num; i++) {

+      Node *n;

+      n = alloc_instruction(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);

+      if (n) {

+         n[1].ui = textures[i];

+         n[2].f = priorities[i];

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PushAttrib(GLbitfield mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PUSH_ATTRIB, 1);

+   if (n) {

+      n[1].bf = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PushAttrib(ctx->Exec, (mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_PushMatrix(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_PUSH_MATRIX, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_PushMatrix(ctx->Exec, ());

+   }

+}

+

+

+static void GLAPIENTRY

+save_PushName(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PUSH_NAME, 1);

+   if (n) {

+      n[1].ui = name;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PushName(ctx->Exec, (name));

+   }

+}

+

+

+static void GLAPIENTRY

+save_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_RASTER_POS, 4);

+   if (n) {

+      n[1].f = x;

+      n[2].f = y;

+      n[3].f = z;

+      n[4].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_RasterPos4f(ctx->Exec, (x, y, z, w));

+   }

+}

+

+static void GLAPIENTRY

+save_RasterPos2d(GLdouble x, GLdouble y)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2f(GLfloat x, GLfloat y)

+{

+   save_RasterPos4f(x, y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2i(GLint x, GLint y)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2s(GLshort x, GLshort y)

+{

+   save_RasterPos4f(x, y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_RasterPos4f(x, y, z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3i(GLint x, GLint y, GLint z)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3s(GLshort x, GLshort y, GLshort z)

+{

+   save_RasterPos4f(x, y, z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);

+}

+

+static void GLAPIENTRY

+save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)

+{

+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);

+}

+

+static void GLAPIENTRY

+save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)

+{

+   save_RasterPos4f(x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_RasterPos2dv(const GLdouble * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2fv(const GLfloat * v)

+{

+   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2iv(const GLint * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos2sv(const GLshort * v)

+{

+   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3dv(const GLdouble * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3fv(const GLfloat * v)

+{

+   save_RasterPos4f(v[0], v[1], v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3iv(const GLint * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos3sv(const GLshort * v)

+{

+   save_RasterPos4f(v[0], v[1], v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_RasterPos4dv(const GLdouble * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],

+                    (GLfloat) v[2], (GLfloat) v[3]);

+}

+

+static void GLAPIENTRY

+save_RasterPos4fv(const GLfloat * v)

+{

+   save_RasterPos4f(v[0], v[1], v[2], v[3]);

+}

+

+static void GLAPIENTRY

+save_RasterPos4iv(const GLint * v)

+{

+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],

+                    (GLfloat) v[2], (GLfloat) v[3]);

+}

+

+static void GLAPIENTRY

+save_RasterPos4sv(const GLshort * v)

+{

+   save_RasterPos4f(v[0], v[1], v[2], v[3]);

+}

+

+

+static void GLAPIENTRY

+save_PassThrough(GLfloat token)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PASSTHROUGH, 1);

+   if (n) {

+      n[1].f = token;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_PassThrough(ctx->Exec, (token));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ReadBuffer(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_READ_BUFFER, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ReadBuffer(ctx->Exec, (mode));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ResetHistogram(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_RESET_HISTOGRAM, 1);

+   if (n) {

+      n[1].e = target;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ResetHistogram(ctx->Exec, (target));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ResetMinmax(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_RESET_MIN_MAX, 1);

+   if (n) {

+      n[1].e = target;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ResetMinmax(ctx->Exec, (target));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ROTATE, 4);

+   if (n) {

+      n[1].f = angle;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Rotatef(ctx->Exec, (angle, x, y, z));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)

+{

+   save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);

+}

+

+

+static void GLAPIENTRY

+save_Scalef(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_SCALE, 3);

+   if (n) {

+      n[1].f = x;

+      n[2].f = y;

+      n[3].f = z;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Scalef(ctx->Exec, (x, y, z));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Scaled(GLdouble x, GLdouble y, GLdouble z)

+{

+   save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);

+}

+

+

+static void GLAPIENTRY

+save_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_SCISSOR, 4);

+   if (n) {

+      n[1].i = x;

+      n[2].i = y;

+      n[3].i = width;

+      n[4].i = height;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Scissor(ctx->Exec, (x, y, width, height));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ShadeModel(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);

+

+   if (ctx->ExecuteFlag) {

+      CALL_ShadeModel(ctx->Exec, (mode));

+   }

+

+   if (ctx->ListState.Current.ShadeModel == mode)

+      return;

+

+   SAVE_FLUSH_VERTICES(ctx);

+

+   /* Only save the value if we know the statechange will take effect:

+    */

+   if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)

+      ctx->ListState.Current.ShadeModel = mode;

+

+   n = alloc_instruction(ctx, OPCODE_SHADE_MODEL, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilFunc(GLenum func, GLint ref, GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC, 3);

+   if (n) {

+      n[1].e = func;

+      n[2].i = ref;

+      n[3].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilFunc(ctx->Exec, (func, ref, mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilMask(GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_MASK, 1);

+   if (n) {

+      n[1].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilMask(ctx->Exec, (mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_OP, 3);

+   if (n) {

+      n[1].e = fail;

+      n[2].e = zfail;

+      n[3].e = zpass;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);

+   if (n) {

+      n[1].e = face;

+      n[2].e = func;

+      n[3].i = ref;

+      n[4].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref,

+                            GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   /* GL_FRONT */

+   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);

+   if (n) {

+      n[1].e = GL_FRONT;

+      n[2].e = frontfunc;

+      n[3].i = ref;

+      n[4].ui = mask;

+   }

+   /* GL_BACK */

+   n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);

+   if (n) {

+      n[1].e = GL_BACK;

+      n[2].e = backfunc;

+      n[3].i = ref;

+      n[4].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));

+      CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilMaskSeparate(GLenum face, GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);

+   if (n) {

+      n[1].e = face;

+      n[2].ui = mask;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilMaskSeparate(ctx->Exec, (face, mask));

+   }

+}

+

+

+static void GLAPIENTRY

+save_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);

+   if (n) {

+      n[1].e = face;

+      n[2].e = fail;

+      n[3].e = zfail;

+      n[4].e = zpass;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TEXENV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      if (pname == GL_TEXTURE_ENV_COLOR) {

+         n[3].f = params[0];

+         n[4].f = params[1];

+         n[5].f = params[2];

+         n[6].f = params[3];

+      }

+      else {

+         n[3].f = params[0];

+         n[4].f = n[5].f = n[6].f = 0.0F;

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexEnvfv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexEnvf(GLenum target, GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = (GLfloat) param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_TexEnvfv(target, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_TexEnvi(GLenum target, GLenum pname, GLint param)

+{

+   GLfloat p[4];

+   p[0] = (GLfloat) param;

+   p[1] = p[2] = p[3] = 0.0F;

+   save_TexEnvfv(target, pname, p);

+}

+

+

+static void GLAPIENTRY

+save_TexEnviv(GLenum target, GLenum pname, const GLint * param)

+{

+   GLfloat p[4];

+   if (pname == GL_TEXTURE_ENV_COLOR) {

+      p[0] = INT_TO_FLOAT(param[0]);

+      p[1] = INT_TO_FLOAT(param[1]);

+      p[2] = INT_TO_FLOAT(param[2]);

+      p[3] = INT_TO_FLOAT(param[3]);

+   }

+   else {

+      p[0] = (GLfloat) param[0];

+      p[1] = p[2] = p[3] = 0.0F;

+   }

+   save_TexEnvfv(target, pname, p);

+}

+

+

+static void GLAPIENTRY

+save_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TEXGEN, 6);

+   if (n) {

+      n[1].e = coord;

+      n[2].e = pname;

+      n[3].f = params[0];

+      n[4].f = params[1];

+      n[5].f = params[2];

+      n[6].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexGenfv(ctx->Exec, (coord, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)

+{

+   GLfloat p[4];

+   p[0] = (GLfloat) params[0];

+   p[1] = (GLfloat) params[1];

+   p[2] = (GLfloat) params[2];

+   p[3] = (GLfloat) params[3];

+   save_TexGenfv(coord, pname, p);

+}

+

+

+static void GLAPIENTRY

+save_TexGend(GLenum coord, GLenum pname, GLdouble param)

+{

+   GLfloat parray[4];

+   parray[0] = (GLfloat) param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_TexGenfv(coord, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)

+{

+   GLfloat p[4];

+   p[0] = (GLfloat) params[0];

+   p[1] = (GLfloat) params[1];

+   p[2] = (GLfloat) params[2];

+   p[3] = (GLfloat) params[3];

+   save_TexGenfv(coord, pname, p);

+}

+

+

+static void GLAPIENTRY

+save_TexGenf(GLenum coord, GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_TexGenfv(coord, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_TexGeni(GLenum coord, GLenum pname, GLint param)

+{

+   GLint parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0;

+   save_TexGeniv(coord, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].f = params[0];

+      n[4].f = params[1];

+      n[5].f = params[2];

+      n[6].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexParameterfv(ctx->Exec, (target, pname, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexParameterf(GLenum target, GLenum pname, GLfloat param)

+{

+   GLfloat parray[4];

+   parray[0] = param;

+   parray[1] = parray[2] = parray[3] = 0.0F;

+   save_TexParameterfv(target, pname, parray);

+}

+

+

+static void GLAPIENTRY

+save_TexParameteri(GLenum target, GLenum pname, GLint param)

+{

+   GLfloat fparam[4];

+   fparam[0] = (GLfloat) param;

+   fparam[1] = fparam[2] = fparam[3] = 0.0F;

+   save_TexParameterfv(target, pname, fparam);

+}

+

+

+static void GLAPIENTRY

+save_TexParameteriv(GLenum target, GLenum pname, const GLint *params)

+{

+   GLfloat fparam[4];

+   fparam[0] = (GLfloat) params[0];

+   fparam[1] = fparam[2] = fparam[3] = 0.0F;

+   save_TexParameterfv(target, pname, fparam);

+}

+

+

+static void GLAPIENTRY

+save_TexImage1D(GLenum target,

+                GLint level, GLint components,

+                GLsizei width, GLint border,

+                GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_1D) {

+      /* don't compile, execute immediately */

+      CALL_TexImage1D(ctx->Exec, (target, level, components, width,

+                                  border, format, type, pixels));

+   }

+   else {

+      Node *n;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE1D, 8);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].i = components;

+         n[4].i = (GLint) width;

+         n[5].i = border;

+         n[6].e = format;

+         n[7].e = type;

+         n[8].data = unpack_image(ctx, 1, width, 1, 1, format, type,

+                                  pixels, &ctx->Unpack);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_TexImage1D(ctx->Exec, (target, level, components, width,

+                                     border, format, type, pixels));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexImage2D(GLenum target,

+                GLint level, GLint components,

+                GLsizei width, GLsizei height, GLint border,

+                GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_2D) {

+      /* don't compile, execute immediately */

+      CALL_TexImage2D(ctx->Exec, (target, level, components, width,

+                                  height, border, format, type, pixels));

+   }

+   else {

+      Node *n;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE2D, 9);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].i = components;

+         n[4].i = (GLint) width;

+         n[5].i = (GLint) height;

+         n[6].i = border;

+         n[7].e = format;

+         n[8].e = type;

+         n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,

+                                  pixels, &ctx->Unpack);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_TexImage2D(ctx->Exec, (target, level, components, width,

+                                     height, border, format, type, pixels));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexImage3D(GLenum target,

+                GLint level, GLint internalFormat,

+                GLsizei width, GLsizei height, GLsizei depth,

+                GLint border,

+                GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_3D) {

+      /* don't compile, execute immediately */

+      CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,

+                                  height, depth, border, format, type,

+                                  pixels));

+   }

+   else {

+      Node *n;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      n = alloc_instruction(ctx, OPCODE_TEX_IMAGE3D, 10);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].i = (GLint) internalFormat;

+         n[4].i = (GLint) width;

+         n[5].i = (GLint) height;

+         n[6].i = (GLint) depth;

+         n[7].i = border;

+         n[8].e = format;

+         n[9].e = type;

+         n[10].data = unpack_image(ctx, 3, width, height, depth, format, type,

+                                   pixels, &ctx->Unpack);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,

+                                     height, depth, border, format, type,

+                                     pixels));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,

+                   GLsizei width, GLenum format, GLenum type,

+                   const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE1D, 7);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = (GLint) width;

+      n[5].e = format;

+      n[6].e = type;

+      n[7].data = unpack_image(ctx, 1, width, 1, 1, format, type,

+                               pixels, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,

+                                     format, type, pixels));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexSubImage2D(GLenum target, GLint level,

+                   GLint xoffset, GLint yoffset,

+                   GLsizei width, GLsizei height,

+                   GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE2D, 9);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = (GLint) width;

+      n[6].i = (GLint) height;

+      n[7].e = format;

+      n[8].e = type;

+      n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,

+                               pixels, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,

+                                     width, height, format, type, pixels));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TexSubImage3D(GLenum target, GLint level,

+                   GLint xoffset, GLint yoffset, GLint zoffset,

+                   GLsizei width, GLsizei height, GLsizei depth,

+                   GLenum format, GLenum type, const GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE3D, 11);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = zoffset;

+      n[6].i = (GLint) width;

+      n[7].i = (GLint) height;

+      n[8].i = (GLint) depth;

+      n[9].e = format;

+      n[10].e = type;

+      n[11].data = unpack_image(ctx, 3, width, height, depth, format, type,

+                                pixels, &ctx->Unpack);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexSubImage3D(ctx->Exec, (target, level,

+                                     xoffset, yoffset, zoffset,

+                                     width, height, depth, format, type,

+                                     pixels));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Translatef(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TRANSLATE, 3);

+   if (n) {

+      n[1].f = x;

+      n[2].f = y;

+      n[3].f = z;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Translatef(ctx->Exec, (x, y, z));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Translated(GLdouble x, GLdouble y, GLdouble z)

+{

+   save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);

+}

+

+

+

+static void GLAPIENTRY

+save_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_VIEWPORT, 4);

+   if (n) {

+      n[1].i = x;

+      n[2].i = y;

+      n[3].i = (GLint) width;

+      n[4].i = (GLint) height;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Viewport(ctx->Exec, (x, y, width, height));

+   }

+}

+

+

+static void GLAPIENTRY

+save_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_WINDOW_POS, 4);

+   if (n) {

+      n[1].f = x;

+      n[2].f = y;

+      n[3].f = z;

+      n[4].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));

+   }

+}

+

+static void GLAPIENTRY

+save_WindowPos2dMESA(GLdouble x, GLdouble y)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2fMESA(GLfloat x, GLfloat y)

+{

+   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2iMESA(GLint x, GLint y)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2sMESA(GLshort x, GLshort y)

+{

+   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_WindowPos4fMESA(x, y, z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3iMESA(GLint x, GLint y, GLint z)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)

+{

+   save_WindowPos4fMESA(x, y, z, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);

+}

+

+static void GLAPIENTRY

+save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)

+{

+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);

+}

+

+static void GLAPIENTRY

+save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)

+{

+   save_WindowPos4fMESA(x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_WindowPos2dvMESA(const GLdouble * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2fvMESA(const GLfloat * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2ivMESA(const GLint * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos2svMESA(const GLshort * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3dvMESA(const GLdouble * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3fvMESA(const GLfloat * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3ivMESA(const GLint * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos3svMESA(const GLshort * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);

+}

+

+static void GLAPIENTRY

+save_WindowPos4dvMESA(const GLdouble * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],

+                        (GLfloat) v[2], (GLfloat) v[3]);

+}

+

+static void GLAPIENTRY

+save_WindowPos4fvMESA(const GLfloat * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);

+}

+

+static void GLAPIENTRY

+save_WindowPos4ivMESA(const GLint * v)

+{

+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],

+                        (GLfloat) v[2], (GLfloat) v[3]);

+}

+

+static void GLAPIENTRY

+save_WindowPos4svMESA(const GLshort * v)

+{

+   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);

+}

+

+

+

+/* GL_ARB_multitexture */

+static void GLAPIENTRY

+save_ActiveTextureARB(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ACTIVE_TEXTURE, 1);

+   if (n) {

+      n[1].e = target;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ActiveTextureARB(ctx->Exec, (target));

+   }

+}

+

+

+/* GL_ARB_transpose_matrix */

+

+static void GLAPIENTRY

+save_LoadTransposeMatrixdARB(const GLdouble m[16])

+{

+   GLfloat tm[16];

+   _math_transposefd(tm, m);

+   save_LoadMatrixf(tm);

+}

+

+

+static void GLAPIENTRY

+save_LoadTransposeMatrixfARB(const GLfloat m[16])

+{

+   GLfloat tm[16];

+   _math_transposef(tm, m);

+   save_LoadMatrixf(tm);

+}

+

+

+static void GLAPIENTRY

+save_MultTransposeMatrixdARB(const GLdouble m[16])

+{

+   GLfloat tm[16];

+   _math_transposefd(tm, m);

+   save_MultMatrixf(tm);

+}

+

+

+static void GLAPIENTRY

+save_MultTransposeMatrixfARB(const GLfloat m[16])

+{

+   GLfloat tm[16];

+   _math_transposef(tm, m);

+   save_MultMatrixf(tm);

+}

+

+

+/* GL_ARB_texture_compression */

+static void GLAPIENTRY

+save_CompressedTexImage1DARB(GLenum target, GLint level,

+                             GLenum internalFormat, GLsizei width,

+                             GLint border, GLsizei imageSize,

+                             const GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_1D) {

+      /* don't compile, execute immediately */

+      CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,

+                                               width, border, imageSize,

+                                               data));

+   }

+   else {

+      Node *n;

+      GLvoid *image;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      /* make copy of image */

+      image = malloc(imageSize);

+      if (!image) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");

+         return;

+      }

+      memcpy(image, data, imageSize);

+      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].e = internalFormat;

+         n[4].i = (GLint) width;

+         n[5].i = border;

+         n[6].i = imageSize;

+         n[7].data = image;

+      }

+      else if (image) {

+         free(image);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_CompressedTexImage1DARB(ctx->Exec,

+                                      (target, level, internalFormat, width,

+                                       border, imageSize, data));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_CompressedTexImage2DARB(GLenum target, GLint level,

+                             GLenum internalFormat, GLsizei width,

+                             GLsizei height, GLint border, GLsizei imageSize,

+                             const GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_2D) {

+      /* don't compile, execute immediately */

+      CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,

+                                               width, height, border,

+                                               imageSize, data));

+   }

+   else {

+      Node *n;

+      GLvoid *image;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      /* make copy of image */

+      image = malloc(imageSize);

+      if (!image) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");

+         return;

+      }

+      memcpy(image, data, imageSize);

+      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].e = internalFormat;

+         n[4].i = (GLint) width;

+         n[5].i = (GLint) height;

+         n[6].i = border;

+         n[7].i = imageSize;

+         n[8].data = image;

+      }

+      else if (image) {

+         free(image);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_CompressedTexImage2DARB(ctx->Exec,

+                                      (target, level, internalFormat, width,

+                                       height, border, imageSize, data));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_CompressedTexImage3DARB(GLenum target, GLint level,

+                             GLenum internalFormat, GLsizei width,

+                             GLsizei height, GLsizei depth, GLint border,

+                             GLsizei imageSize, const GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (target == GL_PROXY_TEXTURE_3D) {

+      /* don't compile, execute immediately */

+      CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,

+                                               width, height, depth, border,

+                                               imageSize, data));

+   }

+   else {

+      Node *n;

+      GLvoid *image;

+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+      /* make copy of image */

+      image = malloc(imageSize);

+      if (!image) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");

+         return;

+      }

+      memcpy(image, data, imageSize);

+      n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9);

+      if (n) {

+         n[1].e = target;

+         n[2].i = level;

+         n[3].e = internalFormat;

+         n[4].i = (GLint) width;

+         n[5].i = (GLint) height;

+         n[6].i = (GLint) depth;

+         n[7].i = border;

+         n[8].i = imageSize;

+         n[9].data = image;

+      }

+      else if (image) {

+         free(image);

+      }

+      if (ctx->ExecuteFlag) {

+         CALL_CompressedTexImage3DARB(ctx->Exec,

+                                      (target, level, internalFormat, width,

+                                       height, depth, border, imageSize,

+                                       data));

+      }

+   }

+}

+

+

+static void GLAPIENTRY

+save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,

+                                GLsizei width, GLenum format,

+                                GLsizei imageSize, const GLvoid * data)

+{

+   Node *n;

+   GLvoid *image;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   /* make copy of image */

+   image = malloc(imageSize);

+   if (!image) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");

+      return;

+   }

+   memcpy(image, data, imageSize);

+   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = (GLint) width;

+      n[5].e = format;

+      n[6].i = imageSize;

+      n[7].data = image;

+   }

+   else if (image) {

+      free(image);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,

+                                                  width, format, imageSize,

+                                                  data));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,

+                                GLint yoffset, GLsizei width, GLsizei height,

+                                GLenum format, GLsizei imageSize,

+                                const GLvoid * data)

+{

+   Node *n;

+   GLvoid *image;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   /* make copy of image */

+   image = malloc(imageSize);

+   if (!image) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");

+      return;

+   }

+   memcpy(image, data, imageSize);

+   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = (GLint) width;

+      n[6].i = (GLint) height;

+      n[7].e = format;

+      n[8].i = imageSize;

+      n[9].data = image;

+   }

+   else if (image) {

+      free(image);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CompressedTexSubImage2DARB(ctx->Exec,

+                                      (target, level, xoffset, yoffset, width,

+                                       height, format, imageSize, data));

+   }

+}

+

+

+static void GLAPIENTRY

+save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,

+                                GLint yoffset, GLint zoffset, GLsizei width,

+                                GLsizei height, GLsizei depth, GLenum format,

+                                GLsizei imageSize, const GLvoid * data)

+{

+   Node *n;

+   GLvoid *image;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   /* make copy of image */

+   image = malloc(imageSize);

+   if (!image) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");

+      return;

+   }

+   memcpy(image, data, imageSize);

+   n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11);

+   if (n) {

+      n[1].e = target;

+      n[2].i = level;

+      n[3].i = xoffset;

+      n[4].i = yoffset;

+      n[5].i = zoffset;

+      n[6].i = (GLint) width;

+      n[7].i = (GLint) height;

+      n[8].i = (GLint) depth;

+      n[9].e = format;

+      n[10].i = imageSize;

+      n[11].data = image;

+   }

+   else if (image) {

+      free(image);

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_CompressedTexSubImage3DARB(ctx->Exec,

+                                      (target, level, xoffset, yoffset,

+                                       zoffset, width, height, depth, format,

+                                       imageSize, data));

+   }

+}

+

+

+/* GL_ARB_multisample */

+static void GLAPIENTRY

+save_SampleCoverageARB(GLclampf value, GLboolean invert)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_SAMPLE_COVERAGE, 2);

+   if (n) {

+      n[1].f = value;

+      n[2].b = invert;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_SampleCoverageARB(ctx->Exec, (value, invert));

+   }

+}

+

+

+/*

+ * GL_NV_vertex_program

+ */

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+static void GLAPIENTRY

+save_BindProgramNV(GLenum target, GLuint id)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BIND_PROGRAM_NV, 2);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = id;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BindProgramNV(ctx->Exec, (target, id));

+   }

+}

+

+static void GLAPIENTRY

+save_ProgramEnvParameter4fARB(GLenum target, GLuint index,

+                              GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = index;

+      n[3].f = x;

+      n[4].f = y;

+      n[5].f = z;

+      n[6].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramEnvParameter4fvARB(GLenum target, GLuint index,

+                               const GLfloat *params)

+{

+   save_ProgramEnvParameter4fARB(target, index, params[0], params[1],

+                                 params[2], params[3]);

+}

+

+

+static void GLAPIENTRY

+save_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,

+				const GLfloat * params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (count > 0) {

+      GLint i;

+      const GLfloat * p = params;

+

+      for (i = 0 ; i < count ; i++) {

+	 n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);

+	 if (n) {

+	    n[1].e = target;

+	    n[2].ui = index;

+	    n[3].f = p[0];

+	    n[4].f = p[1];

+	    n[5].f = p[2];

+	    n[6].f = p[3];

+	    p += 4;

+	 }

+      }

+   }

+

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramEnvParameter4dARB(GLenum target, GLuint index,

+                              GLdouble x, GLdouble y, GLdouble z, GLdouble w)

+{

+   save_ProgramEnvParameter4fARB(target, index,

+                                 (GLfloat) x,

+                                 (GLfloat) y, (GLfloat) z, (GLfloat) w);

+}

+

+

+static void GLAPIENTRY

+save_ProgramEnvParameter4dvARB(GLenum target, GLuint index,

+                               const GLdouble *params)

+{

+   save_ProgramEnvParameter4fARB(target, index,

+                                 (GLfloat) params[0],

+                                 (GLfloat) params[1],

+                                 (GLfloat) params[2], (GLfloat) params[3]);

+}

+

+#endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program */

+

+#if FEATURE_NV_vertex_program

+static void GLAPIENTRY

+save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_EXECUTE_PROGRAM_NV, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = id;

+      n[3].f = params[0];

+      n[4].f = params[1];

+      n[5].f = params[2];

+      n[6].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ExecuteProgramNV(ctx->Exec, (target, id, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramParameters4dvNV(GLenum target, GLuint index,

+                            GLsizei num, const GLdouble *params)

+{

+   GLint i;

+   for (i = 0; i < num; i++) {

+      save_ProgramEnvParameter4dvARB(target, index + i, params + 4 * i);

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramParameters4fvNV(GLenum target, GLuint index,

+                            GLsizei num, const GLfloat *params)

+{

+   GLint i;

+   for (i = 0; i < num; i++) {

+      save_ProgramEnvParameter4fvARB(target, index + i, params + 4 * i);

+   }

+}

+

+

+static void GLAPIENTRY

+save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,

+                   const GLubyte * program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_LOAD_PROGRAM_NV, 4);

+   if (n) {

+      GLubyte *programCopy = (GLubyte *) malloc(len);

+      if (!programCopy) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");

+         return;

+      }

+      memcpy(programCopy, program, len);

+      n[1].e = target;

+      n[2].ui = id;

+      n[3].i = len;

+      n[4].data = programCopy;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_LoadProgramNV(ctx->Exec, (target, id, len, program));

+   }

+}

+

+

+static void GLAPIENTRY

+save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 2);

+   if (n) {

+      GLuint *idCopy = (GLuint *) malloc(num * sizeof(GLuint));

+      if (!idCopy) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");

+         return;

+      }

+      memcpy(idCopy, ids, num * sizeof(GLuint));

+      n[1].i = num;

+      n[2].data = idCopy;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_RequestResidentProgramsNV(ctx->Exec, (num, ids));

+   }

+}

+

+

+static void GLAPIENTRY

+save_TrackMatrixNV(GLenum target, GLuint address,

+                   GLenum matrix, GLenum transform)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 4);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = address;

+      n[3].e = matrix;

+      n[4].e = transform;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TrackMatrixNV(ctx->Exec, (target, address, matrix, transform));

+   }

+}

+#endif /* FEATURE_NV_vertex_program */

+

+

+/*

+ * GL_NV_fragment_program

+ */

+#if FEATURE_NV_fragment_program

+static void GLAPIENTRY

+save_ProgramLocalParameter4fARB(GLenum target, GLuint index,

+                                GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = index;

+      n[3].f = x;

+      n[4].f = y;

+      n[5].f = z;

+      n[6].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramLocalParameter4fvARB(GLenum target, GLuint index,

+                                 const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = index;

+      n[3].f = params[0];

+      n[4].f = params[1];

+      n[5].f = params[2];

+      n[6].f = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,

+				  const GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (count > 0) {

+      GLint i;

+      const GLfloat * p = params;

+

+      for (i = 0 ; i < count ; i++) {

+	 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);

+	 if (n) {

+	    n[1].e = target;

+	    n[2].ui = index;

+	    n[3].f = p[0];

+	    n[4].f = p[1];

+	    n[5].f = p[2];

+	    n[6].f = p[3];

+	    p += 4;

+	 }

+      }

+   }

+

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramLocalParameter4dARB(GLenum target, GLuint index,

+                                GLdouble x, GLdouble y,

+                                GLdouble z, GLdouble w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = index;

+      n[3].f = (GLfloat) x;

+      n[4].f = (GLfloat) y;

+      n[5].f = (GLfloat) z;

+      n[6].f = (GLfloat) w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramLocalParameter4dvARB(GLenum target, GLuint index,

+                                 const GLdouble *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = index;

+      n[3].f = (GLfloat) params[0];

+      n[4].f = (GLfloat) params[1];

+      n[5].f = (GLfloat) params[2];

+      n[6].f = (GLfloat) params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));

+   }

+}

+

+static void GLAPIENTRY

+save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,

+                               GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);

+   if (n) {

+      GLubyte *nameCopy = (GLubyte *) malloc(len);

+      if (!nameCopy) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");

+         return;

+      }

+      memcpy(nameCopy, name, len);

+      n[1].ui = id;

+      n[2].i = len;

+      n[3].data = nameCopy;

+      n[4].f = x;

+      n[5].f = y;

+      n[6].f = z;

+      n[7].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramNamedParameter4fNV(ctx->Exec, (id, len, name, x, y, z, w));

+   }

+}

+

+

+static void GLAPIENTRY

+save_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name,

+                                const float v[])

+{

+   save_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);

+}

+

+

+static void GLAPIENTRY

+save_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name,

+                               GLdouble x, GLdouble y, GLdouble z, GLdouble w)

+{

+   save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) x, (GLfloat) y,

+                                  (GLfloat) z, (GLfloat) w);

+}

+

+

+static void GLAPIENTRY

+save_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name,

+                                const double v[])

+{

+   save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) v[0],

+                                  (GLfloat) v[1], (GLfloat) v[2],

+                                  (GLfloat) v[3]);

+}

+

+#endif /* FEATURE_NV_fragment_program */

+

+

+

+/* GL_EXT_stencil_two_side */

+static void GLAPIENTRY

+save_ActiveStencilFaceEXT(GLenum face)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);

+   if (n) {

+      n[1].e = face;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ActiveStencilFaceEXT(ctx->Exec, (face));

+   }

+}

+

+

+/* GL_EXT_depth_bounds_test */

+static void GLAPIENTRY

+save_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);

+   if (n) {

+      n[1].f = (GLfloat) zmin;

+      n[2].f = (GLfloat) zmax;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));

+   }

+}

+

+

+

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+

+static void GLAPIENTRY

+save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,

+                      const GLvoid * string)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 4);

+   if (n) {

+      GLubyte *programCopy = (GLubyte *) malloc(len);

+      if (!programCopy) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");

+         return;

+      }

+      memcpy(programCopy, string, len);

+      n[1].e = target;

+      n[2].e = format;

+      n[3].i = len;

+      n[4].data = programCopy;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));

+   }

+}

+

+#endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */

+

+

+#if FEATURE_queryobj

+

+static void GLAPIENTRY

+save_BeginQueryARB(GLenum target, GLuint id)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_ARB, 2);

+   if (n) {

+      n[1].e = target;

+      n[2].ui = id;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BeginQueryARB(ctx->Exec, (target, id));

+   }

+}

+

+

+static void GLAPIENTRY

+save_EndQueryARB(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_END_QUERY_ARB, 1);

+   if (n) {

+      n[1].e = target;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EndQueryARB(ctx->Exec, (target));

+   }

+}

+

+#endif /* FEATURE_queryobj */

+

+

+static void GLAPIENTRY

+save_DrawBuffersARB(GLsizei count, const GLenum * buffers)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);

+   if (n) {

+      GLint i;

+      n[1].i = count;

+      if (count > MAX_DRAW_BUFFERS)

+         count = MAX_DRAW_BUFFERS;

+      for (i = 0; i < count; i++) {

+         n[2 + i].e = buffers[i];

+      }

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_DrawBuffersARB(ctx->Exec, (count, buffers));

+   }

+}

+

+static void GLAPIENTRY

+save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   n = alloc_instruction(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5);

+   if (n) {

+      n[1].ui = pname;

+      n[2].f = param[0];

+      n[3].f = param[1];

+      n[4].f = param[2];

+      n[5].f = param[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param));

+   }

+}

+

+static void GLAPIENTRY

+save_TexBumpParameterivATI(GLenum pname, const GLint *param)

+{

+   GLfloat p[4];

+   p[0] = INT_TO_FLOAT(param[0]);

+   p[1] = INT_TO_FLOAT(param[1]);

+   p[2] = INT_TO_FLOAT(param[2]);

+   p[3] = INT_TO_FLOAT(param[3]);

+   save_TexBumpParameterfvATI(pname, p);

+}

+

+#if FEATURE_ATI_fragment_shader

+static void GLAPIENTRY

+save_BindFragmentShaderATI(GLuint id)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   n = alloc_instruction(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);

+   if (n) {

+      n[1].ui = id;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BindFragmentShaderATI(ctx->Exec, (id));

+   }

+}

+

+static void GLAPIENTRY

+save_SetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+

+   n = alloc_instruction(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);

+   if (n) {

+      n[1].ui = dst;

+      n[2].f = value[0];

+      n[3].f = value[1];

+      n[4].f = value[2];

+      n[5].f = value[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));

+   }

+}

+#endif

+

+static void

+save_Attr1fNV(GLenum attr, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_1F_NV, 2);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 1;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));

+   }

+}

+

+static void

+save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_2F_NV, 3);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 2;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));

+   }

+}

+

+static void

+save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_3F_NV, 4);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 3;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));

+   }

+}

+

+static void

+save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_4F_NV, 5);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+      n[5].f = w;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 4;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));

+   }

+}

+

+

+static void

+save_Attr1fARB(GLenum attr, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_1F_ARB, 2);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 1;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));

+   }

+}

+

+static void

+save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_2F_ARB, 3);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 2;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));

+   }

+}

+

+static void

+save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_3F_ARB, 4);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 3;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));

+   }

+}

+

+static void

+save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_ATTR_4F_ARB, 5);

+   if (n) {

+      n[1].e = attr;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+      n[5].f = w;

+   }

+

+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);

+   ctx->ListState.ActiveAttribSize[attr] = 4;

+   ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);

+

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));

+   }

+}

+

+

+static void GLAPIENTRY

+save_EvalCoord1f(GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVAL_C1, 1);

+   if (n) {

+      n[1].f = x;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalCoord1f(ctx->Exec, (x));

+   }

+}

+

+static void GLAPIENTRY

+save_EvalCoord1fv(const GLfloat * v)

+{

+   save_EvalCoord1f(v[0]);

+}

+

+static void GLAPIENTRY

+save_EvalCoord2f(GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVAL_C2, 2);

+   if (n) {

+      n[1].f = x;

+      n[2].f = y;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalCoord2f(ctx->Exec, (x, y));

+   }

+}

+

+static void GLAPIENTRY

+save_EvalCoord2fv(const GLfloat * v)

+{

+   save_EvalCoord2f(v[0], v[1]);

+}

+

+

+static void GLAPIENTRY

+save_EvalPoint1(GLint x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVAL_P1, 1);

+   if (n) {

+      n[1].i = x;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalPoint1(ctx->Exec, (x));

+   }

+}

+

+static void GLAPIENTRY

+save_EvalPoint2(GLint x, GLint y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_EVAL_P2, 2);

+   if (n) {

+      n[1].i = x;

+      n[2].i = y;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_EvalPoint2(ctx->Exec, (x, y));

+   }

+}

+

+static void GLAPIENTRY

+save_Indexf(GLfloat x)

+{

+   save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);

+}

+

+static void GLAPIENTRY

+save_Indexfv(const GLfloat * v)

+{

+   save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);

+}

+

+static void GLAPIENTRY

+save_EdgeFlag(GLboolean x)

+{

+   save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? (GLfloat)1.0 : (GLfloat)0.0);

+}

+

+static INLINE GLboolean compare4fv( const GLfloat *a,

+                                    const GLfloat *b,

+                                    GLuint count )

+{

+   return memcmp( a, b, count * sizeof(GLfloat) ) == 0;

+}

+                              

+

+static void GLAPIENTRY

+save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   int args, i;

+   GLuint bitmask;

+

+   switch (face) {

+   case GL_BACK:

+   case GL_FRONT:

+   case GL_FRONT_AND_BACK:

+      break;

+   default:

+      _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(face)");

+      return;

+   }

+

+   switch (pname) {

+   case GL_EMISSION:

+   case GL_AMBIENT:

+   case GL_DIFFUSE:

+   case GL_SPECULAR:

+   case GL_AMBIENT_AND_DIFFUSE:

+      args = 4;

+      break;

+   case GL_SHININESS:

+      args = 1;

+      break;

+   case GL_COLOR_INDEXES:

+      args = 3;

+      break;

+   default:

+      _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(pname)");

+      return;

+   }

+   

+   if (ctx->ExecuteFlag) {

+      CALL_Materialfv(ctx->Exec, (face, pname, param));

+   }

+

+   bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);

+

+   /* Try to eliminate redundant statechanges.  Because it is legal to

+    * call glMaterial even inside begin/end calls, don't need to worry

+    * about ctx->Driver.CurrentSavePrimitive here.

+    */

+   for (i = 0; i < MAT_ATTRIB_MAX; i++) {

+      if (bitmask & (1 << i)) {

+         if (ctx->ListState.ActiveMaterialSize[i] == args &&

+             compare4fv(ctx->ListState.CurrentMaterial[i], param, args)) {

+            bitmask &= ~(1 << i);

+         }

+         else {

+            ctx->ListState.ActiveMaterialSize[i] = args;

+            COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);

+         }

+      }

+   }

+

+   /* If this call has effect, return early:

+    */

+   if (bitmask == 0)

+      return;

+

+   SAVE_FLUSH_VERTICES(ctx);

+

+   n = alloc_instruction(ctx, OPCODE_MATERIAL, 6);

+   if (n) {

+      n[1].e = face;

+      n[2].e = pname;

+      for (i = 0; i < args; i++)

+         n[3 + i].f = param[i];

+   }

+}

+

+static void GLAPIENTRY

+save_Begin(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   GLboolean error = GL_FALSE;

+

+   if ( /*mode < GL_POINTS || */ mode > GL_POLYGON) {

+      _mesa_compile_error(ctx, GL_INVALID_ENUM, "Begin (mode)");

+      error = GL_TRUE;

+   }

+   else if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN) {

+      /* Typically the first begin.  This may raise an error on

+       * playback, depending on whether CallList is issued from inside

+       * a begin/end or not.

+       */

+      ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;

+   }

+   else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END) {

+      ctx->Driver.CurrentSavePrimitive = mode;

+   }

+   else {

+      _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive begin");

+      error = GL_TRUE;

+   }

+

+   if (!error) {

+      /* Give the driver an opportunity to hook in an optimized

+       * display list compiler.

+       */

+      if (ctx->Driver.NotifySaveBegin(ctx, mode))

+         return;

+

+      SAVE_FLUSH_VERTICES(ctx);

+      n = alloc_instruction(ctx, OPCODE_BEGIN, 1);

+      if (n) {

+         n[1].e = mode;

+      }

+   }

+

+   if (ctx->ExecuteFlag) {

+      CALL_Begin(ctx->Exec, (mode));

+   }

+}

+

+static void GLAPIENTRY

+save_End(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   SAVE_FLUSH_VERTICES(ctx);

+   (void) alloc_instruction(ctx, OPCODE_END, 0);

+   ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;

+   if (ctx->ExecuteFlag) {

+      CALL_End(ctx->Exec, ());

+   }

+}

+

+static void GLAPIENTRY

+save_Rectf(GLfloat a, GLfloat b, GLfloat c, GLfloat d)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   SAVE_FLUSH_VERTICES(ctx);

+   n = alloc_instruction(ctx, OPCODE_RECTF, 4);

+   if (n) {

+      n[1].f = a;

+      n[2].f = b;

+      n[3].f = c;

+      n[4].f = d;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Rectf(ctx->Exec, (a, b, c, d));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Vertex2f(GLfloat x, GLfloat y)

+{

+   save_Attr2fNV(VERT_ATTRIB_POS, x, y);

+}

+

+static void GLAPIENTRY

+save_Vertex2fv(const GLfloat * v)

+{

+   save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);

+}

+

+static void GLAPIENTRY

+save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);

+}

+

+static void GLAPIENTRY

+save_Vertex3fv(const GLfloat * v)

+{

+   save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);

+}

+

+static void GLAPIENTRY

+save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_Vertex4fv(const GLfloat * v)

+{

+   save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);

+}

+

+static void GLAPIENTRY

+save_TexCoord1f(GLfloat x)

+{

+   save_Attr1fNV(VERT_ATTRIB_TEX0, x);

+}

+

+static void GLAPIENTRY

+save_TexCoord1fv(const GLfloat * v)

+{

+   save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);

+}

+

+static void GLAPIENTRY

+save_TexCoord2f(GLfloat x, GLfloat y)

+{

+   save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);

+}

+

+static void GLAPIENTRY

+save_TexCoord2fv(const GLfloat * v)

+{

+   save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);

+}

+

+static void GLAPIENTRY

+save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);

+}

+

+static void GLAPIENTRY

+save_TexCoord3fv(const GLfloat * v)

+{

+   save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);

+}

+

+static void GLAPIENTRY

+save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_TexCoord4fv(const GLfloat * v)

+{

+   save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);

+}

+

+static void GLAPIENTRY

+save_Normal3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);

+}

+

+static void GLAPIENTRY

+save_Normal3fv(const GLfloat * v)

+{

+   save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);

+}

+

+static void GLAPIENTRY

+save_FogCoordfEXT(GLfloat x)

+{

+   save_Attr1fNV(VERT_ATTRIB_FOG, x);

+}

+

+static void GLAPIENTRY

+save_FogCoordfvEXT(const GLfloat * v)

+{

+   save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);

+}

+

+static void GLAPIENTRY

+save_Color3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);

+}

+

+static void GLAPIENTRY

+save_Color3fv(const GLfloat * v)

+{

+   save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);

+}

+

+static void GLAPIENTRY

+save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_Color4fv(const GLfloat * v)

+{

+   save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);

+}

+

+static void GLAPIENTRY

+save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)

+{

+   save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);

+}

+

+static void GLAPIENTRY

+save_SecondaryColor3fvEXT(const GLfloat * v)

+{

+   save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);

+}

+

+

+/* Just call the respective ATTR for texcoord

+ */

+static void GLAPIENTRY

+save_MultiTexCoord1f(GLenum target, GLfloat x)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr1fNV(attr, x);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord1fv(GLenum target, const GLfloat * v)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr1fNV(attr, v[0]);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr2fNV(attr, x, y);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord2fv(GLenum target, const GLfloat * v)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr2fNV(attr, v[0], v[1]);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr3fNV(attr, x, y, z);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord3fv(GLenum target, const GLfloat * v)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr3fNV(attr, v[0], v[1], v[2]);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,

+                     GLfloat z, GLfloat w)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr4fNV(attr, x, y, z, w);

+}

+

+static void GLAPIENTRY

+save_MultiTexCoord4fv(GLenum target, const GLfloat * v)

+{

+   GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;

+   save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);

+}

+

+

+/**

+ * Record a GL_INVALID_VALUE error when a invalid vertex attribute

+ * index is found.

+ */

+static void

+index_error(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");

+}

+

+

+/* First level for NV_vertex_program:

+ *

+ * Check for errors at compile time?.

+ */

+static void GLAPIENTRY

+save_VertexAttrib1fNV(GLuint index, GLfloat x)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr1fNV(index, x);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr1fNV(index, v[0]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr2fNV(index, x, y);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr2fNV(index, v[0], v[1]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr3fNV(index, x, y, z);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr3fNV(index, v[0], v[1], v[2]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,

+                      GLfloat z, GLfloat w)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr4fNV(index, x, y, z, w);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)

+      save_Attr4fNV(index, v[0], v[1], v[2], v[3]);

+   else

+      index_error();

+}

+

+

+

+

+static void GLAPIENTRY

+save_VertexAttrib1fARB(GLuint index, GLfloat x)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr1fARB(index, x);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr1fARB(index, v[0]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr2fARB(index, x, y);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr2fARB(index, v[0], v[1]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr3fARB(index, x, y, z);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr3fARB(index, v[0], v[1], v[2]);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,

+                       GLfloat w)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr4fARB(index, x, y, z, w);

+   else

+      index_error();

+}

+

+static void GLAPIENTRY

+save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)

+{

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      save_Attr4fARB(index, v[0], v[1], v[2], v[3]);

+   else

+      index_error();

+}

+

+

+/* GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */

+

+static void GLAPIENTRY

+exec_BindAttribLocationARB(GLuint program, GLuint index, const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_BindAttribLocationARB(ctx->Exec, (program, index, name));

+}

+

+static GLint GLAPIENTRY

+exec_GetAttribLocationARB(GLuint program, const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_GetAttribLocationARB(ctx->Exec, (program, name));

+}

+

+static GLint GLAPIENTRY

+exec_GetUniformLocationARB(GLuint program, const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_GetUniformLocationARB(ctx->Exec, (program, name));

+}

+/* XXX more shader functions needed here */

+

+

+#if FEATURE_EXT_framebuffer_blit

+static void GLAPIENTRY

+save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                        GLbitfield mask, GLenum filter)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);

+   if (n) {

+      n[1].i = srcX0;

+      n[2].i = srcY0;

+      n[3].i = srcX1;

+      n[4].i = srcY1;

+      n[5].i = dstX0;

+      n[6].i = dstY0;

+      n[7].i = dstX1;

+      n[8].i = dstY1;

+      n[9].i = mask;

+      n[10].e = filter;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BlitFramebufferEXT(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,

+                                          dstX0, dstY0, dstX1, dstY1,

+                                          mask, filter));

+   }

+}

+#endif

+

+

+/** GL_EXT_provoking_vertex */

+static void GLAPIENTRY

+save_ProvokingVertexEXT(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_ProvokingVertexEXT(ctx->Exec, (mode));*/

+      _mesa_ProvokingVertexEXT(mode);

+   }

+}

+

+

+/** GL_EXT_transform_feedback */

+static void GLAPIENTRY

+save_BeginTransformFeedback(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);

+   if (n) {

+      n[1].e = mode;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_BeginTransformFeedbackEXT(ctx->Exec, (mode));

+   }

+}

+

+

+/** GL_EXT_transform_feedback */

+static void GLAPIENTRY

+save_EndTransformFeedback(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);

+   if (ctx->ExecuteFlag) {

+      CALL_EndTransformFeedbackEXT(ctx->Exec, ());

+   }

+}

+

+

+/* aka UseProgram() */

+static void GLAPIENTRY

+save_UseProgramObjectARB(GLhandleARB program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);

+   if (n) {

+      n[1].ui = program;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UseProgramObjectARB(ctx->Exec, (program));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Uniform1fARB(GLint location, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);

+   if (n) {

+      n[1].i = location;

+      n[2].f = x;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform1fARB(ctx->Exec, (location, x));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].f = x;

+      n[3].f = y;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform2fARB(ctx->Exec, (location, x, y));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform3fARB(ctx->Exec, (location, x, y, z));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);

+   if (n) {

+      n[1].i = location;

+      n[2].f = x;

+      n[3].f = y;

+      n[4].f = z;

+      n[5].f = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform4fARB(ctx->Exec, (location, x, y, z, w));

+   }

+}

+

+

+/** Return copy of memory */

+static void *

+memdup(const void *src, GLsizei bytes)

+{

+   void *b = bytes >= 0 ? malloc(bytes) : NULL;

+   if (b)

+      memcpy(b, src, bytes);

+   return b;

+}

+

+

+static void GLAPIENTRY

+save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 1 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform1fvARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 2 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform2fvARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 3 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform3fvARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform4fvARB(ctx->Exec, (location, count, v));

+   }

+}

+

+

+static void GLAPIENTRY

+save_Uniform1iARB(GLint location, GLint x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform1iARB(ctx->Exec, (location, x));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform2iARB(GLint location, GLint x, GLint y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform2iARB(ctx->Exec, (location, x, y));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+      n[4].i = z;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform3iARB(ctx->Exec, (location, x, y, z));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+      n[4].i = z;

+      n[5].i = w;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform4iARB(ctx->Exec, (location, x, y, z, w));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 1 * sizeof(GLint));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform1ivARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 2 * sizeof(GLint));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform2ivARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 3 * sizeof(GLint));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform3ivARB(ctx->Exec, (location, count, v));

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 4 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_Uniform4ivARB(ctx->Exec, (location, count, v));

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_Uniform1ui(GLint location, GLuint x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform1ui(ctx->Exec, (location, x));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform2ui(GLint location, GLuint x, GLuint y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform2ui(ctx->Exec, (location, x, y));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+      n[4].i = z;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform3ui(ctx->Exec, (location, x, y, z));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);

+   if (n) {

+      n[1].i = location;

+      n[2].i = x;

+      n[3].i = y;

+      n[4].i = z;

+      n[5].i = w;

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));*/

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 1 * sizeof(*v));

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform1uiv(ctx->Exec, (location, count, v));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 2 * sizeof(*v));

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform2uiv(ctx->Exec, (location, count, v));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 3 * sizeof(*v));

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform3uiv(ctx->Exec, (location, count, v));*/

+   }

+}

+

+static void GLAPIENTRY

+save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 3);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].data = memdup(v, count * 4 * sizeof(*v));

+   }

+   if (ctx->ExecuteFlag) {

+      /*CALL_Uniform4uiv(ctx->Exec, (location, count, v));*/

+   }

+}

+

+

+

+static void GLAPIENTRY

+save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 2 * 2 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix2fvARB(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 3 * 3 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix3fvARB(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 4 * 4 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix4fvARB(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+

+static void GLAPIENTRY

+save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 2 * 3 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 3 * 2 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+

+static void GLAPIENTRY

+save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 2 * 4 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 4 * 2 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+

+static void GLAPIENTRY

+save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 3 * 4 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,

+                        const GLfloat *m)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 4);

+   if (n) {

+      n[1].i = location;

+      n[2].i = count;

+      n[3].b = transpose;

+      n[4].data = memdup(m, count * 4 * 3 * sizeof(GLfloat));

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));

+   }

+}

+

+static void GLAPIENTRY

+save_UseShaderProgramEXT(GLenum type, GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_USE_SHADER_PROGRAM_EXT, 2);

+   if (n) {

+      n[1].ui = type;

+      n[2].ui = program;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_UseShaderProgramEXT(ctx->Exec, (type, program));

+   }

+}

+

+static void GLAPIENTRY

+save_ActiveProgramEXT(GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_ACTIVE_PROGRAM_EXT, 1);

+   if (n) {

+      n[1].ui = program;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ActiveProgramEXT(ctx->Exec, (program));

+   }

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+save_ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_I, 4);

+   if (n) {

+      n[1].i = red;

+      n[2].i = green;

+      n[3].i = blue;

+      n[4].i = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearColorIiEXT(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+save_ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_UI, 4);

+   if (n) {

+      n[1].ui = red;

+      n[2].ui = green;

+      n[3].ui = blue;

+      n[4].ui = alpha;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_ClearColorIuiEXT(ctx->Exec, (red, green, blue, alpha));

+   }

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+save_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_I, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].i = params[0];

+      n[4].i = params[1];

+      n[5].i = params[2];

+      n[6].i = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexParameterIivEXT(ctx->Exec, (target, pname, params));

+   }

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+save_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_UI, 6);

+   if (n) {

+      n[1].e = target;

+      n[2].e = pname;

+      n[3].ui = params[0];

+      n[4].ui = params[1];

+      n[5].ui = params[2];

+      n[6].ui = params[3];

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_TexParameterIuivEXT(ctx->Exec, (target, pname, params));

+   }

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+exec_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexParameterIivEXT(ctx->Exec, (target, pname, params));

+}

+

+/** GL_EXT_texture_integer */

+static void GLAPIENTRY

+exec_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexParameterIuivEXT(ctx->Exec, (target, pname, params));

+}

+

+

+/* GL_ARB_instanced_arrays */

+static void

+save_VertexAttribDivisor(GLuint index, GLuint divisor)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   Node *n;

+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);

+   n = alloc_instruction(ctx, OPCODE_VERTEX_ATTRIB_DIVISOR, 2);

+   if (n) {

+      n[1].ui = index;

+      n[2].ui = divisor;

+   }

+   if (ctx->ExecuteFlag) {

+      CALL_VertexAttribDivisorARB(ctx->Exec, (index, divisor));

+   }

+}

+

+

+

+/**

+ * Save an error-generating command into display list.

+ *

+ * KW: Will appear in the list before the vertex buffer containing the

+ * command that provoked the error.  I don't see this as a problem.

+ */

+static void

+save_error(struct gl_context *ctx, GLenum error, const char *s)

+{

+   Node *n;

+   n = alloc_instruction(ctx, OPCODE_ERROR, 2);

+   if (n) {

+      n[1].e = error;

+      n[2].data = (void *) s;

+   }

+}

+

+

+/**

+ * Compile an error into current display list.

+ */

+void

+_mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s)

+{

+   if (ctx->CompileFlag)

+      save_error(ctx, error, s);

+   if (ctx->ExecuteFlag)

+      _mesa_error(ctx, error, "%s", s);

+}

+

+

+/**

+ * Test if ID names a display list.

+ */

+static GLboolean

+islist(struct gl_context *ctx, GLuint list)

+{

+   if (list > 0 && lookup_list(ctx, list)) {

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+

+/**********************************************************************/

+/*                     Display list execution                         */

+/**********************************************************************/

+

+

+/*

+ * Execute a display list.  Note that the ListBase offset must have already

+ * been added before calling this function.  I.e. the list argument is

+ * the absolute list number, not relative to ListBase.

+ * \param list - display list number

+ */

+static void

+execute_list(struct gl_context *ctx, GLuint list)

+{

+   struct gl_display_list *dlist;

+   Node *n;

+   GLboolean done;

+

+   if (list == 0 || !islist(ctx, list))

+      return;

+

+   if (ctx->ListState.CallDepth == MAX_LIST_NESTING) {

+      /* raise an error? */

+      return;

+   }

+

+   dlist = lookup_list(ctx, list);

+   if (!dlist)

+      return;

+

+   ctx->ListState.CallDepth++;

+

+   if (ctx->Driver.BeginCallList)

+      ctx->Driver.BeginCallList(ctx, dlist);

+

+   n = dlist->Head;

+

+   done = GL_FALSE;

+   while (!done) {

+      const OpCode opcode = n[0].opcode;

+

+      if (is_ext_opcode(opcode)) {

+         n += ext_opcode_execute(ctx, n);

+      }

+      else {

+         switch (opcode) {

+         case OPCODE_ERROR:

+            _mesa_error(ctx, n[1].e, "%s", (const char *) n[2].data);

+            break;

+         case OPCODE_ACCUM:

+            CALL_Accum(ctx->Exec, (n[1].e, n[2].f));

+            break;

+         case OPCODE_ALPHA_FUNC:

+            CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));

+            break;

+         case OPCODE_BIND_TEXTURE:

+            CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));

+            break;

+         case OPCODE_BITMAP:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,

+                                       n[3].f, n[4].f, n[5].f, n[6].f,

+                                       (const GLubyte *) n[7].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_BLEND_COLOR:

+            CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_BLEND_EQUATION:

+            CALL_BlendEquation(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_BLEND_EQUATION_SEPARATE:

+            CALL_BlendEquationSeparateEXT(ctx->Exec, (n[1].e, n[2].e));

+            break;

+         case OPCODE_BLEND_FUNC_SEPARATE:

+            CALL_BlendFuncSeparateEXT(ctx->Exec,

+                                      (n[1].e, n[2].e, n[3].e, n[4].e));

+            break;

+

+         case OPCODE_BLEND_FUNC_I:

+            /* GL_ARB_draw_buffers_blend */

+            CALL_BlendFunciARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e));

+            break;

+         case OPCODE_BLEND_FUNC_SEPARATE_I:

+            /* GL_ARB_draw_buffers_blend */

+            CALL_BlendFuncSeparateiARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e,

+                                                   n[4].e, n[5].e));

+            break;

+         case OPCODE_BLEND_EQUATION_I:

+            /* GL_ARB_draw_buffers_blend */

+            CALL_BlendEquationiARB(ctx->Exec, (n[1].ui, n[2].e));

+            break;

+         case OPCODE_BLEND_EQUATION_SEPARATE_I:

+            /* GL_ARB_draw_buffers_blend */

+            CALL_BlendEquationSeparateiARB(ctx->Exec,

+                                           (n[1].ui, n[2].e, n[3].e));

+            break;

+

+         case OPCODE_CALL_LIST:

+            /* Generated by glCallList(), don't add ListBase */

+            if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {

+               execute_list(ctx, n[1].ui);

+            }

+            break;

+         case OPCODE_CALL_LIST_OFFSET:

+            /* Generated by glCallLists() so we must add ListBase */

+            if (n[2].b) {

+               /* user specified a bad data type at compile time */

+               _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");

+            }

+            else if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {

+               GLuint list = (GLuint) (ctx->List.ListBase + n[1].i);

+               execute_list(ctx, list);

+            }

+            break;

+         case OPCODE_CLEAR:

+            CALL_Clear(ctx->Exec, (n[1].bf));

+            break;

+         case OPCODE_CLEAR_BUFFER_IV:

+            {

+               GLint value[4];

+               value[0] = n[3].i;

+               value[1] = n[4].i;

+               value[2] = n[5].i;

+               value[3] = n[6].i;

+               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/

+            }

+            break;

+         case OPCODE_CLEAR_BUFFER_UIV:

+            {

+               GLuint value[4];

+               value[0] = n[3].ui;

+               value[1] = n[4].ui;

+               value[2] = n[5].ui;

+               value[3] = n[6].ui;

+               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/

+            }

+            break;

+         case OPCODE_CLEAR_BUFFER_FV:

+            {

+               GLfloat value[4];

+               value[0] = n[3].f;

+               value[1] = n[4].f;

+               value[2] = n[5].f;

+               value[3] = n[6].f;

+               /*CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));*/

+            }

+            break;

+         case OPCODE_CLEAR_BUFFER_FI:

+            /*CALL_ClearBufferfi(ctx->Exec, (n[1].e, n[2].i, n[3].f, n[4].i));*/

+            break;

+         case OPCODE_CLEAR_COLOR:

+            CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_CLEAR_ACCUM:

+            CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_CLEAR_DEPTH:

+            CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));

+            break;

+         case OPCODE_CLEAR_INDEX:

+            CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));

+            break;

+         case OPCODE_CLEAR_STENCIL:

+            CALL_ClearStencil(ctx->Exec, (n[1].i));

+            break;

+         case OPCODE_CLIP_PLANE:

+            {

+               GLdouble eq[4];

+               eq[0] = n[2].f;

+               eq[1] = n[3].f;

+               eq[2] = n[4].f;

+               eq[3] = n[5].f;

+               CALL_ClipPlane(ctx->Exec, (n[1].e, eq));

+            }

+            break;

+         case OPCODE_COLOR_MASK:

+            CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));

+            break;

+         case OPCODE_COLOR_MASK_INDEXED:

+            CALL_ColorMaskIndexedEXT(ctx->Exec, (n[1].ui, n[2].b, n[3].b,

+                                                 n[4].b, n[5].b));

+            break;

+         case OPCODE_COLOR_MATERIAL:

+            CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));

+            break;

+         case OPCODE_COLOR_TABLE:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_ColorTable(ctx->Exec, (n[1].e, n[2].e, n[3].i, n[4].e,

+                                           n[5].e, n[6].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_COLOR_TABLE_PARAMETER_FV:

+            {

+               GLfloat params[4];

+               params[0] = n[3].f;

+               params[1] = n[4].f;

+               params[2] = n[5].f;

+               params[3] = n[6].f;

+               CALL_ColorTableParameterfv(ctx->Exec,

+                                          (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_COLOR_TABLE_PARAMETER_IV:

+            {

+               GLint params[4];

+               params[0] = n[3].i;

+               params[1] = n[4].i;

+               params[2] = n[5].i;

+               params[3] = n[6].i;

+               CALL_ColorTableParameteriv(ctx->Exec,

+                                          (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_COLOR_SUB_TABLE:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_ColorSubTable(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                              n[4].e, n[5].e, n[6].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_CONVOLUTION_FILTER_1D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_ConvolutionFilter1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                                    n[4].e, n[5].e,

+                                                    n[6].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_CONVOLUTION_FILTER_2D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_ConvolutionFilter2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                                    n[4].i, n[5].e, n[6].e,

+                                                    n[7].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_CONVOLUTION_PARAMETER_I:

+            CALL_ConvolutionParameteri(ctx->Exec, (n[1].e, n[2].e, n[3].i));

+            break;

+         case OPCODE_CONVOLUTION_PARAMETER_IV:

+            {

+               GLint params[4];

+               params[0] = n[3].i;

+               params[1] = n[4].i;

+               params[2] = n[5].i;

+               params[3] = n[6].i;

+               CALL_ConvolutionParameteriv(ctx->Exec,

+                                           (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_CONVOLUTION_PARAMETER_F:

+            CALL_ConvolutionParameterf(ctx->Exec, (n[1].e, n[2].e, n[3].f));

+            break;

+         case OPCODE_CONVOLUTION_PARAMETER_FV:

+            {

+               GLfloat params[4];

+               params[0] = n[3].f;

+               params[1] = n[4].f;

+               params[2] = n[5].f;

+               params[3] = n[6].f;

+               CALL_ConvolutionParameterfv(ctx->Exec,

+                                           (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_COPY_COLOR_SUB_TABLE:

+            CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,

+                                               n[3].i, n[4].i, n[5].i));

+            break;

+         case OPCODE_COPY_COLOR_TABLE:

+            CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,

+                                               n[3].i, n[4].i, n[5].i));

+            break;

+         case OPCODE_COPY_PIXELS:

+            CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,

+                                        (GLsizei) n[3].i, (GLsizei) n[4].i,

+                                        n[5].e));

+            break;

+         case OPCODE_COPY_TEX_IMAGE1D:

+            CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,

+                                            n[5].i, n[6].i, n[7].i));

+            break;

+         case OPCODE_COPY_TEX_IMAGE2D:

+            CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,

+                                            n[5].i, n[6].i, n[7].i, n[8].i));

+            break;

+         case OPCODE_COPY_TEX_SUB_IMAGE1D:

+            CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                               n[4].i, n[5].i, n[6].i));

+            break;

+         case OPCODE_COPY_TEX_SUB_IMAGE2D:

+            CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                               n[4].i, n[5].i, n[6].i, n[7].i,

+                                               n[8].i));

+            break;

+         case OPCODE_COPY_TEX_SUB_IMAGE3D:

+            CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                               n[4].i, n[5].i, n[6].i, n[7].i,

+                                               n[8].i, n[9].i));

+            break;

+         case OPCODE_CULL_FACE:

+            CALL_CullFace(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_DEPTH_FUNC:

+            CALL_DepthFunc(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_DEPTH_MASK:

+            CALL_DepthMask(ctx->Exec, (n[1].b));

+            break;

+         case OPCODE_DEPTH_RANGE:

+            CALL_DepthRange(ctx->Exec,

+                            ((GLclampd) n[1].f, (GLclampd) n[2].f));

+            break;

+         case OPCODE_DISABLE:

+            CALL_Disable(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_DISABLE_INDEXED:

+            CALL_DisableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));

+            break;

+         case OPCODE_DRAW_BUFFER:

+            CALL_DrawBuffer(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_DRAW_PIXELS:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,

+                                           n[5].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_ENABLE:

+            CALL_Enable(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_ENABLE_INDEXED:

+            CALL_EnableIndexedEXT(ctx->Exec, (n[1].ui, n[2].e));

+            break;

+         case OPCODE_EVALMESH1:

+            CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));

+            break;

+         case OPCODE_EVALMESH2:

+            CALL_EvalMesh2(ctx->Exec,

+                           (n[1].e, n[2].i, n[3].i, n[4].i, n[5].i));

+            break;

+         case OPCODE_FOG:

+            {

+               GLfloat p[4];

+               p[0] = n[2].f;

+               p[1] = n[3].f;

+               p[2] = n[4].f;

+               p[3] = n[5].f;

+               CALL_Fogfv(ctx->Exec, (n[1].e, p));

+            }

+            break;

+         case OPCODE_FRONT_FACE:

+            CALL_FrontFace(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_FRUSTUM:

+            CALL_Frustum(ctx->Exec,

+                         (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));

+            break;

+         case OPCODE_HINT:

+            CALL_Hint(ctx->Exec, (n[1].e, n[2].e));

+            break;

+         case OPCODE_HISTOGRAM:

+            CALL_Histogram(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].b));

+            break;

+         case OPCODE_INDEX_MASK:

+            CALL_IndexMask(ctx->Exec, (n[1].ui));

+            break;

+         case OPCODE_INIT_NAMES:

+            CALL_InitNames(ctx->Exec, ());

+            break;

+         case OPCODE_LIGHT:

+            {

+               GLfloat p[4];

+               p[0] = n[3].f;

+               p[1] = n[4].f;

+               p[2] = n[5].f;

+               p[3] = n[6].f;

+               CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));

+            }

+            break;

+         case OPCODE_LIGHT_MODEL:

+            {

+               GLfloat p[4];

+               p[0] = n[2].f;

+               p[1] = n[3].f;

+               p[2] = n[4].f;

+               p[3] = n[5].f;

+               CALL_LightModelfv(ctx->Exec, (n[1].e, p));

+            }

+            break;

+         case OPCODE_LINE_STIPPLE:

+            CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));

+            break;

+         case OPCODE_LINE_WIDTH:

+            CALL_LineWidth(ctx->Exec, (n[1].f));

+            break;

+         case OPCODE_LIST_BASE:

+            CALL_ListBase(ctx->Exec, (n[1].ui));

+            break;

+         case OPCODE_LOAD_IDENTITY:

+            CALL_LoadIdentity(ctx->Exec, ());

+            break;

+         case OPCODE_LOAD_MATRIX:

+            if (sizeof(Node) == sizeof(GLfloat)) {

+               CALL_LoadMatrixf(ctx->Exec, (&n[1].f));

+            }

+            else {

+               GLfloat m[16];

+               GLuint i;

+               for (i = 0; i < 16; i++) {

+                  m[i] = n[1 + i].f;

+               }

+               CALL_LoadMatrixf(ctx->Exec, (m));

+            }

+            break;

+         case OPCODE_LOAD_NAME:

+            CALL_LoadName(ctx->Exec, (n[1].ui));

+            break;

+         case OPCODE_LOGIC_OP:

+            CALL_LogicOp(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_MAP1:

+            {

+               GLenum target = n[1].e;

+               GLint ustride = _mesa_evaluator_components(target);

+               GLint uorder = n[5].i;

+               GLfloat u1 = n[2].f;

+               GLfloat u2 = n[3].f;

+               CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,

+                                      (GLfloat *) n[6].data));

+            }

+            break;

+         case OPCODE_MAP2:

+            {

+               GLenum target = n[1].e;

+               GLfloat u1 = n[2].f;

+               GLfloat u2 = n[3].f;

+               GLfloat v1 = n[4].f;

+               GLfloat v2 = n[5].f;

+               GLint ustride = n[6].i;

+               GLint vstride = n[7].i;

+               GLint uorder = n[8].i;

+               GLint vorder = n[9].i;

+               CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,

+                                      v1, v2, vstride, vorder,

+                                      (GLfloat *) n[10].data));

+            }

+            break;

+         case OPCODE_MAPGRID1:

+            CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));

+            break;

+         case OPCODE_MAPGRID2:

+            CALL_MapGrid2f(ctx->Exec,

+                           (n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));

+            break;

+         case OPCODE_MATRIX_MODE:

+            CALL_MatrixMode(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_MIN_MAX:

+            CALL_Minmax(ctx->Exec, (n[1].e, n[2].e, n[3].b));

+            break;

+         case OPCODE_MULT_MATRIX:

+            if (sizeof(Node) == sizeof(GLfloat)) {

+               CALL_MultMatrixf(ctx->Exec, (&n[1].f));

+            }

+            else {

+               GLfloat m[16];

+               GLuint i;

+               for (i = 0; i < 16; i++) {

+                  m[i] = n[1 + i].f;

+               }

+               CALL_MultMatrixf(ctx->Exec, (m));

+            }

+            break;

+         case OPCODE_ORTHO:

+            CALL_Ortho(ctx->Exec,

+                       (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));

+            break;

+         case OPCODE_PASSTHROUGH:

+            CALL_PassThrough(ctx->Exec, (n[1].f));

+            break;

+         case OPCODE_PIXEL_MAP:

+            CALL_PixelMapfv(ctx->Exec,

+                            (n[1].e, n[2].i, (GLfloat *) n[3].data));

+            break;

+         case OPCODE_PIXEL_TRANSFER:

+            CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));

+            break;

+         case OPCODE_PIXEL_ZOOM:

+            CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));

+            break;

+         case OPCODE_POINT_SIZE:

+            CALL_PointSize(ctx->Exec, (n[1].f));

+            break;

+         case OPCODE_POINT_PARAMETERS:

+            {

+               GLfloat params[3];

+               params[0] = n[2].f;

+               params[1] = n[3].f;

+               params[2] = n[4].f;

+               CALL_PointParameterfvEXT(ctx->Exec, (n[1].e, params));

+            }

+            break;

+         case OPCODE_POLYGON_MODE:

+            CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));

+            break;

+         case OPCODE_POLYGON_STIPPLE:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_PolygonStipple(ctx->Exec, ((GLubyte *) n[1].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_POLYGON_OFFSET:

+            CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));

+            break;

+         case OPCODE_POP_ATTRIB:

+            CALL_PopAttrib(ctx->Exec, ());

+            break;

+         case OPCODE_POP_MATRIX:

+            CALL_PopMatrix(ctx->Exec, ());

+            break;

+         case OPCODE_POP_NAME:

+            CALL_PopName(ctx->Exec, ());

+            break;

+         case OPCODE_PRIORITIZE_TEXTURE:

+            CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));

+            break;

+         case OPCODE_PUSH_ATTRIB:

+            CALL_PushAttrib(ctx->Exec, (n[1].bf));

+            break;

+         case OPCODE_PUSH_MATRIX:

+            CALL_PushMatrix(ctx->Exec, ());

+            break;

+         case OPCODE_PUSH_NAME:

+            CALL_PushName(ctx->Exec, (n[1].ui));

+            break;

+         case OPCODE_RASTER_POS:

+            CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_READ_BUFFER:

+            CALL_ReadBuffer(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_RESET_HISTOGRAM:

+            CALL_ResetHistogram(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_RESET_MIN_MAX:

+            CALL_ResetMinmax(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_ROTATE:

+            CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_SCALE:

+            CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));

+            break;

+         case OPCODE_SCISSOR:

+            CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));

+            break;

+         case OPCODE_SHADE_MODEL:

+            CALL_ShadeModel(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_PROVOKING_VERTEX:

+            CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_BEGIN_TRANSFORM_FEEDBACK:

+            CALL_BeginTransformFeedbackEXT(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_END_TRANSFORM_FEEDBACK:

+            CALL_EndTransformFeedbackEXT(ctx->Exec, ());

+            break;

+         case OPCODE_STENCIL_FUNC:

+            CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));

+            break;

+         case OPCODE_STENCIL_MASK:

+            CALL_StencilMask(ctx->Exec, (n[1].ui));

+            break;

+         case OPCODE_STENCIL_OP:

+            CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));

+            break;

+         case OPCODE_STENCIL_FUNC_SEPARATE:

+            CALL_StencilFuncSeparate(ctx->Exec,

+                                     (n[1].e, n[2].e, n[3].i, n[4].ui));

+            break;

+         case OPCODE_STENCIL_MASK_SEPARATE:

+            CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));

+            break;

+         case OPCODE_STENCIL_OP_SEPARATE:

+            CALL_StencilOpSeparate(ctx->Exec,

+                                   (n[1].e, n[2].e, n[3].e, n[4].e));

+            break;

+         case OPCODE_TEXENV:

+            {

+               GLfloat params[4];

+               params[0] = n[3].f;

+               params[1] = n[4].f;

+               params[2] = n[5].f;

+               params[3] = n[6].f;

+               CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_TEXGEN:

+            {

+               GLfloat params[4];

+               params[0] = n[3].f;

+               params[1] = n[4].f;

+               params[2] = n[5].f;

+               params[3] = n[6].f;

+               CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_TEXPARAMETER:

+            {

+               GLfloat params[4];

+               params[0] = n[3].f;

+               params[1] = n[4].f;

+               params[2] = n[5].f;

+               params[3] = n[6].f;

+               CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_TEX_IMAGE1D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexImage1D(ctx->Exec, (n[1].e,      /* target */

+                                           n[2].i,      /* level */

+                                           n[3].i,      /* components */

+                                           n[4].i,      /* width */

+                                           n[5].e,      /* border */

+                                           n[6].e,      /* format */

+                                           n[7].e,      /* type */

+                                           n[8].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TEX_IMAGE2D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexImage2D(ctx->Exec, (n[1].e,      /* target */

+                                           n[2].i,      /* level */

+                                           n[3].i,      /* components */

+                                           n[4].i,      /* width */

+                                           n[5].i,      /* height */

+                                           n[6].e,      /* border */

+                                           n[7].e,      /* format */

+                                           n[8].e,      /* type */

+                                           n[9].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TEX_IMAGE3D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexImage3D(ctx->Exec, (n[1].e,      /* target */

+                                           n[2].i,      /* level */

+                                           n[3].i,      /* components */

+                                           n[4].i,      /* width */

+                                           n[5].i,      /* height */

+                                           n[6].i,      /* depth  */

+                                           n[7].e,      /* border */

+                                           n[8].e,      /* format */

+                                           n[9].e,      /* type */

+                                           n[10].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TEX_SUB_IMAGE1D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                              n[4].i, n[5].e,

+                                              n[6].e, n[7].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TEX_SUB_IMAGE2D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                              n[4].i, n[5].e,

+                                              n[6].i, n[7].e, n[8].e,

+                                              n[9].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TEX_SUB_IMAGE3D:

+            {

+               const struct gl_pixelstore_attrib save = ctx->Unpack;

+               ctx->Unpack = ctx->DefaultPacking;

+               CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,

+                                              n[4].i, n[5].i, n[6].i, n[7].i,

+                                              n[8].i, n[9].e, n[10].e,

+                                              n[11].data));

+               ctx->Unpack = save;      /* restore */

+            }

+            break;

+         case OPCODE_TRANSLATE:

+            CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));

+            break;

+         case OPCODE_VIEWPORT:

+            CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,

+                                      (GLsizei) n[3].i, (GLsizei) n[4].i));

+            break;

+         case OPCODE_WINDOW_POS:

+            CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_ACTIVE_TEXTURE:   /* GL_ARB_multitexture */

+            CALL_ActiveTextureARB(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_1D:  /* GL_ARB_texture_compression */

+            CALL_CompressedTexImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,

+                                                     n[4].i, n[5].i, n[6].i,

+                                                     n[7].data));

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_2D:  /* GL_ARB_texture_compression */

+            CALL_CompressedTexImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,

+                                                     n[4].i, n[5].i, n[6].i,

+                                                     n[7].i, n[8].data));

+            break;

+         case OPCODE_COMPRESSED_TEX_IMAGE_3D:  /* GL_ARB_texture_compression */

+            CALL_CompressedTexImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,

+                                                     n[4].i, n[5].i, n[6].i,

+                                                     n[7].i, n[8].i,

+                                                     n[9].data));

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:      /* GL_ARB_texture_compress */

+            CALL_CompressedTexSubImage1DARB(ctx->Exec,

+                                            (n[1].e, n[2].i, n[3].i, n[4].i,

+                                             n[5].e, n[6].i, n[7].data));

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:      /* GL_ARB_texture_compress */

+            CALL_CompressedTexSubImage2DARB(ctx->Exec,

+                                            (n[1].e, n[2].i, n[3].i, n[4].i,

+                                             n[5].i, n[6].i, n[7].e, n[8].i,

+                                             n[9].data));

+            break;

+         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:      /* GL_ARB_texture_compress */

+            CALL_CompressedTexSubImage3DARB(ctx->Exec,

+                                            (n[1].e, n[2].i, n[3].i, n[4].i,

+                                             n[5].i, n[6].i, n[7].i, n[8].i,

+                                             n[9].e, n[10].i, n[11].data));

+            break;

+         case OPCODE_SAMPLE_COVERAGE:  /* GL_ARB_multisample */

+            CALL_SampleCoverageARB(ctx->Exec, (n[1].f, n[2].b));

+            break;

+         case OPCODE_WINDOW_POS_ARB:   /* GL_ARB_window_pos */

+            CALL_WindowPos3fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f));

+            break;

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+         case OPCODE_BIND_PROGRAM_NV:  /* GL_NV_vertex_program */

+            CALL_BindProgramNV(ctx->Exec, (n[1].e, n[2].ui));

+            break;

+#endif

+#if FEATURE_NV_vertex_program

+         case OPCODE_EXECUTE_PROGRAM_NV:

+            {

+               GLfloat v[4];

+               v[0] = n[3].f;

+               v[1] = n[4].f;

+               v[2] = n[5].f;

+               v[3] = n[6].f;

+               CALL_ExecuteProgramNV(ctx->Exec, (n[1].e, n[2].ui, v));

+            }

+            break;

+         case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:

+            CALL_RequestResidentProgramsNV(ctx->Exec, (n[1].ui,

+                                                       (GLuint *) n[2].data));

+            break;

+         case OPCODE_LOAD_PROGRAM_NV:

+            CALL_LoadProgramNV(ctx->Exec, (n[1].e, n[2].ui, n[3].i,

+                                           (const GLubyte *) n[4].data));

+            break;

+         case OPCODE_TRACK_MATRIX_NV:

+            CALL_TrackMatrixNV(ctx->Exec, (n[1].e, n[2].ui, n[3].e, n[4].e));

+            break;

+#endif

+

+#if FEATURE_NV_fragment_program

+         case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:

+            CALL_ProgramLocalParameter4fARB(ctx->Exec,

+                                            (n[1].e, n[2].ui, n[3].f, n[4].f,

+                                             n[5].f, n[6].f));

+            break;

+         case OPCODE_PROGRAM_NAMED_PARAMETER_NV:

+            CALL_ProgramNamedParameter4fNV(ctx->Exec, (n[1].ui, n[2].i,

+                                                       (const GLubyte *) n[3].

+                                                       data, n[4].f, n[5].f,

+                                                       n[6].f, n[7].f));

+            break;

+#endif

+

+         case OPCODE_ACTIVE_STENCIL_FACE_EXT:

+            CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_DEPTH_BOUNDS_EXT:

+            CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));

+            break;

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+         case OPCODE_PROGRAM_STRING_ARB:

+            CALL_ProgramStringARB(ctx->Exec,

+                                  (n[1].e, n[2].e, n[3].i, n[4].data));

+            break;

+#endif

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program

+         case OPCODE_PROGRAM_ENV_PARAMETER_ARB:

+            CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,

+                                                      n[4].f, n[5].f,

+                                                      n[6].f));

+            break;

+#endif

+#if FEATURE_queryobj

+         case OPCODE_BEGIN_QUERY_ARB:

+            CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));

+            break;

+         case OPCODE_END_QUERY_ARB:

+            CALL_EndQueryARB(ctx->Exec, (n[1].e));

+            break;

+#endif

+         case OPCODE_DRAW_BUFFERS_ARB:

+            {

+               GLenum buffers[MAX_DRAW_BUFFERS];

+               GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);

+               for (i = 0; i < count; i++)

+                  buffers[i] = n[2 + i].e;

+               CALL_DrawBuffersARB(ctx->Exec, (n[1].i, buffers));

+            }

+            break;

+#if FEATURE_EXT_framebuffer_blit

+	 case OPCODE_BLIT_FRAMEBUFFER:

+	    CALL_BlitFramebufferEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,

+                                                n[5].i, n[6].i, n[7].i, n[8].i,

+                                                n[9].i, n[10].e));

+	    break;

+#endif

+

+	 case OPCODE_USE_PROGRAM:

+	    CALL_UseProgramObjectARB(ctx->Exec, (n[1].ui));

+	    break;

+	 case OPCODE_USE_SHADER_PROGRAM_EXT:

+	    CALL_UseShaderProgramEXT(ctx->Exec, (n[1].ui, n[2].ui));

+	    break;

+	 case OPCODE_ACTIVE_PROGRAM_EXT:

+	    CALL_ActiveProgramEXT(ctx->Exec, (n[1].ui));

+	    break;

+	 case OPCODE_UNIFORM_1F:

+	    CALL_Uniform1fARB(ctx->Exec, (n[1].i, n[2].f));

+	    break;

+	 case OPCODE_UNIFORM_2F:

+	    CALL_Uniform2fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f));

+	    break;

+	 case OPCODE_UNIFORM_3F:

+	    CALL_Uniform3fARB(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));

+	    break;

+	 case OPCODE_UNIFORM_4F:

+	    CALL_Uniform4fARB(ctx->Exec,

+                              (n[1].i, n[2].f, n[3].f, n[4].f, n[5].f));

+	    break;

+	 case OPCODE_UNIFORM_1FV:

+	    CALL_Uniform1fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_2FV:

+	    CALL_Uniform2fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_3FV:

+	    CALL_Uniform3fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_4FV:

+	    CALL_Uniform4fvARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_1I:

+	    CALL_Uniform1iARB(ctx->Exec, (n[1].i, n[2].i));

+	    break;

+	 case OPCODE_UNIFORM_2I:

+	    CALL_Uniform2iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));

+	    break;

+	 case OPCODE_UNIFORM_3I:

+	    CALL_Uniform3iARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));

+	    break;

+	 case OPCODE_UNIFORM_4I:

+	    CALL_Uniform4iARB(ctx->Exec,

+                              (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));

+	    break;

+	 case OPCODE_UNIFORM_1IV:

+	    CALL_Uniform1ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_2IV:

+	    CALL_Uniform2ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_3IV:

+	    CALL_Uniform3ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_4IV:

+	    CALL_Uniform4ivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));

+	    break;

+	 case OPCODE_UNIFORM_1UI:

+	    /*CALL_Uniform1uiARB(ctx->Exec, (n[1].i, n[2].i));*/

+	    break;

+	 case OPCODE_UNIFORM_2UI:

+	    /*CALL_Uniform2uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));*/

+	    break;

+	 case OPCODE_UNIFORM_3UI:

+	    /*CALL_Uniform3uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));*/

+	    break;

+	 case OPCODE_UNIFORM_4UI:

+	    /*CALL_Uniform4uiARB(ctx->Exec,

+                              (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));

+            */

+	    break;

+	 case OPCODE_UNIFORM_1UIV:

+	    /*CALL_Uniform1uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/

+	    break;

+	 case OPCODE_UNIFORM_2UIV:

+	    /*CALL_Uniform2uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/

+	    break;

+	 case OPCODE_UNIFORM_3UIV:

+	    /*CALL_Uniform3uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/

+	    break;

+	 case OPCODE_UNIFORM_4UIV:

+	    /*CALL_Uniform4uivARB(ctx->Exec, (n[1].i, n[2].i, n[3].data));*/

+	    break;

+	 case OPCODE_UNIFORM_MATRIX22:

+	    CALL_UniformMatrix2fvARB(ctx->Exec,

+                                     (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX33:

+	    CALL_UniformMatrix3fvARB(ctx->Exec,

+                                     (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX44:

+	    CALL_UniformMatrix4fvARB(ctx->Exec,

+                                     (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX23:

+	    CALL_UniformMatrix2x3fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX32:

+	    CALL_UniformMatrix3x2fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX24:

+	    CALL_UniformMatrix2x4fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX42:

+	    CALL_UniformMatrix4x2fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX34:

+	    CALL_UniformMatrix3x4fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+	 case OPCODE_UNIFORM_MATRIX43:

+	    CALL_UniformMatrix4x3fv(ctx->Exec,

+                                    (n[1].i, n[2].i, n[3].b, n[4].data));

+	    break;

+

+         case OPCODE_TEX_BUMP_PARAMETER_ATI:

+            {

+               GLfloat values[4];

+               GLuint i, pname = n[1].ui;

+

+               for (i = 0; i < 4; i++)

+                  values[i] = n[1 + i].f;

+               CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values));

+            }

+            break;

+#if FEATURE_ATI_fragment_shader

+         case OPCODE_BIND_FRAGMENT_SHADER_ATI:

+            CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));

+            break;

+         case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:

+            {

+               GLfloat values[4];

+               GLuint i, dst = n[1].ui;

+

+               for (i = 0; i < 4; i++)

+                  values[i] = n[1 + i].f;

+               CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, values));

+            }

+            break;

+#endif

+         case OPCODE_ATTR_1F_NV:

+            CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));

+            break;

+         case OPCODE_ATTR_2F_NV:

+            /* Really shouldn't have to do this - the Node structure

+             * is convenient, but it would be better to store the data

+             * packed appropriately so that it can be sent directly

+             * on.  With x86_64 becoming common, this will start to

+             * matter more.

+             */

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib2fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f));

+            break;

+         case OPCODE_ATTR_3F_NV:

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib3fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,

+                                                 n[4].f));

+            break;

+         case OPCODE_ATTR_4F_NV:

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib4fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,

+                                                 n[4].f, n[5].f));

+            break;

+         case OPCODE_ATTR_1F_ARB:

+            CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));

+            break;

+         case OPCODE_ATTR_2F_ARB:

+            /* Really shouldn't have to do this - the Node structure

+             * is convenient, but it would be better to store the data

+             * packed appropriately so that it can be sent directly

+             * on.  With x86_64 becoming common, this will start to

+             * matter more.

+             */

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib2fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f));

+            break;

+         case OPCODE_ATTR_3F_ARB:

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib3fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,

+                                                  n[4].f));

+            break;

+         case OPCODE_ATTR_4F_ARB:

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));

+            else

+               CALL_VertexAttrib4fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,

+                                                  n[4].f, n[5].f));

+            break;

+         case OPCODE_MATERIAL:

+            if (sizeof(Node) == sizeof(GLfloat))

+               CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));

+            else {

+               GLfloat f[4];

+               f[0] = n[3].f;

+               f[1] = n[4].f;

+               f[2] = n[5].f;

+               f[3] = n[6].f;

+               CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, f));

+            }

+            break;

+         case OPCODE_BEGIN:

+            CALL_Begin(ctx->Exec, (n[1].e));

+            break;

+         case OPCODE_END:

+            CALL_End(ctx->Exec, ());

+            break;

+         case OPCODE_RECTF:

+            CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));

+            break;

+         case OPCODE_EVAL_C1:

+            CALL_EvalCoord1f(ctx->Exec, (n[1].f));

+            break;

+         case OPCODE_EVAL_C2:

+            CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));

+            break;

+         case OPCODE_EVAL_P1:

+            CALL_EvalPoint1(ctx->Exec, (n[1].i));

+            break;

+         case OPCODE_EVAL_P2:

+            CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));

+            break;

+

+         /* GL_EXT_texture_integer */

+         case OPCODE_CLEARCOLOR_I:

+            CALL_ClearColorIiEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));

+            break;

+         case OPCODE_CLEARCOLOR_UI:

+            CALL_ClearColorIuiEXT(ctx->Exec,

+                                  (n[1].ui, n[2].ui, n[3].ui, n[4].ui));

+            break;

+         case OPCODE_TEXPARAMETER_I:

+            {

+               GLint params[4];

+               params[0] = n[3].i;

+               params[1] = n[4].i;

+               params[2] = n[5].i;

+               params[3] = n[6].i;

+               CALL_TexParameterIivEXT(ctx->Exec, (n[1].e, n[2].e, params));

+            }

+            break;

+         case OPCODE_TEXPARAMETER_UI:

+            {

+               GLuint params[4];

+               params[0] = n[3].ui;

+               params[1] = n[4].ui;

+               params[2] = n[5].ui;

+               params[3] = n[6].ui;

+               CALL_TexParameterIuivEXT(ctx->Exec, (n[1].e, n[2].e, params));

+            }

+            break;

+

+         case OPCODE_VERTEX_ATTRIB_DIVISOR:

+            /* GL_ARB_instanced_arrays */

+            CALL_VertexAttribDivisorARB(ctx->Exec, (n[1].ui, n[2].ui));

+            break;

+

+         case OPCODE_CONTINUE:

+            n = (Node *) n[1].next;

+            break;

+         case OPCODE_END_OF_LIST:

+            done = GL_TRUE;

+            break;

+         default:

+            {

+               char msg[1000];

+               _mesa_snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",

+                             (int) opcode);

+               _mesa_problem(ctx, "%s", msg);

+            }

+            done = GL_TRUE;

+         }

+

+         /* increment n to point to next compiled command */

+         if (opcode != OPCODE_CONTINUE) {

+            n += InstSize[opcode];

+         }

+      }

+   }

+

+   if (ctx->Driver.EndCallList)

+      ctx->Driver.EndCallList(ctx);

+

+   ctx->ListState.CallDepth--;

+}

+

+

+

+/**********************************************************************/

+/*                           GL functions                             */

+/**********************************************************************/

+

+/**

+ * Test if a display list number is valid.

+ */

+static GLboolean GLAPIENTRY

+_mesa_IsList(GLuint list)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+   return islist(ctx, list);

+}

+

+

+/**

+ * Delete a sequence of consecutive display lists.

+ */

+static void GLAPIENTRY

+_mesa_DeleteLists(GLuint list, GLsizei range)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint i;

+   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (range < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");

+      return;

+   }

+   for (i = list; i < list + range; i++) {

+      destroy_list(ctx, i);

+   }

+}

+

+

+/**

+ * Return a display list number, n, such that lists n through n+range-1

+ * are free.

+ */

+static GLuint GLAPIENTRY

+_mesa_GenLists(GLsizei range)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint base;

+   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   if (range < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");

+      return 0;

+   }

+   if (range == 0) {

+      return 0;

+   }

+

+   /*

+    * Make this an atomic operation

+    */

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+

+   base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);

+   if (base) {

+      /* reserve the list IDs by with empty/dummy lists */

+      GLint i;

+      for (i = 0; i < range; i++) {

+         _mesa_HashInsert(ctx->Shared->DisplayList, base + i,

+                          make_list(base + i, 1));

+      }

+   }

+

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+

+   return base;

+}

+

+

+/**

+ * Begin a new display list.

+ */

+static void GLAPIENTRY

+_mesa_NewList(GLuint name, GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   FLUSH_CURRENT(ctx, 0);       /* must be called before assert */

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glNewList %u %s\n", name,

+                  _mesa_lookup_enum_by_nr(mode));

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");

+      return;

+   }

+

+   if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");

+      return;

+   }

+

+   if (ctx->ListState.CurrentList) {

+      /* already compiling a display list */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");

+      return;

+   }

+

+   ctx->CompileFlag = GL_TRUE;

+   ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);

+

+   /* Reset acumulated list state:

+    */

+   invalidate_saved_current_state( ctx );

+

+   /* Allocate new display list */

+   ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);

+   ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;

+   ctx->ListState.CurrentPos = 0;

+

+   ctx->Driver.NewList(ctx, name, mode);

+

+   ctx->CurrentDispatch = ctx->Save;

+   _glapi_set_dispatch(ctx->CurrentDispatch);

+}

+

+

+/**

+ * End definition of current display list. 

+ */

+static void GLAPIENTRY

+_mesa_EndList(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   SAVE_FLUSH_VERTICES(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glEndList\n");

+

+   /* Check that a list is under construction */

+   if (!ctx->ListState.CurrentList) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");

+      return;

+   }

+   

+   /* Call before emitting END_OF_LIST, in case the driver wants to

+    * emit opcodes itself.

+    */

+   ctx->Driver.EndList(ctx);

+

+   (void) alloc_instruction(ctx, OPCODE_END_OF_LIST, 0);

+

+   /* Destroy old list, if any */

+   destroy_list(ctx, ctx->ListState.CurrentList->Name);

+

+   /* Install the new list */

+   _mesa_HashInsert(ctx->Shared->DisplayList,

+                    ctx->ListState.CurrentList->Name,

+                    ctx->ListState.CurrentList);

+

+

+   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)

+      mesa_print_display_list(ctx->ListState.CurrentList->Name);

+

+   ctx->ListState.CurrentList = NULL;

+   ctx->ExecuteFlag = GL_TRUE;

+   ctx->CompileFlag = GL_FALSE;

+

+   ctx->CurrentDispatch = ctx->Exec;

+   _glapi_set_dispatch(ctx->CurrentDispatch);

+}

+

+

+void GLAPIENTRY

+_mesa_CallList(GLuint list)

+{

+   GLboolean save_compile_flag;

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_CURRENT(ctx, 0);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCallList %d\n", list);

+

+   if (list == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");

+      return;

+   }

+

+   if (0)

+      mesa_print_display_list( list );

+

+   /* VERY IMPORTANT:  Save the CompileFlag status, turn it off,

+    * execute the display list, and restore the CompileFlag.

+    */

+   save_compile_flag = ctx->CompileFlag;

+   if (save_compile_flag) {

+      ctx->CompileFlag = GL_FALSE;

+   }

+

+   execute_list(ctx, list);

+   ctx->CompileFlag = save_compile_flag;

+

+   /* also restore API function pointers to point to "save" versions */

+   if (save_compile_flag) {

+      ctx->CurrentDispatch = ctx->Save;

+      _glapi_set_dispatch(ctx->CurrentDispatch);

+   }

+}

+

+

+/**

+ * Execute glCallLists:  call multiple display lists.

+ */

+void GLAPIENTRY

+_mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+   GLboolean save_compile_flag;

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCallLists %d\n", n);

+

+   switch (type) {

+   case GL_BYTE:

+   case GL_UNSIGNED_BYTE:

+   case GL_SHORT:

+   case GL_UNSIGNED_SHORT:

+   case GL_INT:

+   case GL_UNSIGNED_INT:

+   case GL_FLOAT:

+   case GL_2_BYTES:

+   case GL_3_BYTES:

+   case GL_4_BYTES:

+      /* OK */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");

+      return;

+   }

+

+   /* Save the CompileFlag status, turn it off, execute display list,

+    * and restore the CompileFlag.

+    */

+   save_compile_flag = ctx->CompileFlag;

+   ctx->CompileFlag = GL_FALSE;

+

+   for (i = 0; i < n; i++) {

+      GLuint list = (GLuint) (ctx->List.ListBase + translate_id(i, type, lists));

+      execute_list(ctx, list);

+   }

+

+   ctx->CompileFlag = save_compile_flag;

+

+   /* also restore API function pointers to point to "save" versions */

+   if (save_compile_flag) {

+      ctx->CurrentDispatch = ctx->Save;

+      _glapi_set_dispatch(ctx->CurrentDispatch);

+   }

+}

+

+

+/**

+ * Set the offset added to list numbers in glCallLists.

+ */

+static void GLAPIENTRY

+_mesa_ListBase(GLuint base)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   ctx->List.ListBase = base;

+}

+

+

+/* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.

+ */

+static void GLAPIENTRY

+exec_Finish(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_Finish(ctx->Exec, ());

+}

+

+static void GLAPIENTRY

+exec_Flush(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_Flush(ctx->Exec, ());

+}

+

+static void GLAPIENTRY

+exec_GetBooleanv(GLenum pname, GLboolean *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetBooleanv(ctx->Exec, (pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetClipPlane(GLenum plane, GLdouble * equation)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetClipPlane(ctx->Exec, (plane, equation));

+}

+

+static void GLAPIENTRY

+exec_GetDoublev(GLenum pname, GLdouble *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetDoublev(ctx->Exec, (pname, params));

+}

+

+static GLenum GLAPIENTRY

+exec_GetError(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_GetError(ctx->Exec, ());

+}

+

+static void GLAPIENTRY

+exec_GetFloatv(GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetFloatv(ctx->Exec, (pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetIntegerv(GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetIntegerv(ctx->Exec, (pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetLightfv(GLenum light, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetLightfv(ctx->Exec, (light, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetLightiv(GLenum light, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetLightiv(ctx->Exec, (light, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetMapdv(GLenum target, GLenum query, GLdouble * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMapdv(ctx->Exec, (target, query, v));

+}

+

+static void GLAPIENTRY

+exec_GetMapfv(GLenum target, GLenum query, GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMapfv(ctx->Exec, (target, query, v));

+}

+

+static void GLAPIENTRY

+exec_GetMapiv(GLenum target, GLenum query, GLint * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMapiv(ctx->Exec, (target, query, v));

+}

+

+static void GLAPIENTRY

+exec_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMaterialfv(ctx->Exec, (face, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetMaterialiv(GLenum face, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMaterialiv(ctx->Exec, (face, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetPixelMapfv(GLenum map, GLfloat *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetPixelMapfv(ctx->Exec, (map, values));

+}

+

+static void GLAPIENTRY

+exec_GetPixelMapuiv(GLenum map, GLuint *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetPixelMapuiv(ctx->Exec, (map, values));

+}

+

+static void GLAPIENTRY

+exec_GetPixelMapusv(GLenum map, GLushort *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetPixelMapusv(ctx->Exec, (map, values));

+}

+

+static void GLAPIENTRY

+exec_GetPolygonStipple(GLubyte * dest)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetPolygonStipple(ctx->Exec, (dest));

+}

+

+static const GLubyte *GLAPIENTRY

+exec_GetString(GLenum name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_GetString(ctx->Exec, (name));

+}

+

+static void GLAPIENTRY

+exec_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexEnvfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexEnviv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexEnviv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexGendv(ctx->Exec, (coord, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexGenfv(ctx->Exec, (coord, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexGeniv(GLenum coord, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexGeniv(ctx->Exec, (coord, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexImage(GLenum target, GLint level, GLenum format,

+                 GLenum type, GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexImage(ctx->Exec, (target, level, format, type, pixels));

+}

+

+static void GLAPIENTRY

+exec_GetTexLevelParameterfv(GLenum target, GLint level,

+                            GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexLevelParameterfv(ctx->Exec, (target, level, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexLevelParameteriv(GLenum target, GLint level,

+                            GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexLevelParameteriv(ctx->Exec, (target, level, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexParameterfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetTexParameteriv(ctx->Exec, (target, pname, params));

+}

+

+static GLboolean GLAPIENTRY

+exec_IsEnabled(GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_IsEnabled(ctx->Exec, (cap));

+}

+

+static void GLAPIENTRY

+exec_PixelStoref(GLenum pname, GLfloat param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_PixelStoref(ctx->Exec, (pname, param));

+}

+

+static void GLAPIENTRY

+exec_PixelStorei(GLenum pname, GLint param)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_PixelStorei(ctx->Exec, (pname, param));

+}

+

+static void GLAPIENTRY

+exec_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,

+                GLenum format, GLenum type, GLvoid * pixels)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_ReadPixels(ctx->Exec, (x, y, width, height, format, type, pixels));

+}

+

+static GLint GLAPIENTRY

+exec_RenderMode(GLenum mode)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_RenderMode(ctx->Exec, (mode));

+}

+

+static void GLAPIENTRY

+exec_FeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_FeedbackBuffer(ctx->Exec, (size, type, buffer));

+}

+

+static void GLAPIENTRY

+exec_SelectBuffer(GLsizei size, GLuint * buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_SelectBuffer(ctx->Exec, (size, buffer));

+}

+

+static GLboolean GLAPIENTRY

+exec_AreTexturesResident(GLsizei n, const GLuint * texName,

+                         GLboolean * residences)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_AreTexturesResident(ctx->Exec, (n, texName, residences));

+}

+

+static void GLAPIENTRY

+exec_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_ColorPointer(ctx->Exec, (size, type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_DeleteTextures(GLsizei n, const GLuint * texName)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_DeleteTextures(ctx->Exec, (n, texName));

+}

+

+static void GLAPIENTRY

+exec_DisableClientState(GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_DisableClientState(ctx->Exec, (cap));

+}

+

+static void GLAPIENTRY

+exec_EdgeFlagPointer(GLsizei stride, const GLvoid * vptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_EdgeFlagPointer(ctx->Exec, (stride, vptr));

+}

+

+static void GLAPIENTRY

+exec_EnableClientState(GLenum cap)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_EnableClientState(ctx->Exec, (cap));

+}

+

+static void GLAPIENTRY

+exec_GenTextures(GLsizei n, GLuint * texName)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GenTextures(ctx->Exec, (n, texName));

+}

+

+static void GLAPIENTRY

+exec_GetPointerv(GLenum pname, GLvoid **params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetPointerv(ctx->Exec, (pname, params));

+}

+

+static void GLAPIENTRY

+exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_IndexPointer(ctx->Exec, (type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_InterleavedArrays(ctx->Exec, (format, stride, pointer));

+}

+

+static GLboolean GLAPIENTRY

+exec_IsTexture(GLuint texture)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   return CALL_IsTexture(ctx->Exec, (texture));

+}

+

+static void GLAPIENTRY

+exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_NormalPointer(ctx->Exec, (type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_PopClientAttrib(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_PopClientAttrib(ctx->Exec, ());

+}

+

+static void GLAPIENTRY

+exec_PushClientAttrib(GLbitfield mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_PushClientAttrib(ctx->Exec, (mask));

+}

+

+static void GLAPIENTRY

+exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,

+                     const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_TexCoordPointer(ctx->Exec, (size, type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetCompressedTexImageARB(ctx->Exec, (target, level, img));

+}

+

+static void GLAPIENTRY

+exec_VertexPointer(GLint size, GLenum type, GLsizei stride,

+                   const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_VertexPointer(ctx->Exec, (size, type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,

+                             GLint x, GLint y, GLsizei width)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_CopyConvolutionFilter1D(ctx->Exec,

+                                (target, internalFormat, x, y, width));

+}

+

+static void GLAPIENTRY

+exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,

+                             GLint x, GLint y, GLsizei width, GLsizei height)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_CopyConvolutionFilter2D(ctx->Exec,

+                                (target, internalFormat, x, y, width,

+                                 height));

+}

+

+static void GLAPIENTRY

+exec_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetColorTable(ctx->Exec, (target, format, type, data));

+}

+

+static void GLAPIENTRY

+exec_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetColorTableParameterfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetColorTableParameteriv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,

+                          GLvoid * image)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetConvolutionFilter(ctx->Exec, (target, format, type, image));

+}

+

+static void GLAPIENTRY

+exec_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetConvolutionParameterfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetConvolutionParameteriv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,

+                  GLenum type, GLvoid *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetHistogram(ctx->Exec, (target, reset, format, type, values));

+}

+

+static void GLAPIENTRY

+exec_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetHistogramParameterfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetHistogramParameteriv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,

+               GLenum type, GLvoid *values)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMinmax(ctx->Exec, (target, reset, format, type, values));

+}

+

+static void GLAPIENTRY

+exec_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMinmaxParameterfv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetMinmaxParameteriv(ctx->Exec, (target, pname, params));

+}

+

+static void GLAPIENTRY

+exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,

+                        GLvoid *row, GLvoid *column, GLvoid *span)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_GetSeparableFilter(ctx->Exec,

+                           (target, format, type, row, column, span));

+}

+

+static void GLAPIENTRY

+exec_SeparableFilter2D(GLenum target, GLenum internalFormat,

+                       GLsizei width, GLsizei height, GLenum format,

+                       GLenum type, const GLvoid *row, const GLvoid *column)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_SeparableFilter2D(ctx->Exec,

+                          (target, internalFormat, width, height, format,

+                           type, row, column));

+}

+

+static void GLAPIENTRY

+exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,

+                     GLsizei count, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_ColorPointerEXT(ctx->Exec, (size, type, stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_EdgeFlagPointerEXT(ctx->Exec, (stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,

+                     const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_IndexPointerEXT(ctx->Exec, (type, stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,

+                      const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_NormalPointerEXT(ctx->Exec, (type, stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,

+                        GLsizei count, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_TexCoordPointerEXT(ctx->Exec, (size, type, stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,

+                      GLsizei count, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_VertexPointerEXT(ctx->Exec, (size, type, stride, count, ptr));

+}

+

+static void GLAPIENTRY

+exec_LockArraysEXT(GLint first, GLsizei count)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_LockArraysEXT(ctx->Exec, (first, count));

+}

+

+static void GLAPIENTRY

+exec_UnlockArraysEXT(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_UnlockArraysEXT(ctx->Exec, ());

+}

+

+static void GLAPIENTRY

+exec_ClientActiveTextureARB(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_ClientActiveTextureARB(ctx->Exec, (target));

+}

+

+static void GLAPIENTRY

+exec_SecondaryColorPointerEXT(GLint size, GLenum type,

+                              GLsizei stride, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_SecondaryColorPointerEXT(ctx->Exec, (size, type, stride, ptr));

+}

+

+static void GLAPIENTRY

+exec_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_FogCoordPointerEXT(ctx->Exec, (type, stride, ptr));

+}

+

+/* GL_EXT_multi_draw_arrays */

+static void GLAPIENTRY

+exec_MultiDrawArraysEXT(GLenum mode, const GLint *first,

+                        const GLsizei *count, GLsizei primcount)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount));

+}

+

+/* GL_IBM_multimode_draw_arrays */

+static void GLAPIENTRY

+exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first,

+                            const GLsizei * count, GLsizei primcount,

+                            GLint modestride)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_MultiModeDrawArraysIBM(ctx->Exec,

+                               (mode, first, count, primcount, modestride));

+}

+

+/* GL_IBM_multimode_draw_arrays */

+static void GLAPIENTRY

+exec_MultiModeDrawElementsIBM(const GLenum * mode,

+                              const GLsizei * count,

+                              GLenum type,

+                              const GLvoid * const *indices,

+                              GLsizei primcount, GLint modestride)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   FLUSH_VERTICES(ctx, 0);

+   CALL_MultiModeDrawElementsIBM(ctx->Exec,

+                                 (mode, count, type, indices, primcount,

+                                  modestride));

+}

+

+

+

+/**

+ * Setup the given dispatch table to point to Mesa's display list

+ * building functions.

+ *

+ * This does not include any of the tnl functions - they are

+ * initialized from _mesa_init_api_defaults and from the active vtxfmt

+ * struct.

+ */

+struct _glapi_table *

+_mesa_create_save_table(void)

+{

+   struct _glapi_table *table;

+

+   table = _mesa_alloc_dispatch_table(_gloffset_COUNT);

+   if (table == NULL)

+      return NULL;

+

+   _mesa_loopback_init_api_table(table);

+

+   /* GL 1.0 */

+   SET_Accum(table, save_Accum);

+   SET_AlphaFunc(table, save_AlphaFunc);

+   SET_Bitmap(table, save_Bitmap);

+   SET_BlendFunc(table, save_BlendFunc);

+   SET_CallList(table, save_CallList);

+   SET_CallLists(table, save_CallLists);

+   SET_Clear(table, save_Clear);

+   SET_ClearAccum(table, save_ClearAccum);

+   SET_ClearColor(table, save_ClearColor);

+   SET_ClearDepth(table, save_ClearDepth);

+   SET_ClearIndex(table, save_ClearIndex);

+   SET_ClearStencil(table, save_ClearStencil);

+   SET_ClipPlane(table, save_ClipPlane);

+   SET_ColorMask(table, save_ColorMask);

+   SET_ColorMaskIndexedEXT(table, save_ColorMaskIndexed);

+   SET_ColorMaterial(table, save_ColorMaterial);

+   SET_CopyPixels(table, save_CopyPixels);

+   SET_CullFace(table, save_CullFace);

+   SET_DeleteLists(table, _mesa_DeleteLists);

+   SET_DepthFunc(table, save_DepthFunc);

+   SET_DepthMask(table, save_DepthMask);

+   SET_DepthRange(table, save_DepthRange);

+   SET_Disable(table, save_Disable);

+   SET_DisableIndexedEXT(table, save_DisableIndexed);

+   SET_DrawBuffer(table, save_DrawBuffer);

+   SET_DrawPixels(table, save_DrawPixels);

+   SET_Enable(table, save_Enable);

+   SET_EnableIndexedEXT(table, save_EnableIndexed);

+   SET_EndList(table, _mesa_EndList);

+   SET_EvalMesh1(table, save_EvalMesh1);

+   SET_EvalMesh2(table, save_EvalMesh2);

+   SET_Finish(table, exec_Finish);

+   SET_Flush(table, exec_Flush);

+   SET_Fogf(table, save_Fogf);

+   SET_Fogfv(table, save_Fogfv);

+   SET_Fogi(table, save_Fogi);

+   SET_Fogiv(table, save_Fogiv);

+   SET_FrontFace(table, save_FrontFace);

+   SET_Frustum(table, save_Frustum);

+   SET_GenLists(table, _mesa_GenLists);

+   SET_GetBooleanv(table, exec_GetBooleanv);

+   SET_GetClipPlane(table, exec_GetClipPlane);

+   SET_GetDoublev(table, exec_GetDoublev);

+   SET_GetError(table, exec_GetError);

+   SET_GetFloatv(table, exec_GetFloatv);

+   SET_GetIntegerv(table, exec_GetIntegerv);

+   SET_GetLightfv(table, exec_GetLightfv);

+   SET_GetLightiv(table, exec_GetLightiv);

+   SET_GetMapdv(table, exec_GetMapdv);

+   SET_GetMapfv(table, exec_GetMapfv);

+   SET_GetMapiv(table, exec_GetMapiv);

+   SET_GetMaterialfv(table, exec_GetMaterialfv);

+   SET_GetMaterialiv(table, exec_GetMaterialiv);

+   SET_GetPixelMapfv(table, exec_GetPixelMapfv);

+   SET_GetPixelMapuiv(table, exec_GetPixelMapuiv);

+   SET_GetPixelMapusv(table, exec_GetPixelMapusv);

+   SET_GetPolygonStipple(table, exec_GetPolygonStipple);

+   SET_GetString(table, exec_GetString);

+   SET_GetTexEnvfv(table, exec_GetTexEnvfv);

+   SET_GetTexEnviv(table, exec_GetTexEnviv);

+   SET_GetTexGendv(table, exec_GetTexGendv);

+   SET_GetTexGenfv(table, exec_GetTexGenfv);

+   SET_GetTexGeniv(table, exec_GetTexGeniv);

+   SET_GetTexImage(table, exec_GetTexImage);

+   SET_GetTexLevelParameterfv(table, exec_GetTexLevelParameterfv);

+   SET_GetTexLevelParameteriv(table, exec_GetTexLevelParameteriv);

+   SET_GetTexParameterfv(table, exec_GetTexParameterfv);

+   SET_GetTexParameteriv(table, exec_GetTexParameteriv);

+   SET_Hint(table, save_Hint);

+   SET_IndexMask(table, save_IndexMask);

+   SET_InitNames(table, save_InitNames);

+   SET_IsEnabled(table, exec_IsEnabled);

+   SET_IsList(table, _mesa_IsList);

+   SET_LightModelf(table, save_LightModelf);

+   SET_LightModelfv(table, save_LightModelfv);

+   SET_LightModeli(table, save_LightModeli);

+   SET_LightModeliv(table, save_LightModeliv);

+   SET_Lightf(table, save_Lightf);

+   SET_Lightfv(table, save_Lightfv);

+   SET_Lighti(table, save_Lighti);

+   SET_Lightiv(table, save_Lightiv);

+   SET_LineStipple(table, save_LineStipple);

+   SET_LineWidth(table, save_LineWidth);

+   SET_ListBase(table, save_ListBase);

+   SET_LoadIdentity(table, save_LoadIdentity);

+   SET_LoadMatrixd(table, save_LoadMatrixd);

+   SET_LoadMatrixf(table, save_LoadMatrixf);

+   SET_LoadName(table, save_LoadName);

+   SET_LogicOp(table, save_LogicOp);

+   SET_Map1d(table, save_Map1d);

+   SET_Map1f(table, save_Map1f);

+   SET_Map2d(table, save_Map2d);

+   SET_Map2f(table, save_Map2f);

+   SET_MapGrid1d(table, save_MapGrid1d);

+   SET_MapGrid1f(table, save_MapGrid1f);

+   SET_MapGrid2d(table, save_MapGrid2d);

+   SET_MapGrid2f(table, save_MapGrid2f);

+   SET_MatrixMode(table, save_MatrixMode);

+   SET_MultMatrixd(table, save_MultMatrixd);

+   SET_MultMatrixf(table, save_MultMatrixf);

+   SET_NewList(table, save_NewList);

+   SET_Ortho(table, save_Ortho);

+   SET_PassThrough(table, save_PassThrough);

+   SET_PixelMapfv(table, save_PixelMapfv);

+   SET_PixelMapuiv(table, save_PixelMapuiv);

+   SET_PixelMapusv(table, save_PixelMapusv);

+   SET_PixelStoref(table, exec_PixelStoref);

+   SET_PixelStorei(table, exec_PixelStorei);

+   SET_PixelTransferf(table, save_PixelTransferf);

+   SET_PixelTransferi(table, save_PixelTransferi);

+   SET_PixelZoom(table, save_PixelZoom);

+   SET_PointSize(table, save_PointSize);

+   SET_PolygonMode(table, save_PolygonMode);

+   SET_PolygonOffset(table, save_PolygonOffset);

+   SET_PolygonStipple(table, save_PolygonStipple);

+   SET_PopAttrib(table, save_PopAttrib);

+   SET_PopMatrix(table, save_PopMatrix);

+   SET_PopName(table, save_PopName);

+   SET_PushAttrib(table, save_PushAttrib);

+   SET_PushMatrix(table, save_PushMatrix);

+   SET_PushName(table, save_PushName);

+   SET_RasterPos2d(table, save_RasterPos2d);

+   SET_RasterPos2dv(table, save_RasterPos2dv);

+   SET_RasterPos2f(table, save_RasterPos2f);

+   SET_RasterPos2fv(table, save_RasterPos2fv);

+   SET_RasterPos2i(table, save_RasterPos2i);

+   SET_RasterPos2iv(table, save_RasterPos2iv);

+   SET_RasterPos2s(table, save_RasterPos2s);

+   SET_RasterPos2sv(table, save_RasterPos2sv);

+   SET_RasterPos3d(table, save_RasterPos3d);

+   SET_RasterPos3dv(table, save_RasterPos3dv);

+   SET_RasterPos3f(table, save_RasterPos3f);

+   SET_RasterPos3fv(table, save_RasterPos3fv);

+   SET_RasterPos3i(table, save_RasterPos3i);

+   SET_RasterPos3iv(table, save_RasterPos3iv);

+   SET_RasterPos3s(table, save_RasterPos3s);

+   SET_RasterPos3sv(table, save_RasterPos3sv);

+   SET_RasterPos4d(table, save_RasterPos4d);

+   SET_RasterPos4dv(table, save_RasterPos4dv);

+   SET_RasterPos4f(table, save_RasterPos4f);

+   SET_RasterPos4fv(table, save_RasterPos4fv);

+   SET_RasterPos4i(table, save_RasterPos4i);

+   SET_RasterPos4iv(table, save_RasterPos4iv);

+   SET_RasterPos4s(table, save_RasterPos4s);

+   SET_RasterPos4sv(table, save_RasterPos4sv);

+   SET_ReadBuffer(table, save_ReadBuffer);

+   SET_ReadPixels(table, exec_ReadPixels);

+   SET_RenderMode(table, exec_RenderMode);

+   SET_Rotated(table, save_Rotated);

+   SET_Rotatef(table, save_Rotatef);

+   SET_Scaled(table, save_Scaled);

+   SET_Scalef(table, save_Scalef);

+   SET_Scissor(table, save_Scissor);

+   SET_FeedbackBuffer(table, exec_FeedbackBuffer);

+   SET_SelectBuffer(table, exec_SelectBuffer);

+   SET_ShadeModel(table, save_ShadeModel);

+   SET_StencilFunc(table, save_StencilFunc);

+   SET_StencilMask(table, save_StencilMask);

+   SET_StencilOp(table, save_StencilOp);

+   SET_TexEnvf(table, save_TexEnvf);

+   SET_TexEnvfv(table, save_TexEnvfv);

+   SET_TexEnvi(table, save_TexEnvi);

+   SET_TexEnviv(table, save_TexEnviv);

+   SET_TexGend(table, save_TexGend);

+   SET_TexGendv(table, save_TexGendv);

+   SET_TexGenf(table, save_TexGenf);

+   SET_TexGenfv(table, save_TexGenfv);

+   SET_TexGeni(table, save_TexGeni);

+   SET_TexGeniv(table, save_TexGeniv);

+   SET_TexImage1D(table, save_TexImage1D);

+   SET_TexImage2D(table, save_TexImage2D);

+   SET_TexParameterf(table, save_TexParameterf);

+   SET_TexParameterfv(table, save_TexParameterfv);

+   SET_TexParameteri(table, save_TexParameteri);

+   SET_TexParameteriv(table, save_TexParameteriv);

+   SET_Translated(table, save_Translated);

+   SET_Translatef(table, save_Translatef);

+   SET_Viewport(table, save_Viewport);

+

+   /* GL 1.1 */

+   SET_AreTexturesResident(table, exec_AreTexturesResident);

+   SET_BindTexture(table, save_BindTexture);

+   SET_ColorPointer(table, exec_ColorPointer);

+   SET_CopyTexImage1D(table, save_CopyTexImage1D);

+   SET_CopyTexImage2D(table, save_CopyTexImage2D);

+   SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);

+   SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);

+   SET_DeleteTextures(table, exec_DeleteTextures);

+   SET_DisableClientState(table, exec_DisableClientState);

+   SET_EdgeFlagPointer(table, exec_EdgeFlagPointer);

+   SET_EnableClientState(table, exec_EnableClientState);

+   SET_GenTextures(table, exec_GenTextures);

+   SET_GetPointerv(table, exec_GetPointerv);

+   SET_IndexPointer(table, exec_IndexPointer);

+   SET_InterleavedArrays(table, exec_InterleavedArrays);

+   SET_IsTexture(table, exec_IsTexture);

+   SET_NormalPointer(table, exec_NormalPointer);

+   SET_PopClientAttrib(table, exec_PopClientAttrib);

+   SET_PrioritizeTextures(table, save_PrioritizeTextures);

+   SET_PushClientAttrib(table, exec_PushClientAttrib);

+   SET_TexCoordPointer(table, exec_TexCoordPointer);

+   SET_TexSubImage1D(table, save_TexSubImage1D);

+   SET_TexSubImage2D(table, save_TexSubImage2D);

+   SET_VertexPointer(table, exec_VertexPointer);

+

+   /* GL 1.2 */

+   SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);

+   SET_TexImage3D(table, save_TexImage3D);

+   SET_TexSubImage3D(table, save_TexSubImage3D);

+

+   /* GL 2.0 */

+   SET_StencilFuncSeparate(table, save_StencilFuncSeparate);

+   SET_StencilMaskSeparate(table, save_StencilMaskSeparate);

+   SET_StencilOpSeparate(table, save_StencilOpSeparate);

+

+   /* ATI_separate_stencil */ 

+   SET_StencilFuncSeparateATI(table, save_StencilFuncSeparateATI);

+

+   /* GL_ARB_imaging */

+   /* Not all are supported */

+   SET_BlendColor(table, save_BlendColor);

+   SET_BlendEquation(table, save_BlendEquation);

+   SET_ColorSubTable(table, save_ColorSubTable);

+   SET_ColorTable(table, save_ColorTable);

+   SET_ColorTableParameterfv(table, save_ColorTableParameterfv);

+   SET_ColorTableParameteriv(table, save_ColorTableParameteriv);

+   SET_ConvolutionFilter1D(table, save_ConvolutionFilter1D);

+   SET_ConvolutionFilter2D(table, save_ConvolutionFilter2D);

+   SET_ConvolutionParameterf(table, save_ConvolutionParameterf);

+   SET_ConvolutionParameterfv(table, save_ConvolutionParameterfv);

+   SET_ConvolutionParameteri(table, save_ConvolutionParameteri);

+   SET_ConvolutionParameteriv(table, save_ConvolutionParameteriv);

+   SET_CopyColorSubTable(table, save_CopyColorSubTable);

+   SET_CopyColorTable(table, save_CopyColorTable);

+   SET_CopyConvolutionFilter1D(table, exec_CopyConvolutionFilter1D);

+   SET_CopyConvolutionFilter2D(table, exec_CopyConvolutionFilter2D);

+   SET_GetColorTable(table, exec_GetColorTable);

+   SET_GetColorTableParameterfv(table, exec_GetColorTableParameterfv);

+   SET_GetColorTableParameteriv(table, exec_GetColorTableParameteriv);

+   SET_GetConvolutionFilter(table, exec_GetConvolutionFilter);

+   SET_GetConvolutionParameterfv(table, exec_GetConvolutionParameterfv);

+   SET_GetConvolutionParameteriv(table, exec_GetConvolutionParameteriv);

+   SET_GetHistogram(table, exec_GetHistogram);

+   SET_GetHistogramParameterfv(table, exec_GetHistogramParameterfv);

+   SET_GetHistogramParameteriv(table, exec_GetHistogramParameteriv);

+   SET_GetMinmax(table, exec_GetMinmax);

+   SET_GetMinmaxParameterfv(table, exec_GetMinmaxParameterfv);

+   SET_GetMinmaxParameteriv(table, exec_GetMinmaxParameteriv);

+   SET_GetSeparableFilter(table, exec_GetSeparableFilter);

+   SET_Histogram(table, save_Histogram);

+   SET_Minmax(table, save_Minmax);

+   SET_ResetHistogram(table, save_ResetHistogram);

+   SET_ResetMinmax(table, save_ResetMinmax);

+   SET_SeparableFilter2D(table, exec_SeparableFilter2D);

+

+   /* 2. GL_EXT_blend_color */

+#if 0

+   SET_BlendColorEXT(table, save_BlendColorEXT);

+#endif

+

+   /* 3. GL_EXT_polygon_offset */

+   SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);

+

+   /* 6. GL_EXT_texture3d */

+#if 0

+   SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);

+   SET_TexImage3DEXT(table, save_TexImage3DEXT);

+   SET_TexSubImage3DEXT(table, save_TexSubImage3D);

+#endif

+

+   /* 14. GL_SGI_color_table */

+#if 0

+   SET_ColorTableSGI(table, save_ColorTable);

+   SET_ColorSubTableSGI(table, save_ColorSubTable);

+   SET_GetColorTableSGI(table, exec_GetColorTable);

+   SET_GetColorTableParameterfvSGI(table, exec_GetColorTableParameterfv);

+   SET_GetColorTableParameterivSGI(table, exec_GetColorTableParameteriv);

+#endif

+

+   /* 30. GL_EXT_vertex_array */

+   SET_ColorPointerEXT(table, exec_ColorPointerEXT);

+   SET_EdgeFlagPointerEXT(table, exec_EdgeFlagPointerEXT);

+   SET_IndexPointerEXT(table, exec_IndexPointerEXT);

+   SET_NormalPointerEXT(table, exec_NormalPointerEXT);

+   SET_TexCoordPointerEXT(table, exec_TexCoordPointerEXT);

+   SET_VertexPointerEXT(table, exec_VertexPointerEXT);

+

+   /* 37. GL_EXT_blend_minmax */

+#if 0

+   SET_BlendEquationEXT(table, save_BlendEquationEXT);

+#endif

+

+   /* 54. GL_EXT_point_parameters */

+   SET_PointParameterfEXT(table, save_PointParameterfEXT);

+   SET_PointParameterfvEXT(table, save_PointParameterfvEXT);

+

+   /* 97. GL_EXT_compiled_vertex_array */

+   SET_LockArraysEXT(table, exec_LockArraysEXT);

+   SET_UnlockArraysEXT(table, exec_UnlockArraysEXT);

+

+   /* 145. GL_EXT_secondary_color */

+   SET_SecondaryColorPointerEXT(table, exec_SecondaryColorPointerEXT);

+

+   /* 148. GL_EXT_multi_draw_arrays */

+   SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);

+

+   /* 149. GL_EXT_fog_coord */

+   SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);

+

+   /* 173. GL_EXT_blend_func_separate */

+   SET_BlendFuncSeparateEXT(table, save_BlendFuncSeparateEXT);

+

+   /* 196. GL_MESA_resize_buffers */

+   SET_ResizeBuffersMESA(table, _mesa_ResizeBuffersMESA);

+

+   /* 197. GL_MESA_window_pos */

+   SET_WindowPos2dMESA(table, save_WindowPos2dMESA);

+   SET_WindowPos2dvMESA(table, save_WindowPos2dvMESA);

+   SET_WindowPos2fMESA(table, save_WindowPos2fMESA);

+   SET_WindowPos2fvMESA(table, save_WindowPos2fvMESA);

+   SET_WindowPos2iMESA(table, save_WindowPos2iMESA);

+   SET_WindowPos2ivMESA(table, save_WindowPos2ivMESA);

+   SET_WindowPos2sMESA(table, save_WindowPos2sMESA);

+   SET_WindowPos2svMESA(table, save_WindowPos2svMESA);

+   SET_WindowPos3dMESA(table, save_WindowPos3dMESA);

+   SET_WindowPos3dvMESA(table, save_WindowPos3dvMESA);

+   SET_WindowPos3fMESA(table, save_WindowPos3fMESA);

+   SET_WindowPos3fvMESA(table, save_WindowPos3fvMESA);

+   SET_WindowPos3iMESA(table, save_WindowPos3iMESA);

+   SET_WindowPos3ivMESA(table, save_WindowPos3ivMESA);

+   SET_WindowPos3sMESA(table, save_WindowPos3sMESA);

+   SET_WindowPos3svMESA(table, save_WindowPos3svMESA);

+   SET_WindowPos4dMESA(table, save_WindowPos4dMESA);

+   SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);

+   SET_WindowPos4fMESA(table, save_WindowPos4fMESA);

+   SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);

+   SET_WindowPos4iMESA(table, save_WindowPos4iMESA);

+   SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);

+   SET_WindowPos4sMESA(table, save_WindowPos4sMESA);

+   SET_WindowPos4svMESA(table, save_WindowPos4svMESA);

+

+   /* 200. GL_IBM_multimode_draw_arrays */

+   SET_MultiModeDrawArraysIBM(table, exec_MultiModeDrawArraysIBM);

+   SET_MultiModeDrawElementsIBM(table, exec_MultiModeDrawElementsIBM);

+

+#if FEATURE_NV_vertex_program

+   /* 233. GL_NV_vertex_program */

+   /* The following commands DO NOT go into display lists:

+    * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,

+    * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*

+    */

+   SET_BindProgramNV(table, save_BindProgramNV);

+   SET_DeleteProgramsNV(table, _mesa_DeletePrograms);

+   SET_ExecuteProgramNV(table, save_ExecuteProgramNV);

+   SET_GenProgramsNV(table, _mesa_GenPrograms);

+   SET_AreProgramsResidentNV(table, _mesa_AreProgramsResidentNV);

+   SET_RequestResidentProgramsNV(table, save_RequestResidentProgramsNV);

+   SET_GetProgramParameterfvNV(table, _mesa_GetProgramParameterfvNV);

+   SET_GetProgramParameterdvNV(table, _mesa_GetProgramParameterdvNV);

+   SET_GetProgramivNV(table, _mesa_GetProgramivNV);

+   SET_GetProgramStringNV(table, _mesa_GetProgramStringNV);

+   SET_GetTrackMatrixivNV(table, _mesa_GetTrackMatrixivNV);

+   SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);

+   SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);

+   SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);

+   SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);

+   SET_IsProgramNV(table, _mesa_IsProgramARB);

+   SET_LoadProgramNV(table, save_LoadProgramNV);

+   SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);

+   SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);

+   SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);

+   SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);

+   SET_ProgramParameters4dvNV(table, save_ProgramParameters4dvNV);

+   SET_ProgramParameters4fvNV(table, save_ProgramParameters4fvNV);

+   SET_TrackMatrixNV(table, save_TrackMatrixNV);

+   SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);

+#endif

+

+   /* 244. GL_ATI_envmap_bumpmap */

+   SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI);

+   SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI);

+

+   /* 245. GL_ATI_fragment_shader */

+#if FEATURE_ATI_fragment_shader

+   SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);

+   SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);

+#endif

+

+   /* 282. GL_NV_fragment_program */

+#if FEATURE_NV_fragment_program

+   SET_ProgramNamedParameter4fNV(table, save_ProgramNamedParameter4fNV);

+   SET_ProgramNamedParameter4dNV(table, save_ProgramNamedParameter4dNV);

+   SET_ProgramNamedParameter4fvNV(table, save_ProgramNamedParameter4fvNV);

+   SET_ProgramNamedParameter4dvNV(table, save_ProgramNamedParameter4dvNV);

+   SET_GetProgramNamedParameterfvNV(table,

+                                    _mesa_GetProgramNamedParameterfvNV);

+   SET_GetProgramNamedParameterdvNV(table,

+                                    _mesa_GetProgramNamedParameterdvNV);

+   SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);

+   SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);

+   SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);

+   SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);

+   SET_GetProgramLocalParameterdvARB(table,

+                                     _mesa_GetProgramLocalParameterdvARB);

+   SET_GetProgramLocalParameterfvARB(table,

+                                     _mesa_GetProgramLocalParameterfvARB);

+#endif

+

+   /* 262. GL_NV_point_sprite */

+   SET_PointParameteriNV(table, save_PointParameteriNV);

+   SET_PointParameterivNV(table, save_PointParameterivNV);

+

+   /* 268. GL_EXT_stencil_two_side */

+   SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);

+

+   /* 273. GL_APPLE_vertex_array_object */

+   SET_BindVertexArrayAPPLE(table, _mesa_BindVertexArrayAPPLE);

+   SET_DeleteVertexArraysAPPLE(table, _mesa_DeleteVertexArraysAPPLE);

+   SET_GenVertexArraysAPPLE(table, _mesa_GenVertexArraysAPPLE);

+   SET_IsVertexArrayAPPLE(table, _mesa_IsVertexArrayAPPLE);

+

+   /* ???. GL_EXT_depth_bounds_test */

+   SET_DepthBoundsEXT(table, save_DepthBoundsEXT);

+

+   /* ARB 1. GL_ARB_multitexture */

+   SET_ActiveTextureARB(table, save_ActiveTextureARB);

+   SET_ClientActiveTextureARB(table, exec_ClientActiveTextureARB);

+

+   /* ARB 3. GL_ARB_transpose_matrix */

+   SET_LoadTransposeMatrixdARB(table, save_LoadTransposeMatrixdARB);

+   SET_LoadTransposeMatrixfARB(table, save_LoadTransposeMatrixfARB);

+   SET_MultTransposeMatrixdARB(table, save_MultTransposeMatrixdARB);

+   SET_MultTransposeMatrixfARB(table, save_MultTransposeMatrixfARB);

+

+   /* ARB 5. GL_ARB_multisample */

+   SET_SampleCoverageARB(table, save_SampleCoverageARB);

+

+   /* ARB 12. GL_ARB_texture_compression */

+   SET_CompressedTexImage3DARB(table, save_CompressedTexImage3DARB);

+   SET_CompressedTexImage2DARB(table, save_CompressedTexImage2DARB);

+   SET_CompressedTexImage1DARB(table, save_CompressedTexImage1DARB);

+   SET_CompressedTexSubImage3DARB(table, save_CompressedTexSubImage3DARB);

+   SET_CompressedTexSubImage2DARB(table, save_CompressedTexSubImage2DARB);

+   SET_CompressedTexSubImage1DARB(table, save_CompressedTexSubImage1DARB);

+   SET_GetCompressedTexImageARB(table, exec_GetCompressedTexImageARB);

+

+   /* ARB 14. GL_ARB_point_parameters */

+   /* aliased with EXT_point_parameters functions */

+

+   /* ARB 25. GL_ARB_window_pos */

+   /* aliased with MESA_window_pos functions */

+

+   /* ARB 26. GL_ARB_vertex_program */

+   /* ARB 27. GL_ARB_fragment_program */

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+   /* glVertexAttrib* functions alias the NV ones, handled elsewhere */

+   SET_VertexAttribPointerARB(table, _mesa_VertexAttribPointerARB);

+   SET_EnableVertexAttribArrayARB(table, _mesa_EnableVertexAttribArrayARB);

+   SET_DisableVertexAttribArrayARB(table, _mesa_DisableVertexAttribArrayARB);

+   SET_ProgramStringARB(table, save_ProgramStringARB);

+   SET_BindProgramNV(table, save_BindProgramNV);

+   SET_DeleteProgramsNV(table, _mesa_DeletePrograms);

+   SET_GenProgramsNV(table, _mesa_GenPrograms);

+   SET_IsProgramNV(table, _mesa_IsProgramARB);

+   SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);

+   SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);

+   SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);

+   SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);

+   SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);

+   SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);

+   SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);

+   SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);

+   SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);

+   SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);

+   SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);

+   SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);

+   SET_GetProgramEnvParameterdvARB(table, _mesa_GetProgramEnvParameterdvARB);

+   SET_GetProgramEnvParameterfvARB(table, _mesa_GetProgramEnvParameterfvARB);

+   SET_GetProgramLocalParameterdvARB(table,

+                                     _mesa_GetProgramLocalParameterdvARB);

+   SET_GetProgramLocalParameterfvARB(table,

+                                     _mesa_GetProgramLocalParameterfvARB);

+   SET_GetProgramivARB(table, _mesa_GetProgramivARB);

+   SET_GetProgramStringARB(table, _mesa_GetProgramStringARB);

+#endif

+

+   /* ARB 28. GL_ARB_vertex_buffer_object */

+#if FEATURE_ARB_vertex_buffer_object

+   /* None of the extension's functions get compiled */

+   SET_BindBufferARB(table, _mesa_BindBufferARB);

+   SET_BufferDataARB(table, _mesa_BufferDataARB);

+   SET_BufferSubDataARB(table, _mesa_BufferSubDataARB);

+   SET_DeleteBuffersARB(table, _mesa_DeleteBuffersARB);

+   SET_GenBuffersARB(table, _mesa_GenBuffersARB);

+   SET_GetBufferParameterivARB(table, _mesa_GetBufferParameterivARB);

+   SET_GetBufferPointervARB(table, _mesa_GetBufferPointervARB);

+   SET_GetBufferSubDataARB(table, _mesa_GetBufferSubDataARB);

+   SET_IsBufferARB(table, _mesa_IsBufferARB);

+   SET_MapBufferARB(table, _mesa_MapBufferARB);

+   SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);

+#endif

+

+#if FEATURE_queryobj

+   SET_BeginQueryARB(table, save_BeginQueryARB);

+   SET_EndQueryARB(table, save_EndQueryARB);

+   SET_GenQueriesARB(table, _mesa_GenQueriesARB);

+   SET_DeleteQueriesARB(table, _mesa_DeleteQueriesARB);

+   SET_IsQueryARB(table, _mesa_IsQueryARB);

+   SET_GetQueryivARB(table, _mesa_GetQueryivARB);

+   SET_GetQueryObjectivARB(table, _mesa_GetQueryObjectivARB);

+   SET_GetQueryObjectuivARB(table, _mesa_GetQueryObjectuivARB);

+#endif

+   SET_DrawBuffersARB(table, save_DrawBuffersARB);

+

+#if FEATURE_EXT_framebuffer_blit

+   SET_BlitFramebufferEXT(table, save_BlitFramebufferEXT);

+#endif

+

+   /* GL_ARB_shader_objects */

+   SET_UseProgramObjectARB(table, save_UseProgramObjectARB);

+   SET_Uniform1fARB(table, save_Uniform1fARB);

+   SET_Uniform2fARB(table, save_Uniform2fARB);

+   SET_Uniform3fARB(table, save_Uniform3fARB);

+   SET_Uniform4fARB(table, save_Uniform4fARB);

+   SET_Uniform1fvARB(table, save_Uniform1fvARB);

+   SET_Uniform2fvARB(table, save_Uniform2fvARB);

+   SET_Uniform3fvARB(table, save_Uniform3fvARB);

+   SET_Uniform4fvARB(table, save_Uniform4fvARB);

+   SET_Uniform1iARB(table, save_Uniform1iARB);

+   SET_Uniform2iARB(table, save_Uniform2iARB);

+   SET_Uniform3iARB(table, save_Uniform3iARB);

+   SET_Uniform4iARB(table, save_Uniform4iARB);

+   SET_Uniform1ivARB(table, save_Uniform1ivARB);

+   SET_Uniform2ivARB(table, save_Uniform2ivARB);

+   SET_Uniform3ivARB(table, save_Uniform3ivARB);

+   SET_Uniform4ivARB(table, save_Uniform4ivARB);

+   SET_UniformMatrix2fvARB(table, save_UniformMatrix2fvARB);

+   SET_UniformMatrix3fvARB(table, save_UniformMatrix3fvARB);

+   SET_UniformMatrix4fvARB(table, save_UniformMatrix4fvARB);

+   SET_UniformMatrix2x3fv(table, save_UniformMatrix2x3fv);

+   SET_UniformMatrix3x2fv(table, save_UniformMatrix3x2fv);

+   SET_UniformMatrix2x4fv(table, save_UniformMatrix2x4fv);

+   SET_UniformMatrix4x2fv(table, save_UniformMatrix4x2fv);

+   SET_UniformMatrix3x4fv(table, save_UniformMatrix3x4fv);

+   SET_UniformMatrix4x3fv(table, save_UniformMatrix4x3fv);

+

+   /* ARB 30/31/32. GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */

+   SET_BindAttribLocationARB(table, exec_BindAttribLocationARB);

+   SET_GetAttribLocationARB(table, exec_GetAttribLocationARB);

+   SET_GetUniformLocationARB(table, exec_GetUniformLocationARB);

+   /* XXX additional functions need to be implemented here! */

+

+   /* 299. GL_EXT_blend_equation_separate */

+   SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);

+

+   /* GL_EXT_gpu_program_parameters */

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+   SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);

+   SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);

+#endif

+

+   /* ARB 50. GL_ARB_map_buffer_range */

+#if FEATURE_ARB_map_buffer_range

+   SET_MapBufferRange(table, _mesa_MapBufferRange); /* no dlist save */

+   SET_FlushMappedBufferRange(table, _mesa_FlushMappedBufferRange); /* no dl */

+#endif

+

+   /* ARB 59. GL_ARB_copy_buffer */

+   SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */

+

+   /* 352. GL_EXT_transform_feedback */

+#if FEATURE_EXT_transform_feedback

+   SET_BeginTransformFeedbackEXT(table, save_BeginTransformFeedback);

+   SET_EndTransformFeedbackEXT(table, save_EndTransformFeedback);

+#endif

+

+   /* 364. GL_EXT_provoking_vertex */

+   SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT);

+

+   /* 371. GL_APPLE_object_purgeable */

+#if FEATURE_APPLE_object_purgeable

+   SET_ObjectPurgeableAPPLE(table, _mesa_ObjectPurgeableAPPLE);

+   SET_ObjectUnpurgeableAPPLE(table, _mesa_ObjectUnpurgeableAPPLE);

+#endif

+

+   /* GL_EXT_texture_integer */

+   SET_ClearColorIiEXT(table, save_ClearColorIi);

+   SET_ClearColorIuiEXT(table, save_ClearColorIui);

+   SET_TexParameterIivEXT(table, save_TexParameterIiv);

+   SET_TexParameterIuivEXT(table, save_TexParameterIuiv);

+   SET_GetTexParameterIivEXT(table, exec_GetTexParameterIiv);

+   SET_GetTexParameterIuivEXT(table, exec_GetTexParameterIuiv);

+

+   /* 377. GL_EXT_separate_shader_objects */

+   SET_UseShaderProgramEXT(table, save_UseShaderProgramEXT);

+   SET_ActiveProgramEXT(table, save_ActiveProgramEXT);

+

+   /* GL 3.0 */

+#if 0

+   SET_ClearBufferiv(table, save_ClearBufferiv);

+   SET_ClearBufferuiv(table, save_ClearBufferuiv);

+   SET_ClearBufferfv(table, save_ClearBufferfv);

+   SET_ClearBufferfi(table, save_ClearBufferfi);

+   SET_Uniform1ui(table, save_Uniform1ui);

+   SET_Uniform2ui(table, save_Uniform2ui);

+   SET_Uniform3ui(table, save_Uniform3ui);

+   SET_Uniform4ui(table, save_Uniform4ui);

+   SET_Uniform1uiv(table, save_Uniform1uiv);

+   SET_Uniform2uiv(table, save_Uniform2uiv);

+   SET_Uniform3uiv(table, save_Uniform3uiv);

+   SET_Uniform4uiv(table, save_Uniform4uiv);

+#else

+   (void) save_ClearBufferiv;

+   (void) save_ClearBufferuiv;

+   (void) save_ClearBufferfv;

+   (void) save_ClearBufferfi;

+   (void) save_Uniform1ui;

+   (void) save_Uniform2ui;

+   (void) save_Uniform3ui;

+   (void) save_Uniform4ui;

+   (void) save_Uniform1uiv;

+   (void) save_Uniform2uiv;

+   (void) save_Uniform3uiv;

+   (void) save_Uniform4uiv;

+#endif

+

+   /* GL_ARB_instanced_arrays */

+   SET_VertexAttribDivisorARB(table, save_VertexAttribDivisor);

+

+   /* GL_ARB_draw_buffer_blend */

+   SET_BlendFunciARB(table, save_BlendFunci);

+   SET_BlendFuncSeparateiARB(table, save_BlendFuncSeparatei);

+   SET_BlendEquationiARB(table, save_BlendEquationi);

+   SET_BlendEquationSeparateiARB(table, save_BlendEquationSeparatei);

+

+   return table;

+}

+

+

+

+static const char *

+enum_string(GLenum k)

+{

+   return _mesa_lookup_enum_by_nr(k);

+}

+

+

+/**

+ * Print the commands in a display list.  For debugging only.

+ * TODO: many commands aren't handled yet.

+ */

+static void GLAPIENTRY

+print_list(struct gl_context *ctx, GLuint list)

+{

+   struct gl_display_list *dlist;

+   Node *n;

+   GLboolean done;

+

+   if (!islist(ctx, list)) {

+      printf("%u is not a display list ID\n", list);

+      return;

+   }

+

+   dlist = lookup_list(ctx, list);

+   if (!dlist)

+      return;

+

+   n = dlist->Head;

+

+   printf("START-LIST %u, address %p\n", list, (void *) n);

+

+   done = n ? GL_FALSE : GL_TRUE;

+   while (!done) {

+      const OpCode opcode = n[0].opcode;

+

+      if (is_ext_opcode(opcode)) {

+         n += ext_opcode_print(ctx, n);

+      }

+      else {

+         switch (opcode) {

+         case OPCODE_ACCUM:

+            printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);

+            break;

+         case OPCODE_BITMAP:

+            printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,

+                         n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data);

+            break;

+         case OPCODE_CALL_LIST:

+            printf("CallList %d\n", (int) n[1].ui);

+            break;

+         case OPCODE_CALL_LIST_OFFSET:

+            printf("CallList %d + offset %u = %u\n", (int) n[1].ui,

+                         ctx->List.ListBase, ctx->List.ListBase + n[1].ui);

+            break;

+         case OPCODE_COLOR_TABLE_PARAMETER_FV:

+            printf("ColorTableParameterfv %s %s %f %f %f %f\n",

+                         enum_string(n[1].e), enum_string(n[2].e),

+                         n[3].f, n[4].f, n[5].f, n[6].f);

+            break;

+         case OPCODE_COLOR_TABLE_PARAMETER_IV:

+            printf("ColorTableParameteriv %s %s %d %d %d %d\n",

+                         enum_string(n[1].e), enum_string(n[2].e),

+                         n[3].i, n[4].i, n[5].i, n[6].i);

+            break;

+         case OPCODE_DISABLE:

+            printf("Disable %s\n", enum_string(n[1].e));

+            break;

+         case OPCODE_ENABLE:

+            printf("Enable %s\n", enum_string(n[1].e));

+            break;

+         case OPCODE_FRUSTUM:

+            printf("Frustum %g %g %g %g %g %g\n",

+                         n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);

+            break;

+         case OPCODE_LINE_STIPPLE:

+            printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);

+            break;

+         case OPCODE_LOAD_IDENTITY:

+            printf("LoadIdentity\n");

+            break;

+         case OPCODE_LOAD_MATRIX:

+            printf("LoadMatrix\n");

+            printf("  %8f %8f %8f %8f\n",

+                         n[1].f, n[5].f, n[9].f, n[13].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[2].f, n[6].f, n[10].f, n[14].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[3].f, n[7].f, n[11].f, n[15].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[4].f, n[8].f, n[12].f, n[16].f);

+            break;

+         case OPCODE_MULT_MATRIX:

+            printf("MultMatrix (or Rotate)\n");

+            printf("  %8f %8f %8f %8f\n",

+                         n[1].f, n[5].f, n[9].f, n[13].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[2].f, n[6].f, n[10].f, n[14].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[3].f, n[7].f, n[11].f, n[15].f);

+            printf("  %8f %8f %8f %8f\n",

+                         n[4].f, n[8].f, n[12].f, n[16].f);

+            break;

+         case OPCODE_ORTHO:

+            printf("Ortho %g %g %g %g %g %g\n",

+                         n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);

+            break;

+         case OPCODE_POP_ATTRIB:

+            printf("PopAttrib\n");

+            break;

+         case OPCODE_POP_MATRIX:

+            printf("PopMatrix\n");

+            break;

+         case OPCODE_POP_NAME:

+            printf("PopName\n");

+            break;

+         case OPCODE_PUSH_ATTRIB:

+            printf("PushAttrib %x\n", n[1].bf);

+            break;

+         case OPCODE_PUSH_MATRIX:

+            printf("PushMatrix\n");

+            break;

+         case OPCODE_PUSH_NAME:

+            printf("PushName %d\n", (int) n[1].ui);

+            break;

+         case OPCODE_RASTER_POS:

+            printf("RasterPos %g %g %g %g\n",

+                         n[1].f, n[2].f, n[3].f, n[4].f);

+            break;

+         case OPCODE_ROTATE:

+            printf("Rotate %g %g %g %g\n",

+                         n[1].f, n[2].f, n[3].f, n[4].f);

+            break;

+         case OPCODE_SCALE:

+            printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);

+            break;

+         case OPCODE_TRANSLATE:

+            printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);

+            break;

+         case OPCODE_BIND_TEXTURE:

+            printf("BindTexture %s %d\n",

+                         _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);

+            break;

+         case OPCODE_SHADE_MODEL:

+            printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));

+            break;

+         case OPCODE_MAP1:

+            printf("Map1 %s %.3f %.3f %d %d\n",

+                         _mesa_lookup_enum_by_nr(n[1].ui),

+                         n[2].f, n[3].f, n[4].i, n[5].i);

+            break;

+         case OPCODE_MAP2:

+            printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",

+                         _mesa_lookup_enum_by_nr(n[1].ui),

+                         n[2].f, n[3].f, n[4].f, n[5].f,

+                         n[6].i, n[7].i, n[8].i, n[9].i);

+            break;

+         case OPCODE_MAPGRID1:

+            printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);

+            break;

+         case OPCODE_MAPGRID2:

+            printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",

+                         n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);

+            break;

+         case OPCODE_EVALMESH1:

+            printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);

+            break;

+         case OPCODE_EVALMESH2:

+            printf("EvalMesh2 %d %d %d %d\n",

+                         n[1].i, n[2].i, n[3].i, n[4].i);

+            break;

+

+         case OPCODE_ATTR_1F_NV:

+            printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);

+            break;

+         case OPCODE_ATTR_2F_NV:

+            printf("ATTR_2F_NV attr %d: %f %f\n",

+                         n[1].i, n[2].f, n[3].f);

+            break;

+         case OPCODE_ATTR_3F_NV:

+            printf("ATTR_3F_NV attr %d: %f %f %f\n",

+                         n[1].i, n[2].f, n[3].f, n[4].f);

+            break;

+         case OPCODE_ATTR_4F_NV:

+            printf("ATTR_4F_NV attr %d: %f %f %f %f\n",

+                         n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);

+            break;

+         case OPCODE_ATTR_1F_ARB:

+            printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);

+            break;

+         case OPCODE_ATTR_2F_ARB:

+            printf("ATTR_2F_ARB attr %d: %f %f\n",

+                         n[1].i, n[2].f, n[3].f);

+            break;

+         case OPCODE_ATTR_3F_ARB:

+            printf("ATTR_3F_ARB attr %d: %f %f %f\n",

+                         n[1].i, n[2].f, n[3].f, n[4].f);

+            break;

+         case OPCODE_ATTR_4F_ARB:

+            printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",

+                         n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);

+            break;

+

+         case OPCODE_MATERIAL:

+            printf("MATERIAL %x %x: %f %f %f %f\n",

+                         n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);

+            break;

+         case OPCODE_BEGIN:

+            printf("BEGIN %x\n", n[1].i);

+            break;

+         case OPCODE_END:

+            printf("END\n");

+            break;

+         case OPCODE_RECTF:

+            printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,

+                         n[4].f);

+            break;

+         case OPCODE_EVAL_C1:

+            printf("EVAL_C1 %f\n", n[1].f);

+            break;

+         case OPCODE_EVAL_C2:

+            printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);

+            break;

+         case OPCODE_EVAL_P1:

+            printf("EVAL_P1 %d\n", n[1].i);

+            break;

+         case OPCODE_EVAL_P2:

+            printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);

+            break;

+

+         case OPCODE_PROVOKING_VERTEX:

+            printf("ProvokingVertex %s\n",

+                         _mesa_lookup_enum_by_nr(n[1].ui));

+            break;

+

+            /*

+             * meta opcodes/commands

+             */

+         case OPCODE_ERROR:

+            printf("Error: %s %s\n",

+                         enum_string(n[1].e), (const char *) n[2].data);

+            break;

+         case OPCODE_CONTINUE:

+            printf("DISPLAY-LIST-CONTINUE\n");

+            n = (Node *) n[1].next;

+            break;

+         case OPCODE_END_OF_LIST:

+            printf("END-LIST %u\n", list);

+            done = GL_TRUE;

+            break;

+         default:

+            if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {

+               printf

+                  ("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",

+                   opcode, (void *) n);

+               return;

+            }

+            else {

+               printf("command %d, %u operands\n", opcode,

+                            InstSize[opcode]);

+            }

+         }

+         /* increment n to point to next compiled command */

+         if (opcode != OPCODE_CONTINUE) {

+            n += InstSize[opcode];

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Clients may call this function to help debug display list problems.

+ * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,

+ * changed, or break in the future without notice.

+ */

+void

+mesa_print_display_list(GLuint list)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   print_list(ctx, list);

+}

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+void

+_mesa_save_vtxfmt_init(GLvertexformat * vfmt)

+{

+   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);

+

+   vfmt->Begin = save_Begin;

+

+   _MESA_INIT_DLIST_VTXFMT(vfmt, save_);

+

+   vfmt->Color3f = save_Color3f;

+   vfmt->Color3fv = save_Color3fv;

+   vfmt->Color4f = save_Color4f;

+   vfmt->Color4fv = save_Color4fv;

+   vfmt->EdgeFlag = save_EdgeFlag;

+   vfmt->End = save_End;

+

+   _MESA_INIT_EVAL_VTXFMT(vfmt, save_);

+

+   vfmt->FogCoordfEXT = save_FogCoordfEXT;

+   vfmt->FogCoordfvEXT = save_FogCoordfvEXT;

+   vfmt->Indexf = save_Indexf;

+   vfmt->Indexfv = save_Indexfv;

+   vfmt->Materialfv = save_Materialfv;

+   vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;

+   vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;

+   vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;

+   vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;

+   vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;

+   vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;

+   vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;

+   vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;

+   vfmt->Normal3f = save_Normal3f;

+   vfmt->Normal3fv = save_Normal3fv;

+   vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;

+   vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;

+   vfmt->TexCoord1f = save_TexCoord1f;

+   vfmt->TexCoord1fv = save_TexCoord1fv;

+   vfmt->TexCoord2f = save_TexCoord2f;

+   vfmt->TexCoord2fv = save_TexCoord2fv;

+   vfmt->TexCoord3f = save_TexCoord3f;

+   vfmt->TexCoord3fv = save_TexCoord3fv;

+   vfmt->TexCoord4f = save_TexCoord4f;

+   vfmt->TexCoord4fv = save_TexCoord4fv;

+   vfmt->Vertex2f = save_Vertex2f;

+   vfmt->Vertex2fv = save_Vertex2fv;

+   vfmt->Vertex3f = save_Vertex3f;

+   vfmt->Vertex3fv = save_Vertex3fv;

+   vfmt->Vertex4f = save_Vertex4f;

+   vfmt->Vertex4fv = save_Vertex4fv;

+   vfmt->VertexAttrib1fNV = save_VertexAttrib1fNV;

+   vfmt->VertexAttrib1fvNV = save_VertexAttrib1fvNV;

+   vfmt->VertexAttrib2fNV = save_VertexAttrib2fNV;

+   vfmt->VertexAttrib2fvNV = save_VertexAttrib2fvNV;

+   vfmt->VertexAttrib3fNV = save_VertexAttrib3fNV;

+   vfmt->VertexAttrib3fvNV = save_VertexAttrib3fvNV;

+   vfmt->VertexAttrib4fNV = save_VertexAttrib4fNV;

+   vfmt->VertexAttrib4fvNV = save_VertexAttrib4fvNV;

+   vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;

+   vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;

+   vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;

+   vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;

+   vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;

+   vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;

+   vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;

+   vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;

+

+   vfmt->Rectf = save_Rectf;

+

+   /* The driver is required to implement these as

+    * 1) They can probably do a better job.

+    * 2) A lot of new mechanisms would have to be added to this module

+    *     to support it.  That code would probably never get used,

+    *     because of (1).

+    */

+#if 0

+   vfmt->DrawArrays = 0;

+   vfmt->DrawElements = 0;

+   vfmt->DrawRangeElements = 0;

+   vfmt->MultiDrawElemementsEXT = 0;

+   vfmt->DrawElementsBaseVertex = 0;

+   vfmt->DrawRangeElementsBaseVertex = 0;

+   vfmt->MultiDrawElemementsBaseVertex = 0;

+#endif

+}

+

+

+void

+_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,

+                           const GLvertexformat *vfmt)

+{

+   SET_CallList(disp, vfmt->CallList);

+   SET_CallLists(disp, vfmt->CallLists);

+}

+

+

+void _mesa_init_dlist_dispatch(struct _glapi_table *disp)

+{

+   SET_CallList(disp, _mesa_CallList);

+   SET_CallLists(disp, _mesa_CallLists);

+

+   SET_DeleteLists(disp, _mesa_DeleteLists);

+   SET_EndList(disp, _mesa_EndList);

+   SET_GenLists(disp, _mesa_GenLists);

+   SET_IsList(disp, _mesa_IsList);

+   SET_ListBase(disp, _mesa_ListBase);

+   SET_NewList(disp, _mesa_NewList);

+}

+

+

+#endif /* FEATURE_dlist */

+

+

+/**

+ * Initialize display list state for given context.

+ */

+void

+_mesa_init_display_list(struct gl_context *ctx)

+{

+   static GLboolean tableInitialized = GL_FALSE;

+

+   /* zero-out the instruction size table, just once */

+   if (!tableInitialized) {

+      memset(InstSize, 0, sizeof(InstSize));

+      tableInitialized = GL_TRUE;

+   }

+

+   /* extension info */

+   ctx->ListExt = CALLOC_STRUCT(gl_list_extensions);

+

+   /* Display list */

+   ctx->ListState.CallDepth = 0;

+   ctx->ExecuteFlag = GL_TRUE;

+   ctx->CompileFlag = GL_FALSE;

+   ctx->ListState.CurrentBlock = NULL;

+   ctx->ListState.CurrentPos = 0;

+

+   /* Display List group */

+   ctx->List.ListBase = 0;

+

+#if FEATURE_dlist

+   _mesa_save_vtxfmt_init(&ctx->ListState.ListVtxfmt);

+#endif

+}

+

+

+void

+_mesa_free_display_list_data(struct gl_context *ctx)

+{

+   free(ctx->ListExt);

+   ctx->ListExt = NULL;

+}

diff --git a/mesalib/src/mesa/main/dlopen.c b/mesalib/src/mesa/main/dlopen.c
index 57a33292e..62d9023a9 100644
--- a/mesalib/src/mesa/main/dlopen.c
+++ b/mesalib/src/mesa/main/dlopen.c
@@ -51,7 +51,7 @@ _mesa_dlopen(const char *libname, int flags)
 #elif defined(_GNU_SOURCE)
    flags = RTLD_LAZY | RTLD_GLOBAL; /* Overriding flags at this time */
    return dlopen(libname, flags);
-#elif defined(__MINGW32__)
+#elif defined(__MINGW32__) | defined(_MSC_VER)
    return LoadLibraryA(libname);
 #else
    return NULL;
@@ -82,7 +82,7 @@ _mesa_dlsym(void *handle, const char *fname)
    u.v = dlsym(handle, fname2);
 #elif defined(_GNU_SOURCE)
    u.v = dlsym(handle, fname);
-#elif defined(__MINGW32__)
+#elif defined(__MINGW32__) | defined(_MSC_VER)
    u.v = (void *) GetProcAddress(handle, fname);
 #else
    u.v = NULL;
@@ -101,7 +101,7 @@ _mesa_dlclose(void *handle)
    (void) handle;
 #elif defined(_GNU_SOURCE)
    dlclose(handle);
-#elif defined(__MINGW32__)
+#elif defined(__MINGW32__) | defined(_MSC_VER)
    FreeLibrary(handle);
 #else
    (void) handle;
diff --git a/mesalib/src/mesa/main/drawpix.c b/mesalib/src/mesa/main/drawpix.c
index fb86036a1..ab6e61fe3 100644
--- a/mesalib/src/mesa/main/drawpix.c
+++ b/mesalib/src/mesa/main/drawpix.c
@@ -1,302 +1,302 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "glheader.h"
-#include "imports.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "drawpix.h"
-#include "enums.h"
-#include "feedback.h"
-#include "framebuffer.h"
-#include "mfeatures.h"
-#include "pbo.h"
-#include "readpix.h"
-#include "state.h"
-#include "dispatch.h"
-
-
-#if FEATURE_drawpix
-
-
-/*
- * Execute glDrawPixels
- */
-static void GLAPIENTRY
-_mesa_DrawPixels( GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDrawPixels(%d, %d, %s, %s, %p) // to %s at %d, %d\n",
-                  width, height,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type),
-                  pixels,
-                  _mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),
-                  IROUND(ctx->Current.RasterPos[0]),
-                  IROUND(ctx->Current.RasterPos[1]));
-
-
-   if (width < 0 || height < 0) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );
-      return;
-   }
-
-   /* We're not using the current vertex program, and the driver may install
-    * its own.  Note: this may dirty some state.
-    */
-   _mesa_set_vp_override(ctx, GL_TRUE);
-
-   /* Note: this call does state validation */
-   if (!_mesa_valid_to_render(ctx, "glDrawPixels")) {
-      goto end;      /* the error code was recorded */
-   }
-
-   if (_mesa_error_check_format_type(ctx, format, type, GL_TRUE)) {
-      goto end;      /* the error code was recorded */
-   }
-
-   if (!ctx->Current.RasterPosValid) {
-      goto end;  /* no-op, not an error */
-   }
-
-   if (ctx->RenderMode == GL_RENDER) {
-      if (width > 0 && height > 0) {
-         /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
-         GLint x = IROUND(ctx->Current.RasterPos[0]);
-         GLint y = IROUND(ctx->Current.RasterPos[1]);
-
-         if (ctx->Unpack.BufferObj->Name) {
-            /* unpack from PBO */
-            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
-                                           format, type, pixels)) {
-               _mesa_error(ctx, GL_INVALID_OPERATION,
-                           "glDrawPixels(invalid PBO access)");
-               goto end;
-            }
-            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
-               /* buffer is mapped - that's an error */
-               _mesa_error(ctx, GL_INVALID_OPERATION,
-                           "glDrawPixels(PBO is mapped)");
-               goto end;
-            }
-         }
-
-         ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
-                                &ctx->Unpack, pixels);
-      }
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      /* Feedback the current raster pos info */
-      FLUSH_CURRENT( ctx, 0 );
-      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
-      _mesa_feedback_vertex( ctx,
-                             ctx->Current.RasterPos,
-                             ctx->Current.RasterColor,
-                             ctx->Current.RasterTexCoords[0] );
-   }
-   else {
-      ASSERT(ctx->RenderMode == GL_SELECT);
-      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
-   }
-
-end:
-   _mesa_set_vp_override(ctx, GL_FALSE);
-}
-
-
-static void GLAPIENTRY
-_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
-                  GLenum type )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx,
-                  "glCopyPixels(%d, %d, %d, %d, %s) // from %s to %s at %d, %d\n",
-                  srcx, srcy, width, height,
-                  _mesa_lookup_enum_by_nr(type),
-                  _mesa_lookup_enum_by_nr(ctx->ReadBuffer->ColorReadBuffer),
-                  _mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),
-                  IROUND(ctx->Current.RasterPos[0]),
-                  IROUND(ctx->Current.RasterPos[1]));
-
-   if (width < 0 || height < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");
-      return;
-   }
-
-   /* Note: more detailed 'type' checking is done by the
-    * _mesa_source/dest_buffer_exists() calls below.  That's where we
-    * check if the stencil buffer exists, etc.
-    */
-   if (type != GL_COLOR &&
-       type != GL_DEPTH &&
-       type != GL_STENCIL &&
-       type != GL_DEPTH_STENCIL) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyPixels(type=%s)",
-                  _mesa_lookup_enum_by_nr(type));
-      return;
-   }
-
-   /* We're not using the current vertex program, and the driver may install
-    * it's own.  Note: this may dirty some state.
-    */
-   _mesa_set_vp_override(ctx, GL_TRUE);
-
-   /* Note: this call does state validation */
-   if (!_mesa_valid_to_render(ctx, "glCopyPixels")) {
-      goto end;      /* the error code was recorded */
-   }
-
-   /* Check read buffer's status (draw buffer was already checked) */
-   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "glCopyPixels(incomplete framebuffer)" );
-      goto end;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, type) ||
-       !_mesa_dest_buffer_exists(ctx, type)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyPixels(missing source or dest buffer)");
-      goto end;
-   }
-
-   if (!ctx->Current.RasterPosValid || width ==0 || height == 0) {
-      goto end; /* no-op, not an error */
-   }
-
-   if (ctx->RenderMode == GL_RENDER) {
-      /* Round to satisfy conformance tests (matches SGI's OpenGL) */
-      if (width > 0 && height > 0) {
-         GLint destx = IROUND(ctx->Current.RasterPos[0]);
-         GLint desty = IROUND(ctx->Current.RasterPos[1]);
-         ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
-                                 type );
-      }
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      FLUSH_CURRENT( ctx, 0 );
-      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
-      _mesa_feedback_vertex( ctx, 
-                             ctx->Current.RasterPos,
-                             ctx->Current.RasterColor,
-                             ctx->Current.RasterTexCoords[0] );
-   }
-   else {
-      ASSERT(ctx->RenderMode == GL_SELECT);
-      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
-   }
-
-end:
-   _mesa_set_vp_override(ctx, GL_FALSE);
-}
-
-
-static void GLAPIENTRY
-_mesa_Bitmap( GLsizei width, GLsizei height,
-              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
-              const GLubyte *bitmap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (width < 0 || height < 0) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
-      return;
-   }
-
-   if (!ctx->Current.RasterPosValid) {
-      return;    /* do nothing */
-   }
-
-   /* Note: this call does state validation */
-   if (!_mesa_valid_to_render(ctx, "glBitmap")) {
-      /* the error code was recorded */
-      return;
-   }
-
-   if (ctx->RenderMode == GL_RENDER) {
-      /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
-      if (width > 0 && height > 0) {
-         const GLfloat epsilon = 0.0001F;
-         GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig);
-         GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig);
-
-         if (ctx->Unpack.BufferObj->Name) {
-            /* unpack from PBO */
-            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
-                                           GL_COLOR_INDEX, GL_BITMAP,
-                                           (GLvoid *) bitmap)) {
-               _mesa_error(ctx, GL_INVALID_OPERATION,
-                           "glBitmap(invalid PBO access)");
-               return;
-            }
-            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
-               /* buffer is mapped - that's an error */
-               _mesa_error(ctx, GL_INVALID_OPERATION,
-                           "glBitmap(PBO is mapped)");
-               return;
-            }
-         }
-
-         ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
-      }
-   }
-#if _HAVE_FULL_GL
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      FLUSH_CURRENT(ctx, 0);
-      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
-      _mesa_feedback_vertex( ctx,
-                             ctx->Current.RasterPos,
-                             ctx->Current.RasterColor,
-                             ctx->Current.RasterTexCoords[0] );
-   }
-   else {
-      ASSERT(ctx->RenderMode == GL_SELECT);
-      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
-   }
-#endif
-
-   /* update raster position */
-   ctx->Current.RasterPos[0] += xmove;
-   ctx->Current.RasterPos[1] += ymove;
-}
-
-
-void
-_mesa_init_drawpix_dispatch(struct _glapi_table *disp)
-{
-   SET_Bitmap(disp, _mesa_Bitmap);
-   SET_CopyPixels(disp, _mesa_CopyPixels);
-   SET_DrawPixels(disp, _mesa_DrawPixels);
-}
-
-
-#endif /* FEATURE_drawpix */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+#include "glheader.h"

+#include "imports.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "drawpix.h"

+#include "enums.h"

+#include "feedback.h"

+#include "framebuffer.h"

+#include "mfeatures.h"

+#include "pbo.h"

+#include "readpix.h"

+#include "state.h"

+#include "dispatch.h"

+

+

+#if FEATURE_drawpix

+

+

+/*

+ * Execute glDrawPixels

+ */

+static void GLAPIENTRY

+_mesa_DrawPixels( GLsizei width, GLsizei height,

+                  GLenum format, GLenum type, const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDrawPixels(%d, %d, %s, %s, %p) // to %s at %d, %d\n",

+                  width, height,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type),

+                  pixels,

+                  _mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),

+                  IROUND(ctx->Current.RasterPos[0]),

+                  IROUND(ctx->Current.RasterPos[1]));

+

+

+   if (width < 0 || height < 0) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );

+      return;

+   }

+

+   /* We're not using the current vertex program, and the driver may install

+    * its own.  Note: this may dirty some state.

+    */

+   _mesa_set_vp_override(ctx, GL_TRUE);

+

+   /* Note: this call does state validation */

+   if (!_mesa_valid_to_render(ctx, "glDrawPixels")) {

+      goto end;      /* the error code was recorded */

+   }

+

+   if (_mesa_error_check_format_type(ctx, format, type, GL_TRUE)) {

+      goto end;      /* the error code was recorded */

+   }

+

+   if (!ctx->Current.RasterPosValid) {

+      goto end;  /* no-op, not an error */

+   }

+

+   if (ctx->RenderMode == GL_RENDER) {

+      if (width > 0 && height > 0) {

+         /* Round, to satisfy conformance tests (matches SGI's OpenGL) */

+         GLint x = IROUND(ctx->Current.RasterPos[0]);

+         GLint y = IROUND(ctx->Current.RasterPos[1]);

+

+         if (ctx->Unpack.BufferObj->Name) {

+            /* unpack from PBO */

+            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,

+                                           format, type, pixels)) {

+               _mesa_error(ctx, GL_INVALID_OPERATION,

+                           "glDrawPixels(invalid PBO access)");

+               goto end;

+            }

+            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {

+               /* buffer is mapped - that's an error */

+               _mesa_error(ctx, GL_INVALID_OPERATION,

+                           "glDrawPixels(PBO is mapped)");

+               goto end;

+            }

+         }

+

+         ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,

+                                &ctx->Unpack, pixels);

+      }

+   }

+   else if (ctx->RenderMode == GL_FEEDBACK) {

+      /* Feedback the current raster pos info */

+      FLUSH_CURRENT( ctx, 0 );

+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );

+      _mesa_feedback_vertex( ctx,

+                             ctx->Current.RasterPos,

+                             ctx->Current.RasterColor,

+                             ctx->Current.RasterTexCoords[0] );

+   }

+   else {

+      ASSERT(ctx->RenderMode == GL_SELECT);

+      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */

+   }

+

+end:

+   _mesa_set_vp_override(ctx, GL_FALSE);

+}

+

+

+static void GLAPIENTRY

+_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,

+                  GLenum type )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx,

+                  "glCopyPixels(%d, %d, %d, %d, %s) // from %s to %s at %d, %d\n",

+                  srcx, srcy, width, height,

+                  _mesa_lookup_enum_by_nr(type),

+                  _mesa_lookup_enum_by_nr(ctx->ReadBuffer->ColorReadBuffer),

+                  _mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),

+                  IROUND(ctx->Current.RasterPos[0]),

+                  IROUND(ctx->Current.RasterPos[1]));

+

+   if (width < 0 || height < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");

+      return;

+   }

+

+   /* Note: more detailed 'type' checking is done by the

+    * _mesa_source/dest_buffer_exists() calls below.  That's where we

+    * check if the stencil buffer exists, etc.

+    */

+   if (type != GL_COLOR &&

+       type != GL_DEPTH &&

+       type != GL_STENCIL &&

+       type != GL_DEPTH_STENCIL) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyPixels(type=%s)",

+                  _mesa_lookup_enum_by_nr(type));

+      return;

+   }

+

+   /* We're not using the current vertex program, and the driver may install

+    * it's own.  Note: this may dirty some state.

+    */

+   _mesa_set_vp_override(ctx, GL_TRUE);

+

+   /* Note: this call does state validation */

+   if (!_mesa_valid_to_render(ctx, "glCopyPixels")) {

+      goto end;      /* the error code was recorded */

+   }

+

+   /* Check read buffer's status (draw buffer was already checked) */

+   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                  "glCopyPixels(incomplete framebuffer)" );

+      goto end;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, type) ||

+       !_mesa_dest_buffer_exists(ctx, type)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyPixels(missing source or dest buffer)");

+      goto end;

+   }

+

+   if (!ctx->Current.RasterPosValid || width ==0 || height == 0) {

+      goto end; /* no-op, not an error */

+   }

+

+   if (ctx->RenderMode == GL_RENDER) {

+      /* Round to satisfy conformance tests (matches SGI's OpenGL) */

+      if (width > 0 && height > 0) {

+         GLint destx = IROUND(ctx->Current.RasterPos[0]);

+         GLint desty = IROUND(ctx->Current.RasterPos[1]);

+         ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,

+                                 type );

+      }

+   }

+   else if (ctx->RenderMode == GL_FEEDBACK) {

+      FLUSH_CURRENT( ctx, 0 );

+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );

+      _mesa_feedback_vertex( ctx, 

+                             ctx->Current.RasterPos,

+                             ctx->Current.RasterColor,

+                             ctx->Current.RasterTexCoords[0] );

+   }

+   else {

+      ASSERT(ctx->RenderMode == GL_SELECT);

+      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */

+   }

+

+end:

+   _mesa_set_vp_override(ctx, GL_FALSE);

+}

+

+

+static void GLAPIENTRY

+_mesa_Bitmap( GLsizei width, GLsizei height,

+              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,

+              const GLubyte *bitmap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (width < 0 || height < 0) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );

+      return;

+   }

+

+   if (!ctx->Current.RasterPosValid) {

+      return;    /* do nothing */

+   }

+

+   /* Note: this call does state validation */

+   if (!_mesa_valid_to_render(ctx, "glBitmap")) {

+      /* the error code was recorded */

+      return;

+   }

+

+   if (ctx->RenderMode == GL_RENDER) {

+      /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */

+      if (width > 0 && height > 0) {

+         const GLfloat epsilon = 0.0001F;

+         GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig);

+         GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig);

+

+         if (ctx->Unpack.BufferObj->Name) {

+            /* unpack from PBO */

+            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,

+                                           GL_COLOR_INDEX, GL_BITMAP,

+                                           (GLvoid *) bitmap)) {

+               _mesa_error(ctx, GL_INVALID_OPERATION,

+                           "glBitmap(invalid PBO access)");

+               return;

+            }

+            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {

+               /* buffer is mapped - that's an error */

+               _mesa_error(ctx, GL_INVALID_OPERATION,

+                           "glBitmap(PBO is mapped)");

+               return;

+            }

+         }

+

+         ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );

+      }

+   }

+#if _HAVE_FULL_GL

+   else if (ctx->RenderMode == GL_FEEDBACK) {

+      FLUSH_CURRENT(ctx, 0);

+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );

+      _mesa_feedback_vertex( ctx,

+                             ctx->Current.RasterPos,

+                             ctx->Current.RasterColor,

+                             ctx->Current.RasterTexCoords[0] );

+   }

+   else {

+      ASSERT(ctx->RenderMode == GL_SELECT);

+      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */

+   }

+#endif

+

+   /* update raster position */

+   ctx->Current.RasterPos[0] += xmove;

+   ctx->Current.RasterPos[1] += ymove;

+}

+

+

+void

+_mesa_init_drawpix_dispatch(struct _glapi_table *disp)

+{

+   SET_Bitmap(disp, _mesa_Bitmap);

+   SET_CopyPixels(disp, _mesa_CopyPixels);

+   SET_DrawPixels(disp, _mesa_DrawPixels);

+}

+

+

+#endif /* FEATURE_drawpix */

diff --git a/mesalib/src/mesa/main/enable.c b/mesalib/src/mesa/main/enable.c
index f24709241..32c3c8713 100644
--- a/mesalib/src/mesa/main/enable.c
+++ b/mesalib/src/mesa/main/enable.c
@@ -1,1487 +1,1487 @@
-/**
- * \file enable.c
- * Enable/disable/query GL capabilities.
- */
-
-/*
- * Mesa 3-D graphics library
- * Version:  7.0.3
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "context.h"
-#include "enable.h"
-#include "light.h"
-#include "simple_list.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "enums.h"
-#include "api_arrayelt.h"
-#include "texstate.h"
-
-
-
-#define CHECK_EXTENSION(EXTNAME, CAP)					\
-   if (!ctx->Extensions.EXTNAME) {					\
-      goto invalid_enum_error;						\
-   }
-
-
-/**
- * Helper to enable/disable client-side state.
- */
-static void
-client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
-{
-   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-   GLuint flag;
-   GLboolean *var;
-
-   switch (cap) {
-      case GL_VERTEX_ARRAY:
-         var = &arrayObj->Vertex.Enabled;
-         flag = _NEW_ARRAY_VERTEX;
-         break;
-      case GL_NORMAL_ARRAY:
-         var = &arrayObj->Normal.Enabled;
-         flag = _NEW_ARRAY_NORMAL;
-         break;
-      case GL_COLOR_ARRAY:
-         var = &arrayObj->Color.Enabled;
-         flag = _NEW_ARRAY_COLOR0;
-         break;
-      case GL_INDEX_ARRAY:
-         var = &arrayObj->Index.Enabled;
-         flag = _NEW_ARRAY_INDEX;
-         break;
-      case GL_TEXTURE_COORD_ARRAY:
-         var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
-         flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
-         break;
-      case GL_EDGE_FLAG_ARRAY:
-         var = &arrayObj->EdgeFlag.Enabled;
-         flag = _NEW_ARRAY_EDGEFLAG;
-         break;
-      case GL_FOG_COORDINATE_ARRAY_EXT:
-         var = &arrayObj->FogCoord.Enabled;
-         flag = _NEW_ARRAY_FOGCOORD;
-         break;
-      case GL_SECONDARY_COLOR_ARRAY_EXT:
-         var = &arrayObj->SecondaryColor.Enabled;
-         flag = _NEW_ARRAY_COLOR1;
-         break;
-
-#if FEATURE_point_size_array
-      case GL_POINT_SIZE_ARRAY_OES:
-         var = &arrayObj->PointSize.Enabled;
-         flag = _NEW_ARRAY_POINT_SIZE;
-         break;
-#endif
-
-#if FEATURE_NV_vertex_program
-      case GL_VERTEX_ATTRIB_ARRAY0_NV:
-      case GL_VERTEX_ATTRIB_ARRAY1_NV:
-      case GL_VERTEX_ATTRIB_ARRAY2_NV:
-      case GL_VERTEX_ATTRIB_ARRAY3_NV:
-      case GL_VERTEX_ATTRIB_ARRAY4_NV:
-      case GL_VERTEX_ATTRIB_ARRAY5_NV:
-      case GL_VERTEX_ATTRIB_ARRAY6_NV:
-      case GL_VERTEX_ATTRIB_ARRAY7_NV:
-      case GL_VERTEX_ATTRIB_ARRAY8_NV:
-      case GL_VERTEX_ATTRIB_ARRAY9_NV:
-      case GL_VERTEX_ATTRIB_ARRAY10_NV:
-      case GL_VERTEX_ATTRIB_ARRAY11_NV:
-      case GL_VERTEX_ATTRIB_ARRAY12_NV:
-      case GL_VERTEX_ATTRIB_ARRAY13_NV:
-      case GL_VERTEX_ATTRIB_ARRAY14_NV:
-      case GL_VERTEX_ATTRIB_ARRAY15_NV:
-         CHECK_EXTENSION(NV_vertex_program, cap);
-         {
-            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
-            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
-            var = &arrayObj->VertexAttrib[n].Enabled;
-            flag = _NEW_ARRAY_ATTRIB(n);
-         }
-         break;
-#endif /* FEATURE_NV_vertex_program */
-
-      /* GL_NV_primitive_restart */
-      case GL_PRIMITIVE_RESTART_NV:
-	 if (!ctx->Extensions.NV_primitive_restart) {
-            goto invalid_enum_error;
-         }
-         var = &ctx->Array.PrimitiveRestart;
-         flag = 0;
-         break;
-
-      default:
-         goto invalid_enum_error;
-   }
-
-   if (*var == state)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_ARRAY);
-   ctx->Array.NewState |= flag;
-
-   _ae_invalidate_state(ctx, _NEW_ARRAY);
-
-   *var = state;
-
-   if (state)
-      ctx->Array.ArrayObj->_Enabled |= flag;
-   else
-      ctx->Array.ArrayObj->_Enabled &= ~flag;
-
-   if (ctx->Driver.Enable) {
-      ctx->Driver.Enable( ctx, cap, state );
-   }
-
-   return;
-
-invalid_enum_error:
-   _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",
-               state ? "Enable" : "Disable", cap);
-}
-
-
-/**
- * Enable GL capability.
- * \param cap  state to enable/disable.
- *
- * Get's the current context, assures that we're outside glBegin()/glEnd() and
- * calls client_state().
- */
-void GLAPIENTRY
-_mesa_EnableClientState( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   client_state( ctx, cap, GL_TRUE );
-}
-
-
-/**
- * Disable GL capability.
- * \param cap  state to enable/disable.
- *
- * Get's the current context, assures that we're outside glBegin()/glEnd() and
- * calls client_state().
- */
-void GLAPIENTRY
-_mesa_DisableClientState( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   client_state( ctx, cap, GL_FALSE );
-}
-
-
-#undef CHECK_EXTENSION
-#define CHECK_EXTENSION(EXTNAME, CAP)					\
-   if (!ctx->Extensions.EXTNAME) {					\
-      goto invalid_enum_error;						\
-   }
-
-#define CHECK_EXTENSION2(EXT1, EXT2, CAP)				\
-   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {		\
-      goto invalid_enum_error;						\
-   }
-
-
-
-/**
- * Return pointer to current texture unit for setting/getting coordinate
- * state.
- * Note that we'll set GL_INVALID_OPERATION if the active texture unit is
- * higher than the number of supported coordinate units.  And we'll return NULL.
- */
-static struct gl_texture_unit *
-get_texcoord_unit(struct gl_context *ctx)
-{
-   if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
-      return NULL;
-   }
-   else {
-      return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   }
-}
-
-
-/**
- * Helper function to enable or disable a texture target.
- * \param bit  one of the TEXTURE_x_BIT values
- * \return GL_TRUE if state is changing or GL_FALSE if no change
- */
-static GLboolean
-enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
-{
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   const GLbitfield newenabled = state
-      ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
-
-   if (texUnit->Enabled == newenabled)
-       return GL_FALSE;
-
-   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-   texUnit->Enabled = newenabled;
-   return GL_TRUE;
-}
-
-
-/**
- * Helper function to enable or disable state.
- *
- * \param ctx GL context.
- * \param cap  the state to enable/disable
- * \param state whether to enable or disable the specified capability.
- *
- * Updates the current context and flushes the vertices as needed. For
- * capabilities associated with extensions it verifies that those extensions
- * are effectivly present before updating. Notifies the driver via
- * dd_function_table::Enable.
- */
-void
-_mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
-{
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "%s %s (newstate is %x)\n",
-                  state ? "glEnable" : "glDisable",
-                  _mesa_lookup_enum_by_nr(cap),
-                  ctx->NewState);
-
-   switch (cap) {
-      case GL_ALPHA_TEST:
-         if (ctx->Color.AlphaEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_COLOR);
-         ctx->Color.AlphaEnabled = state;
-         break;
-      case GL_AUTO_NORMAL:
-         if (ctx->Eval.AutoNormal == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.AutoNormal = state;
-         break;
-      case GL_BLEND:
-         {
-            GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
-            if (newEnabled != ctx->Color.BlendEnabled) {
-               FLUSH_VERTICES(ctx, _NEW_COLOR);
-               ctx->Color.BlendEnabled = newEnabled;
-            }
-         }
-         break;
-#if FEATURE_userclip
-      case GL_CLIP_PLANE0:
-      case GL_CLIP_PLANE1:
-      case GL_CLIP_PLANE2:
-      case GL_CLIP_PLANE3:
-      case GL_CLIP_PLANE4:
-      case GL_CLIP_PLANE5:
-         {
-            const GLuint p = cap - GL_CLIP_PLANE0;
-
-            if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p))
-               return;
-
-            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-
-            if (state) {
-               ctx->Transform.ClipPlanesEnabled |= (1 << p);
-
-               if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))
-                  _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
-
-               /* This derived state also calculated in clip.c and
-                * from _mesa_update_state() on changes to EyeUserPlane
-                * and ctx->ProjectionMatrix respectively.
-                */
-               _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
-                                    ctx->Transform.EyeUserPlane[p],
-                                    ctx->ProjectionMatrixStack.Top->inv );
-            }
-            else {
-               ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
-            }               
-         }
-         break;
-#endif
-      case GL_COLOR_MATERIAL:
-         if (ctx->Light.ColorMaterialEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_LIGHT);
-         FLUSH_CURRENT(ctx, 0);
-         ctx->Light.ColorMaterialEnabled = state;
-         if (state) {
-            _mesa_update_color_material( ctx,
-                                  ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
-         }
-         break;
-      case GL_CULL_FACE:
-         if (ctx->Polygon.CullFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.CullFlag = state;
-         break;
-      case GL_DEPTH_TEST:
-         if (ctx->Depth.Test == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_DEPTH);
-         ctx->Depth.Test = state;
-         break;
-      case GL_DITHER:
-         if (ctx->Color.DitherFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_COLOR);
-         ctx->Color.DitherFlag = state;
-         break;
-      case GL_FOG:
-         if (ctx->Fog.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_FOG);
-         ctx->Fog.Enabled = state;
-         break;
-      case GL_LIGHT0:
-      case GL_LIGHT1:
-      case GL_LIGHT2:
-      case GL_LIGHT3:
-      case GL_LIGHT4:
-      case GL_LIGHT5:
-      case GL_LIGHT6:
-      case GL_LIGHT7:
-         if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_LIGHT);
-         ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
-         if (state) {
-            insert_at_tail(&ctx->Light.EnabledList,
-                           &ctx->Light.Light[cap-GL_LIGHT0]);
-         }
-         else {
-            remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
-         }
-         break;
-      case GL_LIGHTING:
-         if (ctx->Light.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_LIGHT);
-         ctx->Light.Enabled = state;
-         if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
-            ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
-         else
-            ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
-         break;
-      case GL_LINE_SMOOTH:
-         if (ctx->Line.SmoothFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_LINE);
-         ctx->Line.SmoothFlag = state;
-         ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
-         break;
-      case GL_LINE_STIPPLE:
-         if (ctx->Line.StippleFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_LINE);
-         ctx->Line.StippleFlag = state;
-         ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
-         break;
-      case GL_INDEX_LOGIC_OP:
-         if (ctx->Color.IndexLogicOpEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_COLOR);
-         ctx->Color.IndexLogicOpEnabled = state;
-         break;
-      case GL_COLOR_LOGIC_OP:
-         if (ctx->Color.ColorLogicOpEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_COLOR);
-         ctx->Color.ColorLogicOpEnabled = state;
-         break;
-      case GL_MAP1_COLOR_4:
-         if (ctx->Eval.Map1Color4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1Color4 = state;
-         break;
-      case GL_MAP1_INDEX:
-         if (ctx->Eval.Map1Index == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1Index = state;
-         break;
-      case GL_MAP1_NORMAL:
-         if (ctx->Eval.Map1Normal == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1Normal = state;
-         break;
-      case GL_MAP1_TEXTURE_COORD_1:
-         if (ctx->Eval.Map1TextureCoord1 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1TextureCoord1 = state;
-         break;
-      case GL_MAP1_TEXTURE_COORD_2:
-         if (ctx->Eval.Map1TextureCoord2 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1TextureCoord2 = state;
-         break;
-      case GL_MAP1_TEXTURE_COORD_3:
-         if (ctx->Eval.Map1TextureCoord3 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1TextureCoord3 = state;
-         break;
-      case GL_MAP1_TEXTURE_COORD_4:
-         if (ctx->Eval.Map1TextureCoord4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1TextureCoord4 = state;
-         break;
-      case GL_MAP1_VERTEX_3:
-         if (ctx->Eval.Map1Vertex3 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1Vertex3 = state;
-         break;
-      case GL_MAP1_VERTEX_4:
-         if (ctx->Eval.Map1Vertex4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map1Vertex4 = state;
-         break;
-      case GL_MAP2_COLOR_4:
-         if (ctx->Eval.Map2Color4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2Color4 = state;
-         break;
-      case GL_MAP2_INDEX:
-         if (ctx->Eval.Map2Index == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2Index = state;
-         break;
-      case GL_MAP2_NORMAL:
-         if (ctx->Eval.Map2Normal == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2Normal = state;
-         break;
-      case GL_MAP2_TEXTURE_COORD_1:
-         if (ctx->Eval.Map2TextureCoord1 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2TextureCoord1 = state;
-         break;
-      case GL_MAP2_TEXTURE_COORD_2:
-         if (ctx->Eval.Map2TextureCoord2 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2TextureCoord2 = state;
-         break;
-      case GL_MAP2_TEXTURE_COORD_3:
-         if (ctx->Eval.Map2TextureCoord3 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2TextureCoord3 = state;
-         break;
-      case GL_MAP2_TEXTURE_COORD_4:
-         if (ctx->Eval.Map2TextureCoord4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2TextureCoord4 = state;
-         break;
-      case GL_MAP2_VERTEX_3:
-         if (ctx->Eval.Map2Vertex3 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2Vertex3 = state;
-         break;
-      case GL_MAP2_VERTEX_4:
-         if (ctx->Eval.Map2Vertex4 == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_EVAL);
-         ctx->Eval.Map2Vertex4 = state;
-         break;
-      case GL_NORMALIZE:
-         if (ctx->Transform.Normalize == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-         ctx->Transform.Normalize = state;
-         break;
-      case GL_POINT_SMOOTH:
-         if (ctx->Point.SmoothFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POINT);
-         ctx->Point.SmoothFlag = state;
-         ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
-         break;
-      case GL_POLYGON_SMOOTH:
-         if (ctx->Polygon.SmoothFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.SmoothFlag = state;
-         ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
-         break;
-      case GL_POLYGON_STIPPLE:
-         if (ctx->Polygon.StippleFlag == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.StippleFlag = state;
-         ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
-         break;
-      case GL_POLYGON_OFFSET_POINT:
-         if (ctx->Polygon.OffsetPoint == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.OffsetPoint = state;
-         break;
-      case GL_POLYGON_OFFSET_LINE:
-         if (ctx->Polygon.OffsetLine == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.OffsetLine = state;
-         break;
-      case GL_POLYGON_OFFSET_FILL:
-         /*case GL_POLYGON_OFFSET_EXT:*/
-         if (ctx->Polygon.OffsetFill == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POLYGON);
-         ctx->Polygon.OffsetFill = state;
-         break;
-      case GL_RESCALE_NORMAL_EXT:
-         if (ctx->Transform.RescaleNormals == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-         ctx->Transform.RescaleNormals = state;
-         break;
-      case GL_SCISSOR_TEST:
-         if (ctx->Scissor.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_SCISSOR);
-         ctx->Scissor.Enabled = state;
-         break;
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         if (ctx->Texture.SharedPalette == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         ctx->Texture.SharedPalette = state;
-         break;
-      case GL_STENCIL_TEST:
-         if (ctx->Stencil.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_STENCIL);
-         ctx->Stencil.Enabled = state;
-         break;
-      case GL_TEXTURE_1D:
-         if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
-            return;
-         }
-         break;
-      case GL_TEXTURE_2D:
-         if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
-            return;
-         }
-         break;
-      case GL_TEXTURE_3D:
-         if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
-            return;
-         }
-         break;
-      case GL_TEXTURE_GEN_Q:
-         {
-            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
-               if (state)
-                  newenabled |= Q_BIT;
-               if (texUnit->TexGenEnabled == newenabled)
-                  return;
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->TexGenEnabled = newenabled;
-            }
-         }
-         break;
-      case GL_TEXTURE_GEN_R:
-         {
-            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
-               if (state)
-                  newenabled |= R_BIT;
-               if (texUnit->TexGenEnabled == newenabled)
-                  return;
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->TexGenEnabled = newenabled;
-            }
-         }
-         break;
-      case GL_TEXTURE_GEN_S:
-         {
-            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
-               if (state)
-                  newenabled |= S_BIT;
-               if (texUnit->TexGenEnabled == newenabled)
-                  return;
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->TexGenEnabled = newenabled;
-            }
-         }
-         break;
-      case GL_TEXTURE_GEN_T:
-         {
-            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
-               if (state)
-                  newenabled |= T_BIT;
-               if (texUnit->TexGenEnabled == newenabled)
-                  return;
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->TexGenEnabled = newenabled;
-            }
-         }
-         break;
-
-#if FEATURE_ES1
-      case GL_TEXTURE_GEN_STR_OES:
-	 /* disable S, T, and R at the same time */
-	 {
-            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               GLuint newenabled =
-		  texUnit->TexGenEnabled & ~STR_BITS;
-               if (state)
-                  newenabled |= STR_BITS;
-               if (texUnit->TexGenEnabled == newenabled)
-                  return;
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->TexGenEnabled = newenabled;
-            }
-         }
-         break;
-#endif
-
-      /*
-       * CLIENT STATE!!!
-       */
-      case GL_VERTEX_ARRAY:
-      case GL_NORMAL_ARRAY:
-      case GL_COLOR_ARRAY:
-      case GL_INDEX_ARRAY:
-      case GL_TEXTURE_COORD_ARRAY:
-      case GL_EDGE_FLAG_ARRAY:
-      case GL_FOG_COORDINATE_ARRAY_EXT:
-      case GL_SECONDARY_COLOR_ARRAY_EXT:
-      case GL_POINT_SIZE_ARRAY_OES:
-         client_state( ctx, cap, state );
-         return;
-
-      /* GL_ARB_texture_cube_map */
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         CHECK_EXTENSION(ARB_texture_cube_map, cap);
-         if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
-            return;
-         }
-         break;
-
-      /* GL_EXT_secondary_color */
-      case GL_COLOR_SUM_EXT:
-         CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
-         if (ctx->Fog.ColorSumEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_FOG);
-         ctx->Fog.ColorSumEnabled = state;
-         break;
-
-      /* GL_ARB_multisample */
-      case GL_MULTISAMPLE_ARB:
-         if (ctx->Multisample.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-         ctx->Multisample.Enabled = state;
-         break;
-      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Multisample.SampleAlphaToCoverage == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-         ctx->Multisample.SampleAlphaToCoverage = state;
-         break;
-      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Multisample.SampleAlphaToOne == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-         ctx->Multisample.SampleAlphaToOne = state;
-         break;
-      case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Multisample.SampleCoverage == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-         ctx->Multisample.SampleCoverage = state;
-         break;
-      case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Multisample.SampleCoverageInvert == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-         ctx->Multisample.SampleCoverageInvert = state;
-         break;
-
-      /* GL_IBM_rasterpos_clip */
-      case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         CHECK_EXTENSION(IBM_rasterpos_clip, cap);
-         if (ctx->Transform.RasterPositionUnclipped == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-         ctx->Transform.RasterPositionUnclipped = state;
-         break;
-
-      /* GL_NV_point_sprite */
-      case GL_POINT_SPRITE_NV:
-         CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
-         if (ctx->Point.PointSprite == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_POINT);
-         ctx->Point.PointSprite = state;
-         break;
-
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-      case GL_VERTEX_PROGRAM_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
-         if (ctx->VertexProgram.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_PROGRAM); 
-         ctx->VertexProgram.Enabled = state;
-         break;
-      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
-         if (ctx->VertexProgram.PointSizeEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-         ctx->VertexProgram.PointSizeEnabled = state;
-         break;
-      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
-         if (ctx->VertexProgram.TwoSideEnabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_PROGRAM); 
-         ctx->VertexProgram.TwoSideEnabled = state;
-         break;
-#endif
-#if FEATURE_NV_vertex_program
-      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program, cap);
-         {
-            const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
-            FLUSH_VERTICES(ctx, _NEW_EVAL);
-            ctx->Eval.Map1Attrib[map] = state;
-         }
-         break;
-      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program, cap);
-         {
-            const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
-            FLUSH_VERTICES(ctx, _NEW_EVAL);
-            ctx->Eval.Map2Attrib[map] = state;
-         }
-         break;
-#endif /* FEATURE_NV_vertex_program */
-
-#if FEATURE_NV_fragment_program
-      case GL_FRAGMENT_PROGRAM_NV:
-         CHECK_EXTENSION(NV_fragment_program, cap);
-         if (ctx->FragmentProgram.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-         ctx->FragmentProgram.Enabled = state;
-         break;
-#endif /* FEATURE_NV_fragment_program */
-
-      /* GL_NV_texture_rectangle */
-      case GL_TEXTURE_RECTANGLE_NV:
-         CHECK_EXTENSION(NV_texture_rectangle, cap);
-         if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
-            return;
-         }
-         break;
-
-      /* GL_EXT_stencil_two_side */
-      case GL_STENCIL_TEST_TWO_SIDE_EXT:
-         CHECK_EXTENSION(EXT_stencil_two_side, cap);
-         if (ctx->Stencil.TestTwoSide == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_STENCIL);
-         ctx->Stencil.TestTwoSide = state;
-         if (state) {
-            ctx->Stencil._BackFace = 2;
-            ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
-         } else {
-            ctx->Stencil._BackFace = 1;
-            ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
-         }
-         break;
-
-#if FEATURE_ARB_fragment_program
-      case GL_FRAGMENT_PROGRAM_ARB:
-         CHECK_EXTENSION(ARB_fragment_program, cap);
-         if (ctx->FragmentProgram.Enabled == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-         ctx->FragmentProgram.Enabled = state;
-         break;
-#endif /* FEATURE_ARB_fragment_program */
-
-      /* GL_EXT_depth_bounds_test */
-      case GL_DEPTH_BOUNDS_TEST_EXT:
-         CHECK_EXTENSION(EXT_depth_bounds_test, cap);
-         if (ctx->Depth.BoundsTest == state)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_DEPTH);
-         ctx->Depth.BoundsTest = state;
-         break;
-
-      case GL_DEPTH_CLAMP:
-         if (ctx->Transform.DepthClamp == state)
-            return;
-	 CHECK_EXTENSION(ARB_depth_clamp, cap);
-         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-	 ctx->Transform.DepthClamp = state;
-	 break;
-
-#if FEATURE_ATI_fragment_shader
-      case GL_FRAGMENT_SHADER_ATI:
-        CHECK_EXTENSION(ATI_fragment_shader, cap);
-	if (ctx->ATIFragmentShader.Enabled == state)
-	  return;
-	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-	ctx->ATIFragmentShader.Enabled = state;
-        break;
-#endif
-
-      /* GL_MESA_texture_array */
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         CHECK_EXTENSION(MESA_texture_array, cap);
-         if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
-            return;
-         }
-         break;
-
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         CHECK_EXTENSION(MESA_texture_array, cap);
-         if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
-            return;
-         }
-         break;
-
-      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
-	 CHECK_EXTENSION(ARB_seamless_cube_map, cap);
-	 ctx->Texture.CubeMapSeamless = state;
-	 break;
-
-#if FEATURE_EXT_transform_feedback
-      case GL_RASTERIZER_DISCARD:
-	 CHECK_EXTENSION(EXT_transform_feedback, cap);
-         if (ctx->TransformFeedback.RasterDiscard != state) {
-            ctx->TransformFeedback.RasterDiscard = state;
-            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-         }
-         break;
-#endif
-
-      /* GL 3.1 primitive restart.  Note: this enum is different from
-       * GL_PRIMITIVE_RESTART_NV (which is client state).
-       */
-      case GL_PRIMITIVE_RESTART:
-         if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
-            goto invalid_enum_error;
-         }
-         if (ctx->Array.PrimitiveRestart != state) {
-            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-            ctx->Array.PrimitiveRestart = state;
-         }
-         break;
-
-      /* GL3.0 - GL_framebuffer_sRGB */
-      case GL_FRAMEBUFFER_SRGB_EXT:
-         CHECK_EXTENSION(EXT_framebuffer_sRGB, cap);
-         FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-         ctx->Color.sRGBEnabled = state;
-         break;
-
-      default:
-         goto invalid_enum_error;
-   }
-
-   if (ctx->Driver.Enable) {
-      ctx->Driver.Enable( ctx, cap, state );
-   }
-
-   return;
-
-invalid_enum_error:
-   _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
-               state ? "Enable" : "Disable", cap);
-}
-
-
-/**
- * Enable GL capability.  Called by glEnable()
- * \param cap  state to enable.
- */
-void GLAPIENTRY
-_mesa_Enable( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   _mesa_set_enable( ctx, cap, GL_TRUE );
-}
-
-
-/**
- * Disable GL capability.  Called by glDisable()
- * \param cap  state to disable.
- */
-void GLAPIENTRY
-_mesa_Disable( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   _mesa_set_enable( ctx, cap, GL_FALSE );
-}
-
-
-
-/**
- * Enable/disable an indexed state var.
- */
-void
-_mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean state)
-{
-   ASSERT(state == 0 || state == 1);
-   switch (cap) {
-   case GL_BLEND:
-      if (!ctx->Extensions.EXT_draw_buffers2) {
-         goto invalid_enum_error;
-      }
-      if (index >= ctx->Const.MaxDrawBuffers) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
-                     state ? "glEnableIndexed" : "glDisableIndexed", index);
-         return;
-      }
-      if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
-         FLUSH_VERTICES(ctx, _NEW_COLOR);
-         if (state)
-            ctx->Color.BlendEnabled |= (1 << index);
-         else
-            ctx->Color.BlendEnabled &= ~(1 << index);
-      }
-      break;
-   default:
-      goto invalid_enum_error;
-   }
-   return;
-
-invalid_enum_error:
-    _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
-                state ? "glEnablei" : "glDisablei",
-                _mesa_lookup_enum_by_nr(cap));
-}
-
-
-void GLAPIENTRY
-_mesa_DisableIndexed( GLenum cap, GLuint index )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   _mesa_set_enablei(ctx, cap, index, GL_FALSE);
-}
-
-
-void GLAPIENTRY
-_mesa_EnableIndexed( GLenum cap, GLuint index )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   _mesa_set_enablei(ctx, cap, index, GL_TRUE);
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsEnabledIndexed( GLenum cap, GLuint index )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   switch (cap) {
-   case GL_BLEND:
-      if (index >= ctx->Const.MaxDrawBuffers) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
-                     index);
-         return GL_FALSE;
-      }
-      return (ctx->Color.BlendEnabled >> index) & 1;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
-                  _mesa_lookup_enum_by_nr(cap));
-      return GL_FALSE;
-   }
-}
-
-
-
-
-#undef CHECK_EXTENSION
-#define CHECK_EXTENSION(EXTNAME)			\
-   if (!ctx->Extensions.EXTNAME) {			\
-      goto invalid_enum_error;				\
-   }
-
-#undef CHECK_EXTENSION2
-#define CHECK_EXTENSION2(EXT1, EXT2)				\
-   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {	\
-      goto invalid_enum_error;					\
-   }
-
-
-/**
- * Helper function to determine whether a texture target is enabled.
- */
-static GLboolean
-is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
-{
-   const struct gl_texture_unit *const texUnit =
-       &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
-}
-
-
-/**
- * Return simple enable/disable state.
- *
- * \param cap  state variable to query.
- *
- * Returns the state of the specified capability from the current GL context.
- * For the capabilities associated with extensions verifies that those
- * extensions are effectively present before reporting.
- */
-GLboolean GLAPIENTRY
-_mesa_IsEnabled( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   switch (cap) {
-      case GL_ALPHA_TEST:
-         return ctx->Color.AlphaEnabled;
-      case GL_AUTO_NORMAL:
-	 return ctx->Eval.AutoNormal;
-      case GL_BLEND:
-         return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
-      case GL_CLIP_PLANE0:
-      case GL_CLIP_PLANE1:
-      case GL_CLIP_PLANE2:
-      case GL_CLIP_PLANE3:
-      case GL_CLIP_PLANE4:
-      case GL_CLIP_PLANE5:
-	 return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
-      case GL_COLOR_MATERIAL:
-	 return ctx->Light.ColorMaterialEnabled;
-      case GL_CULL_FACE:
-         return ctx->Polygon.CullFlag;
-      case GL_DEPTH_TEST:
-         return ctx->Depth.Test;
-      case GL_DITHER:
-	 return ctx->Color.DitherFlag;
-      case GL_FOG:
-	 return ctx->Fog.Enabled;
-      case GL_LIGHTING:
-         return ctx->Light.Enabled;
-      case GL_LIGHT0:
-      case GL_LIGHT1:
-      case GL_LIGHT2:
-      case GL_LIGHT3:
-      case GL_LIGHT4:
-      case GL_LIGHT5:
-      case GL_LIGHT6:
-      case GL_LIGHT7:
-         return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
-      case GL_LINE_SMOOTH:
-	 return ctx->Line.SmoothFlag;
-      case GL_LINE_STIPPLE:
-	 return ctx->Line.StippleFlag;
-      case GL_INDEX_LOGIC_OP:
-	 return ctx->Color.IndexLogicOpEnabled;
-      case GL_COLOR_LOGIC_OP:
-	 return ctx->Color.ColorLogicOpEnabled;
-      case GL_MAP1_COLOR_4:
-	 return ctx->Eval.Map1Color4;
-      case GL_MAP1_INDEX:
-	 return ctx->Eval.Map1Index;
-      case GL_MAP1_NORMAL:
-	 return ctx->Eval.Map1Normal;
-      case GL_MAP1_TEXTURE_COORD_1:
-	 return ctx->Eval.Map1TextureCoord1;
-      case GL_MAP1_TEXTURE_COORD_2:
-	 return ctx->Eval.Map1TextureCoord2;
-      case GL_MAP1_TEXTURE_COORD_3:
-	 return ctx->Eval.Map1TextureCoord3;
-      case GL_MAP1_TEXTURE_COORD_4:
-	 return ctx->Eval.Map1TextureCoord4;
-      case GL_MAP1_VERTEX_3:
-	 return ctx->Eval.Map1Vertex3;
-      case GL_MAP1_VERTEX_4:
-	 return ctx->Eval.Map1Vertex4;
-      case GL_MAP2_COLOR_4:
-	 return ctx->Eval.Map2Color4;
-      case GL_MAP2_INDEX:
-	 return ctx->Eval.Map2Index;
-      case GL_MAP2_NORMAL:
-	 return ctx->Eval.Map2Normal;
-      case GL_MAP2_TEXTURE_COORD_1:
-	 return ctx->Eval.Map2TextureCoord1;
-      case GL_MAP2_TEXTURE_COORD_2:
-	 return ctx->Eval.Map2TextureCoord2;
-      case GL_MAP2_TEXTURE_COORD_3:
-	 return ctx->Eval.Map2TextureCoord3;
-      case GL_MAP2_TEXTURE_COORD_4:
-	 return ctx->Eval.Map2TextureCoord4;
-      case GL_MAP2_VERTEX_3:
-	 return ctx->Eval.Map2Vertex3;
-      case GL_MAP2_VERTEX_4:
-	 return ctx->Eval.Map2Vertex4;
-      case GL_NORMALIZE:
-	 return ctx->Transform.Normalize;
-      case GL_POINT_SMOOTH:
-	 return ctx->Point.SmoothFlag;
-      case GL_POLYGON_SMOOTH:
-	 return ctx->Polygon.SmoothFlag;
-      case GL_POLYGON_STIPPLE:
-	 return ctx->Polygon.StippleFlag;
-      case GL_POLYGON_OFFSET_POINT:
-	 return ctx->Polygon.OffsetPoint;
-      case GL_POLYGON_OFFSET_LINE:
-	 return ctx->Polygon.OffsetLine;
-      case GL_POLYGON_OFFSET_FILL:
-      /*case GL_POLYGON_OFFSET_EXT:*/
-	 return ctx->Polygon.OffsetFill;
-      case GL_RESCALE_NORMAL_EXT:
-         return ctx->Transform.RescaleNormals;
-      case GL_SCISSOR_TEST:
-	 return ctx->Scissor.Enabled;
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         return ctx->Texture.SharedPalette;
-      case GL_STENCIL_TEST:
-	 return ctx->Stencil.Enabled;
-      case GL_TEXTURE_1D:
-         return is_texture_enabled(ctx, TEXTURE_1D_BIT);
-      case GL_TEXTURE_2D:
-         return is_texture_enabled(ctx, TEXTURE_2D_BIT);
-      case GL_TEXTURE_3D:
-         return is_texture_enabled(ctx, TEXTURE_3D_BIT);
-      case GL_TEXTURE_GEN_Q:
-         {
-            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
-            }
-         }
-         return GL_FALSE;
-      case GL_TEXTURE_GEN_R:
-         {
-            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
-            }
-         }
-         return GL_FALSE;
-      case GL_TEXTURE_GEN_S:
-         {
-            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
-            }
-         }
-         return GL_FALSE;
-      case GL_TEXTURE_GEN_T:
-         {
-            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-               return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
-            }
-         }
-         return GL_FALSE;
-#if FEATURE_ES1
-      case GL_TEXTURE_GEN_STR_OES:
-	 {
-            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
-            if (texUnit) {
-		    return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE;
-            }
-         }
-#endif
-
-      /*
-       * CLIENT STATE!!!
-       */
-      case GL_VERTEX_ARRAY:
-         return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
-      case GL_NORMAL_ARRAY:
-         return (ctx->Array.ArrayObj->Normal.Enabled != 0);
-      case GL_COLOR_ARRAY:
-         return (ctx->Array.ArrayObj->Color.Enabled != 0);
-      case GL_INDEX_ARRAY:
-         return (ctx->Array.ArrayObj->Index.Enabled != 0);
-      case GL_TEXTURE_COORD_ARRAY:
-         return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
-      case GL_EDGE_FLAG_ARRAY:
-         return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
-      case GL_FOG_COORDINATE_ARRAY_EXT:
-         CHECK_EXTENSION(EXT_fog_coord);
-         return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
-      case GL_SECONDARY_COLOR_ARRAY_EXT:
-         CHECK_EXTENSION(EXT_secondary_color);
-         return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
-#if FEATURE_point_size_array
-      case GL_POINT_SIZE_ARRAY_OES:
-         return (ctx->Array.ArrayObj->PointSize.Enabled != 0);
-#endif
-
-      /* GL_ARB_texture_cube_map */
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         CHECK_EXTENSION(ARB_texture_cube_map);
-         return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
-
-      /* GL_EXT_secondary_color */
-      case GL_COLOR_SUM_EXT:
-         CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
-         return ctx->Fog.ColorSumEnabled;
-
-      /* GL_ARB_multisample */
-      case GL_MULTISAMPLE_ARB:
-         return ctx->Multisample.Enabled;
-      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         return ctx->Multisample.SampleAlphaToCoverage;
-      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         return ctx->Multisample.SampleAlphaToOne;
-      case GL_SAMPLE_COVERAGE_ARB:
-         return ctx->Multisample.SampleCoverage;
-      case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         return ctx->Multisample.SampleCoverageInvert;
-
-      /* GL_IBM_rasterpos_clip */
-      case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         CHECK_EXTENSION(IBM_rasterpos_clip);
-         return ctx->Transform.RasterPositionUnclipped;
-
-      /* GL_NV_point_sprite */
-      case GL_POINT_SPRITE_NV:
-         CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
-         return ctx->Point.PointSprite;
-
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-      case GL_VERTEX_PROGRAM_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
-         return ctx->VertexProgram.Enabled;
-      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
-         return ctx->VertexProgram.PointSizeEnabled;
-      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
-         return ctx->VertexProgram.TwoSideEnabled;
-#endif
-#if FEATURE_NV_vertex_program
-      case GL_VERTEX_ATTRIB_ARRAY0_NV:
-      case GL_VERTEX_ATTRIB_ARRAY1_NV:
-      case GL_VERTEX_ATTRIB_ARRAY2_NV:
-      case GL_VERTEX_ATTRIB_ARRAY3_NV:
-      case GL_VERTEX_ATTRIB_ARRAY4_NV:
-      case GL_VERTEX_ATTRIB_ARRAY5_NV:
-      case GL_VERTEX_ATTRIB_ARRAY6_NV:
-      case GL_VERTEX_ATTRIB_ARRAY7_NV:
-      case GL_VERTEX_ATTRIB_ARRAY8_NV:
-      case GL_VERTEX_ATTRIB_ARRAY9_NV:
-      case GL_VERTEX_ATTRIB_ARRAY10_NV:
-      case GL_VERTEX_ATTRIB_ARRAY11_NV:
-      case GL_VERTEX_ATTRIB_ARRAY12_NV:
-      case GL_VERTEX_ATTRIB_ARRAY13_NV:
-      case GL_VERTEX_ATTRIB_ARRAY14_NV:
-      case GL_VERTEX_ATTRIB_ARRAY15_NV:
-         CHECK_EXTENSION(NV_vertex_program);
-         {
-            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
-            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
-            return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
-         }
-      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program);
-         {
-            const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
-            return ctx->Eval.Map1Attrib[map];
-         }
-      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
-      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program);
-         {
-            const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
-            return ctx->Eval.Map2Attrib[map];
-         }
-#endif /* FEATURE_NV_vertex_program */
-
-#if FEATURE_NV_fragment_program
-      case GL_FRAGMENT_PROGRAM_NV:
-         CHECK_EXTENSION(NV_fragment_program);
-         return ctx->FragmentProgram.Enabled;
-#endif /* FEATURE_NV_fragment_program */
-
-      /* GL_NV_texture_rectangle */
-      case GL_TEXTURE_RECTANGLE_NV:
-         CHECK_EXTENSION(NV_texture_rectangle);
-         return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
-
-      /* GL_EXT_stencil_two_side */
-      case GL_STENCIL_TEST_TWO_SIDE_EXT:
-         CHECK_EXTENSION(EXT_stencil_two_side);
-         return ctx->Stencil.TestTwoSide;
-
-#if FEATURE_ARB_fragment_program
-      case GL_FRAGMENT_PROGRAM_ARB:
-         return ctx->FragmentProgram.Enabled;
-#endif /* FEATURE_ARB_fragment_program */
-
-      /* GL_EXT_depth_bounds_test */
-      case GL_DEPTH_BOUNDS_TEST_EXT:
-         CHECK_EXTENSION(EXT_depth_bounds_test);
-         return ctx->Depth.BoundsTest;
-
-      /* GL_ARB_depth_clamp */
-      case GL_DEPTH_CLAMP:
-         CHECK_EXTENSION(ARB_depth_clamp);
-         return ctx->Transform.DepthClamp;
-
-#if FEATURE_ATI_fragment_shader
-      case GL_FRAGMENT_SHADER_ATI:
-	 CHECK_EXTENSION(ATI_fragment_shader);
-	 return ctx->ATIFragmentShader.Enabled;
-#endif /* FEATURE_ATI_fragment_shader */
-
-      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
-	 CHECK_EXTENSION(ARB_seamless_cube_map);
-	 return ctx->Texture.CubeMapSeamless;
-
-#if FEATURE_EXT_transform_feedback
-      case GL_RASTERIZER_DISCARD:
-	 CHECK_EXTENSION(EXT_transform_feedback);
-         return ctx->TransformFeedback.RasterDiscard;
-#endif
-
-      /* GL_NV_primitive_restart */
-      case GL_PRIMITIVE_RESTART_NV:
-	 if (!ctx->Extensions.NV_primitive_restart) {
-            goto invalid_enum_error;
-         }
-         return ctx->Array.PrimitiveRestart;
-
-      /* GL 3.1 primitive restart */
-      case GL_PRIMITIVE_RESTART:
-         if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
-            goto invalid_enum_error;
-         }
-         return ctx->Array.PrimitiveRestart;
-
-      /* GL3.0 - GL_framebuffer_sRGB */
-      case GL_FRAMEBUFFER_SRGB_EXT:
-	 CHECK_EXTENSION(EXT_framebuffer_sRGB);
-	 return ctx->Color.sRGBEnabled;
-
-      default:
-         goto invalid_enum_error;
-   }
-
-   return GL_FALSE;
-
-invalid_enum_error:
-   _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
-   return GL_FALSE;
-}
+/**

+ * \file enable.c

+ * Enable/disable/query GL capabilities.

+ */

+

+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0.3

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "context.h"

+#include "enable.h"

+#include "light.h"

+#include "simple_list.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "enums.h"

+#include "api_arrayelt.h"

+#include "texstate.h"

+

+

+

+#define CHECK_EXTENSION(EXTNAME, CAP)					\

+   if (!ctx->Extensions.EXTNAME) {					\

+      goto invalid_enum_error;						\

+   }

+

+

+/**

+ * Helper to enable/disable client-side state.

+ */

+static void

+client_state(struct gl_context *ctx, GLenum cap, GLboolean state)

+{

+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+   GLuint flag;

+   GLboolean *var;

+

+   switch (cap) {

+      case GL_VERTEX_ARRAY:

+         var = &arrayObj->Vertex.Enabled;

+         flag = _NEW_ARRAY_VERTEX;

+         break;

+      case GL_NORMAL_ARRAY:

+         var = &arrayObj->Normal.Enabled;

+         flag = _NEW_ARRAY_NORMAL;

+         break;

+      case GL_COLOR_ARRAY:

+         var = &arrayObj->Color.Enabled;

+         flag = _NEW_ARRAY_COLOR0;

+         break;

+      case GL_INDEX_ARRAY:

+         var = &arrayObj->Index.Enabled;

+         flag = _NEW_ARRAY_INDEX;

+         break;

+      case GL_TEXTURE_COORD_ARRAY:

+         var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;

+         flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);

+         break;

+      case GL_EDGE_FLAG_ARRAY:

+         var = &arrayObj->EdgeFlag.Enabled;

+         flag = _NEW_ARRAY_EDGEFLAG;

+         break;

+      case GL_FOG_COORDINATE_ARRAY_EXT:

+         var = &arrayObj->FogCoord.Enabled;

+         flag = _NEW_ARRAY_FOGCOORD;

+         break;

+      case GL_SECONDARY_COLOR_ARRAY_EXT:

+         var = &arrayObj->SecondaryColor.Enabled;

+         flag = _NEW_ARRAY_COLOR1;

+         break;

+

+#if FEATURE_point_size_array

+      case GL_POINT_SIZE_ARRAY_OES:

+         var = &arrayObj->PointSize.Enabled;

+         flag = _NEW_ARRAY_POINT_SIZE;

+         break;

+#endif

+

+#if FEATURE_NV_vertex_program

+      case GL_VERTEX_ATTRIB_ARRAY0_NV:

+      case GL_VERTEX_ATTRIB_ARRAY1_NV:

+      case GL_VERTEX_ATTRIB_ARRAY2_NV:

+      case GL_VERTEX_ATTRIB_ARRAY3_NV:

+      case GL_VERTEX_ATTRIB_ARRAY4_NV:

+      case GL_VERTEX_ATTRIB_ARRAY5_NV:

+      case GL_VERTEX_ATTRIB_ARRAY6_NV:

+      case GL_VERTEX_ATTRIB_ARRAY7_NV:

+      case GL_VERTEX_ATTRIB_ARRAY8_NV:

+      case GL_VERTEX_ATTRIB_ARRAY9_NV:

+      case GL_VERTEX_ATTRIB_ARRAY10_NV:

+      case GL_VERTEX_ATTRIB_ARRAY11_NV:

+      case GL_VERTEX_ATTRIB_ARRAY12_NV:

+      case GL_VERTEX_ATTRIB_ARRAY13_NV:

+      case GL_VERTEX_ATTRIB_ARRAY14_NV:

+      case GL_VERTEX_ATTRIB_ARRAY15_NV:

+         CHECK_EXTENSION(NV_vertex_program, cap);

+         {

+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;

+            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));

+            var = &arrayObj->VertexAttrib[n].Enabled;

+            flag = _NEW_ARRAY_ATTRIB(n);

+         }

+         break;

+#endif /* FEATURE_NV_vertex_program */

+

+      /* GL_NV_primitive_restart */

+      case GL_PRIMITIVE_RESTART_NV:

+	 if (!ctx->Extensions.NV_primitive_restart) {

+            goto invalid_enum_error;

+         }

+         var = &ctx->Array.PrimitiveRestart;

+         flag = 0;

+         break;

+

+      default:

+         goto invalid_enum_error;

+   }

+

+   if (*var == state)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_ARRAY);

+   ctx->Array.NewState |= flag;

+

+   _ae_invalidate_state(ctx, _NEW_ARRAY);

+

+   *var = state;

+

+   if (state)

+      ctx->Array.ArrayObj->_Enabled |= flag;

+   else

+      ctx->Array.ArrayObj->_Enabled &= ~flag;

+

+   if (ctx->Driver.Enable) {

+      ctx->Driver.Enable( ctx, cap, state );

+   }

+

+   return;

+

+invalid_enum_error:

+   _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",

+               state ? "Enable" : "Disable", cap);

+}

+

+

+/**

+ * Enable GL capability.

+ * \param cap  state to enable/disable.

+ *

+ * Get's the current context, assures that we're outside glBegin()/glEnd() and

+ * calls client_state().

+ */

+void GLAPIENTRY

+_mesa_EnableClientState( GLenum cap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   client_state( ctx, cap, GL_TRUE );

+}

+

+

+/**

+ * Disable GL capability.

+ * \param cap  state to enable/disable.

+ *

+ * Get's the current context, assures that we're outside glBegin()/glEnd() and

+ * calls client_state().

+ */

+void GLAPIENTRY

+_mesa_DisableClientState( GLenum cap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   client_state( ctx, cap, GL_FALSE );

+}

+

+

+#undef CHECK_EXTENSION

+#define CHECK_EXTENSION(EXTNAME, CAP)					\

+   if (!ctx->Extensions.EXTNAME) {					\

+      goto invalid_enum_error;						\

+   }

+

+#define CHECK_EXTENSION2(EXT1, EXT2, CAP)				\

+   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {		\

+      goto invalid_enum_error;						\

+   }

+

+

+

+/**

+ * Return pointer to current texture unit for setting/getting coordinate

+ * state.

+ * Note that we'll set GL_INVALID_OPERATION if the active texture unit is

+ * higher than the number of supported coordinate units.  And we'll return NULL.

+ */

+static struct gl_texture_unit *

+get_texcoord_unit(struct gl_context *ctx)

+{

+   if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");

+      return NULL;

+   }

+   else {

+      return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];

+   }

+}

+

+

+/**

+ * Helper function to enable or disable a texture target.

+ * \param bit  one of the TEXTURE_x_BIT values

+ * \return GL_TRUE if state is changing or GL_FALSE if no change

+ */

+static GLboolean

+enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)

+{

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   const GLbitfield newenabled = state

+      ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);

+

+   if (texUnit->Enabled == newenabled)

+       return GL_FALSE;

+

+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+   texUnit->Enabled = newenabled;

+   return GL_TRUE;

+}

+

+

+/**

+ * Helper function to enable or disable state.

+ *

+ * \param ctx GL context.

+ * \param cap  the state to enable/disable

+ * \param state whether to enable or disable the specified capability.

+ *

+ * Updates the current context and flushes the vertices as needed. For

+ * capabilities associated with extensions it verifies that those extensions

+ * are effectivly present before updating. Notifies the driver via

+ * dd_function_table::Enable.

+ */

+void

+_mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)

+{

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "%s %s (newstate is %x)\n",

+                  state ? "glEnable" : "glDisable",

+                  _mesa_lookup_enum_by_nr(cap),

+                  ctx->NewState);

+

+   switch (cap) {

+      case GL_ALPHA_TEST:

+         if (ctx->Color.AlphaEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_COLOR);

+         ctx->Color.AlphaEnabled = state;

+         break;

+      case GL_AUTO_NORMAL:

+         if (ctx->Eval.AutoNormal == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.AutoNormal = state;

+         break;

+      case GL_BLEND:

+         {

+            GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1);

+            if (newEnabled != ctx->Color.BlendEnabled) {

+               FLUSH_VERTICES(ctx, _NEW_COLOR);

+               ctx->Color.BlendEnabled = newEnabled;

+            }

+         }

+         break;

+#if FEATURE_userclip

+      case GL_CLIP_PLANE0:

+      case GL_CLIP_PLANE1:

+      case GL_CLIP_PLANE2:

+      case GL_CLIP_PLANE3:

+      case GL_CLIP_PLANE4:

+      case GL_CLIP_PLANE5:

+         {

+            const GLuint p = cap - GL_CLIP_PLANE0;

+

+            if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p))

+               return;

+

+            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+

+            if (state) {

+               ctx->Transform.ClipPlanesEnabled |= (1 << p);

+

+               if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))

+                  _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );

+

+               /* This derived state also calculated in clip.c and

+                * from _mesa_update_state() on changes to EyeUserPlane

+                * and ctx->ProjectionMatrix respectively.

+                */

+               _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],

+                                    ctx->Transform.EyeUserPlane[p],

+                                    ctx->ProjectionMatrixStack.Top->inv );

+            }

+            else {

+               ctx->Transform.ClipPlanesEnabled &= ~(1 << p);

+            }               

+         }

+         break;

+#endif

+      case GL_COLOR_MATERIAL:

+         if (ctx->Light.ColorMaterialEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_LIGHT);

+         FLUSH_CURRENT(ctx, 0);

+         ctx->Light.ColorMaterialEnabled = state;

+         if (state) {

+            _mesa_update_color_material( ctx,

+                                  ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );

+         }

+         break;

+      case GL_CULL_FACE:

+         if (ctx->Polygon.CullFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.CullFlag = state;

+         break;

+      case GL_DEPTH_TEST:

+         if (ctx->Depth.Test == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_DEPTH);

+         ctx->Depth.Test = state;

+         break;

+      case GL_DITHER:

+         if (ctx->Color.DitherFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_COLOR);

+         ctx->Color.DitherFlag = state;

+         break;

+      case GL_FOG:

+         if (ctx->Fog.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_FOG);

+         ctx->Fog.Enabled = state;

+         break;

+      case GL_LIGHT0:

+      case GL_LIGHT1:

+      case GL_LIGHT2:

+      case GL_LIGHT3:

+      case GL_LIGHT4:

+      case GL_LIGHT5:

+      case GL_LIGHT6:

+      case GL_LIGHT7:

+         if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_LIGHT);

+         ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;

+         if (state) {

+            insert_at_tail(&ctx->Light.EnabledList,

+                           &ctx->Light.Light[cap-GL_LIGHT0]);

+         }

+         else {

+            remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);

+         }

+         break;

+      case GL_LIGHTING:

+         if (ctx->Light.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_LIGHT);

+         ctx->Light.Enabled = state;

+         if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)

+            ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;

+         else

+            ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;

+         break;

+      case GL_LINE_SMOOTH:

+         if (ctx->Line.SmoothFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_LINE);

+         ctx->Line.SmoothFlag = state;

+         ctx->_TriangleCaps ^= DD_LINE_SMOOTH;

+         break;

+      case GL_LINE_STIPPLE:

+         if (ctx->Line.StippleFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_LINE);

+         ctx->Line.StippleFlag = state;

+         ctx->_TriangleCaps ^= DD_LINE_STIPPLE;

+         break;

+      case GL_INDEX_LOGIC_OP:

+         if (ctx->Color.IndexLogicOpEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_COLOR);

+         ctx->Color.IndexLogicOpEnabled = state;

+         break;

+      case GL_COLOR_LOGIC_OP:

+         if (ctx->Color.ColorLogicOpEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_COLOR);

+         ctx->Color.ColorLogicOpEnabled = state;

+         break;

+      case GL_MAP1_COLOR_4:

+         if (ctx->Eval.Map1Color4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1Color4 = state;

+         break;

+      case GL_MAP1_INDEX:

+         if (ctx->Eval.Map1Index == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1Index = state;

+         break;

+      case GL_MAP1_NORMAL:

+         if (ctx->Eval.Map1Normal == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1Normal = state;

+         break;

+      case GL_MAP1_TEXTURE_COORD_1:

+         if (ctx->Eval.Map1TextureCoord1 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1TextureCoord1 = state;

+         break;

+      case GL_MAP1_TEXTURE_COORD_2:

+         if (ctx->Eval.Map1TextureCoord2 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1TextureCoord2 = state;

+         break;

+      case GL_MAP1_TEXTURE_COORD_3:

+         if (ctx->Eval.Map1TextureCoord3 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1TextureCoord3 = state;

+         break;

+      case GL_MAP1_TEXTURE_COORD_4:

+         if (ctx->Eval.Map1TextureCoord4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1TextureCoord4 = state;

+         break;

+      case GL_MAP1_VERTEX_3:

+         if (ctx->Eval.Map1Vertex3 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1Vertex3 = state;

+         break;

+      case GL_MAP1_VERTEX_4:

+         if (ctx->Eval.Map1Vertex4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map1Vertex4 = state;

+         break;

+      case GL_MAP2_COLOR_4:

+         if (ctx->Eval.Map2Color4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2Color4 = state;

+         break;

+      case GL_MAP2_INDEX:

+         if (ctx->Eval.Map2Index == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2Index = state;

+         break;

+      case GL_MAP2_NORMAL:

+         if (ctx->Eval.Map2Normal == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2Normal = state;

+         break;

+      case GL_MAP2_TEXTURE_COORD_1:

+         if (ctx->Eval.Map2TextureCoord1 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2TextureCoord1 = state;

+         break;

+      case GL_MAP2_TEXTURE_COORD_2:

+         if (ctx->Eval.Map2TextureCoord2 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2TextureCoord2 = state;

+         break;

+      case GL_MAP2_TEXTURE_COORD_3:

+         if (ctx->Eval.Map2TextureCoord3 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2TextureCoord3 = state;

+         break;

+      case GL_MAP2_TEXTURE_COORD_4:

+         if (ctx->Eval.Map2TextureCoord4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2TextureCoord4 = state;

+         break;

+      case GL_MAP2_VERTEX_3:

+         if (ctx->Eval.Map2Vertex3 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2Vertex3 = state;

+         break;

+      case GL_MAP2_VERTEX_4:

+         if (ctx->Eval.Map2Vertex4 == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_EVAL);

+         ctx->Eval.Map2Vertex4 = state;

+         break;

+      case GL_NORMALIZE:

+         if (ctx->Transform.Normalize == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+         ctx->Transform.Normalize = state;

+         break;

+      case GL_POINT_SMOOTH:

+         if (ctx->Point.SmoothFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POINT);

+         ctx->Point.SmoothFlag = state;

+         ctx->_TriangleCaps ^= DD_POINT_SMOOTH;

+         break;

+      case GL_POLYGON_SMOOTH:

+         if (ctx->Polygon.SmoothFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.SmoothFlag = state;

+         ctx->_TriangleCaps ^= DD_TRI_SMOOTH;

+         break;

+      case GL_POLYGON_STIPPLE:

+         if (ctx->Polygon.StippleFlag == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.StippleFlag = state;

+         ctx->_TriangleCaps ^= DD_TRI_STIPPLE;

+         break;

+      case GL_POLYGON_OFFSET_POINT:

+         if (ctx->Polygon.OffsetPoint == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.OffsetPoint = state;

+         break;

+      case GL_POLYGON_OFFSET_LINE:

+         if (ctx->Polygon.OffsetLine == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.OffsetLine = state;

+         break;

+      case GL_POLYGON_OFFSET_FILL:

+         /*case GL_POLYGON_OFFSET_EXT:*/

+         if (ctx->Polygon.OffsetFill == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POLYGON);

+         ctx->Polygon.OffsetFill = state;

+         break;

+      case GL_RESCALE_NORMAL_EXT:

+         if (ctx->Transform.RescaleNormals == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+         ctx->Transform.RescaleNormals = state;

+         break;

+      case GL_SCISSOR_TEST:

+         if (ctx->Scissor.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_SCISSOR);

+         ctx->Scissor.Enabled = state;

+         break;

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         if (ctx->Texture.SharedPalette == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+         ctx->Texture.SharedPalette = state;

+         break;

+      case GL_STENCIL_TEST:

+         if (ctx->Stencil.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_STENCIL);

+         ctx->Stencil.Enabled = state;

+         break;

+      case GL_TEXTURE_1D:

+         if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {

+            return;

+         }

+         break;

+      case GL_TEXTURE_2D:

+         if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {

+            return;

+         }

+         break;

+      case GL_TEXTURE_3D:

+         if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {

+            return;

+         }

+         break;

+      case GL_TEXTURE_GEN_Q:

+         {

+            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;

+               if (state)

+                  newenabled |= Q_BIT;

+               if (texUnit->TexGenEnabled == newenabled)

+                  return;

+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+               texUnit->TexGenEnabled = newenabled;

+            }

+         }

+         break;

+      case GL_TEXTURE_GEN_R:

+         {

+            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;

+               if (state)

+                  newenabled |= R_BIT;

+               if (texUnit->TexGenEnabled == newenabled)

+                  return;

+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+               texUnit->TexGenEnabled = newenabled;

+            }

+         }

+         break;

+      case GL_TEXTURE_GEN_S:

+         {

+            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;

+               if (state)

+                  newenabled |= S_BIT;

+               if (texUnit->TexGenEnabled == newenabled)

+                  return;

+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+               texUnit->TexGenEnabled = newenabled;

+            }

+         }

+         break;

+      case GL_TEXTURE_GEN_T:

+         {

+            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;

+               if (state)

+                  newenabled |= T_BIT;

+               if (texUnit->TexGenEnabled == newenabled)

+                  return;

+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+               texUnit->TexGenEnabled = newenabled;

+            }

+         }

+         break;

+

+#if FEATURE_ES1

+      case GL_TEXTURE_GEN_STR_OES:

+	 /* disable S, T, and R at the same time */

+	 {

+            struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               GLuint newenabled =

+		  texUnit->TexGenEnabled & ~STR_BITS;

+               if (state)

+                  newenabled |= STR_BITS;

+               if (texUnit->TexGenEnabled == newenabled)

+                  return;

+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+               texUnit->TexGenEnabled = newenabled;

+            }

+         }

+         break;

+#endif

+

+      /*

+       * CLIENT STATE!!!

+       */

+      case GL_VERTEX_ARRAY:

+      case GL_NORMAL_ARRAY:

+      case GL_COLOR_ARRAY:

+      case GL_INDEX_ARRAY:

+      case GL_TEXTURE_COORD_ARRAY:

+      case GL_EDGE_FLAG_ARRAY:

+      case GL_FOG_COORDINATE_ARRAY_EXT:

+      case GL_SECONDARY_COLOR_ARRAY_EXT:

+      case GL_POINT_SIZE_ARRAY_OES:

+         client_state( ctx, cap, state );

+         return;

+

+      /* GL_ARB_texture_cube_map */

+      case GL_TEXTURE_CUBE_MAP_ARB:

+         CHECK_EXTENSION(ARB_texture_cube_map, cap);

+         if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {

+            return;

+         }

+         break;

+

+      /* GL_EXT_secondary_color */

+      case GL_COLOR_SUM_EXT:

+         CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);

+         if (ctx->Fog.ColorSumEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_FOG);

+         ctx->Fog.ColorSumEnabled = state;

+         break;

+

+      /* GL_ARB_multisample */

+      case GL_MULTISAMPLE_ARB:

+         if (ctx->Multisample.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);

+         ctx->Multisample.Enabled = state;

+         break;

+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:

+         if (ctx->Multisample.SampleAlphaToCoverage == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);

+         ctx->Multisample.SampleAlphaToCoverage = state;

+         break;

+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:

+         if (ctx->Multisample.SampleAlphaToOne == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);

+         ctx->Multisample.SampleAlphaToOne = state;

+         break;

+      case GL_SAMPLE_COVERAGE_ARB:

+         if (ctx->Multisample.SampleCoverage == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);

+         ctx->Multisample.SampleCoverage = state;

+         break;

+      case GL_SAMPLE_COVERAGE_INVERT_ARB:

+         if (ctx->Multisample.SampleCoverageInvert == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);

+         ctx->Multisample.SampleCoverageInvert = state;

+         break;

+

+      /* GL_IBM_rasterpos_clip */

+      case GL_RASTER_POSITION_UNCLIPPED_IBM:

+         CHECK_EXTENSION(IBM_rasterpos_clip, cap);

+         if (ctx->Transform.RasterPositionUnclipped == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+         ctx->Transform.RasterPositionUnclipped = state;

+         break;

+

+      /* GL_NV_point_sprite */

+      case GL_POINT_SPRITE_NV:

+         CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);

+         if (ctx->Point.PointSprite == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_POINT);

+         ctx->Point.PointSprite = state;

+         break;

+

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+      case GL_VERTEX_PROGRAM_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);

+         if (ctx->VertexProgram.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_PROGRAM); 

+         ctx->VertexProgram.Enabled = state;

+         break;

+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);

+         if (ctx->VertexProgram.PointSizeEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+         ctx->VertexProgram.PointSizeEnabled = state;

+         break;

+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);

+         if (ctx->VertexProgram.TwoSideEnabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_PROGRAM); 

+         ctx->VertexProgram.TwoSideEnabled = state;

+         break;

+#endif

+#if FEATURE_NV_vertex_program

+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:

+         CHECK_EXTENSION(NV_vertex_program, cap);

+         {

+            const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);

+            FLUSH_VERTICES(ctx, _NEW_EVAL);

+            ctx->Eval.Map1Attrib[map] = state;

+         }

+         break;

+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:

+         CHECK_EXTENSION(NV_vertex_program, cap);

+         {

+            const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);

+            FLUSH_VERTICES(ctx, _NEW_EVAL);

+            ctx->Eval.Map2Attrib[map] = state;

+         }

+         break;

+#endif /* FEATURE_NV_vertex_program */

+

+#if FEATURE_NV_fragment_program

+      case GL_FRAGMENT_PROGRAM_NV:

+         CHECK_EXTENSION(NV_fragment_program, cap);

+         if (ctx->FragmentProgram.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+         ctx->FragmentProgram.Enabled = state;

+         break;

+#endif /* FEATURE_NV_fragment_program */

+

+      /* GL_NV_texture_rectangle */

+      case GL_TEXTURE_RECTANGLE_NV:

+         CHECK_EXTENSION(NV_texture_rectangle, cap);

+         if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {

+            return;

+         }

+         break;

+

+      /* GL_EXT_stencil_two_side */

+      case GL_STENCIL_TEST_TWO_SIDE_EXT:

+         CHECK_EXTENSION(EXT_stencil_two_side, cap);

+         if (ctx->Stencil.TestTwoSide == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_STENCIL);

+         ctx->Stencil.TestTwoSide = state;

+         if (state) {

+            ctx->Stencil._BackFace = 2;

+            ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;

+         } else {

+            ctx->Stencil._BackFace = 1;

+            ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;

+         }

+         break;

+

+#if FEATURE_ARB_fragment_program

+      case GL_FRAGMENT_PROGRAM_ARB:

+         CHECK_EXTENSION(ARB_fragment_program, cap);

+         if (ctx->FragmentProgram.Enabled == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+         ctx->FragmentProgram.Enabled = state;

+         break;

+#endif /* FEATURE_ARB_fragment_program */

+

+      /* GL_EXT_depth_bounds_test */

+      case GL_DEPTH_BOUNDS_TEST_EXT:

+         CHECK_EXTENSION(EXT_depth_bounds_test, cap);

+         if (ctx->Depth.BoundsTest == state)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_DEPTH);

+         ctx->Depth.BoundsTest = state;

+         break;

+

+      case GL_DEPTH_CLAMP:

+         if (ctx->Transform.DepthClamp == state)

+            return;

+	 CHECK_EXTENSION(ARB_depth_clamp, cap);

+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+	 ctx->Transform.DepthClamp = state;

+	 break;

+

+#if FEATURE_ATI_fragment_shader

+      case GL_FRAGMENT_SHADER_ATI:

+        CHECK_EXTENSION(ATI_fragment_shader, cap);

+	if (ctx->ATIFragmentShader.Enabled == state)

+	  return;

+	FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+	ctx->ATIFragmentShader.Enabled = state;

+        break;

+#endif

+

+      /* GL_MESA_texture_array */

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         CHECK_EXTENSION(MESA_texture_array, cap);

+         if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {

+            return;

+         }

+         break;

+

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         CHECK_EXTENSION(MESA_texture_array, cap);

+         if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {

+            return;

+         }

+         break;

+

+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:

+	 CHECK_EXTENSION(ARB_seamless_cube_map, cap);

+	 ctx->Texture.CubeMapSeamless = state;

+	 break;

+

+#if FEATURE_EXT_transform_feedback

+      case GL_RASTERIZER_DISCARD:

+	 CHECK_EXTENSION(EXT_transform_feedback, cap);

+         if (ctx->TransformFeedback.RasterDiscard != state) {

+            ctx->TransformFeedback.RasterDiscard = state;

+            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+         }

+         break;

+#endif

+

+      /* GL 3.1 primitive restart.  Note: this enum is different from

+       * GL_PRIMITIVE_RESTART_NV (which is client state).

+       */

+      case GL_PRIMITIVE_RESTART:

+         if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {

+            goto invalid_enum_error;

+         }

+         if (ctx->Array.PrimitiveRestart != state) {

+            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);

+            ctx->Array.PrimitiveRestart = state;

+         }

+         break;

+

+      /* GL3.0 - GL_framebuffer_sRGB */

+      case GL_FRAMEBUFFER_SRGB_EXT:

+         CHECK_EXTENSION(EXT_framebuffer_sRGB, cap);

+         FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+         ctx->Color.sRGBEnabled = state;

+         break;

+

+      default:

+         goto invalid_enum_error;

+   }

+

+   if (ctx->Driver.Enable) {

+      ctx->Driver.Enable( ctx, cap, state );

+   }

+

+   return;

+

+invalid_enum_error:

+   _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",

+               state ? "Enable" : "Disable", cap);

+}

+

+

+/**

+ * Enable GL capability.  Called by glEnable()

+ * \param cap  state to enable.

+ */

+void GLAPIENTRY

+_mesa_Enable( GLenum cap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   _mesa_set_enable( ctx, cap, GL_TRUE );

+}

+

+

+/**

+ * Disable GL capability.  Called by glDisable()

+ * \param cap  state to disable.

+ */

+void GLAPIENTRY

+_mesa_Disable( GLenum cap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   _mesa_set_enable( ctx, cap, GL_FALSE );

+}

+

+

+

+/**

+ * Enable/disable an indexed state var.

+ */

+void

+_mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean state)

+{

+   ASSERT(state == 0 || state == 1);

+   switch (cap) {

+   case GL_BLEND:

+      if (!ctx->Extensions.EXT_draw_buffers2) {

+         goto invalid_enum_error;

+      }

+      if (index >= ctx->Const.MaxDrawBuffers) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",

+                     state ? "glEnableIndexed" : "glDisableIndexed", index);

+         return;

+      }

+      if (((ctx->Color.BlendEnabled >> index) & 1) != state) {

+         FLUSH_VERTICES(ctx, _NEW_COLOR);

+         if (state)

+            ctx->Color.BlendEnabled |= (1 << index);

+         else

+            ctx->Color.BlendEnabled &= ~(1 << index);

+      }

+      break;

+   default:

+      goto invalid_enum_error;

+   }

+   return;

+

+invalid_enum_error:

+    _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",

+                state ? "glEnablei" : "glDisablei",

+                _mesa_lookup_enum_by_nr(cap));

+}

+

+

+void GLAPIENTRY

+_mesa_DisableIndexed( GLenum cap, GLuint index )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   _mesa_set_enablei(ctx, cap, index, GL_FALSE);

+}

+

+

+void GLAPIENTRY

+_mesa_EnableIndexed( GLenum cap, GLuint index )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   _mesa_set_enablei(ctx, cap, index, GL_TRUE);

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsEnabledIndexed( GLenum cap, GLuint index )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   switch (cap) {

+   case GL_BLEND:

+      if (index >= ctx->Const.MaxDrawBuffers) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",

+                     index);

+         return GL_FALSE;

+      }

+      return (ctx->Color.BlendEnabled >> index) & 1;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",

+                  _mesa_lookup_enum_by_nr(cap));

+      return GL_FALSE;

+   }

+}

+

+

+

+

+#undef CHECK_EXTENSION

+#define CHECK_EXTENSION(EXTNAME)			\

+   if (!ctx->Extensions.EXTNAME) {			\

+      goto invalid_enum_error;				\

+   }

+

+#undef CHECK_EXTENSION2

+#define CHECK_EXTENSION2(EXT1, EXT2)				\

+   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {	\

+      goto invalid_enum_error;					\

+   }

+

+

+/**

+ * Helper function to determine whether a texture target is enabled.

+ */

+static GLboolean

+is_texture_enabled(struct gl_context *ctx, GLbitfield bit)

+{

+   const struct gl_texture_unit *const texUnit =

+       &ctx->Texture.Unit[ctx->Texture.CurrentUnit];

+   return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;

+}

+

+

+/**

+ * Return simple enable/disable state.

+ *

+ * \param cap  state variable to query.

+ *

+ * Returns the state of the specified capability from the current GL context.

+ * For the capabilities associated with extensions verifies that those

+ * extensions are effectively present before reporting.

+ */

+GLboolean GLAPIENTRY

+_mesa_IsEnabled( GLenum cap )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   switch (cap) {

+      case GL_ALPHA_TEST:

+         return ctx->Color.AlphaEnabled;

+      case GL_AUTO_NORMAL:

+	 return ctx->Eval.AutoNormal;

+      case GL_BLEND:

+         return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */

+      case GL_CLIP_PLANE0:

+      case GL_CLIP_PLANE1:

+      case GL_CLIP_PLANE2:

+      case GL_CLIP_PLANE3:

+      case GL_CLIP_PLANE4:

+      case GL_CLIP_PLANE5:

+	 return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;

+      case GL_COLOR_MATERIAL:

+	 return ctx->Light.ColorMaterialEnabled;

+      case GL_CULL_FACE:

+         return ctx->Polygon.CullFlag;

+      case GL_DEPTH_TEST:

+         return ctx->Depth.Test;

+      case GL_DITHER:

+	 return ctx->Color.DitherFlag;

+      case GL_FOG:

+	 return ctx->Fog.Enabled;

+      case GL_LIGHTING:

+         return ctx->Light.Enabled;

+      case GL_LIGHT0:

+      case GL_LIGHT1:

+      case GL_LIGHT2:

+      case GL_LIGHT3:

+      case GL_LIGHT4:

+      case GL_LIGHT5:

+      case GL_LIGHT6:

+      case GL_LIGHT7:

+         return ctx->Light.Light[cap-GL_LIGHT0].Enabled;

+      case GL_LINE_SMOOTH:

+	 return ctx->Line.SmoothFlag;

+      case GL_LINE_STIPPLE:

+	 return ctx->Line.StippleFlag;

+      case GL_INDEX_LOGIC_OP:

+	 return ctx->Color.IndexLogicOpEnabled;

+      case GL_COLOR_LOGIC_OP:

+	 return ctx->Color.ColorLogicOpEnabled;

+      case GL_MAP1_COLOR_4:

+	 return ctx->Eval.Map1Color4;

+      case GL_MAP1_INDEX:

+	 return ctx->Eval.Map1Index;

+      case GL_MAP1_NORMAL:

+	 return ctx->Eval.Map1Normal;

+      case GL_MAP1_TEXTURE_COORD_1:

+	 return ctx->Eval.Map1TextureCoord1;

+      case GL_MAP1_TEXTURE_COORD_2:

+	 return ctx->Eval.Map1TextureCoord2;

+      case GL_MAP1_TEXTURE_COORD_3:

+	 return ctx->Eval.Map1TextureCoord3;

+      case GL_MAP1_TEXTURE_COORD_4:

+	 return ctx->Eval.Map1TextureCoord4;

+      case GL_MAP1_VERTEX_3:

+	 return ctx->Eval.Map1Vertex3;

+      case GL_MAP1_VERTEX_4:

+	 return ctx->Eval.Map1Vertex4;

+      case GL_MAP2_COLOR_4:

+	 return ctx->Eval.Map2Color4;

+      case GL_MAP2_INDEX:

+	 return ctx->Eval.Map2Index;

+      case GL_MAP2_NORMAL:

+	 return ctx->Eval.Map2Normal;

+      case GL_MAP2_TEXTURE_COORD_1:

+	 return ctx->Eval.Map2TextureCoord1;

+      case GL_MAP2_TEXTURE_COORD_2:

+	 return ctx->Eval.Map2TextureCoord2;

+      case GL_MAP2_TEXTURE_COORD_3:

+	 return ctx->Eval.Map2TextureCoord3;

+      case GL_MAP2_TEXTURE_COORD_4:

+	 return ctx->Eval.Map2TextureCoord4;

+      case GL_MAP2_VERTEX_3:

+	 return ctx->Eval.Map2Vertex3;

+      case GL_MAP2_VERTEX_4:

+	 return ctx->Eval.Map2Vertex4;

+      case GL_NORMALIZE:

+	 return ctx->Transform.Normalize;

+      case GL_POINT_SMOOTH:

+	 return ctx->Point.SmoothFlag;

+      case GL_POLYGON_SMOOTH:

+	 return ctx->Polygon.SmoothFlag;

+      case GL_POLYGON_STIPPLE:

+	 return ctx->Polygon.StippleFlag;

+      case GL_POLYGON_OFFSET_POINT:

+	 return ctx->Polygon.OffsetPoint;

+      case GL_POLYGON_OFFSET_LINE:

+	 return ctx->Polygon.OffsetLine;

+      case GL_POLYGON_OFFSET_FILL:

+      /*case GL_POLYGON_OFFSET_EXT:*/

+	 return ctx->Polygon.OffsetFill;

+      case GL_RESCALE_NORMAL_EXT:

+         return ctx->Transform.RescaleNormals;

+      case GL_SCISSOR_TEST:

+	 return ctx->Scissor.Enabled;

+      case GL_SHARED_TEXTURE_PALETTE_EXT:

+         return ctx->Texture.SharedPalette;

+      case GL_STENCIL_TEST:

+	 return ctx->Stencil.Enabled;

+      case GL_TEXTURE_1D:

+         return is_texture_enabled(ctx, TEXTURE_1D_BIT);

+      case GL_TEXTURE_2D:

+         return is_texture_enabled(ctx, TEXTURE_2D_BIT);

+      case GL_TEXTURE_3D:

+         return is_texture_enabled(ctx, TEXTURE_3D_BIT);

+      case GL_TEXTURE_GEN_Q:

+         {

+            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;

+            }

+         }

+         return GL_FALSE;

+      case GL_TEXTURE_GEN_R:

+         {

+            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;

+            }

+         }

+         return GL_FALSE;

+      case GL_TEXTURE_GEN_S:

+         {

+            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;

+            }

+         }

+         return GL_FALSE;

+      case GL_TEXTURE_GEN_T:

+         {

+            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+               return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;

+            }

+         }

+         return GL_FALSE;

+#if FEATURE_ES1

+      case GL_TEXTURE_GEN_STR_OES:

+	 {

+            const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);

+            if (texUnit) {

+		    return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE;

+            }

+         }

+#endif

+

+      /*

+       * CLIENT STATE!!!

+       */

+      case GL_VERTEX_ARRAY:

+         return (ctx->Array.ArrayObj->Vertex.Enabled != 0);

+      case GL_NORMAL_ARRAY:

+         return (ctx->Array.ArrayObj->Normal.Enabled != 0);

+      case GL_COLOR_ARRAY:

+         return (ctx->Array.ArrayObj->Color.Enabled != 0);

+      case GL_INDEX_ARRAY:

+         return (ctx->Array.ArrayObj->Index.Enabled != 0);

+      case GL_TEXTURE_COORD_ARRAY:

+         return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);

+      case GL_EDGE_FLAG_ARRAY:

+         return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);

+      case GL_FOG_COORDINATE_ARRAY_EXT:

+         CHECK_EXTENSION(EXT_fog_coord);

+         return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);

+      case GL_SECONDARY_COLOR_ARRAY_EXT:

+         CHECK_EXTENSION(EXT_secondary_color);

+         return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);

+#if FEATURE_point_size_array

+      case GL_POINT_SIZE_ARRAY_OES:

+         return (ctx->Array.ArrayObj->PointSize.Enabled != 0);

+#endif

+

+      /* GL_ARB_texture_cube_map */

+      case GL_TEXTURE_CUBE_MAP_ARB:

+         CHECK_EXTENSION(ARB_texture_cube_map);

+         return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);

+

+      /* GL_EXT_secondary_color */

+      case GL_COLOR_SUM_EXT:

+         CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);

+         return ctx->Fog.ColorSumEnabled;

+

+      /* GL_ARB_multisample */

+      case GL_MULTISAMPLE_ARB:

+         return ctx->Multisample.Enabled;

+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:

+         return ctx->Multisample.SampleAlphaToCoverage;

+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:

+         return ctx->Multisample.SampleAlphaToOne;

+      case GL_SAMPLE_COVERAGE_ARB:

+         return ctx->Multisample.SampleCoverage;

+      case GL_SAMPLE_COVERAGE_INVERT_ARB:

+         return ctx->Multisample.SampleCoverageInvert;

+

+      /* GL_IBM_rasterpos_clip */

+      case GL_RASTER_POSITION_UNCLIPPED_IBM:

+         CHECK_EXTENSION(IBM_rasterpos_clip);

+         return ctx->Transform.RasterPositionUnclipped;

+

+      /* GL_NV_point_sprite */

+      case GL_POINT_SPRITE_NV:

+         CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)

+         return ctx->Point.PointSprite;

+

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+      case GL_VERTEX_PROGRAM_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);

+         return ctx->VertexProgram.Enabled;

+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);

+         return ctx->VertexProgram.PointSizeEnabled;

+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:

+         CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);

+         return ctx->VertexProgram.TwoSideEnabled;

+#endif

+#if FEATURE_NV_vertex_program

+      case GL_VERTEX_ATTRIB_ARRAY0_NV:

+      case GL_VERTEX_ATTRIB_ARRAY1_NV:

+      case GL_VERTEX_ATTRIB_ARRAY2_NV:

+      case GL_VERTEX_ATTRIB_ARRAY3_NV:

+      case GL_VERTEX_ATTRIB_ARRAY4_NV:

+      case GL_VERTEX_ATTRIB_ARRAY5_NV:

+      case GL_VERTEX_ATTRIB_ARRAY6_NV:

+      case GL_VERTEX_ATTRIB_ARRAY7_NV:

+      case GL_VERTEX_ATTRIB_ARRAY8_NV:

+      case GL_VERTEX_ATTRIB_ARRAY9_NV:

+      case GL_VERTEX_ATTRIB_ARRAY10_NV:

+      case GL_VERTEX_ATTRIB_ARRAY11_NV:

+      case GL_VERTEX_ATTRIB_ARRAY12_NV:

+      case GL_VERTEX_ATTRIB_ARRAY13_NV:

+      case GL_VERTEX_ATTRIB_ARRAY14_NV:

+      case GL_VERTEX_ATTRIB_ARRAY15_NV:

+         CHECK_EXTENSION(NV_vertex_program);

+         {

+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;

+            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));

+            return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);

+         }

+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:

+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:

+         CHECK_EXTENSION(NV_vertex_program);

+         {

+            const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);

+            return ctx->Eval.Map1Attrib[map];

+         }

+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:

+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:

+         CHECK_EXTENSION(NV_vertex_program);

+         {

+            const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);

+            return ctx->Eval.Map2Attrib[map];

+         }

+#endif /* FEATURE_NV_vertex_program */

+

+#if FEATURE_NV_fragment_program

+      case GL_FRAGMENT_PROGRAM_NV:

+         CHECK_EXTENSION(NV_fragment_program);

+         return ctx->FragmentProgram.Enabled;

+#endif /* FEATURE_NV_fragment_program */

+

+      /* GL_NV_texture_rectangle */

+      case GL_TEXTURE_RECTANGLE_NV:

+         CHECK_EXTENSION(NV_texture_rectangle);

+         return is_texture_enabled(ctx, TEXTURE_RECT_BIT);

+

+      /* GL_EXT_stencil_two_side */

+      case GL_STENCIL_TEST_TWO_SIDE_EXT:

+         CHECK_EXTENSION(EXT_stencil_two_side);

+         return ctx->Stencil.TestTwoSide;

+

+#if FEATURE_ARB_fragment_program

+      case GL_FRAGMENT_PROGRAM_ARB:

+         return ctx->FragmentProgram.Enabled;

+#endif /* FEATURE_ARB_fragment_program */

+

+      /* GL_EXT_depth_bounds_test */

+      case GL_DEPTH_BOUNDS_TEST_EXT:

+         CHECK_EXTENSION(EXT_depth_bounds_test);

+         return ctx->Depth.BoundsTest;

+

+      /* GL_ARB_depth_clamp */

+      case GL_DEPTH_CLAMP:

+         CHECK_EXTENSION(ARB_depth_clamp);

+         return ctx->Transform.DepthClamp;

+

+#if FEATURE_ATI_fragment_shader

+      case GL_FRAGMENT_SHADER_ATI:

+	 CHECK_EXTENSION(ATI_fragment_shader);

+	 return ctx->ATIFragmentShader.Enabled;

+#endif /* FEATURE_ATI_fragment_shader */

+

+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:

+	 CHECK_EXTENSION(ARB_seamless_cube_map);

+	 return ctx->Texture.CubeMapSeamless;

+

+#if FEATURE_EXT_transform_feedback

+      case GL_RASTERIZER_DISCARD:

+	 CHECK_EXTENSION(EXT_transform_feedback);

+         return ctx->TransformFeedback.RasterDiscard;

+#endif

+

+      /* GL_NV_primitive_restart */

+      case GL_PRIMITIVE_RESTART_NV:

+	 if (!ctx->Extensions.NV_primitive_restart) {

+            goto invalid_enum_error;

+         }

+         return ctx->Array.PrimitiveRestart;

+

+      /* GL 3.1 primitive restart */

+      case GL_PRIMITIVE_RESTART:

+         if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {

+            goto invalid_enum_error;

+         }

+         return ctx->Array.PrimitiveRestart;

+

+      /* GL3.0 - GL_framebuffer_sRGB */

+      case GL_FRAMEBUFFER_SRGB_EXT:

+	 CHECK_EXTENSION(EXT_framebuffer_sRGB);

+	 return ctx->Color.sRGBEnabled;

+

+      default:

+         goto invalid_enum_error;

+   }

+

+   return GL_FALSE;

+

+invalid_enum_error:

+   _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);

+   return GL_FALSE;

+}

diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c
index 68740e24c..6de0ca696 100644
--- a/mesalib/src/mesa/main/extensions.c
+++ b/mesalib/src/mesa/main/extensions.c
@@ -1,917 +1,917 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file
- * \brief Extension handling
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "context.h"
-#include "extensions.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-
-enum {
-   DISABLE = 0,
-   GL  = 1 << API_OPENGL,
-   ES1 = 1 << API_OPENGLES,
-   ES2 = 1 << API_OPENGLES2,
-};
-
-/**
- * \brief An element of the \c extension_table.
- */
-struct extension {
-   /** Name of extension, such as "GL_ARB_depth_clamp". */
-   const char *name;
-
-   /** Offset (in bytes) of the corresponding member in struct gl_extensions. */
-   size_t offset;
-
-   /** Set of API's in which the extension exists, as a bitset. */
-   uint8_t api_set;
-};
-
-
-/**
- * Given a member \c x of struct gl_extensions, return offset of
- * \c x in bytes.
- */
-#define o(x) offsetof(struct gl_extensions, x)
-
-
-/**
- * \brief Table of supported OpenGL extensions for all API's.
- *
- * Note: The GL_MESAX_* extensions are placeholders for future ARB extensions.
- */
-static const struct extension extension_table[] = {
-   /* ARB Extensions */
-   { "GL_ARB_ES2_compatibility",                   o(ARB_ES2_compatibility),                   GL             },
-   { "GL_ARB_blend_func_extended",                 o(ARB_blend_func_extended),                 GL             },
-   { "GL_ARB_copy_buffer",                         o(ARB_copy_buffer),                         GL             },
-   { "GL_ARB_depth_buffer_float",                  o(ARB_depth_buffer_float),                  GL             },
-   { "GL_ARB_depth_clamp",                         o(ARB_depth_clamp),                         GL             },
-   { "GL_ARB_depth_texture",                       o(ARB_depth_texture),                       GL             },
-   { "GL_ARB_draw_buffers",                        o(ARB_draw_buffers),                        GL             },
-   { "GL_ARB_draw_buffers_blend",                  o(ARB_draw_buffers_blend),                  GL             },
-   { "GL_ARB_draw_elements_base_vertex",           o(ARB_draw_elements_base_vertex),           GL             },
-   { "GL_ARB_draw_instanced",                      o(ARB_draw_instanced),                      GL             },
-   { "GL_ARB_explicit_attrib_location",            o(ARB_explicit_attrib_location),            GL             },
-   { "GL_ARB_fragment_coord_conventions",          o(ARB_fragment_coord_conventions),          GL             },
-   { "GL_ARB_fragment_program",                    o(ARB_fragment_program),                    GL             },
-   { "GL_ARB_fragment_program_shadow",             o(ARB_fragment_program_shadow),             GL             },
-   { "GL_ARB_fragment_shader",                     o(ARB_fragment_shader),                     GL             },
-   { "GL_ARB_framebuffer_object",                  o(ARB_framebuffer_object),                  GL             },
-   { "GL_ARB_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL             },
-   { "GL_ARB_half_float_pixel",                    o(ARB_half_float_pixel),                    GL             },
-   { "GL_ARB_half_float_vertex",                   o(ARB_half_float_vertex),                   GL             },
-   { "GL_ARB_instanced_arrays",                    o(ARB_instanced_arrays),                    GL             },
-   { "GL_ARB_map_buffer_range",                    o(ARB_map_buffer_range),                    GL             },
-   { "GL_ARB_multisample",                         o(ARB_multisample),                         GL             },
-   { "GL_ARB_multitexture",                        o(ARB_multitexture),                        GL             },
-   { "GL_ARB_occlusion_query2",                    o(ARB_occlusion_query2),                    GL             },
-   { "GL_ARB_occlusion_query",                     o(ARB_occlusion_query),                     GL             },
-   { "GL_ARB_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL             },
-   { "GL_ARB_point_parameters",                    o(EXT_point_parameters),                    GL             },
-   { "GL_ARB_point_sprite",                        o(ARB_point_sprite),                        GL             },
-   { "GL_ARB_provoking_vertex",                    o(EXT_provoking_vertex),                    GL             },
-   { "GL_ARB_sampler_objects",                     o(ARB_sampler_objects),                     GL             },
-   { "GL_ARB_seamless_cube_map",                   o(ARB_seamless_cube_map),                   GL             },
-   { "GL_ARB_shader_objects",                      o(ARB_shader_objects),                      GL             },
-   { "GL_ARB_shader_stencil_export",               o(ARB_shader_stencil_export),               GL             },
-   { "GL_ARB_shading_language_100",                o(ARB_shading_language_100),                GL             },
-   { "GL_ARB_shadow_ambient",                      o(ARB_shadow_ambient),                      GL             },
-   { "GL_ARB_shadow",                              o(ARB_shadow),                              GL             },
-   { "GL_ARB_sync",                                o(ARB_sync),                                GL             },
-   { "GL_ARB_texture_border_clamp",                o(ARB_texture_border_clamp),                GL             },
-   { "GL_ARB_texture_buffer_object",               o(ARB_texture_buffer_object),               GL             },
-   { "GL_ARB_texture_compression",                 o(ARB_texture_compression),                 GL             },
-   { "GL_ARB_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL             },
-   { "GL_ARB_texture_cube_map",                    o(ARB_texture_cube_map),                    GL             },
-   { "GL_ARB_texture_env_add",                     o(EXT_texture_env_add),                     GL             },
-   { "GL_ARB_texture_env_combine",                 o(ARB_texture_env_combine),                 GL             },
-   { "GL_ARB_texture_env_crossbar",                o(ARB_texture_env_crossbar),                GL             },
-   { "GL_ARB_texture_env_dot3",                    o(ARB_texture_env_dot3),                    GL             },
-   { "GL_ARB_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),             GL             },
-   { "GL_ARB_texture_multisample",                 o(ARB_texture_multisample),                 GL             },
-   { "GL_ARB_texture_non_power_of_two",            o(ARB_texture_non_power_of_two),            GL             },
-   { "GL_ARB_texture_rectangle",                   o(NV_texture_rectangle),                    GL             },
-   { "GL_ARB_texture_rgb10_a2ui",                  o(ARB_texture_rgb10_a2ui),                  GL             },
-   { "GL_ARB_texture_rg",                          o(ARB_texture_rg),                          GL             },
-   { "GL_ARB_texture_swizzle",                     o(EXT_texture_swizzle),                     GL             },
-   { "GL_ARB_transform_feedback2",                 o(ARB_transform_feedback2),                 GL             },
-   { "GL_ARB_transpose_matrix",                    o(ARB_transpose_matrix),                    GL             },
-   { "GL_ARB_uniform_buffer_object",               o(ARB_uniform_buffer_object),               GL             },
-   { "GL_ARB_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL             },
-   { "GL_ARB_vertex_array_object",                 o(ARB_vertex_array_object),                 GL             },
-   { "GL_ARB_vertex_buffer_object",                o(ARB_vertex_buffer_object),                GL             },
-   { "GL_ARB_vertex_program",                      o(ARB_vertex_program),                      GL             },
-   { "GL_ARB_vertex_shader",                       o(ARB_vertex_shader),                       GL             },
-   { "GL_ARB_vertex_type_2_10_10_10_rev",          o(ARB_vertex_type_2_10_10_10_rev),          GL             },
-   { "GL_ARB_window_pos",                          o(ARB_window_pos),                          GL             },
-
-   /* EXT extensions */
-   { "GL_EXT_abgr",                                o(EXT_abgr),                                GL             },
-   { "GL_EXT_bgra",                                o(EXT_bgra),                                GL             },
-   { "GL_EXT_blend_color",                         o(EXT_blend_color),                         GL             },
-   { "GL_EXT_blend_equation_separate",             o(EXT_blend_equation_separate),             GL             },
-   { "GL_EXT_blend_func_separate",                 o(EXT_blend_func_separate),                 GL             },
-   { "GL_EXT_blend_logic_op",                      o(EXT_blend_logic_op),                      GL             },
-   { "GL_EXT_blend_minmax",                        o(EXT_blend_minmax),                        GL | ES1 | ES2 },
-   { "GL_EXT_blend_subtract",                      o(EXT_blend_subtract),                      GL             },
-   { "GL_EXT_clip_volume_hint",                    o(EXT_clip_volume_hint),                    GL             },
-   { "GL_EXT_compiled_vertex_array",               o(EXT_compiled_vertex_array),               GL             },
-   { "GL_EXT_copy_texture",                        o(EXT_copy_texture),                        GL             },
-   { "GL_EXT_depth_bounds_test",                   o(EXT_depth_bounds_test),                   GL             },
-   { "GL_EXT_draw_buffers2",                       o(EXT_draw_buffers2),                       GL             },
-   { "GL_EXT_draw_instanced",                      o(ARB_draw_instanced),                      GL             },
-   { "GL_EXT_draw_range_elements",                 o(EXT_draw_range_elements),                 GL             },
-   { "GL_EXT_fog_coord",                           o(EXT_fog_coord),                           GL             },
-   { "GL_EXT_framebuffer_blit",                    o(EXT_framebuffer_blit),                    GL             },
-   { "GL_EXT_framebuffer_multisample",             o(EXT_framebuffer_multisample),             GL             },
-   { "GL_EXT_framebuffer_object",                  o(EXT_framebuffer_object),                  GL             },
-   { "GL_EXT_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL             },
-   { "GL_EXT_gpu_program_parameters",              o(EXT_gpu_program_parameters),              GL             },
-   { "GL_EXT_gpu_shader4",                         o(EXT_gpu_shader4),                         GL             },
-   { "GL_EXT_multi_draw_arrays",                   o(EXT_multi_draw_arrays),                   GL | ES1 | ES2 },
-   { "GL_EXT_packed_depth_stencil",                o(EXT_packed_depth_stencil),                GL             },
-   { "GL_EXT_packed_float",                        o(EXT_packed_float),                        GL             },
-   { "GL_EXT_packed_pixels",                       o(EXT_packed_pixels),                       GL             },
-   { "GL_EXT_paletted_texture",                    o(EXT_paletted_texture),                    GL             },
-   { "GL_EXT_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL             },
-   { "GL_EXT_point_parameters",                    o(EXT_point_parameters),                    GL             },
-   { "GL_EXT_polygon_offset",                      o(EXT_polygon_offset),                      GL             },
-   { "GL_EXT_provoking_vertex",                    o(EXT_provoking_vertex),                    GL             },
-   { "GL_EXT_rescale_normal",                      o(EXT_rescale_normal),                      GL             },
-   { "GL_EXT_secondary_color",                     o(EXT_secondary_color),                     GL             },
-   { "GL_EXT_separate_shader_objects",             o(EXT_separate_shader_objects),             GL             },
-   { "GL_EXT_separate_specular_color",             o(EXT_separate_specular_color),             GL             },
-   { "GL_EXT_shadow_funcs",                        o(EXT_shadow_funcs),                        GL             },
-   { "GL_EXT_shared_texture_palette",              o(EXT_shared_texture_palette),              GL             },
-   { "GL_EXT_stencil_two_side",                    o(EXT_stencil_two_side),                    GL             },
-   { "GL_EXT_stencil_wrap",                        o(EXT_stencil_wrap),                        GL             },
-   { "GL_EXT_subtexture",                          o(EXT_subtexture),                          GL             },
-   { "GL_EXT_texture3D",                           o(EXT_texture3D),                           GL             },
-   { "GL_EXT_texture_array",                       o(EXT_texture_array),                       GL             },
-   { "GL_EXT_texture_compression_dxt1",            o(EXT_texture_compression_s3tc),            GL | ES1 | ES2 },
-   { "GL_EXT_texture_compression_latc",            o(EXT_texture_compression_latc),            GL             },
-   { "GL_EXT_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL             },
-   { "GL_EXT_texture_compression_s3tc",            o(EXT_texture_compression_s3tc),            GL             },
-   { "GL_EXT_texture_cube_map",                    o(ARB_texture_cube_map),                    GL             },
-   { "GL_EXT_texture_edge_clamp",                  o(SGIS_texture_edge_clamp),                 GL             },
-   { "GL_EXT_texture_env_add",                     o(EXT_texture_env_add),                     GL             },
-   { "GL_EXT_texture_env_combine",                 o(EXT_texture_env_combine),                 GL             },
-   { "GL_EXT_texture_env_dot3",                    o(EXT_texture_env_dot3),                    GL             },
-   { "GL_EXT_texture_filter_anisotropic",          o(EXT_texture_filter_anisotropic),          GL | ES1 | ES2 },
-   { "GL_EXT_texture_format_BGRA8888",             o(EXT_texture_format_BGRA8888),                  ES1 | ES2 },
-   { "GL_EXT_texture_integer",                     o(EXT_texture_integer),                     GL             },
-   { "GL_EXT_texture_lod_bias",                    o(EXT_texture_lod_bias),                    GL | ES1       },
-   { "GL_EXT_texture_mirror_clamp",                o(EXT_texture_mirror_clamp),                GL             },
-   { "GL_EXT_texture_object",                      o(EXT_texture_object),                      GL             },
-   { "GL_EXT_texture",                             o(EXT_texture),                             GL             },
-   { "GL_EXT_texture_rectangle",                   o(NV_texture_rectangle),                    GL             },
-   { "GL_EXT_texture_shared_exponent",             o(EXT_texture_shared_exponent),             GL             },
-   { "GL_EXT_texture_sRGB",                        o(EXT_texture_sRGB),                        GL             },
-   { "GL_EXT_texture_sRGB_decode",                 o(EXT_texture_sRGB_decode),                        GL             },
-   { "GL_EXT_texture_swizzle",                     o(EXT_texture_swizzle),                     GL             },
-   { "GL_EXT_texture_type_2_10_10_10_REV",         o(dummy_true),                                         ES2 },
-   { "GL_EXT_timer_query",                         o(EXT_timer_query),                         GL             },
-   { "GL_EXT_transform_feedback",                  o(EXT_transform_feedback),                  GL             },
-   { "GL_EXT_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL             },
-   { "GL_EXT_vertex_array",                        o(EXT_vertex_array),                        GL             },
-   { "GL_EXT_vertex_array_set",                    o(EXT_vertex_array_set),                    GL             },
-
-   /* OES extensions */
-   { "GL_OES_blend_equation_separate",             o(EXT_blend_equation_separate),                  ES1       },
-   { "GL_OES_blend_func_separate",                 o(EXT_blend_func_separate),                      ES1       },
-   { "GL_OES_blend_subtract",                      o(EXT_blend_subtract),                           ES1       },
-   { "GL_OES_byte_coordinates",                    o(dummy_true),                                   ES1       },
-   { "GL_OES_compressed_paletted_texture",         o(dummy_false),                     DISABLE                },
-   { "GL_OES_depth24",                             o(EXT_framebuffer_object),                       ES1 | ES2 },
-   { "GL_OES_depth32",                             o(dummy_false),                     DISABLE                },
-   { "GL_OES_depth_texture",                       o(ARB_depth_texture),                                  ES2 },
-#if FEATURE_OES_draw_texture
-   { "GL_OES_draw_texture",                        o(OES_draw_texture),                             ES1 | ES2 },
-#endif
-#if FEATURE_OES_EGL_image
-   /*  FIXME: Mesa expects GL_OES_EGL_image to be available in OpenGL contexts. */
-   { "GL_OES_EGL_image",                           o(OES_EGL_image),                           GL | ES1 | ES2 },
-#endif
-   { "GL_OES_element_index_uint",                  o(EXT_vertex_array),                             ES1 | ES2 },
-   { "GL_OES_fbo_render_mipmap",                   o(EXT_framebuffer_object),                       ES1 | ES2 },
-   { "GL_OES_fixed_point",                         o(dummy_true),                                   ES1       },
-   { "GL_OES_framebuffer_object",                  o(EXT_framebuffer_object),                       ES1       },
-   { "GL_OES_mapbuffer",                           o(ARB_vertex_buffer_object),                     ES1 | ES2 },
-   { "GL_OES_matrix_get",                          o(dummy_true),                                   ES1       },
-   { "GL_OES_packed_depth_stencil",                o(EXT_packed_depth_stencil),                     ES1 | ES2 },
-   { "GL_OES_point_size_array",                    o(dummy_true),                                   ES1       },
-   { "GL_OES_point_sprite",                        o(ARB_point_sprite),                             ES1       },
-   { "GL_OES_query_matrix",                        o(dummy_true),                                   ES1       },
-   { "GL_OES_read_format",                         o(OES_read_format),                         GL | ES1       },
-   { "GL_OES_rgb8_rgba8",                          o(EXT_framebuffer_object),                       ES1 | ES2 },
-   { "GL_OES_single_precision",                    o(dummy_true),                                   ES1       },
-   { "GL_OES_standard_derivatives",                o(OES_standard_derivatives),                           ES2 },
-   { "GL_OES_stencil1",                            o(dummy_false),                     DISABLE                },
-   { "GL_OES_stencil4",                            o(dummy_false),                     DISABLE                },
-   { "GL_OES_stencil8",                            o(EXT_framebuffer_object),                       ES1 | ES2 },
-   { "GL_OES_stencil_wrap",                        o(EXT_stencil_wrap),                             ES1       },
-   { "GL_OES_texture_3D",                          o(EXT_texture3D),                                      ES2 },
-   { "GL_OES_texture_cube_map",                    o(ARB_texture_cube_map),                         ES1       },
-   { "GL_OES_texture_env_crossbar",                o(ARB_texture_env_crossbar),                     ES1       },
-   { "GL_OES_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),                  ES1       },
-   { "GL_OES_texture_npot",                        o(ARB_texture_non_power_of_two),                       ES2 },
-
-   /* Vendor extensions */
-   { "GL_3DFX_texture_compression_FXT1",           o(TDFX_texture_compression_FXT1),           GL             },
-   { "GL_AMD_conservative_depth",                  o(AMD_conservative_depth),                  GL             },
-   { "GL_APPLE_client_storage",                    o(APPLE_client_storage),                    GL             },
-   { "GL_APPLE_object_purgeable",                  o(APPLE_object_purgeable),                  GL             },
-   { "GL_APPLE_packed_pixels",                     o(APPLE_packed_pixels),                     GL             },
-   { "GL_APPLE_vertex_array_object",               o(APPLE_vertex_array_object),               GL             },
-   { "GL_ATI_blend_equation_separate",             o(EXT_blend_equation_separate),             GL             },
-   { "GL_ATI_envmap_bumpmap",                      o(ATI_envmap_bumpmap),                      GL             },
-   { "GL_ATI_fragment_shader",                     o(ATI_fragment_shader),                     GL             },
-   { "GL_ATI_separate_stencil",                    o(ATI_separate_stencil),                    GL             },
-   { "GL_ATI_texture_compression_3dc",             o(ATI_texture_compression_3dc),             GL             },
-   { "GL_ATI_texture_env_combine3",                o(ATI_texture_env_combine3),                GL             },
-   { "GL_ATI_texture_mirror_once",                 o(ATI_texture_mirror_once),                 GL             },
-   { "GL_IBM_multimode_draw_arrays",               o(IBM_multimode_draw_arrays),               GL             },
-   { "GL_IBM_rasterpos_clip",                      o(IBM_rasterpos_clip),                      GL             },
-   { "GL_IBM_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),             GL             },
-   { "GL_INGR_blend_func_separate",                o(EXT_blend_func_separate),                 GL             },
-   { "GL_MESA_pack_invert",                        o(MESA_pack_invert),                        GL             },
-   { "GL_MESA_resize_buffers",                     o(MESA_resize_buffers),                     GL             },
-   { "GL_MESA_texture_array",                      o(MESA_texture_array),                      GL             },
-   { "GL_MESA_texture_signed_rgba",                o(MESA_texture_signed_rgba),                GL             },
-   { "GL_MESA_window_pos",                         o(ARB_window_pos),                          GL             },
-   { "GL_MESAX_texture_float",                     o(ARB_texture_float),                       GL             },
-   { "GL_MESA_ycbcr_texture",                      o(MESA_ycbcr_texture),                      GL             },
-   { "GL_NV_blend_square",                         o(NV_blend_square),                         GL             },
-   { "GL_NV_conditional_render",                   o(NV_conditional_render),                   GL             },
-   { "GL_NV_depth_clamp",                          o(ARB_depth_clamp),                         GL             },
-   { "GL_NV_fragment_program",                     o(NV_fragment_program),                     GL             },
-   { "GL_NV_fragment_program_option",              o(NV_fragment_program_option),              GL             },
-   { "GL_NV_light_max_exponent",                   o(NV_light_max_exponent),                   GL             },
-   { "GL_NV_packed_depth_stencil",                 o(EXT_packed_depth_stencil),                GL             },
-   { "GL_NV_point_sprite",                         o(NV_point_sprite),                         GL             },
-   { "GL_NV_primitive_restart",                    o(NV_primitive_restart),                    GL             },
-   { "GL_NV_texgen_reflection",                    o(NV_texgen_reflection),                    GL             },
-   { "GL_NV_texture_env_combine4",                 o(NV_texture_env_combine4),                 GL             },
-   { "GL_NV_texture_rectangle",                    o(NV_texture_rectangle),                    GL             },
-   { "GL_NV_vertex_program1_1",                    o(NV_vertex_program1_1),                    GL             },
-   { "GL_NV_vertex_program",                       o(NV_vertex_program),                       GL             },
-   { "GL_S3_s3tc",                                 o(S3_s3tc),                                 GL             },
-   { "GL_SGIS_generate_mipmap",                    o(SGIS_generate_mipmap),                    GL             },
-   { "GL_SGIS_texture_border_clamp",               o(ARB_texture_border_clamp),                GL             },
-   { "GL_SGIS_texture_edge_clamp",                 o(SGIS_texture_edge_clamp),                 GL             },
-   { "GL_SGIS_texture_lod",                        o(SGIS_texture_lod),                        GL             },
-   { "GL_SUN_multi_draw_arrays",                   o(EXT_multi_draw_arrays),                   GL             },
-
-   { 0, 0, 0 },
-};
-
-
-/**
- * Given an extension name, lookup up the corresponding member of struct
- * gl_extensions and return that member's offset (in bytes).  If the name is
- * not found in the \c extension_table, return 0.
- *
- * \param name Name of extension.
- * \return Offset of member in struct gl_extensions.
- */
-static size_t
-name_to_offset(const char* name)
-{
-   const struct extension *i;
-
-   if (name == 0)
-      return 0;
-
-   for (i = extension_table; i->name != 0; ++i) {
-      if (strcmp(name, i->name) == 0)
-	 return i->offset;
-   }
-
-   return 0;
-}
-
-
-/**
- * \brief Extensions enabled by default.
- *
- * These extensions are enabled by _mesa_init_extensions().
- *
- * XXX: Should these defaults also apply to GLES?
- */
-static const size_t default_extensions[] = {
-   o(ARB_copy_buffer),
-   o(ARB_draw_buffers),
-   o(ARB_multisample),
-   o(ARB_texture_compression),
-   o(ARB_transpose_matrix),
-   o(ARB_vertex_buffer_object),
-   o(ARB_window_pos),
-
-   o(EXT_abgr),
-   o(EXT_bgra),
-   o(EXT_compiled_vertex_array),
-   o(EXT_copy_texture),
-   o(EXT_draw_range_elements),
-   o(EXT_multi_draw_arrays),
-   o(EXT_packed_pixels),
-   o(EXT_polygon_offset),
-   o(EXT_rescale_normal),
-   o(EXT_separate_specular_color),
-   o(EXT_subtexture),
-   o(EXT_texture),
-   o(EXT_texture3D),
-   o(EXT_texture_object),
-   o(EXT_vertex_array),
-
-   o(OES_read_format),
-   o(OES_standard_derivatives),
-
-   /* Vendor Extensions */
-   o(APPLE_packed_pixels),
-   o(IBM_multimode_draw_arrays),
-   o(IBM_rasterpos_clip),
-   o(NV_light_max_exponent),
-   o(NV_texgen_reflection),
-   o(SGIS_generate_mipmap),
-   o(SGIS_texture_edge_clamp),
-   o(SGIS_texture_lod),
-
-   0,
-};
-
-
-/**
- * Enable all extensions suitable for a software-only renderer.
- * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
- */
-void
-_mesa_enable_sw_extensions(struct gl_context *ctx)
-{
-   /*ctx->Extensions.ARB_copy_buffer = GL_TRUE;*/
-   ctx->Extensions.ARB_depth_clamp = GL_TRUE;
-   ctx->Extensions.ARB_depth_texture = GL_TRUE;
-   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
-   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
-   ctx->Extensions.ARB_draw_instanced = GL_TRUE;
-   ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
-   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
-#if FEATURE_ARB_fragment_program
-   ctx->Extensions.ARB_fragment_program = GL_TRUE;
-   ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
-#endif
-#if FEATURE_ARB_fragment_shader
-   ctx->Extensions.ARB_fragment_shader = GL_TRUE;
-#endif
-#if FEATURE_ARB_framebuffer_object
-   ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
-#endif
-#if FEATURE_ARB_geometry_shader4 && 0
-   /* XXX re-enable when GLSL compiler again supports geometry shaders */
-   ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
-#endif
-   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
-   ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
-   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
-   ctx->Extensions.ARB_multitexture = GL_TRUE;
-#if FEATURE_queryobj
-   ctx->Extensions.ARB_occlusion_query = GL_TRUE;
-   ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
-#endif
-   ctx->Extensions.ARB_point_sprite = GL_TRUE;
-#if FEATURE_ARB_shader_objects
-   ctx->Extensions.ARB_shader_objects = GL_TRUE;
-   ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;
-#endif
-#if FEATURE_ARB_shading_language_100
-   ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
-#endif
-   ctx->Extensions.ARB_shadow = GL_TRUE;
-   ctx->Extensions.ARB_shadow_ambient = GL_TRUE;
-   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
-   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
-   /*ctx->Extensions.ARB_texture_float = GL_TRUE;*/
-   ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
-   ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
-   ctx->Extensions.ARB_texture_rg = GL_TRUE;
-   ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
-   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;
-#if FEATURE_ARB_vertex_program
-   ctx->Extensions.ARB_vertex_program = GL_TRUE;
-#endif
-#if FEATURE_ARB_vertex_shader
-   ctx->Extensions.ARB_vertex_shader = GL_TRUE;
-#endif
-#if FEATURE_ARB_vertex_buffer_object
-   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/
-#endif
-#if FEATURE_ARB_sync
-   ctx->Extensions.ARB_sync = GL_TRUE;
-#endif
-   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;
-#if FEATURE_APPLE_object_purgeable
-   ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
-#endif
-   ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE;
-#if FEATURE_ATI_fragment_shader
-   ctx->Extensions.ATI_fragment_shader = GL_TRUE;
-#endif
-   ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
-   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
-   ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
-   ctx->Extensions.ATI_separate_stencil = GL_TRUE;
-   ctx->Extensions.EXT_blend_color = GL_TRUE;
-   ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
-   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
-   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;
-   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
-   ctx->Extensions.EXT_blend_subtract = GL_TRUE;
-   ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
-   ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
-   ctx->Extensions.EXT_fog_coord = GL_TRUE;
-#if FEATURE_EXT_framebuffer_object
-   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;
-#endif
-#if FEATURE_EXT_framebuffer_blit
-   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
-#endif
-#if FEATURE_ARB_framebuffer_object
-   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
-#endif
-   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/
-   ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
-   ctx->Extensions.EXT_paletted_texture = GL_TRUE;
-#if FEATURE_EXT_pixel_buffer_object
-   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
-#endif
-   ctx->Extensions.EXT_point_parameters = GL_TRUE;
-   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
-   ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
-   ctx->Extensions.EXT_secondary_color = GL_TRUE;
-   ctx->Extensions.EXT_shared_texture_palette = GL_TRUE;
-   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
-   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
-   ctx->Extensions.EXT_texture_array = GL_TRUE;
-   ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_add = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
-   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;
-#if FEATURE_EXT_texture_sRGB
-   ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
-   ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
-#endif
-   ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
-#if FEATURE_EXT_transform_feedback
-   /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
-#endif
-   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
-   /*ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;*/
-   ctx->Extensions.MESA_pack_invert = GL_TRUE;
-   ctx->Extensions.MESA_resize_buffers = GL_TRUE;
-   ctx->Extensions.MESA_texture_array = GL_TRUE;
-   ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
-   ctx->Extensions.NV_blend_square = GL_TRUE;
-   ctx->Extensions.NV_conditional_render = GL_TRUE;
-   /*ctx->Extensions.NV_light_max_exponent = GL_TRUE;*/
-   ctx->Extensions.NV_point_sprite = GL_TRUE;
-   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
-   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
-   /*ctx->Extensions.NV_texgen_reflection = GL_TRUE;*/
-#if FEATURE_NV_vertex_program
-   ctx->Extensions.NV_vertex_program = GL_TRUE;
-   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;
-#endif
-#if FEATURE_NV_fragment_program
-   ctx->Extensions.NV_fragment_program = GL_TRUE;
-#endif
-#if FEATURE_NV_fragment_program && FEATURE_ARB_fragment_program
-   ctx->Extensions.NV_fragment_program_option = GL_TRUE;
-#endif
-   /*ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;*/
-   ctx->Extensions.SGIS_texture_edge_clamp = GL_TRUE;
-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
-   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
-#endif
-#if FEATURE_texture_fxt1
-   _mesa_enable_extension(ctx, "GL_3DFX_texture_compression_FXT1");
-#endif
-#if FEATURE_texture_s3tc
-   if (ctx->Mesa_DXTn) {
-      _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");
-      _mesa_enable_extension(ctx, "GL_S3_s3tc");
-   }
-#endif
-}
-
-
-/**
- * Enable common EXT extensions in the ARB_imaging subset.
- */
-void
-_mesa_enable_imaging_extensions(struct gl_context *ctx)
-{
-   ctx->Extensions.EXT_blend_color = GL_TRUE;
-   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;
-   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
-   ctx->Extensions.EXT_blend_subtract = GL_TRUE;
-}
-
-
-
-/**
- * Enable all OpenGL 1.3 features and extensions.
- * A convenience function to be called by drivers.
- */
-void
-_mesa_enable_1_3_extensions(struct gl_context *ctx)
-{
-   /*ctx->Extensions.ARB_multisample = GL_TRUE;*/
-   ctx->Extensions.ARB_multitexture = GL_TRUE;
-   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
-   /*ctx->Extensions.ARB_texture_compression = GL_TRUE;*/
-   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_add = GL_TRUE;
-   /*ctx->Extensions.ARB_transpose_matrix = GL_TRUE;*/
-}
-
-
-
-/**
- * Enable all OpenGL 1.4 features and extensions.
- * A convenience function to be called by drivers.
- */
-void
-_mesa_enable_1_4_extensions(struct gl_context *ctx)
-{
-   ctx->Extensions.ARB_depth_texture = GL_TRUE;
-   ctx->Extensions.ARB_shadow = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
-   ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
-   ctx->Extensions.ARB_window_pos = GL_TRUE;
-   ctx->Extensions.EXT_blend_color = GL_TRUE;
-   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
-   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
-   ctx->Extensions.EXT_blend_subtract = GL_TRUE;
-   ctx->Extensions.EXT_fog_coord = GL_TRUE;
-   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/
-   ctx->Extensions.EXT_point_parameters = GL_TRUE;
-   ctx->Extensions.EXT_secondary_color = GL_TRUE;
-   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
-   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;
-   /*ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;*/
-}
-
-
-/**
- * Enable all OpenGL 1.5 features and extensions.
- * A convenience function to be called by drivers.
- */
-void
-_mesa_enable_1_5_extensions(struct gl_context *ctx)
-{
-   ctx->Extensions.ARB_occlusion_query = GL_TRUE;
-   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/
-   ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
-}
-
-
-/**
- * Enable all OpenGL 2.0 features and extensions.
- * A convenience function to be called by drivers.
- */
-void
-_mesa_enable_2_0_extensions(struct gl_context *ctx)
-{
-   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
-#if FEATURE_ARB_fragment_shader
-   ctx->Extensions.ARB_fragment_shader = GL_TRUE;
-#endif
-   ctx->Extensions.ARB_point_sprite = GL_TRUE;
-   ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
-   ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
-#if FEATURE_ARB_shader_objects
-   ctx->Extensions.ARB_shader_objects = GL_TRUE;
-#endif
-#if FEATURE_ARB_shading_language_100
-   ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
-#endif
-   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
-#if FEATURE_ARB_vertex_shader
-   ctx->Extensions.ARB_vertex_shader = GL_TRUE;
-#endif
-}
-
-
-/**
- * Enable all OpenGL 2.1 features and extensions.
- * A convenience function to be called by drivers.
- */
-void
-_mesa_enable_2_1_extensions(struct gl_context *ctx)
-{
-#if FEATURE_EXT_pixel_buffer_object
-   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
-#endif
-#if FEATURE_EXT_texture_sRGB
-   ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
-#endif
-}
-
-
-/**
- * Either enable or disable the named extension.
- * \return GL_TRUE for success, GL_FALSE if invalid extension name
- */
-static GLboolean
-set_extension( struct gl_context *ctx, const char *name, GLboolean state )
-{
-   size_t offset;
-
-   if (ctx->Extensions.String) {
-      /* The string was already queried - can't change it now! */
-      _mesa_problem(ctx, "Trying to enable/disable extension after glGetString(GL_EXTENSIONS): %s", name);
-      return GL_FALSE;
-   }
-
-   offset = name_to_offset(name);
-   if (offset == 0) {
-      _mesa_problem(ctx, "Trying to enable/disable unknown extension %s",
-	            name);
-      return GL_FALSE;
-   } else if (offset == o(dummy_true) && state == GL_FALSE) {
-      _mesa_problem(ctx, "Trying to disable a permanently enabled extension: "
-	                  "%s", name);
-      return GL_FALSE;
-   } else {
-      GLboolean *base = (GLboolean *) &ctx->Extensions;
-      base[offset] = state;
-      return GL_TRUE;
-   }
-}
-
-
-/**
- * Enable the named extension.
- * Typically called by drivers.
- */
-void
-_mesa_enable_extension( struct gl_context *ctx, const char *name )
-{
-   if (!set_extension(ctx, name, GL_TRUE))
-      _mesa_problem(ctx, "Trying to enable unknown extension: %s", name);
-}
-
-
-/**
- * Disable the named extension.
- * XXX is this really needed???
- */
-void
-_mesa_disable_extension( struct gl_context *ctx, const char *name )
-{
-   if (!set_extension(ctx, name, GL_FALSE))
-      _mesa_problem(ctx, "Trying to disable unknown extension: %s", name);
-}
-
-
-/**
- * Test if the named extension is enabled in this context.
- */
-GLboolean
-_mesa_extension_is_enabled( struct gl_context *ctx, const char *name )
-{
-   size_t offset;
-   GLboolean *base;
-
-   if (name == 0)
-      return GL_FALSE;
-
-   offset = name_to_offset(name);
-   if (offset == 0)
-      return GL_FALSE;
-   base = (GLboolean *) &ctx->Extensions;
-   return base[offset];
-}
-
-
-/**
- * \brief Apply the \c MESA_EXTENSION_OVERRIDE environment variable.
- *
- * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
- * enable or disable. The list is processed thus:
- *    - Enable recognized extension names that are prefixed with '+'.
- *    - Disable recognized extension names that are prefixed with '-'.
- *    - Enable recognized extension names that are not prefixed.
- *    - Collect unrecognized extension names in a new string.
- *
- * \return Space-separated list of unrecognized extension names (which must
- *    be freed). Does not return \c NULL.
- */
-static char *
-get_extension_override( struct gl_context *ctx )
-{
-   const char *env_const= _mesa_getenv("MESA_EXTENSION_OVERRIDE");
-   char *env;
-   char *ext;
-   char *extra_exts;
-   int len;
-
-   if (env_const == NULL) {
-      /* Return the empty string rather than NULL. This simplifies the logic
-       * of client functions. */
-      return calloc(1, sizeof(char));
-   }
-
-   /* extra_exts: List of unrecognized extensions. */
-   extra_exts = calloc(strlen(env_const), sizeof(char));
-
-   /* Copy env_const because strtok() is destructive. */
-   env = strdup(env_const);
-   for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
-      int enable;
-      int recognized;
-      switch (ext[0]) {
-      case '+':
-         enable = 1;
-         ++ext;
-         break;
-      case '-':
-         enable = 0;
-         ++ext;
-         break;
-      default:
-         enable = 1;
-         break;
-      }
-      recognized = set_extension(ctx, ext, enable);
-      if (!recognized) {
-         strcat(extra_exts, ext);
-         strcat(extra_exts, " ");
-      }
-   }
-
-   /* Remove trailing space. */
-   len  = strlen(extra_exts);
-   if (extra_exts[len - 1] == ' ')
-      extra_exts[len - 1] = '\0';
-
-   return extra_exts;
-}
-
-
-/**
- * \brief Initialize extension tables and enable default extensions.
- *
- * This should be called during context initialization.
- * Note: Sets gl_extensions.dummy_true to true.
- */
-void
-_mesa_init_extensions( struct gl_context *ctx )
-{
-   GLboolean *base = (GLboolean *) &ctx->Extensions;
-   GLboolean *sentinel = base + o(extension_sentinel);
-   GLboolean *i;
-   const size_t *j;
-
-   /* First, turn all extensions off. */
-   for (i = base; i != sentinel; ++i)
-      *i = GL_FALSE;
-
-   /* Then, selectively turn default extensions on. */
-   ctx->Extensions.dummy_true = GL_TRUE;
-   for (j = default_extensions; *j != 0; ++j)
-      base[*j] = GL_TRUE;
-}
-
-
-/**
- * Construct the GL_EXTENSIONS string.  Called the first time that
- * glGetString(GL_EXTENSIONS) is called.
- */
-GLubyte*
-_mesa_make_extension_string(struct gl_context *ctx)
-{
-   /* The extension string. */
-   char *exts = 0;
-   /* Length of extension string. */
-   size_t length = 0;
-   /* String of extra extensions. */
-   char *extra_extensions = get_extension_override(ctx);
-   GLboolean *base = (GLboolean *) &ctx->Extensions;
-   const struct extension *i;
-
-   /* Compute length of the extension string. */
-   for (i = extension_table; i->name != 0; ++i) {
-      if (base[i->offset] && (i->api_set & (1 << ctx->API))) {
-	 length += strlen(i->name) + 1; /* +1 for space */
-      }
-   }
-   if (extra_extensions != NULL)
-      length += 1 + strlen(extra_extensions); /* +1 for space */
-
-   exts = (char *) calloc(length + 1, sizeof(char));
-   if (exts == NULL) {
-      free(extra_extensions);
-      return NULL;
-   }
-
-   /* Build the extension string.*/
-   for (i = extension_table; i->name != 0; ++i) {
-      if (base[i->offset] && (i->api_set & (1 << ctx->API))) {
-         strcat(exts, i->name);
-         strcat(exts, " ");
-      }
-   }
-   if (extra_extensions != 0) {
-      strcat(exts, extra_extensions);
-      free(extra_extensions);
-   }
-
-   return (GLubyte *) exts;
-}
-
-/**
- * Return number of enabled extensions.
- */
-GLuint
-_mesa_get_extension_count(struct gl_context *ctx)
-{
-   GLboolean *base;
-   const struct extension *i;
-
-   /* only count once */
-   if (ctx->Extensions.Count != 0)
-      return ctx->Extensions.Count;
-
-   base = (GLboolean *) &ctx->Extensions;
-   for (i = extension_table; i->name != 0; ++i) {
-      if (base[i->offset]) {
-	 ctx->Extensions.Count++;
-      }
-   }
-   return ctx->Extensions.Count;
-}
-
-/**
- * Return name of i-th enabled extension
- */
-const GLubyte *
-_mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
-{
-   const GLboolean *base;
-   size_t n;
-   const struct extension *i;
-
-   if (index < 0)
-      return NULL;
-
-   base = (GLboolean*) &ctx->Extensions;
-   n = 0;
-   for (i = extension_table; i->name != 0; ++i) {
-      if (n == index && base[i->offset]) {
-	 return (GLubyte*) i->name;
-      } else if (base[i->offset]) {
-	 ++n;
-      }
-   }
-
-   return NULL;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file

+ * \brief Extension handling

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "context.h"

+#include "extensions.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+

+enum {

+   DISABLE = 0,

+   GL  = 1 << API_OPENGL,

+   ES1 = 1 << API_OPENGLES,

+   ES2 = 1 << API_OPENGLES2,

+};

+

+/**

+ * \brief An element of the \c extension_table.

+ */

+struct extension {

+   /** Name of extension, such as "GL_ARB_depth_clamp". */

+   const char *name;

+

+   /** Offset (in bytes) of the corresponding member in struct gl_extensions. */

+   size_t offset;

+

+   /** Set of API's in which the extension exists, as a bitset. */

+   uint8_t api_set;

+};

+

+

+/**

+ * Given a member \c x of struct gl_extensions, return offset of

+ * \c x in bytes.

+ */

+#define o(x) offsetof(struct gl_extensions, x)

+

+

+/**

+ * \brief Table of supported OpenGL extensions for all API's.

+ *

+ * Note: The GL_MESAX_* extensions are placeholders for future ARB extensions.

+ */

+static const struct extension extension_table[] = {

+   /* ARB Extensions */

+   { "GL_ARB_ES2_compatibility",                   o(ARB_ES2_compatibility),                   GL             },

+   { "GL_ARB_blend_func_extended",                 o(ARB_blend_func_extended),                 GL             },

+   { "GL_ARB_copy_buffer",                         o(ARB_copy_buffer),                         GL             },

+   { "GL_ARB_depth_buffer_float",                  o(ARB_depth_buffer_float),                  GL             },

+   { "GL_ARB_depth_clamp",                         o(ARB_depth_clamp),                         GL             },

+   { "GL_ARB_depth_texture",                       o(ARB_depth_texture),                       GL             },

+   { "GL_ARB_draw_buffers",                        o(ARB_draw_buffers),                        GL             },

+   { "GL_ARB_draw_buffers_blend",                  o(ARB_draw_buffers_blend),                  GL             },

+   { "GL_ARB_draw_elements_base_vertex",           o(ARB_draw_elements_base_vertex),           GL             },

+   { "GL_ARB_draw_instanced",                      o(ARB_draw_instanced),                      GL             },

+   { "GL_ARB_explicit_attrib_location",            o(ARB_explicit_attrib_location),            GL             },

+   { "GL_ARB_fragment_coord_conventions",          o(ARB_fragment_coord_conventions),          GL             },

+   { "GL_ARB_fragment_program",                    o(ARB_fragment_program),                    GL             },

+   { "GL_ARB_fragment_program_shadow",             o(ARB_fragment_program_shadow),             GL             },

+   { "GL_ARB_fragment_shader",                     o(ARB_fragment_shader),                     GL             },

+   { "GL_ARB_framebuffer_object",                  o(ARB_framebuffer_object),                  GL             },

+   { "GL_ARB_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL             },

+   { "GL_ARB_half_float_pixel",                    o(ARB_half_float_pixel),                    GL             },

+   { "GL_ARB_half_float_vertex",                   o(ARB_half_float_vertex),                   GL             },

+   { "GL_ARB_instanced_arrays",                    o(ARB_instanced_arrays),                    GL             },

+   { "GL_ARB_map_buffer_range",                    o(ARB_map_buffer_range),                    GL             },

+   { "GL_ARB_multisample",                         o(ARB_multisample),                         GL             },

+   { "GL_ARB_multitexture",                        o(ARB_multitexture),                        GL             },

+   { "GL_ARB_occlusion_query2",                    o(ARB_occlusion_query2),                    GL             },

+   { "GL_ARB_occlusion_query",                     o(ARB_occlusion_query),                     GL             },

+   { "GL_ARB_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL             },

+   { "GL_ARB_point_parameters",                    o(EXT_point_parameters),                    GL             },

+   { "GL_ARB_point_sprite",                        o(ARB_point_sprite),                        GL             },

+   { "GL_ARB_provoking_vertex",                    o(EXT_provoking_vertex),                    GL             },

+   { "GL_ARB_sampler_objects",                     o(ARB_sampler_objects),                     GL             },

+   { "GL_ARB_seamless_cube_map",                   o(ARB_seamless_cube_map),                   GL             },

+   { "GL_ARB_shader_objects",                      o(ARB_shader_objects),                      GL             },

+   { "GL_ARB_shader_stencil_export",               o(ARB_shader_stencil_export),               GL             },

+   { "GL_ARB_shading_language_100",                o(ARB_shading_language_100),                GL             },

+   { "GL_ARB_shadow_ambient",                      o(ARB_shadow_ambient),                      GL             },

+   { "GL_ARB_shadow",                              o(ARB_shadow),                              GL             },

+   { "GL_ARB_sync",                                o(ARB_sync),                                GL             },

+   { "GL_ARB_texture_border_clamp",                o(ARB_texture_border_clamp),                GL             },

+   { "GL_ARB_texture_buffer_object",               o(ARB_texture_buffer_object),               GL             },

+   { "GL_ARB_texture_compression",                 o(ARB_texture_compression),                 GL             },

+   { "GL_ARB_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL             },

+   { "GL_ARB_texture_cube_map",                    o(ARB_texture_cube_map),                    GL             },

+   { "GL_ARB_texture_env_add",                     o(EXT_texture_env_add),                     GL             },

+   { "GL_ARB_texture_env_combine",                 o(ARB_texture_env_combine),                 GL             },

+   { "GL_ARB_texture_env_crossbar",                o(ARB_texture_env_crossbar),                GL             },

+   { "GL_ARB_texture_env_dot3",                    o(ARB_texture_env_dot3),                    GL             },

+   { "GL_ARB_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),             GL             },

+   { "GL_ARB_texture_multisample",                 o(ARB_texture_multisample),                 GL             },

+   { "GL_ARB_texture_non_power_of_two",            o(ARB_texture_non_power_of_two),            GL             },

+   { "GL_ARB_texture_rectangle",                   o(NV_texture_rectangle),                    GL             },

+   { "GL_ARB_texture_rgb10_a2ui",                  o(ARB_texture_rgb10_a2ui),                  GL             },

+   { "GL_ARB_texture_rg",                          o(ARB_texture_rg),                          GL             },

+   { "GL_ARB_texture_swizzle",                     o(EXT_texture_swizzle),                     GL             },

+   { "GL_ARB_transform_feedback2",                 o(ARB_transform_feedback2),                 GL             },

+   { "GL_ARB_transpose_matrix",                    o(ARB_transpose_matrix),                    GL             },

+   { "GL_ARB_uniform_buffer_object",               o(ARB_uniform_buffer_object),               GL             },

+   { "GL_ARB_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL             },

+   { "GL_ARB_vertex_array_object",                 o(ARB_vertex_array_object),                 GL             },

+   { "GL_ARB_vertex_buffer_object",                o(ARB_vertex_buffer_object),                GL             },

+   { "GL_ARB_vertex_program",                      o(ARB_vertex_program),                      GL             },

+   { "GL_ARB_vertex_shader",                       o(ARB_vertex_shader),                       GL             },

+   { "GL_ARB_vertex_type_2_10_10_10_rev",          o(ARB_vertex_type_2_10_10_10_rev),          GL             },

+   { "GL_ARB_window_pos",                          o(ARB_window_pos),                          GL             },

+

+   /* EXT extensions */

+   { "GL_EXT_abgr",                                o(EXT_abgr),                                GL             },

+   { "GL_EXT_bgra",                                o(EXT_bgra),                                GL             },

+   { "GL_EXT_blend_color",                         o(EXT_blend_color),                         GL             },

+   { "GL_EXT_blend_equation_separate",             o(EXT_blend_equation_separate),             GL             },

+   { "GL_EXT_blend_func_separate",                 o(EXT_blend_func_separate),                 GL             },

+   { "GL_EXT_blend_logic_op",                      o(EXT_blend_logic_op),                      GL             },

+   { "GL_EXT_blend_minmax",                        o(EXT_blend_minmax),                        GL | ES1 | ES2 },

+   { "GL_EXT_blend_subtract",                      o(EXT_blend_subtract),                      GL             },

+   { "GL_EXT_clip_volume_hint",                    o(EXT_clip_volume_hint),                    GL             },

+   { "GL_EXT_compiled_vertex_array",               o(EXT_compiled_vertex_array),               GL             },

+   { "GL_EXT_copy_texture",                        o(EXT_copy_texture),                        GL             },

+   { "GL_EXT_depth_bounds_test",                   o(EXT_depth_bounds_test),                   GL             },

+   { "GL_EXT_draw_buffers2",                       o(EXT_draw_buffers2),                       GL             },

+   { "GL_EXT_draw_instanced",                      o(ARB_draw_instanced),                      GL             },

+   { "GL_EXT_draw_range_elements",                 o(EXT_draw_range_elements),                 GL             },

+   { "GL_EXT_fog_coord",                           o(EXT_fog_coord),                           GL             },

+   { "GL_EXT_framebuffer_blit",                    o(EXT_framebuffer_blit),                    GL             },

+   { "GL_EXT_framebuffer_multisample",             o(EXT_framebuffer_multisample),             GL             },

+   { "GL_EXT_framebuffer_object",                  o(EXT_framebuffer_object),                  GL             },

+   { "GL_EXT_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL             },

+   { "GL_EXT_gpu_program_parameters",              o(EXT_gpu_program_parameters),              GL             },

+   { "GL_EXT_gpu_shader4",                         o(EXT_gpu_shader4),                         GL             },

+   { "GL_EXT_multi_draw_arrays",                   o(EXT_multi_draw_arrays),                   GL | ES1 | ES2 },

+   { "GL_EXT_packed_depth_stencil",                o(EXT_packed_depth_stencil),                GL             },

+   { "GL_EXT_packed_float",                        o(EXT_packed_float),                        GL             },

+   { "GL_EXT_packed_pixels",                       o(EXT_packed_pixels),                       GL             },

+   { "GL_EXT_paletted_texture",                    o(EXT_paletted_texture),                    GL             },

+   { "GL_EXT_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL             },

+   { "GL_EXT_point_parameters",                    o(EXT_point_parameters),                    GL             },

+   { "GL_EXT_polygon_offset",                      o(EXT_polygon_offset),                      GL             },

+   { "GL_EXT_provoking_vertex",                    o(EXT_provoking_vertex),                    GL             },

+   { "GL_EXT_rescale_normal",                      o(EXT_rescale_normal),                      GL             },

+   { "GL_EXT_secondary_color",                     o(EXT_secondary_color),                     GL             },

+   { "GL_EXT_separate_shader_objects",             o(EXT_separate_shader_objects),             GL             },

+   { "GL_EXT_separate_specular_color",             o(EXT_separate_specular_color),             GL             },

+   { "GL_EXT_shadow_funcs",                        o(EXT_shadow_funcs),                        GL             },

+   { "GL_EXT_shared_texture_palette",              o(EXT_shared_texture_palette),              GL             },

+   { "GL_EXT_stencil_two_side",                    o(EXT_stencil_two_side),                    GL             },

+   { "GL_EXT_stencil_wrap",                        o(EXT_stencil_wrap),                        GL             },

+   { "GL_EXT_subtexture",                          o(EXT_subtexture),                          GL             },

+   { "GL_EXT_texture3D",                           o(EXT_texture3D),                           GL             },

+   { "GL_EXT_texture_array",                       o(EXT_texture_array),                       GL             },

+   { "GL_EXT_texture_compression_dxt1",            o(EXT_texture_compression_s3tc),            GL | ES1 | ES2 },

+   { "GL_EXT_texture_compression_latc",            o(EXT_texture_compression_latc),            GL             },

+   { "GL_EXT_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL             },

+   { "GL_EXT_texture_compression_s3tc",            o(EXT_texture_compression_s3tc),            GL             },

+   { "GL_EXT_texture_cube_map",                    o(ARB_texture_cube_map),                    GL             },

+   { "GL_EXT_texture_edge_clamp",                  o(SGIS_texture_edge_clamp),                 GL             },

+   { "GL_EXT_texture_env_add",                     o(EXT_texture_env_add),                     GL             },

+   { "GL_EXT_texture_env_combine",                 o(EXT_texture_env_combine),                 GL             },

+   { "GL_EXT_texture_env_dot3",                    o(EXT_texture_env_dot3),                    GL             },

+   { "GL_EXT_texture_filter_anisotropic",          o(EXT_texture_filter_anisotropic),          GL | ES1 | ES2 },

+   { "GL_EXT_texture_format_BGRA8888",             o(EXT_texture_format_BGRA8888),                  ES1 | ES2 },

+   { "GL_EXT_texture_integer",                     o(EXT_texture_integer),                     GL             },

+   { "GL_EXT_texture_lod_bias",                    o(EXT_texture_lod_bias),                    GL | ES1       },

+   { "GL_EXT_texture_mirror_clamp",                o(EXT_texture_mirror_clamp),                GL             },

+   { "GL_EXT_texture_object",                      o(EXT_texture_object),                      GL             },

+   { "GL_EXT_texture",                             o(EXT_texture),                             GL             },

+   { "GL_EXT_texture_rectangle",                   o(NV_texture_rectangle),                    GL             },

+   { "GL_EXT_texture_shared_exponent",             o(EXT_texture_shared_exponent),             GL             },

+   { "GL_EXT_texture_sRGB",                        o(EXT_texture_sRGB),                        GL             },

+   { "GL_EXT_texture_sRGB_decode",                 o(EXT_texture_sRGB_decode),                        GL             },

+   { "GL_EXT_texture_swizzle",                     o(EXT_texture_swizzle),                     GL             },

+   { "GL_EXT_texture_type_2_10_10_10_REV",         o(dummy_true),                                         ES2 },

+   { "GL_EXT_timer_query",                         o(EXT_timer_query),                         GL             },

+   { "GL_EXT_transform_feedback",                  o(EXT_transform_feedback),                  GL             },

+   { "GL_EXT_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL             },

+   { "GL_EXT_vertex_array",                        o(EXT_vertex_array),                        GL             },

+   { "GL_EXT_vertex_array_set",                    o(EXT_vertex_array_set),                    GL             },

+

+   /* OES extensions */

+   { "GL_OES_blend_equation_separate",             o(EXT_blend_equation_separate),                  ES1       },

+   { "GL_OES_blend_func_separate",                 o(EXT_blend_func_separate),                      ES1       },

+   { "GL_OES_blend_subtract",                      o(EXT_blend_subtract),                           ES1       },

+   { "GL_OES_byte_coordinates",                    o(dummy_true),                                   ES1       },

+   { "GL_OES_compressed_paletted_texture",         o(dummy_false),                     DISABLE                },

+   { "GL_OES_depth24",                             o(EXT_framebuffer_object),                       ES1 | ES2 },

+   { "GL_OES_depth32",                             o(dummy_false),                     DISABLE                },

+   { "GL_OES_depth_texture",                       o(ARB_depth_texture),                                  ES2 },

+#if FEATURE_OES_draw_texture

+   { "GL_OES_draw_texture",                        o(OES_draw_texture),                             ES1 | ES2 },

+#endif

+#if FEATURE_OES_EGL_image

+   /*  FIXME: Mesa expects GL_OES_EGL_image to be available in OpenGL contexts. */

+   { "GL_OES_EGL_image",                           o(OES_EGL_image),                           GL | ES1 | ES2 },

+#endif

+   { "GL_OES_element_index_uint",                  o(EXT_vertex_array),                             ES1 | ES2 },

+   { "GL_OES_fbo_render_mipmap",                   o(EXT_framebuffer_object),                       ES1 | ES2 },

+   { "GL_OES_fixed_point",                         o(dummy_true),                                   ES1       },

+   { "GL_OES_framebuffer_object",                  o(EXT_framebuffer_object),                       ES1       },

+   { "GL_OES_mapbuffer",                           o(ARB_vertex_buffer_object),                     ES1 | ES2 },

+   { "GL_OES_matrix_get",                          o(dummy_true),                                   ES1       },

+   { "GL_OES_packed_depth_stencil",                o(EXT_packed_depth_stencil),                     ES1 | ES2 },

+   { "GL_OES_point_size_array",                    o(dummy_true),                                   ES1       },

+   { "GL_OES_point_sprite",                        o(ARB_point_sprite),                             ES1       },

+   { "GL_OES_query_matrix",                        o(dummy_true),                                   ES1       },

+   { "GL_OES_read_format",                         o(OES_read_format),                         GL | ES1       },

+   { "GL_OES_rgb8_rgba8",                          o(EXT_framebuffer_object),                       ES1 | ES2 },

+   { "GL_OES_single_precision",                    o(dummy_true),                                   ES1       },

+   { "GL_OES_standard_derivatives",                o(OES_standard_derivatives),                           ES2 },

+   { "GL_OES_stencil1",                            o(dummy_false),                     DISABLE                },

+   { "GL_OES_stencil4",                            o(dummy_false),                     DISABLE                },

+   { "GL_OES_stencil8",                            o(EXT_framebuffer_object),                       ES1 | ES2 },

+   { "GL_OES_stencil_wrap",                        o(EXT_stencil_wrap),                             ES1       },

+   { "GL_OES_texture_3D",                          o(EXT_texture3D),                                      ES2 },

+   { "GL_OES_texture_cube_map",                    o(ARB_texture_cube_map),                         ES1       },

+   { "GL_OES_texture_env_crossbar",                o(ARB_texture_env_crossbar),                     ES1       },

+   { "GL_OES_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),                  ES1       },

+   { "GL_OES_texture_npot",                        o(ARB_texture_non_power_of_two),                       ES2 },

+

+   /* Vendor extensions */

+   { "GL_3DFX_texture_compression_FXT1",           o(TDFX_texture_compression_FXT1),           GL             },

+   { "GL_AMD_conservative_depth",                  o(AMD_conservative_depth),                  GL             },

+   { "GL_APPLE_client_storage",                    o(APPLE_client_storage),                    GL             },

+   { "GL_APPLE_object_purgeable",                  o(APPLE_object_purgeable),                  GL             },

+   { "GL_APPLE_packed_pixels",                     o(APPLE_packed_pixels),                     GL             },

+   { "GL_APPLE_vertex_array_object",               o(APPLE_vertex_array_object),               GL             },

+   { "GL_ATI_blend_equation_separate",             o(EXT_blend_equation_separate),             GL             },

+   { "GL_ATI_envmap_bumpmap",                      o(ATI_envmap_bumpmap),                      GL             },

+   { "GL_ATI_fragment_shader",                     o(ATI_fragment_shader),                     GL             },

+   { "GL_ATI_separate_stencil",                    o(ATI_separate_stencil),                    GL             },

+   { "GL_ATI_texture_compression_3dc",             o(ATI_texture_compression_3dc),             GL             },

+   { "GL_ATI_texture_env_combine3",                o(ATI_texture_env_combine3),                GL             },

+   { "GL_ATI_texture_mirror_once",                 o(ATI_texture_mirror_once),                 GL             },

+   { "GL_IBM_multimode_draw_arrays",               o(IBM_multimode_draw_arrays),               GL             },

+   { "GL_IBM_rasterpos_clip",                      o(IBM_rasterpos_clip),                      GL             },

+   { "GL_IBM_texture_mirrored_repeat",             o(ARB_texture_mirrored_repeat),             GL             },

+   { "GL_INGR_blend_func_separate",                o(EXT_blend_func_separate),                 GL             },

+   { "GL_MESA_pack_invert",                        o(MESA_pack_invert),                        GL             },

+   { "GL_MESA_resize_buffers",                     o(MESA_resize_buffers),                     GL             },

+   { "GL_MESA_texture_array",                      o(MESA_texture_array),                      GL             },

+   { "GL_MESA_texture_signed_rgba",                o(MESA_texture_signed_rgba),                GL             },

+   { "GL_MESA_window_pos",                         o(ARB_window_pos),                          GL             },

+   { "GL_MESAX_texture_float",                     o(ARB_texture_float),                       GL             },

+   { "GL_MESA_ycbcr_texture",                      o(MESA_ycbcr_texture),                      GL             },

+   { "GL_NV_blend_square",                         o(NV_blend_square),                         GL             },

+   { "GL_NV_conditional_render",                   o(NV_conditional_render),                   GL             },

+   { "GL_NV_depth_clamp",                          o(ARB_depth_clamp),                         GL             },

+   { "GL_NV_fragment_program",                     o(NV_fragment_program),                     GL             },

+   { "GL_NV_fragment_program_option",              o(NV_fragment_program_option),              GL             },

+   { "GL_NV_light_max_exponent",                   o(NV_light_max_exponent),                   GL             },

+   { "GL_NV_packed_depth_stencil",                 o(EXT_packed_depth_stencil),                GL             },

+   { "GL_NV_point_sprite",                         o(NV_point_sprite),                         GL             },

+   { "GL_NV_primitive_restart",                    o(NV_primitive_restart),                    GL             },

+   { "GL_NV_texgen_reflection",                    o(NV_texgen_reflection),                    GL             },

+   { "GL_NV_texture_env_combine4",                 o(NV_texture_env_combine4),                 GL             },

+   { "GL_NV_texture_rectangle",                    o(NV_texture_rectangle),                    GL             },

+   { "GL_NV_vertex_program1_1",                    o(NV_vertex_program1_1),                    GL             },

+   { "GL_NV_vertex_program",                       o(NV_vertex_program),                       GL             },

+   { "GL_S3_s3tc",                                 o(S3_s3tc),                                 GL             },

+   { "GL_SGIS_generate_mipmap",                    o(SGIS_generate_mipmap),                    GL             },

+   { "GL_SGIS_texture_border_clamp",               o(ARB_texture_border_clamp),                GL             },

+   { "GL_SGIS_texture_edge_clamp",                 o(SGIS_texture_edge_clamp),                 GL             },

+   { "GL_SGIS_texture_lod",                        o(SGIS_texture_lod),                        GL             },

+   { "GL_SUN_multi_draw_arrays",                   o(EXT_multi_draw_arrays),                   GL             },

+

+   { 0, 0, 0 },

+};

+

+

+/**

+ * Given an extension name, lookup up the corresponding member of struct

+ * gl_extensions and return that member's offset (in bytes).  If the name is

+ * not found in the \c extension_table, return 0.

+ *

+ * \param name Name of extension.

+ * \return Offset of member in struct gl_extensions.

+ */

+static size_t

+name_to_offset(const char* name)

+{

+   const struct extension *i;

+

+   if (name == 0)

+      return 0;

+

+   for (i = extension_table; i->name != 0; ++i) {

+      if (strcmp(name, i->name) == 0)

+	 return i->offset;

+   }

+

+   return 0;

+}

+

+

+/**

+ * \brief Extensions enabled by default.

+ *

+ * These extensions are enabled by _mesa_init_extensions().

+ *

+ * XXX: Should these defaults also apply to GLES?

+ */

+static const size_t default_extensions[] = {

+   o(ARB_copy_buffer),

+   o(ARB_draw_buffers),

+   o(ARB_multisample),

+   o(ARB_texture_compression),

+   o(ARB_transpose_matrix),

+   o(ARB_vertex_buffer_object),

+   o(ARB_window_pos),

+

+   o(EXT_abgr),

+   o(EXT_bgra),

+   o(EXT_compiled_vertex_array),

+   o(EXT_copy_texture),

+   o(EXT_draw_range_elements),

+   o(EXT_multi_draw_arrays),

+   o(EXT_packed_pixels),

+   o(EXT_polygon_offset),

+   o(EXT_rescale_normal),

+   o(EXT_separate_specular_color),

+   o(EXT_subtexture),

+   o(EXT_texture),

+   o(EXT_texture3D),

+   o(EXT_texture_object),

+   o(EXT_vertex_array),

+

+   o(OES_read_format),

+   o(OES_standard_derivatives),

+

+   /* Vendor Extensions */

+   o(APPLE_packed_pixels),

+   o(IBM_multimode_draw_arrays),

+   o(IBM_rasterpos_clip),

+   o(NV_light_max_exponent),

+   o(NV_texgen_reflection),

+   o(SGIS_generate_mipmap),

+   o(SGIS_texture_edge_clamp),

+   o(SGIS_texture_lod),

+

+   0,

+};

+

+

+/**

+ * Enable all extensions suitable for a software-only renderer.

+ * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.

+ */

+void

+_mesa_enable_sw_extensions(struct gl_context *ctx)

+{

+   /*ctx->Extensions.ARB_copy_buffer = GL_TRUE;*/

+   ctx->Extensions.ARB_depth_clamp = GL_TRUE;

+   ctx->Extensions.ARB_depth_texture = GL_TRUE;

+   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/

+   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;

+   ctx->Extensions.ARB_draw_instanced = GL_TRUE;

+   ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;

+   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;

+#if FEATURE_ARB_fragment_program

+   ctx->Extensions.ARB_fragment_program = GL_TRUE;

+   ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;

+#endif

+#if FEATURE_ARB_fragment_shader

+   ctx->Extensions.ARB_fragment_shader = GL_TRUE;

+#endif

+#if FEATURE_ARB_framebuffer_object

+   ctx->Extensions.ARB_framebuffer_object = GL_TRUE;

+#endif

+#if FEATURE_ARB_geometry_shader4 && 0

+   /* XXX re-enable when GLSL compiler again supports geometry shaders */

+   ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;

+#endif

+   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;

+   ctx->Extensions.ARB_half_float_vertex = GL_TRUE;

+   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;

+   ctx->Extensions.ARB_multitexture = GL_TRUE;

+#if FEATURE_queryobj

+   ctx->Extensions.ARB_occlusion_query = GL_TRUE;

+   ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;

+#endif

+   ctx->Extensions.ARB_point_sprite = GL_TRUE;

+#if FEATURE_ARB_shader_objects

+   ctx->Extensions.ARB_shader_objects = GL_TRUE;

+   ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;

+#endif

+#if FEATURE_ARB_shading_language_100

+   ctx->Extensions.ARB_shading_language_100 = GL_TRUE;

+#endif

+   ctx->Extensions.ARB_shadow = GL_TRUE;

+   ctx->Extensions.ARB_shadow_ambient = GL_TRUE;

+   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;

+   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;

+   /*ctx->Extensions.ARB_texture_float = GL_TRUE;*/

+   ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;

+   ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;

+   ctx->Extensions.ARB_texture_rg = GL_TRUE;

+   ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;

+   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;

+#if FEATURE_ARB_vertex_program

+   ctx->Extensions.ARB_vertex_program = GL_TRUE;

+#endif

+#if FEATURE_ARB_vertex_shader

+   ctx->Extensions.ARB_vertex_shader = GL_TRUE;

+#endif

+#if FEATURE_ARB_vertex_buffer_object

+   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/

+#endif

+#if FEATURE_ARB_sync

+   ctx->Extensions.ARB_sync = GL_TRUE;

+#endif

+   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;

+#if FEATURE_APPLE_object_purgeable

+   ctx->Extensions.APPLE_object_purgeable = GL_TRUE;

+#endif

+   ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE;

+#if FEATURE_ATI_fragment_shader

+   ctx->Extensions.ATI_fragment_shader = GL_TRUE;

+#endif

+   ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;

+   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;

+   ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;

+   ctx->Extensions.ATI_separate_stencil = GL_TRUE;

+   ctx->Extensions.EXT_blend_color = GL_TRUE;

+   ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;

+   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;

+   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;

+   ctx->Extensions.EXT_blend_minmax = GL_TRUE;

+   ctx->Extensions.EXT_blend_subtract = GL_TRUE;

+   ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;

+   ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;

+   ctx->Extensions.EXT_fog_coord = GL_TRUE;

+#if FEATURE_EXT_framebuffer_object

+   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;

+#endif

+#if FEATURE_EXT_framebuffer_blit

+   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;

+#endif

+#if FEATURE_ARB_framebuffer_object

+   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;

+#endif

+   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/

+   ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

+   ctx->Extensions.EXT_paletted_texture = GL_TRUE;

+#if FEATURE_EXT_pixel_buffer_object

+   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;

+#endif

+   ctx->Extensions.EXT_point_parameters = GL_TRUE;

+   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;

+   ctx->Extensions.EXT_shadow_funcs = GL_TRUE;

+   ctx->Extensions.EXT_secondary_color = GL_TRUE;

+   ctx->Extensions.EXT_shared_texture_palette = GL_TRUE;

+   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;

+   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;

+   ctx->Extensions.EXT_texture_array = GL_TRUE;

+   ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_add = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;

+   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;

+#if FEATURE_EXT_texture_sRGB

+   ctx->Extensions.EXT_texture_sRGB = GL_TRUE;

+   ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;

+#endif

+   ctx->Extensions.EXT_texture_swizzle = GL_TRUE;

+#if FEATURE_EXT_transform_feedback

+   /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/

+#endif

+   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;

+   /*ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;*/

+   ctx->Extensions.MESA_pack_invert = GL_TRUE;

+   ctx->Extensions.MESA_resize_buffers = GL_TRUE;

+   ctx->Extensions.MESA_texture_array = GL_TRUE;

+   ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;

+   ctx->Extensions.NV_blend_square = GL_TRUE;

+   ctx->Extensions.NV_conditional_render = GL_TRUE;

+   /*ctx->Extensions.NV_light_max_exponent = GL_TRUE;*/

+   ctx->Extensions.NV_point_sprite = GL_TRUE;

+   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;

+   ctx->Extensions.NV_texture_rectangle = GL_TRUE;

+   /*ctx->Extensions.NV_texgen_reflection = GL_TRUE;*/

+#if FEATURE_NV_vertex_program

+   ctx->Extensions.NV_vertex_program = GL_TRUE;

+   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;

+#endif

+#if FEATURE_NV_fragment_program

+   ctx->Extensions.NV_fragment_program = GL_TRUE;

+#endif

+#if FEATURE_NV_fragment_program && FEATURE_ARB_fragment_program

+   ctx->Extensions.NV_fragment_program_option = GL_TRUE;

+#endif

+   /*ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;*/

+   ctx->Extensions.SGIS_texture_edge_clamp = GL_TRUE;

+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

+   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;

+#endif

+#if FEATURE_texture_fxt1

+   _mesa_enable_extension(ctx, "GL_3DFX_texture_compression_FXT1");

+#endif

+#if FEATURE_texture_s3tc

+   if (ctx->Mesa_DXTn) {

+      _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");

+      _mesa_enable_extension(ctx, "GL_S3_s3tc");

+   }

+#endif

+}

+

+

+/**

+ * Enable common EXT extensions in the ARB_imaging subset.

+ */

+void

+_mesa_enable_imaging_extensions(struct gl_context *ctx)

+{

+   ctx->Extensions.EXT_blend_color = GL_TRUE;

+   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;

+   ctx->Extensions.EXT_blend_minmax = GL_TRUE;

+   ctx->Extensions.EXT_blend_subtract = GL_TRUE;

+}

+

+

+

+/**

+ * Enable all OpenGL 1.3 features and extensions.

+ * A convenience function to be called by drivers.

+ */

+void

+_mesa_enable_1_3_extensions(struct gl_context *ctx)

+{

+   /*ctx->Extensions.ARB_multisample = GL_TRUE;*/

+   ctx->Extensions.ARB_multitexture = GL_TRUE;

+   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;

+   /*ctx->Extensions.ARB_texture_compression = GL_TRUE;*/

+   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_add = GL_TRUE;

+   /*ctx->Extensions.ARB_transpose_matrix = GL_TRUE;*/

+}

+

+

+

+/**

+ * Enable all OpenGL 1.4 features and extensions.

+ * A convenience function to be called by drivers.

+ */

+void

+_mesa_enable_1_4_extensions(struct gl_context *ctx)

+{

+   ctx->Extensions.ARB_depth_texture = GL_TRUE;

+   ctx->Extensions.ARB_shadow = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;

+   ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;

+   ctx->Extensions.ARB_window_pos = GL_TRUE;

+   ctx->Extensions.EXT_blend_color = GL_TRUE;

+   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;

+   ctx->Extensions.EXT_blend_minmax = GL_TRUE;

+   ctx->Extensions.EXT_blend_subtract = GL_TRUE;

+   ctx->Extensions.EXT_fog_coord = GL_TRUE;

+   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/

+   ctx->Extensions.EXT_point_parameters = GL_TRUE;

+   ctx->Extensions.EXT_secondary_color = GL_TRUE;

+   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;

+   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;

+   /*ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;*/

+}

+

+

+/**

+ * Enable all OpenGL 1.5 features and extensions.

+ * A convenience function to be called by drivers.

+ */

+void

+_mesa_enable_1_5_extensions(struct gl_context *ctx)

+{

+   ctx->Extensions.ARB_occlusion_query = GL_TRUE;

+   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/

+   ctx->Extensions.EXT_shadow_funcs = GL_TRUE;

+}

+

+

+/**

+ * Enable all OpenGL 2.0 features and extensions.

+ * A convenience function to be called by drivers.

+ */

+void

+_mesa_enable_2_0_extensions(struct gl_context *ctx)

+{

+   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/

+#if FEATURE_ARB_fragment_shader

+   ctx->Extensions.ARB_fragment_shader = GL_TRUE;

+#endif

+   ctx->Extensions.ARB_point_sprite = GL_TRUE;

+   ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;

+   ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;

+#if FEATURE_ARB_shader_objects

+   ctx->Extensions.ARB_shader_objects = GL_TRUE;

+#endif

+#if FEATURE_ARB_shading_language_100

+   ctx->Extensions.ARB_shading_language_100 = GL_TRUE;

+#endif

+   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;

+#if FEATURE_ARB_vertex_shader

+   ctx->Extensions.ARB_vertex_shader = GL_TRUE;

+#endif

+}

+

+

+/**

+ * Enable all OpenGL 2.1 features and extensions.

+ * A convenience function to be called by drivers.

+ */

+void

+_mesa_enable_2_1_extensions(struct gl_context *ctx)

+{

+#if FEATURE_EXT_pixel_buffer_object

+   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;

+#endif

+#if FEATURE_EXT_texture_sRGB

+   ctx->Extensions.EXT_texture_sRGB = GL_TRUE;

+#endif

+}

+

+

+/**

+ * Either enable or disable the named extension.

+ * \return GL_TRUE for success, GL_FALSE if invalid extension name

+ */

+static GLboolean

+set_extension( struct gl_context *ctx, const char *name, GLboolean state )

+{

+   size_t offset;

+

+   if (ctx->Extensions.String) {

+      /* The string was already queried - can't change it now! */

+      _mesa_problem(ctx, "Trying to enable/disable extension after glGetString(GL_EXTENSIONS): %s", name);

+      return GL_FALSE;

+   }

+

+   offset = name_to_offset(name);

+   if (offset == 0) {

+      _mesa_problem(ctx, "Trying to enable/disable unknown extension %s",

+	            name);

+      return GL_FALSE;

+   } else if (offset == o(dummy_true) && state == GL_FALSE) {

+      _mesa_problem(ctx, "Trying to disable a permanently enabled extension: "

+	                  "%s", name);

+      return GL_FALSE;

+   } else {

+      GLboolean *base = (GLboolean *) &ctx->Extensions;

+      base[offset] = state;

+      return GL_TRUE;

+   }

+}

+

+

+/**

+ * Enable the named extension.

+ * Typically called by drivers.

+ */

+void

+_mesa_enable_extension( struct gl_context *ctx, const char *name )

+{

+   if (!set_extension(ctx, name, GL_TRUE))

+      _mesa_problem(ctx, "Trying to enable unknown extension: %s", name);

+}

+

+

+/**

+ * Disable the named extension.

+ * XXX is this really needed???

+ */

+void

+_mesa_disable_extension( struct gl_context *ctx, const char *name )

+{

+   if (!set_extension(ctx, name, GL_FALSE))

+      _mesa_problem(ctx, "Trying to disable unknown extension: %s", name);

+}

+

+

+/**

+ * Test if the named extension is enabled in this context.

+ */

+GLboolean

+_mesa_extension_is_enabled( struct gl_context *ctx, const char *name )

+{

+   size_t offset;

+   GLboolean *base;

+

+   if (name == 0)

+      return GL_FALSE;

+

+   offset = name_to_offset(name);

+   if (offset == 0)

+      return GL_FALSE;

+   base = (GLboolean *) &ctx->Extensions;

+   return base[offset];

+}

+

+

+/**

+ * \brief Apply the \c MESA_EXTENSION_OVERRIDE environment variable.

+ *

+ * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to

+ * enable or disable. The list is processed thus:

+ *    - Enable recognized extension names that are prefixed with '+'.

+ *    - Disable recognized extension names that are prefixed with '-'.

+ *    - Enable recognized extension names that are not prefixed.

+ *    - Collect unrecognized extension names in a new string.

+ *

+ * \return Space-separated list of unrecognized extension names (which must

+ *    be freed). Does not return \c NULL.

+ */

+static char *

+get_extension_override( struct gl_context *ctx )

+{

+   const char *env_const= _mesa_getenv("MESA_EXTENSION_OVERRIDE");

+   char *env;

+   char *ext;

+   char *extra_exts;

+   int len;

+

+   if (env_const == NULL) {

+      /* Return the empty string rather than NULL. This simplifies the logic

+       * of client functions. */

+      return calloc(1, sizeof(char));

+   }

+

+   /* extra_exts: List of unrecognized extensions. */

+   extra_exts = calloc(strlen(env_const), sizeof(char));

+

+   /* Copy env_const because strtok() is destructive. */

+   env = strdup(env_const);

+   for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {

+      int enable;

+      int recognized;

+      switch (ext[0]) {

+      case '+':

+         enable = 1;

+         ++ext;

+         break;

+      case '-':

+         enable = 0;

+         ++ext;

+         break;

+      default:

+         enable = 1;

+         break;

+      }

+      recognized = set_extension(ctx, ext, enable);

+      if (!recognized) {

+         strcat(extra_exts, ext);

+         strcat(extra_exts, " ");

+      }

+   }

+

+   /* Remove trailing space. */

+   len  = strlen(extra_exts);

+   if (extra_exts[len - 1] == ' ')

+      extra_exts[len - 1] = '\0';

+

+   return extra_exts;

+}

+

+

+/**

+ * \brief Initialize extension tables and enable default extensions.

+ *

+ * This should be called during context initialization.

+ * Note: Sets gl_extensions.dummy_true to true.

+ */

+void

+_mesa_init_extensions( struct gl_context *ctx )

+{

+   GLboolean *base = (GLboolean *) &ctx->Extensions;

+   GLboolean *sentinel = base + o(extension_sentinel);

+   GLboolean *i;

+   const size_t *j;

+

+   /* First, turn all extensions off. */

+   for (i = base; i != sentinel; ++i)

+      *i = GL_FALSE;

+

+   /* Then, selectively turn default extensions on. */

+   ctx->Extensions.dummy_true = GL_TRUE;

+   for (j = default_extensions; *j != 0; ++j)

+      base[*j] = GL_TRUE;

+}

+

+

+/**

+ * Construct the GL_EXTENSIONS string.  Called the first time that

+ * glGetString(GL_EXTENSIONS) is called.

+ */

+GLubyte*

+_mesa_make_extension_string(struct gl_context *ctx)

+{

+   /* The extension string. */

+   char *exts = 0;

+   /* Length of extension string. */

+   size_t length = 0;

+   /* String of extra extensions. */

+   char *extra_extensions = get_extension_override(ctx);

+   GLboolean *base = (GLboolean *) &ctx->Extensions;

+   const struct extension *i;

+

+   /* Compute length of the extension string. */

+   for (i = extension_table; i->name != 0; ++i) {

+      if (base[i->offset] && (i->api_set & (1 << ctx->API))) {

+	 length += strlen(i->name) + 1; /* +1 for space */

+      }

+   }

+   if (extra_extensions != NULL)

+      length += 1 + strlen(extra_extensions); /* +1 for space */

+

+   exts = (char *) calloc(length + 1, sizeof(char));

+   if (exts == NULL) {

+      free(extra_extensions);

+      return NULL;

+   }

+

+   /* Build the extension string.*/

+   for (i = extension_table; i->name != 0; ++i) {

+      if (base[i->offset] && (i->api_set & (1 << ctx->API))) {

+         strcat(exts, i->name);

+         strcat(exts, " ");

+      }

+   }

+   if (extra_extensions != 0) {

+      strcat(exts, extra_extensions);

+      free(extra_extensions);

+   }

+

+   return (GLubyte *) exts;

+}

+

+/**

+ * Return number of enabled extensions.

+ */

+GLuint

+_mesa_get_extension_count(struct gl_context *ctx)

+{

+   GLboolean *base;

+   const struct extension *i;

+

+   /* only count once */

+   if (ctx->Extensions.Count != 0)

+      return ctx->Extensions.Count;

+

+   base = (GLboolean *) &ctx->Extensions;

+   for (i = extension_table; i->name != 0; ++i) {

+      if (base[i->offset]) {

+	 ctx->Extensions.Count++;

+      }

+   }

+   return ctx->Extensions.Count;

+}

+

+/**

+ * Return name of i-th enabled extension

+ */

+const GLubyte *

+_mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)

+{

+   const GLboolean *base;

+   size_t n;

+   const struct extension *i;

+

+   if (index < 0)

+      return NULL;

+

+   base = (GLboolean*) &ctx->Extensions;

+   n = 0;

+   for (i = extension_table; i->name != 0; ++i) {

+      if (n == index && base[i->offset]) {

+	 return (GLubyte*) i->name;

+      } else if (base[i->offset]) {

+	 ++n;

+      }

+   }

+

+   return NULL;

+}

diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c
index ffdd08425..0bffbcfae 100644
--- a/mesalib/src/mesa/main/fbobject.c
+++ b/mesalib/src/mesa/main/fbobject.c
@@ -1,2462 +1,2462 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 1999-2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * GL_EXT/ARB_framebuffer_object extensions
- *
- * Authors:
- *   Brian Paul
- */
-
-
-#include "buffers.h"
-#include "context.h"
-#include "enums.h"
-#include "fbobject.h"
-#include "formats.h"
-#include "framebuffer.h"
-#include "hash.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "renderbuffer.h"
-#include "state.h"
-#include "teximage.h"
-#include "texobj.h"
-
-
-/** Set this to 1 to help debug FBO incompleteness problems */
-#define DEBUG_FBO 0
-
-/** Set this to 1 to debug/log glBlitFramebuffer() calls */
-#define DEBUG_BLIT 0
-
-
-/**
- * Notes:
- *
- * None of the GL_EXT_framebuffer_object functions are compiled into
- * display lists.
- */
-
-
-
-/*
- * When glGenRender/FramebuffersEXT() is called we insert pointers to
- * these placeholder objects into the hash table.
- * Later, when the object ID is first bound, we replace the placeholder
- * with the real frame/renderbuffer.
- */
-static struct gl_framebuffer DummyFramebuffer;
-static struct gl_renderbuffer DummyRenderbuffer;
-
-/* We bind this framebuffer when applications pass a NULL
- * drawable/surface in make current. */
-static struct gl_framebuffer IncompleteFramebuffer;
-
-
-#define IS_CUBE_FACE(TARGET) \
-   ((TARGET) >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && \
-    (TARGET) <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)
-
-
-static void
-delete_dummy_renderbuffer(struct gl_renderbuffer *rb)
-{
-   /* no op */
-}
-
-static void
-delete_dummy_framebuffer(struct gl_framebuffer *fb)
-{
-   /* no op */
-}
-
-
-void
-_mesa_init_fbobjects(struct gl_context *ctx)
-{
-   _glthread_INIT_MUTEX(DummyFramebuffer.Mutex);
-   _glthread_INIT_MUTEX(DummyRenderbuffer.Mutex);
-   _glthread_INIT_MUTEX(IncompleteFramebuffer.Mutex);
-   DummyFramebuffer.Delete = delete_dummy_framebuffer;
-   DummyRenderbuffer.Delete = delete_dummy_renderbuffer;
-   IncompleteFramebuffer.Delete = delete_dummy_framebuffer;
-}
-
-struct gl_framebuffer *
-_mesa_get_incomplete_framebuffer(void)
-{
-   return &IncompleteFramebuffer;
-}
-
-/**
- * Helper routine for getting a gl_renderbuffer.
- */
-struct gl_renderbuffer *
-_mesa_lookup_renderbuffer(struct gl_context *ctx, GLuint id)
-{
-   struct gl_renderbuffer *rb;
-
-   if (id == 0)
-      return NULL;
-
-   rb = (struct gl_renderbuffer *)
-      _mesa_HashLookup(ctx->Shared->RenderBuffers, id);
-   return rb;
-}
-
-
-/**
- * Helper routine for getting a gl_framebuffer.
- */
-struct gl_framebuffer *
-_mesa_lookup_framebuffer(struct gl_context *ctx, GLuint id)
-{
-   struct gl_framebuffer *fb;
-
-   if (id == 0)
-      return NULL;
-
-   fb = (struct gl_framebuffer *)
-      _mesa_HashLookup(ctx->Shared->FrameBuffers, id);
-   return fb;
-}
-
-
-/**
- * Mark the given framebuffer as invalid.  This will force the
- * test for framebuffer completeness to be done before the framebuffer
- * is used.
- */
-static void
-invalidate_framebuffer(struct gl_framebuffer *fb)
-{
-   fb->_Status = 0; /* "indeterminate" */
-}
-
-
-/**
- * Return the gl_framebuffer object which corresponds to the given
- * framebuffer target, such as GL_DRAW_FRAMEBUFFER.
- * Check support for GL_EXT_framebuffer_blit to determine if certain
- * targets are legal.
- * \return gl_framebuffer pointer or NULL if target is illegal
- */
-static struct gl_framebuffer *
-get_framebuffer_target(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_DRAW_FRAMEBUFFER:
-      return ctx->Extensions.EXT_framebuffer_blit ? ctx->DrawBuffer : NULL;
-   case GL_READ_FRAMEBUFFER:
-      return ctx->Extensions.EXT_framebuffer_blit ? ctx->ReadBuffer : NULL;
-   case GL_FRAMEBUFFER_EXT:
-      return ctx->DrawBuffer;
-   default:
-      return NULL;
-   }
-}
-
-
-/**
- * Given a GL_*_ATTACHMENTn token, return a pointer to the corresponding
- * gl_renderbuffer_attachment object.
- * This function is only used for user-created FB objects, not the
- * default / window-system FB object.
- * If \p attachment is GL_DEPTH_STENCIL_ATTACHMENT, return a pointer to
- * the depth buffer attachment point.
- */
-struct gl_renderbuffer_attachment *
-_mesa_get_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,
-                     GLenum attachment)
-{
-   GLuint i;
-
-   assert(fb->Name > 0);
-
-   switch (attachment) {
-   case GL_COLOR_ATTACHMENT0_EXT:
-   case GL_COLOR_ATTACHMENT1_EXT:
-   case GL_COLOR_ATTACHMENT2_EXT:
-   case GL_COLOR_ATTACHMENT3_EXT:
-   case GL_COLOR_ATTACHMENT4_EXT:
-   case GL_COLOR_ATTACHMENT5_EXT:
-   case GL_COLOR_ATTACHMENT6_EXT:
-   case GL_COLOR_ATTACHMENT7_EXT:
-   case GL_COLOR_ATTACHMENT8_EXT:
-   case GL_COLOR_ATTACHMENT9_EXT:
-   case GL_COLOR_ATTACHMENT10_EXT:
-   case GL_COLOR_ATTACHMENT11_EXT:
-   case GL_COLOR_ATTACHMENT12_EXT:
-   case GL_COLOR_ATTACHMENT13_EXT:
-   case GL_COLOR_ATTACHMENT14_EXT:
-   case GL_COLOR_ATTACHMENT15_EXT:
-      i = attachment - GL_COLOR_ATTACHMENT0_EXT;
-      if (i >= ctx->Const.MaxColorAttachments) {
-	 return NULL;
-      }
-      return &fb->Attachment[BUFFER_COLOR0 + i];
-   case GL_DEPTH_STENCIL_ATTACHMENT:
-      /* fall-through */
-   case GL_DEPTH_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_DEPTH_ATTACHMENT_EXT:
-      return &fb->Attachment[BUFFER_DEPTH];
-   case GL_STENCIL_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_STENCIL_ATTACHMENT_EXT:
-      return &fb->Attachment[BUFFER_STENCIL];
-   default:
-      return NULL;
-   }
-}
-
-
-/**
- * As above, but only used for getting attachments of the default /
- * window-system framebuffer (not user-created framebuffer objects).
- */
-static struct gl_renderbuffer_attachment *
-_mesa_get_fb0_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,
-                         GLenum attachment)
-{
-   assert(fb->Name == 0);
-
-   switch (attachment) {
-   case GL_FRONT_LEFT:
-      return &fb->Attachment[BUFFER_FRONT_LEFT];
-   case GL_FRONT_RIGHT:
-      return &fb->Attachment[BUFFER_FRONT_RIGHT];
-   case GL_BACK_LEFT:
-      return &fb->Attachment[BUFFER_BACK_LEFT];
-   case GL_BACK_RIGHT:
-      return &fb->Attachment[BUFFER_BACK_RIGHT];
-   case GL_AUX0:
-      if (fb->Visual.numAuxBuffers == 1) {
-         return &fb->Attachment[BUFFER_AUX0];
-      }
-      return NULL;
-   case GL_DEPTH_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_DEPTH_ATTACHMENT_EXT:
-      return &fb->Attachment[BUFFER_DEPTH];
-   case GL_STENCIL_BUFFER:
-      /* fall-through / new in GL 3.0 */
-   case GL_STENCIL_ATTACHMENT_EXT:
-      return &fb->Attachment[BUFFER_STENCIL];
-   default:
-      return NULL;
-   }
-}
-
-
-
-/**
- * Remove any texture or renderbuffer attached to the given attachment
- * point.  Update reference counts, etc.
- */
-void
-_mesa_remove_attachment(struct gl_context *ctx,
-                        struct gl_renderbuffer_attachment *att)
-{
-   if (att->Type == GL_TEXTURE) {
-      ASSERT(att->Texture);
-      if (ctx->Driver.FinishRenderTexture) {
-         /* tell driver that we're done rendering to this texture. */
-         ctx->Driver.FinishRenderTexture(ctx, att);
-      }
-      _mesa_reference_texobj(&att->Texture, NULL); /* unbind */
-      ASSERT(!att->Texture);
-   }
-   if (att->Type == GL_TEXTURE || att->Type == GL_RENDERBUFFER_EXT) {
-      ASSERT(!att->Texture);
-      _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); /* unbind */
-      ASSERT(!att->Renderbuffer);
-   }
-   att->Type = GL_NONE;
-   att->Complete = GL_TRUE;
-}
-
-
-/**
- * Bind a texture object to an attachment point.
- * The previous binding, if any, will be removed first.
- */
-void
-_mesa_set_texture_attachment(struct gl_context *ctx,
-                             struct gl_framebuffer *fb,
-                             struct gl_renderbuffer_attachment *att,
-                             struct gl_texture_object *texObj,
-                             GLenum texTarget, GLuint level, GLuint zoffset)
-{
-   if (att->Texture == texObj) {
-      /* re-attaching same texture */
-      ASSERT(att->Type == GL_TEXTURE);
-      if (ctx->Driver.FinishRenderTexture)
-	 ctx->Driver.FinishRenderTexture(ctx, att);
-   }
-   else {
-      /* new attachment */
-      if (ctx->Driver.FinishRenderTexture && att->Texture)
-	 ctx->Driver.FinishRenderTexture(ctx, att);
-      _mesa_remove_attachment(ctx, att);
-      att->Type = GL_TEXTURE;
-      assert(!att->Texture);
-      _mesa_reference_texobj(&att->Texture, texObj);
-   }
-
-   /* always update these fields */
-   att->TextureLevel = level;
-   att->CubeMapFace = _mesa_tex_target_to_face(texTarget);
-   att->Zoffset = zoffset;
-   att->Complete = GL_FALSE;
-
-   if (att->Texture->Image[att->CubeMapFace][att->TextureLevel]) {
-      ctx->Driver.RenderTexture(ctx, fb, att);
-   }
-
-   invalidate_framebuffer(fb);
-}
-
-
-/**
- * Bind a renderbuffer to an attachment point.
- * The previous binding, if any, will be removed first.
- */
-void
-_mesa_set_renderbuffer_attachment(struct gl_context *ctx,
-                                  struct gl_renderbuffer_attachment *att,
-                                  struct gl_renderbuffer *rb)
-{
-   /* XXX check if re-doing same attachment, exit early */
-   _mesa_remove_attachment(ctx, att);
-   att->Type = GL_RENDERBUFFER_EXT;
-   att->Texture = NULL; /* just to be safe */
-   att->Complete = GL_FALSE;
-   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);
-}
-
-
-/**
- * Fallback for ctx->Driver.FramebufferRenderbuffer()
- * Attach a renderbuffer object to a framebuffer object.
- */
-void
-_mesa_framebuffer_renderbuffer(struct gl_context *ctx,
-                               struct gl_framebuffer *fb,
-                               GLenum attachment, struct gl_renderbuffer *rb)
-{
-   struct gl_renderbuffer_attachment *att;
-
-   _glthread_LOCK_MUTEX(fb->Mutex);
-
-   att = _mesa_get_attachment(ctx, fb, attachment);
-   ASSERT(att);
-   if (rb) {
-      _mesa_set_renderbuffer_attachment(ctx, att, rb);
-      if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-         /* do stencil attachment here (depth already done above) */
-         att = _mesa_get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT);
-         assert(att);
-         _mesa_set_renderbuffer_attachment(ctx, att, rb);
-      }
-      rb->AttachedAnytime = GL_TRUE;
-   }
-   else {
-      _mesa_remove_attachment(ctx, att);
-   }
-
-   invalidate_framebuffer(fb);
-
-   _glthread_UNLOCK_MUTEX(fb->Mutex);
-}
-
-
-/**
- * Fallback for ctx->Driver.ValidateFramebuffer()
- * Check if the renderbuffer's formats are supported by the software
- * renderer.
- * Drivers should probably override this.
- */
-void
-_mesa_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   gl_buffer_index buf;
-   for (buf = 0; buf < BUFFER_COUNT; buf++) {
-      const struct gl_renderbuffer *rb = fb->Attachment[buf].Renderbuffer;
-      if (rb) {
-         switch (rb->_BaseFormat) {
-         case GL_ALPHA:
-         case GL_LUMINANCE_ALPHA:
-         case GL_LUMINANCE:
-         case GL_INTENSITY:
-         case GL_RED:
-         case GL_RG:
-            fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED;
-            return;
-         default:
-            /* render buffer format is supported by software rendering */
-            ;
-         }
-      }
-   }
-}
-
-
-/**
- * For debug only.
- */
-static void
-att_incomplete(const char *msg)
-{
-#if DEBUG_FBO
-   _mesa_debug(NULL, "attachment incomplete: %s\n", msg);
-#else
-   (void) msg;
-#endif
-}
-
-
-/**
- * For debug only.
- */
-static void
-fbo_incomplete(const char *msg, int index)
-{
-#if DEBUG_FBO
-   _mesa_debug(NULL, "FBO Incomplete: %s [%d]\n", msg, index);
-#else
-   (void) msg;
-   (void) index;
-#endif
-}
-
-
-/**
- * Is the given base format a legal format for a color renderbuffer?
- */
-GLboolean
-_mesa_is_legal_color_format(const struct gl_context *ctx, GLenum baseFormat)
-{
-   switch (baseFormat) {
-   case GL_RGB:
-   case GL_RGBA:
-      return GL_TRUE;
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_ALPHA:
-      return ctx->Extensions.ARB_framebuffer_object;
-   case GL_RED:
-   case GL_RG:
-      return ctx->Extensions.ARB_texture_rg;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Is the given base format a legal format for a depth/stencil renderbuffer?
- */
-static GLboolean
-is_legal_depth_format(const struct gl_context *ctx, GLenum baseFormat)
-{
-   switch (baseFormat) {
-   case GL_DEPTH_COMPONENT:
-   case GL_DEPTH_STENCIL_EXT:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if an attachment point is complete and update its Complete field.
- * \param format if GL_COLOR, this is a color attachment point,
- *               if GL_DEPTH, this is a depth component attachment point,
- *               if GL_STENCIL, this is a stencil component attachment point.
- */
-static void
-test_attachment_completeness(const struct gl_context *ctx, GLenum format,
-                             struct gl_renderbuffer_attachment *att)
-{
-   assert(format == GL_COLOR || format == GL_DEPTH || format == GL_STENCIL);
-
-   /* assume complete */
-   att->Complete = GL_TRUE;
-
-   /* Look for reasons why the attachment might be incomplete */
-   if (att->Type == GL_TEXTURE) {
-      const struct gl_texture_object *texObj = att->Texture;
-      struct gl_texture_image *texImage;
-      GLenum baseFormat;
-
-      if (!texObj) {
-         att_incomplete("no texobj");
-         att->Complete = GL_FALSE;
-         return;
-      }
-
-      texImage = texObj->Image[att->CubeMapFace][att->TextureLevel];
-      if (!texImage) {
-         att_incomplete("no teximage");
-         att->Complete = GL_FALSE;
-         return;
-      }
-      if (texImage->Width < 1 || texImage->Height < 1) {
-         att_incomplete("teximage width/height=0");
-         printf("texobj = %u\n", texObj->Name);
-         printf("level = %d\n", att->TextureLevel);
-         att->Complete = GL_FALSE;
-         return;
-      }
-      if (texObj->Target == GL_TEXTURE_3D && att->Zoffset >= texImage->Depth) {
-         att_incomplete("bad z offset");
-         att->Complete = GL_FALSE;
-         return;
-      }
-
-      baseFormat = _mesa_get_format_base_format(texImage->TexFormat);
-
-      if (format == GL_COLOR) {
-         if (!_mesa_is_legal_color_format(ctx, baseFormat)) {
-            att_incomplete("bad format");
-            att->Complete = GL_FALSE;
-            return;
-         }
-         if (_mesa_is_format_compressed(texImage->TexFormat)) {
-            att_incomplete("compressed internalformat");
-            att->Complete = GL_FALSE;
-            return;
-         }
-      }
-      else if (format == GL_DEPTH) {
-         if (baseFormat == GL_DEPTH_COMPONENT) {
-            /* OK */
-         }
-         else if (ctx->Extensions.EXT_packed_depth_stencil &&
-                  ctx->Extensions.ARB_depth_texture &&
-                  baseFormat == GL_DEPTH_STENCIL_EXT) {
-            /* OK */
-         }
-         else {
-            att->Complete = GL_FALSE;
-            att_incomplete("bad depth format");
-            return;
-         }
-      }
-      else {
-         ASSERT(format == GL_STENCIL);
-         if (ctx->Extensions.EXT_packed_depth_stencil &&
-             ctx->Extensions.ARB_depth_texture &&
-             baseFormat == GL_DEPTH_STENCIL_EXT) {
-            /* OK */
-         }
-         else {
-            /* no such thing as stencil-only textures */
-            att_incomplete("illegal stencil texture");
-            att->Complete = GL_FALSE;
-            return;
-         }
-      }
-   }
-   else if (att->Type == GL_RENDERBUFFER_EXT) {
-      const GLenum baseFormat =
-         _mesa_get_format_base_format(att->Renderbuffer->Format);
-
-      ASSERT(att->Renderbuffer);
-      if (!att->Renderbuffer->InternalFormat ||
-          att->Renderbuffer->Width < 1 ||
-          att->Renderbuffer->Height < 1) {
-         att_incomplete("0x0 renderbuffer");
-         att->Complete = GL_FALSE;
-         return;
-      }
-      if (format == GL_COLOR) {
-         if (!_mesa_is_legal_color_format(ctx, baseFormat)) {
-            att_incomplete("bad renderbuffer color format");
-            att->Complete = GL_FALSE;
-            return;
-         }
-      }
-      else if (format == GL_DEPTH) {
-         if (baseFormat == GL_DEPTH_COMPONENT) {
-            /* OK */
-         }
-         else if (ctx->Extensions.EXT_packed_depth_stencil &&
-                  baseFormat == GL_DEPTH_STENCIL_EXT) {
-            /* OK */
-         }
-         else {
-            att_incomplete("bad renderbuffer depth format");
-            att->Complete = GL_FALSE;
-            return;
-         }
-      }
-      else {
-         assert(format == GL_STENCIL);
-         if (baseFormat == GL_STENCIL_INDEX) {
-            /* OK */
-         }
-         else if (ctx->Extensions.EXT_packed_depth_stencil &&
-                  baseFormat == GL_DEPTH_STENCIL_EXT) {
-            /* OK */
-         }
-         else {
-            att->Complete = GL_FALSE;
-            att_incomplete("bad renderbuffer stencil format");
-            return;
-         }
-      }
-   }
-   else {
-      ASSERT(att->Type == GL_NONE);
-      /* complete */
-      return;
-   }
-}
-
-
-/**
- * Test if the given framebuffer object is complete and update its
- * Status field with the results.
- * Calls the ctx->Driver.ValidateFramebuffer() function to allow the
- * driver to make hardware-specific validation/completeness checks.
- * Also update the framebuffer's Width and Height fields if the
- * framebuffer is complete.
- */
-void
-_mesa_test_framebuffer_completeness(struct gl_context *ctx,
-                                    struct gl_framebuffer *fb)
-{
-   GLuint numImages;
-   GLenum intFormat = GL_NONE; /* color buffers' internal format */
-   GLuint minWidth = ~0, minHeight = ~0, maxWidth = 0, maxHeight = 0;
-   GLint numSamples = -1;
-   GLint i;
-   GLuint j;
-
-   assert(fb->Name != 0);
-
-   numImages = 0;
-   fb->Width = 0;
-   fb->Height = 0;
-
-   /* Start at -2 to more easily loop over all attachment points.
-    *  -2: depth buffer
-    *  -1: stencil buffer
-    * >=0: color buffer
-    */
-   for (i = -2; i < (GLint) ctx->Const.MaxColorAttachments; i++) {
-      struct gl_renderbuffer_attachment *att;
-      GLenum f;
-      gl_format attFormat;
-
-      /*
-       * XXX for ARB_fbo, only check color buffers that are named by
-       * GL_READ_BUFFER and GL_DRAW_BUFFERi.
-       */
-
-      /* check for attachment completeness
-       */
-      if (i == -2) {
-         att = &fb->Attachment[BUFFER_DEPTH];
-         test_attachment_completeness(ctx, GL_DEPTH, att);
-         if (!att->Complete) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;
-            fbo_incomplete("depth attachment incomplete", -1);
-            return;
-         }
-      }
-      else if (i == -1) {
-         att = &fb->Attachment[BUFFER_STENCIL];
-         test_attachment_completeness(ctx, GL_STENCIL, att);
-         if (!att->Complete) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;
-            fbo_incomplete("stencil attachment incomplete", -1);
-            return;
-         }
-      }
-      else {
-         att = &fb->Attachment[BUFFER_COLOR0 + i];
-         test_attachment_completeness(ctx, GL_COLOR, att);
-         if (!att->Complete) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;
-            fbo_incomplete("color attachment incomplete", i);
-            return;
-         }
-      }
-
-      /* get width, height, format of the renderbuffer/texture
-       */
-      if (att->Type == GL_TEXTURE) {
-         const struct gl_texture_image *texImg
-            = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
-         minWidth = MIN2(minWidth, texImg->Width);
-         maxWidth = MAX2(maxWidth, texImg->Width);
-         minHeight = MIN2(minHeight, texImg->Height);
-         maxHeight = MAX2(maxHeight, texImg->Height);
-         f = texImg->_BaseFormat;
-         attFormat = texImg->TexFormat;
-         numImages++;
-         if (!_mesa_is_legal_color_format(ctx, f) &&
-             !is_legal_depth_format(ctx, f)) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;
-            fbo_incomplete("texture attachment incomplete", -1);
-            return;
-         }
-      }
-      else if (att->Type == GL_RENDERBUFFER_EXT) {
-         minWidth = MIN2(minWidth, att->Renderbuffer->Width);
-         maxWidth = MAX2(minWidth, att->Renderbuffer->Width);
-         minHeight = MIN2(minHeight, att->Renderbuffer->Height);
-         maxHeight = MAX2(minHeight, att->Renderbuffer->Height);
-         f = att->Renderbuffer->InternalFormat;
-         attFormat = att->Renderbuffer->Format;
-         numImages++;
-      }
-      else {
-         assert(att->Type == GL_NONE);
-         continue;
-      }
-
-      if (numSamples < 0) {
-         /* first buffer */
-         numSamples = att->Renderbuffer->NumSamples;
-      }
-
-      /* check if integer color */
-      fb->_IntegerColor = _mesa_is_format_integer_color(attFormat);
-
-      /* Error-check width, height, format, samples
-       */
-      if (numImages == 1) {
-         /* save format, num samples */
-         if (i >= 0) {
-            intFormat = f;
-         }
-      }
-      else {
-         if (!ctx->Extensions.ARB_framebuffer_object) {
-            /* check that width, height, format are same */
-            if (minWidth != maxWidth || minHeight != maxHeight) {
-               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT;
-               fbo_incomplete("width or height mismatch", -1);
-               return;
-            }
-            /* check that all color buffer have same format */
-            if (intFormat != GL_NONE && f != intFormat) {
-               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;
-               fbo_incomplete("format mismatch", -1);
-               return;
-            }
-         }
-         if (att->Renderbuffer &&
-             att->Renderbuffer->NumSamples != numSamples) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;
-            fbo_incomplete("inconsistant number of samples", i);
-            return;
-         }            
-
-      }
-   }
-
-#if FEATURE_GL
-   if (ctx->API == API_OPENGL) {
-      /* Check that all DrawBuffers are present */
-      for (j = 0; j < ctx->Const.MaxDrawBuffers; j++) {
-	 if (fb->ColorDrawBuffer[j] != GL_NONE) {
-	    const struct gl_renderbuffer_attachment *att
-	       = _mesa_get_attachment(ctx, fb, fb->ColorDrawBuffer[j]);
-	    assert(att);
-	    if (att->Type == GL_NONE) {
-	       fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT;
-	       fbo_incomplete("missing drawbuffer", j);
-	       return;
-	    }
-	 }
-      }
-
-      /* Check that the ReadBuffer is present */
-      if (fb->ColorReadBuffer != GL_NONE) {
-	 const struct gl_renderbuffer_attachment *att
-	    = _mesa_get_attachment(ctx, fb, fb->ColorReadBuffer);
-	 assert(att);
-	 if (att->Type == GL_NONE) {
-	    fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT;
-            fbo_incomplete("missing readbuffer", -1);
-	    return;
-	 }
-      }
-   }
-#else
-   (void) j;
-#endif
-
-   if (numImages == 0) {
-      fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT;
-      fbo_incomplete("no attachments", -1);
-      return;
-   }
-
-   /* Provisionally set status = COMPLETE ... */
-   fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
-
-   /* ... but the driver may say the FB is incomplete.
-    * Drivers will most likely set the status to GL_FRAMEBUFFER_UNSUPPORTED
-    * if anything.
-    */
-   if (ctx->Driver.ValidateFramebuffer) {
-      ctx->Driver.ValidateFramebuffer(ctx, fb);
-      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         fbo_incomplete("driver marked FBO as incomplete", -1);
-      }
-   }
-
-   if (fb->_Status == GL_FRAMEBUFFER_COMPLETE_EXT) {
-      /*
-       * Note that if ARB_framebuffer_object is supported and the attached
-       * renderbuffers/textures are different sizes, the framebuffer
-       * width/height will be set to the smallest width/height.
-       */
-      fb->Width = minWidth;
-      fb->Height = minHeight;
-
-      /* finally, update the visual info for the framebuffer */
-      _mesa_update_framebuffer_visual(ctx, fb);
-   }
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsRenderbufferEXT(GLuint renderbuffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-   if (renderbuffer) {
-      struct gl_renderbuffer *rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
-      if (rb != NULL && rb != &DummyRenderbuffer)
-         return GL_TRUE;
-   }
-   return GL_FALSE;
-}
-
-
-void GLAPIENTRY
-_mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
-{
-   struct gl_renderbuffer *newRb;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (target != GL_RENDERBUFFER_EXT) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindRenderbufferEXT(target)");
-      return;
-   }
-
-   /* No need to flush here since the render buffer binding has no
-    * effect on rendering state.
-    */
-
-   if (renderbuffer) {
-      newRb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
-      if (newRb == &DummyRenderbuffer) {
-         /* ID was reserved, but no real renderbuffer object made yet */
-         newRb = NULL;
-      }
-      else if (!newRb && ctx->Extensions.ARB_framebuffer_object) {
-         /* All RB IDs must be Gen'd */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindRenderbuffer(buffer)");
-         return;
-      }
-
-      if (!newRb) {
-	 /* create new renderbuffer object */
-	 newRb = ctx->Driver.NewRenderbuffer(ctx, renderbuffer);
-	 if (!newRb) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindRenderbufferEXT");
-	    return;
-	 }
-         ASSERT(newRb->AllocStorage);
-         _mesa_HashInsert(ctx->Shared->RenderBuffers, renderbuffer, newRb);
-         newRb->RefCount = 1; /* referenced by hash table */
-      }
-   }
-   else {
-      newRb = NULL;
-   }
-
-   ASSERT(newRb != &DummyRenderbuffer);
-
-   _mesa_reference_renderbuffer(&ctx->CurrentRenderbuffer, newRb);
-}
-
-
-/**
- * If the given renderbuffer is anywhere attached to the framebuffer, detach
- * the renderbuffer.
- * This is used when a renderbuffer object is deleted.
- * The spec calls for unbinding.
- */
-static void
-detach_renderbuffer(struct gl_context *ctx,
-                    struct gl_framebuffer *fb,
-                    struct gl_renderbuffer *rb)
-{
-   GLuint i;
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      if (fb->Attachment[i].Renderbuffer == rb) {
-         _mesa_remove_attachment(ctx, &fb->Attachment[i]);
-      }
-   }
-   invalidate_framebuffer(fb);
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)
-{
-   GLint i;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   for (i = 0; i < n; i++) {
-      if (renderbuffers[i] > 0) {
-	 struct gl_renderbuffer *rb;
-	 rb = _mesa_lookup_renderbuffer(ctx, renderbuffers[i]);
-	 if (rb) {
-            /* check if deleting currently bound renderbuffer object */
-            if (rb == ctx->CurrentRenderbuffer) {
-               /* bind default */
-               ASSERT(rb->RefCount >= 2);
-               _mesa_BindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
-            }
-
-            if (ctx->DrawBuffer->Name) {
-               detach_renderbuffer(ctx, ctx->DrawBuffer, rb);
-            }
-            if (ctx->ReadBuffer->Name && ctx->ReadBuffer != ctx->DrawBuffer) {
-               detach_renderbuffer(ctx, ctx->ReadBuffer, rb);
-            }
-
-	    /* Remove from hash table immediately, to free the ID.
-             * But the object will not be freed until it's no longer
-             * referenced anywhere else.
-             */
-	    _mesa_HashRemove(ctx->Shared->RenderBuffers, renderbuffers[i]);
-
-            if (rb != &DummyRenderbuffer) {
-               /* no longer referenced by hash table */
-               _mesa_reference_renderbuffer(&rb, NULL);
-	    }
-	 }
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint first;
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenRenderbuffersEXT(n)");
-      return;
-   }
-
-   if (!renderbuffers)
-      return;
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->RenderBuffers, n);
-
-   for (i = 0; i < n; i++) {
-      GLuint name = first + i;
-      renderbuffers[i] = name;
-      /* insert dummy placeholder into hash table */
-      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-      _mesa_HashInsert(ctx->Shared->RenderBuffers, name, &DummyRenderbuffer);
-      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-   }
-}
-
-
-/**
- * Given an internal format token for a render buffer, return the
- * corresponding base format (one of GL_RGB, GL_RGBA, GL_STENCIL_INDEX,
- * GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL_EXT, GL_ALPHA, GL_LUMINANCE,
- * GL_LUMINANCE_ALPHA, GL_INTENSITY, etc).
- *
- * This is similar to _mesa_base_tex_format() but the set of valid
- * internal formats is different.
- *
- * Note that even if a format is determined to be legal here, validation
- * of the FBO may fail if the format is not supported by the driver/GPU.
- *
- * \param internalFormat  as passed to glRenderbufferStorage()
- * \return the base internal format, or 0 if internalFormat is illegal
- */
-GLenum
-_mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
-{
-   /*
-    * Notes: some formats such as alpha, luminance, etc. were added
-    * with GL_ARB_framebuffer_object.
-    */
-   switch (internalFormat) {
-   case GL_ALPHA:
-   case GL_ALPHA4:
-   case GL_ALPHA8:
-   case GL_ALPHA12:
-   case GL_ALPHA16:
-      return ctx->Extensions.ARB_framebuffer_object ? GL_ALPHA : 0;
-   case GL_LUMINANCE:
-   case GL_LUMINANCE4:
-   case GL_LUMINANCE8:
-   case GL_LUMINANCE12:
-   case GL_LUMINANCE16:
-      return ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE : 0;
-   case GL_LUMINANCE_ALPHA:
-   case GL_LUMINANCE4_ALPHA4:
-   case GL_LUMINANCE6_ALPHA2:
-   case GL_LUMINANCE8_ALPHA8:
-   case GL_LUMINANCE12_ALPHA4:
-   case GL_LUMINANCE12_ALPHA12:
-   case GL_LUMINANCE16_ALPHA16:
-      return ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE_ALPHA : 0;
-   case GL_INTENSITY:
-   case GL_INTENSITY4:
-   case GL_INTENSITY8:
-   case GL_INTENSITY12:
-   case GL_INTENSITY16:
-      return ctx->Extensions.ARB_framebuffer_object ? GL_INTENSITY : 0;
-   case GL_RGB:
-   case GL_R3_G3_B2:
-   case GL_RGB4:
-   case GL_RGB5:
-   case GL_RGB8:
-   case GL_RGB10:
-   case GL_RGB12:
-   case GL_RGB16:
-   case GL_SRGB8_EXT:
-      return GL_RGB;
-   case GL_RGBA:
-   case GL_RGBA2:
-   case GL_RGBA4:
-   case GL_RGB5_A1:
-   case GL_RGBA8:
-   case GL_RGB10_A2:
-   case GL_RGBA12:
-   case GL_RGBA16:
-   case GL_RGBA16_SNORM:
-   case GL_SRGB8_ALPHA8_EXT:
-      return GL_RGBA;
-   case GL_STENCIL_INDEX:
-   case GL_STENCIL_INDEX1_EXT:
-   case GL_STENCIL_INDEX4_EXT:
-   case GL_STENCIL_INDEX8_EXT:
-   case GL_STENCIL_INDEX16_EXT:
-      return GL_STENCIL_INDEX;
-   case GL_DEPTH_COMPONENT:
-   case GL_DEPTH_COMPONENT16:
-   case GL_DEPTH_COMPONENT24:
-   case GL_DEPTH_COMPONENT32:
-      return GL_DEPTH_COMPONENT;
-   case GL_DEPTH_STENCIL_EXT:
-   case GL_DEPTH24_STENCIL8_EXT:
-      if (ctx->Extensions.EXT_packed_depth_stencil)
-         return GL_DEPTH_STENCIL_EXT;
-      else
-         return 0;
-   case GL_RED:
-   case GL_R8:
-   case GL_R16:
-      return ctx->Extensions.ARB_texture_rg ? GL_RED : 0;
-   case GL_RG:
-   case GL_RG8:
-   case GL_RG16:
-      return ctx->Extensions.ARB_texture_rg ? GL_RG : 0;
-   /* XXX add floating point and integer formats eventually */
-   default:
-      return 0;
-   }
-}
-
-
-/**
- * Invalidate a renderbuffer attachment.  Called from _mesa_HashWalk().
- */
-static void
-invalidate_rb(GLuint key, void *data, void *userData)
-{
-   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
-   struct gl_renderbuffer *rb = (struct gl_renderbuffer *) userData;
-
-   /* If this is a user-created FBO */
-   if (fb->Name) {
-      GLuint i;
-      for (i = 0; i < BUFFER_COUNT; i++) {
-         struct gl_renderbuffer_attachment *att = fb->Attachment + i;
-         if (att->Type == GL_RENDERBUFFER &&
-             att->Renderbuffer == rb) {
-            /* Mark fb status as indeterminate to force re-validation */
-            fb->_Status = 0;
-            return;
-         }
-      }
-   }
-}
-
-
-/** sentinal value, see below */
-#define NO_SAMPLES 1000
-
-
-/**
- * Helper function used by _mesa_RenderbufferStorageEXT() and 
- * _mesa_RenderbufferStorageMultisample().
- * samples will be NO_SAMPLES if called by _mesa_RenderbufferStorageEXT().
- */
-static void
-renderbuffer_storage(GLenum target, GLenum internalFormat,
-                     GLsizei width, GLsizei height, GLsizei samples)
-{
-   const char *func = samples == NO_SAMPLES ?
-      "glRenderbufferStorage" : "RenderbufferStorageMultisample";
-   struct gl_renderbuffer *rb;
-   GLenum baseFormat;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (target != GL_RENDERBUFFER_EXT) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", func);
-      return;
-   }
-
-   baseFormat = _mesa_base_fbo_format(ctx, internalFormat);
-   if (baseFormat == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(internalFormat)", func);
-      return;
-   }
-
-   if (width < 1 || width > (GLsizei) ctx->Const.MaxRenderbufferSize) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(width)", func);
-      return;
-   }
-
-   if (height < 1 || height > (GLsizei) ctx->Const.MaxRenderbufferSize) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(height)", func);
-      return;
-   }
-
-   if (samples == NO_SAMPLES) {
-      /* NumSamples == 0 indicates non-multisampling */
-      samples = 0;
-   }
-   else if (samples > (GLsizei) ctx->Const.MaxSamples) {
-      /* note: driver may choose to use more samples than what's requested */
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(samples)", func);
-      return;
-   }
-
-   rb = ctx->CurrentRenderbuffer;
-   if (!rb) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   if (rb->InternalFormat == internalFormat &&
-       rb->Width == (GLuint) width &&
-       rb->Height == (GLuint) height) {
-      /* no change in allocation needed */
-      return;
-   }
-
-   /* These MUST get set by the AllocStorage func */
-   rb->Format = MESA_FORMAT_NONE;
-   rb->NumSamples = samples;
-
-   /* Now allocate the storage */
-   ASSERT(rb->AllocStorage);
-   if (rb->AllocStorage(ctx, rb, internalFormat, width, height)) {
-      /* No error - check/set fields now */
-      assert(rb->Format != MESA_FORMAT_NONE);
-      assert(rb->Width == (GLuint) width);
-      assert(rb->Height == (GLuint) height);
-      rb->InternalFormat = internalFormat;
-      rb->_BaseFormat = baseFormat;
-      assert(rb->_BaseFormat != 0);
-   }
-   else {
-      /* Probably ran out of memory - clear the fields */
-      rb->Width = 0;
-      rb->Height = 0;
-      rb->Format = MESA_FORMAT_NONE;
-      rb->InternalFormat = GL_NONE;
-      rb->_BaseFormat = GL_NONE;
-      rb->NumSamples = 0;
-   }
-
-   /* Invalidate the framebuffers the renderbuffer is attached in. */
-   if (rb->AttachedAnytime) {
-      _mesa_HashWalk(ctx->Shared->FrameBuffers, invalidate_rb, rb);
-   }
-}
-
-
-#if FEATURE_OES_EGL_image
-void GLAPIENTRY
-_mesa_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
-{
-   struct gl_renderbuffer *rb;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!ctx->Extensions.OES_EGL_image) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glEGLImageTargetRenderbufferStorageOES(unsupported)");
-      return;
-   }
-
-   if (target != GL_RENDERBUFFER) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "EGLImageTargetRenderbufferStorageOES");
-      return;
-   }
-
-   rb = ctx->CurrentRenderbuffer;
-   if (!rb) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "EGLImageTargetRenderbufferStorageOES");
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   ctx->Driver.EGLImageTargetRenderbufferStorage(ctx, rb, image);
-}
-#endif
-
-
-/**
- * Helper function for _mesa_GetRenderbufferParameterivEXT() and
- * _mesa_GetFramebufferAttachmentParameterivEXT()
- * We have to be careful to respect the base format.  For example, if a
- * renderbuffer/texture was created with internalFormat=GL_RGB but the
- * driver actually chose a GL_RGBA format, when the user queries ALPHA_SIZE
- * we need to return zero.
- */
-static GLint
-get_component_bits(GLenum pname, GLenum baseFormat, gl_format format)
-{
-   switch (pname) {
-   case GL_RENDERBUFFER_RED_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
-      if (baseFormat == GL_RGB || baseFormat == GL_RGBA ||
-	  baseFormat == GL_RG || baseFormat == GL_RED)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   case GL_RENDERBUFFER_GREEN_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
-      if (baseFormat == GL_RGB || baseFormat == GL_RGBA || baseFormat == GL_RG)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   case GL_RENDERBUFFER_BLUE_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
-      if (baseFormat == GL_RGB || baseFormat == GL_RGBA)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
-      if (baseFormat == GL_RGBA || baseFormat == GL_ALPHA ||
-	  baseFormat == GL_LUMINANCE_ALPHA)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
-      if (baseFormat == GL_DEPTH_COMPONENT || baseFormat == GL_DEPTH_STENCIL)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
-      if (baseFormat == GL_STENCIL_INDEX || baseFormat == GL_DEPTH_STENCIL)
-         return _mesa_get_format_bits(format, pname);
-      else
-         return 0;
-   default:
-      return 0;
-   }
-}
-
-
-
-void GLAPIENTRY
-_mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
-                             GLsizei width, GLsizei height)
-{
-   /* GL_ARB_fbo says calling this function is equivalent to calling
-    * glRenderbufferStorageMultisample() with samples=0.  We pass in
-    * a token value here just for error reporting purposes.
-    */
-   renderbuffer_storage(target, internalFormat, width, height, NO_SAMPLES);
-}
-
-
-void GLAPIENTRY
-_mesa_RenderbufferStorageMultisample(GLenum target, GLsizei samples,
-                                     GLenum internalFormat,
-                                     GLsizei width, GLsizei height)
-{
-   renderbuffer_storage(target, internalFormat, width, height, samples);
-}
-
-
-/**
- * OpenGL ES version of glRenderBufferStorage.
- */
-void GLAPIENTRY
-_es_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
-			   GLsizei width, GLsizei height)
-{
-   switch (internalFormat) {
-   case GL_RGB565:
-      /* XXX this confuses GL_RENDERBUFFER_INTERNAL_FORMAT_OES */
-      /* choose a closest format */
-      internalFormat = GL_RGB5;
-      break;
-   default:
-      break;
-   }
-
-   renderbuffer_storage(target, internalFormat, width, height, 0);
-}
-
-
-void GLAPIENTRY
-_mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
-{
-   struct gl_renderbuffer *rb;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (target != GL_RENDERBUFFER_EXT) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetRenderbufferParameterivEXT(target)");
-      return;
-   }
-
-   rb = ctx->CurrentRenderbuffer;
-   if (!rb) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetRenderbufferParameterivEXT");
-      return;
-   }
-
-   /* No need to flush here since we're just quering state which is
-    * not effected by rendering.
-    */
-
-   switch (pname) {
-   case GL_RENDERBUFFER_WIDTH_EXT:
-      *params = rb->Width;
-      return;
-   case GL_RENDERBUFFER_HEIGHT_EXT:
-      *params = rb->Height;
-      return;
-   case GL_RENDERBUFFER_INTERNAL_FORMAT_EXT:
-      *params = rb->InternalFormat;
-      return;
-   case GL_RENDERBUFFER_RED_SIZE_EXT:
-   case GL_RENDERBUFFER_GREEN_SIZE_EXT:
-   case GL_RENDERBUFFER_BLUE_SIZE_EXT:
-   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
-   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
-   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
-      *params = get_component_bits(pname, rb->_BaseFormat, rb->Format);
-      break;
-   case GL_RENDERBUFFER_SAMPLES:
-      if (ctx->Extensions.ARB_framebuffer_object) {
-         *params = rb->NumSamples;
-         break;
-      }
-      /* fallthrough */
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetRenderbufferParameterivEXT(target)");
-      return;
-   }
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsFramebufferEXT(GLuint framebuffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-   if (framebuffer) {
-      struct gl_framebuffer *rb = _mesa_lookup_framebuffer(ctx, framebuffer);
-      if (rb != NULL && rb != &DummyFramebuffer)
-         return GL_TRUE;
-   }
-   return GL_FALSE;
-}
-
-
-/**
- * Check if any of the attachments of the given framebuffer are textures
- * (render to texture).  Call ctx->Driver.RenderTexture() for such
- * attachments.
- */
-static void
-check_begin_texture_render(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   GLuint i;
-   ASSERT(ctx->Driver.RenderTexture);
-
-   if (fb->Name == 0)
-      return; /* can't render to texture with winsys framebuffers */
-
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      struct gl_renderbuffer_attachment *att = fb->Attachment + i;
-      struct gl_texture_object *texObj = att->Texture;
-      if (texObj
-          && texObj->Image[att->CubeMapFace][att->TextureLevel]) {
-         ctx->Driver.RenderTexture(ctx, fb, att);
-      }
-   }
-}
-
-
-/**
- * Examine all the framebuffer's attachments to see if any are textures.
- * If so, call ctx->Driver.FinishRenderTexture() for each texture to
- * notify the device driver that the texture image may have changed.
- */
-static void
-check_end_texture_render(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   if (fb->Name == 0)
-      return; /* can't render to texture with winsys framebuffers */
-
-   if (ctx->Driver.FinishRenderTexture) {
-      GLuint i;
-      for (i = 0; i < BUFFER_COUNT; i++) {
-         struct gl_renderbuffer_attachment *att = fb->Attachment + i;
-         if (att->Texture && att->Renderbuffer) {
-            ctx->Driver.FinishRenderTexture(ctx, att);
-         }
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
-{
-   struct gl_framebuffer *newDrawFb, *newReadFb;
-   struct gl_framebuffer *oldDrawFb, *oldReadFb;
-   GLboolean bindReadBuf, bindDrawBuf;
-   GET_CURRENT_CONTEXT(ctx);
-
-#ifdef DEBUG
-   if (ctx->Extensions.ARB_framebuffer_object) {
-      ASSERT(ctx->Extensions.EXT_framebuffer_object);
-      ASSERT(ctx->Extensions.EXT_framebuffer_blit);
-   }
-#endif
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!ctx->Extensions.EXT_framebuffer_object) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glBindFramebufferEXT(unsupported)");
-      return;
-   }
-
-   switch (target) {
-#if FEATURE_EXT_framebuffer_blit
-   case GL_DRAW_FRAMEBUFFER_EXT:
-      if (!ctx->Extensions.EXT_framebuffer_blit) {
-         _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");
-         return;
-      }
-      bindDrawBuf = GL_TRUE;
-      bindReadBuf = GL_FALSE;
-      break;
-   case GL_READ_FRAMEBUFFER_EXT:
-      if (!ctx->Extensions.EXT_framebuffer_blit) {
-         _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");
-         return;
-      }
-      bindDrawBuf = GL_FALSE;
-      bindReadBuf = GL_TRUE;
-      break;
-#endif
-   case GL_FRAMEBUFFER_EXT:
-      bindDrawBuf = GL_TRUE;
-      bindReadBuf = GL_TRUE;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");
-      return;
-   }
-
-   if (framebuffer) {
-      /* Binding a user-created framebuffer object */
-      newDrawFb = _mesa_lookup_framebuffer(ctx, framebuffer);
-      if (newDrawFb == &DummyFramebuffer) {
-         /* ID was reserved, but no real framebuffer object made yet */
-         newDrawFb = NULL;
-      }
-      else if (!newDrawFb && ctx->Extensions.ARB_framebuffer_object) {
-         /* All FBO IDs must be Gen'd */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindFramebuffer(buffer)");
-         return;
-      }
-
-      if (!newDrawFb) {
-	 /* create new framebuffer object */
-	 newDrawFb = ctx->Driver.NewFramebuffer(ctx, framebuffer);
-	 if (!newDrawFb) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindFramebufferEXT");
-	    return;
-	 }
-         _mesa_HashInsert(ctx->Shared->FrameBuffers, framebuffer, newDrawFb);
-      }
-      newReadFb = newDrawFb;
-   }
-   else {
-      /* Binding the window system framebuffer (which was originally set
-       * with MakeCurrent).
-       */
-      newDrawFb = ctx->WinSysDrawBuffer;
-      newReadFb = ctx->WinSysReadBuffer;
-   }
-
-   ASSERT(newDrawFb);
-   ASSERT(newDrawFb != &DummyFramebuffer);
-
-   /* save pointers to current/old framebuffers */
-   oldDrawFb = ctx->DrawBuffer;
-   oldReadFb = ctx->ReadBuffer;
-
-   /* check if really changing bindings */
-   if (oldDrawFb == newDrawFb)
-      bindDrawBuf = GL_FALSE;
-   if (oldReadFb == newReadFb)
-      bindReadBuf = GL_FALSE;
-
-   /*
-    * OK, now bind the new Draw/Read framebuffers, if they're changing.
-    *
-    * We also check if we're beginning and/or ending render-to-texture.
-    * When a framebuffer with texture attachments is unbound, call
-    * ctx->Driver.FinishRenderTexture().
-    * When a framebuffer with texture attachments is bound, call
-    * ctx->Driver.RenderTexture().
-    *
-    * Note that if the ReadBuffer has texture attachments we don't consider
-    * that a render-to-texture case.
-    */
-   if (bindReadBuf) {
-      FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-      /* check if old readbuffer was render-to-texture */
-      check_end_texture_render(ctx, oldReadFb);
-
-      _mesa_reference_framebuffer(&ctx->ReadBuffer, newReadFb);
-   }
-
-   if (bindDrawBuf) {
-      FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-      /* check if old read/draw buffers were render-to-texture */
-      if (!bindReadBuf)
-         check_end_texture_render(ctx, oldReadFb);
-
-      if (oldDrawFb != oldReadFb)
-         check_end_texture_render(ctx, oldDrawFb);
-
-      /* check if newly bound framebuffer has any texture attachments */
-      check_begin_texture_render(ctx, newDrawFb);
-
-      _mesa_reference_framebuffer(&ctx->DrawBuffer, newDrawFb);
-   }
-
-   if ((bindDrawBuf || bindReadBuf) && ctx->Driver.BindFramebuffer) {
-      ctx->Driver.BindFramebuffer(ctx, target, newDrawFb, newReadFb);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
-{
-   GLint i;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   for (i = 0; i < n; i++) {
-      if (framebuffers[i] > 0) {
-	 struct gl_framebuffer *fb;
-	 fb = _mesa_lookup_framebuffer(ctx, framebuffers[i]);
-	 if (fb) {
-            ASSERT(fb == &DummyFramebuffer || fb->Name == framebuffers[i]);
-
-            /* check if deleting currently bound framebuffer object */
-            if (ctx->Extensions.EXT_framebuffer_blit) {
-               /* separate draw/read binding points */
-               if (fb == ctx->DrawBuffer) {
-                  /* bind default */
-                  ASSERT(fb->RefCount >= 2);
-                  _mesa_BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
-               }
-               if (fb == ctx->ReadBuffer) {
-                  /* bind default */
-                  ASSERT(fb->RefCount >= 2);
-                  _mesa_BindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
-               }
-            }
-            else {
-               /* only one binding point for read/draw buffers */
-               if (fb == ctx->DrawBuffer || fb == ctx->ReadBuffer) {
-                  /* bind default */
-                  ASSERT(fb->RefCount >= 2);
-                  _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-               }    
-            }
-
-	    /* remove from hash table immediately, to free the ID */
-	    _mesa_HashRemove(ctx->Shared->FrameBuffers, framebuffers[i]);
-
-            if (fb != &DummyFramebuffer) {
-               /* But the object will not be freed until it's no longer
-                * bound in any context.
-                */
-               _mesa_reference_framebuffer(&fb, NULL);
-	    }
-	 }
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GenFramebuffersEXT(GLsizei n, GLuint *framebuffers)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint first;
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenFramebuffersEXT(n)");
-      return;
-   }
-
-   if (!framebuffers)
-      return;
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->FrameBuffers, n);
-
-   for (i = 0; i < n; i++) {
-      GLuint name = first + i;
-      framebuffers[i] = name;
-      /* insert dummy placeholder into hash table */
-      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-      _mesa_HashInsert(ctx->Shared->FrameBuffers, name, &DummyFramebuffer);
-      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-   }
-}
-
-
-
-GLenum GLAPIENTRY
-_mesa_CheckFramebufferStatusEXT(GLenum target)
-{
-   struct gl_framebuffer *buffer;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   buffer = get_framebuffer_target(ctx, target);
-   if (!buffer) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCheckFramebufferStatus(target)");
-      return 0;
-   }
-
-   if (buffer->Name == 0) {
-      /* The window system / default framebuffer is always complete */
-      return GL_FRAMEBUFFER_COMPLETE_EXT;
-   }
-
-   /* No need to flush here */
-
-   if (buffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
-      _mesa_test_framebuffer_completeness(ctx, buffer);
-   }
-
-   return buffer->_Status;
-}
-
-
-
-/**
- * Common code called by glFramebufferTexture1D/2D/3DEXT().
- */
-static void
-framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target, 
-                    GLenum attachment, GLenum textarget, GLuint texture,
-                    GLint level, GLint zoffset)
-{
-   struct gl_renderbuffer_attachment *att;
-   struct gl_texture_object *texObj = NULL;
-   struct gl_framebuffer *fb;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   fb = get_framebuffer_target(ctx, target);
-   if (!fb) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferTexture%sEXT(target=0x%x)", caller, target);
-      return;
-   }
-
-   /* check framebuffer binding */
-   if (fb->Name == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glFramebufferTexture%sEXT", caller);
-      return;
-   }
-
-
-   /* The textarget, level, and zoffset parameters are only validated if
-    * texture is non-zero.
-    */
-   if (texture) {
-      GLboolean err = GL_TRUE;
-
-      texObj = _mesa_lookup_texture(ctx, texture);
-      if (texObj != NULL) {
-         if (textarget == 0) {
-            /* XXX what's the purpose of this? */
-            err = (texObj->Target != GL_TEXTURE_3D) &&
-                (texObj->Target != GL_TEXTURE_1D_ARRAY_EXT) &&
-                (texObj->Target != GL_TEXTURE_2D_ARRAY_EXT);
-         }
-         else {
-            err = (texObj->Target == GL_TEXTURE_CUBE_MAP)
-                ? !IS_CUBE_FACE(textarget)
-                : (texObj->Target != textarget);
-         }
-      }
-      else {
-         /* can't render to a non-existant texture */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glFramebufferTexture%sEXT(non existant texture)",
-                     caller);
-         return;
-      }
-
-      if (err) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glFramebufferTexture%sEXT(texture target mismatch)",
-                     caller);
-         return;
-      }
-
-      if (texObj->Target == GL_TEXTURE_3D) {
-         const GLint maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);
-         if (zoffset < 0 || zoffset >= maxSize) {
-            _mesa_error(ctx, GL_INVALID_VALUE,
-                        "glFramebufferTexture%sEXT(zoffset)", caller);
-            return;
-         }
-      }
-      else if ((texObj->Target == GL_TEXTURE_1D_ARRAY_EXT) ||
-               (texObj->Target == GL_TEXTURE_2D_ARRAY_EXT)) {
-         if (zoffset < 0 || zoffset >= ctx->Const.MaxArrayTextureLayers) {
-            _mesa_error(ctx, GL_INVALID_VALUE,
-                        "glFramebufferTexture%sEXT(layer)", caller);
-            return;
-         }
-      }
-
-      if ((level < 0) || 
-          (level >= _mesa_max_texture_levels(ctx, texObj->Target))) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glFramebufferTexture%sEXT(level)", caller);
-         return;
-      }
-   }
-
-   att = _mesa_get_attachment(ctx, fb, attachment);
-   if (att == NULL) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferTexture%sEXT(attachment)", caller);
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   _glthread_LOCK_MUTEX(fb->Mutex);
-   if (texObj) {
-      _mesa_set_texture_attachment(ctx, fb, att, texObj, textarget,
-                                   level, zoffset);
-      /* Set the render-to-texture flag.  We'll check this flag in
-       * glTexImage() and friends to determine if we need to revalidate
-       * any FBOs that might be rendering into this texture.
-       * This flag never gets cleared since it's non-trivial to determine
-       * when all FBOs might be done rendering to this texture.  That's OK
-       * though since it's uncommon to render to a texture then repeatedly
-       * call glTexImage() to change images in the texture.
-       */
-      texObj->_RenderToTexture = GL_TRUE;
-   }
-   else {
-      _mesa_remove_attachment(ctx, att);
-   }
-
-   invalidate_framebuffer(fb);
-
-   _glthread_UNLOCK_MUTEX(fb->Mutex);
-}
-
-
-
-void GLAPIENTRY
-_mesa_FramebufferTexture1DEXT(GLenum target, GLenum attachment,
-                              GLenum textarget, GLuint texture, GLint level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if ((texture != 0) && (textarget != GL_TEXTURE_1D)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferTexture1DEXT(textarget)");
-      return;
-   }
-
-   framebuffer_texture(ctx, "1D", target, attachment, textarget, texture,
-                       level, 0);
-}
-
-
-void GLAPIENTRY
-_mesa_FramebufferTexture2DEXT(GLenum target, GLenum attachment,
-                              GLenum textarget, GLuint texture, GLint level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if ((texture != 0) &&
-       (textarget != GL_TEXTURE_2D) &&
-       (textarget != GL_TEXTURE_RECTANGLE_ARB) &&
-       (!IS_CUBE_FACE(textarget))) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glFramebufferTexture2DEXT(textarget=0x%x)", textarget);
-      return;
-   }
-
-   framebuffer_texture(ctx, "2D", target, attachment, textarget, texture,
-                       level, 0);
-}
-
-
-void GLAPIENTRY
-_mesa_FramebufferTexture3DEXT(GLenum target, GLenum attachment,
-                              GLenum textarget, GLuint texture,
-                              GLint level, GLint zoffset)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if ((texture != 0) && (textarget != GL_TEXTURE_3D)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferTexture3DEXT(textarget)");
-      return;
-   }
-
-   framebuffer_texture(ctx, "3D", target, attachment, textarget, texture,
-                       level, zoffset);
-}
-
-
-void GLAPIENTRY
-_mesa_FramebufferTextureLayerEXT(GLenum target, GLenum attachment,
-                                 GLuint texture, GLint level, GLint layer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   framebuffer_texture(ctx, "Layer", target, attachment, 0, texture,
-                       level, layer);
-}
-
-
-void GLAPIENTRY
-_mesa_FramebufferRenderbufferEXT(GLenum target, GLenum attachment,
-                                 GLenum renderbufferTarget,
-                                 GLuint renderbuffer)
-{
-   struct gl_renderbuffer_attachment *att;
-   struct gl_framebuffer *fb;
-   struct gl_renderbuffer *rb;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   fb = get_framebuffer_target(ctx, target);
-   if (!fb) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glFramebufferRenderbufferEXT(target)");
-      return;
-   }
-
-   if (renderbufferTarget != GL_RENDERBUFFER_EXT) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferRenderbufferEXT(renderbufferTarget)");
-      return;
-   }
-
-   if (fb->Name == 0) {
-      /* Can't attach new renderbuffers to a window system framebuffer */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glFramebufferRenderbufferEXT");
-      return;
-   }
-
-   att = _mesa_get_attachment(ctx, fb, attachment);
-   if (att == NULL) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferRenderbufferEXT(invalid attachment %s)",
-                  _mesa_lookup_enum_by_nr(attachment));
-      return;
-   }
-
-   if (renderbuffer) {
-      rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
-      if (!rb) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION,
-		     "glFramebufferRenderbufferEXT(non-existant"
-                     " renderbuffer %u)", renderbuffer);
-	 return;
-      }
-      else if (rb == &DummyRenderbuffer) {
-         /* This is what NVIDIA does */
-	 _mesa_error(ctx, GL_INVALID_VALUE,
-		     "glFramebufferRenderbufferEXT(renderbuffer %u)",
-                     renderbuffer);
-	 return;
-      }
-   }
-   else {
-      /* remove renderbuffer attachment */
-      rb = NULL;
-   }
-
-   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT &&
-       rb && rb->Format != MESA_FORMAT_NONE) {
-      /* make sure the renderbuffer is a depth/stencil format */
-      const GLenum baseFormat = _mesa_get_format_base_format(rb->Format);
-      if (baseFormat != GL_DEPTH_STENCIL) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glFramebufferRenderbufferEXT(renderbuffer"
-                     " is not DEPTH_STENCIL format)");
-         return;
-      }
-   }
-
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   assert(ctx->Driver.FramebufferRenderbuffer);
-   ctx->Driver.FramebufferRenderbuffer(ctx, fb, attachment, rb);
-
-   /* Some subsequent GL commands may depend on the framebuffer's visual
-    * after the binding is updated.  Update visual info now.
-    */
-   _mesa_update_framebuffer_visual(ctx, fb);
-}
-
-
-void GLAPIENTRY
-_mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment,
-                                             GLenum pname, GLint *params)
-{
-   const struct gl_renderbuffer_attachment *att;
-   struct gl_framebuffer *buffer;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   buffer = get_framebuffer_target(ctx, target);
-   if (!buffer) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetFramebufferAttachmentParameterivEXT(target)");
-      return;
-   }
-
-   if (buffer->Name == 0) {
-      /* the default / window-system FBO */
-      att = _mesa_get_fb0_attachment(ctx, buffer, attachment);
-   }
-   else {
-      /* user-created framebuffer FBO */
-      att = _mesa_get_attachment(ctx, buffer, attachment);
-   }
-
-   if (att == NULL) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetFramebufferAttachmentParameterivEXT(attachment)");
-      return;
-   }
-
-   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-      /* the depth and stencil attachments must point to the same buffer */
-      const struct gl_renderbuffer_attachment *depthAtt, *stencilAtt;
-      depthAtt = _mesa_get_attachment(ctx, buffer, GL_DEPTH_ATTACHMENT);
-      stencilAtt = _mesa_get_attachment(ctx, buffer, GL_STENCIL_ATTACHMENT);
-      if (depthAtt->Renderbuffer != stencilAtt->Renderbuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetFramebufferAttachmentParameterivEXT(DEPTH/STENCIL"
-                     " attachments differ)");
-         return;
-      }
-   }
-
-   /* No need to flush here */
-
-   switch (pname) {
-   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:
-      *params = buffer->Name == 0 ? GL_FRAMEBUFFER_DEFAULT : att->Type;
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:
-      if (att->Type == GL_RENDERBUFFER_EXT) {
-	 *params = att->Renderbuffer->Name;
-      }
-      else if (att->Type == GL_TEXTURE) {
-	 *params = att->Texture->Name;
-      }
-      else {
-         assert(att->Type == GL_NONE);
-         *params = 0;
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT:
-      if (att->Type == GL_TEXTURE) {
-	 *params = att->TextureLevel;
-      }
-      else {
-	 _mesa_error(ctx, GL_INVALID_ENUM,
-		     "glGetFramebufferAttachmentParameterivEXT(pname)");
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT:
-      if (att->Type == GL_TEXTURE) {
-         if (att->Texture && att->Texture->Target == GL_TEXTURE_CUBE_MAP) {
-            *params = GL_TEXTURE_CUBE_MAP_POSITIVE_X + att->CubeMapFace;
-         }
-         else {
-            *params = 0;
-         }
-      }
-      else {
-	 _mesa_error(ctx, GL_INVALID_ENUM,
-		     "glGetFramebufferAttachmentParameterivEXT(pname)");
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT:
-      if (att->Type == GL_TEXTURE) {
-         if (att->Texture && att->Texture->Target == GL_TEXTURE_3D) {
-            *params = att->Zoffset;
-         }
-         else {
-            *params = 0;
-         }
-      }
-      else {
-	 _mesa_error(ctx, GL_INVALID_ENUM,
-		     "glGetFramebufferAttachmentParameterivEXT(pname)");
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
-      if (!ctx->Extensions.ARB_framebuffer_object) {
-         _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glGetFramebufferAttachmentParameterivEXT(pname)");
-      }
-      else {
-         if (ctx->Extensions.EXT_framebuffer_sRGB && ctx->Const.sRGBCapable) {
-            *params = _mesa_get_format_color_encoding(att->Renderbuffer->Format);
-         }
-         else {
-            /* According to ARB_framebuffer_sRGB, we should return LINEAR
-             * if the sRGB conversion is unsupported. */
-            *params = GL_LINEAR;
-         }
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
-      if (!ctx->Extensions.ARB_framebuffer_object) {
-         _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glGetFramebufferAttachmentParameterivEXT(pname)");
-         return;
-      }
-      else {
-         gl_format format = att->Renderbuffer->Format;
-         if (format == MESA_FORMAT_CI8 || format == MESA_FORMAT_S8) {
-            /* special cases */
-            *params = GL_INDEX;
-         }
-         else {
-            *params = _mesa_get_format_datatype(format);
-         }
-      }
-      return;
-   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
-   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
-   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
-   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
-   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
-   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
-      if (!ctx->Extensions.ARB_framebuffer_object) {
-         _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glGetFramebufferAttachmentParameterivEXT(pname)");
-      }
-      else if (att->Texture) {
-         const struct gl_texture_image *texImage =
-            _mesa_select_tex_image(ctx, att->Texture, att->Texture->Target,
-                                   att->TextureLevel);
-         if (texImage) {
-            *params = get_component_bits(pname, texImage->_BaseFormat,
-                                         texImage->TexFormat);
-         }
-         else {
-            *params = 0;
-         }
-      }
-      else if (att->Renderbuffer) {
-         *params = get_component_bits(pname, att->Renderbuffer->_BaseFormat,
-                                      att->Renderbuffer->Format);
-      }
-      else {
-         *params = 0;
-      }
-      return;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetFramebufferAttachmentParameterivEXT(pname)");
-      return;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GenerateMipmapEXT(GLenum target)
-{
-   struct gl_texture_object *texObj;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_3D:
-   case GL_TEXTURE_CUBE_MAP:
-      /* OK, legal value */
-      break;
-   default:
-      /* XXX need to implement GL_TEXTURE_1D_ARRAY and GL_TEXTURE_2D_ARRAY */
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGenerateMipmapEXT(target)");
-      return;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   if (texObj->BaseLevel >= texObj->MaxLevel) {
-      /* nothing to do */
-      return;
-   }
-
-   if (texObj->Target == GL_TEXTURE_CUBE_MAP &&
-       !_mesa_cube_complete(texObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGenerateMipmap(incomplete cube map)");
-      return;
-   }
-
-   _mesa_lock_texture(ctx, texObj);
-   if (target == GL_TEXTURE_CUBE_MAP) {
-      GLuint face;
-      for (face = 0; face < 6; face++)
-	 ctx->Driver.GenerateMipmap(ctx,
-				    GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + face,
-				    texObj);
-   }
-   else {
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-#if FEATURE_EXT_framebuffer_blit
-
-static const struct gl_renderbuffer_attachment *
-find_attachment(const struct gl_framebuffer *fb,
-                const struct gl_renderbuffer *rb)
-{
-   GLuint i;
-   for (i = 0; i < Elements(fb->Attachment); i++) {
-      if (fb->Attachment[i].Renderbuffer == rb)
-         return &fb->Attachment[i];
-   }
-   return NULL;
-}
-
-
-
-/**
- * Blit rectangular region, optionally from one framebuffer to another.
- *
- * Note, if the src buffer is multisampled and the dest is not, this is
- * when the samples must be resolved to a single color.
- */
-void GLAPIENTRY
-_mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                         GLbitfield mask, GLenum filter)
-{
-   const GLbitfield legalMaskBits = (GL_COLOR_BUFFER_BIT |
-                                     GL_DEPTH_BUFFER_BIT |
-                                     GL_STENCIL_BUFFER_BIT);
-   const struct gl_framebuffer *readFb, *drawFb;
-   const struct gl_renderbuffer *colorReadRb, *colorDrawRb;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx,
-                  "glBlitFramebuffer(%d, %d, %d, %d,  %d, %d, %d, %d, 0x%x, %s)\n",
-                  srcX0, srcY0, srcX1, srcY1,
-                  dstX0, dstY0, dstX1, dstY1,
-                  mask, _mesa_lookup_enum_by_nr(filter));
-
-   if (ctx->NewState) {
-      _mesa_update_state(ctx);
-   }
-
-   readFb = ctx->ReadBuffer;
-   drawFb = ctx->DrawBuffer;
-
-   if (!readFb || !drawFb) {
-      /* This will normally never happen but someday we may want to
-       * support MakeCurrent() with no drawables.
-       */
-      return;
-   }
-
-   /* check for complete framebuffers */
-   if (drawFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||
-       readFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "glBlitFramebufferEXT(incomplete draw/read buffers)");
-      return;
-   }
-
-   if (filter != GL_NEAREST && filter != GL_LINEAR) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBlitFramebufferEXT(filter)");
-      return;
-   }
-
-   if (mask & ~legalMaskBits) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glBlitFramebufferEXT(mask)");
-      return;
-   }
-
-   /* depth/stencil must be blitted with nearest filtering */
-   if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
-        && filter != GL_NEAREST) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-             "glBlitFramebufferEXT(depth/stencil requires GL_NEAREST filter");
-      return;
-   }
-
-   /* get color read/draw renderbuffers */
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      colorReadRb = readFb->_ColorReadBuffer;
-      colorDrawRb = drawFb->_ColorDrawBuffers[0];
-   }
-   else {
-      colorReadRb = colorDrawRb = NULL;
-   }
-
-   if (mask & GL_STENCIL_BUFFER_BIT) {
-      struct gl_renderbuffer *readRb = readFb->_StencilBuffer;
-      struct gl_renderbuffer *drawRb = drawFb->_StencilBuffer;
-      if (!readRb ||
-          !drawRb ||
-          _mesa_get_format_bits(readRb->Format, GL_STENCIL_BITS) != 
-          _mesa_get_format_bits(drawRb->Format, GL_STENCIL_BITS)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glBlitFramebufferEXT(stencil buffer size mismatch");
-         return;
-      }
-   }
-
-   if (mask & GL_DEPTH_BUFFER_BIT) {
-      struct gl_renderbuffer *readRb = readFb->_DepthBuffer;
-      struct gl_renderbuffer *drawRb = drawFb->_DepthBuffer;
-      if (!readRb ||
-          !drawRb ||
-          _mesa_get_format_bits(readRb->Format, GL_DEPTH_BITS) != 
-          _mesa_get_format_bits(drawRb->Format, GL_DEPTH_BITS)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glBlitFramebufferEXT(depth buffer size mismatch");
-         return;
-      }
-   }
-
-   if (readFb->Visual.samples > 0 &&
-       drawFb->Visual.samples > 0 &&
-       readFb->Visual.samples != drawFb->Visual.samples) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glBlitFramebufferEXT(mismatched samples");
-      return;
-   }
-
-   /* extra checks for multisample copies... */
-   if (readFb->Visual.samples > 0 || drawFb->Visual.samples > 0) {
-      /* src and dest region sizes must be the same */
-      if (srcX1 - srcX0 != dstX1 - dstX0 ||
-          srcY1 - srcY0 != dstY1 - dstY0) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                "glBlitFramebufferEXT(bad src/dst multisample region sizes");
-         return;
-      }
-
-      /* color formats must match */
-      if (colorReadRb &&
-          colorDrawRb &&
-          colorReadRb->Format != colorDrawRb->Format) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                "glBlitFramebufferEXT(bad src/dst multisample pixel formats");
-         return;
-      }
-   }
-
-   if (!ctx->Extensions.EXT_framebuffer_blit) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlitFramebufferEXT");
-      return;
-   }
-
-   /* Debug code */
-   if (DEBUG_BLIT) {
-      printf("glBlitFramebuffer(%d, %d, %d, %d,  %d, %d, %d, %d,"
-	     " 0x%x, 0x%x)\n",
-	     srcX0, srcY0, srcX1, srcY1,
-	     dstX0, dstY0, dstX1, dstY1,
-	     mask, filter);
-      if (colorReadRb) {
-         const struct gl_renderbuffer_attachment *att;
-
-         att = find_attachment(readFb, colorReadRb);
-         printf("  Src FBO %u  RB %u (%dx%d)  ",
-		readFb->Name, colorReadRb->Name,
-		colorReadRb->Width, colorReadRb->Height);
-         if (att && att->Texture) {
-            printf("Tex %u  tgt 0x%x  level %u  face %u",
-		   att->Texture->Name,
-		   att->Texture->Target,
-		   att->TextureLevel,
-		   att->CubeMapFace);
-         }
-         printf("\n");
-
-         att = find_attachment(drawFb, colorDrawRb);
-         printf("  Dst FBO %u  RB %u (%dx%d)  ",
-		drawFb->Name, colorDrawRb->Name,
-		colorDrawRb->Width, colorDrawRb->Height);
-         if (att && att->Texture) {
-            printf("Tex %u  tgt 0x%x  level %u  face %u",
-		   att->Texture->Name,
-		   att->Texture->Target,
-		   att->TextureLevel,
-		   att->CubeMapFace);
-         }
-         printf("\n");
-      }
-   }
-
-   ASSERT(ctx->Driver.BlitFramebuffer);
-   ctx->Driver.BlitFramebuffer(ctx,
-                               srcX0, srcY0, srcX1, srcY1,
-                               dstX0, dstY0, dstX1, dstY1,
-                               mask, filter);
-}
-#endif /* FEATURE_EXT_framebuffer_blit */
-
-#if FEATURE_ARB_geometry_shader4
-void GLAPIENTRY
-_mesa_FramebufferTextureARB(GLenum target, GLenum attachment,
-                            GLuint texture, GLint level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_error(ctx, GL_INVALID_OPERATION,
-               "glFramebufferTextureARB "
-               "not implemented!");
-}
-
-void GLAPIENTRY
-_mesa_FramebufferTextureFaceARB(GLenum target, GLenum attachment,
-                                GLuint texture, GLint level, GLenum face)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_error(ctx, GL_INVALID_OPERATION,
-               "glFramebufferTextureFaceARB "
-               "not implemented!");
-}
-#endif /* FEATURE_ARB_geometry_shader4 */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 1999-2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/*

+ * GL_EXT/ARB_framebuffer_object extensions

+ *

+ * Authors:

+ *   Brian Paul

+ */

+

+

+#include "buffers.h"

+#include "context.h"

+#include "enums.h"

+#include "fbobject.h"

+#include "formats.h"

+#include "framebuffer.h"

+#include "hash.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "renderbuffer.h"

+#include "state.h"

+#include "teximage.h"

+#include "texobj.h"

+

+

+/** Set this to 1 to help debug FBO incompleteness problems */

+#define DEBUG_FBO 0

+

+/** Set this to 1 to debug/log glBlitFramebuffer() calls */

+#define DEBUG_BLIT 0

+

+

+/**

+ * Notes:

+ *

+ * None of the GL_EXT_framebuffer_object functions are compiled into

+ * display lists.

+ */

+

+

+

+/*

+ * When glGenRender/FramebuffersEXT() is called we insert pointers to

+ * these placeholder objects into the hash table.

+ * Later, when the object ID is first bound, we replace the placeholder

+ * with the real frame/renderbuffer.

+ */

+static struct gl_framebuffer DummyFramebuffer;

+static struct gl_renderbuffer DummyRenderbuffer;

+

+/* We bind this framebuffer when applications pass a NULL

+ * drawable/surface in make current. */

+static struct gl_framebuffer IncompleteFramebuffer;

+

+

+#define IS_CUBE_FACE(TARGET) \

+   ((TARGET) >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && \

+    (TARGET) <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)

+

+

+static void

+delete_dummy_renderbuffer(struct gl_renderbuffer *rb)

+{

+   /* no op */

+}

+

+static void

+delete_dummy_framebuffer(struct gl_framebuffer *fb)

+{

+   /* no op */

+}

+

+

+void

+_mesa_init_fbobjects(struct gl_context *ctx)

+{

+   _glthread_INIT_MUTEX(DummyFramebuffer.Mutex);

+   _glthread_INIT_MUTEX(DummyRenderbuffer.Mutex);

+   _glthread_INIT_MUTEX(IncompleteFramebuffer.Mutex);

+   DummyFramebuffer.Delete = delete_dummy_framebuffer;

+   DummyRenderbuffer.Delete = delete_dummy_renderbuffer;

+   IncompleteFramebuffer.Delete = delete_dummy_framebuffer;

+}

+

+struct gl_framebuffer *

+_mesa_get_incomplete_framebuffer(void)

+{

+   return &IncompleteFramebuffer;

+}

+

+/**

+ * Helper routine for getting a gl_renderbuffer.

+ */

+struct gl_renderbuffer *

+_mesa_lookup_renderbuffer(struct gl_context *ctx, GLuint id)

+{

+   struct gl_renderbuffer *rb;

+

+   if (id == 0)

+      return NULL;

+

+   rb = (struct gl_renderbuffer *)

+      _mesa_HashLookup(ctx->Shared->RenderBuffers, id);

+   return rb;

+}

+

+

+/**

+ * Helper routine for getting a gl_framebuffer.

+ */

+struct gl_framebuffer *

+_mesa_lookup_framebuffer(struct gl_context *ctx, GLuint id)

+{

+   struct gl_framebuffer *fb;

+

+   if (id == 0)

+      return NULL;

+

+   fb = (struct gl_framebuffer *)

+      _mesa_HashLookup(ctx->Shared->FrameBuffers, id);

+   return fb;

+}

+

+

+/**

+ * Mark the given framebuffer as invalid.  This will force the

+ * test for framebuffer completeness to be done before the framebuffer

+ * is used.

+ */

+static void

+invalidate_framebuffer(struct gl_framebuffer *fb)

+{

+   fb->_Status = 0; /* "indeterminate" */

+}

+

+

+/**

+ * Return the gl_framebuffer object which corresponds to the given

+ * framebuffer target, such as GL_DRAW_FRAMEBUFFER.

+ * Check support for GL_EXT_framebuffer_blit to determine if certain

+ * targets are legal.

+ * \return gl_framebuffer pointer or NULL if target is illegal

+ */

+static struct gl_framebuffer *

+get_framebuffer_target(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_DRAW_FRAMEBUFFER:

+      return ctx->Extensions.EXT_framebuffer_blit ? ctx->DrawBuffer : NULL;

+   case GL_READ_FRAMEBUFFER:

+      return ctx->Extensions.EXT_framebuffer_blit ? ctx->ReadBuffer : NULL;

+   case GL_FRAMEBUFFER_EXT:

+      return ctx->DrawBuffer;

+   default:

+      return NULL;

+   }

+}

+

+

+/**

+ * Given a GL_*_ATTACHMENTn token, return a pointer to the corresponding

+ * gl_renderbuffer_attachment object.

+ * This function is only used for user-created FB objects, not the

+ * default / window-system FB object.

+ * If \p attachment is GL_DEPTH_STENCIL_ATTACHMENT, return a pointer to

+ * the depth buffer attachment point.

+ */

+struct gl_renderbuffer_attachment *

+_mesa_get_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,

+                     GLenum attachment)

+{

+   GLuint i;

+

+   assert(fb->Name > 0);

+

+   switch (attachment) {

+   case GL_COLOR_ATTACHMENT0_EXT:

+   case GL_COLOR_ATTACHMENT1_EXT:

+   case GL_COLOR_ATTACHMENT2_EXT:

+   case GL_COLOR_ATTACHMENT3_EXT:

+   case GL_COLOR_ATTACHMENT4_EXT:

+   case GL_COLOR_ATTACHMENT5_EXT:

+   case GL_COLOR_ATTACHMENT6_EXT:

+   case GL_COLOR_ATTACHMENT7_EXT:

+   case GL_COLOR_ATTACHMENT8_EXT:

+   case GL_COLOR_ATTACHMENT9_EXT:

+   case GL_COLOR_ATTACHMENT10_EXT:

+   case GL_COLOR_ATTACHMENT11_EXT:

+   case GL_COLOR_ATTACHMENT12_EXT:

+   case GL_COLOR_ATTACHMENT13_EXT:

+   case GL_COLOR_ATTACHMENT14_EXT:

+   case GL_COLOR_ATTACHMENT15_EXT:

+      i = attachment - GL_COLOR_ATTACHMENT0_EXT;

+      if (i >= ctx->Const.MaxColorAttachments) {

+	 return NULL;

+      }

+      return &fb->Attachment[BUFFER_COLOR0 + i];

+   case GL_DEPTH_STENCIL_ATTACHMENT:

+      /* fall-through */

+   case GL_DEPTH_BUFFER:

+      /* fall-through / new in GL 3.0 */

+   case GL_DEPTH_ATTACHMENT_EXT:

+      return &fb->Attachment[BUFFER_DEPTH];

+   case GL_STENCIL_BUFFER:

+      /* fall-through / new in GL 3.0 */

+   case GL_STENCIL_ATTACHMENT_EXT:

+      return &fb->Attachment[BUFFER_STENCIL];

+   default:

+      return NULL;

+   }

+}

+

+

+/**

+ * As above, but only used for getting attachments of the default /

+ * window-system framebuffer (not user-created framebuffer objects).

+ */

+static struct gl_renderbuffer_attachment *

+_mesa_get_fb0_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,

+                         GLenum attachment)

+{

+   assert(fb->Name == 0);

+

+   switch (attachment) {

+   case GL_FRONT_LEFT:

+      return &fb->Attachment[BUFFER_FRONT_LEFT];

+   case GL_FRONT_RIGHT:

+      return &fb->Attachment[BUFFER_FRONT_RIGHT];

+   case GL_BACK_LEFT:

+      return &fb->Attachment[BUFFER_BACK_LEFT];

+   case GL_BACK_RIGHT:

+      return &fb->Attachment[BUFFER_BACK_RIGHT];

+   case GL_AUX0:

+      if (fb->Visual.numAuxBuffers == 1) {

+         return &fb->Attachment[BUFFER_AUX0];

+      }

+      return NULL;

+   case GL_DEPTH_BUFFER:

+      /* fall-through / new in GL 3.0 */

+   case GL_DEPTH_ATTACHMENT_EXT:

+      return &fb->Attachment[BUFFER_DEPTH];

+   case GL_STENCIL_BUFFER:

+      /* fall-through / new in GL 3.0 */

+   case GL_STENCIL_ATTACHMENT_EXT:

+      return &fb->Attachment[BUFFER_STENCIL];

+   default:

+      return NULL;

+   }

+}

+

+

+

+/**

+ * Remove any texture or renderbuffer attached to the given attachment

+ * point.  Update reference counts, etc.

+ */

+void

+_mesa_remove_attachment(struct gl_context *ctx,

+                        struct gl_renderbuffer_attachment *att)

+{

+   if (att->Type == GL_TEXTURE) {

+      ASSERT(att->Texture);

+      if (ctx->Driver.FinishRenderTexture) {

+         /* tell driver that we're done rendering to this texture. */

+         ctx->Driver.FinishRenderTexture(ctx, att);

+      }

+      _mesa_reference_texobj(&att->Texture, NULL); /* unbind */

+      ASSERT(!att->Texture);

+   }

+   if (att->Type == GL_TEXTURE || att->Type == GL_RENDERBUFFER_EXT) {

+      ASSERT(!att->Texture);

+      _mesa_reference_renderbuffer(&att->Renderbuffer, NULL); /* unbind */

+      ASSERT(!att->Renderbuffer);

+   }

+   att->Type = GL_NONE;

+   att->Complete = GL_TRUE;

+}

+

+

+/**

+ * Bind a texture object to an attachment point.

+ * The previous binding, if any, will be removed first.

+ */

+void

+_mesa_set_texture_attachment(struct gl_context *ctx,

+                             struct gl_framebuffer *fb,

+                             struct gl_renderbuffer_attachment *att,

+                             struct gl_texture_object *texObj,

+                             GLenum texTarget, GLuint level, GLuint zoffset)

+{

+   if (att->Texture == texObj) {

+      /* re-attaching same texture */

+      ASSERT(att->Type == GL_TEXTURE);

+      if (ctx->Driver.FinishRenderTexture)

+	 ctx->Driver.FinishRenderTexture(ctx, att);

+   }

+   else {

+      /* new attachment */

+      if (ctx->Driver.FinishRenderTexture && att->Texture)

+	 ctx->Driver.FinishRenderTexture(ctx, att);

+      _mesa_remove_attachment(ctx, att);

+      att->Type = GL_TEXTURE;

+      assert(!att->Texture);

+      _mesa_reference_texobj(&att->Texture, texObj);

+   }

+

+   /* always update these fields */

+   att->TextureLevel = level;

+   att->CubeMapFace = _mesa_tex_target_to_face(texTarget);

+   att->Zoffset = zoffset;

+   att->Complete = GL_FALSE;

+

+   if (att->Texture->Image[att->CubeMapFace][att->TextureLevel]) {

+      ctx->Driver.RenderTexture(ctx, fb, att);

+   }

+

+   invalidate_framebuffer(fb);

+}

+

+

+/**

+ * Bind a renderbuffer to an attachment point.

+ * The previous binding, if any, will be removed first.

+ */

+void

+_mesa_set_renderbuffer_attachment(struct gl_context *ctx,

+                                  struct gl_renderbuffer_attachment *att,

+                                  struct gl_renderbuffer *rb)

+{

+   /* XXX check if re-doing same attachment, exit early */

+   _mesa_remove_attachment(ctx, att);

+   att->Type = GL_RENDERBUFFER_EXT;

+   att->Texture = NULL; /* just to be safe */

+   att->Complete = GL_FALSE;

+   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);

+}

+

+

+/**

+ * Fallback for ctx->Driver.FramebufferRenderbuffer()

+ * Attach a renderbuffer object to a framebuffer object.

+ */

+void

+_mesa_framebuffer_renderbuffer(struct gl_context *ctx,

+                               struct gl_framebuffer *fb,

+                               GLenum attachment, struct gl_renderbuffer *rb)

+{

+   struct gl_renderbuffer_attachment *att;

+

+   _glthread_LOCK_MUTEX(fb->Mutex);

+

+   att = _mesa_get_attachment(ctx, fb, attachment);

+   ASSERT(att);

+   if (rb) {

+      _mesa_set_renderbuffer_attachment(ctx, att, rb);

+      if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {

+         /* do stencil attachment here (depth already done above) */

+         att = _mesa_get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT);

+         assert(att);

+         _mesa_set_renderbuffer_attachment(ctx, att, rb);

+      }

+      rb->AttachedAnytime = GL_TRUE;

+   }

+   else {

+      _mesa_remove_attachment(ctx, att);

+   }

+

+   invalidate_framebuffer(fb);

+

+   _glthread_UNLOCK_MUTEX(fb->Mutex);

+}

+

+

+/**

+ * Fallback for ctx->Driver.ValidateFramebuffer()

+ * Check if the renderbuffer's formats are supported by the software

+ * renderer.

+ * Drivers should probably override this.

+ */

+void

+_mesa_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   gl_buffer_index buf;

+   for (buf = 0; buf < BUFFER_COUNT; buf++) {

+      const struct gl_renderbuffer *rb = fb->Attachment[buf].Renderbuffer;

+      if (rb) {

+         switch (rb->_BaseFormat) {

+         case GL_ALPHA:

+         case GL_LUMINANCE_ALPHA:

+         case GL_LUMINANCE:

+         case GL_INTENSITY:

+         case GL_RED:

+         case GL_RG:

+            fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED;

+            return;

+         default:

+            /* render buffer format is supported by software rendering */

+            ;

+         }

+      }

+   }

+}

+

+

+/**

+ * For debug only.

+ */

+static void

+att_incomplete(const char *msg)

+{

+#if DEBUG_FBO

+   _mesa_debug(NULL, "attachment incomplete: %s\n", msg);

+#else

+   (void) msg;

+#endif

+}

+

+

+/**

+ * For debug only.

+ */

+static void

+fbo_incomplete(const char *msg, int index)

+{

+#if DEBUG_FBO

+   _mesa_debug(NULL, "FBO Incomplete: %s [%d]\n", msg, index);

+#else

+   (void) msg;

+   (void) index;

+#endif

+}

+

+

+/**

+ * Is the given base format a legal format for a color renderbuffer?

+ */

+GLboolean

+_mesa_is_legal_color_format(const struct gl_context *ctx, GLenum baseFormat)

+{

+   switch (baseFormat) {

+   case GL_RGB:

+   case GL_RGBA:

+      return GL_TRUE;

+   case GL_LUMINANCE:

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+   case GL_ALPHA:

+      return ctx->Extensions.ARB_framebuffer_object;

+   case GL_RED:

+   case GL_RG:

+      return ctx->Extensions.ARB_texture_rg;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Is the given base format a legal format for a depth/stencil renderbuffer?

+ */

+static GLboolean

+is_legal_depth_format(const struct gl_context *ctx, GLenum baseFormat)

+{

+   switch (baseFormat) {

+   case GL_DEPTH_COMPONENT:

+   case GL_DEPTH_STENCIL_EXT:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if an attachment point is complete and update its Complete field.

+ * \param format if GL_COLOR, this is a color attachment point,

+ *               if GL_DEPTH, this is a depth component attachment point,

+ *               if GL_STENCIL, this is a stencil component attachment point.

+ */

+static void

+test_attachment_completeness(const struct gl_context *ctx, GLenum format,

+                             struct gl_renderbuffer_attachment *att)

+{

+   assert(format == GL_COLOR || format == GL_DEPTH || format == GL_STENCIL);

+

+   /* assume complete */

+   att->Complete = GL_TRUE;

+

+   /* Look for reasons why the attachment might be incomplete */

+   if (att->Type == GL_TEXTURE) {

+      const struct gl_texture_object *texObj = att->Texture;

+      struct gl_texture_image *texImage;

+      GLenum baseFormat;

+

+      if (!texObj) {

+         att_incomplete("no texobj");

+         att->Complete = GL_FALSE;

+         return;

+      }

+

+      texImage = texObj->Image[att->CubeMapFace][att->TextureLevel];

+      if (!texImage) {

+         att_incomplete("no teximage");

+         att->Complete = GL_FALSE;

+         return;

+      }

+      if (texImage->Width < 1 || texImage->Height < 1) {

+         att_incomplete("teximage width/height=0");

+         printf("texobj = %u\n", texObj->Name);

+         printf("level = %d\n", att->TextureLevel);

+         att->Complete = GL_FALSE;

+         return;

+      }

+      if (texObj->Target == GL_TEXTURE_3D && att->Zoffset >= texImage->Depth) {

+         att_incomplete("bad z offset");

+         att->Complete = GL_FALSE;

+         return;

+      }

+

+      baseFormat = _mesa_get_format_base_format(texImage->TexFormat);

+

+      if (format == GL_COLOR) {

+         if (!_mesa_is_legal_color_format(ctx, baseFormat)) {

+            att_incomplete("bad format");

+            att->Complete = GL_FALSE;

+            return;

+         }

+         if (_mesa_is_format_compressed(texImage->TexFormat)) {

+            att_incomplete("compressed internalformat");

+            att->Complete = GL_FALSE;

+            return;

+         }

+      }

+      else if (format == GL_DEPTH) {

+         if (baseFormat == GL_DEPTH_COMPONENT) {

+            /* OK */

+         }

+         else if (ctx->Extensions.EXT_packed_depth_stencil &&

+                  ctx->Extensions.ARB_depth_texture &&

+                  baseFormat == GL_DEPTH_STENCIL_EXT) {

+            /* OK */

+         }

+         else {

+            att->Complete = GL_FALSE;

+            att_incomplete("bad depth format");

+            return;

+         }

+      }

+      else {

+         ASSERT(format == GL_STENCIL);

+         if (ctx->Extensions.EXT_packed_depth_stencil &&

+             ctx->Extensions.ARB_depth_texture &&

+             baseFormat == GL_DEPTH_STENCIL_EXT) {

+            /* OK */

+         }

+         else {

+            /* no such thing as stencil-only textures */

+            att_incomplete("illegal stencil texture");

+            att->Complete = GL_FALSE;

+            return;

+         }

+      }

+   }

+   else if (att->Type == GL_RENDERBUFFER_EXT) {

+      const GLenum baseFormat =

+         _mesa_get_format_base_format(att->Renderbuffer->Format);

+

+      ASSERT(att->Renderbuffer);

+      if (!att->Renderbuffer->InternalFormat ||

+          att->Renderbuffer->Width < 1 ||

+          att->Renderbuffer->Height < 1) {

+         att_incomplete("0x0 renderbuffer");

+         att->Complete = GL_FALSE;

+         return;

+      }

+      if (format == GL_COLOR) {

+         if (!_mesa_is_legal_color_format(ctx, baseFormat)) {

+            att_incomplete("bad renderbuffer color format");

+            att->Complete = GL_FALSE;

+            return;

+         }

+      }

+      else if (format == GL_DEPTH) {

+         if (baseFormat == GL_DEPTH_COMPONENT) {

+            /* OK */

+         }

+         else if (ctx->Extensions.EXT_packed_depth_stencil &&

+                  baseFormat == GL_DEPTH_STENCIL_EXT) {

+            /* OK */

+         }

+         else {

+            att_incomplete("bad renderbuffer depth format");

+            att->Complete = GL_FALSE;

+            return;

+         }

+      }

+      else {

+         assert(format == GL_STENCIL);

+         if (baseFormat == GL_STENCIL_INDEX) {

+            /* OK */

+         }

+         else if (ctx->Extensions.EXT_packed_depth_stencil &&

+                  baseFormat == GL_DEPTH_STENCIL_EXT) {

+            /* OK */

+         }

+         else {

+            att->Complete = GL_FALSE;

+            att_incomplete("bad renderbuffer stencil format");

+            return;

+         }

+      }

+   }

+   else {

+      ASSERT(att->Type == GL_NONE);

+      /* complete */

+      return;

+   }

+}

+

+

+/**

+ * Test if the given framebuffer object is complete and update its

+ * Status field with the results.

+ * Calls the ctx->Driver.ValidateFramebuffer() function to allow the

+ * driver to make hardware-specific validation/completeness checks.

+ * Also update the framebuffer's Width and Height fields if the

+ * framebuffer is complete.

+ */

+void

+_mesa_test_framebuffer_completeness(struct gl_context *ctx,

+                                    struct gl_framebuffer *fb)

+{

+   GLuint numImages;

+   GLenum intFormat = GL_NONE; /* color buffers' internal format */

+   GLuint minWidth = ~0, minHeight = ~0, maxWidth = 0, maxHeight = 0;

+   GLint numSamples = -1;

+   GLint i;

+   GLuint j;

+

+   assert(fb->Name != 0);

+

+   numImages = 0;

+   fb->Width = 0;

+   fb->Height = 0;

+

+   /* Start at -2 to more easily loop over all attachment points.

+    *  -2: depth buffer

+    *  -1: stencil buffer

+    * >=0: color buffer

+    */

+   for (i = -2; i < (GLint) ctx->Const.MaxColorAttachments; i++) {

+      struct gl_renderbuffer_attachment *att;

+      GLenum f;

+      gl_format attFormat;

+

+      /*

+       * XXX for ARB_fbo, only check color buffers that are named by

+       * GL_READ_BUFFER and GL_DRAW_BUFFERi.

+       */

+

+      /* check for attachment completeness

+       */

+      if (i == -2) {

+         att = &fb->Attachment[BUFFER_DEPTH];

+         test_attachment_completeness(ctx, GL_DEPTH, att);

+         if (!att->Complete) {

+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;

+            fbo_incomplete("depth attachment incomplete", -1);

+            return;

+         }

+      }

+      else if (i == -1) {

+         att = &fb->Attachment[BUFFER_STENCIL];

+         test_attachment_completeness(ctx, GL_STENCIL, att);

+         if (!att->Complete) {

+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;

+            fbo_incomplete("stencil attachment incomplete", -1);

+            return;

+         }

+      }

+      else {

+         att = &fb->Attachment[BUFFER_COLOR0 + i];

+         test_attachment_completeness(ctx, GL_COLOR, att);

+         if (!att->Complete) {

+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;

+            fbo_incomplete("color attachment incomplete", i);

+            return;

+         }

+      }

+

+      /* get width, height, format of the renderbuffer/texture

+       */

+      if (att->Type == GL_TEXTURE) {

+         const struct gl_texture_image *texImg

+            = att->Texture->Image[att->CubeMapFace][att->TextureLevel];

+         minWidth = MIN2(minWidth, texImg->Width);

+         maxWidth = MAX2(maxWidth, texImg->Width);

+         minHeight = MIN2(minHeight, texImg->Height);

+         maxHeight = MAX2(maxHeight, texImg->Height);

+         f = texImg->_BaseFormat;

+         attFormat = texImg->TexFormat;

+         numImages++;

+         if (!_mesa_is_legal_color_format(ctx, f) &&

+             !is_legal_depth_format(ctx, f)) {

+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;

+            fbo_incomplete("texture attachment incomplete", -1);

+            return;

+         }

+      }

+      else if (att->Type == GL_RENDERBUFFER_EXT) {

+         minWidth = MIN2(minWidth, att->Renderbuffer->Width);

+         maxWidth = MAX2(minWidth, att->Renderbuffer->Width);

+         minHeight = MIN2(minHeight, att->Renderbuffer->Height);

+         maxHeight = MAX2(minHeight, att->Renderbuffer->Height);

+         f = att->Renderbuffer->InternalFormat;

+         attFormat = att->Renderbuffer->Format;

+         numImages++;

+      }

+      else {

+         assert(att->Type == GL_NONE);

+         continue;

+      }

+

+      if (numSamples < 0) {

+         /* first buffer */

+         numSamples = att->Renderbuffer->NumSamples;

+      }

+

+      /* check if integer color */

+      fb->_IntegerColor = _mesa_is_format_integer_color(attFormat);

+

+      /* Error-check width, height, format, samples

+       */

+      if (numImages == 1) {

+         /* save format, num samples */

+         if (i >= 0) {

+            intFormat = f;

+         }

+      }

+      else {

+         if (!ctx->Extensions.ARB_framebuffer_object) {

+            /* check that width, height, format are same */

+            if (minWidth != maxWidth || minHeight != maxHeight) {

+               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT;

+               fbo_incomplete("width or height mismatch", -1);

+               return;

+            }

+            /* check that all color buffer have same format */

+            if (intFormat != GL_NONE && f != intFormat) {

+               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;

+               fbo_incomplete("format mismatch", -1);

+               return;

+            }

+         }

+         if (att->Renderbuffer &&

+             att->Renderbuffer->NumSamples != numSamples) {

+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;

+            fbo_incomplete("inconsistant number of samples", i);

+            return;

+         }            

+

+      }

+   }

+

+#if FEATURE_GL

+   if (ctx->API == API_OPENGL) {

+      /* Check that all DrawBuffers are present */

+      for (j = 0; j < ctx->Const.MaxDrawBuffers; j++) {

+	 if (fb->ColorDrawBuffer[j] != GL_NONE) {

+	    const struct gl_renderbuffer_attachment *att

+	       = _mesa_get_attachment(ctx, fb, fb->ColorDrawBuffer[j]);

+	    assert(att);

+	    if (att->Type == GL_NONE) {

+	       fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT;

+	       fbo_incomplete("missing drawbuffer", j);

+	       return;

+	    }

+	 }

+      }

+

+      /* Check that the ReadBuffer is present */

+      if (fb->ColorReadBuffer != GL_NONE) {

+	 const struct gl_renderbuffer_attachment *att

+	    = _mesa_get_attachment(ctx, fb, fb->ColorReadBuffer);

+	 assert(att);

+	 if (att->Type == GL_NONE) {

+	    fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT;

+            fbo_incomplete("missing readbuffer", -1);

+	    return;

+	 }

+      }

+   }

+#else

+   (void) j;

+#endif

+

+   if (numImages == 0) {

+      fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT;

+      fbo_incomplete("no attachments", -1);

+      return;

+   }

+

+   /* Provisionally set status = COMPLETE ... */

+   fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;

+

+   /* ... but the driver may say the FB is incomplete.

+    * Drivers will most likely set the status to GL_FRAMEBUFFER_UNSUPPORTED

+    * if anything.

+    */

+   if (ctx->Driver.ValidateFramebuffer) {

+      ctx->Driver.ValidateFramebuffer(ctx, fb);

+      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         fbo_incomplete("driver marked FBO as incomplete", -1);

+      }

+   }

+

+   if (fb->_Status == GL_FRAMEBUFFER_COMPLETE_EXT) {

+      /*

+       * Note that if ARB_framebuffer_object is supported and the attached

+       * renderbuffers/textures are different sizes, the framebuffer

+       * width/height will be set to the smallest width/height.

+       */

+      fb->Width = minWidth;

+      fb->Height = minHeight;

+

+      /* finally, update the visual info for the framebuffer */

+      _mesa_update_framebuffer_visual(ctx, fb);

+   }

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsRenderbufferEXT(GLuint renderbuffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+   if (renderbuffer) {

+      struct gl_renderbuffer *rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);

+      if (rb != NULL && rb != &DummyRenderbuffer)

+         return GL_TRUE;

+   }

+   return GL_FALSE;

+}

+

+

+void GLAPIENTRY

+_mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)

+{

+   struct gl_renderbuffer *newRb;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (target != GL_RENDERBUFFER_EXT) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBindRenderbufferEXT(target)");

+      return;

+   }

+

+   /* No need to flush here since the render buffer binding has no

+    * effect on rendering state.

+    */

+

+   if (renderbuffer) {

+      newRb = _mesa_lookup_renderbuffer(ctx, renderbuffer);

+      if (newRb == &DummyRenderbuffer) {

+         /* ID was reserved, but no real renderbuffer object made yet */

+         newRb = NULL;

+      }

+      else if (!newRb && ctx->Extensions.ARB_framebuffer_object) {

+         /* All RB IDs must be Gen'd */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindRenderbuffer(buffer)");

+         return;

+      }

+

+      if (!newRb) {

+	 /* create new renderbuffer object */

+	 newRb = ctx->Driver.NewRenderbuffer(ctx, renderbuffer);

+	 if (!newRb) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindRenderbufferEXT");

+	    return;

+	 }

+         ASSERT(newRb->AllocStorage);

+         _mesa_HashInsert(ctx->Shared->RenderBuffers, renderbuffer, newRb);

+         newRb->RefCount = 1; /* referenced by hash table */

+      }

+   }

+   else {

+      newRb = NULL;

+   }

+

+   ASSERT(newRb != &DummyRenderbuffer);

+

+   _mesa_reference_renderbuffer(&ctx->CurrentRenderbuffer, newRb);

+}

+

+

+/**

+ * If the given renderbuffer is anywhere attached to the framebuffer, detach

+ * the renderbuffer.

+ * This is used when a renderbuffer object is deleted.

+ * The spec calls for unbinding.

+ */

+static void

+detach_renderbuffer(struct gl_context *ctx,

+                    struct gl_framebuffer *fb,

+                    struct gl_renderbuffer *rb)

+{

+   GLuint i;

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      if (fb->Attachment[i].Renderbuffer == rb) {

+         _mesa_remove_attachment(ctx, &fb->Attachment[i]);

+      }

+   }

+   invalidate_framebuffer(fb);

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)

+{

+   GLint i;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   for (i = 0; i < n; i++) {

+      if (renderbuffers[i] > 0) {

+	 struct gl_renderbuffer *rb;

+	 rb = _mesa_lookup_renderbuffer(ctx, renderbuffers[i]);

+	 if (rb) {

+            /* check if deleting currently bound renderbuffer object */

+            if (rb == ctx->CurrentRenderbuffer) {

+               /* bind default */

+               ASSERT(rb->RefCount >= 2);

+               _mesa_BindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);

+            }

+

+            if (ctx->DrawBuffer->Name) {

+               detach_renderbuffer(ctx, ctx->DrawBuffer, rb);

+            }

+            if (ctx->ReadBuffer->Name && ctx->ReadBuffer != ctx->DrawBuffer) {

+               detach_renderbuffer(ctx, ctx->ReadBuffer, rb);

+            }

+

+	    /* Remove from hash table immediately, to free the ID.

+             * But the object will not be freed until it's no longer

+             * referenced anywhere else.

+             */

+	    _mesa_HashRemove(ctx->Shared->RenderBuffers, renderbuffers[i]);

+

+            if (rb != &DummyRenderbuffer) {

+               /* no longer referenced by hash table */

+               _mesa_reference_renderbuffer(&rb, NULL);

+	    }

+	 }

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint first;

+   GLint i;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenRenderbuffersEXT(n)");

+      return;

+   }

+

+   if (!renderbuffers)

+      return;

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->RenderBuffers, n);

+

+   for (i = 0; i < n; i++) {

+      GLuint name = first + i;

+      renderbuffers[i] = name;

+      /* insert dummy placeholder into hash table */

+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+      _mesa_HashInsert(ctx->Shared->RenderBuffers, name, &DummyRenderbuffer);

+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+   }

+}

+

+

+/**

+ * Given an internal format token for a render buffer, return the

+ * corresponding base format (one of GL_RGB, GL_RGBA, GL_STENCIL_INDEX,

+ * GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL_EXT, GL_ALPHA, GL_LUMINANCE,

+ * GL_LUMINANCE_ALPHA, GL_INTENSITY, etc).

+ *

+ * This is similar to _mesa_base_tex_format() but the set of valid

+ * internal formats is different.

+ *

+ * Note that even if a format is determined to be legal here, validation

+ * of the FBO may fail if the format is not supported by the driver/GPU.

+ *

+ * \param internalFormat  as passed to glRenderbufferStorage()

+ * \return the base internal format, or 0 if internalFormat is illegal

+ */

+GLenum

+_mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)

+{

+   /*

+    * Notes: some formats such as alpha, luminance, etc. were added

+    * with GL_ARB_framebuffer_object.

+    */

+   switch (internalFormat) {

+   case GL_ALPHA:

+   case GL_ALPHA4:

+   case GL_ALPHA8:

+   case GL_ALPHA12:

+   case GL_ALPHA16:

+      return ctx->Extensions.ARB_framebuffer_object ? GL_ALPHA : 0;

+   case GL_LUMINANCE:

+   case GL_LUMINANCE4:

+   case GL_LUMINANCE8:

+   case GL_LUMINANCE12:

+   case GL_LUMINANCE16:

+      return ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE : 0;

+   case GL_LUMINANCE_ALPHA:

+   case GL_LUMINANCE4_ALPHA4:

+   case GL_LUMINANCE6_ALPHA2:

+   case GL_LUMINANCE8_ALPHA8:

+   case GL_LUMINANCE12_ALPHA4:

+   case GL_LUMINANCE12_ALPHA12:

+   case GL_LUMINANCE16_ALPHA16:

+      return ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE_ALPHA : 0;

+   case GL_INTENSITY:

+   case GL_INTENSITY4:

+   case GL_INTENSITY8:

+   case GL_INTENSITY12:

+   case GL_INTENSITY16:

+      return ctx->Extensions.ARB_framebuffer_object ? GL_INTENSITY : 0;

+   case GL_RGB:

+   case GL_R3_G3_B2:

+   case GL_RGB4:

+   case GL_RGB5:

+   case GL_RGB8:

+   case GL_RGB10:

+   case GL_RGB12:

+   case GL_RGB16:

+   case GL_SRGB8_EXT:

+      return GL_RGB;

+   case GL_RGBA:

+   case GL_RGBA2:

+   case GL_RGBA4:

+   case GL_RGB5_A1:

+   case GL_RGBA8:

+   case GL_RGB10_A2:

+   case GL_RGBA12:

+   case GL_RGBA16:

+   case GL_RGBA16_SNORM:

+   case GL_SRGB8_ALPHA8_EXT:

+      return GL_RGBA;

+   case GL_STENCIL_INDEX:

+   case GL_STENCIL_INDEX1_EXT:

+   case GL_STENCIL_INDEX4_EXT:

+   case GL_STENCIL_INDEX8_EXT:

+   case GL_STENCIL_INDEX16_EXT:

+      return GL_STENCIL_INDEX;

+   case GL_DEPTH_COMPONENT:

+   case GL_DEPTH_COMPONENT16:

+   case GL_DEPTH_COMPONENT24:

+   case GL_DEPTH_COMPONENT32:

+      return GL_DEPTH_COMPONENT;

+   case GL_DEPTH_STENCIL_EXT:

+   case GL_DEPTH24_STENCIL8_EXT:

+      if (ctx->Extensions.EXT_packed_depth_stencil)

+         return GL_DEPTH_STENCIL_EXT;

+      else

+         return 0;

+   case GL_RED:

+   case GL_R8:

+   case GL_R16:

+      return ctx->Extensions.ARB_texture_rg ? GL_RED : 0;

+   case GL_RG:

+   case GL_RG8:

+   case GL_RG16:

+      return ctx->Extensions.ARB_texture_rg ? GL_RG : 0;

+   /* XXX add floating point and integer formats eventually */

+   default:

+      return 0;

+   }

+}

+

+

+/**

+ * Invalidate a renderbuffer attachment.  Called from _mesa_HashWalk().

+ */

+static void

+invalidate_rb(GLuint key, void *data, void *userData)

+{

+   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;

+   struct gl_renderbuffer *rb = (struct gl_renderbuffer *) userData;

+

+   /* If this is a user-created FBO */

+   if (fb->Name) {

+      GLuint i;

+      for (i = 0; i < BUFFER_COUNT; i++) {

+         struct gl_renderbuffer_attachment *att = fb->Attachment + i;

+         if (att->Type == GL_RENDERBUFFER &&

+             att->Renderbuffer == rb) {

+            /* Mark fb status as indeterminate to force re-validation */

+            fb->_Status = 0;

+            return;

+         }

+      }

+   }

+}

+

+

+/** sentinal value, see below */

+#define NO_SAMPLES 1000

+

+

+/**

+ * Helper function used by _mesa_RenderbufferStorageEXT() and 

+ * _mesa_RenderbufferStorageMultisample().

+ * samples will be NO_SAMPLES if called by _mesa_RenderbufferStorageEXT().

+ */

+static void

+renderbuffer_storage(GLenum target, GLenum internalFormat,

+                     GLsizei width, GLsizei height, GLsizei samples)

+{

+   const char *func = samples == NO_SAMPLES ?

+      "glRenderbufferStorage" : "RenderbufferStorageMultisample";

+   struct gl_renderbuffer *rb;

+   GLenum baseFormat;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (target != GL_RENDERBUFFER_EXT) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", func);

+      return;

+   }

+

+   baseFormat = _mesa_base_fbo_format(ctx, internalFormat);

+   if (baseFormat == 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(internalFormat)", func);

+      return;

+   }

+

+   if (width < 1 || width > (GLsizei) ctx->Const.MaxRenderbufferSize) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(width)", func);

+      return;

+   }

+

+   if (height < 1 || height > (GLsizei) ctx->Const.MaxRenderbufferSize) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(height)", func);

+      return;

+   }

+

+   if (samples == NO_SAMPLES) {

+      /* NumSamples == 0 indicates non-multisampling */

+      samples = 0;

+   }

+   else if (samples > (GLsizei) ctx->Const.MaxSamples) {

+      /* note: driver may choose to use more samples than what's requested */

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(samples)", func);

+      return;

+   }

+

+   rb = ctx->CurrentRenderbuffer;

+   if (!rb) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", func);

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   if (rb->InternalFormat == internalFormat &&

+       rb->Width == (GLuint) width &&

+       rb->Height == (GLuint) height) {

+      /* no change in allocation needed */

+      return;

+   }

+

+   /* These MUST get set by the AllocStorage func */

+   rb->Format = MESA_FORMAT_NONE;

+   rb->NumSamples = samples;

+

+   /* Now allocate the storage */

+   ASSERT(rb->AllocStorage);

+   if (rb->AllocStorage(ctx, rb, internalFormat, width, height)) {

+      /* No error - check/set fields now */

+      assert(rb->Format != MESA_FORMAT_NONE);

+      assert(rb->Width == (GLuint) width);

+      assert(rb->Height == (GLuint) height);

+      rb->InternalFormat = internalFormat;

+      rb->_BaseFormat = baseFormat;

+      assert(rb->_BaseFormat != 0);

+   }

+   else {

+      /* Probably ran out of memory - clear the fields */

+      rb->Width = 0;

+      rb->Height = 0;

+      rb->Format = MESA_FORMAT_NONE;

+      rb->InternalFormat = GL_NONE;

+      rb->_BaseFormat = GL_NONE;

+      rb->NumSamples = 0;

+   }

+

+   /* Invalidate the framebuffers the renderbuffer is attached in. */

+   if (rb->AttachedAnytime) {

+      _mesa_HashWalk(ctx->Shared->FrameBuffers, invalidate_rb, rb);

+   }

+}

+

+

+#if FEATURE_OES_EGL_image

+void GLAPIENTRY

+_mesa_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)

+{

+   struct gl_renderbuffer *rb;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!ctx->Extensions.OES_EGL_image) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glEGLImageTargetRenderbufferStorageOES(unsupported)");

+      return;

+   }

+

+   if (target != GL_RENDERBUFFER) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "EGLImageTargetRenderbufferStorageOES");

+      return;

+   }

+

+   rb = ctx->CurrentRenderbuffer;

+   if (!rb) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "EGLImageTargetRenderbufferStorageOES");

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   ctx->Driver.EGLImageTargetRenderbufferStorage(ctx, rb, image);

+}

+#endif

+

+

+/**

+ * Helper function for _mesa_GetRenderbufferParameterivEXT() and

+ * _mesa_GetFramebufferAttachmentParameterivEXT()

+ * We have to be careful to respect the base format.  For example, if a

+ * renderbuffer/texture was created with internalFormat=GL_RGB but the

+ * driver actually chose a GL_RGBA format, when the user queries ALPHA_SIZE

+ * we need to return zero.

+ */

+static GLint

+get_component_bits(GLenum pname, GLenum baseFormat, gl_format format)

+{

+   switch (pname) {

+   case GL_RENDERBUFFER_RED_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:

+      if (baseFormat == GL_RGB || baseFormat == GL_RGBA ||

+	  baseFormat == GL_RG || baseFormat == GL_RED)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   case GL_RENDERBUFFER_GREEN_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:

+      if (baseFormat == GL_RGB || baseFormat == GL_RGBA || baseFormat == GL_RG)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   case GL_RENDERBUFFER_BLUE_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:

+      if (baseFormat == GL_RGB || baseFormat == GL_RGBA)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:

+      if (baseFormat == GL_RGBA || baseFormat == GL_ALPHA ||

+	  baseFormat == GL_LUMINANCE_ALPHA)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:

+      if (baseFormat == GL_DEPTH_COMPONENT || baseFormat == GL_DEPTH_STENCIL)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:

+      if (baseFormat == GL_STENCIL_INDEX || baseFormat == GL_DEPTH_STENCIL)

+         return _mesa_get_format_bits(format, pname);

+      else

+         return 0;

+   default:

+      return 0;

+   }

+}

+

+

+

+void GLAPIENTRY

+_mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,

+                             GLsizei width, GLsizei height)

+{

+   /* GL_ARB_fbo says calling this function is equivalent to calling

+    * glRenderbufferStorageMultisample() with samples=0.  We pass in

+    * a token value here just for error reporting purposes.

+    */

+   renderbuffer_storage(target, internalFormat, width, height, NO_SAMPLES);

+}

+

+

+void GLAPIENTRY

+_mesa_RenderbufferStorageMultisample(GLenum target, GLsizei samples,

+                                     GLenum internalFormat,

+                                     GLsizei width, GLsizei height)

+{

+   renderbuffer_storage(target, internalFormat, width, height, samples);

+}

+

+

+/**

+ * OpenGL ES version of glRenderBufferStorage.

+ */

+void GLAPIENTRY

+_es_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,

+			   GLsizei width, GLsizei height)

+{

+   switch (internalFormat) {

+   case GL_RGB565:

+      /* XXX this confuses GL_RENDERBUFFER_INTERNAL_FORMAT_OES */

+      /* choose a closest format */

+      internalFormat = GL_RGB5;

+      break;

+   default:

+      break;

+   }

+

+   renderbuffer_storage(target, internalFormat, width, height, 0);

+}

+

+

+void GLAPIENTRY

+_mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)

+{

+   struct gl_renderbuffer *rb;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (target != GL_RENDERBUFFER_EXT) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetRenderbufferParameterivEXT(target)");

+      return;

+   }

+

+   rb = ctx->CurrentRenderbuffer;

+   if (!rb) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetRenderbufferParameterivEXT");

+      return;

+   }

+

+   /* No need to flush here since we're just quering state which is

+    * not effected by rendering.

+    */

+

+   switch (pname) {

+   case GL_RENDERBUFFER_WIDTH_EXT:

+      *params = rb->Width;

+      return;

+   case GL_RENDERBUFFER_HEIGHT_EXT:

+      *params = rb->Height;

+      return;

+   case GL_RENDERBUFFER_INTERNAL_FORMAT_EXT:

+      *params = rb->InternalFormat;

+      return;

+   case GL_RENDERBUFFER_RED_SIZE_EXT:

+   case GL_RENDERBUFFER_GREEN_SIZE_EXT:

+   case GL_RENDERBUFFER_BLUE_SIZE_EXT:

+   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:

+   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:

+   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:

+      *params = get_component_bits(pname, rb->_BaseFormat, rb->Format);

+      break;

+   case GL_RENDERBUFFER_SAMPLES:

+      if (ctx->Extensions.ARB_framebuffer_object) {

+         *params = rb->NumSamples;

+         break;

+      }

+      /* fallthrough */

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetRenderbufferParameterivEXT(target)");

+      return;

+   }

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsFramebufferEXT(GLuint framebuffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+   if (framebuffer) {

+      struct gl_framebuffer *rb = _mesa_lookup_framebuffer(ctx, framebuffer);

+      if (rb != NULL && rb != &DummyFramebuffer)

+         return GL_TRUE;

+   }

+   return GL_FALSE;

+}

+

+

+/**

+ * Check if any of the attachments of the given framebuffer are textures

+ * (render to texture).  Call ctx->Driver.RenderTexture() for such

+ * attachments.

+ */

+static void

+check_begin_texture_render(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   GLuint i;

+   ASSERT(ctx->Driver.RenderTexture);

+

+   if (fb->Name == 0)

+      return; /* can't render to texture with winsys framebuffers */

+

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      struct gl_renderbuffer_attachment *att = fb->Attachment + i;

+      struct gl_texture_object *texObj = att->Texture;

+      if (texObj

+          && texObj->Image[att->CubeMapFace][att->TextureLevel]) {

+         ctx->Driver.RenderTexture(ctx, fb, att);

+      }

+   }

+}

+

+

+/**

+ * Examine all the framebuffer's attachments to see if any are textures.

+ * If so, call ctx->Driver.FinishRenderTexture() for each texture to

+ * notify the device driver that the texture image may have changed.

+ */

+static void

+check_end_texture_render(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   if (fb->Name == 0)

+      return; /* can't render to texture with winsys framebuffers */

+

+   if (ctx->Driver.FinishRenderTexture) {

+      GLuint i;

+      for (i = 0; i < BUFFER_COUNT; i++) {

+         struct gl_renderbuffer_attachment *att = fb->Attachment + i;

+         if (att->Texture && att->Renderbuffer) {

+            ctx->Driver.FinishRenderTexture(ctx, att);

+         }

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)

+{

+   struct gl_framebuffer *newDrawFb, *newReadFb;

+   struct gl_framebuffer *oldDrawFb, *oldReadFb;

+   GLboolean bindReadBuf, bindDrawBuf;

+   GET_CURRENT_CONTEXT(ctx);

+

+#ifdef DEBUG

+   if (ctx->Extensions.ARB_framebuffer_object) {

+      ASSERT(ctx->Extensions.EXT_framebuffer_object);

+      ASSERT(ctx->Extensions.EXT_framebuffer_blit);

+   }

+#endif

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!ctx->Extensions.EXT_framebuffer_object) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glBindFramebufferEXT(unsupported)");

+      return;

+   }

+

+   switch (target) {

+#if FEATURE_EXT_framebuffer_blit

+   case GL_DRAW_FRAMEBUFFER_EXT:

+      if (!ctx->Extensions.EXT_framebuffer_blit) {

+         _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");

+         return;

+      }

+      bindDrawBuf = GL_TRUE;

+      bindReadBuf = GL_FALSE;

+      break;

+   case GL_READ_FRAMEBUFFER_EXT:

+      if (!ctx->Extensions.EXT_framebuffer_blit) {

+         _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");

+         return;

+      }

+      bindDrawBuf = GL_FALSE;

+      bindReadBuf = GL_TRUE;

+      break;

+#endif

+   case GL_FRAMEBUFFER_EXT:

+      bindDrawBuf = GL_TRUE;

+      bindReadBuf = GL_TRUE;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBindFramebufferEXT(target)");

+      return;

+   }

+

+   if (framebuffer) {

+      /* Binding a user-created framebuffer object */

+      newDrawFb = _mesa_lookup_framebuffer(ctx, framebuffer);

+      if (newDrawFb == &DummyFramebuffer) {

+         /* ID was reserved, but no real framebuffer object made yet */

+         newDrawFb = NULL;

+      }

+      else if (!newDrawFb && ctx->Extensions.ARB_framebuffer_object) {

+         /* All FBO IDs must be Gen'd */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindFramebuffer(buffer)");

+         return;

+      }

+

+      if (!newDrawFb) {

+	 /* create new framebuffer object */

+	 newDrawFb = ctx->Driver.NewFramebuffer(ctx, framebuffer);

+	 if (!newDrawFb) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindFramebufferEXT");

+	    return;

+	 }

+         _mesa_HashInsert(ctx->Shared->FrameBuffers, framebuffer, newDrawFb);

+      }

+      newReadFb = newDrawFb;

+   }

+   else {

+      /* Binding the window system framebuffer (which was originally set

+       * with MakeCurrent).

+       */

+      newDrawFb = ctx->WinSysDrawBuffer;

+      newReadFb = ctx->WinSysReadBuffer;

+   }

+

+   ASSERT(newDrawFb);

+   ASSERT(newDrawFb != &DummyFramebuffer);

+

+   /* save pointers to current/old framebuffers */

+   oldDrawFb = ctx->DrawBuffer;

+   oldReadFb = ctx->ReadBuffer;

+

+   /* check if really changing bindings */

+   if (oldDrawFb == newDrawFb)

+      bindDrawBuf = GL_FALSE;

+   if (oldReadFb == newReadFb)

+      bindReadBuf = GL_FALSE;

+

+   /*

+    * OK, now bind the new Draw/Read framebuffers, if they're changing.

+    *

+    * We also check if we're beginning and/or ending render-to-texture.

+    * When a framebuffer with texture attachments is unbound, call

+    * ctx->Driver.FinishRenderTexture().

+    * When a framebuffer with texture attachments is bound, call

+    * ctx->Driver.RenderTexture().

+    *

+    * Note that if the ReadBuffer has texture attachments we don't consider

+    * that a render-to-texture case.

+    */

+   if (bindReadBuf) {

+      FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+      /* check if old readbuffer was render-to-texture */

+      check_end_texture_render(ctx, oldReadFb);

+

+      _mesa_reference_framebuffer(&ctx->ReadBuffer, newReadFb);

+   }

+

+   if (bindDrawBuf) {

+      FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+      /* check if old read/draw buffers were render-to-texture */

+      if (!bindReadBuf)

+         check_end_texture_render(ctx, oldReadFb);

+

+      if (oldDrawFb != oldReadFb)

+         check_end_texture_render(ctx, oldDrawFb);

+

+      /* check if newly bound framebuffer has any texture attachments */

+      check_begin_texture_render(ctx, newDrawFb);

+

+      _mesa_reference_framebuffer(&ctx->DrawBuffer, newDrawFb);

+   }

+

+   if ((bindDrawBuf || bindReadBuf) && ctx->Driver.BindFramebuffer) {

+      ctx->Driver.BindFramebuffer(ctx, target, newDrawFb, newReadFb);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)

+{

+   GLint i;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   for (i = 0; i < n; i++) {

+      if (framebuffers[i] > 0) {

+	 struct gl_framebuffer *fb;

+	 fb = _mesa_lookup_framebuffer(ctx, framebuffers[i]);

+	 if (fb) {

+            ASSERT(fb == &DummyFramebuffer || fb->Name == framebuffers[i]);

+

+            /* check if deleting currently bound framebuffer object */

+            if (ctx->Extensions.EXT_framebuffer_blit) {

+               /* separate draw/read binding points */

+               if (fb == ctx->DrawBuffer) {

+                  /* bind default */

+                  ASSERT(fb->RefCount >= 2);

+                  _mesa_BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);

+               }

+               if (fb == ctx->ReadBuffer) {

+                  /* bind default */

+                  ASSERT(fb->RefCount >= 2);

+                  _mesa_BindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);

+               }

+            }

+            else {

+               /* only one binding point for read/draw buffers */

+               if (fb == ctx->DrawBuffer || fb == ctx->ReadBuffer) {

+                  /* bind default */

+                  ASSERT(fb->RefCount >= 2);

+                  _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

+               }    

+            }

+

+	    /* remove from hash table immediately, to free the ID */

+	    _mesa_HashRemove(ctx->Shared->FrameBuffers, framebuffers[i]);

+

+            if (fb != &DummyFramebuffer) {

+               /* But the object will not be freed until it's no longer

+                * bound in any context.

+                */

+               _mesa_reference_framebuffer(&fb, NULL);

+	    }

+	 }

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GenFramebuffersEXT(GLsizei n, GLuint *framebuffers)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint first;

+   GLint i;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenFramebuffersEXT(n)");

+      return;

+   }

+

+   if (!framebuffers)

+      return;

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->FrameBuffers, n);

+

+   for (i = 0; i < n; i++) {

+      GLuint name = first + i;

+      framebuffers[i] = name;

+      /* insert dummy placeholder into hash table */

+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+      _mesa_HashInsert(ctx->Shared->FrameBuffers, name, &DummyFramebuffer);

+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+   }

+}

+

+

+

+GLenum GLAPIENTRY

+_mesa_CheckFramebufferStatusEXT(GLenum target)

+{

+   struct gl_framebuffer *buffer;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   buffer = get_framebuffer_target(ctx, target);

+   if (!buffer) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCheckFramebufferStatus(target)");

+      return 0;

+   }

+

+   if (buffer->Name == 0) {

+      /* The window system / default framebuffer is always complete */

+      return GL_FRAMEBUFFER_COMPLETE_EXT;

+   }

+

+   /* No need to flush here */

+

+   if (buffer->_Status != GL_FRAMEBUFFER_COMPLETE) {

+      _mesa_test_framebuffer_completeness(ctx, buffer);

+   }

+

+   return buffer->_Status;

+}

+

+

+

+/**

+ * Common code called by glFramebufferTexture1D/2D/3DEXT().

+ */

+static void

+framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target, 

+                    GLenum attachment, GLenum textarget, GLuint texture,

+                    GLint level, GLint zoffset)

+{

+   struct gl_renderbuffer_attachment *att;

+   struct gl_texture_object *texObj = NULL;

+   struct gl_framebuffer *fb;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   fb = get_framebuffer_target(ctx, target);

+   if (!fb) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferTexture%sEXT(target=0x%x)", caller, target);

+      return;

+   }

+

+   /* check framebuffer binding */

+   if (fb->Name == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glFramebufferTexture%sEXT", caller);

+      return;

+   }

+

+

+   /* The textarget, level, and zoffset parameters are only validated if

+    * texture is non-zero.

+    */

+   if (texture) {

+      GLboolean err = GL_TRUE;

+

+      texObj = _mesa_lookup_texture(ctx, texture);

+      if (texObj != NULL) {

+         if (textarget == 0) {

+            /* XXX what's the purpose of this? */

+            err = (texObj->Target != GL_TEXTURE_3D) &&

+                (texObj->Target != GL_TEXTURE_1D_ARRAY_EXT) &&

+                (texObj->Target != GL_TEXTURE_2D_ARRAY_EXT);

+         }

+         else {

+            err = (texObj->Target == GL_TEXTURE_CUBE_MAP)

+                ? !IS_CUBE_FACE(textarget)

+                : (texObj->Target != textarget);

+         }

+      }

+      else {

+         /* can't render to a non-existant texture */

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glFramebufferTexture%sEXT(non existant texture)",

+                     caller);

+         return;

+      }

+

+      if (err) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glFramebufferTexture%sEXT(texture target mismatch)",

+                     caller);

+         return;

+      }

+

+      if (texObj->Target == GL_TEXTURE_3D) {

+         const GLint maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);

+         if (zoffset < 0 || zoffset >= maxSize) {

+            _mesa_error(ctx, GL_INVALID_VALUE,

+                        "glFramebufferTexture%sEXT(zoffset)", caller);

+            return;

+         }

+      }

+      else if ((texObj->Target == GL_TEXTURE_1D_ARRAY_EXT) ||

+               (texObj->Target == GL_TEXTURE_2D_ARRAY_EXT)) {

+         if (zoffset < 0 || zoffset >= ctx->Const.MaxArrayTextureLayers) {

+            _mesa_error(ctx, GL_INVALID_VALUE,

+                        "glFramebufferTexture%sEXT(layer)", caller);

+            return;

+         }

+      }

+

+      if ((level < 0) || 

+          (level >= _mesa_max_texture_levels(ctx, texObj->Target))) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glFramebufferTexture%sEXT(level)", caller);

+         return;

+      }

+   }

+

+   att = _mesa_get_attachment(ctx, fb, attachment);

+   if (att == NULL) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferTexture%sEXT(attachment)", caller);

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   _glthread_LOCK_MUTEX(fb->Mutex);

+   if (texObj) {

+      _mesa_set_texture_attachment(ctx, fb, att, texObj, textarget,

+                                   level, zoffset);

+      /* Set the render-to-texture flag.  We'll check this flag in

+       * glTexImage() and friends to determine if we need to revalidate

+       * any FBOs that might be rendering into this texture.

+       * This flag never gets cleared since it's non-trivial to determine

+       * when all FBOs might be done rendering to this texture.  That's OK

+       * though since it's uncommon to render to a texture then repeatedly

+       * call glTexImage() to change images in the texture.

+       */

+      texObj->_RenderToTexture = GL_TRUE;

+   }

+   else {

+      _mesa_remove_attachment(ctx, att);

+   }

+

+   invalidate_framebuffer(fb);

+

+   _glthread_UNLOCK_MUTEX(fb->Mutex);

+}

+

+

+

+void GLAPIENTRY

+_mesa_FramebufferTexture1DEXT(GLenum target, GLenum attachment,

+                              GLenum textarget, GLuint texture, GLint level)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if ((texture != 0) && (textarget != GL_TEXTURE_1D)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferTexture1DEXT(textarget)");

+      return;

+   }

+

+   framebuffer_texture(ctx, "1D", target, attachment, textarget, texture,

+                       level, 0);

+}

+

+

+void GLAPIENTRY

+_mesa_FramebufferTexture2DEXT(GLenum target, GLenum attachment,

+                              GLenum textarget, GLuint texture, GLint level)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if ((texture != 0) &&

+       (textarget != GL_TEXTURE_2D) &&

+       (textarget != GL_TEXTURE_RECTANGLE_ARB) &&

+       (!IS_CUBE_FACE(textarget))) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glFramebufferTexture2DEXT(textarget=0x%x)", textarget);

+      return;

+   }

+

+   framebuffer_texture(ctx, "2D", target, attachment, textarget, texture,

+                       level, 0);

+}

+

+

+void GLAPIENTRY

+_mesa_FramebufferTexture3DEXT(GLenum target, GLenum attachment,

+                              GLenum textarget, GLuint texture,

+                              GLint level, GLint zoffset)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if ((texture != 0) && (textarget != GL_TEXTURE_3D)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferTexture3DEXT(textarget)");

+      return;

+   }

+

+   framebuffer_texture(ctx, "3D", target, attachment, textarget, texture,

+                       level, zoffset);

+}

+

+

+void GLAPIENTRY

+_mesa_FramebufferTextureLayerEXT(GLenum target, GLenum attachment,

+                                 GLuint texture, GLint level, GLint layer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   framebuffer_texture(ctx, "Layer", target, attachment, 0, texture,

+                       level, layer);

+}

+

+

+void GLAPIENTRY

+_mesa_FramebufferRenderbufferEXT(GLenum target, GLenum attachment,

+                                 GLenum renderbufferTarget,

+                                 GLuint renderbuffer)

+{

+   struct gl_renderbuffer_attachment *att;

+   struct gl_framebuffer *fb;

+   struct gl_renderbuffer *rb;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   fb = get_framebuffer_target(ctx, target);

+   if (!fb) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glFramebufferRenderbufferEXT(target)");

+      return;

+   }

+

+   if (renderbufferTarget != GL_RENDERBUFFER_EXT) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferRenderbufferEXT(renderbufferTarget)");

+      return;

+   }

+

+   if (fb->Name == 0) {

+      /* Can't attach new renderbuffers to a window system framebuffer */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glFramebufferRenderbufferEXT");

+      return;

+   }

+

+   att = _mesa_get_attachment(ctx, fb, attachment);

+   if (att == NULL) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glFramebufferRenderbufferEXT(invalid attachment %s)",

+                  _mesa_lookup_enum_by_nr(attachment));

+      return;

+   }

+

+   if (renderbuffer) {

+      rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);

+      if (!rb) {

+	 _mesa_error(ctx, GL_INVALID_OPERATION,

+		     "glFramebufferRenderbufferEXT(non-existant"

+                     " renderbuffer %u)", renderbuffer);

+	 return;

+      }

+      else if (rb == &DummyRenderbuffer) {

+         /* This is what NVIDIA does */

+	 _mesa_error(ctx, GL_INVALID_VALUE,

+		     "glFramebufferRenderbufferEXT(renderbuffer %u)",

+                     renderbuffer);

+	 return;

+      }

+   }

+   else {

+      /* remove renderbuffer attachment */

+      rb = NULL;

+   }

+

+   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT &&

+       rb && rb->Format != MESA_FORMAT_NONE) {

+      /* make sure the renderbuffer is a depth/stencil format */

+      const GLenum baseFormat = _mesa_get_format_base_format(rb->Format);

+      if (baseFormat != GL_DEPTH_STENCIL) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glFramebufferRenderbufferEXT(renderbuffer"

+                     " is not DEPTH_STENCIL format)");

+         return;

+      }

+   }

+

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   assert(ctx->Driver.FramebufferRenderbuffer);

+   ctx->Driver.FramebufferRenderbuffer(ctx, fb, attachment, rb);

+

+   /* Some subsequent GL commands may depend on the framebuffer's visual

+    * after the binding is updated.  Update visual info now.

+    */

+   _mesa_update_framebuffer_visual(ctx, fb);

+}

+

+

+void GLAPIENTRY

+_mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment,

+                                             GLenum pname, GLint *params)

+{

+   const struct gl_renderbuffer_attachment *att;

+   struct gl_framebuffer *buffer;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   buffer = get_framebuffer_target(ctx, target);

+   if (!buffer) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetFramebufferAttachmentParameterivEXT(target)");

+      return;

+   }

+

+   if (buffer->Name == 0) {

+      /* the default / window-system FBO */

+      att = _mesa_get_fb0_attachment(ctx, buffer, attachment);

+   }

+   else {

+      /* user-created framebuffer FBO */

+      att = _mesa_get_attachment(ctx, buffer, attachment);

+   }

+

+   if (att == NULL) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetFramebufferAttachmentParameterivEXT(attachment)");

+      return;

+   }

+

+   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {

+      /* the depth and stencil attachments must point to the same buffer */

+      const struct gl_renderbuffer_attachment *depthAtt, *stencilAtt;

+      depthAtt = _mesa_get_attachment(ctx, buffer, GL_DEPTH_ATTACHMENT);

+      stencilAtt = _mesa_get_attachment(ctx, buffer, GL_STENCIL_ATTACHMENT);

+      if (depthAtt->Renderbuffer != stencilAtt->Renderbuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetFramebufferAttachmentParameterivEXT(DEPTH/STENCIL"

+                     " attachments differ)");

+         return;

+      }

+   }

+

+   /* No need to flush here */

+

+   switch (pname) {

+   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:

+      *params = buffer->Name == 0 ? GL_FRAMEBUFFER_DEFAULT : att->Type;

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:

+      if (att->Type == GL_RENDERBUFFER_EXT) {

+	 *params = att->Renderbuffer->Name;

+      }

+      else if (att->Type == GL_TEXTURE) {

+	 *params = att->Texture->Name;

+      }

+      else {

+         assert(att->Type == GL_NONE);

+         *params = 0;

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT:

+      if (att->Type == GL_TEXTURE) {

+	 *params = att->TextureLevel;

+      }

+      else {

+	 _mesa_error(ctx, GL_INVALID_ENUM,

+		     "glGetFramebufferAttachmentParameterivEXT(pname)");

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT:

+      if (att->Type == GL_TEXTURE) {

+         if (att->Texture && att->Texture->Target == GL_TEXTURE_CUBE_MAP) {

+            *params = GL_TEXTURE_CUBE_MAP_POSITIVE_X + att->CubeMapFace;

+         }

+         else {

+            *params = 0;

+         }

+      }

+      else {

+	 _mesa_error(ctx, GL_INVALID_ENUM,

+		     "glGetFramebufferAttachmentParameterivEXT(pname)");

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT:

+      if (att->Type == GL_TEXTURE) {

+         if (att->Texture && att->Texture->Target == GL_TEXTURE_3D) {

+            *params = att->Zoffset;

+         }

+         else {

+            *params = 0;

+         }

+      }

+      else {

+	 _mesa_error(ctx, GL_INVALID_ENUM,

+		     "glGetFramebufferAttachmentParameterivEXT(pname)");

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:

+      if (!ctx->Extensions.ARB_framebuffer_object) {

+         _mesa_error(ctx, GL_INVALID_ENUM,

+                     "glGetFramebufferAttachmentParameterivEXT(pname)");

+      }

+      else {

+         if (ctx->Extensions.EXT_framebuffer_sRGB && ctx->Const.sRGBCapable) {

+            *params = _mesa_get_format_color_encoding(att->Renderbuffer->Format);

+         }

+         else {

+            /* According to ARB_framebuffer_sRGB, we should return LINEAR

+             * if the sRGB conversion is unsupported. */

+            *params = GL_LINEAR;

+         }

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:

+      if (!ctx->Extensions.ARB_framebuffer_object) {

+         _mesa_error(ctx, GL_INVALID_ENUM,

+                     "glGetFramebufferAttachmentParameterivEXT(pname)");

+         return;

+      }

+      else {

+         gl_format format = att->Renderbuffer->Format;

+         if (format == MESA_FORMAT_CI8 || format == MESA_FORMAT_S8) {

+            /* special cases */

+            *params = GL_INDEX;

+         }

+         else {

+            *params = _mesa_get_format_datatype(format);

+         }

+      }

+      return;

+   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:

+   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:

+   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:

+   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:

+   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:

+   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:

+      if (!ctx->Extensions.ARB_framebuffer_object) {

+         _mesa_error(ctx, GL_INVALID_ENUM,

+                     "glGetFramebufferAttachmentParameterivEXT(pname)");

+      }

+      else if (att->Texture) {

+         const struct gl_texture_image *texImage =

+            _mesa_select_tex_image(ctx, att->Texture, att->Texture->Target,

+                                   att->TextureLevel);

+         if (texImage) {

+            *params = get_component_bits(pname, texImage->_BaseFormat,

+                                         texImage->TexFormat);

+         }

+         else {

+            *params = 0;

+         }

+      }

+      else if (att->Renderbuffer) {

+         *params = get_component_bits(pname, att->Renderbuffer->_BaseFormat,

+                                      att->Renderbuffer->Format);

+      }

+      else {

+         *params = 0;

+      }

+      return;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetFramebufferAttachmentParameterivEXT(pname)");

+      return;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GenerateMipmapEXT(GLenum target)

+{

+   struct gl_texture_object *texObj;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_3D:

+   case GL_TEXTURE_CUBE_MAP:

+      /* OK, legal value */

+      break;

+   default:

+      /* XXX need to implement GL_TEXTURE_1D_ARRAY and GL_TEXTURE_2D_ARRAY */

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGenerateMipmapEXT(target)");

+      return;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   if (texObj->BaseLevel >= texObj->MaxLevel) {

+      /* nothing to do */

+      return;

+   }

+

+   if (texObj->Target == GL_TEXTURE_CUBE_MAP &&

+       !_mesa_cube_complete(texObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGenerateMipmap(incomplete cube map)");

+      return;

+   }

+

+   _mesa_lock_texture(ctx, texObj);

+   if (target == GL_TEXTURE_CUBE_MAP) {

+      GLuint face;

+      for (face = 0; face < 6; face++)

+	 ctx->Driver.GenerateMipmap(ctx,

+				    GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + face,

+				    texObj);

+   }

+   else {

+      ctx->Driver.GenerateMipmap(ctx, target, texObj);

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+#if FEATURE_EXT_framebuffer_blit

+

+static const struct gl_renderbuffer_attachment *

+find_attachment(const struct gl_framebuffer *fb,

+                const struct gl_renderbuffer *rb)

+{

+   GLuint i;

+   for (i = 0; i < Elements(fb->Attachment); i++) {

+      if (fb->Attachment[i].Renderbuffer == rb)

+         return &fb->Attachment[i];

+   }

+   return NULL;

+}

+

+

+

+/**

+ * Blit rectangular region, optionally from one framebuffer to another.

+ *

+ * Note, if the src buffer is multisampled and the dest is not, this is

+ * when the samples must be resolved to a single color.

+ */

+void GLAPIENTRY

+_mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

+                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

+                         GLbitfield mask, GLenum filter)

+{

+   const GLbitfield legalMaskBits = (GL_COLOR_BUFFER_BIT |

+                                     GL_DEPTH_BUFFER_BIT |

+                                     GL_STENCIL_BUFFER_BIT);

+   const struct gl_framebuffer *readFb, *drawFb;

+   const struct gl_renderbuffer *colorReadRb, *colorDrawRb;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, _NEW_BUFFERS);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx,

+                  "glBlitFramebuffer(%d, %d, %d, %d,  %d, %d, %d, %d, 0x%x, %s)\n",

+                  srcX0, srcY0, srcX1, srcY1,

+                  dstX0, dstY0, dstX1, dstY1,

+                  mask, _mesa_lookup_enum_by_nr(filter));

+

+   if (ctx->NewState) {

+      _mesa_update_state(ctx);

+   }

+

+   readFb = ctx->ReadBuffer;

+   drawFb = ctx->DrawBuffer;

+

+   if (!readFb || !drawFb) {

+      /* This will normally never happen but someday we may want to

+       * support MakeCurrent() with no drawables.

+       */

+      return;

+   }

+

+   /* check for complete framebuffers */

+   if (drawFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||

+       readFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                  "glBlitFramebufferEXT(incomplete draw/read buffers)");

+      return;

+   }

+

+   if (filter != GL_NEAREST && filter != GL_LINEAR) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBlitFramebufferEXT(filter)");

+      return;

+   }

+

+   if (mask & ~legalMaskBits) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glBlitFramebufferEXT(mask)");

+      return;

+   }

+

+   /* depth/stencil must be blitted with nearest filtering */

+   if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))

+        && filter != GL_NEAREST) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+             "glBlitFramebufferEXT(depth/stencil requires GL_NEAREST filter");

+      return;

+   }

+

+   /* get color read/draw renderbuffers */

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      colorReadRb = readFb->_ColorReadBuffer;

+      colorDrawRb = drawFb->_ColorDrawBuffers[0];

+   }

+   else {

+      colorReadRb = colorDrawRb = NULL;

+   }

+

+   if (mask & GL_STENCIL_BUFFER_BIT) {

+      struct gl_renderbuffer *readRb = readFb->_StencilBuffer;

+      struct gl_renderbuffer *drawRb = drawFb->_StencilBuffer;

+      if (!readRb ||

+          !drawRb ||

+          _mesa_get_format_bits(readRb->Format, GL_STENCIL_BITS) != 

+          _mesa_get_format_bits(drawRb->Format, GL_STENCIL_BITS)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glBlitFramebufferEXT(stencil buffer size mismatch");

+         return;

+      }

+   }

+

+   if (mask & GL_DEPTH_BUFFER_BIT) {

+      struct gl_renderbuffer *readRb = readFb->_DepthBuffer;

+      struct gl_renderbuffer *drawRb = drawFb->_DepthBuffer;

+      if (!readRb ||

+          !drawRb ||

+          _mesa_get_format_bits(readRb->Format, GL_DEPTH_BITS) != 

+          _mesa_get_format_bits(drawRb->Format, GL_DEPTH_BITS)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glBlitFramebufferEXT(depth buffer size mismatch");

+         return;

+      }

+   }

+

+   if (readFb->Visual.samples > 0 &&

+       drawFb->Visual.samples > 0 &&

+       readFb->Visual.samples != drawFb->Visual.samples) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glBlitFramebufferEXT(mismatched samples");

+      return;

+   }

+

+   /* extra checks for multisample copies... */

+   if (readFb->Visual.samples > 0 || drawFb->Visual.samples > 0) {

+      /* src and dest region sizes must be the same */

+      if (srcX1 - srcX0 != dstX1 - dstX0 ||

+          srcY1 - srcY0 != dstY1 - dstY0) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                "glBlitFramebufferEXT(bad src/dst multisample region sizes");

+         return;

+      }

+

+      /* color formats must match */

+      if (colorReadRb &&

+          colorDrawRb &&

+          colorReadRb->Format != colorDrawRb->Format) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                "glBlitFramebufferEXT(bad src/dst multisample pixel formats");

+         return;

+      }

+   }

+

+   if (!ctx->Extensions.EXT_framebuffer_blit) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBlitFramebufferEXT");

+      return;

+   }

+

+   /* Debug code */

+   if (DEBUG_BLIT) {

+      printf("glBlitFramebuffer(%d, %d, %d, %d,  %d, %d, %d, %d,"

+	     " 0x%x, 0x%x)\n",

+	     srcX0, srcY0, srcX1, srcY1,

+	     dstX0, dstY0, dstX1, dstY1,

+	     mask, filter);

+      if (colorReadRb) {

+         const struct gl_renderbuffer_attachment *att;

+

+         att = find_attachment(readFb, colorReadRb);

+         printf("  Src FBO %u  RB %u (%dx%d)  ",

+		readFb->Name, colorReadRb->Name,

+		colorReadRb->Width, colorReadRb->Height);

+         if (att && att->Texture) {

+            printf("Tex %u  tgt 0x%x  level %u  face %u",

+		   att->Texture->Name,

+		   att->Texture->Target,

+		   att->TextureLevel,

+		   att->CubeMapFace);

+         }

+         printf("\n");

+

+         att = find_attachment(drawFb, colorDrawRb);

+         printf("  Dst FBO %u  RB %u (%dx%d)  ",

+		drawFb->Name, colorDrawRb->Name,

+		colorDrawRb->Width, colorDrawRb->Height);

+         if (att && att->Texture) {

+            printf("Tex %u  tgt 0x%x  level %u  face %u",

+		   att->Texture->Name,

+		   att->Texture->Target,

+		   att->TextureLevel,

+		   att->CubeMapFace);

+         }

+         printf("\n");

+      }

+   }

+

+   ASSERT(ctx->Driver.BlitFramebuffer);

+   ctx->Driver.BlitFramebuffer(ctx,

+                               srcX0, srcY0, srcX1, srcY1,

+                               dstX0, dstY0, dstX1, dstY1,

+                               mask, filter);

+}

+#endif /* FEATURE_EXT_framebuffer_blit */

+

+#if FEATURE_ARB_geometry_shader4

+void GLAPIENTRY

+_mesa_FramebufferTextureARB(GLenum target, GLenum attachment,

+                            GLuint texture, GLint level)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_error(ctx, GL_INVALID_OPERATION,

+               "glFramebufferTextureARB "

+               "not implemented!");

+}

+

+void GLAPIENTRY

+_mesa_FramebufferTextureFaceARB(GLenum target, GLenum attachment,

+                                GLuint texture, GLint level, GLenum face)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_error(ctx, GL_INVALID_OPERATION,

+               "glFramebufferTextureFaceARB "

+               "not implemented!");

+}

+#endif /* FEATURE_ARB_geometry_shader4 */

diff --git a/mesalib/src/mesa/main/formats.c b/mesalib/src/mesa/main/formats.c
index db10c9b4c..e2541bdf6 100644
--- a/mesalib/src/mesa/main/formats.c
+++ b/mesalib/src/mesa/main/formats.c
@@ -1,1698 +1,1698 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008-2009  VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "imports.h"
-#include "formats.h"
-#include "mfeatures.h"
-
-
-/**
- * Information about texture formats.
- */
-struct gl_format_info
-{
-   gl_format Name;
-
-   /** text name for debugging */
-   const char *StrName;
-
-   /**
-    * Base format is one of GL_RED, GL_RG, GL_RGB, GL_RGBA, GL_ALPHA,
-    * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_YCBCR_MESA,
-    * GL_COLOR_INDEX, GL_DEPTH_COMPONENT, GL_STENCIL_INDEX,
-    * GL_DEPTH_STENCIL, GL_DUDV_ATI.
-    */
-   GLenum BaseFormat;
-
-   /**
-    * Logical data type: one of  GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALED,
-    * GL_UNSIGNED_INT, GL_INT, GL_FLOAT.
-    */
-   GLenum DataType;
-
-   GLubyte RedBits;
-   GLubyte GreenBits;
-   GLubyte BlueBits;
-   GLubyte AlphaBits;
-   GLubyte LuminanceBits;
-   GLubyte IntensityBits;
-   GLubyte IndexBits;
-   GLubyte DepthBits;
-   GLubyte StencilBits;
-
-   /**
-    * To describe compressed formats.  If not compressed, Width=Height=1.
-    */
-   GLubyte BlockWidth, BlockHeight;
-   GLubyte BytesPerBlock;
-};
-
-
-/**
- * Info about each format.
- * These must be in the same order as the MESA_FORMAT_* enums so that
- * we can do lookups without searching.
- */
-static struct gl_format_info format_info[MESA_FORMAT_COUNT] =
-{
-   {
-      MESA_FORMAT_NONE,            /* Name */
-      "MESA_FORMAT_NONE",          /* StrName */
-      GL_NONE,                     /* BaseFormat */
-      GL_NONE,                     /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      0, 0, 0                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGBA8888,        /* Name */
-      "MESA_FORMAT_RGBA8888",      /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGBA8888_REV,    /* Name */
-      "MESA_FORMAT_RGBA8888_REV",  /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB8888,        /* Name */
-      "MESA_FORMAT_ARGB8888",      /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB8888_REV,    /* Name */
-      "MESA_FORMAT_ARGB8888_REV",  /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_XRGB8888,        /* Name */
-      "MESA_FORMAT_XRGB8888",      /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_XRGB8888_REV,    /* Name */
-      "MESA_FORMAT_XRGB8888_REV",  /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGB888,          /* Name */
-      "MESA_FORMAT_RGB888",        /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 3                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_BGR888,          /* Name */
-      "MESA_FORMAT_BGR888",        /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 3                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGB565,          /* Name */
-      "MESA_FORMAT_RGB565",        /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      5, 6, 5, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGB565_REV,      /* Name */
-      "MESA_FORMAT_RGB565_REV",    /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      5, 6, 5, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB4444,        /* Name */
-      "MESA_FORMAT_ARGB4444",      /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      4, 4, 4, 4,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB4444_REV,    /* Name */
-      "MESA_FORMAT_ARGB4444_REV",  /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      4, 4, 4, 4,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGBA5551,        /* Name */
-      "MESA_FORMAT_RGBA5551",      /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB1555,        /* Name */
-      "MESA_FORMAT_ARGB1555",      /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_ARGB1555_REV,    /* Name */
-      "MESA_FORMAT_ARGB1555_REV",  /* StrName */
-      GL_RGBA,                     /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_AL44,            /* Name */
-      "MESA_FORMAT_AL44",          /* StrName */
-      GL_LUMINANCE_ALPHA,          /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 4,                  /* Red/Green/Blue/AlphaBits */
-      4, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_AL88,            /* Name */
-      "MESA_FORMAT_AL88",          /* StrName */
-      GL_LUMINANCE_ALPHA,          /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */
-      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_AL88_REV,        /* Name */
-      "MESA_FORMAT_AL88_REV",      /* StrName */
-      GL_LUMINANCE_ALPHA,          /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */
-      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_AL1616,          /* Name */
-      "MESA_FORMAT_AL1616",        /* StrName */
-      GL_LUMINANCE_ALPHA,          /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */
-      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_AL1616_REV,      /* Name */
-      "MESA_FORMAT_AL1616_REV",    /* StrName */
-      GL_LUMINANCE_ALPHA,          /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */
-      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_RGB332,          /* Name */
-      "MESA_FORMAT_RGB332",        /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      3, 3, 2, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_A8,              /* Name */
-      "MESA_FORMAT_A8",            /* StrName */
-      GL_ALPHA,                    /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_A16,             /* Name */
-      "MESA_FORMAT_A16",           /* StrName */
-      GL_ALPHA,                    /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_L8,              /* Name */
-      "MESA_FORMAT_L8",            /* StrName */
-      GL_LUMINANCE,                /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_L16,             /* Name */
-      "MESA_FORMAT_L16",           /* StrName */
-      GL_LUMINANCE,                /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_I8,              /* Name */
-      "MESA_FORMAT_I8",            /* StrName */
-      GL_INTENSITY,                /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 8, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_I16,             /* Name */
-      "MESA_FORMAT_I16",           /* StrName */
-      GL_INTENSITY,                /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 16, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_CI8,             /* Name */
-      "MESA_FORMAT_CI8",           /* StrName */
-      GL_COLOR_INDEX,              /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 8, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_YCBCR,           /* Name */
-      "MESA_FORMAT_YCBCR",         /* StrName */
-      GL_YCBCR_MESA,               /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_YCBCR_REV,       /* Name */
-      "MESA_FORMAT_YCBCR_REV",     /* StrName */
-      GL_YCBCR_MESA,               /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_R8,
-      "MESA_FORMAT_R8",
-      GL_RED,
-      GL_UNSIGNED_NORMALIZED,
-      8, 0, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 1
-   },
-   {
-      MESA_FORMAT_RG88,
-      "MESA_FORMAT_RG88",
-      GL_RG,
-      GL_UNSIGNED_NORMALIZED,
-      8, 8, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_RG88_REV,
-      "MESA_FORMAT_RG88_REV",
-      GL_RG,
-      GL_UNSIGNED_NORMALIZED,
-      8, 8, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_R16,
-      "MESA_FORMAT_R16",
-      GL_RED,
-      GL_UNSIGNED_NORMALIZED,
-      16, 0, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_RG1616,
-      "MESA_FORMAT_RG1616",
-      GL_RG,
-      GL_UNSIGNED_NORMALIZED,
-      16, 16, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_RG1616_REV,
-      "MESA_FORMAT_RG1616_REV",
-      GL_RG,
-      GL_UNSIGNED_NORMALIZED,
-      16, 16, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_ARGB2101010,
-      "MESA_FORMAT_ARGB2101010",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      10, 10, 10, 2,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_Z24_S8,          /* Name */
-      "MESA_FORMAT_Z24_S8",        /* StrName */
-      GL_DEPTH_STENCIL,            /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 24, 8,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_S8_Z24,          /* Name */
-      "MESA_FORMAT_S8_Z24",        /* StrName */
-      GL_DEPTH_STENCIL,            /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 24, 8,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_Z16,             /* Name */
-      "MESA_FORMAT_Z16",           /* StrName */
-      GL_DEPTH_COMPONENT,          /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 16, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 2                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_X8_Z24,          /* Name */
-      "MESA_FORMAT_X8_Z24",        /* StrName */
-      GL_DEPTH_COMPONENT,          /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 24, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_Z24_X8,          /* Name */
-      "MESA_FORMAT_Z24_X8",        /* StrName */
-      GL_DEPTH_COMPONENT,          /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 24, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_Z32,             /* Name */
-      "MESA_FORMAT_Z32",           /* StrName */
-      GL_DEPTH_COMPONENT,          /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 32, 0,              /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 4                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_S8,              /* Name */
-      "MESA_FORMAT_S8",            /* StrName */
-      GL_STENCIL_INDEX,            /* BaseFormat */
-      GL_UNSIGNED_INT,             /* DataType */
-      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 8,               /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                      /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_SRGB8,
-      "MESA_FORMAT_SRGB8",
-      GL_RGB,
-      GL_UNSIGNED_NORMALIZED,
-      8, 8, 8, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 3
-   },
-   {
-      MESA_FORMAT_SRGBA8,
-      "MESA_FORMAT_SRGBA8",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,    
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_SARGB8,
-      "MESA_FORMAT_SARGB8",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,    
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_SL8,
-      "MESA_FORMAT_SL8",
-      GL_LUMINANCE,
-      GL_UNSIGNED_NORMALIZED,    
-      0, 0, 0, 0,
-      8, 0, 0, 0, 0,
-      1, 1, 1
-   },
-   {
-      MESA_FORMAT_SLA8,
-      "MESA_FORMAT_SLA8",
-      GL_LUMINANCE_ALPHA,
-      GL_UNSIGNED_NORMALIZED,    
-      0, 0, 0, 8,
-      8, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_SRGB_DXT1,       /* Name */
-      "MESA_FORMAT_SRGB_DXT1",     /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      4, 4, 4, 0,                  /* approx Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      4, 4, 8                      /* 8 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT1,
-      "MESA_FORMAT_SRGBA_DXT1",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 8                      /* 8 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT3,
-      "MESA_FORMAT_SRGBA_DXT3",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT5,
-      "MESA_FORMAT_SRGBA_DXT5",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-
-   {
-      MESA_FORMAT_RGB_FXT1,
-      "MESA_FORMAT_RGB_FXT1",
-      GL_RGB,
-      GL_UNSIGNED_NORMALIZED,
-      4, 4, 4, 0,                  /* approx Red/Green/BlueBits */
-      0, 0, 0, 0, 0,
-      8, 4, 16                     /* 16 bytes per 8x4 block */
-   },
-   {
-      MESA_FORMAT_RGBA_FXT1,
-      "MESA_FORMAT_RGBA_FXT1",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      4, 4, 4, 1,                  /* approx Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,
-      8, 4, 16                     /* 16 bytes per 8x4 block */
-   },
-
-   {
-      MESA_FORMAT_RGB_DXT1,        /* Name */
-      "MESA_FORMAT_RGB_DXT1",      /* StrName */
-      GL_RGB,                      /* BaseFormat */
-      GL_UNSIGNED_NORMALIZED,      /* DataType */
-      4, 4, 4, 0,                  /* approx Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */
-      4, 4, 8                      /* 8 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_RGBA_DXT1,
-      "MESA_FORMAT_RGBA_DXT1",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,    
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 8                      /* 8 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_RGBA_DXT3,
-      "MESA_FORMAT_RGBA_DXT3",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,    
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_RGBA_DXT5,
-      "MESA_FORMAT_RGBA_DXT5",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,    
-      4, 4, 4, 4,
-      0, 0, 0, 0, 0,
-      4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-      MESA_FORMAT_RGBA_FLOAT32,
-      "MESA_FORMAT_RGBA_FLOAT32",
-      GL_RGBA,
-      GL_FLOAT,
-      32, 32, 32, 32,
-      0, 0, 0, 0, 0,
-      1, 1, 16
-   },
-   {
-      MESA_FORMAT_RGBA_FLOAT16,
-      "MESA_FORMAT_RGBA_FLOAT16",
-      GL_RGBA,
-      GL_FLOAT,
-      16, 16, 16, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-      MESA_FORMAT_RGB_FLOAT32,
-      "MESA_FORMAT_RGB_FLOAT32",
-      GL_RGB,
-      GL_FLOAT,
-      32, 32, 32, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 12
-   },
-   {
-      MESA_FORMAT_RGB_FLOAT16,
-      "MESA_FORMAT_RGB_FLOAT16",
-      GL_RGB,
-      GL_FLOAT,
-      16, 16, 16, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 6
-   },
-   {
-      MESA_FORMAT_ALPHA_FLOAT32,
-      "MESA_FORMAT_ALPHA_FLOAT32",
-      GL_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 32,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_ALPHA_FLOAT16,
-      "MESA_FORMAT_ALPHA_FLOAT16",
-      GL_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_LUMINANCE_FLOAT32,
-      "MESA_FORMAT_LUMINANCE_FLOAT32",
-      GL_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 0,
-      32, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_LUMINANCE_FLOAT16,
-      "MESA_FORMAT_LUMINANCE_FLOAT16",
-      GL_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 0,
-      16, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,
-      "MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32",
-      GL_LUMINANCE_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 32,
-      32, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,
-      "MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16",
-      GL_LUMINANCE_ALPHA,
-      GL_FLOAT,
-      0, 0, 0, 16,
-      16, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_INTENSITY_FLOAT32,
-      "MESA_FORMAT_INTENSITY_FLOAT32",
-      GL_INTENSITY,
-      GL_FLOAT,
-      0, 0, 0, 0,
-      0, 32, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_INTENSITY_FLOAT16,
-      "MESA_FORMAT_INTENSITY_FLOAT16",
-      GL_INTENSITY,
-      GL_FLOAT,
-      0, 0, 0, 0,
-      0, 16, 0, 0, 0,
-      1, 1, 2
-   },
-
-   /* unnormalized signed int formats */
-   {
-      MESA_FORMAT_RGBA_INT8,
-      "MESA_FORMAT_RGBA_INT8",
-      GL_RGBA,
-      GL_INT,
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_RGBA_INT16,
-      "MESA_FORMAT_RGBA_INT16",
-      GL_RGBA,
-      GL_INT,
-      16, 16, 16, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-      MESA_FORMAT_RGBA_INT32,
-      "MESA_FORMAT_RGBA_INT32",
-      GL_RGBA,
-      GL_INT,
-      32, 32, 32, 32,
-      0, 0, 0, 0, 0,
-      1, 1, 16
-   },
-
-   /* unnormalized unsigned int formats */
-   {
-      MESA_FORMAT_RGBA_UINT8,
-      "MESA_FORMAT_RGBA_UINT8",
-      GL_RGBA,
-      GL_UNSIGNED_INT,
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_RGBA_UINT16,
-      "MESA_FORMAT_RGBA_UINT16",
-      GL_RGBA,
-      GL_UNSIGNED_INT,
-      16, 16, 16, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-      MESA_FORMAT_RGBA_UINT32,
-      "MESA_FORMAT_RGBA_UINT32",
-      GL_RGBA,
-      GL_UNSIGNED_INT,
-      32, 32, 32, 32,
-      0, 0, 0, 0, 0,
-      1, 1, 16
-   },
-
-
-   {
-      MESA_FORMAT_DUDV8,
-      "MESA_FORMAT_DUDV8",
-      GL_DUDV_ATI,
-      GL_SIGNED_NORMALIZED,
-      0, 0, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-
-   /* Signed 8 bits / channel */
-   {
-      MESA_FORMAT_SIGNED_R8,        /* Name */
-      "MESA_FORMAT_SIGNED_R8",      /* StrName */
-      GL_RED,                       /* BaseFormat */
-      GL_SIGNED_NORMALIZED,         /* DataType */
-      8, 0, 0, 0,                   /* Red/Green/Blue/AlphaBits */
-      0, 0, 0, 0, 0,                /* Lum/Int/Index/Depth/StencilBits */
-      1, 1, 1                       /* BlockWidth/Height,Bytes */
-   },
-   {
-      MESA_FORMAT_SIGNED_RG88,
-      "MESA_FORMAT_SIGNED_RG88",
-      GL_RG,
-      GL_SIGNED_NORMALIZED,
-      8, 8, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBX8888,
-      "MESA_FORMAT_SIGNED_RGBX8888",
-      GL_RGB,
-      GL_SIGNED_NORMALIZED,
-      8, 8, 8, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 4                       /* 4 bpp, but no alpha */
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA8888,
-      "MESA_FORMAT_SIGNED_RGBA8888",
-      GL_RGBA,
-      GL_SIGNED_NORMALIZED,
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA8888_REV,
-      "MESA_FORMAT_SIGNED_RGBA8888_REV",
-      GL_RGBA,
-      GL_SIGNED_NORMALIZED,
-      8, 8, 8, 8,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-
-   /* Signed 16 bits / channel */
-   {
-      MESA_FORMAT_SIGNED_R_16,
-      "MESA_FORMAT_SIGNED_R_16",
-      GL_RED,
-      GL_SIGNED_NORMALIZED,
-      16, 0, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 2
-   },
-   {
-      MESA_FORMAT_SIGNED_RG_16,
-      "MESA_FORMAT_SIGNED_RG_16",
-      GL_RG,
-      GL_SIGNED_NORMALIZED,
-      16, 16, 0, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 4
-   },
-   {
-      MESA_FORMAT_SIGNED_RGB_16,
-      "MESA_FORMAT_SIGNED_RGB_16",
-      GL_RGB,
-      GL_SIGNED_NORMALIZED,
-      16, 16, 16, 0,
-      0, 0, 0, 0, 0,
-      1, 1, 6
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA_16,
-      "MESA_FORMAT_SIGNED_RGBA_16",
-      GL_RGBA,
-      GL_SIGNED_NORMALIZED,
-      16, 16, 16, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-      MESA_FORMAT_RGBA_16,
-      "MESA_FORMAT_RGBA_16",
-      GL_RGBA,
-      GL_UNSIGNED_NORMALIZED,
-      16, 16, 16, 16,
-      0, 0, 0, 0, 0,
-      1, 1, 8
-   },
-   {
-     MESA_FORMAT_RED_RGTC1,
-     "MESA_FORMAT_RED_RGTC1",
-     GL_RED,
-     GL_UNSIGNED_NORMALIZED,
-     4, 0, 0, 0,
-     0, 0, 0, 0, 0,
-     4, 4, 8                     /* 8 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_SIGNED_RED_RGTC1,
-     "MESA_FORMAT_SIGNED_RED_RGTC1",
-     GL_RED,
-     GL_SIGNED_NORMALIZED,
-     4, 0, 0, 0,
-     0, 0, 0, 0, 0,
-     4, 4, 8                     /* 8 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_RG_RGTC2,
-     "MESA_FORMAT_RG_RGTC2",
-     GL_RG,
-     GL_UNSIGNED_NORMALIZED,
-     4, 4, 0, 0,
-     0, 0, 0, 0, 0,
-     4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_SIGNED_RG_RGTC2,
-     "MESA_FORMAT_SIGNED_RG_RGTC2",
-     GL_RG,
-     GL_SIGNED_NORMALIZED,
-     4, 4, 0, 0,
-     0, 0, 0, 0, 0,
-     4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_L_LATC1,
-     "MESA_FORMAT_L_LATC1",
-     GL_LUMINANCE,
-     GL_UNSIGNED_NORMALIZED,
-     0, 0, 0, 0,
-     4, 0, 0, 0, 0,
-     4, 4, 8                     /* 8 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_SIGNED_L_LATC1,
-     "MESA_FORMAT_SIGNED_L_LATC1",
-     GL_LUMINANCE,
-     GL_SIGNED_NORMALIZED,
-     0, 0, 0, 0,
-     4, 0, 0, 0, 0,
-     4, 4, 8                     /* 8 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_LA_LATC2,
-     "MESA_FORMAT_LA_LATC2",
-     GL_LUMINANCE_ALPHA,
-     GL_UNSIGNED_NORMALIZED,
-     0, 0, 0, 4,
-     4, 0, 0, 0, 0,
-     4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-   {
-     MESA_FORMAT_SIGNED_LA_LATC2,
-     "MESA_FORMAT_SIGNED_LA_LATC2",
-     GL_LUMINANCE_ALPHA,
-     GL_SIGNED_NORMALIZED,
-     0, 0, 0, 4,
-     4, 0, 0, 0, 0,
-     4, 4, 16                     /* 16 bytes per 4x4 block */
-   },
-};
-
-
-
-static const struct gl_format_info *
-_mesa_get_format_info(gl_format format)
-{
-   const struct gl_format_info *info = &format_info[format];
-   assert(info->Name == format);
-   return info;
-}
-
-
-/** Return string name of format (for debugging) */
-const char *
-_mesa_get_format_name(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   return info->StrName;
-}
-
-
-
-/**
- * Return bytes needed to store a block of pixels in the given format.
- * Normally, a block is 1x1 (a single pixel).  But for compressed formats
- * a block may be 4x4 or 8x4, etc.
- */
-GLuint
-_mesa_get_format_bytes(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   ASSERT(info->BytesPerBlock);
-   return info->BytesPerBlock;
-}
-
-
-/**
- * Return bits per component for the given format.
- * \param format  one of MESA_FORMAT_x
- * \param pname  the component, such as GL_RED_BITS, GL_TEXTURE_BLUE_BITS, etc.
- */
-GLint
-_mesa_get_format_bits(gl_format format, GLenum pname)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-
-   switch (pname) {
-   case GL_RED_BITS:
-   case GL_TEXTURE_RED_SIZE:
-   case GL_RENDERBUFFER_RED_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
-      return info->RedBits;
-   case GL_GREEN_BITS:
-   case GL_TEXTURE_GREEN_SIZE:
-   case GL_RENDERBUFFER_GREEN_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
-      return info->GreenBits;
-   case GL_BLUE_BITS:
-   case GL_TEXTURE_BLUE_SIZE:
-   case GL_RENDERBUFFER_BLUE_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
-      return info->BlueBits;
-   case GL_ALPHA_BITS:
-   case GL_TEXTURE_ALPHA_SIZE:
-   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
-      return info->AlphaBits;
-   case GL_TEXTURE_INTENSITY_SIZE:
-      return info->IntensityBits;
-   case GL_TEXTURE_LUMINANCE_SIZE:
-      return info->LuminanceBits;
-   case GL_INDEX_BITS:
-   case GL_TEXTURE_INDEX_SIZE_EXT:
-      return info->IndexBits;
-   case GL_DEPTH_BITS:
-   case GL_TEXTURE_DEPTH_SIZE_ARB:
-   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
-      return info->DepthBits;
-   case GL_STENCIL_BITS:
-   case GL_TEXTURE_STENCIL_SIZE_EXT:
-   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
-   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
-      return info->StencilBits;
-   default:
-      _mesa_problem(NULL, "bad pname in _mesa_get_format_bits()");
-      return 0;
-   }
-}
-
-
-/**
- * Return the data type (or more specifically, the data representation)
- * for the given format.
- * The return value will be one of:
- *    GL_UNSIGNED_NORMALIZED = unsigned int representing [0,1]
- *    GL_SIGNED_NORMALIZED = signed int representing [-1, 1]
- *    GL_UNSIGNED_INT = an ordinary unsigned integer
- *    GL_INT = an ordinary signed integer
- *    GL_FLOAT = an ordinary float
- */
-GLenum
-_mesa_get_format_datatype(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   return info->DataType;
-}
-
-
-/**
- * Return the basic format for the given type.  The result will be
- * one of GL_RGB, GL_RGBA, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA,
- * GL_INTENSITY, GL_YCBCR_MESA, GL_COLOR_INDEX, GL_DEPTH_COMPONENT,
- * GL_STENCIL_INDEX, GL_DEPTH_STENCIL.
- */
-GLenum
-_mesa_get_format_base_format(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   return info->BaseFormat;
-}
-
-
-/**
- * Return the block size (in pixels) for the given format.  Normally
- * the block size is 1x1.  But compressed formats will have block sizes
- * of 4x4 or 8x4 pixels, etc.
- * \param bw  returns block width in pixels
- * \param bh  returns block height in pixels
- */
-void
-_mesa_get_format_block_size(gl_format format, GLuint *bw, GLuint *bh)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   *bw = info->BlockWidth;
-   *bh = info->BlockHeight;
-}
-
-
-/** Is the given format a compressed format? */
-GLboolean
-_mesa_is_format_compressed(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   return info->BlockWidth > 1 || info->BlockHeight > 1;
-}
-
-
-/**
- * Determine if the given format represents a packed depth/stencil buffer.
- */
-GLboolean
-_mesa_is_format_packed_depth_stencil(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-
-   return info->BaseFormat == GL_DEPTH_STENCIL;
-}
-
-
-/**
- * Is the given format a signed/unsigned integer color format?
- */
-GLboolean
-_mesa_is_format_integer_color(gl_format format)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT) &&
-      info->BaseFormat != GL_DEPTH_COMPONENT &&
-      info->BaseFormat != GL_DEPTH_STENCIL &&
-      info->BaseFormat != GL_STENCIL_INDEX;
-}
-
-
-/**
- * Return color encoding for given format.
- * \return GL_LINEAR or GL_SRGB
- */
-GLenum
-_mesa_get_format_color_encoding(gl_format format)
-{
-   /* XXX this info should be encoded in gl_format_info */
-   switch (format) {
-   case MESA_FORMAT_SRGB8:
-   case MESA_FORMAT_SRGBA8:
-   case MESA_FORMAT_SARGB8:
-   case MESA_FORMAT_SL8:
-   case MESA_FORMAT_SLA8:
-   case MESA_FORMAT_SRGB_DXT1:
-   case MESA_FORMAT_SRGBA_DXT1:
-   case MESA_FORMAT_SRGBA_DXT3:
-   case MESA_FORMAT_SRGBA_DXT5:
-      return GL_SRGB;
-   default:
-      return GL_LINEAR;
-   }
-}
-
-
-/**
- * For an sRGB format, return the corresponding linear color space format.
- * For non-sRGB formats, return the format as-is.
- */
-gl_format
-_mesa_get_srgb_format_linear(gl_format format)
-{
-   switch (format) {
-   case MESA_FORMAT_SRGB8:
-      format = MESA_FORMAT_RGB888;
-      break;
-   case MESA_FORMAT_SRGBA8:
-      format = MESA_FORMAT_RGBA8888;
-      break;
-   case MESA_FORMAT_SARGB8:
-      format = MESA_FORMAT_ARGB8888;
-      break;
-   case MESA_FORMAT_SL8:
-      format = MESA_FORMAT_L8;
-      break;
-   case MESA_FORMAT_SLA8:
-      format = MESA_FORMAT_AL88;
-      break;
-   case MESA_FORMAT_SRGB_DXT1:
-      format = MESA_FORMAT_RGB_DXT1;
-      break;
-   case MESA_FORMAT_SRGBA_DXT1:
-      format = MESA_FORMAT_RGBA_DXT1;
-      break;
-   case MESA_FORMAT_SRGBA_DXT3:
-      format = MESA_FORMAT_RGBA_DXT3;
-      break;
-   case MESA_FORMAT_SRGBA_DXT5:
-      format = MESA_FORMAT_RGBA_DXT5;
-      break;
-   default:
-      break;
-   }
-   return format;
-}
-
-
-/**
- * Return number of bytes needed to store an image of the given size
- * in the given format.
- */
-GLuint
-_mesa_format_image_size(gl_format format, GLsizei width,
-                        GLsizei height, GLsizei depth)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   /* Strictly speaking, a conditional isn't needed here */
-   if (info->BlockWidth > 1 || info->BlockHeight > 1) {
-      /* compressed format (2D only for now) */
-      const GLuint bw = info->BlockWidth, bh = info->BlockHeight;
-      const GLuint wblocks = (width + bw - 1) / bw;
-      const GLuint hblocks = (height + bh - 1) / bh;
-      const GLuint sz = wblocks * hblocks * info->BytesPerBlock;
-      assert(depth == 1);
-      return sz;
-   }
-   else {
-      /* non-compressed */
-      const GLuint sz = width * height * depth * info->BytesPerBlock;
-      return sz;
-   }
-}
-
-
-/**
- * Same as _mesa_format_image_size() but returns a 64-bit value to
- * accomodate very large textures.
- */
-uint64_t
-_mesa_format_image_size64(gl_format format, GLsizei width,
-                          GLsizei height, GLsizei depth)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   /* Strictly speaking, a conditional isn't needed here */
-   if (info->BlockWidth > 1 || info->BlockHeight > 1) {
-      /* compressed format (2D only for now) */
-      const uint64_t bw = info->BlockWidth, bh = info->BlockHeight;
-      const uint64_t wblocks = (width + bw - 1) / bw;
-      const uint64_t hblocks = (height + bh - 1) / bh;
-      const uint64_t sz = wblocks * hblocks * info->BytesPerBlock;
-      assert(depth == 1);
-      return sz;
-   }
-   else {
-      /* non-compressed */
-      const uint64_t sz = ((uint64_t) width *
-                           (uint64_t) height *
-                           (uint64_t) depth *
-                           info->BytesPerBlock);
-      return sz;
-   }
-}
-
-
-
-GLint
-_mesa_format_row_stride(gl_format format, GLsizei width)
-{
-   const struct gl_format_info *info = _mesa_get_format_info(format);
-   /* Strictly speaking, a conditional isn't needed here */
-   if (info->BlockWidth > 1 || info->BlockHeight > 1) {
-      /* compressed format */
-      const GLuint bw = info->BlockWidth;
-      const GLuint wblocks = (width + bw - 1) / bw;
-      const GLint stride = wblocks * info->BytesPerBlock;
-      return stride;
-   }
-   else {
-      const GLint stride = width * info->BytesPerBlock;
-      return stride;
-   }
-}
-
-
-/**
- * Debug/test: check that all formats are handled in the
- * _mesa_format_to_type_and_comps() function.  When new pixel formats
- * are added to Mesa, that function needs to be updated.
- * This is a no-op after the first call.
- */
-static void
-check_format_to_type_and_comps(void)
-{
-   gl_format f;
-
-   for (f = MESA_FORMAT_NONE + 1; f < MESA_FORMAT_COUNT; f++) {
-      GLenum datatype = 0;
-      GLuint comps = 0;
-      /* This function will emit a problem/warning if the format is
-       * not handled.
-       */
-      _mesa_format_to_type_and_comps(f, &datatype, &comps);
-   }
-}
-
-
-/**
- * Do sanity checking of the format info table.
- */
-void
-_mesa_test_formats(void)
-{
-   GLuint i;
-
-   assert(Elements(format_info) == MESA_FORMAT_COUNT);
-
-   for (i = 0; i < MESA_FORMAT_COUNT; i++) {
-      const struct gl_format_info *info = _mesa_get_format_info(i);
-      assert(info);
-
-      assert(info->Name == i);
-
-      if (info->Name == MESA_FORMAT_NONE)
-         continue;
-
-      if (info->BlockWidth == 1 && info->BlockHeight == 1) {
-         if (info->RedBits > 0) {
-            GLuint t = info->RedBits + info->GreenBits
-               + info->BlueBits + info->AlphaBits;
-            assert(t / 8 <= info->BytesPerBlock);
-            (void) t;
-         }
-      }
-
-      assert(info->DataType == GL_UNSIGNED_NORMALIZED ||
-             info->DataType == GL_SIGNED_NORMALIZED ||
-             info->DataType == GL_UNSIGNED_INT ||
-             info->DataType == GL_INT ||
-             info->DataType == GL_FLOAT);
-
-      if (info->BaseFormat == GL_RGB) {
-         assert(info->RedBits > 0);
-         assert(info->GreenBits > 0);
-         assert(info->BlueBits > 0);
-         assert(info->AlphaBits == 0);
-         assert(info->LuminanceBits == 0);
-         assert(info->IntensityBits == 0);
-      }
-      else if (info->BaseFormat == GL_RGBA) {
-         assert(info->RedBits > 0);
-         assert(info->GreenBits > 0);
-         assert(info->BlueBits > 0);
-         assert(info->AlphaBits > 0);
-         assert(info->LuminanceBits == 0);
-         assert(info->IntensityBits == 0);
-      }
-      else if (info->BaseFormat == GL_RG) {
-         assert(info->RedBits > 0);
-         assert(info->GreenBits > 0);
-         assert(info->BlueBits == 0);
-         assert(info->AlphaBits == 0);
-         assert(info->LuminanceBits == 0);
-         assert(info->IntensityBits == 0);
-      }
-      else if (info->BaseFormat == GL_RED) {
-         assert(info->RedBits > 0);
-         assert(info->GreenBits == 0);
-         assert(info->BlueBits == 0);
-         assert(info->AlphaBits == 0);
-         assert(info->LuminanceBits == 0);
-         assert(info->IntensityBits == 0);
-      }
-      else if (info->BaseFormat == GL_LUMINANCE) {
-         assert(info->RedBits == 0);
-         assert(info->GreenBits == 0);
-         assert(info->BlueBits == 0);
-         assert(info->AlphaBits == 0);
-         assert(info->LuminanceBits > 0);
-         assert(info->IntensityBits == 0);
-      }
-      else if (info->BaseFormat == GL_INTENSITY) {
-         assert(info->RedBits == 0);
-         assert(info->GreenBits == 0);
-         assert(info->BlueBits == 0);
-         assert(info->AlphaBits == 0);
-         assert(info->LuminanceBits == 0);
-         assert(info->IntensityBits > 0);
-      }
-   }
-
-   check_format_to_type_and_comps();
-}
-
-
-
-/**
- * Return datatype and number of components per texel for the given gl_format.
- * Only used for mipmap generation code.
- */
-void
-_mesa_format_to_type_and_comps(gl_format format,
-                               GLenum *datatype, GLuint *comps)
-{
-   switch (format) {
-   case MESA_FORMAT_RGBA8888:
-   case MESA_FORMAT_RGBA8888_REV:
-   case MESA_FORMAT_ARGB8888:
-   case MESA_FORMAT_ARGB8888_REV:
-   case MESA_FORMAT_XRGB8888:
-   case MESA_FORMAT_XRGB8888_REV:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGB888:
-   case MESA_FORMAT_BGR888:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 3;
-      return;
-   case MESA_FORMAT_RGB565:
-   case MESA_FORMAT_RGB565_REV:
-      *datatype = GL_UNSIGNED_SHORT_5_6_5;
-      *comps = 3;
-      return;
-
-   case MESA_FORMAT_ARGB4444:
-   case MESA_FORMAT_ARGB4444_REV:
-      *datatype = GL_UNSIGNED_SHORT_4_4_4_4;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_ARGB1555:
-   case MESA_FORMAT_ARGB1555_REV:
-      *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_ARGB2101010:
-      *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_RGBA5551:
-      *datatype = GL_UNSIGNED_SHORT_5_5_5_1;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_AL44:
-      *datatype = MESA_UNSIGNED_BYTE_4_4;
-      *comps = 2;
-      return;
-
-   case MESA_FORMAT_AL88:
-   case MESA_FORMAT_AL88_REV:
-   case MESA_FORMAT_RG88:
-   case MESA_FORMAT_RG88_REV:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 2;
-      return;
-
-   case MESA_FORMAT_AL1616:
-   case MESA_FORMAT_AL1616_REV:
-   case MESA_FORMAT_RG1616:
-   case MESA_FORMAT_RG1616_REV:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 2;
-      return;
-
-   case MESA_FORMAT_R16:
-   case MESA_FORMAT_A16:
-   case MESA_FORMAT_L16:
-   case MESA_FORMAT_I16:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_RGB332:
-      *datatype = GL_UNSIGNED_BYTE_3_3_2;
-      *comps = 3;
-      return;
-
-   case MESA_FORMAT_A8:
-   case MESA_FORMAT_L8:
-   case MESA_FORMAT_I8:
-   case MESA_FORMAT_CI8:
-   case MESA_FORMAT_R8:
-   case MESA_FORMAT_S8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_YCBCR:
-   case MESA_FORMAT_YCBCR_REV:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 2;
-      return;
-
-   case MESA_FORMAT_Z24_S8:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 1; /* XXX OK? */
-      return;
-
-   case MESA_FORMAT_S8_Z24:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 1; /* XXX OK? */
-      return;
-
-   case MESA_FORMAT_Z16:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_X8_Z24:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_Z24_X8:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_Z32:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_DUDV8:
-      *datatype = GL_BYTE;
-      *comps = 2;
-      return;
-
-   case MESA_FORMAT_SIGNED_R8:
-      *datatype = GL_BYTE;
-      *comps = 1;
-      return;
-   case MESA_FORMAT_SIGNED_RG88:
-      *datatype = GL_BYTE;
-      *comps = 2;
-      return;
-   case MESA_FORMAT_SIGNED_RGBA8888:
-   case MESA_FORMAT_SIGNED_RGBA8888_REV:
-   case MESA_FORMAT_SIGNED_RGBX8888:
-      *datatype = GL_BYTE;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_RGBA_16:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_SIGNED_R_16:
-      *datatype = GL_SHORT;
-      *comps = 1;
-      return;
-   case MESA_FORMAT_SIGNED_RG_16:
-      *datatype = GL_SHORT;
-      *comps = 2;
-      return;
-   case MESA_FORMAT_SIGNED_RGB_16:
-      *datatype = GL_SHORT;
-      *comps = 3;
-      return;
-   case MESA_FORMAT_SIGNED_RGBA_16:
-      *datatype = GL_SHORT;
-      *comps = 4;
-      return;
-
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 3;
-      return;
-   case MESA_FORMAT_SRGBA8:
-   case MESA_FORMAT_SARGB8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_SL8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 1;
-      return;
-   case MESA_FORMAT_SLA8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 2;
-      return;
-#endif
-
-#if FEATURE_texture_fxt1
-   case MESA_FORMAT_RGB_FXT1:
-   case MESA_FORMAT_RGBA_FXT1:
-#endif
-#if FEATURE_texture_s3tc
-   case MESA_FORMAT_RGB_DXT1:
-   case MESA_FORMAT_RGBA_DXT1:
-   case MESA_FORMAT_RGBA_DXT3:
-   case MESA_FORMAT_RGBA_DXT5:
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB_DXT1:
-   case MESA_FORMAT_SRGBA_DXT1:
-   case MESA_FORMAT_SRGBA_DXT3:
-   case MESA_FORMAT_SRGBA_DXT5:
-#endif
-#endif
-   case MESA_FORMAT_RED_RGTC1:
-   case MESA_FORMAT_SIGNED_RED_RGTC1:
-   case MESA_FORMAT_RG_RGTC2:
-   case MESA_FORMAT_SIGNED_RG_RGTC2:
-   case MESA_FORMAT_L_LATC1:
-   case MESA_FORMAT_SIGNED_L_LATC1:
-   case MESA_FORMAT_LA_LATC2:
-   case MESA_FORMAT_SIGNED_LA_LATC2:
-      /* XXX generate error instead? */
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 0;
-      return;
-
-   case MESA_FORMAT_RGBA_FLOAT32:
-      *datatype = GL_FLOAT;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGBA_FLOAT16:
-      *datatype = GL_HALF_FLOAT_ARB;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGB_FLOAT32:
-      *datatype = GL_FLOAT;
-      *comps = 3;
-      return;
-   case MESA_FORMAT_RGB_FLOAT16:
-      *datatype = GL_HALF_FLOAT_ARB;
-      *comps = 3;
-      return;
-   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
-      *datatype = GL_FLOAT;
-      *comps = 2;
-      return;
-   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
-      *datatype = GL_HALF_FLOAT_ARB;
-      *comps = 2;
-      return;
-   case MESA_FORMAT_ALPHA_FLOAT32:
-   case MESA_FORMAT_LUMINANCE_FLOAT32:
-   case MESA_FORMAT_INTENSITY_FLOAT32:
-      *datatype = GL_FLOAT;
-      *comps = 1;
-      return;
-   case MESA_FORMAT_ALPHA_FLOAT16:
-   case MESA_FORMAT_LUMINANCE_FLOAT16:
-   case MESA_FORMAT_INTENSITY_FLOAT16:
-      *datatype = GL_HALF_FLOAT_ARB;
-      *comps = 1;
-      return;
-
-   case MESA_FORMAT_RGBA_INT8:
-      *datatype = GL_BYTE;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGBA_INT16:
-      *datatype = GL_SHORT;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGBA_INT32:
-      *datatype = GL_INT;
-      *comps = 4;
-      return;
-
-   /**
-    * \name Non-normalized unsigned integer formats.
-    */
-   case MESA_FORMAT_RGBA_UINT8:
-      *datatype = GL_UNSIGNED_BYTE;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGBA_UINT16:
-      *datatype = GL_UNSIGNED_SHORT;
-      *comps = 4;
-      return;
-   case MESA_FORMAT_RGBA_UINT32:
-      *datatype = GL_UNSIGNED_INT;
-      *comps = 4;
-      return;
-
-   case MESA_FORMAT_COUNT:
-      assert(0);
-      return;
-
-   case MESA_FORMAT_NONE:
-   /* For debug builds, warn if any formats are not handled */
-#ifdef DEBUG
-   default:
-#endif
-      _mesa_problem(NULL, "bad format %s in _mesa_format_to_type_and_comps",
-                    _mesa_get_format_name(format));
-      *datatype = 0;
-      *comps = 1;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008-2009  VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "imports.h"

+#include "formats.h"

+#include "mfeatures.h"

+

+

+/**

+ * Information about texture formats.

+ */

+struct gl_format_info

+{

+   gl_format Name;

+

+   /** text name for debugging */

+   const char *StrName;

+

+   /**

+    * Base format is one of GL_RED, GL_RG, GL_RGB, GL_RGBA, GL_ALPHA,

+    * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_YCBCR_MESA,

+    * GL_COLOR_INDEX, GL_DEPTH_COMPONENT, GL_STENCIL_INDEX,

+    * GL_DEPTH_STENCIL, GL_DUDV_ATI.

+    */

+   GLenum BaseFormat;

+

+   /**

+    * Logical data type: one of  GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALED,

+    * GL_UNSIGNED_INT, GL_INT, GL_FLOAT.

+    */

+   GLenum DataType;

+

+   GLubyte RedBits;

+   GLubyte GreenBits;

+   GLubyte BlueBits;

+   GLubyte AlphaBits;

+   GLubyte LuminanceBits;

+   GLubyte IntensityBits;

+   GLubyte IndexBits;

+   GLubyte DepthBits;

+   GLubyte StencilBits;

+

+   /**

+    * To describe compressed formats.  If not compressed, Width=Height=1.

+    */

+   GLubyte BlockWidth, BlockHeight;

+   GLubyte BytesPerBlock;

+};

+

+

+/**

+ * Info about each format.

+ * These must be in the same order as the MESA_FORMAT_* enums so that

+ * we can do lookups without searching.

+ */

+static struct gl_format_info format_info[MESA_FORMAT_COUNT] =

+{

+   {

+      MESA_FORMAT_NONE,            /* Name */

+      "MESA_FORMAT_NONE",          /* StrName */

+      GL_NONE,                     /* BaseFormat */

+      GL_NONE,                     /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      0, 0, 0                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGBA8888,        /* Name */

+      "MESA_FORMAT_RGBA8888",      /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGBA8888_REV,    /* Name */

+      "MESA_FORMAT_RGBA8888_REV",  /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB8888,        /* Name */

+      "MESA_FORMAT_ARGB8888",      /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB8888_REV,    /* Name */

+      "MESA_FORMAT_ARGB8888_REV",  /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 8,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_XRGB8888,        /* Name */

+      "MESA_FORMAT_XRGB8888",      /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_XRGB8888_REV,    /* Name */

+      "MESA_FORMAT_XRGB8888_REV",  /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGB888,          /* Name */

+      "MESA_FORMAT_RGB888",        /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 3                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_BGR888,          /* Name */

+      "MESA_FORMAT_BGR888",        /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      8, 8, 8, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 3                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGB565,          /* Name */

+      "MESA_FORMAT_RGB565",        /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      5, 6, 5, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGB565_REV,      /* Name */

+      "MESA_FORMAT_RGB565_REV",    /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      5, 6, 5, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB4444,        /* Name */

+      "MESA_FORMAT_ARGB4444",      /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      4, 4, 4, 4,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB4444_REV,    /* Name */

+      "MESA_FORMAT_ARGB4444_REV",  /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      4, 4, 4, 4,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGBA5551,        /* Name */

+      "MESA_FORMAT_RGBA5551",      /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB1555,        /* Name */

+      "MESA_FORMAT_ARGB1555",      /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_ARGB1555_REV,    /* Name */

+      "MESA_FORMAT_ARGB1555_REV",  /* StrName */

+      GL_RGBA,                     /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      5, 5, 5, 1,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_AL44,            /* Name */

+      "MESA_FORMAT_AL44",          /* StrName */

+      GL_LUMINANCE_ALPHA,          /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 4,                  /* Red/Green/Blue/AlphaBits */

+      4, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_AL88,            /* Name */

+      "MESA_FORMAT_AL88",          /* StrName */

+      GL_LUMINANCE_ALPHA,          /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */

+      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_AL88_REV,        /* Name */

+      "MESA_FORMAT_AL88_REV",      /* StrName */

+      GL_LUMINANCE_ALPHA,          /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */

+      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_AL1616,          /* Name */

+      "MESA_FORMAT_AL1616",        /* StrName */

+      GL_LUMINANCE_ALPHA,          /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */

+      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_AL1616_REV,      /* Name */

+      "MESA_FORMAT_AL1616_REV",    /* StrName */

+      GL_LUMINANCE_ALPHA,          /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */

+      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_RGB332,          /* Name */

+      "MESA_FORMAT_RGB332",        /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      3, 3, 2, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_A8,              /* Name */

+      "MESA_FORMAT_A8",            /* StrName */

+      GL_ALPHA,                    /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 8,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_A16,             /* Name */

+      "MESA_FORMAT_A16",           /* StrName */

+      GL_ALPHA,                    /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 16,                 /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_L8,              /* Name */

+      "MESA_FORMAT_L8",            /* StrName */

+      GL_LUMINANCE,                /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      8, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_L16,             /* Name */

+      "MESA_FORMAT_L16",           /* StrName */

+      GL_LUMINANCE,                /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      16, 0, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_I8,              /* Name */

+      "MESA_FORMAT_I8",            /* StrName */

+      GL_INTENSITY,                /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 8, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_I16,             /* Name */

+      "MESA_FORMAT_I16",           /* StrName */

+      GL_INTENSITY,                /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 16, 0, 0, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_CI8,             /* Name */

+      "MESA_FORMAT_CI8",           /* StrName */

+      GL_COLOR_INDEX,              /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 8, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_YCBCR,           /* Name */

+      "MESA_FORMAT_YCBCR",         /* StrName */

+      GL_YCBCR_MESA,               /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_YCBCR_REV,       /* Name */

+      "MESA_FORMAT_YCBCR_REV",     /* StrName */

+      GL_YCBCR_MESA,               /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_R8,

+      "MESA_FORMAT_R8",

+      GL_RED,

+      GL_UNSIGNED_NORMALIZED,

+      8, 0, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 1

+   },

+   {

+      MESA_FORMAT_RG88,

+      "MESA_FORMAT_RG88",

+      GL_RG,

+      GL_UNSIGNED_NORMALIZED,

+      8, 8, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_RG88_REV,

+      "MESA_FORMAT_RG88_REV",

+      GL_RG,

+      GL_UNSIGNED_NORMALIZED,

+      8, 8, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_R16,

+      "MESA_FORMAT_R16",

+      GL_RED,

+      GL_UNSIGNED_NORMALIZED,

+      16, 0, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_RG1616,

+      "MESA_FORMAT_RG1616",

+      GL_RG,

+      GL_UNSIGNED_NORMALIZED,

+      16, 16, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_RG1616_REV,

+      "MESA_FORMAT_RG1616_REV",

+      GL_RG,

+      GL_UNSIGNED_NORMALIZED,

+      16, 16, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_ARGB2101010,

+      "MESA_FORMAT_ARGB2101010",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      10, 10, 10, 2,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_Z24_S8,          /* Name */

+      "MESA_FORMAT_Z24_S8",        /* StrName */

+      GL_DEPTH_STENCIL,            /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 24, 8,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_S8_Z24,          /* Name */

+      "MESA_FORMAT_S8_Z24",        /* StrName */

+      GL_DEPTH_STENCIL,            /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 24, 8,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_Z16,             /* Name */

+      "MESA_FORMAT_Z16",           /* StrName */

+      GL_DEPTH_COMPONENT,          /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 16, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 2                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_X8_Z24,          /* Name */

+      "MESA_FORMAT_X8_Z24",        /* StrName */

+      GL_DEPTH_COMPONENT,          /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 24, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_Z24_X8,          /* Name */

+      "MESA_FORMAT_Z24_X8",        /* StrName */

+      GL_DEPTH_COMPONENT,          /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 24, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_Z32,             /* Name */

+      "MESA_FORMAT_Z32",           /* StrName */

+      GL_DEPTH_COMPONENT,          /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 32, 0,              /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 4                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_S8,              /* Name */

+      "MESA_FORMAT_S8",            /* StrName */

+      GL_STENCIL_INDEX,            /* BaseFormat */

+      GL_UNSIGNED_INT,             /* DataType */

+      0, 0, 0, 0,                  /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 8,               /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                      /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_SRGB8,

+      "MESA_FORMAT_SRGB8",

+      GL_RGB,

+      GL_UNSIGNED_NORMALIZED,

+      8, 8, 8, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 3

+   },

+   {

+      MESA_FORMAT_SRGBA8,

+      "MESA_FORMAT_SRGBA8",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,    

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_SARGB8,

+      "MESA_FORMAT_SARGB8",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,    

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_SL8,

+      "MESA_FORMAT_SL8",

+      GL_LUMINANCE,

+      GL_UNSIGNED_NORMALIZED,    

+      0, 0, 0, 0,

+      8, 0, 0, 0, 0,

+      1, 1, 1

+   },

+   {

+      MESA_FORMAT_SLA8,

+      "MESA_FORMAT_SLA8",

+      GL_LUMINANCE_ALPHA,

+      GL_UNSIGNED_NORMALIZED,    

+      0, 0, 0, 8,

+      8, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_SRGB_DXT1,       /* Name */

+      "MESA_FORMAT_SRGB_DXT1",     /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      4, 4, 4, 0,                  /* approx Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      4, 4, 8                      /* 8 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT1,

+      "MESA_FORMAT_SRGBA_DXT1",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 8                      /* 8 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT3,

+      "MESA_FORMAT_SRGBA_DXT3",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT5,

+      "MESA_FORMAT_SRGBA_DXT5",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+

+   {

+      MESA_FORMAT_RGB_FXT1,

+      "MESA_FORMAT_RGB_FXT1",

+      GL_RGB,

+      GL_UNSIGNED_NORMALIZED,

+      4, 4, 4, 0,                  /* approx Red/Green/BlueBits */

+      0, 0, 0, 0, 0,

+      8, 4, 16                     /* 16 bytes per 8x4 block */

+   },

+   {

+      MESA_FORMAT_RGBA_FXT1,

+      "MESA_FORMAT_RGBA_FXT1",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      4, 4, 4, 1,                  /* approx Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,

+      8, 4, 16                     /* 16 bytes per 8x4 block */

+   },

+

+   {

+      MESA_FORMAT_RGB_DXT1,        /* Name */

+      "MESA_FORMAT_RGB_DXT1",      /* StrName */

+      GL_RGB,                      /* BaseFormat */

+      GL_UNSIGNED_NORMALIZED,      /* DataType */

+      4, 4, 4, 0,                  /* approx Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,               /* Lum/Int/Index/Depth/StencilBits */

+      4, 4, 8                      /* 8 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_RGBA_DXT1,

+      "MESA_FORMAT_RGBA_DXT1",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,    

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 8                      /* 8 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_RGBA_DXT3,

+      "MESA_FORMAT_RGBA_DXT3",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,    

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_RGBA_DXT5,

+      "MESA_FORMAT_RGBA_DXT5",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,    

+      4, 4, 4, 4,

+      0, 0, 0, 0, 0,

+      4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+      MESA_FORMAT_RGBA_FLOAT32,

+      "MESA_FORMAT_RGBA_FLOAT32",

+      GL_RGBA,

+      GL_FLOAT,

+      32, 32, 32, 32,

+      0, 0, 0, 0, 0,

+      1, 1, 16

+   },

+   {

+      MESA_FORMAT_RGBA_FLOAT16,

+      "MESA_FORMAT_RGBA_FLOAT16",

+      GL_RGBA,

+      GL_FLOAT,

+      16, 16, 16, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+      MESA_FORMAT_RGB_FLOAT32,

+      "MESA_FORMAT_RGB_FLOAT32",

+      GL_RGB,

+      GL_FLOAT,

+      32, 32, 32, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 12

+   },

+   {

+      MESA_FORMAT_RGB_FLOAT16,

+      "MESA_FORMAT_RGB_FLOAT16",

+      GL_RGB,

+      GL_FLOAT,

+      16, 16, 16, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 6

+   },

+   {

+      MESA_FORMAT_ALPHA_FLOAT32,

+      "MESA_FORMAT_ALPHA_FLOAT32",

+      GL_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 32,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_ALPHA_FLOAT16,

+      "MESA_FORMAT_ALPHA_FLOAT16",

+      GL_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_LUMINANCE_FLOAT32,

+      "MESA_FORMAT_LUMINANCE_FLOAT32",

+      GL_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 0,

+      32, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_LUMINANCE_FLOAT16,

+      "MESA_FORMAT_LUMINANCE_FLOAT16",

+      GL_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 0,

+      16, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,

+      "MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32",

+      GL_LUMINANCE_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 32,

+      32, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,

+      "MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16",

+      GL_LUMINANCE_ALPHA,

+      GL_FLOAT,

+      0, 0, 0, 16,

+      16, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_INTENSITY_FLOAT32,

+      "MESA_FORMAT_INTENSITY_FLOAT32",

+      GL_INTENSITY,

+      GL_FLOAT,

+      0, 0, 0, 0,

+      0, 32, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_INTENSITY_FLOAT16,

+      "MESA_FORMAT_INTENSITY_FLOAT16",

+      GL_INTENSITY,

+      GL_FLOAT,

+      0, 0, 0, 0,

+      0, 16, 0, 0, 0,

+      1, 1, 2

+   },

+

+   /* unnormalized signed int formats */

+   {

+      MESA_FORMAT_RGBA_INT8,

+      "MESA_FORMAT_RGBA_INT8",

+      GL_RGBA,

+      GL_INT,

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_RGBA_INT16,

+      "MESA_FORMAT_RGBA_INT16",

+      GL_RGBA,

+      GL_INT,

+      16, 16, 16, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+      MESA_FORMAT_RGBA_INT32,

+      "MESA_FORMAT_RGBA_INT32",

+      GL_RGBA,

+      GL_INT,

+      32, 32, 32, 32,

+      0, 0, 0, 0, 0,

+      1, 1, 16

+   },

+

+   /* unnormalized unsigned int formats */

+   {

+      MESA_FORMAT_RGBA_UINT8,

+      "MESA_FORMAT_RGBA_UINT8",

+      GL_RGBA,

+      GL_UNSIGNED_INT,

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_RGBA_UINT16,

+      "MESA_FORMAT_RGBA_UINT16",

+      GL_RGBA,

+      GL_UNSIGNED_INT,

+      16, 16, 16, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+      MESA_FORMAT_RGBA_UINT32,

+      "MESA_FORMAT_RGBA_UINT32",

+      GL_RGBA,

+      GL_UNSIGNED_INT,

+      32, 32, 32, 32,

+      0, 0, 0, 0, 0,

+      1, 1, 16

+   },

+

+

+   {

+      MESA_FORMAT_DUDV8,

+      "MESA_FORMAT_DUDV8",

+      GL_DUDV_ATI,

+      GL_SIGNED_NORMALIZED,

+      0, 0, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+

+   /* Signed 8 bits / channel */

+   {

+      MESA_FORMAT_SIGNED_R8,        /* Name */

+      "MESA_FORMAT_SIGNED_R8",      /* StrName */

+      GL_RED,                       /* BaseFormat */

+      GL_SIGNED_NORMALIZED,         /* DataType */

+      8, 0, 0, 0,                   /* Red/Green/Blue/AlphaBits */

+      0, 0, 0, 0, 0,                /* Lum/Int/Index/Depth/StencilBits */

+      1, 1, 1                       /* BlockWidth/Height,Bytes */

+   },

+   {

+      MESA_FORMAT_SIGNED_RG88,

+      "MESA_FORMAT_SIGNED_RG88",

+      GL_RG,

+      GL_SIGNED_NORMALIZED,

+      8, 8, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBX8888,

+      "MESA_FORMAT_SIGNED_RGBX8888",

+      GL_RGB,

+      GL_SIGNED_NORMALIZED,

+      8, 8, 8, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 4                       /* 4 bpp, but no alpha */

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA8888,

+      "MESA_FORMAT_SIGNED_RGBA8888",

+      GL_RGBA,

+      GL_SIGNED_NORMALIZED,

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA8888_REV,

+      "MESA_FORMAT_SIGNED_RGBA8888_REV",

+      GL_RGBA,

+      GL_SIGNED_NORMALIZED,

+      8, 8, 8, 8,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+

+   /* Signed 16 bits / channel */

+   {

+      MESA_FORMAT_SIGNED_R_16,

+      "MESA_FORMAT_SIGNED_R_16",

+      GL_RED,

+      GL_SIGNED_NORMALIZED,

+      16, 0, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 2

+   },

+   {

+      MESA_FORMAT_SIGNED_RG_16,

+      "MESA_FORMAT_SIGNED_RG_16",

+      GL_RG,

+      GL_SIGNED_NORMALIZED,

+      16, 16, 0, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 4

+   },

+   {

+      MESA_FORMAT_SIGNED_RGB_16,

+      "MESA_FORMAT_SIGNED_RGB_16",

+      GL_RGB,

+      GL_SIGNED_NORMALIZED,

+      16, 16, 16, 0,

+      0, 0, 0, 0, 0,

+      1, 1, 6

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA_16,

+      "MESA_FORMAT_SIGNED_RGBA_16",

+      GL_RGBA,

+      GL_SIGNED_NORMALIZED,

+      16, 16, 16, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+      MESA_FORMAT_RGBA_16,

+      "MESA_FORMAT_RGBA_16",

+      GL_RGBA,

+      GL_UNSIGNED_NORMALIZED,

+      16, 16, 16, 16,

+      0, 0, 0, 0, 0,

+      1, 1, 8

+   },

+   {

+     MESA_FORMAT_RED_RGTC1,

+     "MESA_FORMAT_RED_RGTC1",

+     GL_RED,

+     GL_UNSIGNED_NORMALIZED,

+     4, 0, 0, 0,

+     0, 0, 0, 0, 0,

+     4, 4, 8                     /* 8 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_SIGNED_RED_RGTC1,

+     "MESA_FORMAT_SIGNED_RED_RGTC1",

+     GL_RED,

+     GL_SIGNED_NORMALIZED,

+     4, 0, 0, 0,

+     0, 0, 0, 0, 0,

+     4, 4, 8                     /* 8 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_RG_RGTC2,

+     "MESA_FORMAT_RG_RGTC2",

+     GL_RG,

+     GL_UNSIGNED_NORMALIZED,

+     4, 4, 0, 0,

+     0, 0, 0, 0, 0,

+     4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_SIGNED_RG_RGTC2,

+     "MESA_FORMAT_SIGNED_RG_RGTC2",

+     GL_RG,

+     GL_SIGNED_NORMALIZED,

+     4, 4, 0, 0,

+     0, 0, 0, 0, 0,

+     4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_L_LATC1,

+     "MESA_FORMAT_L_LATC1",

+     GL_LUMINANCE,

+     GL_UNSIGNED_NORMALIZED,

+     0, 0, 0, 0,

+     4, 0, 0, 0, 0,

+     4, 4, 8                     /* 8 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_SIGNED_L_LATC1,

+     "MESA_FORMAT_SIGNED_L_LATC1",

+     GL_LUMINANCE,

+     GL_SIGNED_NORMALIZED,

+     0, 0, 0, 0,

+     4, 0, 0, 0, 0,

+     4, 4, 8                     /* 8 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_LA_LATC2,

+     "MESA_FORMAT_LA_LATC2",

+     GL_LUMINANCE_ALPHA,

+     GL_UNSIGNED_NORMALIZED,

+     0, 0, 0, 4,

+     4, 0, 0, 0, 0,

+     4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+   {

+     MESA_FORMAT_SIGNED_LA_LATC2,

+     "MESA_FORMAT_SIGNED_LA_LATC2",

+     GL_LUMINANCE_ALPHA,

+     GL_SIGNED_NORMALIZED,

+     0, 0, 0, 4,

+     4, 0, 0, 0, 0,

+     4, 4, 16                     /* 16 bytes per 4x4 block */

+   },

+};

+

+

+

+static const struct gl_format_info *

+_mesa_get_format_info(gl_format format)

+{

+   const struct gl_format_info *info = &format_info[format];

+   assert(info->Name == format);

+   return info;

+}

+

+

+/** Return string name of format (for debugging) */

+const char *

+_mesa_get_format_name(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   return info->StrName;

+}

+

+

+

+/**

+ * Return bytes needed to store a block of pixels in the given format.

+ * Normally, a block is 1x1 (a single pixel).  But for compressed formats

+ * a block may be 4x4 or 8x4, etc.

+ */

+GLuint

+_mesa_get_format_bytes(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   ASSERT(info->BytesPerBlock);

+   return info->BytesPerBlock;

+}

+

+

+/**

+ * Return bits per component for the given format.

+ * \param format  one of MESA_FORMAT_x

+ * \param pname  the component, such as GL_RED_BITS, GL_TEXTURE_BLUE_BITS, etc.

+ */

+GLint

+_mesa_get_format_bits(gl_format format, GLenum pname)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+

+   switch (pname) {

+   case GL_RED_BITS:

+   case GL_TEXTURE_RED_SIZE:

+   case GL_RENDERBUFFER_RED_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:

+      return info->RedBits;

+   case GL_GREEN_BITS:

+   case GL_TEXTURE_GREEN_SIZE:

+   case GL_RENDERBUFFER_GREEN_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:

+      return info->GreenBits;

+   case GL_BLUE_BITS:

+   case GL_TEXTURE_BLUE_SIZE:

+   case GL_RENDERBUFFER_BLUE_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:

+      return info->BlueBits;

+   case GL_ALPHA_BITS:

+   case GL_TEXTURE_ALPHA_SIZE:

+   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:

+      return info->AlphaBits;

+   case GL_TEXTURE_INTENSITY_SIZE:

+      return info->IntensityBits;

+   case GL_TEXTURE_LUMINANCE_SIZE:

+      return info->LuminanceBits;

+   case GL_INDEX_BITS:

+   case GL_TEXTURE_INDEX_SIZE_EXT:

+      return info->IndexBits;

+   case GL_DEPTH_BITS:

+   case GL_TEXTURE_DEPTH_SIZE_ARB:

+   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:

+      return info->DepthBits;

+   case GL_STENCIL_BITS:

+   case GL_TEXTURE_STENCIL_SIZE_EXT:

+   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:

+   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:

+      return info->StencilBits;

+   default:

+      _mesa_problem(NULL, "bad pname in _mesa_get_format_bits()");

+      return 0;

+   }

+}

+

+

+/**

+ * Return the data type (or more specifically, the data representation)

+ * for the given format.

+ * The return value will be one of:

+ *    GL_UNSIGNED_NORMALIZED = unsigned int representing [0,1]

+ *    GL_SIGNED_NORMALIZED = signed int representing [-1, 1]

+ *    GL_UNSIGNED_INT = an ordinary unsigned integer

+ *    GL_INT = an ordinary signed integer

+ *    GL_FLOAT = an ordinary float

+ */

+GLenum

+_mesa_get_format_datatype(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   return info->DataType;

+}

+

+

+/**

+ * Return the basic format for the given type.  The result will be

+ * one of GL_RGB, GL_RGBA, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA,

+ * GL_INTENSITY, GL_YCBCR_MESA, GL_COLOR_INDEX, GL_DEPTH_COMPONENT,

+ * GL_STENCIL_INDEX, GL_DEPTH_STENCIL.

+ */

+GLenum

+_mesa_get_format_base_format(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   return info->BaseFormat;

+}

+

+

+/**

+ * Return the block size (in pixels) for the given format.  Normally

+ * the block size is 1x1.  But compressed formats will have block sizes

+ * of 4x4 or 8x4 pixels, etc.

+ * \param bw  returns block width in pixels

+ * \param bh  returns block height in pixels

+ */

+void

+_mesa_get_format_block_size(gl_format format, GLuint *bw, GLuint *bh)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   *bw = info->BlockWidth;

+   *bh = info->BlockHeight;

+}

+

+

+/** Is the given format a compressed format? */

+GLboolean

+_mesa_is_format_compressed(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   return info->BlockWidth > 1 || info->BlockHeight > 1;

+}

+

+

+/**

+ * Determine if the given format represents a packed depth/stencil buffer.

+ */

+GLboolean

+_mesa_is_format_packed_depth_stencil(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+

+   return info->BaseFormat == GL_DEPTH_STENCIL;

+}

+

+

+/**

+ * Is the given format a signed/unsigned integer color format?

+ */

+GLboolean

+_mesa_is_format_integer_color(gl_format format)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT) &&

+      info->BaseFormat != GL_DEPTH_COMPONENT &&

+      info->BaseFormat != GL_DEPTH_STENCIL &&

+      info->BaseFormat != GL_STENCIL_INDEX;

+}

+

+

+/**

+ * Return color encoding for given format.

+ * \return GL_LINEAR or GL_SRGB

+ */

+GLenum

+_mesa_get_format_color_encoding(gl_format format)

+{

+   /* XXX this info should be encoded in gl_format_info */

+   switch (format) {

+   case MESA_FORMAT_SRGB8:

+   case MESA_FORMAT_SRGBA8:

+   case MESA_FORMAT_SARGB8:

+   case MESA_FORMAT_SL8:

+   case MESA_FORMAT_SLA8:

+   case MESA_FORMAT_SRGB_DXT1:

+   case MESA_FORMAT_SRGBA_DXT1:

+   case MESA_FORMAT_SRGBA_DXT3:

+   case MESA_FORMAT_SRGBA_DXT5:

+      return GL_SRGB;

+   default:

+      return GL_LINEAR;

+   }

+}

+

+

+/**

+ * For an sRGB format, return the corresponding linear color space format.

+ * For non-sRGB formats, return the format as-is.

+ */

+gl_format

+_mesa_get_srgb_format_linear(gl_format format)

+{

+   switch (format) {

+   case MESA_FORMAT_SRGB8:

+      format = MESA_FORMAT_RGB888;

+      break;

+   case MESA_FORMAT_SRGBA8:

+      format = MESA_FORMAT_RGBA8888;

+      break;

+   case MESA_FORMAT_SARGB8:

+      format = MESA_FORMAT_ARGB8888;

+      break;

+   case MESA_FORMAT_SL8:

+      format = MESA_FORMAT_L8;

+      break;

+   case MESA_FORMAT_SLA8:

+      format = MESA_FORMAT_AL88;

+      break;

+   case MESA_FORMAT_SRGB_DXT1:

+      format = MESA_FORMAT_RGB_DXT1;

+      break;

+   case MESA_FORMAT_SRGBA_DXT1:

+      format = MESA_FORMAT_RGBA_DXT1;

+      break;

+   case MESA_FORMAT_SRGBA_DXT3:

+      format = MESA_FORMAT_RGBA_DXT3;

+      break;

+   case MESA_FORMAT_SRGBA_DXT5:

+      format = MESA_FORMAT_RGBA_DXT5;

+      break;

+   default:

+      break;

+   }

+   return format;

+}

+

+

+/**

+ * Return number of bytes needed to store an image of the given size

+ * in the given format.

+ */

+GLuint

+_mesa_format_image_size(gl_format format, GLsizei width,

+                        GLsizei height, GLsizei depth)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   /* Strictly speaking, a conditional isn't needed here */

+   if (info->BlockWidth > 1 || info->BlockHeight > 1) {

+      /* compressed format (2D only for now) */

+      const GLuint bw = info->BlockWidth, bh = info->BlockHeight;

+      const GLuint wblocks = (width + bw - 1) / bw;

+      const GLuint hblocks = (height + bh - 1) / bh;

+      const GLuint sz = wblocks * hblocks * info->BytesPerBlock;

+      assert(depth == 1);

+      return sz;

+   }

+   else {

+      /* non-compressed */

+      const GLuint sz = width * height * depth * info->BytesPerBlock;

+      return sz;

+   }

+}

+

+

+/**

+ * Same as _mesa_format_image_size() but returns a 64-bit value to

+ * accomodate very large textures.

+ */

+uint64_t

+_mesa_format_image_size64(gl_format format, GLsizei width,

+                          GLsizei height, GLsizei depth)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   /* Strictly speaking, a conditional isn't needed here */

+   if (info->BlockWidth > 1 || info->BlockHeight > 1) {

+      /* compressed format (2D only for now) */

+      const uint64_t bw = info->BlockWidth, bh = info->BlockHeight;

+      const uint64_t wblocks = (width + bw - 1) / bw;

+      const uint64_t hblocks = (height + bh - 1) / bh;

+      const uint64_t sz = wblocks * hblocks * info->BytesPerBlock;

+      assert(depth == 1);

+      return sz;

+   }

+   else {

+      /* non-compressed */

+      const uint64_t sz = ((uint64_t) width *

+                           (uint64_t) height *

+                           (uint64_t) depth *

+                           info->BytesPerBlock);

+      return sz;

+   }

+}

+

+

+

+GLint

+_mesa_format_row_stride(gl_format format, GLsizei width)

+{

+   const struct gl_format_info *info = _mesa_get_format_info(format);

+   /* Strictly speaking, a conditional isn't needed here */

+   if (info->BlockWidth > 1 || info->BlockHeight > 1) {

+      /* compressed format */

+      const GLuint bw = info->BlockWidth;

+      const GLuint wblocks = (width + bw - 1) / bw;

+      const GLint stride = wblocks * info->BytesPerBlock;

+      return stride;

+   }

+   else {

+      const GLint stride = width * info->BytesPerBlock;

+      return stride;

+   }

+}

+

+

+/**

+ * Debug/test: check that all formats are handled in the

+ * _mesa_format_to_type_and_comps() function.  When new pixel formats

+ * are added to Mesa, that function needs to be updated.

+ * This is a no-op after the first call.

+ */

+static void

+check_format_to_type_and_comps(void)

+{

+   gl_format f;

+

+   for (f = MESA_FORMAT_NONE + 1; f < MESA_FORMAT_COUNT; f++) {

+      GLenum datatype = 0;

+      GLuint comps = 0;

+      /* This function will emit a problem/warning if the format is

+       * not handled.

+       */

+      _mesa_format_to_type_and_comps(f, &datatype, &comps);

+   }

+}

+

+

+/**

+ * Do sanity checking of the format info table.

+ */

+void

+_mesa_test_formats(void)

+{

+   GLuint i;

+

+   assert(Elements(format_info) == MESA_FORMAT_COUNT);

+

+   for (i = 0; i < MESA_FORMAT_COUNT; i++) {

+      const struct gl_format_info *info = _mesa_get_format_info(i);

+      assert(info);

+

+      assert(info->Name == i);

+

+      if (info->Name == MESA_FORMAT_NONE)

+         continue;

+

+      if (info->BlockWidth == 1 && info->BlockHeight == 1) {

+         if (info->RedBits > 0) {

+            GLuint t = info->RedBits + info->GreenBits

+               + info->BlueBits + info->AlphaBits;

+            assert(t / 8 <= info->BytesPerBlock);

+            (void) t;

+         }

+      }

+

+      assert(info->DataType == GL_UNSIGNED_NORMALIZED ||

+             info->DataType == GL_SIGNED_NORMALIZED ||

+             info->DataType == GL_UNSIGNED_INT ||

+             info->DataType == GL_INT ||

+             info->DataType == GL_FLOAT);

+

+      if (info->BaseFormat == GL_RGB) {

+         assert(info->RedBits > 0);

+         assert(info->GreenBits > 0);

+         assert(info->BlueBits > 0);

+         assert(info->AlphaBits == 0);

+         assert(info->LuminanceBits == 0);

+         assert(info->IntensityBits == 0);

+      }

+      else if (info->BaseFormat == GL_RGBA) {

+         assert(info->RedBits > 0);

+         assert(info->GreenBits > 0);

+         assert(info->BlueBits > 0);

+         assert(info->AlphaBits > 0);

+         assert(info->LuminanceBits == 0);

+         assert(info->IntensityBits == 0);

+      }

+      else if (info->BaseFormat == GL_RG) {

+         assert(info->RedBits > 0);

+         assert(info->GreenBits > 0);

+         assert(info->BlueBits == 0);

+         assert(info->AlphaBits == 0);

+         assert(info->LuminanceBits == 0);

+         assert(info->IntensityBits == 0);

+      }

+      else if (info->BaseFormat == GL_RED) {

+         assert(info->RedBits > 0);

+         assert(info->GreenBits == 0);

+         assert(info->BlueBits == 0);

+         assert(info->AlphaBits == 0);

+         assert(info->LuminanceBits == 0);

+         assert(info->IntensityBits == 0);

+      }

+      else if (info->BaseFormat == GL_LUMINANCE) {

+         assert(info->RedBits == 0);

+         assert(info->GreenBits == 0);

+         assert(info->BlueBits == 0);

+         assert(info->AlphaBits == 0);

+         assert(info->LuminanceBits > 0);

+         assert(info->IntensityBits == 0);

+      }

+      else if (info->BaseFormat == GL_INTENSITY) {

+         assert(info->RedBits == 0);

+         assert(info->GreenBits == 0);

+         assert(info->BlueBits == 0);

+         assert(info->AlphaBits == 0);

+         assert(info->LuminanceBits == 0);

+         assert(info->IntensityBits > 0);

+      }

+   }

+

+   check_format_to_type_and_comps();

+}

+

+

+

+/**

+ * Return datatype and number of components per texel for the given gl_format.

+ * Only used for mipmap generation code.

+ */

+void

+_mesa_format_to_type_and_comps(gl_format format,

+                               GLenum *datatype, GLuint *comps)

+{

+   switch (format) {

+   case MESA_FORMAT_RGBA8888:

+   case MESA_FORMAT_RGBA8888_REV:

+   case MESA_FORMAT_ARGB8888:

+   case MESA_FORMAT_ARGB8888_REV:

+   case MESA_FORMAT_XRGB8888:

+   case MESA_FORMAT_XRGB8888_REV:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGB888:

+   case MESA_FORMAT_BGR888:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 3;

+      return;

+   case MESA_FORMAT_RGB565:

+   case MESA_FORMAT_RGB565_REV:

+      *datatype = GL_UNSIGNED_SHORT_5_6_5;

+      *comps = 3;

+      return;

+

+   case MESA_FORMAT_ARGB4444:

+   case MESA_FORMAT_ARGB4444_REV:

+      *datatype = GL_UNSIGNED_SHORT_4_4_4_4;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_ARGB1555:

+   case MESA_FORMAT_ARGB1555_REV:

+      *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_ARGB2101010:

+      *datatype = GL_UNSIGNED_INT_2_10_10_10_REV;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_RGBA5551:

+      *datatype = GL_UNSIGNED_SHORT_5_5_5_1;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_AL44:

+      *datatype = MESA_UNSIGNED_BYTE_4_4;

+      *comps = 2;

+      return;

+

+   case MESA_FORMAT_AL88:

+   case MESA_FORMAT_AL88_REV:

+   case MESA_FORMAT_RG88:

+   case MESA_FORMAT_RG88_REV:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 2;

+      return;

+

+   case MESA_FORMAT_AL1616:

+   case MESA_FORMAT_AL1616_REV:

+   case MESA_FORMAT_RG1616:

+   case MESA_FORMAT_RG1616_REV:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 2;

+      return;

+

+   case MESA_FORMAT_R16:

+   case MESA_FORMAT_A16:

+   case MESA_FORMAT_L16:

+   case MESA_FORMAT_I16:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_RGB332:

+      *datatype = GL_UNSIGNED_BYTE_3_3_2;

+      *comps = 3;

+      return;

+

+   case MESA_FORMAT_A8:

+   case MESA_FORMAT_L8:

+   case MESA_FORMAT_I8:

+   case MESA_FORMAT_CI8:

+   case MESA_FORMAT_R8:

+   case MESA_FORMAT_S8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_YCBCR:

+   case MESA_FORMAT_YCBCR_REV:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 2;

+      return;

+

+   case MESA_FORMAT_Z24_S8:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 1; /* XXX OK? */

+      return;

+

+   case MESA_FORMAT_S8_Z24:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 1; /* XXX OK? */

+      return;

+

+   case MESA_FORMAT_Z16:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_X8_Z24:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_Z24_X8:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_Z32:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_DUDV8:

+      *datatype = GL_BYTE;

+      *comps = 2;

+      return;

+

+   case MESA_FORMAT_SIGNED_R8:

+      *datatype = GL_BYTE;

+      *comps = 1;

+      return;

+   case MESA_FORMAT_SIGNED_RG88:

+      *datatype = GL_BYTE;

+      *comps = 2;

+      return;

+   case MESA_FORMAT_SIGNED_RGBA8888:

+   case MESA_FORMAT_SIGNED_RGBA8888_REV:

+   case MESA_FORMAT_SIGNED_RGBX8888:

+      *datatype = GL_BYTE;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_RGBA_16:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_SIGNED_R_16:

+      *datatype = GL_SHORT;

+      *comps = 1;

+      return;

+   case MESA_FORMAT_SIGNED_RG_16:

+      *datatype = GL_SHORT;

+      *comps = 2;

+      return;

+   case MESA_FORMAT_SIGNED_RGB_16:

+      *datatype = GL_SHORT;

+      *comps = 3;

+      return;

+   case MESA_FORMAT_SIGNED_RGBA_16:

+      *datatype = GL_SHORT;

+      *comps = 4;

+      return;

+

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SRGB8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 3;

+      return;

+   case MESA_FORMAT_SRGBA8:

+   case MESA_FORMAT_SARGB8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_SL8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 1;

+      return;

+   case MESA_FORMAT_SLA8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 2;

+      return;

+#endif

+

+#if FEATURE_texture_fxt1

+   case MESA_FORMAT_RGB_FXT1:

+   case MESA_FORMAT_RGBA_FXT1:

+#endif

+#if FEATURE_texture_s3tc

+   case MESA_FORMAT_RGB_DXT1:

+   case MESA_FORMAT_RGBA_DXT1:

+   case MESA_FORMAT_RGBA_DXT3:

+   case MESA_FORMAT_RGBA_DXT5:

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SRGB_DXT1:

+   case MESA_FORMAT_SRGBA_DXT1:

+   case MESA_FORMAT_SRGBA_DXT3:

+   case MESA_FORMAT_SRGBA_DXT5:

+#endif

+#endif

+   case MESA_FORMAT_RED_RGTC1:

+   case MESA_FORMAT_SIGNED_RED_RGTC1:

+   case MESA_FORMAT_RG_RGTC2:

+   case MESA_FORMAT_SIGNED_RG_RGTC2:

+   case MESA_FORMAT_L_LATC1:

+   case MESA_FORMAT_SIGNED_L_LATC1:

+   case MESA_FORMAT_LA_LATC2:

+   case MESA_FORMAT_SIGNED_LA_LATC2:

+      /* XXX generate error instead? */

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 0;

+      return;

+

+   case MESA_FORMAT_RGBA_FLOAT32:

+      *datatype = GL_FLOAT;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGBA_FLOAT16:

+      *datatype = GL_HALF_FLOAT_ARB;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGB_FLOAT32:

+      *datatype = GL_FLOAT;

+      *comps = 3;

+      return;

+   case MESA_FORMAT_RGB_FLOAT16:

+      *datatype = GL_HALF_FLOAT_ARB;

+      *comps = 3;

+      return;

+   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:

+      *datatype = GL_FLOAT;

+      *comps = 2;

+      return;

+   case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:

+      *datatype = GL_HALF_FLOAT_ARB;

+      *comps = 2;

+      return;

+   case MESA_FORMAT_ALPHA_FLOAT32:

+   case MESA_FORMAT_LUMINANCE_FLOAT32:

+   case MESA_FORMAT_INTENSITY_FLOAT32:

+      *datatype = GL_FLOAT;

+      *comps = 1;

+      return;

+   case MESA_FORMAT_ALPHA_FLOAT16:

+   case MESA_FORMAT_LUMINANCE_FLOAT16:

+   case MESA_FORMAT_INTENSITY_FLOAT16:

+      *datatype = GL_HALF_FLOAT_ARB;

+      *comps = 1;

+      return;

+

+   case MESA_FORMAT_RGBA_INT8:

+      *datatype = GL_BYTE;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGBA_INT16:

+      *datatype = GL_SHORT;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGBA_INT32:

+      *datatype = GL_INT;

+      *comps = 4;

+      return;

+

+   /**

+    * \name Non-normalized unsigned integer formats.

+    */

+   case MESA_FORMAT_RGBA_UINT8:

+      *datatype = GL_UNSIGNED_BYTE;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGBA_UINT16:

+      *datatype = GL_UNSIGNED_SHORT;

+      *comps = 4;

+      return;

+   case MESA_FORMAT_RGBA_UINT32:

+      *datatype = GL_UNSIGNED_INT;

+      *comps = 4;

+      return;

+

+   case MESA_FORMAT_COUNT:

+      assert(0);

+      return;

+

+   case MESA_FORMAT_NONE:

+   /* For debug builds, warn if any formats are not handled */

+#ifdef DEBUG

+   default:

+#endif

+      _mesa_problem(NULL, "bad format %s in _mesa_format_to_type_and_comps",

+                    _mesa_get_format_name(format));

+      *datatype = 0;

+      *comps = 1;

+   }

+}

diff --git a/mesalib/src/mesa/main/formats.h b/mesalib/src/mesa/main/formats.h
index 04a18930b..81ba76ce0 100644
--- a/mesalib/src/mesa/main/formats.h
+++ b/mesalib/src/mesa/main/formats.h
@@ -1,251 +1,251 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008-2009  VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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:
- *   Brian Paul
- */
-
-
-#ifndef FORMATS_H
-#define FORMATS_H
-
-
-#include <GL/gl.h>
-
-/* OpenGL doesn't have GL_UNSIGNED_BYTE_4_4, so we must define our own type
- * for GL_LUMINANCE4_ALPHA4. */
-#define MESA_UNSIGNED_BYTE_4_4 (GL_UNSIGNED_BYTE<<1)
-
-
-/**
- * Mesa texture/renderbuffer image formats.
- */
-typedef enum
-{
-   MESA_FORMAT_NONE = 0,
-
-   /** 
-    * \name Basic hardware formats
-    */
-   /*@{*/
-				/* msb <------ TEXEL BITS -----------> lsb */
-				/* ---- ---- ---- ---- ---- ---- ---- ---- */
-   MESA_FORMAT_RGBA8888,	/* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */
-   MESA_FORMAT_RGBA8888_REV,	/* AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */
-   MESA_FORMAT_ARGB8888,	/* AAAA AAAA RRRR RRRR GGGG GGGG BBBB BBBB */
-   MESA_FORMAT_ARGB8888_REV,	/* BBBB BBBB GGGG GGGG RRRR RRRR AAAA AAAA */
-   MESA_FORMAT_XRGB8888,	/* xxxx xxxx RRRR RRRR GGGG GGGG BBBB BBBB */
-   MESA_FORMAT_XRGB8888_REV,	/* BBBB BBBB GGGG GGGG RRRR RRRR xxxx xxxx */
-   MESA_FORMAT_RGB888,		/*           RRRR RRRR GGGG GGGG BBBB BBBB */
-   MESA_FORMAT_BGR888,		/*           BBBB BBBB GGGG GGGG RRRR RRRR */
-   MESA_FORMAT_RGB565,		/*                     RRRR RGGG GGGB BBBB */
-   MESA_FORMAT_RGB565_REV,	/*                     GGGB BBBB RRRR RGGG */
-   MESA_FORMAT_ARGB4444,	/*                     AAAA RRRR GGGG BBBB */
-   MESA_FORMAT_ARGB4444_REV,	/*                     GGGG BBBB AAAA RRRR */
-   MESA_FORMAT_RGBA5551,        /*                     RRRR RGGG GGBB BBBA */
-   MESA_FORMAT_ARGB1555,	/*                     ARRR RRGG GGGB BBBB */
-   MESA_FORMAT_ARGB1555_REV,	/*                     GGGB BBBB ARRR RRGG */
-   MESA_FORMAT_AL44,		/*                               AAAA LLLL */
-   MESA_FORMAT_AL88,		/*                     AAAA AAAA LLLL LLLL */
-   MESA_FORMAT_AL88_REV,	/*                     LLLL LLLL AAAA AAAA */
-   MESA_FORMAT_AL1616,          /* AAAA AAAA AAAA AAAA LLLL LLLL LLLL LLLL */
-   MESA_FORMAT_AL1616_REV,      /* LLLL LLLL LLLL LLLL AAAA AAAA AAAA AAAA */
-   MESA_FORMAT_RGB332,		/*                               RRRG GGBB */
-   MESA_FORMAT_A8,		/*                               AAAA AAAA */
-   MESA_FORMAT_A16,             /*                     AAAA AAAA AAAA AAAA */
-   MESA_FORMAT_L8,		/*                               LLLL LLLL */
-   MESA_FORMAT_L16,             /*                     LLLL LLLL LLLL LLLL */
-   MESA_FORMAT_I8,		/*                               IIII IIII */
-   MESA_FORMAT_I16,             /*                     IIII IIII IIII IIII */
-   MESA_FORMAT_CI8,		/*                               CCCC CCCC */
-   MESA_FORMAT_YCBCR,		/*                     YYYY YYYY UorV UorV */
-   MESA_FORMAT_YCBCR_REV,	/*                     UorV UorV YYYY YYYY */
-   MESA_FORMAT_R8,		/*                               RRRR RRRR */
-   MESA_FORMAT_RG88,		/*                     RRRR RRRR GGGG GGGG */
-   MESA_FORMAT_RG88_REV,	/*                     GGGG GGGG RRRR RRRR */
-   MESA_FORMAT_R16,		/*                     RRRR RRRR RRRR RRRR */
-   MESA_FORMAT_RG1616,		/* RRRR RRRR RRRR RRRR GGGG GGGG GGGG GGGG */
-   MESA_FORMAT_RG1616_REV,	/* GGGG GGGG GGGG GGGG RRRR RRRR RRRR RRRR */
-   MESA_FORMAT_ARGB2101010,     /* AARR RRRR RRRR GGGG GGGG GGBB BBBB BBBB */
-   MESA_FORMAT_Z24_S8,          /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ SSSS SSSS */
-   MESA_FORMAT_S8_Z24,          /* SSSS SSSS ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */
-   MESA_FORMAT_Z16,             /*                     ZZZZ ZZZZ ZZZZ ZZZZ */
-   MESA_FORMAT_X8_Z24,          /* xxxx xxxx ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */
-   MESA_FORMAT_Z24_X8,          /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ xxxx xxxx */
-   MESA_FORMAT_Z32,             /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */
-   MESA_FORMAT_S8,              /*                               SSSS SSSS */
-   /*@}*/
-
-   /**
-    * \name 8-bit/channel sRGB formats
-    */
-   /*@{*/
-   MESA_FORMAT_SRGB8,
-   MESA_FORMAT_SRGBA8,
-   MESA_FORMAT_SARGB8,
-   MESA_FORMAT_SL8,
-   MESA_FORMAT_SLA8,
-   MESA_FORMAT_SRGB_DXT1,
-   MESA_FORMAT_SRGBA_DXT1,
-   MESA_FORMAT_SRGBA_DXT3,
-   MESA_FORMAT_SRGBA_DXT5,
-   /*@}*/
-
-   /**
-    * \name Compressed texture formats.
-    */
-   /*@{*/
-   MESA_FORMAT_RGB_FXT1,
-   MESA_FORMAT_RGBA_FXT1,
-   MESA_FORMAT_RGB_DXT1,
-   MESA_FORMAT_RGBA_DXT1,
-   MESA_FORMAT_RGBA_DXT3,
-   MESA_FORMAT_RGBA_DXT5,
-   /*@}*/
-
-   /**
-    * \name Floating point texture formats.
-    */
-   /*@{*/
-   MESA_FORMAT_RGBA_FLOAT32,
-   MESA_FORMAT_RGBA_FLOAT16,
-   MESA_FORMAT_RGB_FLOAT32,
-   MESA_FORMAT_RGB_FLOAT16,
-   MESA_FORMAT_ALPHA_FLOAT32,
-   MESA_FORMAT_ALPHA_FLOAT16,
-   MESA_FORMAT_LUMINANCE_FLOAT32,
-   MESA_FORMAT_LUMINANCE_FLOAT16,
-   MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,
-   MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,
-   MESA_FORMAT_INTENSITY_FLOAT32,
-   MESA_FORMAT_INTENSITY_FLOAT16,
-   /*@}*/
-
-   /**
-    * \name Non-normalized signed integer formats.
-    * XXX Note: these are just stand-ins for some better hardware
-    * formats TBD such as BGRA or ARGB.
-    */
-   MESA_FORMAT_RGBA_INT8,
-   MESA_FORMAT_RGBA_INT16,
-   MESA_FORMAT_RGBA_INT32,
-
-   /**
-    * \name Non-normalized unsigned integer formats.
-    */
-   MESA_FORMAT_RGBA_UINT8,
-   MESA_FORMAT_RGBA_UINT16,
-   MESA_FORMAT_RGBA_UINT32,
-
-                                  /* msb <------ TEXEL BITS -----------> lsb */
-                                  /* ---- ---- ---- ---- ---- ---- ---- ---- */
-   /**
-    * \name Signed fixed point texture formats.
-    */
-   /*@{*/
-   MESA_FORMAT_DUDV8,             /*                     DUDU DUDU DVDV DVDV */
-   MESA_FORMAT_SIGNED_R8,         /*                               RRRR RRRR */
-   MESA_FORMAT_SIGNED_RG88,       /*                     RRRR RRRR GGGG GGGG */
-   MESA_FORMAT_SIGNED_RGBX8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB xxxx xxxx */
-   MESA_FORMAT_SIGNED_RGBA8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */
-   MESA_FORMAT_SIGNED_RGBA8888_REV,/*AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */
-   MESA_FORMAT_SIGNED_R_16,       /* ushort[0]=R */
-   MESA_FORMAT_SIGNED_RG_16,      /* ushort[0]=R, ushort[1]=G */
-   MESA_FORMAT_SIGNED_RGB_16,     /* ushort[0]=R, ushort[1]=G, ushort[2]=B */
-   MESA_FORMAT_SIGNED_RGBA_16,    /* ... */
-   MESA_FORMAT_RGBA_16,           /* ... */
-   /*@}*/
-
-   /*@{*/
-   MESA_FORMAT_RED_RGTC1,
-   MESA_FORMAT_SIGNED_RED_RGTC1,
-   MESA_FORMAT_RG_RGTC2,
-   MESA_FORMAT_SIGNED_RG_RGTC2,
-   /*@}*/
-
-   /*@{*/
-   MESA_FORMAT_L_LATC1,
-   MESA_FORMAT_SIGNED_L_LATC1,
-   MESA_FORMAT_LA_LATC2,
-   MESA_FORMAT_SIGNED_LA_LATC2,
-   /*@}*/
-
-   MESA_FORMAT_COUNT
-} gl_format;
-
-
-extern const char *
-_mesa_get_format_name(gl_format format);
-
-extern GLuint
-_mesa_get_format_bytes(gl_format format);
-
-extern GLint
-_mesa_get_format_bits(gl_format format, GLenum pname);
-
-extern GLenum
-_mesa_get_format_datatype(gl_format format);
-
-extern GLenum
-_mesa_get_format_base_format(gl_format format);
-
-extern void
-_mesa_get_format_block_size(gl_format format, GLuint *bw, GLuint *bh);
-
-extern GLboolean
-_mesa_is_format_compressed(gl_format format);
-
-extern GLboolean
-_mesa_is_format_packed_depth_stencil(gl_format format);
-
-extern GLboolean
-_mesa_is_format_integer_color(gl_format format);
-
-extern GLenum
-_mesa_get_format_color_encoding(gl_format format);
-
-extern GLuint
-_mesa_format_image_size(gl_format format, GLsizei width,
-                        GLsizei height, GLsizei depth);
-
-extern uint64_t
-_mesa_format_image_size64(gl_format format, GLsizei width,
-                          GLsizei height, GLsizei depth);
-
-extern GLint
-_mesa_format_row_stride(gl_format format, GLsizei width);
-
-extern void
-_mesa_format_to_type_and_comps(gl_format format,
-                               GLenum *datatype, GLuint *comps);
-
-extern void
-_mesa_test_formats(void);
-
-extern gl_format
-_mesa_get_srgb_format_linear(gl_format format);
-
-#endif /* FORMATS_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008-2009  VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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:

+ *   Brian Paul

+ */

+

+

+#ifndef FORMATS_H

+#define FORMATS_H

+

+

+#include <GL/gl.h>

+

+/* OpenGL doesn't have GL_UNSIGNED_BYTE_4_4, so we must define our own type

+ * for GL_LUMINANCE4_ALPHA4. */

+#define MESA_UNSIGNED_BYTE_4_4 (GL_UNSIGNED_BYTE<<1)

+

+

+/**

+ * Mesa texture/renderbuffer image formats.

+ */

+typedef enum

+{

+   MESA_FORMAT_NONE = 0,

+

+   /** 

+    * \name Basic hardware formats

+    */

+   /*@{*/

+				/* msb <------ TEXEL BITS -----------> lsb */

+				/* ---- ---- ---- ---- ---- ---- ---- ---- */

+   MESA_FORMAT_RGBA8888,	/* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */

+   MESA_FORMAT_RGBA8888_REV,	/* AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */

+   MESA_FORMAT_ARGB8888,	/* AAAA AAAA RRRR RRRR GGGG GGGG BBBB BBBB */

+   MESA_FORMAT_ARGB8888_REV,	/* BBBB BBBB GGGG GGGG RRRR RRRR AAAA AAAA */

+   MESA_FORMAT_XRGB8888,	/* xxxx xxxx RRRR RRRR GGGG GGGG BBBB BBBB */

+   MESA_FORMAT_XRGB8888_REV,	/* BBBB BBBB GGGG GGGG RRRR RRRR xxxx xxxx */

+   MESA_FORMAT_RGB888,		/*           RRRR RRRR GGGG GGGG BBBB BBBB */

+   MESA_FORMAT_BGR888,		/*           BBBB BBBB GGGG GGGG RRRR RRRR */

+   MESA_FORMAT_RGB565,		/*                     RRRR RGGG GGGB BBBB */

+   MESA_FORMAT_RGB565_REV,	/*                     GGGB BBBB RRRR RGGG */

+   MESA_FORMAT_ARGB4444,	/*                     AAAA RRRR GGGG BBBB */

+   MESA_FORMAT_ARGB4444_REV,	/*                     GGGG BBBB AAAA RRRR */

+   MESA_FORMAT_RGBA5551,        /*                     RRRR RGGG GGBB BBBA */

+   MESA_FORMAT_ARGB1555,	/*                     ARRR RRGG GGGB BBBB */

+   MESA_FORMAT_ARGB1555_REV,	/*                     GGGB BBBB ARRR RRGG */

+   MESA_FORMAT_AL44,		/*                               AAAA LLLL */

+   MESA_FORMAT_AL88,		/*                     AAAA AAAA LLLL LLLL */

+   MESA_FORMAT_AL88_REV,	/*                     LLLL LLLL AAAA AAAA */

+   MESA_FORMAT_AL1616,          /* AAAA AAAA AAAA AAAA LLLL LLLL LLLL LLLL */

+   MESA_FORMAT_AL1616_REV,      /* LLLL LLLL LLLL LLLL AAAA AAAA AAAA AAAA */

+   MESA_FORMAT_RGB332,		/*                               RRRG GGBB */

+   MESA_FORMAT_A8,		/*                               AAAA AAAA */

+   MESA_FORMAT_A16,             /*                     AAAA AAAA AAAA AAAA */

+   MESA_FORMAT_L8,		/*                               LLLL LLLL */

+   MESA_FORMAT_L16,             /*                     LLLL LLLL LLLL LLLL */

+   MESA_FORMAT_I8,		/*                               IIII IIII */

+   MESA_FORMAT_I16,             /*                     IIII IIII IIII IIII */

+   MESA_FORMAT_CI8,		/*                               CCCC CCCC */

+   MESA_FORMAT_YCBCR,		/*                     YYYY YYYY UorV UorV */

+   MESA_FORMAT_YCBCR_REV,	/*                     UorV UorV YYYY YYYY */

+   MESA_FORMAT_R8,		/*                               RRRR RRRR */

+   MESA_FORMAT_RG88,		/*                     RRRR RRRR GGGG GGGG */

+   MESA_FORMAT_RG88_REV,	/*                     GGGG GGGG RRRR RRRR */

+   MESA_FORMAT_R16,		/*                     RRRR RRRR RRRR RRRR */

+   MESA_FORMAT_RG1616,		/* RRRR RRRR RRRR RRRR GGGG GGGG GGGG GGGG */

+   MESA_FORMAT_RG1616_REV,	/* GGGG GGGG GGGG GGGG RRRR RRRR RRRR RRRR */

+   MESA_FORMAT_ARGB2101010,     /* AARR RRRR RRRR GGGG GGGG GGBB BBBB BBBB */

+   MESA_FORMAT_Z24_S8,          /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ SSSS SSSS */

+   MESA_FORMAT_S8_Z24,          /* SSSS SSSS ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */

+   MESA_FORMAT_Z16,             /*                     ZZZZ ZZZZ ZZZZ ZZZZ */

+   MESA_FORMAT_X8_Z24,          /* xxxx xxxx ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */

+   MESA_FORMAT_Z24_X8,          /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ xxxx xxxx */

+   MESA_FORMAT_Z32,             /* ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ ZZZZ */

+   MESA_FORMAT_S8,              /*                               SSSS SSSS */

+   /*@}*/

+

+   /**

+    * \name 8-bit/channel sRGB formats

+    */

+   /*@{*/

+   MESA_FORMAT_SRGB8,

+   MESA_FORMAT_SRGBA8,

+   MESA_FORMAT_SARGB8,

+   MESA_FORMAT_SL8,

+   MESA_FORMAT_SLA8,

+   MESA_FORMAT_SRGB_DXT1,

+   MESA_FORMAT_SRGBA_DXT1,

+   MESA_FORMAT_SRGBA_DXT3,

+   MESA_FORMAT_SRGBA_DXT5,

+   /*@}*/

+

+   /**

+    * \name Compressed texture formats.

+    */

+   /*@{*/

+   MESA_FORMAT_RGB_FXT1,

+   MESA_FORMAT_RGBA_FXT1,

+   MESA_FORMAT_RGB_DXT1,

+   MESA_FORMAT_RGBA_DXT1,

+   MESA_FORMAT_RGBA_DXT3,

+   MESA_FORMAT_RGBA_DXT5,

+   /*@}*/

+

+   /**

+    * \name Floating point texture formats.

+    */

+   /*@{*/

+   MESA_FORMAT_RGBA_FLOAT32,

+   MESA_FORMAT_RGBA_FLOAT16,

+   MESA_FORMAT_RGB_FLOAT32,

+   MESA_FORMAT_RGB_FLOAT16,

+   MESA_FORMAT_ALPHA_FLOAT32,

+   MESA_FORMAT_ALPHA_FLOAT16,

+   MESA_FORMAT_LUMINANCE_FLOAT32,

+   MESA_FORMAT_LUMINANCE_FLOAT16,

+   MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,

+   MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,

+   MESA_FORMAT_INTENSITY_FLOAT32,

+   MESA_FORMAT_INTENSITY_FLOAT16,

+   /*@}*/

+

+   /**

+    * \name Non-normalized signed integer formats.

+    * XXX Note: these are just stand-ins for some better hardware

+    * formats TBD such as BGRA or ARGB.

+    */

+   MESA_FORMAT_RGBA_INT8,

+   MESA_FORMAT_RGBA_INT16,

+   MESA_FORMAT_RGBA_INT32,

+

+   /**

+    * \name Non-normalized unsigned integer formats.

+    */

+   MESA_FORMAT_RGBA_UINT8,

+   MESA_FORMAT_RGBA_UINT16,

+   MESA_FORMAT_RGBA_UINT32,

+

+                                  /* msb <------ TEXEL BITS -----------> lsb */

+                                  /* ---- ---- ---- ---- ---- ---- ---- ---- */

+   /**

+    * \name Signed fixed point texture formats.

+    */

+   /*@{*/

+   MESA_FORMAT_DUDV8,             /*                     DUDU DUDU DVDV DVDV */

+   MESA_FORMAT_SIGNED_R8,         /*                               RRRR RRRR */

+   MESA_FORMAT_SIGNED_RG88,       /*                     RRRR RRRR GGGG GGGG */

+   MESA_FORMAT_SIGNED_RGBX8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB xxxx xxxx */

+   MESA_FORMAT_SIGNED_RGBA8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */

+   MESA_FORMAT_SIGNED_RGBA8888_REV,/*AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */

+   MESA_FORMAT_SIGNED_R_16,       /* ushort[0]=R */

+   MESA_FORMAT_SIGNED_RG_16,      /* ushort[0]=R, ushort[1]=G */

+   MESA_FORMAT_SIGNED_RGB_16,     /* ushort[0]=R, ushort[1]=G, ushort[2]=B */

+   MESA_FORMAT_SIGNED_RGBA_16,    /* ... */

+   MESA_FORMAT_RGBA_16,           /* ... */

+   /*@}*/

+

+   /*@{*/

+   MESA_FORMAT_RED_RGTC1,

+   MESA_FORMAT_SIGNED_RED_RGTC1,

+   MESA_FORMAT_RG_RGTC2,

+   MESA_FORMAT_SIGNED_RG_RGTC2,

+   /*@}*/

+

+   /*@{*/

+   MESA_FORMAT_L_LATC1,

+   MESA_FORMAT_SIGNED_L_LATC1,

+   MESA_FORMAT_LA_LATC2,

+   MESA_FORMAT_SIGNED_LA_LATC2,

+   /*@}*/

+

+   MESA_FORMAT_COUNT

+} gl_format;

+

+

+extern const char *

+_mesa_get_format_name(gl_format format);

+

+extern GLuint

+_mesa_get_format_bytes(gl_format format);

+

+extern GLint

+_mesa_get_format_bits(gl_format format, GLenum pname);

+

+extern GLenum

+_mesa_get_format_datatype(gl_format format);

+

+extern GLenum

+_mesa_get_format_base_format(gl_format format);

+

+extern void

+_mesa_get_format_block_size(gl_format format, GLuint *bw, GLuint *bh);

+

+extern GLboolean

+_mesa_is_format_compressed(gl_format format);

+

+extern GLboolean

+_mesa_is_format_packed_depth_stencil(gl_format format);

+

+extern GLboolean

+_mesa_is_format_integer_color(gl_format format);

+

+extern GLenum

+_mesa_get_format_color_encoding(gl_format format);

+

+extern GLuint

+_mesa_format_image_size(gl_format format, GLsizei width,

+                        GLsizei height, GLsizei depth);

+

+extern uint64_t

+_mesa_format_image_size64(gl_format format, GLsizei width,

+                          GLsizei height, GLsizei depth);

+

+extern GLint

+_mesa_format_row_stride(gl_format format, GLsizei width);

+

+extern void

+_mesa_format_to_type_and_comps(gl_format format,

+                               GLenum *datatype, GLuint *comps);

+

+extern void

+_mesa_test_formats(void);

+

+extern gl_format

+_mesa_get_srgb_format_linear(gl_format format);

+

+#endif /* FORMATS_H */

diff --git a/mesalib/src/mesa/main/framebuffer.c b/mesalib/src/mesa/main/framebuffer.c
index 8916441f4..9de4e56fe 100644
--- a/mesalib/src/mesa/main/framebuffer.c
+++ b/mesalib/src/mesa/main/framebuffer.c
@@ -1,1083 +1,1083 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.2
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * Functions for allocating/managing framebuffers and renderbuffers.
- * Also, routines for reading/writing renderbuffer data as ubytes,
- * ushorts, uints, etc.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "buffers.h"
-#include "context.h"
-#include "depthstencil.h"
-#include "enums.h"
-#include "formats.h"
-#include "macros.h"
-#include "mtypes.h"
-#include "fbobject.h"
-#include "framebuffer.h"
-#include "renderbuffer.h"
-#include "texobj.h"
-
-
-
-/**
- * Compute/set the _DepthMax field for the given framebuffer.
- * This value depends on the Z buffer resolution.
- */
-static void
-compute_depth_max(struct gl_framebuffer *fb)
-{
-   if (fb->Visual.depthBits == 0) {
-      /* Special case.  Even if we don't have a depth buffer we need
-       * good values for DepthMax for Z vertex transformation purposes
-       * and for per-fragment fog computation.
-       */
-      fb->_DepthMax = (1 << 16) - 1;
-   }
-   else if (fb->Visual.depthBits < 32) {
-      fb->_DepthMax = (1 << fb->Visual.depthBits) - 1;
-   }
-   else {
-      /* Special case since shift values greater than or equal to the
-       * number of bits in the left hand expression's type are undefined.
-       */
-      fb->_DepthMax = 0xffffffff;
-   }
-   fb->_DepthMaxF = (GLfloat) fb->_DepthMax;
-
-   /* Minimum resolvable depth value, for polygon offset */
-   fb->_MRD = (GLfloat)1.0 / fb->_DepthMaxF;
-}
-
-/**
- * Create and initialize a gl_framebuffer object.
- * This is intended for creating _window_system_ framebuffers, not generic
- * framebuffer objects ala GL_EXT_framebuffer_object.
- *
- * \sa _mesa_new_framebuffer
- */
-struct gl_framebuffer *
-_mesa_create_framebuffer(const struct gl_config *visual)
-{
-   struct gl_framebuffer *fb = CALLOC_STRUCT(gl_framebuffer);
-   assert(visual);
-   if (fb) {
-      _mesa_initialize_window_framebuffer(fb, visual);
-   }
-   return fb;
-}
-
-
-/**
- * Allocate a new gl_framebuffer object.
- * This is the default function for ctx->Driver.NewFramebuffer().
- * This is for allocating user-created framebuffers, not window-system
- * framebuffers!
- * \sa _mesa_create_framebuffer
- */
-struct gl_framebuffer *
-_mesa_new_framebuffer(struct gl_context *ctx, GLuint name)
-{
-   struct gl_framebuffer *fb;
-   (void) ctx;
-   assert(name != 0);
-   fb = CALLOC_STRUCT(gl_framebuffer);
-   if (fb) {
-      _mesa_initialize_user_framebuffer(fb, name);
-   }
-   return fb;
-}
-
-
-/**
- * Initialize a gl_framebuffer object.  Typically used to initialize
- * window system-created framebuffers, not user-created framebuffers.
- * \sa _mesa_initialize_user_framebuffer
- */
-void
-_mesa_initialize_window_framebuffer(struct gl_framebuffer *fb,
-				     const struct gl_config *visual)
-{
-   assert(fb);
-   assert(visual);
-
-   memset(fb, 0, sizeof(struct gl_framebuffer));
-
-   _glthread_INIT_MUTEX(fb->Mutex);
-
-   fb->RefCount = 1;
-
-   /* save the visual */
-   fb->Visual = *visual;
-
-   /* Init read/draw renderbuffer state */
-   if (visual->doubleBufferMode) {
-      fb->_NumColorDrawBuffers = 1;
-      fb->ColorDrawBuffer[0] = GL_BACK;
-      fb->_ColorDrawBufferIndexes[0] = BUFFER_BACK_LEFT;
-      fb->ColorReadBuffer = GL_BACK;
-      fb->_ColorReadBufferIndex = BUFFER_BACK_LEFT;
-   }
-   else {
-      fb->_NumColorDrawBuffers = 1;
-      fb->ColorDrawBuffer[0] = GL_FRONT;
-      fb->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;
-      fb->ColorReadBuffer = GL_FRONT;
-      fb->_ColorReadBufferIndex = BUFFER_FRONT_LEFT;
-   }
-
-   fb->Delete = _mesa_destroy_framebuffer;
-   fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
-
-   compute_depth_max(fb);
-}
-
-
-/**
- * Initialize a user-created gl_framebuffer object.
- * \sa _mesa_initialize_window_framebuffer
- */
-void
-_mesa_initialize_user_framebuffer(struct gl_framebuffer *fb, GLuint name)
-{
-   assert(fb);
-   assert(name);
-
-   memset(fb, 0, sizeof(struct gl_framebuffer));
-
-   fb->Name = name;
-   fb->RefCount = 1;
-   fb->_NumColorDrawBuffers = 1;
-   fb->ColorDrawBuffer[0] = GL_COLOR_ATTACHMENT0_EXT;
-   fb->_ColorDrawBufferIndexes[0] = BUFFER_COLOR0;
-   fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT;
-   fb->_ColorReadBufferIndex = BUFFER_COLOR0;
-   fb->Delete = _mesa_destroy_framebuffer;
-   _glthread_INIT_MUTEX(fb->Mutex);
-}
-
-
-/**
- * Deallocate buffer and everything attached to it.
- * Typically called via the gl_framebuffer->Delete() method.
- */
-void
-_mesa_destroy_framebuffer(struct gl_framebuffer *fb)
-{
-   if (fb) {
-      _mesa_free_framebuffer_data(fb);
-      free(fb);
-   }
-}
-
-
-/**
- * Free all the data hanging off the given gl_framebuffer, but don't free
- * the gl_framebuffer object itself.
- */
-void
-_mesa_free_framebuffer_data(struct gl_framebuffer *fb)
-{
-   GLuint i;
-
-   assert(fb);
-   assert(fb->RefCount == 0);
-
-   _glthread_DESTROY_MUTEX(fb->Mutex);
-
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
-      if (att->Renderbuffer) {
-         _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
-      }
-      if (att->Texture) {
-         _mesa_reference_texobj(&att->Texture, NULL);
-      }
-      ASSERT(!att->Renderbuffer);
-      ASSERT(!att->Texture);
-      att->Type = GL_NONE;
-   }
-
-   /* unbind _Depth/_StencilBuffer to decr ref counts */
-   _mesa_reference_renderbuffer(&fb->_DepthBuffer, NULL);
-   _mesa_reference_renderbuffer(&fb->_StencilBuffer, NULL);
-}
-
-
-/**
- * Set *ptr to point to fb, with refcounting and locking.
- */
-void
-_mesa_reference_framebuffer(struct gl_framebuffer **ptr,
-                            struct gl_framebuffer *fb)
-{
-   assert(ptr);
-   if (*ptr == fb) {
-      /* no change */
-      return;
-   }
-
-   if (*ptr) {
-      /* unreference old renderbuffer */
-      GLboolean deleteFlag = GL_FALSE;
-      struct gl_framebuffer *oldFb = *ptr;
-
-      _glthread_LOCK_MUTEX(oldFb->Mutex);
-      ASSERT(oldFb->RefCount > 0);
-      oldFb->RefCount--;
-      deleteFlag = (oldFb->RefCount == 0);
-      _glthread_UNLOCK_MUTEX(oldFb->Mutex);
-      
-      if (deleteFlag)
-         oldFb->Delete(oldFb);
-
-      *ptr = NULL;
-   }
-   assert(!*ptr);
-
-   if (fb) {
-      _glthread_LOCK_MUTEX(fb->Mutex);
-      fb->RefCount++;
-      _glthread_UNLOCK_MUTEX(fb->Mutex);
-      *ptr = fb;
-   }
-}
-
-
-/**
- * Resize the given framebuffer's renderbuffers to the new width and height.
- * This should only be used for window-system framebuffers, not
- * user-created renderbuffers (i.e. made with GL_EXT_framebuffer_object).
- * This will typically be called via ctx->Driver.ResizeBuffers() or directly
- * from a device driver.
- *
- * \note it's possible for ctx to be null since a window can be resized
- * without a currently bound rendering context.
- */
-void
-_mesa_resize_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb,
-                         GLuint width, GLuint height)
-{
-   GLuint i;
-
-   /* XXX I think we could check if the size is not changing
-    * and return early.
-    */
-
-   /* For window system framebuffers, Name is zero */
-   assert(fb->Name == 0);
-
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
-      if (att->Type == GL_RENDERBUFFER_EXT && att->Renderbuffer) {
-         struct gl_renderbuffer *rb = att->Renderbuffer;
-         /* only resize if size is changing */
-         if (rb->Width != width || rb->Height != height) {
-            if (rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {
-               ASSERT(rb->Width == width);
-               ASSERT(rb->Height == height);
-            }
-            else {
-               _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");
-               /* no return */
-            }
-         }
-      }
-   }
-
-   if (fb->_DepthBuffer) {
-      struct gl_renderbuffer *rb = fb->_DepthBuffer;
-      if (rb->Width != width || rb->Height != height) {
-         if (!rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");
-         }
-      }
-   }
-
-   if (fb->_StencilBuffer) {
-      struct gl_renderbuffer *rb = fb->_StencilBuffer;
-      if (rb->Width != width || rb->Height != height) {
-         if (!rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");
-         }
-      }
-   }
-
-   fb->Width = width;
-   fb->Height = height;
-
-   if (ctx) {
-      /* update scissor / window bounds */
-      _mesa_update_draw_buffer_bounds(ctx);
-      /* Signal new buffer state so that swrast will update its clipping
-       * info (the CLIP_BIT flag).
-       */
-      ctx->NewState |= _NEW_BUFFERS;
-   }
-}
-
-
-
-/**
- * XXX THIS IS OBSOLETE - drivers should take care of detecting window
- * size changes and act accordingly, likely calling _mesa_resize_framebuffer().
- *
- * GL_MESA_resize_buffers extension.
- *
- * When this function is called, we'll ask the window system how large
- * the current window is.  If it's a new size, we'll call the driver's
- * ResizeBuffers function.  The driver will then resize its color buffers
- * as needed, and maybe call the swrast's routine for reallocating
- * swrast-managed depth/stencil/accum/etc buffers.
- * \note This function should only be called through the GL API, not
- * from device drivers (as was done in the past).
- */
-void
-_mesa_resizebuffers( struct gl_context *ctx )
-{
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glResizeBuffersMESA\n");
-
-   if (!ctx->Driver.GetBufferSize) {
-      return;
-   }
-
-   if (ctx->WinSysDrawBuffer) {
-      GLuint newWidth, newHeight;
-      struct gl_framebuffer *buffer = ctx->WinSysDrawBuffer;
-
-      assert(buffer->Name == 0);
-
-      /* ask device driver for size of output buffer */
-      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
-
-      /* see if size of device driver's color buffer (window) has changed */
-      if (buffer->Width != newWidth || buffer->Height != newHeight) {
-         if (ctx->Driver.ResizeBuffers)
-            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
-      }
-   }
-
-   if (ctx->WinSysReadBuffer
-       && ctx->WinSysReadBuffer != ctx->WinSysDrawBuffer) {
-      GLuint newWidth, newHeight;
-      struct gl_framebuffer *buffer = ctx->WinSysReadBuffer;
-
-      assert(buffer->Name == 0);
-
-      /* ask device driver for size of read buffer */
-      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
-
-      /* see if size of device driver's color buffer (window) has changed */
-      if (buffer->Width != newWidth || buffer->Height != newHeight) {
-         if (ctx->Driver.ResizeBuffers)
-            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
-      }
-   }
-
-   ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */
-}
-
-
-/*
- * XXX THIS IS OBSOLETE
- */
-void GLAPIENTRY
-_mesa_ResizeBuffersMESA( void )
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (ctx->Extensions.MESA_resize_buffers)
-      _mesa_resizebuffers( ctx );
-}
-
-
-
-/**
- * Examine all the framebuffer's renderbuffers to update the Width/Height
- * fields of the framebuffer.  If we have renderbuffers with different
- * sizes, set the framebuffer's width and height to the min size.
- * Note: this is only intended for user-created framebuffers, not
- * window-system framebuffes.
- */
-static void
-update_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   GLuint minWidth = ~0, minHeight = ~0;
-   GLuint i;
-
-   /* user-created framebuffers only */
-   assert(fb->Name);
-
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
-      const struct gl_renderbuffer *rb = att->Renderbuffer;
-      if (rb) {
-         minWidth = MIN2(minWidth, rb->Width);
-         minHeight = MIN2(minHeight, rb->Height);
-      }
-   }
-
-   if (minWidth != ~0) {
-      fb->Width = minWidth;
-      fb->Height = minHeight;
-   }
-   else {
-      fb->Width = 0;
-      fb->Height = 0;
-   }
-}
-
-
-/**
- * Update the context's current drawing buffer's Xmin, Xmax, Ymin, Ymax fields.
- * These values are computed from the buffer's width and height and
- * the scissor box, if it's enabled.
- * \param ctx  the GL context.
- */
-void
-_mesa_update_draw_buffer_bounds(struct gl_context *ctx)
-{
-   struct gl_framebuffer *buffer = ctx->DrawBuffer;
-
-   if (!buffer)
-      return;
-
-   if (buffer->Name) {
-      /* user-created framebuffer size depends on the renderbuffers */
-      update_framebuffer_size(ctx, buffer);
-   }
-
-   buffer->_Xmin = 0;
-   buffer->_Ymin = 0;
-   buffer->_Xmax = buffer->Width;
-   buffer->_Ymax = buffer->Height;
-
-   if (ctx->Scissor.Enabled) {
-      if (ctx->Scissor.X > buffer->_Xmin) {
-	 buffer->_Xmin = ctx->Scissor.X;
-      }
-      if (ctx->Scissor.Y > buffer->_Ymin) {
-	 buffer->_Ymin = ctx->Scissor.Y;
-      }
-      if (ctx->Scissor.X + ctx->Scissor.Width < buffer->_Xmax) {
-	 buffer->_Xmax = ctx->Scissor.X + ctx->Scissor.Width;
-      }
-      if (ctx->Scissor.Y + ctx->Scissor.Height < buffer->_Ymax) {
-	 buffer->_Ymax = ctx->Scissor.Y + ctx->Scissor.Height;
-      }
-      /* finally, check for empty region */
-      if (buffer->_Xmin > buffer->_Xmax) {
-         buffer->_Xmin = buffer->_Xmax;
-      }
-      if (buffer->_Ymin > buffer->_Ymax) {
-         buffer->_Ymin = buffer->_Ymax;
-      }
-   }
-
-   ASSERT(buffer->_Xmin <= buffer->_Xmax);
-   ASSERT(buffer->_Ymin <= buffer->_Ymax);
-}
-
-
-/**
- * The glGet queries of the framebuffer red/green/blue size, stencil size,
- * etc. are satisfied by the fields of ctx->DrawBuffer->Visual.  These can
- * change depending on the renderbuffer bindings.  This function updates
- * the given framebuffer's Visual from the current renderbuffer bindings.
- *
- * This may apply to user-created framebuffers or window system framebuffers.
- *
- * Also note: ctx->DrawBuffer->Visual.depthBits might not equal
- * ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer.DepthBits.
- * The former one is used to convert floating point depth values into
- * integer Z values.
- */
-void
-_mesa_update_framebuffer_visual(struct gl_context *ctx,
-				struct gl_framebuffer *fb)
-{
-   GLuint i;
-
-   memset(&fb->Visual, 0, sizeof(fb->Visual));
-   fb->Visual.rgbMode = GL_TRUE; /* assume this */
-
-#if 0 /* this _might_ be needed */
-   if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      /* leave visual fields zero'd */
-      return;
-   }
-#endif
-
-   /* find first RGB renderbuffer */
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      if (fb->Attachment[i].Renderbuffer) {
-         const struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer;
-         const GLenum baseFormat = _mesa_get_format_base_format(rb->Format);
-         const gl_format fmt = rb->Format;
-
-         if (_mesa_is_legal_color_format(ctx, baseFormat)) {
-            fb->Visual.redBits = _mesa_get_format_bits(fmt, GL_RED_BITS);
-            fb->Visual.greenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);
-            fb->Visual.blueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);
-            fb->Visual.alphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);
-            fb->Visual.rgbBits = fb->Visual.redBits
-               + fb->Visual.greenBits + fb->Visual.blueBits;
-            fb->Visual.floatMode = GL_FALSE;
-            fb->Visual.samples = rb->NumSamples;
-            if (_mesa_get_format_color_encoding(fmt) == GL_SRGB)
-                fb->Visual.sRGBCapable = ctx->Const.sRGBCapable;
-            break;
-         }
-      }
-   }
-
-   if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) {
-      const struct gl_renderbuffer *rb =
-         fb->Attachment[BUFFER_DEPTH].Renderbuffer;
-      const gl_format fmt = rb->Format;
-      fb->Visual.haveDepthBuffer = GL_TRUE;
-      fb->Visual.depthBits = _mesa_get_format_bits(fmt, GL_DEPTH_BITS);
-   }
-
-   if (fb->Attachment[BUFFER_STENCIL].Renderbuffer) {
-      const struct gl_renderbuffer *rb =
-         fb->Attachment[BUFFER_STENCIL].Renderbuffer;
-      const gl_format fmt = rb->Format;
-      fb->Visual.haveStencilBuffer = GL_TRUE;
-      fb->Visual.stencilBits = _mesa_get_format_bits(fmt, GL_STENCIL_BITS);
-   }
-
-   if (fb->Attachment[BUFFER_ACCUM].Renderbuffer) {
-      const struct gl_renderbuffer *rb =
-         fb->Attachment[BUFFER_ACCUM].Renderbuffer;
-      const gl_format fmt = rb->Format;
-      fb->Visual.haveAccumBuffer = GL_TRUE;
-      fb->Visual.accumRedBits = _mesa_get_format_bits(fmt, GL_RED_BITS);
-      fb->Visual.accumGreenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);
-      fb->Visual.accumBlueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);
-      fb->Visual.accumAlphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);
-   }
-
-   compute_depth_max(fb);
-}
-
-
-/**
- * Update the framebuffer's _DepthBuffer field using the renderbuffer
- * found at the given attachment index.
- *
- * If that attachment points to a combined GL_DEPTH_STENCIL renderbuffer,
- * create and install a depth wrapper/adaptor.
- *
- * \param fb  the framebuffer whose _DepthBuffer field to update
- * \param attIndex  indicates the renderbuffer to possibly wrap
- */
-void
-_mesa_update_depth_buffer(struct gl_context *ctx,
-                          struct gl_framebuffer *fb,
-                          GLuint attIndex)
-{
-   struct gl_renderbuffer *depthRb;
-
-   /* only one possiblity for now */
-   ASSERT(attIndex == BUFFER_DEPTH);
-
-   depthRb = fb->Attachment[attIndex].Renderbuffer;
-
-   if (depthRb && _mesa_is_format_packed_depth_stencil(depthRb->Format)) {
-      /* The attached depth buffer is a GL_DEPTH_STENCIL renderbuffer */
-      if (!fb->_DepthBuffer
-          || fb->_DepthBuffer->Wrapped != depthRb
-          || _mesa_get_format_base_format(fb->_DepthBuffer->Format) != GL_DEPTH_COMPONENT) {
-         /* need to update wrapper */
-         struct gl_renderbuffer *wrapper
-            = _mesa_new_z24_renderbuffer_wrapper(ctx, depthRb);
-         _mesa_reference_renderbuffer(&fb->_DepthBuffer, wrapper);
-         ASSERT(fb->_DepthBuffer->Wrapped == depthRb);
-      }
-   }
-   else {
-      /* depthRb may be null */
-      _mesa_reference_renderbuffer(&fb->_DepthBuffer, depthRb);
-   }
-}
-
-
-/**
- * Update the framebuffer's _StencilBuffer field using the renderbuffer
- * found at the given attachment index.
- *
- * If that attachment points to a combined GL_DEPTH_STENCIL renderbuffer,
- * create and install a stencil wrapper/adaptor.
- *
- * \param fb  the framebuffer whose _StencilBuffer field to update
- * \param attIndex  indicates the renderbuffer to possibly wrap
- */
-void
-_mesa_update_stencil_buffer(struct gl_context *ctx,
-                            struct gl_framebuffer *fb,
-                            GLuint attIndex)
-{
-   struct gl_renderbuffer *stencilRb;
-
-   ASSERT(attIndex == BUFFER_DEPTH ||
-          attIndex == BUFFER_STENCIL);
-
-   stencilRb = fb->Attachment[attIndex].Renderbuffer;
-
-   if (stencilRb && _mesa_is_format_packed_depth_stencil(stencilRb->Format)) {
-      /* The attached stencil buffer is a GL_DEPTH_STENCIL renderbuffer */
-      if (!fb->_StencilBuffer
-          || fb->_StencilBuffer->Wrapped != stencilRb
-          || _mesa_get_format_base_format(fb->_StencilBuffer->Format) != GL_STENCIL_INDEX) {
-         /* need to update wrapper */
-         struct gl_renderbuffer *wrapper
-            = _mesa_new_s8_renderbuffer_wrapper(ctx, stencilRb);
-         _mesa_reference_renderbuffer(&fb->_StencilBuffer, wrapper);
-         ASSERT(fb->_StencilBuffer->Wrapped == stencilRb);
-      }
-   }
-   else {
-      /* stencilRb may be null */
-      _mesa_reference_renderbuffer(&fb->_StencilBuffer, stencilRb);
-   }
-}
-
-
-/*
- * Example DrawBuffers scenarios:
- *
- * 1. glDrawBuffer(GL_FRONT_AND_BACK), fixed-func or shader writes to
- * "gl_FragColor" or program writes to the "result.color" register:
- *
- *   fragment color output   renderbuffer
- *   ---------------------   ---------------
- *   color[0]                Front, Back
- *
- *
- * 2. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]), shader writes to
- * gl_FragData[i] or program writes to result.color[i] registers:
- *
- *   fragment color output   renderbuffer
- *   ---------------------   ---------------
- *   color[0]                Front
- *   color[1]                Aux0
- *   color[3]                Aux1
- *
- *
- * 3. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]) and shader writes to
- * gl_FragColor, or fixed function:
- *
- *   fragment color output   renderbuffer
- *   ---------------------   ---------------
- *   color[0]                Front, Aux0, Aux1
- *
- *
- * In either case, the list of renderbuffers is stored in the
- * framebuffer->_ColorDrawBuffers[] array and
- * framebuffer->_NumColorDrawBuffers indicates the number of buffers.
- * The renderer (like swrast) has to look at the current fragment shader
- * to see if it writes to gl_FragColor vs. gl_FragData[i] to determine
- * how to map color outputs to renderbuffers.
- *
- * Note that these two calls are equivalent (for fixed function fragment
- * shading anyway):
- *   a)  glDrawBuffer(GL_FRONT_AND_BACK);  (assuming non-stereo framebuffer)
- *   b)  glDrawBuffers(2, [GL_FRONT_LEFT, GL_BACK_LEFT]);
- */
-
-
-
-
-/**
- * Update the (derived) list of color drawing renderbuffer pointers.
- * Later, when we're rendering we'll loop from 0 to _NumColorDrawBuffers
- * writing colors.
- */
-static void
-update_color_draw_buffers(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   GLuint output;
-
-   /* set 0th buffer to NULL now in case _NumColorDrawBuffers is zero */
-   fb->_ColorDrawBuffers[0] = NULL;
-
-   for (output = 0; output < fb->_NumColorDrawBuffers; output++) {
-      GLint buf = fb->_ColorDrawBufferIndexes[output];
-      if (buf >= 0) {
-         fb->_ColorDrawBuffers[output] = fb->Attachment[buf].Renderbuffer;
-      }
-      else {
-         fb->_ColorDrawBuffers[output] = NULL;
-      }
-   }
-}
-
-
-/**
- * Update the (derived) color read renderbuffer pointer.
- * Unlike the DrawBuffer, we can only read from one (or zero) color buffers.
- */
-static void
-update_color_read_buffer(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   (void) ctx;
-   if (fb->_ColorReadBufferIndex == -1 ||
-       fb->DeletePending ||
-       fb->Width == 0 ||
-       fb->Height == 0) {
-      fb->_ColorReadBuffer = NULL; /* legal! */
-   }
-   else {
-      ASSERT(fb->_ColorReadBufferIndex >= 0);
-      ASSERT(fb->_ColorReadBufferIndex < BUFFER_COUNT);
-      fb->_ColorReadBuffer
-         = fb->Attachment[fb->_ColorReadBufferIndex].Renderbuffer;
-   }
-}
-
-
-/**
- * Update a gl_framebuffer's derived state.
- *
- * Specifically, update these framebuffer fields:
- *    _ColorDrawBuffers
- *    _NumColorDrawBuffers
- *    _ColorReadBuffer
- *    _DepthBuffer
- *    _StencilBuffer
- *
- * If the framebuffer is user-created, make sure it's complete.
- *
- * The following functions (at least) can effect framebuffer state:
- * glReadBuffer, glDrawBuffer, glDrawBuffersARB, glFramebufferRenderbufferEXT,
- * glRenderbufferStorageEXT.
- */
-static void
-update_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   if (fb->Name == 0) {
-      /* This is a window-system framebuffer */
-      /* Need to update the FB's GL_DRAW_BUFFER state to match the
-       * context state (GL_READ_BUFFER too).
-       */
-      if (fb->ColorDrawBuffer[0] != ctx->Color.DrawBuffer[0]) {
-         _mesa_drawbuffers(ctx, ctx->Const.MaxDrawBuffers,
-                           ctx->Color.DrawBuffer, NULL);
-      }
-   }
-   else {
-      /* This is a user-created framebuffer.
-       * Completeness only matters for user-created framebuffers.
-       */
-      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE) {
-         _mesa_test_framebuffer_completeness(ctx, fb);
-      }
-   }
-
-   /* Strictly speaking, we don't need to update the draw-state
-    * if this FB is bound as ctx->ReadBuffer (and conversely, the
-    * read-state if this FB is bound as ctx->DrawBuffer), but no
-    * harm.
-    */
-   update_color_draw_buffers(ctx, fb);
-   update_color_read_buffer(ctx, fb);
-   _mesa_update_depth_buffer(ctx, fb, BUFFER_DEPTH);
-   _mesa_update_stencil_buffer(ctx, fb, BUFFER_STENCIL);
-
-   compute_depth_max(fb);
-}
-
-
-/**
- * Update state related to the current draw/read framebuffers.
- */
-void
-_mesa_update_framebuffer(struct gl_context *ctx)
-{
-   struct gl_framebuffer *drawFb;
-   struct gl_framebuffer *readFb;
-
-   assert(ctx);
-   drawFb = ctx->DrawBuffer;
-   readFb = ctx->ReadBuffer;
-
-   update_framebuffer(ctx, drawFb);
-   if (readFb != drawFb)
-      update_framebuffer(ctx, readFb);
-}
-
-
-/**
- * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,
- * glCopyTex[Sub]Image, etc) exists.
- * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
- *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
- * \return GL_TRUE if buffer exists, GL_FALSE otherwise
- */
-GLboolean
-_mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
-{
-   const struct gl_renderbuffer_attachment *att = ctx->ReadBuffer->Attachment;
-
-   /* If we don't know the framebuffer status, update it now */
-   if (ctx->ReadBuffer->_Status == 0) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
-   }
-
-   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      return GL_FALSE;
-   }
-
-   switch (format) {
-   case GL_COLOR:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_RG:
-   case GL_RGB:
-   case GL_BGR:
-   case GL_RGBA:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-   case GL_COLOR_INDEX:
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      if (ctx->ReadBuffer->_ColorReadBuffer == NULL) {
-         return GL_FALSE;
-      }
-      ASSERT(_mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_RED_BITS) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_ALPHA_BITS) > 0 ||
-             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_INDEX_BITS) > 0);
-      break;
-   case GL_DEPTH:
-   case GL_DEPTH_COMPONENT:
-      if (!att[BUFFER_DEPTH].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/
-      break;
-   case GL_STENCIL:
-   case GL_STENCIL_INDEX:
-      if (!att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      if (!att[BUFFER_DEPTH].Renderbuffer ||
-          !att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*
-      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);
-      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);
-      */
-      break;
-   default:
-      _mesa_problem(ctx,
-                    "Unexpected format 0x%x in _mesa_source_buffer_exists",
-                    format);
-      return GL_FALSE;
-   }
-
-   /* OK */
-   return GL_TRUE;
-}
-
-
-/**
- * As above, but for drawing operations.
- * XXX could do some code merging w/ above function.
- */
-GLboolean
-_mesa_dest_buffer_exists(struct gl_context *ctx, GLenum format)
-{
-   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;
-
-   /* If we don't know the framebuffer status, update it now */
-   if (ctx->DrawBuffer->_Status == 0) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->DrawBuffer);
-   }
-
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      return GL_FALSE;
-   }
-
-   switch (format) {
-   case GL_COLOR:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_RGB:
-   case GL_BGR:
-   case GL_RGBA:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-   case GL_COLOR_INDEX:
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      /* Nothing special since GL_DRAW_BUFFER could be GL_NONE. */
-      /* Could assert that colorbuffer has RedBits > 0 */
-      break;
-   case GL_DEPTH:
-   case GL_DEPTH_COMPONENT:
-      if (!att[BUFFER_DEPTH].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/
-      break;
-   case GL_STENCIL:
-   case GL_STENCIL_INDEX:
-      if (!att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      if (!att[BUFFER_DEPTH].Renderbuffer ||
-          !att[BUFFER_STENCIL].Renderbuffer) {
-         return GL_FALSE;
-      }
-      /*
-      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);
-      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);
-      */
-      break;
-   default:
-      _mesa_problem(ctx,
-                    "Unexpected format 0x%x in _mesa_dest_buffer_exists",
-                    format);
-      return GL_FALSE;
-   }
-
-   /* OK */
-   return GL_TRUE;
-}
-
-
-/**
- * Used to answer the GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES query.
- */
-GLenum
-_mesa_get_color_read_format(struct gl_context *ctx)
-{
-   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {
-   case MESA_FORMAT_ARGB8888:
-      return GL_BGRA;
-   case MESA_FORMAT_RGB565:
-      return GL_BGR;
-   default:
-      return GL_RGBA;
-   }
-}
-
-
-/**
- * Used to answer the GL_IMPLEMENTATION_COLOR_READ_TYPE_OES query.
- */
-GLenum
-_mesa_get_color_read_type(struct gl_context *ctx)
-{
-   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {
-   case MESA_FORMAT_ARGB8888:
-      return GL_UNSIGNED_BYTE;
-   case MESA_FORMAT_RGB565:
-      return GL_UNSIGNED_SHORT_5_6_5_REV;
-   default:
-      return GL_UNSIGNED_BYTE;
-   }
-}
-
-
-/**
- * Print framebuffer info to stderr, for debugging.
- */
-void
-_mesa_print_framebuffer(const struct gl_framebuffer *fb)
-{
-   GLuint i;
-
-   fprintf(stderr, "Mesa Framebuffer %u at %p\n", fb->Name, (void *) fb);
-   fprintf(stderr, "  Size: %u x %u  Status: %s\n", fb->Width, fb->Height,
-           _mesa_lookup_enum_by_nr(fb->_Status));
-   fprintf(stderr, "  Attachments:\n");
-
-   for (i = 0; i < BUFFER_COUNT; i++) {
-      const struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
-      if (att->Type == GL_TEXTURE) {
-         const struct gl_texture_image *texImage;
-         fprintf(stderr,
-                 "  %2d: Texture %u, level %u, face %u, slice %u, complete %d\n",
-                 i, att->Texture->Name, att->TextureLevel, att->CubeMapFace,
-                 att->Zoffset, att->Complete);
-         texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
-         fprintf(stderr, "       Size: %u x %u x %u  Format %s\n",
-                 texImage->Width, texImage->Height, texImage->Depth,
-                 _mesa_get_format_name(texImage->TexFormat));
-      }
-      else if (att->Type == GL_RENDERBUFFER) {
-         fprintf(stderr, "  %2d: Renderbuffer %u, complete %d\n",
-                 i, att->Renderbuffer->Name, att->Complete);
-         fprintf(stderr, "       Size: %u x %u  Format %s\n",
-                 att->Renderbuffer->Width, att->Renderbuffer->Height,
-                 _mesa_get_format_name(att->Renderbuffer->Format));
-      }
-      else {
-         fprintf(stderr, "  %2d: none\n", i);
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.2

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * Functions for allocating/managing framebuffers and renderbuffers.

+ * Also, routines for reading/writing renderbuffer data as ubytes,

+ * ushorts, uints, etc.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "buffers.h"

+#include "context.h"

+#include "depthstencil.h"

+#include "enums.h"

+#include "formats.h"

+#include "macros.h"

+#include "mtypes.h"

+#include "fbobject.h"

+#include "framebuffer.h"

+#include "renderbuffer.h"

+#include "texobj.h"

+

+

+

+/**

+ * Compute/set the _DepthMax field for the given framebuffer.

+ * This value depends on the Z buffer resolution.

+ */

+static void

+compute_depth_max(struct gl_framebuffer *fb)

+{

+   if (fb->Visual.depthBits == 0) {

+      /* Special case.  Even if we don't have a depth buffer we need

+       * good values for DepthMax for Z vertex transformation purposes

+       * and for per-fragment fog computation.

+       */

+      fb->_DepthMax = (1 << 16) - 1;

+   }

+   else if (fb->Visual.depthBits < 32) {

+      fb->_DepthMax = (1 << fb->Visual.depthBits) - 1;

+   }

+   else {

+      /* Special case since shift values greater than or equal to the

+       * number of bits in the left hand expression's type are undefined.

+       */

+      fb->_DepthMax = 0xffffffff;

+   }

+   fb->_DepthMaxF = (GLfloat) fb->_DepthMax;

+

+   /* Minimum resolvable depth value, for polygon offset */

+   fb->_MRD = (GLfloat)1.0 / fb->_DepthMaxF;

+}

+

+/**

+ * Create and initialize a gl_framebuffer object.

+ * This is intended for creating _window_system_ framebuffers, not generic

+ * framebuffer objects ala GL_EXT_framebuffer_object.

+ *

+ * \sa _mesa_new_framebuffer

+ */

+struct gl_framebuffer *

+_mesa_create_framebuffer(const struct gl_config *visual)

+{

+   struct gl_framebuffer *fb = CALLOC_STRUCT(gl_framebuffer);

+   assert(visual);

+   if (fb) {

+      _mesa_initialize_window_framebuffer(fb, visual);

+   }

+   return fb;

+}

+

+

+/**

+ * Allocate a new gl_framebuffer object.

+ * This is the default function for ctx->Driver.NewFramebuffer().

+ * This is for allocating user-created framebuffers, not window-system

+ * framebuffers!

+ * \sa _mesa_create_framebuffer

+ */

+struct gl_framebuffer *

+_mesa_new_framebuffer(struct gl_context *ctx, GLuint name)

+{

+   struct gl_framebuffer *fb;

+   (void) ctx;

+   assert(name != 0);

+   fb = CALLOC_STRUCT(gl_framebuffer);

+   if (fb) {

+      _mesa_initialize_user_framebuffer(fb, name);

+   }

+   return fb;

+}

+

+

+/**

+ * Initialize a gl_framebuffer object.  Typically used to initialize

+ * window system-created framebuffers, not user-created framebuffers.

+ * \sa _mesa_initialize_user_framebuffer

+ */

+void

+_mesa_initialize_window_framebuffer(struct gl_framebuffer *fb,

+				     const struct gl_config *visual)

+{

+   assert(fb);

+   assert(visual);

+

+   memset(fb, 0, sizeof(struct gl_framebuffer));

+

+   _glthread_INIT_MUTEX(fb->Mutex);

+

+   fb->RefCount = 1;

+

+   /* save the visual */

+   fb->Visual = *visual;

+

+   /* Init read/draw renderbuffer state */

+   if (visual->doubleBufferMode) {

+      fb->_NumColorDrawBuffers = 1;

+      fb->ColorDrawBuffer[0] = GL_BACK;

+      fb->_ColorDrawBufferIndexes[0] = BUFFER_BACK_LEFT;

+      fb->ColorReadBuffer = GL_BACK;

+      fb->_ColorReadBufferIndex = BUFFER_BACK_LEFT;

+   }

+   else {

+      fb->_NumColorDrawBuffers = 1;

+      fb->ColorDrawBuffer[0] = GL_FRONT;

+      fb->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;

+      fb->ColorReadBuffer = GL_FRONT;

+      fb->_ColorReadBufferIndex = BUFFER_FRONT_LEFT;

+   }

+

+   fb->Delete = _mesa_destroy_framebuffer;

+   fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;

+

+   compute_depth_max(fb);

+}

+

+

+/**

+ * Initialize a user-created gl_framebuffer object.

+ * \sa _mesa_initialize_window_framebuffer

+ */

+void

+_mesa_initialize_user_framebuffer(struct gl_framebuffer *fb, GLuint name)

+{

+   assert(fb);

+   assert(name);

+

+   memset(fb, 0, sizeof(struct gl_framebuffer));

+

+   fb->Name = name;

+   fb->RefCount = 1;

+   fb->_NumColorDrawBuffers = 1;

+   fb->ColorDrawBuffer[0] = GL_COLOR_ATTACHMENT0_EXT;

+   fb->_ColorDrawBufferIndexes[0] = BUFFER_COLOR0;

+   fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT;

+   fb->_ColorReadBufferIndex = BUFFER_COLOR0;

+   fb->Delete = _mesa_destroy_framebuffer;

+   _glthread_INIT_MUTEX(fb->Mutex);

+}

+

+

+/**

+ * Deallocate buffer and everything attached to it.

+ * Typically called via the gl_framebuffer->Delete() method.

+ */

+void

+_mesa_destroy_framebuffer(struct gl_framebuffer *fb)

+{

+   if (fb) {

+      _mesa_free_framebuffer_data(fb);

+      free(fb);

+   }

+}

+

+

+/**

+ * Free all the data hanging off the given gl_framebuffer, but don't free

+ * the gl_framebuffer object itself.

+ */

+void

+_mesa_free_framebuffer_data(struct gl_framebuffer *fb)

+{

+   GLuint i;

+

+   assert(fb);

+   assert(fb->RefCount == 0);

+

+   _glthread_DESTROY_MUTEX(fb->Mutex);

+

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];

+      if (att->Renderbuffer) {

+         _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);

+      }

+      if (att->Texture) {

+         _mesa_reference_texobj(&att->Texture, NULL);

+      }

+      ASSERT(!att->Renderbuffer);

+      ASSERT(!att->Texture);

+      att->Type = GL_NONE;

+   }

+

+   /* unbind _Depth/_StencilBuffer to decr ref counts */

+   _mesa_reference_renderbuffer(&fb->_DepthBuffer, NULL);

+   _mesa_reference_renderbuffer(&fb->_StencilBuffer, NULL);

+}

+

+

+/**

+ * Set *ptr to point to fb, with refcounting and locking.

+ */

+void

+_mesa_reference_framebuffer(struct gl_framebuffer **ptr,

+                            struct gl_framebuffer *fb)

+{

+   assert(ptr);

+   if (*ptr == fb) {

+      /* no change */

+      return;

+   }

+

+   if (*ptr) {

+      /* unreference old renderbuffer */

+      GLboolean deleteFlag = GL_FALSE;

+      struct gl_framebuffer *oldFb = *ptr;

+

+      _glthread_LOCK_MUTEX(oldFb->Mutex);

+      ASSERT(oldFb->RefCount > 0);

+      oldFb->RefCount--;

+      deleteFlag = (oldFb->RefCount == 0);

+      _glthread_UNLOCK_MUTEX(oldFb->Mutex);

+      

+      if (deleteFlag)

+         oldFb->Delete(oldFb);

+

+      *ptr = NULL;

+   }

+   assert(!*ptr);

+

+   if (fb) {

+      _glthread_LOCK_MUTEX(fb->Mutex);

+      fb->RefCount++;

+      _glthread_UNLOCK_MUTEX(fb->Mutex);

+      *ptr = fb;

+   }

+}

+

+

+/**

+ * Resize the given framebuffer's renderbuffers to the new width and height.

+ * This should only be used for window-system framebuffers, not

+ * user-created renderbuffers (i.e. made with GL_EXT_framebuffer_object).

+ * This will typically be called via ctx->Driver.ResizeBuffers() or directly

+ * from a device driver.

+ *

+ * \note it's possible for ctx to be null since a window can be resized

+ * without a currently bound rendering context.

+ */

+void

+_mesa_resize_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb,

+                         GLuint width, GLuint height)

+{

+   GLuint i;

+

+   /* XXX I think we could check if the size is not changing

+    * and return early.

+    */

+

+   /* For window system framebuffers, Name is zero */

+   assert(fb->Name == 0);

+

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];

+      if (att->Type == GL_RENDERBUFFER_EXT && att->Renderbuffer) {

+         struct gl_renderbuffer *rb = att->Renderbuffer;

+         /* only resize if size is changing */

+         if (rb->Width != width || rb->Height != height) {

+            if (rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {

+               ASSERT(rb->Width == width);

+               ASSERT(rb->Height == height);

+            }

+            else {

+               _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");

+               /* no return */

+            }

+         }

+      }

+   }

+

+   if (fb->_DepthBuffer) {

+      struct gl_renderbuffer *rb = fb->_DepthBuffer;

+      if (rb->Width != width || rb->Height != height) {

+         if (!rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");

+         }

+      }

+   }

+

+   if (fb->_StencilBuffer) {

+      struct gl_renderbuffer *rb = fb->_StencilBuffer;

+      if (rb->Width != width || rb->Height != height) {

+         if (!rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");

+         }

+      }

+   }

+

+   fb->Width = width;

+   fb->Height = height;

+

+   if (ctx) {

+      /* update scissor / window bounds */

+      _mesa_update_draw_buffer_bounds(ctx);

+      /* Signal new buffer state so that swrast will update its clipping

+       * info (the CLIP_BIT flag).

+       */

+      ctx->NewState |= _NEW_BUFFERS;

+   }

+}

+

+

+

+/**

+ * XXX THIS IS OBSOLETE - drivers should take care of detecting window

+ * size changes and act accordingly, likely calling _mesa_resize_framebuffer().

+ *

+ * GL_MESA_resize_buffers extension.

+ *

+ * When this function is called, we'll ask the window system how large

+ * the current window is.  If it's a new size, we'll call the driver's

+ * ResizeBuffers function.  The driver will then resize its color buffers

+ * as needed, and maybe call the swrast's routine for reallocating

+ * swrast-managed depth/stencil/accum/etc buffers.

+ * \note This function should only be called through the GL API, not

+ * from device drivers (as was done in the past).

+ */

+void

+_mesa_resizebuffers( struct gl_context *ctx )

+{

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glResizeBuffersMESA\n");

+

+   if (!ctx->Driver.GetBufferSize) {

+      return;

+   }

+

+   if (ctx->WinSysDrawBuffer) {

+      GLuint newWidth, newHeight;

+      struct gl_framebuffer *buffer = ctx->WinSysDrawBuffer;

+

+      assert(buffer->Name == 0);

+

+      /* ask device driver for size of output buffer */

+      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );

+

+      /* see if size of device driver's color buffer (window) has changed */

+      if (buffer->Width != newWidth || buffer->Height != newHeight) {

+         if (ctx->Driver.ResizeBuffers)

+            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );

+      }

+   }

+

+   if (ctx->WinSysReadBuffer

+       && ctx->WinSysReadBuffer != ctx->WinSysDrawBuffer) {

+      GLuint newWidth, newHeight;

+      struct gl_framebuffer *buffer = ctx->WinSysReadBuffer;

+

+      assert(buffer->Name == 0);

+

+      /* ask device driver for size of read buffer */

+      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );

+

+      /* see if size of device driver's color buffer (window) has changed */

+      if (buffer->Width != newWidth || buffer->Height != newHeight) {

+         if (ctx->Driver.ResizeBuffers)

+            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );

+      }

+   }

+

+   ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */

+}

+

+

+/*

+ * XXX THIS IS OBSOLETE

+ */

+void GLAPIENTRY

+_mesa_ResizeBuffersMESA( void )

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (ctx->Extensions.MESA_resize_buffers)

+      _mesa_resizebuffers( ctx );

+}

+

+

+

+/**

+ * Examine all the framebuffer's renderbuffers to update the Width/Height

+ * fields of the framebuffer.  If we have renderbuffers with different

+ * sizes, set the framebuffer's width and height to the min size.

+ * Note: this is only intended for user-created framebuffers, not

+ * window-system framebuffes.

+ */

+static void

+update_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   GLuint minWidth = ~0, minHeight = ~0;

+   GLuint i;

+

+   /* user-created framebuffers only */

+   assert(fb->Name);

+

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];

+      const struct gl_renderbuffer *rb = att->Renderbuffer;

+      if (rb) {

+         minWidth = MIN2(minWidth, rb->Width);

+         minHeight = MIN2(minHeight, rb->Height);

+      }

+   }

+

+   if (minWidth != ~0) {

+      fb->Width = minWidth;

+      fb->Height = minHeight;

+   }

+   else {

+      fb->Width = 0;

+      fb->Height = 0;

+   }

+}

+

+

+/**

+ * Update the context's current drawing buffer's Xmin, Xmax, Ymin, Ymax fields.

+ * These values are computed from the buffer's width and height and

+ * the scissor box, if it's enabled.

+ * \param ctx  the GL context.

+ */

+void

+_mesa_update_draw_buffer_bounds(struct gl_context *ctx)

+{

+   struct gl_framebuffer *buffer = ctx->DrawBuffer;

+

+   if (!buffer)

+      return;

+

+   if (buffer->Name) {

+      /* user-created framebuffer size depends on the renderbuffers */

+      update_framebuffer_size(ctx, buffer);

+   }

+

+   buffer->_Xmin = 0;

+   buffer->_Ymin = 0;

+   buffer->_Xmax = buffer->Width;

+   buffer->_Ymax = buffer->Height;

+

+   if (ctx->Scissor.Enabled) {

+      if (ctx->Scissor.X > buffer->_Xmin) {

+	 buffer->_Xmin = ctx->Scissor.X;

+      }

+      if (ctx->Scissor.Y > buffer->_Ymin) {

+	 buffer->_Ymin = ctx->Scissor.Y;

+      }

+      if (ctx->Scissor.X + ctx->Scissor.Width < buffer->_Xmax) {

+	 buffer->_Xmax = ctx->Scissor.X + ctx->Scissor.Width;

+      }

+      if (ctx->Scissor.Y + ctx->Scissor.Height < buffer->_Ymax) {

+	 buffer->_Ymax = ctx->Scissor.Y + ctx->Scissor.Height;

+      }

+      /* finally, check for empty region */

+      if (buffer->_Xmin > buffer->_Xmax) {

+         buffer->_Xmin = buffer->_Xmax;

+      }

+      if (buffer->_Ymin > buffer->_Ymax) {

+         buffer->_Ymin = buffer->_Ymax;

+      }

+   }

+

+   ASSERT(buffer->_Xmin <= buffer->_Xmax);

+   ASSERT(buffer->_Ymin <= buffer->_Ymax);

+}

+

+

+/**

+ * The glGet queries of the framebuffer red/green/blue size, stencil size,

+ * etc. are satisfied by the fields of ctx->DrawBuffer->Visual.  These can

+ * change depending on the renderbuffer bindings.  This function updates

+ * the given framebuffer's Visual from the current renderbuffer bindings.

+ *

+ * This may apply to user-created framebuffers or window system framebuffers.

+ *

+ * Also note: ctx->DrawBuffer->Visual.depthBits might not equal

+ * ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer.DepthBits.

+ * The former one is used to convert floating point depth values into

+ * integer Z values.

+ */

+void

+_mesa_update_framebuffer_visual(struct gl_context *ctx,

+				struct gl_framebuffer *fb)

+{

+   GLuint i;

+

+   memset(&fb->Visual, 0, sizeof(fb->Visual));

+   fb->Visual.rgbMode = GL_TRUE; /* assume this */

+

+#if 0 /* this _might_ be needed */

+   if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      /* leave visual fields zero'd */

+      return;

+   }

+#endif

+

+   /* find first RGB renderbuffer */

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      if (fb->Attachment[i].Renderbuffer) {

+         const struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer;

+         const GLenum baseFormat = _mesa_get_format_base_format(rb->Format);

+         const gl_format fmt = rb->Format;

+

+         if (_mesa_is_legal_color_format(ctx, baseFormat)) {

+            fb->Visual.redBits = _mesa_get_format_bits(fmt, GL_RED_BITS);

+            fb->Visual.greenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);

+            fb->Visual.blueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);

+            fb->Visual.alphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);

+            fb->Visual.rgbBits = fb->Visual.redBits

+               + fb->Visual.greenBits + fb->Visual.blueBits;

+            fb->Visual.floatMode = GL_FALSE;

+            fb->Visual.samples = rb->NumSamples;

+            if (_mesa_get_format_color_encoding(fmt) == GL_SRGB)

+                fb->Visual.sRGBCapable = ctx->Const.sRGBCapable;

+            break;

+         }

+      }

+   }

+

+   if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) {

+      const struct gl_renderbuffer *rb =

+         fb->Attachment[BUFFER_DEPTH].Renderbuffer;

+      const gl_format fmt = rb->Format;

+      fb->Visual.haveDepthBuffer = GL_TRUE;

+      fb->Visual.depthBits = _mesa_get_format_bits(fmt, GL_DEPTH_BITS);

+   }

+

+   if (fb->Attachment[BUFFER_STENCIL].Renderbuffer) {

+      const struct gl_renderbuffer *rb =

+         fb->Attachment[BUFFER_STENCIL].Renderbuffer;

+      const gl_format fmt = rb->Format;

+      fb->Visual.haveStencilBuffer = GL_TRUE;

+      fb->Visual.stencilBits = _mesa_get_format_bits(fmt, GL_STENCIL_BITS);

+   }

+

+   if (fb->Attachment[BUFFER_ACCUM].Renderbuffer) {

+      const struct gl_renderbuffer *rb =

+         fb->Attachment[BUFFER_ACCUM].Renderbuffer;

+      const gl_format fmt = rb->Format;

+      fb->Visual.haveAccumBuffer = GL_TRUE;

+      fb->Visual.accumRedBits = _mesa_get_format_bits(fmt, GL_RED_BITS);

+      fb->Visual.accumGreenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);

+      fb->Visual.accumBlueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);

+      fb->Visual.accumAlphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);

+   }

+

+   compute_depth_max(fb);

+}

+

+

+/**

+ * Update the framebuffer's _DepthBuffer field using the renderbuffer

+ * found at the given attachment index.

+ *

+ * If that attachment points to a combined GL_DEPTH_STENCIL renderbuffer,

+ * create and install a depth wrapper/adaptor.

+ *

+ * \param fb  the framebuffer whose _DepthBuffer field to update

+ * \param attIndex  indicates the renderbuffer to possibly wrap

+ */

+void

+_mesa_update_depth_buffer(struct gl_context *ctx,

+                          struct gl_framebuffer *fb,

+                          GLuint attIndex)

+{

+   struct gl_renderbuffer *depthRb;

+

+   /* only one possiblity for now */

+   ASSERT(attIndex == BUFFER_DEPTH);

+

+   depthRb = fb->Attachment[attIndex].Renderbuffer;

+

+   if (depthRb && _mesa_is_format_packed_depth_stencil(depthRb->Format)) {

+      /* The attached depth buffer is a GL_DEPTH_STENCIL renderbuffer */

+      if (!fb->_DepthBuffer

+          || fb->_DepthBuffer->Wrapped != depthRb

+          || _mesa_get_format_base_format(fb->_DepthBuffer->Format) != GL_DEPTH_COMPONENT) {

+         /* need to update wrapper */

+         struct gl_renderbuffer *wrapper

+            = _mesa_new_z24_renderbuffer_wrapper(ctx, depthRb);

+         _mesa_reference_renderbuffer(&fb->_DepthBuffer, wrapper);

+         ASSERT(fb->_DepthBuffer->Wrapped == depthRb);

+      }

+   }

+   else {

+      /* depthRb may be null */

+      _mesa_reference_renderbuffer(&fb->_DepthBuffer, depthRb);

+   }

+}

+

+

+/**

+ * Update the framebuffer's _StencilBuffer field using the renderbuffer

+ * found at the given attachment index.

+ *

+ * If that attachment points to a combined GL_DEPTH_STENCIL renderbuffer,

+ * create and install a stencil wrapper/adaptor.

+ *

+ * \param fb  the framebuffer whose _StencilBuffer field to update

+ * \param attIndex  indicates the renderbuffer to possibly wrap

+ */

+void

+_mesa_update_stencil_buffer(struct gl_context *ctx,

+                            struct gl_framebuffer *fb,

+                            GLuint attIndex)

+{

+   struct gl_renderbuffer *stencilRb;

+

+   ASSERT(attIndex == BUFFER_DEPTH ||

+          attIndex == BUFFER_STENCIL);

+

+   stencilRb = fb->Attachment[attIndex].Renderbuffer;

+

+   if (stencilRb && _mesa_is_format_packed_depth_stencil(stencilRb->Format)) {

+      /* The attached stencil buffer is a GL_DEPTH_STENCIL renderbuffer */

+      if (!fb->_StencilBuffer

+          || fb->_StencilBuffer->Wrapped != stencilRb

+          || _mesa_get_format_base_format(fb->_StencilBuffer->Format) != GL_STENCIL_INDEX) {

+         /* need to update wrapper */

+         struct gl_renderbuffer *wrapper

+            = _mesa_new_s8_renderbuffer_wrapper(ctx, stencilRb);

+         _mesa_reference_renderbuffer(&fb->_StencilBuffer, wrapper);

+         ASSERT(fb->_StencilBuffer->Wrapped == stencilRb);

+      }

+   }

+   else {

+      /* stencilRb may be null */

+      _mesa_reference_renderbuffer(&fb->_StencilBuffer, stencilRb);

+   }

+}

+

+

+/*

+ * Example DrawBuffers scenarios:

+ *

+ * 1. glDrawBuffer(GL_FRONT_AND_BACK), fixed-func or shader writes to

+ * "gl_FragColor" or program writes to the "result.color" register:

+ *

+ *   fragment color output   renderbuffer

+ *   ---------------------   ---------------

+ *   color[0]                Front, Back

+ *

+ *

+ * 2. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]), shader writes to

+ * gl_FragData[i] or program writes to result.color[i] registers:

+ *

+ *   fragment color output   renderbuffer

+ *   ---------------------   ---------------

+ *   color[0]                Front

+ *   color[1]                Aux0

+ *   color[3]                Aux1

+ *

+ *

+ * 3. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]) and shader writes to

+ * gl_FragColor, or fixed function:

+ *

+ *   fragment color output   renderbuffer

+ *   ---------------------   ---------------

+ *   color[0]                Front, Aux0, Aux1

+ *

+ *

+ * In either case, the list of renderbuffers is stored in the

+ * framebuffer->_ColorDrawBuffers[] array and

+ * framebuffer->_NumColorDrawBuffers indicates the number of buffers.

+ * The renderer (like swrast) has to look at the current fragment shader

+ * to see if it writes to gl_FragColor vs. gl_FragData[i] to determine

+ * how to map color outputs to renderbuffers.

+ *

+ * Note that these two calls are equivalent (for fixed function fragment

+ * shading anyway):

+ *   a)  glDrawBuffer(GL_FRONT_AND_BACK);  (assuming non-stereo framebuffer)

+ *   b)  glDrawBuffers(2, [GL_FRONT_LEFT, GL_BACK_LEFT]);

+ */

+

+

+

+

+/**

+ * Update the (derived) list of color drawing renderbuffer pointers.

+ * Later, when we're rendering we'll loop from 0 to _NumColorDrawBuffers

+ * writing colors.

+ */

+static void

+update_color_draw_buffers(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   GLuint output;

+

+   /* set 0th buffer to NULL now in case _NumColorDrawBuffers is zero */

+   fb->_ColorDrawBuffers[0] = NULL;

+

+   for (output = 0; output < fb->_NumColorDrawBuffers; output++) {

+      GLint buf = fb->_ColorDrawBufferIndexes[output];

+      if (buf >= 0) {

+         fb->_ColorDrawBuffers[output] = fb->Attachment[buf].Renderbuffer;

+      }

+      else {

+         fb->_ColorDrawBuffers[output] = NULL;

+      }

+   }

+}

+

+

+/**

+ * Update the (derived) color read renderbuffer pointer.

+ * Unlike the DrawBuffer, we can only read from one (or zero) color buffers.

+ */

+static void

+update_color_read_buffer(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   (void) ctx;

+   if (fb->_ColorReadBufferIndex == -1 ||

+       fb->DeletePending ||

+       fb->Width == 0 ||

+       fb->Height == 0) {

+      fb->_ColorReadBuffer = NULL; /* legal! */

+   }

+   else {

+      ASSERT(fb->_ColorReadBufferIndex >= 0);

+      ASSERT(fb->_ColorReadBufferIndex < BUFFER_COUNT);

+      fb->_ColorReadBuffer

+         = fb->Attachment[fb->_ColorReadBufferIndex].Renderbuffer;

+   }

+}

+

+

+/**

+ * Update a gl_framebuffer's derived state.

+ *

+ * Specifically, update these framebuffer fields:

+ *    _ColorDrawBuffers

+ *    _NumColorDrawBuffers

+ *    _ColorReadBuffer

+ *    _DepthBuffer

+ *    _StencilBuffer

+ *

+ * If the framebuffer is user-created, make sure it's complete.

+ *

+ * The following functions (at least) can effect framebuffer state:

+ * glReadBuffer, glDrawBuffer, glDrawBuffersARB, glFramebufferRenderbufferEXT,

+ * glRenderbufferStorageEXT.

+ */

+static void

+update_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   if (fb->Name == 0) {

+      /* This is a window-system framebuffer */

+      /* Need to update the FB's GL_DRAW_BUFFER state to match the

+       * context state (GL_READ_BUFFER too).

+       */

+      if (fb->ColorDrawBuffer[0] != ctx->Color.DrawBuffer[0]) {

+         _mesa_drawbuffers(ctx, ctx->Const.MaxDrawBuffers,

+                           ctx->Color.DrawBuffer, NULL);

+      }

+   }

+   else {

+      /* This is a user-created framebuffer.

+       * Completeness only matters for user-created framebuffers.

+       */

+      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE) {

+         _mesa_test_framebuffer_completeness(ctx, fb);

+      }

+   }

+

+   /* Strictly speaking, we don't need to update the draw-state

+    * if this FB is bound as ctx->ReadBuffer (and conversely, the

+    * read-state if this FB is bound as ctx->DrawBuffer), but no

+    * harm.

+    */

+   update_color_draw_buffers(ctx, fb);

+   update_color_read_buffer(ctx, fb);

+   _mesa_update_depth_buffer(ctx, fb, BUFFER_DEPTH);

+   _mesa_update_stencil_buffer(ctx, fb, BUFFER_STENCIL);

+

+   compute_depth_max(fb);

+}

+

+

+/**

+ * Update state related to the current draw/read framebuffers.

+ */

+void

+_mesa_update_framebuffer(struct gl_context *ctx)

+{

+   struct gl_framebuffer *drawFb;

+   struct gl_framebuffer *readFb;

+

+   assert(ctx);

+   drawFb = ctx->DrawBuffer;

+   readFb = ctx->ReadBuffer;

+

+   update_framebuffer(ctx, drawFb);

+   if (readFb != drawFb)

+      update_framebuffer(ctx, readFb);

+}

+

+

+/**

+ * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,

+ * glCopyTex[Sub]Image, etc) exists.

+ * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,

+ *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.

+ * \return GL_TRUE if buffer exists, GL_FALSE otherwise

+ */

+GLboolean

+_mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)

+{

+   const struct gl_renderbuffer_attachment *att = ctx->ReadBuffer->Attachment;

+

+   /* If we don't know the framebuffer status, update it now */

+   if (ctx->ReadBuffer->_Status == 0) {

+      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);

+   }

+

+   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      return GL_FALSE;

+   }

+

+   switch (format) {

+   case GL_COLOR:

+   case GL_RED:

+   case GL_GREEN:

+   case GL_BLUE:

+   case GL_ALPHA:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+   case GL_RG:

+   case GL_RGB:

+   case GL_BGR:

+   case GL_RGBA:

+   case GL_BGRA:

+   case GL_ABGR_EXT:

+   case GL_COLOR_INDEX:

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      if (ctx->ReadBuffer->_ColorReadBuffer == NULL) {

+         return GL_FALSE;

+      }

+      ASSERT(_mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_RED_BITS) > 0 ||

+             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_ALPHA_BITS) > 0 ||

+             _mesa_get_format_bits(ctx->ReadBuffer->_ColorReadBuffer->Format, GL_INDEX_BITS) > 0);

+      break;

+   case GL_DEPTH:

+   case GL_DEPTH_COMPONENT:

+      if (!att[BUFFER_DEPTH].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/

+      break;

+   case GL_STENCIL:

+   case GL_STENCIL_INDEX:

+      if (!att[BUFFER_STENCIL].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/

+      break;

+   case GL_DEPTH_STENCIL_EXT:

+      if (!att[BUFFER_DEPTH].Renderbuffer ||

+          !att[BUFFER_STENCIL].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*

+      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);

+      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);

+      */

+      break;

+   default:

+      _mesa_problem(ctx,

+                    "Unexpected format 0x%x in _mesa_source_buffer_exists",

+                    format);

+      return GL_FALSE;

+   }

+

+   /* OK */

+   return GL_TRUE;

+}

+

+

+/**

+ * As above, but for drawing operations.

+ * XXX could do some code merging w/ above function.

+ */

+GLboolean

+_mesa_dest_buffer_exists(struct gl_context *ctx, GLenum format)

+{

+   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;

+

+   /* If we don't know the framebuffer status, update it now */

+   if (ctx->DrawBuffer->_Status == 0) {

+      _mesa_test_framebuffer_completeness(ctx, ctx->DrawBuffer);

+   }

+

+   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      return GL_FALSE;

+   }

+

+   switch (format) {

+   case GL_COLOR:

+   case GL_RED:

+   case GL_GREEN:

+   case GL_BLUE:

+   case GL_ALPHA:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+   case GL_RGB:

+   case GL_BGR:

+   case GL_RGBA:

+   case GL_BGRA:

+   case GL_ABGR_EXT:

+   case GL_COLOR_INDEX:

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      /* Nothing special since GL_DRAW_BUFFER could be GL_NONE. */

+      /* Could assert that colorbuffer has RedBits > 0 */

+      break;

+   case GL_DEPTH:

+   case GL_DEPTH_COMPONENT:

+      if (!att[BUFFER_DEPTH].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);*/

+      break;

+   case GL_STENCIL:

+   case GL_STENCIL_INDEX:

+      if (!att[BUFFER_STENCIL].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);*/

+      break;

+   case GL_DEPTH_STENCIL_EXT:

+      if (!att[BUFFER_DEPTH].Renderbuffer ||

+          !att[BUFFER_STENCIL].Renderbuffer) {

+         return GL_FALSE;

+      }

+      /*

+      ASSERT(att[BUFFER_DEPTH].Renderbuffer->DepthBits > 0);

+      ASSERT(att[BUFFER_STENCIL].Renderbuffer->StencilBits > 0);

+      */

+      break;

+   default:

+      _mesa_problem(ctx,

+                    "Unexpected format 0x%x in _mesa_dest_buffer_exists",

+                    format);

+      return GL_FALSE;

+   }

+

+   /* OK */

+   return GL_TRUE;

+}

+

+

+/**

+ * Used to answer the GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES query.

+ */

+GLenum

+_mesa_get_color_read_format(struct gl_context *ctx)

+{

+   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {

+   case MESA_FORMAT_ARGB8888:

+      return GL_BGRA;

+   case MESA_FORMAT_RGB565:

+      return GL_BGR;

+   default:

+      return GL_RGBA;

+   }

+}

+

+

+/**

+ * Used to answer the GL_IMPLEMENTATION_COLOR_READ_TYPE_OES query.

+ */

+GLenum

+_mesa_get_color_read_type(struct gl_context *ctx)

+{

+   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {

+   case MESA_FORMAT_ARGB8888:

+      return GL_UNSIGNED_BYTE;

+   case MESA_FORMAT_RGB565:

+      return GL_UNSIGNED_SHORT_5_6_5_REV;

+   default:

+      return GL_UNSIGNED_BYTE;

+   }

+}

+

+

+/**

+ * Print framebuffer info to stderr, for debugging.

+ */

+void

+_mesa_print_framebuffer(const struct gl_framebuffer *fb)

+{

+   GLuint i;

+

+   fprintf(stderr, "Mesa Framebuffer %u at %p\n", fb->Name, (void *) fb);

+   fprintf(stderr, "  Size: %u x %u  Status: %s\n", fb->Width, fb->Height,

+           _mesa_lookup_enum_by_nr(fb->_Status));

+   fprintf(stderr, "  Attachments:\n");

+

+   for (i = 0; i < BUFFER_COUNT; i++) {

+      const struct gl_renderbuffer_attachment *att = &fb->Attachment[i];

+      if (att->Type == GL_TEXTURE) {

+         const struct gl_texture_image *texImage;

+         fprintf(stderr,

+                 "  %2d: Texture %u, level %u, face %u, slice %u, complete %d\n",

+                 i, att->Texture->Name, att->TextureLevel, att->CubeMapFace,

+                 att->Zoffset, att->Complete);

+         texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];

+         fprintf(stderr, "       Size: %u x %u x %u  Format %s\n",

+                 texImage->Width, texImage->Height, texImage->Depth,

+                 _mesa_get_format_name(texImage->TexFormat));

+      }

+      else if (att->Type == GL_RENDERBUFFER) {

+         fprintf(stderr, "  %2d: Renderbuffer %u, complete %d\n",

+                 i, att->Renderbuffer->Name, att->Complete);

+         fprintf(stderr, "       Size: %u x %u  Format %s\n",

+                 att->Renderbuffer->Width, att->Renderbuffer->Height,

+                 _mesa_get_format_name(att->Renderbuffer->Format));

+      }

+      else {

+         fprintf(stderr, "  %2d: none\n", i);

+      }

+   }

+}

diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 336304c59..529285027 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -1,2527 +1,2527 @@
-/*
- * Copyright (C) 2010  Brian Paul   All Rights Reserved.
- * Copyright (C) 2010  Intel Corporation
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- *
- * Author: Kristian Høgsberg <krh@bitplanet.net>
- */
-
-#include "glheader.h"
-#include "context.h"
-#include "enable.h"
-#include "enums.h"
-#include "extensions.h"
-#include "get.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "state.h"
-#include "texcompress.h"
-#include "framebuffer.h"
-
-/* This is a table driven implemetation of the glGet*v() functions.
- * The basic idea is that most getters just look up an int somewhere
- * in struct gl_context and then convert it to a bool or float according to
- * which of glGetIntegerv() glGetBooleanv() etc is being called.
- * Instead of generating code to do this, we can just record the enum
- * value and the offset into struct gl_context in an array of structs.  Then
- * in glGet*(), we lookup the struct for the enum in question, and use
- * the offset to get the int we need.
- *
- * Sometimes we need to look up a float, a boolean, a bit in a
- * bitfield, a matrix or other types instead, so we need to track the
- * type of the value in struct gl_context.  And sometimes the value isn't in
- * struct gl_context but in the drawbuffer, the array object, current texture
- * unit, or maybe it's a computed value.  So we need to also track
- * where or how to find the value.  Finally, we sometimes need to
- * check that one of a number of extensions are enabled, the GL
- * version or flush or call _mesa_update_state().  This is done by
- * attaching optional extra information to the value description
- * struct, it's sort of like an array of opcodes that describe extra
- * checks or actions.
- *
- * Putting all this together we end up with struct value_desc below,
- * and with a couple of macros to help, the table of struct value_desc
- * is about as concise as the specification in the old python script.
- */
-
-#undef CONST
-
-#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
-#define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
-                                ((F) * 65536.0f < INT_MIN) ? INT_MIN : \
-                                (GLint) ((F) * 65536.0f) )
-
-#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
-#define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \
-                                ((I) < SHRT_MIN) ? INT_MIN : \
-                                (GLint) ((I) * 65536) )
-
-#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
-#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
-
-#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
-#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
-#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
-#define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )
-
-#define ENUM_TO_INT64(E)      ( (GLint64) (E) )
-#define ENUM_TO_FIXED(E)      (E)
-
-enum value_type {
-   TYPE_INVALID,
-   TYPE_API_MASK,
-   TYPE_INT,
-   TYPE_INT_2,
-   TYPE_INT_3,
-   TYPE_INT_4,
-   TYPE_INT_N,
-   TYPE_INT64,
-   TYPE_ENUM,
-   TYPE_ENUM_2,
-   TYPE_BOOLEAN,
-   TYPE_BIT_0,
-   TYPE_BIT_1,
-   TYPE_BIT_2,
-   TYPE_BIT_3,
-   TYPE_BIT_4,
-   TYPE_BIT_5,
-   TYPE_FLOAT,
-   TYPE_FLOAT_2,
-   TYPE_FLOAT_3,
-   TYPE_FLOAT_4,
-   TYPE_FLOATN,
-   TYPE_FLOATN_2,
-   TYPE_FLOATN_3,
-   TYPE_FLOATN_4,
-   TYPE_DOUBLEN,
-   TYPE_MATRIX,
-   TYPE_MATRIX_T,
-   TYPE_CONST
-};
-
-enum value_location {
-   LOC_BUFFER,
-   LOC_CONTEXT,
-   LOC_ARRAY,
-   LOC_TEXUNIT,
-   LOC_CUSTOM
-};
-
-enum value_extra {
-   EXTRA_END = 0x8000,
-   EXTRA_VERSION_30,
-   EXTRA_VERSION_31,
-   EXTRA_VERSION_32,
-   EXTRA_VERSION_ES2,
-   EXTRA_NEW_BUFFERS, 
-   EXTRA_VALID_DRAW_BUFFER,
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_FLUSH_CURRENT,
-};
-
-#define NO_EXTRA NULL
-#define NO_OFFSET 0
-
-struct value_desc {
-   GLenum pname;
-   GLubyte location;  /**< enum value_location */
-   GLubyte type;      /**< enum value_type */
-   int offset;
-   const int *extra;
-};
-
-union value {
-   GLfloat value_float;
-   GLfloat value_float_4[4];
-   GLmatrix *value_matrix;
-   GLint value_int;
-   GLint value_int_4[4];
-   GLint64 value_int64;
-   GLenum value_enum;
-
-   /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
-   struct {
-      GLint n, ints[100];
-   } value_int_n;
-   GLboolean value_bool;
-};
-
-#define BUFFER_FIELD(field, type) \
-   LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
-#define CONTEXT_FIELD(field, type) \
-   LOC_CONTEXT, type, offsetof(struct gl_context, field)
-#define ARRAY_FIELD(field, type) \
-   LOC_ARRAY, type, offsetof(struct gl_array_object, field)
-#define CONST(value) \
-   LOC_CONTEXT, TYPE_CONST, value
-
-#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
-#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
-#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
-
-#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
-#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
-#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
-#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
-#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
-#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
-#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
-#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
-#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
-#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
-#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
-#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
-#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
-#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
-#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
-#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
-#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
-#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
-
-#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
-#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
-#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
-
-#define EXT(f)					\
-   offsetof(struct gl_extensions, f)
-
-#define EXTRA_EXT(e)				\
-   static const int extra_##e[] = {		\
-      EXT(e), EXTRA_END				\
-   }
-
-#define EXTRA_EXT2(e1, e2)			\
-   static const int extra_##e1##_##e2[] = {	\
-      EXT(e1), EXT(e2), EXTRA_END		\
-   }
-
-/* The 'extra' mechanism is a way to specify extra checks (such as
- * extensions or specific gl versions) or actions (flush current, new
- * buffers) that we need to do before looking up an enum.  We need to
- * declare them all up front so we can refer to them in the value_desc
- * structs below. */
-
-static const int extra_new_buffers[] = {
-   EXTRA_NEW_BUFFERS,
-   EXTRA_END
-};
-
-static const int extra_valid_draw_buffer[] = {
-   EXTRA_VALID_DRAW_BUFFER,
-   EXTRA_END
-};
-
-static const int extra_valid_texture_unit[] = {
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_END
-};
-
-static const int extra_flush_current_valid_texture_unit[] = {
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_END
-};
-
-static const int extra_flush_current[] = {
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_new_buffers_OES_read_format[] = {
-   EXTRA_NEW_BUFFERS,
-   EXT(OES_read_format),
-   EXTRA_END
-};
-
-static const int extra_EXT_secondary_color_flush_current[] = {
-   EXT(EXT_secondary_color),
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_EXT_fog_coord_flush_current[] = {
-   EXT(EXT_fog_coord),
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_EXT_texture_integer[] = {
-   EXT(EXT_texture_integer),
-   EXTRA_END
-};
-
-static const int extra_EXT_gpu_shader4[] = {
-   EXT(EXT_gpu_shader4),
-   EXTRA_END
-};
-
-
-EXTRA_EXT(ARB_ES2_compatibility);
-EXTRA_EXT(ARB_multitexture);
-EXTRA_EXT(ARB_texture_cube_map);
-EXTRA_EXT(MESA_texture_array);
-EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);
-EXTRA_EXT(EXT_secondary_color);
-EXTRA_EXT(EXT_fog_coord);
-EXTRA_EXT(EXT_texture_lod_bias);
-EXTRA_EXT(EXT_texture_filter_anisotropic);
-EXTRA_EXT(IBM_rasterpos_clip);
-EXTRA_EXT(NV_point_sprite);
-EXTRA_EXT(SGIS_generate_mipmap);
-EXTRA_EXT(NV_vertex_program);
-EXTRA_EXT(NV_fragment_program);
-EXTRA_EXT(NV_texture_rectangle);
-EXTRA_EXT(EXT_stencil_two_side);
-EXTRA_EXT(NV_light_max_exponent);
-EXTRA_EXT(EXT_depth_bounds_test);
-EXTRA_EXT(ARB_depth_clamp);
-EXTRA_EXT(ATI_fragment_shader);
-EXTRA_EXT(EXT_framebuffer_blit);
-EXTRA_EXT(ARB_shader_objects);
-EXTRA_EXT(EXT_provoking_vertex);
-EXTRA_EXT(ARB_fragment_shader);
-EXTRA_EXT(ARB_fragment_program);
-EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);
-EXTRA_EXT(EXT_framebuffer_object);
-EXTRA_EXT(APPLE_vertex_array_object);
-EXTRA_EXT(ARB_seamless_cube_map);
-EXTRA_EXT(EXT_compiled_vertex_array);
-EXTRA_EXT(ARB_sync);
-EXTRA_EXT(ARB_vertex_shader);
-EXTRA_EXT(EXT_transform_feedback);
-EXTRA_EXT(ARB_transform_feedback2);
-EXTRA_EXT(EXT_pixel_buffer_object);
-EXTRA_EXT(ARB_vertex_program);
-EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);
-EXTRA_EXT2(ARB_fragment_program, NV_fragment_program);
-EXTRA_EXT2(ARB_vertex_program, NV_vertex_program);
-EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
-EXTRA_EXT(ARB_vertex_buffer_object);
-EXTRA_EXT(ARB_geometry_shader4);
-EXTRA_EXT(ARB_copy_buffer);
-EXTRA_EXT(EXT_framebuffer_sRGB);
-
-static const int
-extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
-   EXT(ARB_vertex_program),
-   EXT(ARB_fragment_program),
-   EXT(NV_vertex_program),
-   EXTRA_END
-};
-
-static const int
-extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
-   EXT(NV_vertex_program),
-   EXT(ARB_vertex_program),
-   EXT(ARB_fragment_program),
-   EXT(NV_vertex_program),
-   EXTRA_END
-};
-
-static const int
-extra_NV_primitive_restart[] = {
-   EXT(NV_primitive_restart),
-   EXTRA_END
-};
-
-static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
-static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
-static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
-
-static const int
-extra_ARB_vertex_program_version_es2[] = {
-   EXT(ARB_vertex_program),
-   EXTRA_VERSION_ES2,
-   EXTRA_END
-};
-
-#define API_OPENGL_BIT (1 << API_OPENGL)
-#define API_OPENGLES_BIT (1 << API_OPENGLES)
-#define API_OPENGLES2_BIT (1 << API_OPENGLES2)
-
-/* This is the big table describing all the enums we accept in
- * glGet*v().  The table is partitioned into six parts: enums
- * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
- * between OpenGL and GLES, enums exclusive to GLES, etc for the
- * remaining combinations.  When we add the enums to the hash table in
- * _mesa_init_get_hash(), we only add the enums for the API we're
- * instantiating and the different sections are guarded by #if
- * FEATURE_GL etc to make sure we only compile in the enums we may
- * need. */
-
-static const struct value_desc values[] = {
-   /* Enums shared between OpenGL, GLES1 and GLES2 */
-   { 0, 0, TYPE_API_MASK,
-     API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT, NO_EXTRA},
-   { GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers },
-   { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },
-   { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },
-   { GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },
-   { GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-   { GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },
-   { GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },
-   { GL_DEPTH_BITS, BUFFER_INT(Visual.depthBits), NO_EXTRA },
-   { GL_DEPTH_CLEAR_VALUE, CONTEXT_FIELD(Depth.Clear, TYPE_DOUBLEN), NO_EXTRA },
-   { GL_DEPTH_FUNC, CONTEXT_ENUM(Depth.Func), NO_EXTRA },
-   { GL_DEPTH_RANGE, CONTEXT_FIELD(Viewport.Near, TYPE_FLOATN_2), NO_EXTRA },
-   { GL_DEPTH_TEST, CONTEXT_BOOL(Depth.Test), NO_EXTRA },
-   { GL_DEPTH_WRITEMASK, CONTEXT_BOOL(Depth.Mask), NO_EXTRA },
-   { GL_DITHER, CONTEXT_BOOL(Color.DitherFlag), NO_EXTRA },
-   { GL_FRONT_FACE, CONTEXT_ENUM(Polygon.FrontFace), NO_EXTRA },
-   { GL_GREEN_BITS, BUFFER_INT(Visual.greenBits), extra_new_buffers },
-   { GL_LINE_WIDTH, CONTEXT_FLOAT(Line.Width), NO_EXTRA },
-   { GL_ALIASED_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidth), NO_EXTRA },
-   { GL_MAX_ELEMENTS_VERTICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
-   { GL_MAX_ELEMENTS_INDICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
-   { GL_MAX_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.MaxTextureLevels), NO_EXTRA },
-   { GL_MAX_VIEWPORT_DIMS, CONTEXT_INT2(Const.MaxViewportWidth), NO_EXTRA },
-   { GL_PACK_ALIGNMENT, CONTEXT_INT(Pack.Alignment), NO_EXTRA },
-   { GL_ALIASED_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSize), NO_EXTRA },
-   { GL_POLYGON_OFFSET_FACTOR, CONTEXT_FLOAT(Polygon.OffsetFactor ), NO_EXTRA },
-   { GL_POLYGON_OFFSET_UNITS, CONTEXT_FLOAT(Polygon.OffsetUnits ), NO_EXTRA },
-   { GL_POLYGON_OFFSET_FILL, CONTEXT_BOOL(Polygon.OffsetFill), NO_EXTRA },
-   { GL_RED_BITS, BUFFER_INT(Visual.redBits), extra_new_buffers },
-   { GL_SCISSOR_BOX, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-   { GL_SCISSOR_TEST, CONTEXT_BOOL(Scissor.Enabled), NO_EXTRA },
-   { GL_STENCIL_BITS, BUFFER_INT(Visual.stencilBits), NO_EXTRA },
-   { GL_STENCIL_CLEAR_VALUE, CONTEXT_INT(Stencil.Clear), NO_EXTRA },
-   { GL_STENCIL_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_FUNC, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_PASS_DEPTH_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_PASS_DEPTH_PASS, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_REF, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_TEST, CONTEXT_BOOL(Stencil.Enabled), NO_EXTRA },
-   { GL_STENCIL_VALUE_MASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_WRITEMASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_SUBPIXEL_BITS, CONTEXT_INT(Const.SubPixelBits), NO_EXTRA },
-   { GL_TEXTURE_BINDING_2D, LOC_CUSTOM, TYPE_INT, TEXTURE_2D_INDEX, NO_EXTRA },
-   { GL_UNPACK_ALIGNMENT, CONTEXT_INT(Unpack.Alignment), NO_EXTRA },
-   { GL_VIEWPORT, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-
-   /* GL_ARB_multitexture */
-   { GL_ACTIVE_TEXTURE_ARB,
-     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
-
-   /* Note that all the OES_* extensions require that the Mesa "struct
-    * gl_extensions" include a member with the name of the extension.
-    * That structure does not yet include OES extensions (and we're
-    * not sure whether it will).  If it does, all the OES_*
-    * extensions below should mark the dependency. */
-
-   /* GL_ARB_texture_cube_map */
-   { GL_TEXTURE_BINDING_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_CUBE_INDEX, extra_ARB_texture_cube_map },
-   { GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.MaxCubeTextureLevels),
-     extra_ARB_texture_cube_map }, /* XXX: OES_texture_cube_map */
-
-   /* XXX: OES_blend_subtract */
-   { GL_BLEND_SRC_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },
-   { GL_BLEND_DST_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },
-   { GL_BLEND_SRC_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].SrcA), NO_EXTRA },
-   { GL_BLEND_DST_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].DstA), NO_EXTRA },
-
-   /* GL_BLEND_EQUATION_RGB, which is what we're really after, is
-    * defined identically to GL_BLEND_EQUATION. */
-   { GL_BLEND_EQUATION, CONTEXT_ENUM(Color.Blend[0].EquationRGB), NO_EXTRA },
-   { GL_BLEND_EQUATION_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].EquationA), NO_EXTRA },
-
-   /* GL_ARB_texture_compression */
-   { GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT_N, 0, NO_EXTRA },
-
-   /* GL_ARB_multisample */
-   { GL_SAMPLE_ALPHA_TO_COVERAGE_ARB,
-     CONTEXT_BOOL(Multisample.SampleAlphaToCoverage), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_ARB, CONTEXT_BOOL(Multisample.SampleCoverage), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_VALUE_ARB,
-     CONTEXT_FLOAT(Multisample.SampleCoverageValue), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_INVERT_ARB,
-     CONTEXT_BOOL(Multisample.SampleCoverageInvert), NO_EXTRA },
-   { GL_SAMPLE_BUFFERS_ARB, BUFFER_INT(Visual.sampleBuffers), NO_EXTRA },
-   { GL_SAMPLES_ARB, BUFFER_INT(Visual.samples), NO_EXTRA },
-
-   /* GL_SGIS_generate_mipmap */
-   { GL_GENERATE_MIPMAP_HINT_SGIS, CONTEXT_ENUM(Hint.GenerateMipmap),
-     extra_SGIS_generate_mipmap },
-
-   /* GL_ARB_vertex_buffer_object */
-   { GL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-
-   /* GL_ARB_vertex_buffer_object */
-   /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported */
-   { GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_buffer_object },
-
-   /* GL_ARB_copy_buffer */
-   { GL_COPY_READ_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
-   { GL_COPY_WRITE_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
-
-   /* GL_OES_read_format */
-   { GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, LOC_CUSTOM, TYPE_INT, 0,
-     extra_new_buffers_OES_read_format },
-   { GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, LOC_CUSTOM, TYPE_INT, 0,
-     extra_new_buffers_OES_read_format },
-
-   /* GL_EXT_framebuffer_object */
-   { GL_FRAMEBUFFER_BINDING_EXT, BUFFER_INT(Name),
-     extra_EXT_framebuffer_object },
-   { GL_RENDERBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_framebuffer_object },
-   { GL_MAX_RENDERBUFFER_SIZE_EXT, CONTEXT_INT(Const.MaxRenderbufferSize),
-     extra_EXT_framebuffer_object },
-
-   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's
-    * GLSL: */
-   { GL_MAX_CLIP_PLANES, CONTEXT_INT(Const.MaxClipPlanes), NO_EXTRA },
-
-#if FEATURE_GL || FEATURE_ES1
-   /* Enums in OpenGL and GLES1 */
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT, NO_EXTRA },
-   { GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA },
-   { GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA },
-   { GL_LIGHT2, CONTEXT_BOOL(Light.Light[2].Enabled), NO_EXTRA },
-   { GL_LIGHT3, CONTEXT_BOOL(Light.Light[3].Enabled), NO_EXTRA },
-   { GL_LIGHT4, CONTEXT_BOOL(Light.Light[4].Enabled), NO_EXTRA },
-   { GL_LIGHT5, CONTEXT_BOOL(Light.Light[5].Enabled), NO_EXTRA },
-   { GL_LIGHT6, CONTEXT_BOOL(Light.Light[6].Enabled), NO_EXTRA },
-   { GL_LIGHT7, CONTEXT_BOOL(Light.Light[7].Enabled), NO_EXTRA },
-   { GL_LIGHTING, CONTEXT_BOOL(Light.Enabled), NO_EXTRA },
-   { GL_LIGHT_MODEL_AMBIENT,
-     CONTEXT_FIELD(Light.Model.Ambient[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },
-   { GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },
-   { GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },
-   { GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },
-   { GL_BLEND_DST, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },
-   { GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE2, CONTEXT_BIT2(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE3, CONTEXT_BIT3(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE4, CONTEXT_BIT4(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE5, CONTEXT_BIT5(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_COLOR_MATERIAL, CONTEXT_BOOL(Light.ColorMaterialEnabled), NO_EXTRA },
-   { GL_CURRENT_COLOR,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR0][0], TYPE_FLOATN_4),
-     extra_flush_current },
-   { GL_CURRENT_NORMAL,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_NORMAL][0], TYPE_FLOATN_3),
-     extra_flush_current },
-   { GL_CURRENT_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
-     extra_flush_current_valid_texture_unit },
-   { GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },
-   { GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },
-   { GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },
-   { GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },
-   { GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },
-   { GL_FOG_MODE, CONTEXT_ENUM(Fog.Mode), NO_EXTRA },
-   { GL_FOG_START, CONTEXT_FLOAT(Fog.Start), NO_EXTRA },
-   { GL_LINE_SMOOTH, CONTEXT_BOOL(Line.SmoothFlag), NO_EXTRA },
-   { GL_LINE_SMOOTH_HINT, CONTEXT_ENUM(Hint.LineSmooth), NO_EXTRA },
-   { GL_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidthAA), NO_EXTRA },
-   { GL_COLOR_LOGIC_OP, CONTEXT_BOOL(Color.ColorLogicOpEnabled), NO_EXTRA },
-   { GL_LOGIC_OP_MODE, CONTEXT_ENUM(Color.LogicOp), NO_EXTRA },
-   { GL_MATRIX_MODE, CONTEXT_ENUM(Transform.MatrixMode), NO_EXTRA },
-   { GL_MAX_MODELVIEW_STACK_DEPTH, CONST(MAX_MODELVIEW_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_PROJECTION_STACK_DEPTH, CONST(MAX_PROJECTION_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_TEXTURE_STACK_DEPTH, CONST(MAX_TEXTURE_STACK_DEPTH), NO_EXTRA },
-   { GL_MODELVIEW_MATRIX, CONTEXT_MATRIX(ModelviewMatrixStack.Top), NO_EXTRA },
-   { GL_MODELVIEW_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, ModelviewMatrixStack.Depth), NO_EXTRA },
-   { GL_NORMALIZE, CONTEXT_BOOL(Transform.Normalize), NO_EXTRA },
-   { GL_PACK_SKIP_IMAGES_EXT, CONTEXT_INT(Pack.SkipImages), NO_EXTRA },
-   { GL_PERSPECTIVE_CORRECTION_HINT, CONTEXT_ENUM(Hint.PerspectiveCorrection), NO_EXTRA },
-   { GL_POINT_SIZE, CONTEXT_FLOAT(Point.Size), NO_EXTRA },
-   { GL_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSizeAA), NO_EXTRA },
-   { GL_POINT_SMOOTH, CONTEXT_BOOL(Point.SmoothFlag), NO_EXTRA },
-   { GL_POINT_SMOOTH_HINT, CONTEXT_ENUM(Hint.PointSmooth), NO_EXTRA },
-   { GL_POINT_SIZE_MIN_EXT, CONTEXT_FLOAT(Point.MinSize), NO_EXTRA },
-   { GL_POINT_SIZE_MAX_EXT, CONTEXT_FLOAT(Point.MaxSize), NO_EXTRA },
-   { GL_POINT_FADE_THRESHOLD_SIZE_EXT, CONTEXT_FLOAT(Point.Threshold), NO_EXTRA },
-   { GL_PROJECTION_MATRIX, CONTEXT_MATRIX(ProjectionMatrixStack.Top), NO_EXTRA },
-   { GL_PROJECTION_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, ProjectionMatrixStack.Depth), NO_EXTRA },
-   { GL_RESCALE_NORMAL, CONTEXT_BOOL(Transform.RescaleNormals), NO_EXTRA },
-   { GL_SHADE_MODEL, CONTEXT_ENUM(Light.ShadeModel), NO_EXTRA },
-   { GL_TEXTURE_2D, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   { GL_TEXTURE_MATRIX, LOC_CUSTOM, TYPE_MATRIX, 0, extra_valid_texture_unit },
-   { GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,
-     extra_valid_texture_unit  },
-
-   { GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA },
-   { GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA },
-   { GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA },
-   { GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA },
-   { GL_NORMAL_ARRAY, ARRAY_ENUM(Normal.Enabled), NO_EXTRA },
-   { GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA },
-   { GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA },
-   { GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA },
-   { GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA },
-   { GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA },
-   { GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_SIZE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Size), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_TYPE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Type), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_STRIDE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Stride), NO_EXTRA },
-
-   /* GL_ARB_ES2_compatibility */
-   { GL_SHADER_COMPILER, CONST(1), extra_ARB_ES2_compatibility },
-   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying),
-     extra_ARB_ES2_compatibility },
-   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_ES2_compatibility },
-   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_ES2_compatibility },
-
-   /* GL_ARB_multitexture */
-   { GL_MAX_TEXTURE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxTextureUnits), extra_ARB_multitexture },
-   { GL_CLIENT_ACTIVE_TEXTURE_ARB,
-     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
-
-   /* GL_ARB_texture_cube_map */
-   { GL_TEXTURE_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   /* S, T, and R are always set at the same time */
-   { GL_TEXTURE_GEN_STR_OES, LOC_TEXUNIT, TYPE_BIT_0,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-
-   /* GL_ARB_multisample */
-   { GL_MULTISAMPLE_ARB, CONTEXT_BOOL(Multisample.Enabled), NO_EXTRA },
-   { GL_SAMPLE_ALPHA_TO_ONE_ARB, CONTEXT_BOOL(Multisample.SampleAlphaToOne), NO_EXTRA },
-
-   /* GL_ARB_vertex_buffer_object */
-   { GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA },
-   { GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA },
-   { GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-
-   /* GL_OES_point_sprite */
-   { GL_POINT_SPRITE_NV,
-     CONTEXT_BOOL(Point.PointSprite),
-     extra_NV_point_sprite_ARB_point_sprite },
-
-   /* GL_ARB_fragment_shader */
-   { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.FragmentProgram.MaxUniformComponents),
-     extra_ARB_fragment_shader },
-
-   /* GL_ARB_vertex_shader */
-   { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.VertexProgram.MaxUniformComponents),
-     extra_ARB_vertex_shader },
-   { GL_MAX_VARYING_FLOATS_ARB, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_shader },
-
-   /* GL_EXT_texture_lod_bias */
-   { GL_MAX_TEXTURE_LOD_BIAS_EXT, CONTEXT_FLOAT(Const.MaxTextureLodBias),
-	 extra_EXT_texture_lod_bias },
-
-   /* GL_EXT_texture_filter_anisotropic */
-   { GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,
-     CONTEXT_FLOAT(Const.MaxTextureMaxAnisotropy),
-     extra_EXT_texture_filter_anisotropic },
-#endif /* FEATURE_GL || FEATURE_ES1 */
-
-#if FEATURE_ES1
-   { 0, 0, TYPE_API_MASK, API_OPENGLES_BIT },
-   /* XXX: OES_matrix_get */
-   { GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES },
-   { GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES },
-   { GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES },
-
-   /* OES_point_size_array */
-   { GL_POINT_SIZE_ARRAY_OES, ARRAY_FIELD(PointSize.Enabled, TYPE_BOOLEAN) },
-   { GL_POINT_SIZE_ARRAY_TYPE_OES, ARRAY_FIELD(PointSize.Type, TYPE_ENUM) },
-   { GL_POINT_SIZE_ARRAY_STRIDE_OES, ARRAY_FIELD(PointSize.Stride, TYPE_INT) },
-   { GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES, LOC_CUSTOM, TYPE_INT, 0 },
-#endif /* FEATURE_ES1 */
-
-#if FEATURE_GL || FEATURE_ES2
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES2_BIT, NO_EXTRA },
-   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's GLSL: */
-   { GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA },
-   { GL_MAX_TEXTURE_COORDS_ARB, /* == GL_MAX_TEXTURE_COORDS_NV */
-     CONTEXT_INT(Const.MaxTextureCoordUnits),
-     extra_ARB_fragment_program_NV_fragment_program },
-
-   /* GL_ARB_draw_buffers */
-   { GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },
-
-   { GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   /* GL_ARB_fragment_program */
-   { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */
-     CONTEXT_INT(Const.MaxTextureImageUnits),
-     extra_ARB_fragment_program_NV_fragment_program },
-   { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxVertexTextureImageUnits), extra_ARB_vertex_shader },
-   { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxCombinedTextureImageUnits),
-     extra_ARB_vertex_shader },
-
-   /* GL_ARB_shader_objects
-    * Actually, this token isn't part of GL_ARB_shader_objects, but is
-    * close enough for now. */
-   { GL_CURRENT_PROGRAM, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_objects },
-
-   /* OpenGL 2.0 */
-   { GL_STENCIL_BACK_FUNC, CONTEXT_ENUM(Stencil.Function[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_VALUE_MASK, CONTEXT_INT(Stencil.ValueMask[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_WRITEMASK, CONTEXT_INT(Stencil.WriteMask[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_REF, CONTEXT_INT(Stencil.Ref[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_FAIL, CONTEXT_ENUM(Stencil.FailFunc[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_PASS_DEPTH_FAIL, CONTEXT_ENUM(Stencil.ZFailFunc[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_PASS_DEPTH_PASS, CONTEXT_ENUM(Stencil.ZPassFunc[1]), NO_EXTRA },
-
-   { GL_MAX_VERTEX_ATTRIBS_ARB,
-     CONTEXT_INT(Const.VertexProgram.MaxAttribs),
-     extra_ARB_vertex_program_version_es2 },
-
-   /* OES_texture_3D */
-   { GL_TEXTURE_BINDING_3D, LOC_CUSTOM, TYPE_INT, TEXTURE_3D_INDEX, NO_EXTRA },
-   { GL_MAX_3D_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.Max3DTextureLevels), NO_EXTRA },
-
-   /* GL_ARB_fragment_program/OES_standard_derivatives */
-   { GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB,
-     CONTEXT_ENUM(Hint.FragmentShaderDerivative), extra_ARB_fragment_shader },
-#endif /* FEATURE_GL || FEATURE_ES2 */
-
-#if FEATURE_ES2
-   /* Enums unique to OpenGL ES 2.0 */
-   { 0, 0, TYPE_API_MASK, API_OPENGLES2_BIT, NO_EXTRA },
-   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying), NO_EXTRA },
-   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_SHADER_COMPILER, CONST(1), NO_EXTRA },
-   /* OES_get_program_binary */
-   { GL_NUM_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
-   { GL_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
-#endif /* FEATURE_ES2 */
-
-#if FEATURE_GL
-   /* Remaining enums are only in OpenGL */
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA },
-   { GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA },
-   { GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA },
-   { GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA },
-   { GL_ACCUM_ALPHA_BITS, BUFFER_INT(Visual.accumAlphaBits), NO_EXTRA },
-   { GL_ACCUM_CLEAR_VALUE, CONTEXT_FIELD(Accum.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_ALPHA_BIAS, CONTEXT_FLOAT(Pixel.AlphaBias), NO_EXTRA },
-   { GL_ALPHA_SCALE, CONTEXT_FLOAT(Pixel.AlphaScale), NO_EXTRA },
-   { GL_ATTRIB_STACK_DEPTH, CONTEXT_INT(AttribStackDepth), NO_EXTRA },
-   { GL_AUTO_NORMAL, CONTEXT_BOOL(Eval.AutoNormal), NO_EXTRA },
-   { GL_AUX_BUFFERS, BUFFER_INT(Visual.numAuxBuffers), NO_EXTRA },
-   { GL_BLUE_BIAS, CONTEXT_FLOAT(Pixel.BlueBias), NO_EXTRA },
-   { GL_BLUE_SCALE, CONTEXT_FLOAT(Pixel.BlueScale), NO_EXTRA },
-   { GL_CLIENT_ATTRIB_STACK_DEPTH, CONTEXT_INT(ClientAttribStackDepth), NO_EXTRA },
-   { GL_COLOR_MATERIAL_FACE, CONTEXT_ENUM(Light.ColorMaterialFace), NO_EXTRA },
-   { GL_COLOR_MATERIAL_PARAMETER, CONTEXT_ENUM(Light.ColorMaterialMode), NO_EXTRA },
-   { GL_CURRENT_INDEX,
-     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]),
-     extra_flush_current },
-   { GL_CURRENT_RASTER_COLOR,
-     CONTEXT_FIELD(Current.RasterColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_CURRENT_RASTER_DISTANCE, CONTEXT_FLOAT(Current.RasterDistance), NO_EXTRA },
-   { GL_CURRENT_RASTER_INDEX, CONST(1), NO_EXTRA },
-   { GL_CURRENT_RASTER_POSITION, CONTEXT_FLOAT4(Current.RasterPos[0]), NO_EXTRA },
-   { GL_CURRENT_RASTER_SECONDARY_COLOR,
-     CONTEXT_FIELD(Current.RasterSecondaryColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_CURRENT_RASTER_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
-     extra_valid_texture_unit },
-   { GL_CURRENT_RASTER_POSITION_VALID, CONTEXT_BOOL(Current.RasterPosValid), NO_EXTRA },
-   { GL_DEPTH_BIAS, CONTEXT_FLOAT(Pixel.DepthBias), NO_EXTRA },
-   { GL_DEPTH_SCALE, CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA },
-   { GL_DOUBLEBUFFER, BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA },
-   { GL_DRAW_BUFFER, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
-   { GL_EDGE_FLAG, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   { GL_FEEDBACK_BUFFER_SIZE, CONTEXT_INT(Feedback.BufferSize), NO_EXTRA },
-   { GL_FEEDBACK_BUFFER_TYPE, CONTEXT_ENUM(Feedback.Type), NO_EXTRA },
-   { GL_FOG_INDEX, CONTEXT_FLOAT(Fog.Index), NO_EXTRA },
-   { GL_GREEN_BIAS, CONTEXT_FLOAT(Pixel.GreenBias), NO_EXTRA },
-   { GL_GREEN_SCALE, CONTEXT_FLOAT(Pixel.GreenScale), NO_EXTRA },
-   { GL_INDEX_BITS, BUFFER_INT(Visual.indexBits), extra_new_buffers },
-   { GL_INDEX_CLEAR_VALUE, CONTEXT_INT(Color.ClearIndex), NO_EXTRA },
-   { GL_INDEX_MODE, CONST(0) , NO_EXTRA}, 
-   { GL_INDEX_OFFSET, CONTEXT_INT(Pixel.IndexOffset), NO_EXTRA },
-   { GL_INDEX_SHIFT, CONTEXT_INT(Pixel.IndexShift), NO_EXTRA },
-   { GL_INDEX_WRITEMASK, CONTEXT_INT(Color.IndexMask), NO_EXTRA },
-   { GL_LIGHT_MODEL_COLOR_CONTROL, CONTEXT_ENUM(Light.Model.ColorControl), NO_EXTRA },
-   { GL_LIGHT_MODEL_LOCAL_VIEWER, CONTEXT_BOOL(Light.Model.LocalViewer), NO_EXTRA },
-   { GL_LINE_STIPPLE, CONTEXT_BOOL(Line.StippleFlag), NO_EXTRA },
-   { GL_LINE_STIPPLE_PATTERN, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_LINE_STIPPLE_REPEAT, CONTEXT_INT(Line.StippleFactor), NO_EXTRA },
-   { GL_LINE_WIDTH_GRANULARITY, CONTEXT_FLOAT(Const.LineWidthGranularity), NO_EXTRA },
-   { GL_LIST_BASE, CONTEXT_INT(List.ListBase), NO_EXTRA },
-   { GL_LIST_INDEX, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_LIST_MODE, LOC_CUSTOM, TYPE_ENUM, 0, NO_EXTRA },
-   { GL_INDEX_LOGIC_OP, CONTEXT_BOOL(Color.IndexLogicOpEnabled), NO_EXTRA },
-   { GL_MAP1_COLOR_4, CONTEXT_BOOL(Eval.Map1Color4), NO_EXTRA },
-   { GL_MAP1_GRID_DOMAIN, CONTEXT_FLOAT2(Eval.MapGrid1u1), NO_EXTRA },
-   { GL_MAP1_GRID_SEGMENTS, CONTEXT_INT(Eval.MapGrid1un), NO_EXTRA },
-   { GL_MAP1_INDEX, CONTEXT_BOOL(Eval.Map1Index), NO_EXTRA },
-   { GL_MAP1_NORMAL, CONTEXT_BOOL(Eval.Map1Normal), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map1TextureCoord1), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map1TextureCoord2), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map1TextureCoord3), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map1TextureCoord4), NO_EXTRA },
-   { GL_MAP1_VERTEX_3, CONTEXT_BOOL(Eval.Map1Vertex3), NO_EXTRA },
-   { GL_MAP1_VERTEX_4, CONTEXT_BOOL(Eval.Map1Vertex4), NO_EXTRA },
-   { GL_MAP2_COLOR_4, CONTEXT_BOOL(Eval.Map2Color4), NO_EXTRA },
-   { GL_MAP2_GRID_DOMAIN, LOC_CUSTOM, TYPE_FLOAT_4, 0, NO_EXTRA },
-   { GL_MAP2_GRID_SEGMENTS, CONTEXT_INT2(Eval.MapGrid2un), NO_EXTRA },
-   { GL_MAP2_INDEX, CONTEXT_BOOL(Eval.Map2Index), NO_EXTRA },
-   { GL_MAP2_NORMAL, CONTEXT_BOOL(Eval.Map2Normal), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map2TextureCoord1), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map2TextureCoord2), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map2TextureCoord3), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map2TextureCoord4), NO_EXTRA },
-   { GL_MAP2_VERTEX_3, CONTEXT_BOOL(Eval.Map2Vertex3), NO_EXTRA },
-   { GL_MAP2_VERTEX_4, CONTEXT_BOOL(Eval.Map2Vertex4), NO_EXTRA },
-   { GL_MAP_COLOR, CONTEXT_BOOL(Pixel.MapColorFlag), NO_EXTRA },
-   { GL_MAP_STENCIL, CONTEXT_BOOL(Pixel.MapStencilFlag), NO_EXTRA },
-   { GL_MAX_ATTRIB_STACK_DEPTH, CONST(MAX_ATTRIB_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, CONST(MAX_CLIENT_ATTRIB_STACK_DEPTH), NO_EXTRA },
-
-   { GL_MAX_EVAL_ORDER, CONST(MAX_EVAL_ORDER), NO_EXTRA },
-   { GL_MAX_LIST_NESTING, CONST(MAX_LIST_NESTING), NO_EXTRA },
-   { GL_MAX_NAME_STACK_DEPTH, CONST(MAX_NAME_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_PIXEL_MAP_TABLE, CONST(MAX_PIXEL_MAP_TABLE), NO_EXTRA },
-   { GL_NAME_STACK_DEPTH, CONTEXT_INT(Select.NameStackDepth), NO_EXTRA },
-   { GL_PACK_LSB_FIRST, CONTEXT_BOOL(Pack.LsbFirst), NO_EXTRA },
-   { GL_PACK_ROW_LENGTH, CONTEXT_INT(Pack.RowLength), NO_EXTRA },
-   { GL_PACK_SKIP_PIXELS, CONTEXT_INT(Pack.SkipPixels), NO_EXTRA },
-   { GL_PACK_SKIP_ROWS, CONTEXT_INT(Pack.SkipRows), NO_EXTRA },
-   { GL_PACK_SWAP_BYTES, CONTEXT_BOOL(Pack.SwapBytes), NO_EXTRA },
-   { GL_PACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Pack.ImageHeight), NO_EXTRA },
-   { GL_PACK_INVERT_MESA, CONTEXT_BOOL(Pack.Invert), NO_EXTRA },
-   { GL_PIXEL_MAP_A_TO_A_SIZE, CONTEXT_INT(PixelMaps.AtoA.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_B_TO_B_SIZE, CONTEXT_INT(PixelMaps.BtoB.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_G_TO_G_SIZE, CONTEXT_INT(PixelMaps.GtoG.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_A_SIZE, CONTEXT_INT(PixelMaps.ItoA.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_B_SIZE, CONTEXT_INT(PixelMaps.ItoB.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_G_SIZE, CONTEXT_INT(PixelMaps.ItoG.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_I_SIZE, CONTEXT_INT(PixelMaps.ItoI.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_R_SIZE, CONTEXT_INT(PixelMaps.ItoR.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_R_TO_R_SIZE, CONTEXT_INT(PixelMaps.RtoR.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_S_TO_S_SIZE, CONTEXT_INT(PixelMaps.StoS.Size), NO_EXTRA },
-   { GL_POINT_SIZE_GRANULARITY, CONTEXT_FLOAT(Const.PointSizeGranularity), NO_EXTRA },
-   { GL_POLYGON_MODE, CONTEXT_ENUM2(Polygon.FrontMode), NO_EXTRA },
-   { GL_POLYGON_OFFSET_BIAS_EXT, CONTEXT_FLOAT(Polygon.OffsetUnits), NO_EXTRA },
-   { GL_POLYGON_OFFSET_POINT, CONTEXT_BOOL(Polygon.OffsetPoint), NO_EXTRA },
-   { GL_POLYGON_OFFSET_LINE, CONTEXT_BOOL(Polygon.OffsetLine), NO_EXTRA },
-   { GL_POLYGON_SMOOTH, CONTEXT_BOOL(Polygon.SmoothFlag), NO_EXTRA },
-   { GL_POLYGON_SMOOTH_HINT, CONTEXT_ENUM(Hint.PolygonSmooth), NO_EXTRA },
-   { GL_POLYGON_STIPPLE, CONTEXT_BOOL(Polygon.StippleFlag), NO_EXTRA },
-   { GL_READ_BUFFER, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_RED_BIAS, CONTEXT_FLOAT(Pixel.RedBias), NO_EXTRA },
-   { GL_RED_SCALE, CONTEXT_FLOAT(Pixel.RedScale), NO_EXTRA },
-   { GL_RENDER_MODE, CONTEXT_ENUM(RenderMode), NO_EXTRA },
-   { GL_RGBA_MODE, CONST(1), NO_EXTRA },
-   { GL_SELECTION_BUFFER_SIZE, CONTEXT_INT(Select.BufferSize), NO_EXTRA },
-   { GL_SHARED_TEXTURE_PALETTE_EXT, CONTEXT_BOOL(Texture.SharedPalette), NO_EXTRA },
-
-   { GL_STEREO, BUFFER_INT(Visual.stereoMode), NO_EXTRA },
-
-   { GL_TEXTURE_1D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_3D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_1D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_2D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-
-   { GL_TEXTURE_BINDING_1D, LOC_CUSTOM, TYPE_INT, TEXTURE_1D_INDEX, NO_EXTRA },
-   { GL_TEXTURE_BINDING_1D_ARRAY, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
-   { GL_TEXTURE_BINDING_2D_ARRAY, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
-   { GL_MAX_ARRAY_TEXTURE_LAYERS_EXT,
-     CONTEXT_INT(Const.MaxArrayTextureLayers), extra_MESA_texture_array },
-
-   { GL_TEXTURE_GEN_S, LOC_TEXUNIT, TYPE_BIT_0,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_T, LOC_TEXUNIT, TYPE_BIT_1,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_R, LOC_TEXUNIT, TYPE_BIT_2,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_Q, LOC_TEXUNIT, TYPE_BIT_3,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_UNPACK_LSB_FIRST, CONTEXT_BOOL(Unpack.LsbFirst), NO_EXTRA },
-   { GL_UNPACK_ROW_LENGTH, CONTEXT_INT(Unpack.RowLength), NO_EXTRA },
-   { GL_UNPACK_SKIP_PIXELS, CONTEXT_INT(Unpack.SkipPixels), NO_EXTRA },
-   { GL_UNPACK_SKIP_ROWS, CONTEXT_INT(Unpack.SkipRows), NO_EXTRA },
-   { GL_UNPACK_SWAP_BYTES, CONTEXT_BOOL(Unpack.SwapBytes), NO_EXTRA },
-   { GL_UNPACK_SKIP_IMAGES_EXT, CONTEXT_INT(Unpack.SkipImages), NO_EXTRA },
-   { GL_UNPACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Unpack.ImageHeight), NO_EXTRA },
-   { GL_UNPACK_CLIENT_STORAGE_APPLE, CONTEXT_BOOL(Unpack.ClientStorage), NO_EXTRA },
-   { GL_ZOOM_X, CONTEXT_FLOAT(Pixel.ZoomX), NO_EXTRA },
-   { GL_ZOOM_Y, CONTEXT_FLOAT(Pixel.ZoomY), NO_EXTRA },
-
-   /* Vertex arrays */
-   { GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA },
-   { GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA },
-   { GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA },
-   { GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-
-   /* GL_ARB_texture_compression */
-   { GL_TEXTURE_COMPRESSION_HINT_ARB, CONTEXT_INT(Hint.TextureCompression), NO_EXTRA },
-
-   /* GL_EXT_compiled_vertex_array */
-   { GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, CONTEXT_INT(Array.LockFirst),
-     extra_EXT_compiled_vertex_array },
-   { GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, CONTEXT_INT(Array.LockCount),
-     extra_EXT_compiled_vertex_array },
-
-   /* GL_ARB_transpose_matrix */
-   { GL_TRANSPOSE_MODELVIEW_MATRIX_ARB,
-     CONTEXT_MATRIX_T(ModelviewMatrixStack), NO_EXTRA },
-   { GL_TRANSPOSE_PROJECTION_MATRIX_ARB,
-     CONTEXT_MATRIX_T(ProjectionMatrixStack.Top), NO_EXTRA },
-   { GL_TRANSPOSE_TEXTURE_MATRIX_ARB, CONTEXT_MATRIX_T(TextureMatrixStack), NO_EXTRA },
-
-   /* GL_EXT_secondary_color */
-   { GL_COLOR_SUM_EXT, CONTEXT_BOOL(Fog.ColorSumEnabled),
-     extra_EXT_secondary_color_ARB_vertex_program },
-   { GL_CURRENT_SECONDARY_COLOR_EXT,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),
-     extra_EXT_secondary_color_flush_current },
-   { GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size),
-     extra_EXT_secondary_color },
-
-   /* GL_EXT_fog_coord */
-   { GL_CURRENT_FOG_COORDINATE_EXT,
-     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),
-     extra_EXT_fog_coord_flush_current },
-   { GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),
-     extra_EXT_fog_coord },
-
-   /* GL_IBM_rasterpos_clip */
-   { GL_RASTER_POSITION_UNCLIPPED_IBM,
-     CONTEXT_BOOL(Transform.RasterPositionUnclipped),
-     extra_IBM_rasterpos_clip },
-
-   /* GL_NV_point_sprite */
-   { GL_POINT_SPRITE_R_MODE_NV,
-     CONTEXT_ENUM(Point.SpriteRMode), extra_NV_point_sprite },
-   { GL_POINT_SPRITE_COORD_ORIGIN, CONTEXT_ENUM(Point.SpriteOrigin),
-     extra_NV_point_sprite_ARB_point_sprite },
-
-   /* GL_NV_vertex_program */
-   { GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB1_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[1]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB2_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[2]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB3_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[3]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB4_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[4]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB5_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[5]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB6_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[6]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB7_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[7]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB8_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[8]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB9_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[9]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB10_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[10]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB11_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[11]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB12_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[12]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB13_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[13]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB14_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[14]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB15_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[15]),
-     extra_NV_vertex_program },
-
-   /* GL_NV_fragment_program */
-   { GL_FRAGMENT_PROGRAM_NV, CONTEXT_BOOL(FragmentProgram.Enabled),
-     extra_NV_fragment_program },
-   { GL_FRAGMENT_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
-     extra_NV_fragment_program },
-   { GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV,
-     CONST(MAX_NV_FRAGMENT_PROGRAM_PARAMS),
-     extra_NV_fragment_program },
-
-   /* GL_NV_texture_rectangle */
-   { GL_TEXTURE_RECTANGLE_NV,
-     LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_NV_texture_rectangle },
-   { GL_TEXTURE_BINDING_RECTANGLE_NV,
-     LOC_CUSTOM, TYPE_INT, TEXTURE_RECT_INDEX, extra_NV_texture_rectangle },
-   { GL_MAX_RECTANGLE_TEXTURE_SIZE_NV,
-     CONTEXT_INT(Const.MaxTextureRectSize), extra_NV_texture_rectangle },
-
-   /* GL_EXT_stencil_two_side */
-   { GL_STENCIL_TEST_TWO_SIDE_EXT, CONTEXT_BOOL(Stencil.TestTwoSide),
-	 extra_EXT_stencil_two_side },
-   { GL_ACTIVE_STENCIL_FACE_EXT, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-
-   /* GL_NV_light_max_exponent */
-   { GL_MAX_SHININESS_NV, CONTEXT_FLOAT(Const.MaxShininess),
-     extra_NV_light_max_exponent },
-   { GL_MAX_SPOT_EXPONENT_NV, CONTEXT_FLOAT(Const.MaxSpotExponent),
-     extra_NV_light_max_exponent },
-     
-   /* GL_NV_primitive_restart */
-   { GL_PRIMITIVE_RESTART_NV, CONTEXT_BOOL(Array.PrimitiveRestart),
-     extra_NV_primitive_restart },
-   { GL_PRIMITIVE_RESTART_INDEX_NV, CONTEXT_INT(Array.RestartIndex),
-     extra_NV_primitive_restart },
- 
-   /* GL_ARB_vertex_buffer_object */
-   { GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA },
-   { GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA },
-   { GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA },
-
-   /* GL_EXT_pixel_buffer_object */
-   { GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_pixel_buffer_object },
-   { GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_pixel_buffer_object },
-
-   /* GL_ARB_vertex_program */
-   { GL_VERTEX_PROGRAM_ARB, /* == GL_VERTEX_PROGRAM_NV */
-     CONTEXT_BOOL(VertexProgram.Enabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_VERTEX_PROGRAM_POINT_SIZE_ARB, /* == GL_VERTEX_PROGRAM_POINT_SIZE_NV*/
-     CONTEXT_BOOL(VertexProgram.PointSizeEnabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_VERTEX_PROGRAM_TWO_SIDE_ARB, /* == GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-     CONTEXT_BOOL(VertexProgram.TwoSideEnabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, /* == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-     CONTEXT_INT(Const.MaxProgramMatrixStackDepth),
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_MAX_PROGRAM_MATRICES_ARB, /* == GL_MAX_TRACK_MATRICES_NV */
-     CONTEXT_INT(Const.MaxProgramMatrices),
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_CURRENT_MATRIX_STACK_DEPTH_ARB, /* == GL_CURRENT_MATRIX_STACK_DEPTH_NV */
-     LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-
-   { GL_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
-     LOC_CUSTOM, TYPE_MATRIX, 0,
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_TRANSPOSE_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
-     LOC_CUSTOM, TYPE_MATRIX, 0,
-     extra_ARB_vertex_program_ARB_fragment_program },
-
-   { GL_PROGRAM_ERROR_POSITION_ARB, /* == GL_PROGRAM_ERROR_POSITION_NV */
-     CONTEXT_INT(Program.ErrorPos),
-     extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-
-   /* GL_ARB_fragment_program */
-   { GL_FRAGMENT_PROGRAM_ARB, CONTEXT_BOOL(FragmentProgram.Enabled),
-     extra_ARB_fragment_program },
-
-   /* GL_EXT_depth_bounds_test */
-   { GL_DEPTH_BOUNDS_TEST_EXT, CONTEXT_BOOL(Depth.BoundsTest),
-     extra_EXT_depth_bounds_test },
-   { GL_DEPTH_BOUNDS_EXT, CONTEXT_FLOAT2(Depth.BoundsMin),
-     extra_EXT_depth_bounds_test },
-
-   /* GL_ARB_depth_clamp*/
-   { GL_DEPTH_CLAMP, CONTEXT_BOOL(Transform.DepthClamp),
-     extra_ARB_depth_clamp },
-
-   /* GL_ARB_draw_buffers */
-   { GL_DRAW_BUFFER0_ARB, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
-   { GL_DRAW_BUFFER1_ARB, BUFFER_ENUM(ColorDrawBuffer[1]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER2_ARB, BUFFER_ENUM(ColorDrawBuffer[2]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER3_ARB, BUFFER_ENUM(ColorDrawBuffer[3]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER4_ARB, BUFFER_ENUM(ColorDrawBuffer[4]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER5_ARB, BUFFER_ENUM(ColorDrawBuffer[5]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER6_ARB, BUFFER_ENUM(ColorDrawBuffer[6]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER7_ARB, BUFFER_ENUM(ColorDrawBuffer[7]),
-     extra_valid_draw_buffer },
-
-   /* GL_ATI_fragment_shader */
-   { GL_NUM_FRAGMENT_REGISTERS_ATI, CONST(6), extra_ATI_fragment_shader },
-   { GL_NUM_FRAGMENT_CONSTANTS_ATI, CONST(8), extra_ATI_fragment_shader },
-   { GL_NUM_PASSES_ATI, CONST(2), extra_ATI_fragment_shader },
-   { GL_NUM_INSTRUCTIONS_PER_PASS_ATI, CONST(8), extra_ATI_fragment_shader },
-   { GL_NUM_INSTRUCTIONS_TOTAL_ATI, CONST(16), extra_ATI_fragment_shader },
-   { GL_COLOR_ALPHA_PAIRING_ATI, CONST(GL_TRUE), extra_ATI_fragment_shader },
-   { GL_NUM_LOOPBACK_COMPONENTS_ATI, CONST(3), extra_ATI_fragment_shader },
-   { GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI,
-     CONST(3), extra_ATI_fragment_shader },
-
-   /* GL_EXT_framebuffer_object */
-   { GL_MAX_COLOR_ATTACHMENTS_EXT, CONTEXT_INT(Const.MaxColorAttachments),
-     extra_EXT_framebuffer_object },
-   
-   /* GL_EXT_framebuffer_blit
-    * NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT */
-   { GL_READ_FRAMEBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_framebuffer_blit },
-
-   /* GL_EXT_provoking_vertex */
-   { GL_PROVOKING_VERTEX_EXT,
-     CONTEXT_BOOL(Light.ProvokingVertex), extra_EXT_provoking_vertex },
-   { GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT,
-     CONTEXT_BOOL(Const.QuadsFollowProvokingVertexConvention),
-     extra_EXT_provoking_vertex },
-
-   /* GL_ARB_framebuffer_object */
-   { GL_MAX_SAMPLES, CONTEXT_INT(Const.MaxSamples),
-     extra_ARB_framebuffer_object_EXT_framebuffer_multisample },
-
-   /* GL_APPLE_vertex_array_object */
-   { GL_VERTEX_ARRAY_BINDING_APPLE, ARRAY_INT(Name),
-     extra_APPLE_vertex_array_object },
-
-   /* GL_ARB_seamless_cube_map */
-   { GL_TEXTURE_CUBE_MAP_SEAMLESS,
-     CONTEXT_BOOL(Texture.CubeMapSeamless), extra_ARB_seamless_cube_map },
-
-   /* GL_ARB_sync */
-   { GL_MAX_SERVER_WAIT_TIMEOUT,
-     CONTEXT_INT64(Const.MaxServerWaitTimeout), extra_ARB_sync },
-
-   /* GL_EXT_texture_integer */
-   { GL_RGBA_INTEGER_MODE_EXT, BUFFER_BOOL(_IntegerColor),
-     extra_EXT_texture_integer },
-
-   /* GL_EXT_transform_feedback */
-   { GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_transform_feedback },
-   { GL_RASTERIZER_DISCARD, CONTEXT_BOOL(TransformFeedback.RasterDiscard),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
-     CONTEXT_INT(Const.MaxTransformFeedbackInterleavedComponents),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
-     CONTEXT_INT(Const.MaxTransformFeedbackSeparateAttribs),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
-     CONTEXT_INT(Const.MaxTransformFeedbackSeparateComponents),
-     extra_EXT_transform_feedback },
-
-   /* GL_ARB_transform_feedback2 */
-   { GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, LOC_CUSTOM, TYPE_BOOLEAN, 0,
-     extra_ARB_transform_feedback2 },
-   { GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, LOC_CUSTOM, TYPE_BOOLEAN, 0,
-     extra_ARB_transform_feedback2 },
-   { GL_TRANSFORM_FEEDBACK_BINDING, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_transform_feedback2 },
-
-   /* GL_ARB_geometry_shader4 */
-   { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTextureImageUnits),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryOutputVertices),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTotalOutputComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryUniformComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryVaryingComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_VERTEX_VARYING_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxVertexVaryingComponents),
-     extra_ARB_geometry_shader4 },
-
-   /* GL_EXT_gpu_shader4 / GL 3.0 */
-   { GL_MIN_PROGRAM_TEXEL_OFFSET,
-     CONTEXT_INT(Const.MinProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
-   { GL_MAX_PROGRAM_TEXEL_OFFSET,
-     CONTEXT_INT(Const.MaxProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
-
-   /* GL 3.0 */
-   { GL_NUM_EXTENSIONS, LOC_CUSTOM, TYPE_INT, 0, extra_version_30 },
-   { GL_MAJOR_VERSION, CONTEXT_INT(VersionMajor), extra_version_30 },
-   { GL_MINOR_VERSION, CONTEXT_INT(VersionMinor), extra_version_30  },
-   { GL_CONTEXT_FLAGS, CONTEXT_INT(Const.ContextFlags), extra_version_30  },
-
-   /* GL3.0 / GL_EXT_framebuffer_sRGB */
-   { GL_FRAMEBUFFER_SRGB_EXT, CONTEXT_BOOL(Color.sRGBEnabled), extra_EXT_framebuffer_sRGB },
-   { GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, BUFFER_INT(Visual.sRGBCapable), extra_EXT_framebuffer_sRGB },
-
-   /* GL 3.1 */
-   /* NOTE: different enum values for GL_PRIMITIVE_RESTART_NV
-    * vs. GL_PRIMITIVE_RESTART!
-    */
-   { GL_PRIMITIVE_RESTART, CONTEXT_BOOL(Array.PrimitiveRestart),
-     extra_version_31 },
-   { GL_PRIMITIVE_RESTART_INDEX, CONTEXT_INT(Array.RestartIndex),
-     extra_version_31 },
- 
-
-   /* GL 3.2 */
-   { GL_CONTEXT_PROFILE_MASK, CONTEXT_INT(Const.ProfileMask),
-     extra_version_32 },
-#endif /* FEATURE_GL */
-};
-
-/* All we need now is a way to look up the value struct from the enum.
- * The code generated by gcc for the old generated big switch
- * statement is a big, balanced, open coded if/else tree, essentially
- * an unrolled binary search.  It would be natural to sort the new
- * enum table and use bsearch(), but we will use a read-only hash
- * table instead.  bsearch() has a nice guaranteed worst case
- * performance, but we're also guaranteed to hit that worst case
- * (log2(n) iterations) for about half the enums.  Instead, using an
- * open addressing hash table, we can find the enum on the first try
- * for 80% of the enums, 1 collision for 10% and never more than 5
- * collisions for any enum (typical numbers).  And the code is very
- * simple, even though it feels a little magic. */
-
-static unsigned short table[1024];
-static const int prime_factor = 89, prime_step = 281;
-
-#ifdef GET_DEBUG
-static void
-print_table_stats(void)
-{
-   int i, j, collisions[11], count, hash, mask;
-   const struct value_desc *d;
-
-   count = 0;
-   mask = Elements(table) - 1;
-   memset(collisions, 0, sizeof collisions);
-
-   for (i = 0; i < Elements(table); i++) {
-      if (!table[i])
-	 continue;
-      count++;
-      d = &values[table[i]];
-      hash = (d->pname * prime_factor);
-      j = 0;
-      while (1) {
-	 if (values[table[hash & mask]].pname == d->pname)
-	    break;
-	 hash += prime_step;
-	 j++;
-      }
-
-      if (j < 10)
-	 collisions[j]++;
-      else
-	 collisions[10]++;
-   }
-
-   printf("number of enums: %d (total %d)\n", count, Elements(values));
-   for (i = 0; i < Elements(collisions) - 1; i++)
-      if (collisions[i] > 0)
-	 printf("  %d enums with %d %scollisions\n",
-		collisions[i], i, i == 10 ? "or more " : "");
-}
-#endif
-
-/**
- * Initialize the enum hash for a given API 
- *
- * This is called from one_time_init() to insert the enum values that
- * are valid for the API in question into the enum hash table.
- *
- * \param the current context, for determining the API in question
- */
-void _mesa_init_get_hash(struct gl_context *ctx)
-{
-   int i, hash, index, mask;
-   int api_mask = 0, api_bit;
-
-   mask = Elements(table) - 1;
-   api_bit = 1 << ctx->API;
-
-   for (i = 0; i < Elements(values); i++) {
-      if (values[i].type == TYPE_API_MASK) {
-	 api_mask = values[i].offset;
-	 continue;
-      }
-      if (!(api_mask & api_bit))
-	 continue;
-
-      hash = (values[i].pname * prime_factor) & mask;
-      while (1) {
-	 index = hash & mask;
-	 if (!table[index]) {
-	    table[index] = i;
-	    break;
-	 }
-	 hash += prime_step;
-      }
-   }
-
-#ifdef GET_DEBUG
-   print_table_stats();
-#endif
-}
-
-/**
- * Handle irregular enums
- *
- * Some values don't conform to the "well-known type at context
- * pointer + offset" pattern, so we have this function to catch all
- * the corner cases.  Typically, it's a computed value or a one-off
- * pointer to a custom struct or something.
- *
- * In this case we can't return a pointer to the value, so we'll have
- * to use the temporary variable 'v' declared back in the calling
- * glGet*v() function to store the result.
- *
- * \param ctx the current context
- * \param d the struct value_desc that describes the enum
- * \param v pointer to the tmp declared in the calling glGet*v() function
- */
-static void
-find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
-{
-   struct gl_buffer_object *buffer_obj;
-   struct gl_client_array *array;
-   GLuint unit, *p;
-
-   switch (d->pname) {
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_3D:
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_TEXTURE_RECTANGLE_NV:
-      v->value_bool = _mesa_IsEnabled(d->pname);
-      break;
-
-   case GL_LINE_STIPPLE_PATTERN:
-      /* This is the only GLushort, special case it here by promoting
-       * to an int rather than introducing a new type. */
-      v->value_int = ctx->Line.StipplePattern;
-      break;
-
-   case GL_CURRENT_RASTER_TEXTURE_COORDS:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
-      v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
-      v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
-      v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
-      break;
-
-   case GL_CURRENT_TEXTURE_COORDS:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
-      v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
-      v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
-      v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
-      break;
-
-   case GL_COLOR_WRITEMASK:
-      v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;
-      v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;
-      v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;
-      v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;
-      break;
-
-   case GL_EDGE_FLAG:
-      v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;
-      break;
-
-   case GL_READ_BUFFER:
-      v->value_enum = ctx->ReadBuffer->ColorReadBuffer;
-      break;
-
-   case GL_MAP2_GRID_DOMAIN:
-      v->value_float_4[0] = ctx->Eval.MapGrid2u1;
-      v->value_float_4[1] = ctx->Eval.MapGrid2u2;
-      v->value_float_4[2] = ctx->Eval.MapGrid2v1;
-      v->value_float_4[3] = ctx->Eval.MapGrid2v2;
-      break;
-
-   case GL_TEXTURE_STACK_DEPTH:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
-      break;
-   case GL_TEXTURE_MATRIX:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_matrix = ctx->TextureMatrixStack[unit].Top;
-      break;
-
-   case GL_TEXTURE_COORD_ARRAY:
-   case GL_TEXTURE_COORD_ARRAY_SIZE:
-   case GL_TEXTURE_COORD_ARRAY_TYPE:
-   case GL_TEXTURE_COORD_ARRAY_STRIDE:
-      array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture];
-      v->value_int = *(GLuint *) ((char *) array + d->offset);
-      break;
-
-   case GL_ACTIVE_TEXTURE_ARB:
-      v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
-      break;
-   case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-      v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
-      break;
-
-   case GL_MODELVIEW_STACK_DEPTH:
-   case GL_PROJECTION_STACK_DEPTH:
-      v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;
-      break;
-
-   case GL_MAX_TEXTURE_SIZE:
-   case GL_MAX_3D_TEXTURE_SIZE:
-   case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-      p = (GLuint *) ((char *) ctx + d->offset);
-      v->value_int = 1 << (*p - 1);
-      break;
-
-   case GL_SCISSOR_BOX:
-      v->value_int_4[0] = ctx->Scissor.X;
-      v->value_int_4[1] = ctx->Scissor.Y;
-      v->value_int_4[2] = ctx->Scissor.Width;
-      v->value_int_4[3] = ctx->Scissor.Height;
-      break;
-
-   case GL_LIST_INDEX:
-      v->value_int =
-	 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
-      break;
-   case GL_LIST_MODE:
-      if (!ctx->CompileFlag)
-	 v->value_enum = 0;
-      else if (ctx->ExecuteFlag)
-	 v->value_enum = GL_COMPILE_AND_EXECUTE;
-      else
-	 v->value_enum = GL_COMPILE;
-      break;
-
-   case GL_VIEWPORT:
-      v->value_int_4[0] = ctx->Viewport.X;
-      v->value_int_4[1] = ctx->Viewport.Y;
-      v->value_int_4[2] = ctx->Viewport.Width;
-      v->value_int_4[3] = ctx->Viewport.Height;
-      break;
-
-   case GL_ACTIVE_STENCIL_FACE_EXT:
-      v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
-      break;
-
-   case GL_STENCIL_FAIL:
-      v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_FUNC:
-      v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_PASS_DEPTH_FAIL:
-      v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_PASS_DEPTH_PASS:
-      v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_REF:
-      v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_VALUE_MASK:
-      v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_WRITEMASK:
-      v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
-      break;
-
-   case GL_NUM_EXTENSIONS:
-      v->value_int = _mesa_get_extension_count(ctx);
-      break;
-
-   case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-      v->value_int = _mesa_get_color_read_type(ctx);
-      break;
-   case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-      v->value_int = _mesa_get_color_read_format(ctx);
-      break;
-
-   case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-      v->value_int = ctx->CurrentStack->Depth + 1;
-      break;
-   case GL_CURRENT_MATRIX_ARB:
-   case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-      v->value_matrix = ctx->CurrentStack->Top;
-      break;
-
-   case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-      v->value_int = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
-      break;
-   case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-      v->value_int_n.n = 
-	 _mesa_get_compressed_formats(ctx, v->value_int_n.ints, GL_FALSE);
-      ASSERT(v->value_int_n.n <= 100);
-      break;
-
-   case GL_MAX_VARYING_FLOATS_ARB:
-      v->value_int = ctx->Const.MaxVarying * 4;
-      break;
-
-   /* Various object names */
-
-   case GL_TEXTURE_BINDING_1D:
-   case GL_TEXTURE_BINDING_2D:
-   case GL_TEXTURE_BINDING_3D:
-   case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
-   case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
-   case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-   case GL_TEXTURE_BINDING_RECTANGLE_NV:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_int =
-	 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
-      break;
-
-   /* GL_ARB_vertex_buffer_object */
-   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-      buffer_obj = (struct gl_buffer_object *)
-	 ((char *) ctx->Array.ArrayObj + d->offset);
-      v->value_int = buffer_obj->Name;
-      break;
-   case GL_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int = ctx->Array.ArrayBufferObj->Name;
-      break;
-   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int =
-	 ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
-      break;
-   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int = ctx->Array.ElementArrayBufferObj->Name;
-      break;
-
-   /* ARB_copy_buffer */
-   case GL_COPY_READ_BUFFER:
-      v->value_int = ctx->CopyReadBuffer->Name;
-      break;
-   case GL_COPY_WRITE_BUFFER:
-      v->value_int = ctx->CopyWriteBuffer->Name;
-      break;
-
-   case GL_FRAGMENT_PROGRAM_BINDING_NV:
-      v->value_int = 
-	 ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
-      break;
-   case GL_VERTEX_PROGRAM_BINDING_NV:
-      v->value_int =
-	 ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;
-      break;
-   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-      v->value_int = ctx->Pack.BufferObj->Name;
-      break;
-   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-      v->value_int = ctx->Unpack.BufferObj->Name;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Active;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BINDING:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Name;
-      break;
-   case GL_CURRENT_PROGRAM:
-      v->value_int =
-	 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
-      break;
-   case GL_READ_FRAMEBUFFER_BINDING_EXT:
-      v->value_int = ctx->ReadBuffer->Name;
-      break;
-   case GL_RENDERBUFFER_BINDING_EXT:
-      v->value_int =
-	 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
-      break;
-   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
-      v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;
-      break;
-
-   case GL_MAX_VERTEX_UNIFORM_VECTORS:
-      v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;
-      break;
-
-   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-      v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;
-      break;
-   }   
-}
-
-/**
- * Check extra constraints on a struct value_desc descriptor
- *
- * If a struct value_desc has a non-NULL extra pointer, it means that
- * there are a number of extra constraints to check or actions to
- * perform.  The extras is just an integer array where each integer
- * encode different constraints or actions.
- *
- * \param ctx current context
- * \param func name of calling glGet*v() function for error reporting
- * \param d the struct value_desc that has the extra constraints
- *
- * \return GL_FALSE if one of the constraints was not satisfied,
- *     otherwise GL_TRUE.
- */
-static GLboolean
-check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
-{
-   const GLuint version = ctx->VersionMajor * 10 + ctx->VersionMinor;
-   int total, enabled;
-   const int *e;
-
-   total = 0;
-   enabled = 0;
-   for (e = d->extra; *e != EXTRA_END; e++)
-      switch (*e) {
-      case EXTRA_VERSION_30:
-	 if (version >= 30) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_31:
-	 if (version >= 31) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_32:
-	 if (version >= 32) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_ES2:
-	 if (ctx->API == API_OPENGLES2) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_NEW_BUFFERS:
-	 if (ctx->NewState & _NEW_BUFFERS)
-	    _mesa_update_state(ctx);
-	 break;
-      case EXTRA_FLUSH_CURRENT:
-	 FLUSH_CURRENT(ctx, 0);
-	 break;
-      case EXTRA_VALID_DRAW_BUFFER:
-	 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
-			func, d->pname - GL_DRAW_BUFFER0_ARB);
-	    return GL_FALSE;
-	 }
-	 break;
-      case EXTRA_VALID_TEXTURE_UNIT:
-	 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
-	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
-			func, ctx->Texture.CurrentUnit);
-	    return GL_FALSE;
-	 }
-	 break;
-      case EXTRA_END:
-	 break;
-      default: /* *e is a offset into the extension struct */
-	 total++;
-	 if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
-	    enabled++;
-	 break;
-      }
-
-   if (total > 0 && enabled == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-                  _mesa_lookup_enum_by_nr(d->pname));
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-static const struct value_desc error_value =
-   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
-
-/**
- * Find the struct value_desc corresponding to the enum 'pname'.
- * 
- * We hash the enum value to get an index into the 'table' array,
- * which holds the index in the 'values' array of struct value_desc.
- * Once we've found the entry, we do the extra checks, if any, then
- * look up the value and return a pointer to it.
- *
- * If the value has to be computed (for example, it's the result of a
- * function call or we need to add 1 to it), we use the tmp 'v' to
- * store the result.
- * 
- * \param func name of glGet*v() func for error reporting
- * \param pname the enum value we're looking up
- * \param p is were we return the pointer to the value
- * \param v a tmp union value variable in the calling glGet*v() function
- *
- * \return the struct value_desc corresponding to the enum or a struct
- *     value_desc of TYPE_INVALID if not found.  This lets the calling
- *     glGet*v() function jump right into a switch statement and
- *     handle errors there instead of having to check for NULL.
- */
-static const struct value_desc *
-find_value(const char *func, GLenum pname, void **p, union value *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *unit;
-   int mask, hash;
-   const struct value_desc *d;
-
-   mask = Elements(table) - 1;
-   hash = (pname * prime_factor);
-   while (1) {
-      d = &values[table[hash & mask]];
-
-      /* If the enum isn't valid, the hash walk ends with index 0,
-       * which is the API mask entry at the beginning of values[]. */
-      if (unlikely(d->type == TYPE_API_MASK)) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-                     _mesa_lookup_enum_by_nr(pname));
-	 return &error_value;
-      }
-
-      if (likely(d->pname == pname))
-	 break;
-
-      hash += prime_step;
-   }
-
-   if (unlikely(d->extra && !check_extra(ctx, func, d)))
-      return &error_value;
-
-   switch (d->location) {
-   case LOC_BUFFER:
-      *p = ((char *) ctx->DrawBuffer + d->offset);
-      return d;
-   case LOC_CONTEXT:
-      *p = ((char *) ctx + d->offset);
-      return d;
-   case LOC_ARRAY:
-      *p = ((char *) ctx->Array.ArrayObj + d->offset);
-      return d;
-   case LOC_TEXUNIT:
-      unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      *p = ((char *) unit + d->offset);
-      return d;
-   case LOC_CUSTOM:
-      find_custom_value(ctx, d, v);
-      *p = v;
-      return d;
-   default:
-      assert(0);
-      break;
-   }
-
-   /* silence warning */
-   return &error_value;
-}
-
-static const int transpose[] = {
-   0, 4,  8, 12,
-   1, 5,  9, 13,
-   2, 6, 10, 14,
-   3, 7, 11, 15
-};
-
-void GLAPIENTRY
-_mesa_GetBooleanv(GLenum pname, GLboolean *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetBooleanv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = INT_TO_BOOLEAN(d->offset);
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = ((GLboolean*) p)[0];
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetFloatv(GLenum pname, GLfloat *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetFloatv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = (GLfloat) d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = ((GLfloat *) p)[3];
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = ((GLfloat *) p)[2];
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = ((GLfloat *) p)[1];
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = ((GLfloat *) p)[0];
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = ((GLdouble *) p)[0];
-      break;
-
-   case TYPE_INT_4:
-      params[3] = (GLfloat) (((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = (GLfloat) (((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = (GLfloat) (((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = (GLfloat) (((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[i];
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[transpose[i]];
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
-      break;
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetIntegerv(GLenum pname, GLint *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetIntegerv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-      params[3] = IROUND(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-      params[2] = IROUND(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-      params[1] = IROUND(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-      params[0] = IROUND(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = v.value_int_n.ints[i];
-      break;
-
-   case TYPE_INT64:
-      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-#if FEATURE_ARB_sync
-void GLAPIENTRY
-_mesa_GetInteger64v(GLenum pname, GLint64 *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetInteger64v", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-      params[3] = IROUND64(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-      params[2] = IROUND64(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-      params[1] = IROUND64(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-      params[0] = IROUND64(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = ((GLboolean*) p)[0];
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT64(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-#endif /* FEATURE_ARB_sync */
-
-void GLAPIENTRY
-_mesa_GetDoublev(GLenum pname, GLdouble *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetDoublev", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = ((GLfloat *) p)[3];
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = ((GLfloat *) p)[2];
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = ((GLfloat *) p)[1];
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = ((GLfloat *) p)[0];
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = ((GLdouble *) p)[0];
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = v.value_int_n.ints[i];
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = *(GLboolean*) p;
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[i];
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[transpose[i]];
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-static enum value_type
-find_value_indexed(const char *func, GLenum pname, int index, union value *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   switch (pname) {
-
-   case GL_BLEND:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_draw_buffers2)
-	 goto invalid_enum;
-      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
-      return TYPE_INT;
-
-   case GL_BLEND_SRC:
-      /* fall-through */
-   case GL_BLEND_SRC_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].SrcRGB;
-      return TYPE_INT;
-   case GL_BLEND_SRC_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].SrcA;
-      return TYPE_INT;
-   case GL_BLEND_DST:
-      /* fall-through */
-   case GL_BLEND_DST_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].DstRGB;
-      return TYPE_INT;
-   case GL_BLEND_DST_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].DstA;
-      return TYPE_INT;
-   case GL_BLEND_EQUATION_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].EquationRGB;
-      return TYPE_INT;
-   case GL_BLEND_EQUATION_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].EquationA;
-      return TYPE_INT;
-
-   case GL_COLOR_WRITEMASK:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_draw_buffers2)
-	 goto invalid_enum;
-      v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;
-      v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;
-      v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;
-      v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;
-      return TYPE_INT_4;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_START:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
-      return TYPE_INT64;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int64 = ctx->TransformFeedback.CurrentObject->Size[index];
-      return TYPE_INT64;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int = ctx->TransformFeedback.CurrentObject->Buffers[index]->Name;
-      return TYPE_INT;
-   }
-
- invalid_enum:
-   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-               _mesa_lookup_enum_by_nr(pname));
-   return TYPE_INVALID;
- invalid_value:
-   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
-               _mesa_lookup_enum_by_nr(pname));
-   return TYPE_INVALID;
-}
-
-void GLAPIENTRY
-_mesa_GetBooleanIndexedv( GLenum pname, GLuint index, GLboolean *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetBooleanIndexedv", pname, index, &v);
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = INT_TO_BOOLEAN(v.value_int);
-      break;
-   case TYPE_INT_4:
-      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
-      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
-      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
-      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
-      break;
-   case TYPE_INT64:
-      params[0] = INT64_TO_BOOLEAN(v.value_int);
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetIntegerIndexedv( GLenum pname, GLuint index, GLint *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = v.value_int;
-      break;
-   case TYPE_INT_4:
-      params[0] = v.value_int_4[0];
-      params[1] = v.value_int_4[1];
-      params[2] = v.value_int_4[2];
-      params[3] = v.value_int_4[3];
-      break;
-   case TYPE_INT64:
-      params[0] = INT64_TO_INT(v.value_int);
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-
-#if FEATURE_ARB_sync
-void GLAPIENTRY
-_mesa_GetInteger64Indexedv( GLenum pname, GLuint index, GLint64 *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);      
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = v.value_int;
-      break;
-   case TYPE_INT_4:
-      params[0] = v.value_int_4[0];
-      params[1] = v.value_int_4[1];
-      params[2] = v.value_int_4[2];
-      params[3] = v.value_int_4[3];
-      break;
-   case TYPE_INT64:
-      params[0] = v.value_int;
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-#endif /* FEATURE_ARB_sync */
-
-#if FEATURE_ES1
-void GLAPIENTRY
-_mesa_GetFixedv(GLenum pname, GLfixed *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetDoublev", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = INT_TO_FIXED(d->offset);
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = INT_TO_FIXED(((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = INT_TO_FIXED(((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = INT_TO_FIXED(((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = INT_TO_FIXED(((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_FIXED(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
-      break;
-   }
-}
-#endif
+/*

+ * Copyright (C) 2010  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2010  Intel Corporation

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ *

+ * Author: Kristian Høgsberg <krh@bitplanet.net>

+ */

+

+#include "glheader.h"

+#include "context.h"

+#include "enable.h"

+#include "enums.h"

+#include "extensions.h"

+#include "get.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "state.h"

+#include "texcompress.h"

+#include "framebuffer.h"

+

+/* This is a table driven implemetation of the glGet*v() functions.

+ * The basic idea is that most getters just look up an int somewhere

+ * in struct gl_context and then convert it to a bool or float according to

+ * which of glGetIntegerv() glGetBooleanv() etc is being called.

+ * Instead of generating code to do this, we can just record the enum

+ * value and the offset into struct gl_context in an array of structs.  Then

+ * in glGet*(), we lookup the struct for the enum in question, and use

+ * the offset to get the int we need.

+ *

+ * Sometimes we need to look up a float, a boolean, a bit in a

+ * bitfield, a matrix or other types instead, so we need to track the

+ * type of the value in struct gl_context.  And sometimes the value isn't in

+ * struct gl_context but in the drawbuffer, the array object, current texture

+ * unit, or maybe it's a computed value.  So we need to also track

+ * where or how to find the value.  Finally, we sometimes need to

+ * check that one of a number of extensions are enabled, the GL

+ * version or flush or call _mesa_update_state().  This is done by

+ * attaching optional extra information to the value description

+ * struct, it's sort of like an array of opcodes that describe extra

+ * checks or actions.

+ *

+ * Putting all this together we end up with struct value_desc below,

+ * and with a couple of macros to help, the table of struct value_desc

+ * is about as concise as the specification in the old python script.

+ */

+

+#undef CONST

+

+#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )

+#define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \

+                                ((F) * 65536.0f < INT_MIN) ? INT_MIN : \

+                                (GLint) ((F) * 65536.0f) )

+

+#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )

+#define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \

+                                ((I) < SHRT_MIN) ? INT_MIN : \

+                                (GLint) ((I) * 65536) )

+

+#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )

+#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )

+

+#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )

+#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )

+#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )

+#define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )

+

+#define ENUM_TO_INT64(E)      ( (GLint64) (E) )

+#define ENUM_TO_FIXED(E)      (E)

+

+enum value_type {

+   TYPE_INVALID,

+   TYPE_API_MASK,

+   TYPE_INT,

+   TYPE_INT_2,

+   TYPE_INT_3,

+   TYPE_INT_4,

+   TYPE_INT_N,

+   TYPE_INT64,

+   TYPE_ENUM,

+   TYPE_ENUM_2,

+   TYPE_BOOLEAN,

+   TYPE_BIT_0,

+   TYPE_BIT_1,

+   TYPE_BIT_2,

+   TYPE_BIT_3,

+   TYPE_BIT_4,

+   TYPE_BIT_5,

+   TYPE_FLOAT,

+   TYPE_FLOAT_2,

+   TYPE_FLOAT_3,

+   TYPE_FLOAT_4,

+   TYPE_FLOATN,

+   TYPE_FLOATN_2,

+   TYPE_FLOATN_3,

+   TYPE_FLOATN_4,

+   TYPE_DOUBLEN,

+   TYPE_MATRIX,

+   TYPE_MATRIX_T,

+   TYPE_CONST

+};

+

+enum value_location {

+   LOC_BUFFER,

+   LOC_CONTEXT,

+   LOC_ARRAY,

+   LOC_TEXUNIT,

+   LOC_CUSTOM

+};

+

+enum value_extra {

+   EXTRA_END = 0x8000,

+   EXTRA_VERSION_30,

+   EXTRA_VERSION_31,

+   EXTRA_VERSION_32,

+   EXTRA_VERSION_ES2,

+   EXTRA_NEW_BUFFERS, 

+   EXTRA_VALID_DRAW_BUFFER,

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_FLUSH_CURRENT,

+};

+

+#define NO_EXTRA NULL

+#define NO_OFFSET 0

+

+struct value_desc {

+   GLenum pname;

+   GLubyte location;  /**< enum value_location */

+   GLubyte type;      /**< enum value_type */

+   int offset;

+   const int *extra;

+};

+

+union value {

+   GLfloat value_float;

+   GLfloat value_float_4[4];

+   GLmatrix *value_matrix;

+   GLint value_int;

+   GLint value_int_4[4];

+   GLint64 value_int64;

+   GLenum value_enum;

+

+   /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */

+   struct {

+      GLint n, ints[100];

+   } value_int_n;

+   GLboolean value_bool;

+};

+

+#define BUFFER_FIELD(field, type) \

+   LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)

+#define CONTEXT_FIELD(field, type) \

+   LOC_CONTEXT, type, offsetof(struct gl_context, field)

+#define ARRAY_FIELD(field, type) \

+   LOC_ARRAY, type, offsetof(struct gl_array_object, field)

+#define CONST(value) \

+   LOC_CONTEXT, TYPE_CONST, value

+

+#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)

+#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)

+#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)

+

+#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)

+#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)

+#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)

+#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)

+#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)

+#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)

+#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)

+#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)

+#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)

+#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)

+#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)

+#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)

+#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)

+#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)

+#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)

+#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)

+#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)

+#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)

+

+#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)

+#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)

+#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)

+

+#define EXT(f)					\

+   offsetof(struct gl_extensions, f)

+

+#define EXTRA_EXT(e)				\

+   static const int extra_##e[] = {		\

+      EXT(e), EXTRA_END				\

+   }

+

+#define EXTRA_EXT2(e1, e2)			\

+   static const int extra_##e1##_##e2[] = {	\

+      EXT(e1), EXT(e2), EXTRA_END		\

+   }

+

+/* The 'extra' mechanism is a way to specify extra checks (such as

+ * extensions or specific gl versions) or actions (flush current, new

+ * buffers) that we need to do before looking up an enum.  We need to

+ * declare them all up front so we can refer to them in the value_desc

+ * structs below. */

+

+static const int extra_new_buffers[] = {

+   EXTRA_NEW_BUFFERS,

+   EXTRA_END

+};

+

+static const int extra_valid_draw_buffer[] = {

+   EXTRA_VALID_DRAW_BUFFER,

+   EXTRA_END

+};

+

+static const int extra_valid_texture_unit[] = {

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_END

+};

+

+static const int extra_flush_current_valid_texture_unit[] = {

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_END

+};

+

+static const int extra_flush_current[] = {

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_new_buffers_OES_read_format[] = {

+   EXTRA_NEW_BUFFERS,

+   EXT(OES_read_format),

+   EXTRA_END

+};

+

+static const int extra_EXT_secondary_color_flush_current[] = {

+   EXT(EXT_secondary_color),

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_EXT_fog_coord_flush_current[] = {

+   EXT(EXT_fog_coord),

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_EXT_texture_integer[] = {

+   EXT(EXT_texture_integer),

+   EXTRA_END

+};

+

+static const int extra_EXT_gpu_shader4[] = {

+   EXT(EXT_gpu_shader4),

+   EXTRA_END

+};

+

+

+EXTRA_EXT(ARB_ES2_compatibility);

+EXTRA_EXT(ARB_multitexture);

+EXTRA_EXT(ARB_texture_cube_map);

+EXTRA_EXT(MESA_texture_array);

+EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);

+EXTRA_EXT(EXT_secondary_color);

+EXTRA_EXT(EXT_fog_coord);

+EXTRA_EXT(EXT_texture_lod_bias);

+EXTRA_EXT(EXT_texture_filter_anisotropic);

+EXTRA_EXT(IBM_rasterpos_clip);

+EXTRA_EXT(NV_point_sprite);

+EXTRA_EXT(SGIS_generate_mipmap);

+EXTRA_EXT(NV_vertex_program);

+EXTRA_EXT(NV_fragment_program);

+EXTRA_EXT(NV_texture_rectangle);

+EXTRA_EXT(EXT_stencil_two_side);

+EXTRA_EXT(NV_light_max_exponent);

+EXTRA_EXT(EXT_depth_bounds_test);

+EXTRA_EXT(ARB_depth_clamp);

+EXTRA_EXT(ATI_fragment_shader);

+EXTRA_EXT(EXT_framebuffer_blit);

+EXTRA_EXT(ARB_shader_objects);

+EXTRA_EXT(EXT_provoking_vertex);

+EXTRA_EXT(ARB_fragment_shader);

+EXTRA_EXT(ARB_fragment_program);

+EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);

+EXTRA_EXT(EXT_framebuffer_object);

+EXTRA_EXT(APPLE_vertex_array_object);

+EXTRA_EXT(ARB_seamless_cube_map);

+EXTRA_EXT(EXT_compiled_vertex_array);

+EXTRA_EXT(ARB_sync);

+EXTRA_EXT(ARB_vertex_shader);

+EXTRA_EXT(EXT_transform_feedback);

+EXTRA_EXT(ARB_transform_feedback2);

+EXTRA_EXT(EXT_pixel_buffer_object);

+EXTRA_EXT(ARB_vertex_program);

+EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);

+EXTRA_EXT2(ARB_fragment_program, NV_fragment_program);

+EXTRA_EXT2(ARB_vertex_program, NV_vertex_program);

+EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);

+EXTRA_EXT(ARB_vertex_buffer_object);

+EXTRA_EXT(ARB_geometry_shader4);

+EXTRA_EXT(ARB_copy_buffer);

+EXTRA_EXT(EXT_framebuffer_sRGB);

+

+static const int

+extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {

+   EXT(ARB_vertex_program),

+   EXT(ARB_fragment_program),

+   EXT(NV_vertex_program),

+   EXTRA_END

+};

+

+static const int

+extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {

+   EXT(NV_vertex_program),

+   EXT(ARB_vertex_program),

+   EXT(ARB_fragment_program),

+   EXT(NV_vertex_program),

+   EXTRA_END

+};

+

+static const int

+extra_NV_primitive_restart[] = {

+   EXT(NV_primitive_restart),

+   EXTRA_END

+};

+

+static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };

+static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };

+static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };

+

+static const int

+extra_ARB_vertex_program_version_es2[] = {

+   EXT(ARB_vertex_program),

+   EXTRA_VERSION_ES2,

+   EXTRA_END

+};

+

+#define API_OPENGL_BIT (1 << API_OPENGL)

+#define API_OPENGLES_BIT (1 << API_OPENGLES)

+#define API_OPENGLES2_BIT (1 << API_OPENGLES2)

+

+/* This is the big table describing all the enums we accept in

+ * glGet*v().  The table is partitioned into six parts: enums

+ * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared

+ * between OpenGL and GLES, enums exclusive to GLES, etc for the

+ * remaining combinations.  When we add the enums to the hash table in

+ * _mesa_init_get_hash(), we only add the enums for the API we're

+ * instantiating and the different sections are guarded by #if

+ * FEATURE_GL etc to make sure we only compile in the enums we may

+ * need. */

+

+static const struct value_desc values[] = {

+   /* Enums shared between OpenGL, GLES1 and GLES2 */

+   { 0, 0, TYPE_API_MASK,

+     API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT, NO_EXTRA},

+   { GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers },

+   { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },

+   { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },

+   { GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },

+   { GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+   { GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },

+   { GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },

+   { GL_DEPTH_BITS, BUFFER_INT(Visual.depthBits), NO_EXTRA },

+   { GL_DEPTH_CLEAR_VALUE, CONTEXT_FIELD(Depth.Clear, TYPE_DOUBLEN), NO_EXTRA },

+   { GL_DEPTH_FUNC, CONTEXT_ENUM(Depth.Func), NO_EXTRA },

+   { GL_DEPTH_RANGE, CONTEXT_FIELD(Viewport.Near, TYPE_FLOATN_2), NO_EXTRA },

+   { GL_DEPTH_TEST, CONTEXT_BOOL(Depth.Test), NO_EXTRA },

+   { GL_DEPTH_WRITEMASK, CONTEXT_BOOL(Depth.Mask), NO_EXTRA },

+   { GL_DITHER, CONTEXT_BOOL(Color.DitherFlag), NO_EXTRA },

+   { GL_FRONT_FACE, CONTEXT_ENUM(Polygon.FrontFace), NO_EXTRA },

+   { GL_GREEN_BITS, BUFFER_INT(Visual.greenBits), extra_new_buffers },

+   { GL_LINE_WIDTH, CONTEXT_FLOAT(Line.Width), NO_EXTRA },

+   { GL_ALIASED_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidth), NO_EXTRA },

+   { GL_MAX_ELEMENTS_VERTICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },

+   { GL_MAX_ELEMENTS_INDICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },

+   { GL_MAX_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.MaxTextureLevels), NO_EXTRA },

+   { GL_MAX_VIEWPORT_DIMS, CONTEXT_INT2(Const.MaxViewportWidth), NO_EXTRA },

+   { GL_PACK_ALIGNMENT, CONTEXT_INT(Pack.Alignment), NO_EXTRA },

+   { GL_ALIASED_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSize), NO_EXTRA },

+   { GL_POLYGON_OFFSET_FACTOR, CONTEXT_FLOAT(Polygon.OffsetFactor ), NO_EXTRA },

+   { GL_POLYGON_OFFSET_UNITS, CONTEXT_FLOAT(Polygon.OffsetUnits ), NO_EXTRA },

+   { GL_POLYGON_OFFSET_FILL, CONTEXT_BOOL(Polygon.OffsetFill), NO_EXTRA },

+   { GL_RED_BITS, BUFFER_INT(Visual.redBits), extra_new_buffers },

+   { GL_SCISSOR_BOX, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+   { GL_SCISSOR_TEST, CONTEXT_BOOL(Scissor.Enabled), NO_EXTRA },

+   { GL_STENCIL_BITS, BUFFER_INT(Visual.stencilBits), NO_EXTRA },

+   { GL_STENCIL_CLEAR_VALUE, CONTEXT_INT(Stencil.Clear), NO_EXTRA },

+   { GL_STENCIL_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_FUNC, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_PASS_DEPTH_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_PASS_DEPTH_PASS, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_REF, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_TEST, CONTEXT_BOOL(Stencil.Enabled), NO_EXTRA },

+   { GL_STENCIL_VALUE_MASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_WRITEMASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_SUBPIXEL_BITS, CONTEXT_INT(Const.SubPixelBits), NO_EXTRA },

+   { GL_TEXTURE_BINDING_2D, LOC_CUSTOM, TYPE_INT, TEXTURE_2D_INDEX, NO_EXTRA },

+   { GL_UNPACK_ALIGNMENT, CONTEXT_INT(Unpack.Alignment), NO_EXTRA },

+   { GL_VIEWPORT, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+

+   /* GL_ARB_multitexture */

+   { GL_ACTIVE_TEXTURE_ARB,

+     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },

+

+   /* Note that all the OES_* extensions require that the Mesa "struct

+    * gl_extensions" include a member with the name of the extension.

+    * That structure does not yet include OES extensions (and we're

+    * not sure whether it will).  If it does, all the OES_*

+    * extensions below should mark the dependency. */

+

+   /* GL_ARB_texture_cube_map */

+   { GL_TEXTURE_BINDING_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_CUBE_INDEX, extra_ARB_texture_cube_map },

+   { GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.MaxCubeTextureLevels),

+     extra_ARB_texture_cube_map }, /* XXX: OES_texture_cube_map */

+

+   /* XXX: OES_blend_subtract */

+   { GL_BLEND_SRC_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },

+   { GL_BLEND_DST_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },

+   { GL_BLEND_SRC_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].SrcA), NO_EXTRA },

+   { GL_BLEND_DST_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].DstA), NO_EXTRA },

+

+   /* GL_BLEND_EQUATION_RGB, which is what we're really after, is

+    * defined identically to GL_BLEND_EQUATION. */

+   { GL_BLEND_EQUATION, CONTEXT_ENUM(Color.Blend[0].EquationRGB), NO_EXTRA },

+   { GL_BLEND_EQUATION_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].EquationA), NO_EXTRA },

+

+   /* GL_ARB_texture_compression */

+   { GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT_N, 0, NO_EXTRA },

+

+   /* GL_ARB_multisample */

+   { GL_SAMPLE_ALPHA_TO_COVERAGE_ARB,

+     CONTEXT_BOOL(Multisample.SampleAlphaToCoverage), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_ARB, CONTEXT_BOOL(Multisample.SampleCoverage), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_VALUE_ARB,

+     CONTEXT_FLOAT(Multisample.SampleCoverageValue), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_INVERT_ARB,

+     CONTEXT_BOOL(Multisample.SampleCoverageInvert), NO_EXTRA },

+   { GL_SAMPLE_BUFFERS_ARB, BUFFER_INT(Visual.sampleBuffers), NO_EXTRA },

+   { GL_SAMPLES_ARB, BUFFER_INT(Visual.samples), NO_EXTRA },

+

+   /* GL_SGIS_generate_mipmap */

+   { GL_GENERATE_MIPMAP_HINT_SGIS, CONTEXT_ENUM(Hint.GenerateMipmap),

+     extra_SGIS_generate_mipmap },

+

+   /* GL_ARB_vertex_buffer_object */

+   { GL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+

+   /* GL_ARB_vertex_buffer_object */

+   /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported */

+   { GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_buffer_object },

+

+   /* GL_ARB_copy_buffer */

+   { GL_COPY_READ_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },

+   { GL_COPY_WRITE_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },

+

+   /* GL_OES_read_format */

+   { GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, LOC_CUSTOM, TYPE_INT, 0,

+     extra_new_buffers_OES_read_format },

+   { GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, LOC_CUSTOM, TYPE_INT, 0,

+     extra_new_buffers_OES_read_format },

+

+   /* GL_EXT_framebuffer_object */

+   { GL_FRAMEBUFFER_BINDING_EXT, BUFFER_INT(Name),

+     extra_EXT_framebuffer_object },

+   { GL_RENDERBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_framebuffer_object },

+   { GL_MAX_RENDERBUFFER_SIZE_EXT, CONTEXT_INT(Const.MaxRenderbufferSize),

+     extra_EXT_framebuffer_object },

+

+   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's

+    * GLSL: */

+   { GL_MAX_CLIP_PLANES, CONTEXT_INT(Const.MaxClipPlanes), NO_EXTRA },

+

+#if FEATURE_GL || FEATURE_ES1

+   /* Enums in OpenGL and GLES1 */

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT, NO_EXTRA },

+   { GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA },

+   { GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA },

+   { GL_LIGHT2, CONTEXT_BOOL(Light.Light[2].Enabled), NO_EXTRA },

+   { GL_LIGHT3, CONTEXT_BOOL(Light.Light[3].Enabled), NO_EXTRA },

+   { GL_LIGHT4, CONTEXT_BOOL(Light.Light[4].Enabled), NO_EXTRA },

+   { GL_LIGHT5, CONTEXT_BOOL(Light.Light[5].Enabled), NO_EXTRA },

+   { GL_LIGHT6, CONTEXT_BOOL(Light.Light[6].Enabled), NO_EXTRA },

+   { GL_LIGHT7, CONTEXT_BOOL(Light.Light[7].Enabled), NO_EXTRA },

+   { GL_LIGHTING, CONTEXT_BOOL(Light.Enabled), NO_EXTRA },

+   { GL_LIGHT_MODEL_AMBIENT,

+     CONTEXT_FIELD(Light.Model.Ambient[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },

+   { GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },

+   { GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },

+   { GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },

+   { GL_BLEND_DST, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },

+   { GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE2, CONTEXT_BIT2(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE3, CONTEXT_BIT3(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE4, CONTEXT_BIT4(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE5, CONTEXT_BIT5(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_COLOR_MATERIAL, CONTEXT_BOOL(Light.ColorMaterialEnabled), NO_EXTRA },

+   { GL_CURRENT_COLOR,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR0][0], TYPE_FLOATN_4),

+     extra_flush_current },

+   { GL_CURRENT_NORMAL,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_NORMAL][0], TYPE_FLOATN_3),

+     extra_flush_current },

+   { GL_CURRENT_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,

+     extra_flush_current_valid_texture_unit },

+   { GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },

+   { GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },

+   { GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },

+   { GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },

+   { GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },

+   { GL_FOG_MODE, CONTEXT_ENUM(Fog.Mode), NO_EXTRA },

+   { GL_FOG_START, CONTEXT_FLOAT(Fog.Start), NO_EXTRA },

+   { GL_LINE_SMOOTH, CONTEXT_BOOL(Line.SmoothFlag), NO_EXTRA },

+   { GL_LINE_SMOOTH_HINT, CONTEXT_ENUM(Hint.LineSmooth), NO_EXTRA },

+   { GL_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidthAA), NO_EXTRA },

+   { GL_COLOR_LOGIC_OP, CONTEXT_BOOL(Color.ColorLogicOpEnabled), NO_EXTRA },

+   { GL_LOGIC_OP_MODE, CONTEXT_ENUM(Color.LogicOp), NO_EXTRA },

+   { GL_MATRIX_MODE, CONTEXT_ENUM(Transform.MatrixMode), NO_EXTRA },

+   { GL_MAX_MODELVIEW_STACK_DEPTH, CONST(MAX_MODELVIEW_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_PROJECTION_STACK_DEPTH, CONST(MAX_PROJECTION_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_TEXTURE_STACK_DEPTH, CONST(MAX_TEXTURE_STACK_DEPTH), NO_EXTRA },

+   { GL_MODELVIEW_MATRIX, CONTEXT_MATRIX(ModelviewMatrixStack.Top), NO_EXTRA },

+   { GL_MODELVIEW_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, ModelviewMatrixStack.Depth), NO_EXTRA },

+   { GL_NORMALIZE, CONTEXT_BOOL(Transform.Normalize), NO_EXTRA },

+   { GL_PACK_SKIP_IMAGES_EXT, CONTEXT_INT(Pack.SkipImages), NO_EXTRA },

+   { GL_PERSPECTIVE_CORRECTION_HINT, CONTEXT_ENUM(Hint.PerspectiveCorrection), NO_EXTRA },

+   { GL_POINT_SIZE, CONTEXT_FLOAT(Point.Size), NO_EXTRA },

+   { GL_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSizeAA), NO_EXTRA },

+   { GL_POINT_SMOOTH, CONTEXT_BOOL(Point.SmoothFlag), NO_EXTRA },

+   { GL_POINT_SMOOTH_HINT, CONTEXT_ENUM(Hint.PointSmooth), NO_EXTRA },

+   { GL_POINT_SIZE_MIN_EXT, CONTEXT_FLOAT(Point.MinSize), NO_EXTRA },

+   { GL_POINT_SIZE_MAX_EXT, CONTEXT_FLOAT(Point.MaxSize), NO_EXTRA },

+   { GL_POINT_FADE_THRESHOLD_SIZE_EXT, CONTEXT_FLOAT(Point.Threshold), NO_EXTRA },

+   { GL_PROJECTION_MATRIX, CONTEXT_MATRIX(ProjectionMatrixStack.Top), NO_EXTRA },

+   { GL_PROJECTION_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, ProjectionMatrixStack.Depth), NO_EXTRA },

+   { GL_RESCALE_NORMAL, CONTEXT_BOOL(Transform.RescaleNormals), NO_EXTRA },

+   { GL_SHADE_MODEL, CONTEXT_ENUM(Light.ShadeModel), NO_EXTRA },

+   { GL_TEXTURE_2D, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   { GL_TEXTURE_MATRIX, LOC_CUSTOM, TYPE_MATRIX, 0, extra_valid_texture_unit },

+   { GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,

+     extra_valid_texture_unit  },

+

+   { GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA },

+   { GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA },

+   { GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA },

+   { GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA },

+   { GL_NORMAL_ARRAY, ARRAY_ENUM(Normal.Enabled), NO_EXTRA },

+   { GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA },

+   { GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA },

+   { GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA },

+   { GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA },

+   { GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA },

+   { GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_SIZE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Size), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_TYPE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Type), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_STRIDE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Stride), NO_EXTRA },

+

+   /* GL_ARB_ES2_compatibility */

+   { GL_SHADER_COMPILER, CONST(1), extra_ARB_ES2_compatibility },

+   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying),

+     extra_ARB_ES2_compatibility },

+   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_ES2_compatibility },

+   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_ES2_compatibility },

+

+   /* GL_ARB_multitexture */

+   { GL_MAX_TEXTURE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxTextureUnits), extra_ARB_multitexture },

+   { GL_CLIENT_ACTIVE_TEXTURE_ARB,

+     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },

+

+   /* GL_ARB_texture_cube_map */

+   { GL_TEXTURE_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   /* S, T, and R are always set at the same time */

+   { GL_TEXTURE_GEN_STR_OES, LOC_TEXUNIT, TYPE_BIT_0,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+

+   /* GL_ARB_multisample */

+   { GL_MULTISAMPLE_ARB, CONTEXT_BOOL(Multisample.Enabled), NO_EXTRA },

+   { GL_SAMPLE_ALPHA_TO_ONE_ARB, CONTEXT_BOOL(Multisample.SampleAlphaToOne), NO_EXTRA },

+

+   /* GL_ARB_vertex_buffer_object */

+   { GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA },

+   { GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA },

+   { GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+

+   /* GL_OES_point_sprite */

+   { GL_POINT_SPRITE_NV,

+     CONTEXT_BOOL(Point.PointSprite),

+     extra_NV_point_sprite_ARB_point_sprite },

+

+   /* GL_ARB_fragment_shader */

+   { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.FragmentProgram.MaxUniformComponents),

+     extra_ARB_fragment_shader },

+

+   /* GL_ARB_vertex_shader */

+   { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.VertexProgram.MaxUniformComponents),

+     extra_ARB_vertex_shader },

+   { GL_MAX_VARYING_FLOATS_ARB, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_shader },

+

+   /* GL_EXT_texture_lod_bias */

+   { GL_MAX_TEXTURE_LOD_BIAS_EXT, CONTEXT_FLOAT(Const.MaxTextureLodBias),

+	 extra_EXT_texture_lod_bias },

+

+   /* GL_EXT_texture_filter_anisotropic */

+   { GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,

+     CONTEXT_FLOAT(Const.MaxTextureMaxAnisotropy),

+     extra_EXT_texture_filter_anisotropic },

+#endif /* FEATURE_GL || FEATURE_ES1 */

+

+#if FEATURE_ES1

+   { 0, 0, TYPE_API_MASK, API_OPENGLES_BIT },

+   /* XXX: OES_matrix_get */

+   { GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES },

+   { GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES },

+   { GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES },

+

+   /* OES_point_size_array */

+   { GL_POINT_SIZE_ARRAY_OES, ARRAY_FIELD(PointSize.Enabled, TYPE_BOOLEAN) },

+   { GL_POINT_SIZE_ARRAY_TYPE_OES, ARRAY_FIELD(PointSize.Type, TYPE_ENUM) },

+   { GL_POINT_SIZE_ARRAY_STRIDE_OES, ARRAY_FIELD(PointSize.Stride, TYPE_INT) },

+   { GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES, LOC_CUSTOM, TYPE_INT, 0 },

+#endif /* FEATURE_ES1 */

+

+#if FEATURE_GL || FEATURE_ES2

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES2_BIT, NO_EXTRA },

+   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's GLSL: */

+   { GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA },

+   { GL_MAX_TEXTURE_COORDS_ARB, /* == GL_MAX_TEXTURE_COORDS_NV */

+     CONTEXT_INT(Const.MaxTextureCoordUnits),

+     extra_ARB_fragment_program_NV_fragment_program },

+

+   /* GL_ARB_draw_buffers */

+   { GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },

+

+   { GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   /* GL_ARB_fragment_program */

+   { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */

+     CONTEXT_INT(Const.MaxTextureImageUnits),

+     extra_ARB_fragment_program_NV_fragment_program },

+   { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxVertexTextureImageUnits), extra_ARB_vertex_shader },

+   { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxCombinedTextureImageUnits),

+     extra_ARB_vertex_shader },

+

+   /* GL_ARB_shader_objects

+    * Actually, this token isn't part of GL_ARB_shader_objects, but is

+    * close enough for now. */

+   { GL_CURRENT_PROGRAM, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_objects },

+

+   /* OpenGL 2.0 */

+   { GL_STENCIL_BACK_FUNC, CONTEXT_ENUM(Stencil.Function[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_VALUE_MASK, CONTEXT_INT(Stencil.ValueMask[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_WRITEMASK, CONTEXT_INT(Stencil.WriteMask[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_REF, CONTEXT_INT(Stencil.Ref[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_FAIL, CONTEXT_ENUM(Stencil.FailFunc[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_PASS_DEPTH_FAIL, CONTEXT_ENUM(Stencil.ZFailFunc[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_PASS_DEPTH_PASS, CONTEXT_ENUM(Stencil.ZPassFunc[1]), NO_EXTRA },

+

+   { GL_MAX_VERTEX_ATTRIBS_ARB,

+     CONTEXT_INT(Const.VertexProgram.MaxAttribs),

+     extra_ARB_vertex_program_version_es2 },

+

+   /* OES_texture_3D */

+   { GL_TEXTURE_BINDING_3D, LOC_CUSTOM, TYPE_INT, TEXTURE_3D_INDEX, NO_EXTRA },

+   { GL_MAX_3D_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.Max3DTextureLevels), NO_EXTRA },

+

+   /* GL_ARB_fragment_program/OES_standard_derivatives */

+   { GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB,

+     CONTEXT_ENUM(Hint.FragmentShaderDerivative), extra_ARB_fragment_shader },

+#endif /* FEATURE_GL || FEATURE_ES2 */

+

+#if FEATURE_ES2

+   /* Enums unique to OpenGL ES 2.0 */

+   { 0, 0, TYPE_API_MASK, API_OPENGLES2_BIT, NO_EXTRA },

+   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying), NO_EXTRA },

+   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_SHADER_COMPILER, CONST(1), NO_EXTRA },

+   /* OES_get_program_binary */

+   { GL_NUM_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },

+   { GL_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },

+#endif /* FEATURE_ES2 */

+

+#if FEATURE_GL

+   /* Remaining enums are only in OpenGL */

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA },

+   { GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA },

+   { GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA },

+   { GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA },

+   { GL_ACCUM_ALPHA_BITS, BUFFER_INT(Visual.accumAlphaBits), NO_EXTRA },

+   { GL_ACCUM_CLEAR_VALUE, CONTEXT_FIELD(Accum.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_ALPHA_BIAS, CONTEXT_FLOAT(Pixel.AlphaBias), NO_EXTRA },

+   { GL_ALPHA_SCALE, CONTEXT_FLOAT(Pixel.AlphaScale), NO_EXTRA },

+   { GL_ATTRIB_STACK_DEPTH, CONTEXT_INT(AttribStackDepth), NO_EXTRA },

+   { GL_AUTO_NORMAL, CONTEXT_BOOL(Eval.AutoNormal), NO_EXTRA },

+   { GL_AUX_BUFFERS, BUFFER_INT(Visual.numAuxBuffers), NO_EXTRA },

+   { GL_BLUE_BIAS, CONTEXT_FLOAT(Pixel.BlueBias), NO_EXTRA },

+   { GL_BLUE_SCALE, CONTEXT_FLOAT(Pixel.BlueScale), NO_EXTRA },

+   { GL_CLIENT_ATTRIB_STACK_DEPTH, CONTEXT_INT(ClientAttribStackDepth), NO_EXTRA },

+   { GL_COLOR_MATERIAL_FACE, CONTEXT_ENUM(Light.ColorMaterialFace), NO_EXTRA },

+   { GL_COLOR_MATERIAL_PARAMETER, CONTEXT_ENUM(Light.ColorMaterialMode), NO_EXTRA },

+   { GL_CURRENT_INDEX,

+     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]),

+     extra_flush_current },

+   { GL_CURRENT_RASTER_COLOR,

+     CONTEXT_FIELD(Current.RasterColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_CURRENT_RASTER_DISTANCE, CONTEXT_FLOAT(Current.RasterDistance), NO_EXTRA },

+   { GL_CURRENT_RASTER_INDEX, CONST(1), NO_EXTRA },

+   { GL_CURRENT_RASTER_POSITION, CONTEXT_FLOAT4(Current.RasterPos[0]), NO_EXTRA },

+   { GL_CURRENT_RASTER_SECONDARY_COLOR,

+     CONTEXT_FIELD(Current.RasterSecondaryColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_CURRENT_RASTER_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,

+     extra_valid_texture_unit },

+   { GL_CURRENT_RASTER_POSITION_VALID, CONTEXT_BOOL(Current.RasterPosValid), NO_EXTRA },

+   { GL_DEPTH_BIAS, CONTEXT_FLOAT(Pixel.DepthBias), NO_EXTRA },

+   { GL_DEPTH_SCALE, CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA },

+   { GL_DOUBLEBUFFER, BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA },

+   { GL_DRAW_BUFFER, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },

+   { GL_EDGE_FLAG, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   { GL_FEEDBACK_BUFFER_SIZE, CONTEXT_INT(Feedback.BufferSize), NO_EXTRA },

+   { GL_FEEDBACK_BUFFER_TYPE, CONTEXT_ENUM(Feedback.Type), NO_EXTRA },

+   { GL_FOG_INDEX, CONTEXT_FLOAT(Fog.Index), NO_EXTRA },

+   { GL_GREEN_BIAS, CONTEXT_FLOAT(Pixel.GreenBias), NO_EXTRA },

+   { GL_GREEN_SCALE, CONTEXT_FLOAT(Pixel.GreenScale), NO_EXTRA },

+   { GL_INDEX_BITS, BUFFER_INT(Visual.indexBits), extra_new_buffers },

+   { GL_INDEX_CLEAR_VALUE, CONTEXT_INT(Color.ClearIndex), NO_EXTRA },

+   { GL_INDEX_MODE, CONST(0) , NO_EXTRA}, 

+   { GL_INDEX_OFFSET, CONTEXT_INT(Pixel.IndexOffset), NO_EXTRA },

+   { GL_INDEX_SHIFT, CONTEXT_INT(Pixel.IndexShift), NO_EXTRA },

+   { GL_INDEX_WRITEMASK, CONTEXT_INT(Color.IndexMask), NO_EXTRA },

+   { GL_LIGHT_MODEL_COLOR_CONTROL, CONTEXT_ENUM(Light.Model.ColorControl), NO_EXTRA },

+   { GL_LIGHT_MODEL_LOCAL_VIEWER, CONTEXT_BOOL(Light.Model.LocalViewer), NO_EXTRA },

+   { GL_LINE_STIPPLE, CONTEXT_BOOL(Line.StippleFlag), NO_EXTRA },

+   { GL_LINE_STIPPLE_PATTERN, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_LINE_STIPPLE_REPEAT, CONTEXT_INT(Line.StippleFactor), NO_EXTRA },

+   { GL_LINE_WIDTH_GRANULARITY, CONTEXT_FLOAT(Const.LineWidthGranularity), NO_EXTRA },

+   { GL_LIST_BASE, CONTEXT_INT(List.ListBase), NO_EXTRA },

+   { GL_LIST_INDEX, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_LIST_MODE, LOC_CUSTOM, TYPE_ENUM, 0, NO_EXTRA },

+   { GL_INDEX_LOGIC_OP, CONTEXT_BOOL(Color.IndexLogicOpEnabled), NO_EXTRA },

+   { GL_MAP1_COLOR_4, CONTEXT_BOOL(Eval.Map1Color4), NO_EXTRA },

+   { GL_MAP1_GRID_DOMAIN, CONTEXT_FLOAT2(Eval.MapGrid1u1), NO_EXTRA },

+   { GL_MAP1_GRID_SEGMENTS, CONTEXT_INT(Eval.MapGrid1un), NO_EXTRA },

+   { GL_MAP1_INDEX, CONTEXT_BOOL(Eval.Map1Index), NO_EXTRA },

+   { GL_MAP1_NORMAL, CONTEXT_BOOL(Eval.Map1Normal), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map1TextureCoord1), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map1TextureCoord2), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map1TextureCoord3), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map1TextureCoord4), NO_EXTRA },

+   { GL_MAP1_VERTEX_3, CONTEXT_BOOL(Eval.Map1Vertex3), NO_EXTRA },

+   { GL_MAP1_VERTEX_4, CONTEXT_BOOL(Eval.Map1Vertex4), NO_EXTRA },

+   { GL_MAP2_COLOR_4, CONTEXT_BOOL(Eval.Map2Color4), NO_EXTRA },

+   { GL_MAP2_GRID_DOMAIN, LOC_CUSTOM, TYPE_FLOAT_4, 0, NO_EXTRA },

+   { GL_MAP2_GRID_SEGMENTS, CONTEXT_INT2(Eval.MapGrid2un), NO_EXTRA },

+   { GL_MAP2_INDEX, CONTEXT_BOOL(Eval.Map2Index), NO_EXTRA },

+   { GL_MAP2_NORMAL, CONTEXT_BOOL(Eval.Map2Normal), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map2TextureCoord1), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map2TextureCoord2), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map2TextureCoord3), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map2TextureCoord4), NO_EXTRA },

+   { GL_MAP2_VERTEX_3, CONTEXT_BOOL(Eval.Map2Vertex3), NO_EXTRA },

+   { GL_MAP2_VERTEX_4, CONTEXT_BOOL(Eval.Map2Vertex4), NO_EXTRA },

+   { GL_MAP_COLOR, CONTEXT_BOOL(Pixel.MapColorFlag), NO_EXTRA },

+   { GL_MAP_STENCIL, CONTEXT_BOOL(Pixel.MapStencilFlag), NO_EXTRA },

+   { GL_MAX_ATTRIB_STACK_DEPTH, CONST(MAX_ATTRIB_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, CONST(MAX_CLIENT_ATTRIB_STACK_DEPTH), NO_EXTRA },

+

+   { GL_MAX_EVAL_ORDER, CONST(MAX_EVAL_ORDER), NO_EXTRA },

+   { GL_MAX_LIST_NESTING, CONST(MAX_LIST_NESTING), NO_EXTRA },

+   { GL_MAX_NAME_STACK_DEPTH, CONST(MAX_NAME_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_PIXEL_MAP_TABLE, CONST(MAX_PIXEL_MAP_TABLE), NO_EXTRA },

+   { GL_NAME_STACK_DEPTH, CONTEXT_INT(Select.NameStackDepth), NO_EXTRA },

+   { GL_PACK_LSB_FIRST, CONTEXT_BOOL(Pack.LsbFirst), NO_EXTRA },

+   { GL_PACK_ROW_LENGTH, CONTEXT_INT(Pack.RowLength), NO_EXTRA },

+   { GL_PACK_SKIP_PIXELS, CONTEXT_INT(Pack.SkipPixels), NO_EXTRA },

+   { GL_PACK_SKIP_ROWS, CONTEXT_INT(Pack.SkipRows), NO_EXTRA },

+   { GL_PACK_SWAP_BYTES, CONTEXT_BOOL(Pack.SwapBytes), NO_EXTRA },

+   { GL_PACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Pack.ImageHeight), NO_EXTRA },

+   { GL_PACK_INVERT_MESA, CONTEXT_BOOL(Pack.Invert), NO_EXTRA },

+   { GL_PIXEL_MAP_A_TO_A_SIZE, CONTEXT_INT(PixelMaps.AtoA.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_B_TO_B_SIZE, CONTEXT_INT(PixelMaps.BtoB.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_G_TO_G_SIZE, CONTEXT_INT(PixelMaps.GtoG.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_A_SIZE, CONTEXT_INT(PixelMaps.ItoA.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_B_SIZE, CONTEXT_INT(PixelMaps.ItoB.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_G_SIZE, CONTEXT_INT(PixelMaps.ItoG.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_I_SIZE, CONTEXT_INT(PixelMaps.ItoI.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_R_SIZE, CONTEXT_INT(PixelMaps.ItoR.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_R_TO_R_SIZE, CONTEXT_INT(PixelMaps.RtoR.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_S_TO_S_SIZE, CONTEXT_INT(PixelMaps.StoS.Size), NO_EXTRA },

+   { GL_POINT_SIZE_GRANULARITY, CONTEXT_FLOAT(Const.PointSizeGranularity), NO_EXTRA },

+   { GL_POLYGON_MODE, CONTEXT_ENUM2(Polygon.FrontMode), NO_EXTRA },

+   { GL_POLYGON_OFFSET_BIAS_EXT, CONTEXT_FLOAT(Polygon.OffsetUnits), NO_EXTRA },

+   { GL_POLYGON_OFFSET_POINT, CONTEXT_BOOL(Polygon.OffsetPoint), NO_EXTRA },

+   { GL_POLYGON_OFFSET_LINE, CONTEXT_BOOL(Polygon.OffsetLine), NO_EXTRA },

+   { GL_POLYGON_SMOOTH, CONTEXT_BOOL(Polygon.SmoothFlag), NO_EXTRA },

+   { GL_POLYGON_SMOOTH_HINT, CONTEXT_ENUM(Hint.PolygonSmooth), NO_EXTRA },

+   { GL_POLYGON_STIPPLE, CONTEXT_BOOL(Polygon.StippleFlag), NO_EXTRA },

+   { GL_READ_BUFFER, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_RED_BIAS, CONTEXT_FLOAT(Pixel.RedBias), NO_EXTRA },

+   { GL_RED_SCALE, CONTEXT_FLOAT(Pixel.RedScale), NO_EXTRA },

+   { GL_RENDER_MODE, CONTEXT_ENUM(RenderMode), NO_EXTRA },

+   { GL_RGBA_MODE, CONST(1), NO_EXTRA },

+   { GL_SELECTION_BUFFER_SIZE, CONTEXT_INT(Select.BufferSize), NO_EXTRA },

+   { GL_SHARED_TEXTURE_PALETTE_EXT, CONTEXT_BOOL(Texture.SharedPalette), NO_EXTRA },

+

+   { GL_STEREO, BUFFER_INT(Visual.stereoMode), NO_EXTRA },

+

+   { GL_TEXTURE_1D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_3D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_1D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_2D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+

+   { GL_TEXTURE_BINDING_1D, LOC_CUSTOM, TYPE_INT, TEXTURE_1D_INDEX, NO_EXTRA },

+   { GL_TEXTURE_BINDING_1D_ARRAY, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },

+   { GL_TEXTURE_BINDING_2D_ARRAY, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },

+   { GL_MAX_ARRAY_TEXTURE_LAYERS_EXT,

+     CONTEXT_INT(Const.MaxArrayTextureLayers), extra_MESA_texture_array },

+

+   { GL_TEXTURE_GEN_S, LOC_TEXUNIT, TYPE_BIT_0,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_T, LOC_TEXUNIT, TYPE_BIT_1,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_R, LOC_TEXUNIT, TYPE_BIT_2,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_Q, LOC_TEXUNIT, TYPE_BIT_3,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_UNPACK_LSB_FIRST, CONTEXT_BOOL(Unpack.LsbFirst), NO_EXTRA },

+   { GL_UNPACK_ROW_LENGTH, CONTEXT_INT(Unpack.RowLength), NO_EXTRA },

+   { GL_UNPACK_SKIP_PIXELS, CONTEXT_INT(Unpack.SkipPixels), NO_EXTRA },

+   { GL_UNPACK_SKIP_ROWS, CONTEXT_INT(Unpack.SkipRows), NO_EXTRA },

+   { GL_UNPACK_SWAP_BYTES, CONTEXT_BOOL(Unpack.SwapBytes), NO_EXTRA },

+   { GL_UNPACK_SKIP_IMAGES_EXT, CONTEXT_INT(Unpack.SkipImages), NO_EXTRA },

+   { GL_UNPACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Unpack.ImageHeight), NO_EXTRA },

+   { GL_UNPACK_CLIENT_STORAGE_APPLE, CONTEXT_BOOL(Unpack.ClientStorage), NO_EXTRA },

+   { GL_ZOOM_X, CONTEXT_FLOAT(Pixel.ZoomX), NO_EXTRA },

+   { GL_ZOOM_Y, CONTEXT_FLOAT(Pixel.ZoomY), NO_EXTRA },

+

+   /* Vertex arrays */

+   { GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA },

+   { GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA },

+   { GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA },

+   { GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+

+   /* GL_ARB_texture_compression */

+   { GL_TEXTURE_COMPRESSION_HINT_ARB, CONTEXT_INT(Hint.TextureCompression), NO_EXTRA },

+

+   /* GL_EXT_compiled_vertex_array */

+   { GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, CONTEXT_INT(Array.LockFirst),

+     extra_EXT_compiled_vertex_array },

+   { GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, CONTEXT_INT(Array.LockCount),

+     extra_EXT_compiled_vertex_array },

+

+   /* GL_ARB_transpose_matrix */

+   { GL_TRANSPOSE_MODELVIEW_MATRIX_ARB,

+     CONTEXT_MATRIX_T(ModelviewMatrixStack), NO_EXTRA },

+   { GL_TRANSPOSE_PROJECTION_MATRIX_ARB,

+     CONTEXT_MATRIX_T(ProjectionMatrixStack.Top), NO_EXTRA },

+   { GL_TRANSPOSE_TEXTURE_MATRIX_ARB, CONTEXT_MATRIX_T(TextureMatrixStack), NO_EXTRA },

+

+   /* GL_EXT_secondary_color */

+   { GL_COLOR_SUM_EXT, CONTEXT_BOOL(Fog.ColorSumEnabled),

+     extra_EXT_secondary_color_ARB_vertex_program },

+   { GL_CURRENT_SECONDARY_COLOR_EXT,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),

+     extra_EXT_secondary_color_flush_current },

+   { GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size),

+     extra_EXT_secondary_color },

+

+   /* GL_EXT_fog_coord */

+   { GL_CURRENT_FOG_COORDINATE_EXT,

+     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),

+     extra_EXT_fog_coord_flush_current },

+   { GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),

+     extra_EXT_fog_coord },

+

+   /* GL_IBM_rasterpos_clip */

+   { GL_RASTER_POSITION_UNCLIPPED_IBM,

+     CONTEXT_BOOL(Transform.RasterPositionUnclipped),

+     extra_IBM_rasterpos_clip },

+

+   /* GL_NV_point_sprite */

+   { GL_POINT_SPRITE_R_MODE_NV,

+     CONTEXT_ENUM(Point.SpriteRMode), extra_NV_point_sprite },

+   { GL_POINT_SPRITE_COORD_ORIGIN, CONTEXT_ENUM(Point.SpriteOrigin),

+     extra_NV_point_sprite_ARB_point_sprite },

+

+   /* GL_NV_vertex_program */

+   { GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB1_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[1]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB2_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[2]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB3_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[3]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB4_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[4]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB5_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[5]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB6_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[6]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB7_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[7]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB8_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[8]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB9_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[9]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB10_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[10]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB11_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[11]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB12_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[12]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB13_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[13]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB14_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[14]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB15_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[15]),

+     extra_NV_vertex_program },

+

+   /* GL_NV_fragment_program */

+   { GL_FRAGMENT_PROGRAM_NV, CONTEXT_BOOL(FragmentProgram.Enabled),

+     extra_NV_fragment_program },

+   { GL_FRAGMENT_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,

+     extra_NV_fragment_program },

+   { GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV,

+     CONST(MAX_NV_FRAGMENT_PROGRAM_PARAMS),

+     extra_NV_fragment_program },

+

+   /* GL_NV_texture_rectangle */

+   { GL_TEXTURE_RECTANGLE_NV,

+     LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_NV_texture_rectangle },

+   { GL_TEXTURE_BINDING_RECTANGLE_NV,

+     LOC_CUSTOM, TYPE_INT, TEXTURE_RECT_INDEX, extra_NV_texture_rectangle },

+   { GL_MAX_RECTANGLE_TEXTURE_SIZE_NV,

+     CONTEXT_INT(Const.MaxTextureRectSize), extra_NV_texture_rectangle },

+

+   /* GL_EXT_stencil_two_side */

+   { GL_STENCIL_TEST_TWO_SIDE_EXT, CONTEXT_BOOL(Stencil.TestTwoSide),

+	 extra_EXT_stencil_two_side },

+   { GL_ACTIVE_STENCIL_FACE_EXT, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+

+   /* GL_NV_light_max_exponent */

+   { GL_MAX_SHININESS_NV, CONTEXT_FLOAT(Const.MaxShininess),

+     extra_NV_light_max_exponent },

+   { GL_MAX_SPOT_EXPONENT_NV, CONTEXT_FLOAT(Const.MaxSpotExponent),

+     extra_NV_light_max_exponent },

+     

+   /* GL_NV_primitive_restart */

+   { GL_PRIMITIVE_RESTART_NV, CONTEXT_BOOL(Array.PrimitiveRestart),

+     extra_NV_primitive_restart },

+   { GL_PRIMITIVE_RESTART_INDEX_NV, CONTEXT_INT(Array.RestartIndex),

+     extra_NV_primitive_restart },

+ 

+   /* GL_ARB_vertex_buffer_object */

+   { GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA },

+   { GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA },

+   { GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA },

+

+   /* GL_EXT_pixel_buffer_object */

+   { GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_pixel_buffer_object },

+   { GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_pixel_buffer_object },

+

+   /* GL_ARB_vertex_program */

+   { GL_VERTEX_PROGRAM_ARB, /* == GL_VERTEX_PROGRAM_NV */

+     CONTEXT_BOOL(VertexProgram.Enabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_VERTEX_PROGRAM_POINT_SIZE_ARB, /* == GL_VERTEX_PROGRAM_POINT_SIZE_NV*/

+     CONTEXT_BOOL(VertexProgram.PointSizeEnabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_VERTEX_PROGRAM_TWO_SIDE_ARB, /* == GL_VERTEX_PROGRAM_TWO_SIDE_NV */

+     CONTEXT_BOOL(VertexProgram.TwoSideEnabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, /* == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */

+     CONTEXT_INT(Const.MaxProgramMatrixStackDepth),

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_MAX_PROGRAM_MATRICES_ARB, /* == GL_MAX_TRACK_MATRICES_NV */

+     CONTEXT_INT(Const.MaxProgramMatrices),

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_CURRENT_MATRIX_STACK_DEPTH_ARB, /* == GL_CURRENT_MATRIX_STACK_DEPTH_NV */

+     LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+

+   { GL_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */

+     LOC_CUSTOM, TYPE_MATRIX, 0,

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_TRANSPOSE_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */

+     LOC_CUSTOM, TYPE_MATRIX, 0,

+     extra_ARB_vertex_program_ARB_fragment_program },

+

+   { GL_PROGRAM_ERROR_POSITION_ARB, /* == GL_PROGRAM_ERROR_POSITION_NV */

+     CONTEXT_INT(Program.ErrorPos),

+     extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+

+   /* GL_ARB_fragment_program */

+   { GL_FRAGMENT_PROGRAM_ARB, CONTEXT_BOOL(FragmentProgram.Enabled),

+     extra_ARB_fragment_program },

+

+   /* GL_EXT_depth_bounds_test */

+   { GL_DEPTH_BOUNDS_TEST_EXT, CONTEXT_BOOL(Depth.BoundsTest),

+     extra_EXT_depth_bounds_test },

+   { GL_DEPTH_BOUNDS_EXT, CONTEXT_FLOAT2(Depth.BoundsMin),

+     extra_EXT_depth_bounds_test },

+

+   /* GL_ARB_depth_clamp*/

+   { GL_DEPTH_CLAMP, CONTEXT_BOOL(Transform.DepthClamp),

+     extra_ARB_depth_clamp },

+

+   /* GL_ARB_draw_buffers */

+   { GL_DRAW_BUFFER0_ARB, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },

+   { GL_DRAW_BUFFER1_ARB, BUFFER_ENUM(ColorDrawBuffer[1]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER2_ARB, BUFFER_ENUM(ColorDrawBuffer[2]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER3_ARB, BUFFER_ENUM(ColorDrawBuffer[3]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER4_ARB, BUFFER_ENUM(ColorDrawBuffer[4]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER5_ARB, BUFFER_ENUM(ColorDrawBuffer[5]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER6_ARB, BUFFER_ENUM(ColorDrawBuffer[6]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER7_ARB, BUFFER_ENUM(ColorDrawBuffer[7]),

+     extra_valid_draw_buffer },

+

+   /* GL_ATI_fragment_shader */

+   { GL_NUM_FRAGMENT_REGISTERS_ATI, CONST(6), extra_ATI_fragment_shader },

+   { GL_NUM_FRAGMENT_CONSTANTS_ATI, CONST(8), extra_ATI_fragment_shader },

+   { GL_NUM_PASSES_ATI, CONST(2), extra_ATI_fragment_shader },

+   { GL_NUM_INSTRUCTIONS_PER_PASS_ATI, CONST(8), extra_ATI_fragment_shader },

+   { GL_NUM_INSTRUCTIONS_TOTAL_ATI, CONST(16), extra_ATI_fragment_shader },

+   { GL_COLOR_ALPHA_PAIRING_ATI, CONST(GL_TRUE), extra_ATI_fragment_shader },

+   { GL_NUM_LOOPBACK_COMPONENTS_ATI, CONST(3), extra_ATI_fragment_shader },

+   { GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI,

+     CONST(3), extra_ATI_fragment_shader },

+

+   /* GL_EXT_framebuffer_object */

+   { GL_MAX_COLOR_ATTACHMENTS_EXT, CONTEXT_INT(Const.MaxColorAttachments),

+     extra_EXT_framebuffer_object },

+   

+   /* GL_EXT_framebuffer_blit

+    * NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT */

+   { GL_READ_FRAMEBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_framebuffer_blit },

+

+   /* GL_EXT_provoking_vertex */

+   { GL_PROVOKING_VERTEX_EXT,

+     CONTEXT_BOOL(Light.ProvokingVertex), extra_EXT_provoking_vertex },

+   { GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT,

+     CONTEXT_BOOL(Const.QuadsFollowProvokingVertexConvention),

+     extra_EXT_provoking_vertex },

+

+   /* GL_ARB_framebuffer_object */

+   { GL_MAX_SAMPLES, CONTEXT_INT(Const.MaxSamples),

+     extra_ARB_framebuffer_object_EXT_framebuffer_multisample },

+

+   /* GL_APPLE_vertex_array_object */

+   { GL_VERTEX_ARRAY_BINDING_APPLE, ARRAY_INT(Name),

+     extra_APPLE_vertex_array_object },

+

+   /* GL_ARB_seamless_cube_map */

+   { GL_TEXTURE_CUBE_MAP_SEAMLESS,

+     CONTEXT_BOOL(Texture.CubeMapSeamless), extra_ARB_seamless_cube_map },

+

+   /* GL_ARB_sync */

+   { GL_MAX_SERVER_WAIT_TIMEOUT,

+     CONTEXT_INT64(Const.MaxServerWaitTimeout), extra_ARB_sync },

+

+   /* GL_EXT_texture_integer */

+   { GL_RGBA_INTEGER_MODE_EXT, BUFFER_BOOL(_IntegerColor),

+     extra_EXT_texture_integer },

+

+   /* GL_EXT_transform_feedback */

+   { GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_transform_feedback },

+   { GL_RASTERIZER_DISCARD, CONTEXT_BOOL(TransformFeedback.RasterDiscard),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,

+     CONTEXT_INT(Const.MaxTransformFeedbackInterleavedComponents),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,

+     CONTEXT_INT(Const.MaxTransformFeedbackSeparateAttribs),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,

+     CONTEXT_INT(Const.MaxTransformFeedbackSeparateComponents),

+     extra_EXT_transform_feedback },

+

+   /* GL_ARB_transform_feedback2 */

+   { GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, LOC_CUSTOM, TYPE_BOOLEAN, 0,

+     extra_ARB_transform_feedback2 },

+   { GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, LOC_CUSTOM, TYPE_BOOLEAN, 0,

+     extra_ARB_transform_feedback2 },

+   { GL_TRANSFORM_FEEDBACK_BINDING, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_transform_feedback2 },

+

+   /* GL_ARB_geometry_shader4 */

+   { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTextureImageUnits),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxGeometryOutputVertices),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTotalOutputComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxGeometryUniformComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxGeometryVaryingComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_VERTEX_VARYING_COMPONENTS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxVertexVaryingComponents),

+     extra_ARB_geometry_shader4 },

+

+   /* GL_EXT_gpu_shader4 / GL 3.0 */

+   { GL_MIN_PROGRAM_TEXEL_OFFSET,

+     CONTEXT_INT(Const.MinProgramTexelOffset),

+     extra_EXT_gpu_shader4 },

+   { GL_MAX_PROGRAM_TEXEL_OFFSET,

+     CONTEXT_INT(Const.MaxProgramTexelOffset),

+     extra_EXT_gpu_shader4 },

+

+   /* GL 3.0 */

+   { GL_NUM_EXTENSIONS, LOC_CUSTOM, TYPE_INT, 0, extra_version_30 },

+   { GL_MAJOR_VERSION, CONTEXT_INT(VersionMajor), extra_version_30 },

+   { GL_MINOR_VERSION, CONTEXT_INT(VersionMinor), extra_version_30  },

+   { GL_CONTEXT_FLAGS, CONTEXT_INT(Const.ContextFlags), extra_version_30  },

+

+   /* GL3.0 / GL_EXT_framebuffer_sRGB */

+   { GL_FRAMEBUFFER_SRGB_EXT, CONTEXT_BOOL(Color.sRGBEnabled), extra_EXT_framebuffer_sRGB },

+   { GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, BUFFER_INT(Visual.sRGBCapable), extra_EXT_framebuffer_sRGB },

+

+   /* GL 3.1 */

+   /* NOTE: different enum values for GL_PRIMITIVE_RESTART_NV

+    * vs. GL_PRIMITIVE_RESTART!

+    */

+   { GL_PRIMITIVE_RESTART, CONTEXT_BOOL(Array.PrimitiveRestart),

+     extra_version_31 },

+   { GL_PRIMITIVE_RESTART_INDEX, CONTEXT_INT(Array.RestartIndex),

+     extra_version_31 },

+ 

+

+   /* GL 3.2 */

+   { GL_CONTEXT_PROFILE_MASK, CONTEXT_INT(Const.ProfileMask),

+     extra_version_32 },

+#endif /* FEATURE_GL */

+};

+

+/* All we need now is a way to look up the value struct from the enum.

+ * The code generated by gcc for the old generated big switch

+ * statement is a big, balanced, open coded if/else tree, essentially

+ * an unrolled binary search.  It would be natural to sort the new

+ * enum table and use bsearch(), but we will use a read-only hash

+ * table instead.  bsearch() has a nice guaranteed worst case

+ * performance, but we're also guaranteed to hit that worst case

+ * (log2(n) iterations) for about half the enums.  Instead, using an

+ * open addressing hash table, we can find the enum on the first try

+ * for 80% of the enums, 1 collision for 10% and never more than 5

+ * collisions for any enum (typical numbers).  And the code is very

+ * simple, even though it feels a little magic. */

+

+static unsigned short table[1024];

+static const int prime_factor = 89, prime_step = 281;

+

+#ifdef GET_DEBUG

+static void

+print_table_stats(void)

+{

+   int i, j, collisions[11], count, hash, mask;

+   const struct value_desc *d;

+

+   count = 0;

+   mask = Elements(table) - 1;

+   memset(collisions, 0, sizeof collisions);

+

+   for (i = 0; i < Elements(table); i++) {

+      if (!table[i])

+	 continue;

+      count++;

+      d = &values[table[i]];

+      hash = (d->pname * prime_factor);

+      j = 0;

+      while (1) {

+	 if (values[table[hash & mask]].pname == d->pname)

+	    break;

+	 hash += prime_step;

+	 j++;

+      }

+

+      if (j < 10)

+	 collisions[j]++;

+      else

+	 collisions[10]++;

+   }

+

+   printf("number of enums: %d (total %d)\n", count, Elements(values));

+   for (i = 0; i < Elements(collisions) - 1; i++)

+      if (collisions[i] > 0)

+	 printf("  %d enums with %d %scollisions\n",

+		collisions[i], i, i == 10 ? "or more " : "");

+}

+#endif

+

+/**

+ * Initialize the enum hash for a given API 

+ *

+ * This is called from one_time_init() to insert the enum values that

+ * are valid for the API in question into the enum hash table.

+ *

+ * \param the current context, for determining the API in question

+ */

+void _mesa_init_get_hash(struct gl_context *ctx)

+{

+   int i, hash, index, mask;

+   int api_mask = 0, api_bit;

+

+   mask = Elements(table) - 1;

+   api_bit = 1 << ctx->API;

+

+   for (i = 0; i < Elements(values); i++) {

+      if (values[i].type == TYPE_API_MASK) {

+	 api_mask = values[i].offset;

+	 continue;

+      }

+      if (!(api_mask & api_bit))

+	 continue;

+

+      hash = (values[i].pname * prime_factor) & mask;

+      while (1) {

+	 index = hash & mask;

+	 if (!table[index]) {

+	    table[index] = i;

+	    break;

+	 }

+	 hash += prime_step;

+      }

+   }

+

+#ifdef GET_DEBUG

+   print_table_stats();

+#endif

+}

+

+/**

+ * Handle irregular enums

+ *

+ * Some values don't conform to the "well-known type at context

+ * pointer + offset" pattern, so we have this function to catch all

+ * the corner cases.  Typically, it's a computed value or a one-off

+ * pointer to a custom struct or something.

+ *

+ * In this case we can't return a pointer to the value, so we'll have

+ * to use the temporary variable 'v' declared back in the calling

+ * glGet*v() function to store the result.

+ *

+ * \param ctx the current context

+ * \param d the struct value_desc that describes the enum

+ * \param v pointer to the tmp declared in the calling glGet*v() function

+ */

+static void

+find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)

+{

+   struct gl_buffer_object *buffer_obj;

+   struct gl_client_array *array;

+   GLuint unit, *p;

+

+   switch (d->pname) {

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_3D:

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_TEXTURE_RECTANGLE_NV:

+      v->value_bool = _mesa_IsEnabled(d->pname);

+      break;

+

+   case GL_LINE_STIPPLE_PATTERN:

+      /* This is the only GLushort, special case it here by promoting

+       * to an int rather than introducing a new type. */

+      v->value_int = ctx->Line.StipplePattern;

+      break;

+

+   case GL_CURRENT_RASTER_TEXTURE_COORDS:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];

+      v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];

+      v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];

+      v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];

+      break;

+

+   case GL_CURRENT_TEXTURE_COORDS:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];

+      v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];

+      v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];

+      v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];

+      break;

+

+   case GL_COLOR_WRITEMASK:

+      v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;

+      v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;

+      v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;

+      v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;

+      break;

+

+   case GL_EDGE_FLAG:

+      v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;

+      break;

+

+   case GL_READ_BUFFER:

+      v->value_enum = ctx->ReadBuffer->ColorReadBuffer;

+      break;

+

+   case GL_MAP2_GRID_DOMAIN:

+      v->value_float_4[0] = ctx->Eval.MapGrid2u1;

+      v->value_float_4[1] = ctx->Eval.MapGrid2u2;

+      v->value_float_4[2] = ctx->Eval.MapGrid2v1;

+      v->value_float_4[3] = ctx->Eval.MapGrid2v2;

+      break;

+

+   case GL_TEXTURE_STACK_DEPTH:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;

+      break;

+   case GL_TEXTURE_MATRIX:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_matrix = ctx->TextureMatrixStack[unit].Top;

+      break;

+

+   case GL_TEXTURE_COORD_ARRAY:

+   case GL_TEXTURE_COORD_ARRAY_SIZE:

+   case GL_TEXTURE_COORD_ARRAY_TYPE:

+   case GL_TEXTURE_COORD_ARRAY_STRIDE:

+      array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture];

+      v->value_int = *(GLuint *) ((char *) array + d->offset);

+      break;

+

+   case GL_ACTIVE_TEXTURE_ARB:

+      v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;

+      break;

+   case GL_CLIENT_ACTIVE_TEXTURE_ARB:

+      v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;

+      break;

+

+   case GL_MODELVIEW_STACK_DEPTH:

+   case GL_PROJECTION_STACK_DEPTH:

+      v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;

+      break;

+

+   case GL_MAX_TEXTURE_SIZE:

+   case GL_MAX_3D_TEXTURE_SIZE:

+   case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:

+      p = (GLuint *) ((char *) ctx + d->offset);

+      v->value_int = 1 << (*p - 1);

+      break;

+

+   case GL_SCISSOR_BOX:

+      v->value_int_4[0] = ctx->Scissor.X;

+      v->value_int_4[1] = ctx->Scissor.Y;

+      v->value_int_4[2] = ctx->Scissor.Width;

+      v->value_int_4[3] = ctx->Scissor.Height;

+      break;

+

+   case GL_LIST_INDEX:

+      v->value_int =

+	 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;

+      break;

+   case GL_LIST_MODE:

+      if (!ctx->CompileFlag)

+	 v->value_enum = 0;

+      else if (ctx->ExecuteFlag)

+	 v->value_enum = GL_COMPILE_AND_EXECUTE;

+      else

+	 v->value_enum = GL_COMPILE;

+      break;

+

+   case GL_VIEWPORT:

+      v->value_int_4[0] = ctx->Viewport.X;

+      v->value_int_4[1] = ctx->Viewport.Y;

+      v->value_int_4[2] = ctx->Viewport.Width;

+      v->value_int_4[3] = ctx->Viewport.Height;

+      break;

+

+   case GL_ACTIVE_STENCIL_FACE_EXT:

+      v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;

+      break;

+

+   case GL_STENCIL_FAIL:

+      v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_FUNC:

+      v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_PASS_DEPTH_FAIL:

+      v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_PASS_DEPTH_PASS:

+      v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_REF:

+      v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_VALUE_MASK:

+      v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_WRITEMASK:

+      v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];

+      break;

+

+   case GL_NUM_EXTENSIONS:

+      v->value_int = _mesa_get_extension_count(ctx);

+      break;

+

+   case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:

+      v->value_int = _mesa_get_color_read_type(ctx);

+      break;

+   case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:

+      v->value_int = _mesa_get_color_read_format(ctx);

+      break;

+

+   case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:

+      v->value_int = ctx->CurrentStack->Depth + 1;

+      break;

+   case GL_CURRENT_MATRIX_ARB:

+   case GL_TRANSPOSE_CURRENT_MATRIX_ARB:

+      v->value_matrix = ctx->CurrentStack->Top;

+      break;

+

+   case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:

+      v->value_int = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);

+      break;

+   case GL_COMPRESSED_TEXTURE_FORMATS_ARB:

+      v->value_int_n.n = 

+	 _mesa_get_compressed_formats(ctx, v->value_int_n.ints, GL_FALSE);

+      ASSERT(v->value_int_n.n <= 100);

+      break;

+

+   case GL_MAX_VARYING_FLOATS_ARB:

+      v->value_int = ctx->Const.MaxVarying * 4;

+      break;

+

+   /* Various object names */

+

+   case GL_TEXTURE_BINDING_1D:

+   case GL_TEXTURE_BINDING_2D:

+   case GL_TEXTURE_BINDING_3D:

+   case GL_TEXTURE_BINDING_1D_ARRAY_EXT:

+   case GL_TEXTURE_BINDING_2D_ARRAY_EXT:

+   case GL_TEXTURE_BINDING_CUBE_MAP_ARB:

+   case GL_TEXTURE_BINDING_RECTANGLE_NV:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_int =

+	 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;

+      break;

+

+   /* GL_ARB_vertex_buffer_object */

+   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:

+   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:

+   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:

+   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:

+   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:

+   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:

+   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:

+      buffer_obj = (struct gl_buffer_object *)

+	 ((char *) ctx->Array.ArrayObj + d->offset);

+      v->value_int = buffer_obj->Name;

+      break;

+   case GL_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int = ctx->Array.ArrayBufferObj->Name;

+      break;

+   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int =

+	 ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;

+      break;

+   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int = ctx->Array.ElementArrayBufferObj->Name;

+      break;

+

+   /* ARB_copy_buffer */

+   case GL_COPY_READ_BUFFER:

+      v->value_int = ctx->CopyReadBuffer->Name;

+      break;

+   case GL_COPY_WRITE_BUFFER:

+      v->value_int = ctx->CopyWriteBuffer->Name;

+      break;

+

+   case GL_FRAGMENT_PROGRAM_BINDING_NV:

+      v->value_int = 

+	 ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;

+      break;

+   case GL_VERTEX_PROGRAM_BINDING_NV:

+      v->value_int =

+	 ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;

+      break;

+   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:

+      v->value_int = ctx->Pack.BufferObj->Name;

+      break;

+   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:

+      v->value_int = ctx->Unpack.BufferObj->Name;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:

+      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Active;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BINDING:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Name;

+      break;

+   case GL_CURRENT_PROGRAM:

+      v->value_int =

+	 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;

+      break;

+   case GL_READ_FRAMEBUFFER_BINDING_EXT:

+      v->value_int = ctx->ReadBuffer->Name;

+      break;

+   case GL_RENDERBUFFER_BINDING_EXT:

+      v->value_int =

+	 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;

+      break;

+   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:

+      v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;

+      break;

+

+   case GL_MAX_VERTEX_UNIFORM_VECTORS:

+      v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;

+      break;

+

+   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:

+      v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;

+      break;

+   }   

+}

+

+/**

+ * Check extra constraints on a struct value_desc descriptor

+ *

+ * If a struct value_desc has a non-NULL extra pointer, it means that

+ * there are a number of extra constraints to check or actions to

+ * perform.  The extras is just an integer array where each integer

+ * encode different constraints or actions.

+ *

+ * \param ctx current context

+ * \param func name of calling glGet*v() function for error reporting

+ * \param d the struct value_desc that has the extra constraints

+ *

+ * \return GL_FALSE if one of the constraints was not satisfied,

+ *     otherwise GL_TRUE.

+ */

+static GLboolean

+check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)

+{

+   const GLuint version = ctx->VersionMajor * 10 + ctx->VersionMinor;

+   int total, enabled;

+   const int *e;

+

+   total = 0;

+   enabled = 0;

+   for (e = d->extra; *e != EXTRA_END; e++)

+      switch (*e) {

+      case EXTRA_VERSION_30:

+	 if (version >= 30) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_31:

+	 if (version >= 31) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_32:

+	 if (version >= 32) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_ES2:

+	 if (ctx->API == API_OPENGLES2) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_NEW_BUFFERS:

+	 if (ctx->NewState & _NEW_BUFFERS)

+	    _mesa_update_state(ctx);

+	 break;

+      case EXTRA_FLUSH_CURRENT:

+	 FLUSH_CURRENT(ctx, 0);

+	 break;

+      case EXTRA_VALID_DRAW_BUFFER:

+	 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {

+	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",

+			func, d->pname - GL_DRAW_BUFFER0_ARB);

+	    return GL_FALSE;

+	 }

+	 break;

+      case EXTRA_VALID_TEXTURE_UNIT:

+	 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {

+	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",

+			func, ctx->Texture.CurrentUnit);

+	    return GL_FALSE;

+	 }

+	 break;

+      case EXTRA_END:

+	 break;

+      default: /* *e is a offset into the extension struct */

+	 total++;

+	 if (*(GLboolean *) ((char *) &ctx->Extensions + *e))

+	    enabled++;

+	 break;

+      }

+

+   if (total > 0 && enabled == 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+                  _mesa_lookup_enum_by_nr(d->pname));

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+static const struct value_desc error_value =

+   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };

+

+/**

+ * Find the struct value_desc corresponding to the enum 'pname'.

+ * 

+ * We hash the enum value to get an index into the 'table' array,

+ * which holds the index in the 'values' array of struct value_desc.

+ * Once we've found the entry, we do the extra checks, if any, then

+ * look up the value and return a pointer to it.

+ *

+ * If the value has to be computed (for example, it's the result of a

+ * function call or we need to add 1 to it), we use the tmp 'v' to

+ * store the result.

+ * 

+ * \param func name of glGet*v() func for error reporting

+ * \param pname the enum value we're looking up

+ * \param p is were we return the pointer to the value

+ * \param v a tmp union value variable in the calling glGet*v() function

+ *

+ * \return the struct value_desc corresponding to the enum or a struct

+ *     value_desc of TYPE_INVALID if not found.  This lets the calling

+ *     glGet*v() function jump right into a switch statement and

+ *     handle errors there instead of having to check for NULL.

+ */

+static const struct value_desc *

+find_value(const char *func, GLenum pname, void **p, union value *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *unit;

+   int mask, hash;

+   const struct value_desc *d;

+

+   mask = Elements(table) - 1;

+   hash = (pname * prime_factor);

+   while (1) {

+      d = &values[table[hash & mask]];

+

+      /* If the enum isn't valid, the hash walk ends with index 0,

+       * which is the API mask entry at the beginning of values[]. */

+      if (unlikely(d->type == TYPE_API_MASK)) {

+	 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+                     _mesa_lookup_enum_by_nr(pname));

+	 return &error_value;

+      }

+

+      if (likely(d->pname == pname))

+	 break;

+

+      hash += prime_step;

+   }

+

+   if (unlikely(d->extra && !check_extra(ctx, func, d)))

+      return &error_value;

+

+   switch (d->location) {

+   case LOC_BUFFER:

+      *p = ((char *) ctx->DrawBuffer + d->offset);

+      return d;

+   case LOC_CONTEXT:

+      *p = ((char *) ctx + d->offset);

+      return d;

+   case LOC_ARRAY:

+      *p = ((char *) ctx->Array.ArrayObj + d->offset);

+      return d;

+   case LOC_TEXUNIT:

+      unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];

+      *p = ((char *) unit + d->offset);

+      return d;

+   case LOC_CUSTOM:

+      find_custom_value(ctx, d, v);

+      *p = v;

+      return d;

+   default:

+      assert(0);

+      break;

+   }

+

+   /* silence warning */

+   return &error_value;

+}

+

+static const int transpose[] = {

+   0, 4,  8, 12,

+   1, 5,  9, 13,

+   2, 6, 10, 14,

+   3, 7, 11, 15

+};

+

+void GLAPIENTRY

+_mesa_GetBooleanv(GLenum pname, GLboolean *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetBooleanv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = INT_TO_BOOLEAN(d->offset);

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = ((GLboolean*) p)[0];

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_BOOLEAN(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetFloatv(GLenum pname, GLfloat *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetFloatv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = (GLfloat) d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = ((GLfloat *) p)[3];

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = ((GLfloat *) p)[2];

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = ((GLfloat *) p)[1];

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = ((GLfloat *) p)[0];

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = ((GLdouble *) p)[0];

+      break;

+

+   case TYPE_INT_4:

+      params[3] = (GLfloat) (((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = (GLfloat) (((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = (GLfloat) (((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = (GLfloat) (((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[i];

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[transpose[i]];

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);

+      break;

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetIntegerv(GLenum pname, GLint *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetIntegerv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+      params[3] = IROUND(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+      params[2] = IROUND(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+      params[1] = IROUND(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+      params[0] = IROUND(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = v.value_int_n.ints[i];

+      break;

+

+   case TYPE_INT64:

+      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+#if FEATURE_ARB_sync

+void GLAPIENTRY

+_mesa_GetInteger64v(GLenum pname, GLint64 *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetInteger64v", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+      params[3] = IROUND64(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+      params[2] = IROUND64(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+      params[1] = IROUND64(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+      params[0] = IROUND64(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = ((GLboolean*) p)[0];

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT64(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+#endif /* FEATURE_ARB_sync */

+

+void GLAPIENTRY

+_mesa_GetDoublev(GLenum pname, GLdouble *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetDoublev", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = ((GLfloat *) p)[3];

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = ((GLfloat *) p)[2];

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = ((GLfloat *) p)[1];

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = ((GLfloat *) p)[0];

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = ((GLdouble *) p)[0];

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = v.value_int_n.ints[i];

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = *(GLboolean*) p;

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[i];

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[transpose[i]];

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+static enum value_type

+find_value_indexed(const char *func, GLenum pname, int index, union value *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   switch (pname) {

+

+   case GL_BLEND:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_draw_buffers2)

+	 goto invalid_enum;

+      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;

+      return TYPE_INT;

+

+   case GL_BLEND_SRC:

+      /* fall-through */

+   case GL_BLEND_SRC_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].SrcRGB;

+      return TYPE_INT;

+   case GL_BLEND_SRC_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].SrcA;

+      return TYPE_INT;

+   case GL_BLEND_DST:

+      /* fall-through */

+   case GL_BLEND_DST_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].DstRGB;

+      return TYPE_INT;

+   case GL_BLEND_DST_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].DstA;

+      return TYPE_INT;

+   case GL_BLEND_EQUATION_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].EquationRGB;

+      return TYPE_INT;

+   case GL_BLEND_EQUATION_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].EquationA;

+      return TYPE_INT;

+

+   case GL_COLOR_WRITEMASK:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_draw_buffers2)

+	 goto invalid_enum;

+      v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;

+      v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;

+      v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;

+      v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;

+      return TYPE_INT_4;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_START:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];

+      return TYPE_INT64;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int64 = ctx->TransformFeedback.CurrentObject->Size[index];

+      return TYPE_INT64;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int = ctx->TransformFeedback.CurrentObject->Buffers[index]->Name;

+      return TYPE_INT;

+   }

+

+ invalid_enum:

+   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+               _mesa_lookup_enum_by_nr(pname));

+   return TYPE_INVALID;

+ invalid_value:

+   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,

+               _mesa_lookup_enum_by_nr(pname));

+   return TYPE_INVALID;

+}

+

+void GLAPIENTRY

+_mesa_GetBooleanIndexedv( GLenum pname, GLuint index, GLboolean *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetBooleanIndexedv", pname, index, &v);

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = INT_TO_BOOLEAN(v.value_int);

+      break;

+   case TYPE_INT_4:

+      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);

+      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);

+      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);

+      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);

+      break;

+   case TYPE_INT64:

+      params[0] = INT64_TO_BOOLEAN(v.value_int);

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetIntegerIndexedv( GLenum pname, GLuint index, GLint *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = v.value_int;

+      break;

+   case TYPE_INT_4:

+      params[0] = v.value_int_4[0];

+      params[1] = v.value_int_4[1];

+      params[2] = v.value_int_4[2];

+      params[3] = v.value_int_4[3];

+      break;

+   case TYPE_INT64:

+      params[0] = INT64_TO_INT(v.value_int);

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+

+#if FEATURE_ARB_sync

+void GLAPIENTRY

+_mesa_GetInteger64Indexedv( GLenum pname, GLuint index, GLint64 *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);      

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = v.value_int;

+      break;

+   case TYPE_INT_4:

+      params[0] = v.value_int_4[0];

+      params[1] = v.value_int_4[1];

+      params[2] = v.value_int_4[2];

+      params[3] = v.value_int_4[3];

+      break;

+   case TYPE_INT64:

+      params[0] = v.value_int;

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+#endif /* FEATURE_ARB_sync */

+

+#if FEATURE_ES1

+void GLAPIENTRY

+_mesa_GetFixedv(GLenum pname, GLfixed *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetDoublev", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = INT_TO_FIXED(d->offset);

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = INT_TO_FIXED(((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = INT_TO_FIXED(((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = INT_TO_FIXED(((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = INT_TO_FIXED(((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_FIXED(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);

+      break;

+   }

+}

+#endif

diff --git a/mesalib/src/mesa/main/glheader.h b/mesalib/src/mesa/main/glheader.h
index 0df811986..dc78ccbf6 100644
--- a/mesalib/src/mesa/main/glheader.h
+++ b/mesalib/src/mesa/main/glheader.h
@@ -1,167 +1,167 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file glheader.h
- * Wrapper for GL/gl.h and GL/glext.h
- */
-
-
-#ifndef GLHEADER_H
-#define GLHEADER_H
-
-
-#ifdef WGLAPI
-#undef WGLAPI
-#endif
-
-
-#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP)
-#  if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */
-#    define WGLAPI __declspec(dllexport)
-#  elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
-#    define WGLAPI __declspec(dllimport)
-#  else /* for use with static link lib build of Win32 edition only */
-#    define WGLAPI __declspec(dllimport)
-#  endif /* _STATIC_MESA support */
-#endif /* WIN32 / CYGWIN bracket */
-
-
-#define GL_GLEXT_PROTOTYPES
-#include "GL/gl.h"
-#include "GL/glext.h"
-
-
-/**
- * GL_FIXED is defined in glext.h version 64 but these typedefs aren't (yet).
- */
-typedef int GLfixed;
-typedef int GLclampx;
-
-
-#ifndef GL_OES_EGL_image
-typedef void *GLeglImageOES;
-#endif
-
-
-#ifndef GL_OES_point_size_array
-#define GL_POINT_SIZE_ARRAY_OES                                 0x8B9C
-#define GL_POINT_SIZE_ARRAY_TYPE_OES                            0x898A
-#define GL_POINT_SIZE_ARRAY_STRIDE_OES                          0x898B
-#define GL_POINT_SIZE_ARRAY_POINTER_OES                         0x898C
-#define GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES                  0x8B9F
-#endif
-
-
-#ifndef GL_OES_draw_texture
-#define GL_TEXTURE_CROP_RECT_OES  0x8B9D
-#endif
-
-
-#ifndef GL_PROGRAM_BINARY_LENGTH_OES
-#define GL_PROGRAM_BINARY_LENGTH_OES 0x8741
-#endif
-
-/* GLES 2.0 tokens */
-#ifndef GL_RGB565
-#define GL_RGB565 0x8D62
-#endif
-
-#ifndef GL_TEXTURE_GEN_STR_OES
-#define GL_TEXTURE_GEN_STR_OES                                  0x8D60
-#endif
-
-#ifndef GL_OES_compressed_paletted_texture
-#define GL_PALETTE4_RGB8_OES                                    0x8B90
-#define GL_PALETTE4_RGBA8_OES                                   0x8B91
-#define GL_PALETTE4_R5_G6_B5_OES                                0x8B92
-#define GL_PALETTE4_RGBA4_OES                                   0x8B93
-#define GL_PALETTE4_RGB5_A1_OES                                 0x8B94
-#define GL_PALETTE8_RGB8_OES                                    0x8B95
-#define GL_PALETTE8_RGBA8_OES                                   0x8B96
-#define GL_PALETTE8_R5_G6_B5_OES                                0x8B97
-#define GL_PALETTE8_RGBA4_OES                                   0x8B98
-#define GL_PALETTE8_RGB5_A1_OES                                 0x8B99
-#endif
-
-#ifndef GL_OES_matrix_get
-#define GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES               0x898D
-#define GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES              0x898E
-#define GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES                 0x898F
-#endif
-
-#ifndef GL_ES_VERSION_2_0
-#define GL_SHADER_BINARY_FORMATS            0x8DF8
-#define GL_NUM_SHADER_BINARY_FORMATS        0x8DF9
-#define GL_SHADER_COMPILER                  0x8DFA
-#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
-#define GL_MAX_VARYING_VECTORS              0x8DFC
-#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
-#endif
-
-#ifndef GL_ATI_texture_compression_3dc
-#define GL_ATI_texture_compression_3dc 1
-#define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837
-#endif
-
-
-/**
- * Internal token to represent a GLSL shader program (a collection of
- * one or more shaders that get linked together).  Note that GLSL
- * shaders and shader programs share one name space (one hash table)
- * so we need a value that's different from any of the
- * GL_VERTEX/FRAGMENT/GEOMETRY_PROGRAM tokens.
- */
-#define GL_SHADER_PROGRAM_MESA 0x9999
-
-
-/**
- * Internal token for geometry programs.
- * Use the value for GL_GEOMETRY_PROGRAM_NV for now.
- */
-#define MESA_GEOMETRY_PROGRAM 0x8c26
-
-/* Several fields of struct gl_config can take these as values.  Since
- * GLX header files may not be available everywhere they need to be used,
- * redefine them here.
- */
-#define GLX_NONE                           0x8000
-#define GLX_SLOW_CONFIG                    0x8001
-#define GLX_TRUE_COLOR                     0x8002
-#define GLX_DIRECT_COLOR                   0x8003
-#define GLX_PSEUDO_COLOR                   0x8004
-#define GLX_STATIC_COLOR                   0x8005
-#define GLX_GRAY_SCALE                     0x8006
-#define GLX_STATIC_GRAY                    0x8007
-#define GLX_TRANSPARENT_RGB                0x8008
-#define GLX_TRANSPARENT_INDEX              0x8009
-#define GLX_NON_CONFORMANT_CONFIG          0x800D
-#define GLX_SWAP_EXCHANGE_OML              0x8061
-#define GLX_SWAP_COPY_OML                  0x8062
-#define GLX_SWAP_UNDEFINED_OML             0x8063
-
-#define GLX_DONT_CARE                      0xFFFFFFFF
-
-#endif /* GLHEADER_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file glheader.h

+ * Wrapper for GL/gl.h and GL/glext.h

+ */

+

+

+#ifndef GLHEADER_H

+#define GLHEADER_H

+

+

+#ifdef WGLAPI

+#undef WGLAPI

+#endif

+

+

+#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP)

+#  if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */

+#    define WGLAPI __declspec(dllexport)

+#  elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */

+#    define WGLAPI __declspec(dllimport)

+#  else /* for use with static link lib build of Win32 edition only */

+#    define WGLAPI __declspec(dllimport)

+#  endif /* _STATIC_MESA support */

+#endif /* WIN32 / CYGWIN bracket */

+

+

+#define GL_GLEXT_PROTOTYPES

+#include "GL/gl.h"

+#include "GL/glext.h"

+

+

+/**

+ * GL_FIXED is defined in glext.h version 64 but these typedefs aren't (yet).

+ */

+typedef int GLfixed;

+typedef int GLclampx;

+

+

+#ifndef GL_OES_EGL_image

+typedef void *GLeglImageOES;

+#endif

+

+

+#ifndef GL_OES_point_size_array

+#define GL_POINT_SIZE_ARRAY_OES                                 0x8B9C

+#define GL_POINT_SIZE_ARRAY_TYPE_OES                            0x898A

+#define GL_POINT_SIZE_ARRAY_STRIDE_OES                          0x898B

+#define GL_POINT_SIZE_ARRAY_POINTER_OES                         0x898C

+#define GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES                  0x8B9F

+#endif

+

+

+#ifndef GL_OES_draw_texture

+#define GL_TEXTURE_CROP_RECT_OES  0x8B9D

+#endif

+

+

+#ifndef GL_PROGRAM_BINARY_LENGTH_OES

+#define GL_PROGRAM_BINARY_LENGTH_OES 0x8741

+#endif

+

+/* GLES 2.0 tokens */

+#ifndef GL_RGB565

+#define GL_RGB565 0x8D62

+#endif

+

+#ifndef GL_TEXTURE_GEN_STR_OES

+#define GL_TEXTURE_GEN_STR_OES                                  0x8D60

+#endif

+

+#ifndef GL_OES_compressed_paletted_texture

+#define GL_PALETTE4_RGB8_OES                                    0x8B90

+#define GL_PALETTE4_RGBA8_OES                                   0x8B91

+#define GL_PALETTE4_R5_G6_B5_OES                                0x8B92

+#define GL_PALETTE4_RGBA4_OES                                   0x8B93

+#define GL_PALETTE4_RGB5_A1_OES                                 0x8B94

+#define GL_PALETTE8_RGB8_OES                                    0x8B95

+#define GL_PALETTE8_RGBA8_OES                                   0x8B96

+#define GL_PALETTE8_R5_G6_B5_OES                                0x8B97

+#define GL_PALETTE8_RGBA4_OES                                   0x8B98

+#define GL_PALETTE8_RGB5_A1_OES                                 0x8B99

+#endif

+

+#ifndef GL_OES_matrix_get

+#define GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES               0x898D

+#define GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES              0x898E

+#define GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES                 0x898F

+#endif

+

+#ifndef GL_ES_VERSION_2_0

+#define GL_SHADER_BINARY_FORMATS            0x8DF8

+#define GL_NUM_SHADER_BINARY_FORMATS        0x8DF9

+#define GL_SHADER_COMPILER                  0x8DFA

+#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB

+#define GL_MAX_VARYING_VECTORS              0x8DFC

+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD

+#endif

+

+#ifndef GL_ATI_texture_compression_3dc

+#define GL_ATI_texture_compression_3dc 1

+#define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837

+#endif

+

+

+/**

+ * Internal token to represent a GLSL shader program (a collection of

+ * one or more shaders that get linked together).  Note that GLSL

+ * shaders and shader programs share one name space (one hash table)

+ * so we need a value that's different from any of the

+ * GL_VERTEX/FRAGMENT/GEOMETRY_PROGRAM tokens.

+ */

+#define GL_SHADER_PROGRAM_MESA 0x9999

+

+

+/**

+ * Internal token for geometry programs.

+ * Use the value for GL_GEOMETRY_PROGRAM_NV for now.

+ */

+#define MESA_GEOMETRY_PROGRAM 0x8c26

+

+/* Several fields of struct gl_config can take these as values.  Since

+ * GLX header files may not be available everywhere they need to be used,

+ * redefine them here.

+ */

+#define GLX_NONE                           0x8000

+#define GLX_SLOW_CONFIG                    0x8001

+#define GLX_TRUE_COLOR                     0x8002

+#define GLX_DIRECT_COLOR                   0x8003

+#define GLX_PSEUDO_COLOR                   0x8004

+#define GLX_STATIC_COLOR                   0x8005

+#define GLX_GRAY_SCALE                     0x8006

+#define GLX_STATIC_GRAY                    0x8007

+#define GLX_TRANSPARENT_RGB                0x8008

+#define GLX_TRANSPARENT_INDEX              0x8009

+#define GLX_NON_CONFORMANT_CONFIG          0x800D

+#define GLX_SWAP_EXCHANGE_OML              0x8061

+#define GLX_SWAP_COPY_OML                  0x8062

+#define GLX_SWAP_UNDEFINED_OML             0x8063

+

+#define GLX_DONT_CARE                      0xFFFFFFFF

+

+#endif /* GLHEADER_H */

diff --git a/mesalib/src/mesa/main/hint.c b/mesalib/src/mesa/main/hint.c
index ff8d88fff..aea0d7022 100644
--- a/mesalib/src/mesa/main/hint.c
+++ b/mesalib/src/mesa/main/hint.c
@@ -1,147 +1,147 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  4.1
- *
- * Copyright (C) 1999-2002  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "enums.h"
-#include "context.h"
-#include "hint.h"
-#include "imports.h"
-#include "mtypes.h"
-
-
-
-void GLAPIENTRY
-_mesa_Hint( GLenum target, GLenum mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glHint %s %s\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  _mesa_lookup_enum_by_nr(mode));
-
-   if (mode != GL_NICEST && mode != GL_FASTEST && mode != GL_DONT_CARE) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glHint(mode)");
-      return;
-   }
-
-   switch (target) {
-      case GL_FOG_HINT:
-         if (ctx->Hint.Fog == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.Fog = mode;
-         break;
-      case GL_LINE_SMOOTH_HINT:
-         if (ctx->Hint.LineSmooth == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.LineSmooth = mode;
-         break;
-      case GL_PERSPECTIVE_CORRECTION_HINT:
-         if (ctx->Hint.PerspectiveCorrection == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.PerspectiveCorrection = mode;
-         break;
-      case GL_POINT_SMOOTH_HINT:
-         if (ctx->Hint.PointSmooth == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.PointSmooth = mode;
-         break;
-      case GL_POLYGON_SMOOTH_HINT:
-         if (ctx->Hint.PolygonSmooth == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.PolygonSmooth = mode;
-         break;
-
-      /* GL_EXT_clip_volume_hint */
-      case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
-         if (ctx->Hint.ClipVolumeClipping == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.ClipVolumeClipping = mode;
-         break;
-
-      /* GL_ARB_texture_compression */
-      case GL_TEXTURE_COMPRESSION_HINT_ARB:
-	 if (ctx->Hint.TextureCompression == mode)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-	 ctx->Hint.TextureCompression = mode;
-         break;
-
-      /* GL_SGIS_generate_mipmap */
-      case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Hint.GenerateMipmap == mode)
-            return;
-	 FLUSH_VERTICES(ctx, _NEW_HINT);
-	 ctx->Hint.GenerateMipmap = mode;
-         break;
-
-      /* GL_ARB_fragment_shader */
-      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-         if (!ctx->Extensions.ARB_fragment_shader) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
-            return;
-         }
-         if (ctx->Hint.FragmentShaderDerivative == mode)
-            return;
-         FLUSH_VERTICES(ctx, _NEW_HINT);
-         ctx->Hint.FragmentShaderDerivative = mode;
-         break;
-
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
-         return;
-   }
-
-   if (ctx->Driver.Hint) {
-      (*ctx->Driver.Hint)( ctx, target, mode );
-   }
-}
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-void _mesa_init_hint( struct gl_context * ctx )
-{
-   /* Hint group */
-   ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
-   ctx->Hint.PointSmooth = GL_DONT_CARE;
-   ctx->Hint.LineSmooth = GL_DONT_CARE;
-   ctx->Hint.PolygonSmooth = GL_DONT_CARE;
-   ctx->Hint.Fog = GL_DONT_CARE;
-   ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
-   ctx->Hint.TextureCompression = GL_DONT_CARE;
-   ctx->Hint.GenerateMipmap = GL_DONT_CARE;
-   ctx->Hint.FragmentShaderDerivative = GL_DONT_CARE;
-}
+

+/*

+ * Mesa 3-D graphics library

+ * Version:  4.1

+ *

+ * Copyright (C) 1999-2002  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "enums.h"

+#include "context.h"

+#include "hint.h"

+#include "imports.h"

+#include "mtypes.h"

+

+

+

+void GLAPIENTRY

+_mesa_Hint( GLenum target, GLenum mode )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glHint %s %s\n",

+                  _mesa_lookup_enum_by_nr(target),

+                  _mesa_lookup_enum_by_nr(mode));

+

+   if (mode != GL_NICEST && mode != GL_FASTEST && mode != GL_DONT_CARE) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glHint(mode)");

+      return;

+   }

+

+   switch (target) {

+      case GL_FOG_HINT:

+         if (ctx->Hint.Fog == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.Fog = mode;

+         break;

+      case GL_LINE_SMOOTH_HINT:

+         if (ctx->Hint.LineSmooth == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.LineSmooth = mode;

+         break;

+      case GL_PERSPECTIVE_CORRECTION_HINT:

+         if (ctx->Hint.PerspectiveCorrection == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.PerspectiveCorrection = mode;

+         break;

+      case GL_POINT_SMOOTH_HINT:

+         if (ctx->Hint.PointSmooth == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.PointSmooth = mode;

+         break;

+      case GL_POLYGON_SMOOTH_HINT:

+         if (ctx->Hint.PolygonSmooth == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.PolygonSmooth = mode;

+         break;

+

+      /* GL_EXT_clip_volume_hint */

+      case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:

+         if (ctx->Hint.ClipVolumeClipping == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.ClipVolumeClipping = mode;

+         break;

+

+      /* GL_ARB_texture_compression */

+      case GL_TEXTURE_COMPRESSION_HINT_ARB:

+	 if (ctx->Hint.TextureCompression == mode)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+	 ctx->Hint.TextureCompression = mode;

+         break;

+

+      /* GL_SGIS_generate_mipmap */

+      case GL_GENERATE_MIPMAP_HINT_SGIS:

+         if (ctx->Hint.GenerateMipmap == mode)

+            return;

+	 FLUSH_VERTICES(ctx, _NEW_HINT);

+	 ctx->Hint.GenerateMipmap = mode;

+         break;

+

+      /* GL_ARB_fragment_shader */

+      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:

+         if (!ctx->Extensions.ARB_fragment_shader) {

+            _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");

+            return;

+         }

+         if (ctx->Hint.FragmentShaderDerivative == mode)

+            return;

+         FLUSH_VERTICES(ctx, _NEW_HINT);

+         ctx->Hint.FragmentShaderDerivative = mode;

+         break;

+

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");

+         return;

+   }

+

+   if (ctx->Driver.Hint) {

+      (*ctx->Driver.Hint)( ctx, target, mode );

+   }

+}

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+void _mesa_init_hint( struct gl_context * ctx )

+{

+   /* Hint group */

+   ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;

+   ctx->Hint.PointSmooth = GL_DONT_CARE;

+   ctx->Hint.LineSmooth = GL_DONT_CARE;

+   ctx->Hint.PolygonSmooth = GL_DONT_CARE;

+   ctx->Hint.Fog = GL_DONT_CARE;

+   ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;

+   ctx->Hint.TextureCompression = GL_DONT_CARE;

+   ctx->Hint.GenerateMipmap = GL_DONT_CARE;

+   ctx->Hint.FragmentShaderDerivative = GL_DONT_CARE;

+}

diff --git a/mesalib/src/mesa/main/image.c b/mesalib/src/mesa/main/image.c
index bbde3800e..466fc617a 100644
--- a/mesalib/src/mesa/main/image.c
+++ b/mesalib/src/mesa/main/image.c
@@ -1,1891 +1,1891 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file image.c
- * Image handling.
- */
-
-
-#include "glheader.h"
-#include "colormac.h"
-#include "image.h"
-#include "imports.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-
-
-/**
- * NOTE:
- * Normally, BYTE_TO_FLOAT(0) returns 0.00392  That causes problems when
- * we later convert the float to a packed integer value (such as for
- * GL_RGB5_A1) because we'll wind up with a non-zero value.
- *
- * We redefine the macros here so zero is handled correctly.
- */
-#undef BYTE_TO_FLOAT
-#define BYTE_TO_FLOAT(B)    ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
-
-#undef SHORT_TO_FLOAT
-#define SHORT_TO_FLOAT(S)   ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
-
-
-
-/** Compute ceiling of integer quotient of A divided by B. */
-#define CEILING( A, B )  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
-
-
-/**
- * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
- */
-GLboolean
-_mesa_type_is_packed(GLenum type)
-{
-   switch (type) {
-   case GL_UNSIGNED_BYTE_3_3_2:
-   case GL_UNSIGNED_BYTE_2_3_3_REV:
-   case MESA_UNSIGNED_BYTE_4_4:
-   case GL_UNSIGNED_SHORT_5_6_5:
-   case GL_UNSIGNED_SHORT_5_6_5_REV:
-   case GL_UNSIGNED_SHORT_4_4_4_4:
-   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-   case GL_UNSIGNED_SHORT_5_5_5_1:
-   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-   case GL_UNSIGNED_INT_8_8_8_8:
-   case GL_UNSIGNED_INT_8_8_8_8_REV:
-   case GL_UNSIGNED_INT_10_10_10_2:
-   case GL_UNSIGNED_INT_2_10_10_10_REV:
-   case GL_UNSIGNED_SHORT_8_8_MESA:
-   case GL_UNSIGNED_SHORT_8_8_REV_MESA:
-   case GL_UNSIGNED_INT_24_8_EXT:
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-
-/**
- * Flip the order of the 2 bytes in each word in the given array.
- *
- * \param p array.
- * \param n number of words.
- */
-void
-_mesa_swap2( GLushort *p, GLuint n )
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
-   }
-}
-
-
-
-/*
- * Flip the order of the 4 bytes in each word in the given array.
- */
-void
-_mesa_swap4( GLuint *p, GLuint n )
-{
-   GLuint i, a, b;
-   for (i = 0; i < n; i++) {
-      b = p[i];
-      a =  (b >> 24)
-	| ((b >> 8) & 0xff00)
-	| ((b << 8) & 0xff0000)
-	| ((b << 24) & 0xff000000);
-      p[i] = a;
-   }
-}
-
-
-/**
- * Get the size of a GL data type.
- *
- * \param type GL data type.
- *
- * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
- * if an invalid type enum.
- */
-GLint
-_mesa_sizeof_type( GLenum type )
-{
-   switch (type) {
-      case GL_BITMAP:
-	 return 0;
-      case GL_UNSIGNED_BYTE:
-         return sizeof(GLubyte);
-      case GL_BYTE:
-	 return sizeof(GLbyte);
-      case GL_UNSIGNED_SHORT:
-	 return sizeof(GLushort);
-      case GL_SHORT:
-	 return sizeof(GLshort);
-      case GL_UNSIGNED_INT:
-	 return sizeof(GLuint);
-      case GL_INT:
-	 return sizeof(GLint);
-      case GL_FLOAT:
-	 return sizeof(GLfloat);
-      case GL_DOUBLE:
-	 return sizeof(GLdouble);
-      case GL_HALF_FLOAT_ARB:
-	 return sizeof(GLhalfARB);
-      case GL_FIXED:
-	 return sizeof(GLfixed);
-      default:
-         return -1;
-   }
-}
-
-
-/**
- * Same as _mesa_sizeof_type() but also accepting the packed pixel
- * format data types.
- */
-GLint
-_mesa_sizeof_packed_type( GLenum type )
-{
-   switch (type) {
-      case GL_BITMAP:
-	 return 0;
-      case GL_UNSIGNED_BYTE:
-         return sizeof(GLubyte);
-      case GL_BYTE:
-	 return sizeof(GLbyte);
-      case GL_UNSIGNED_SHORT:
-	 return sizeof(GLushort);
-      case GL_SHORT:
-	 return sizeof(GLshort);
-      case GL_UNSIGNED_INT:
-	 return sizeof(GLuint);
-      case GL_INT:
-	 return sizeof(GLint);
-      case GL_HALF_FLOAT_ARB:
-	 return sizeof(GLhalfARB);
-      case GL_FLOAT:
-	 return sizeof(GLfloat);
-      case GL_UNSIGNED_BYTE_3_3_2:
-         return sizeof(GLubyte);
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-         return sizeof(GLubyte);
-      case MESA_UNSIGNED_BYTE_4_4:
-         return sizeof(GLubyte);
-      case GL_UNSIGNED_SHORT_5_6_5:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-         return sizeof(GLushort);
-      case GL_UNSIGNED_INT_8_8_8_8:
-         return sizeof(GLuint);
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-         return sizeof(GLuint);
-      case GL_UNSIGNED_INT_10_10_10_2:
-         return sizeof(GLuint);
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-         return sizeof(GLuint);
-      case GL_UNSIGNED_SHORT_8_8_MESA:
-      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
-         return sizeof(GLushort);      
-      case GL_UNSIGNED_INT_24_8_EXT:
-         return sizeof(GLuint);
-      default:
-         return -1;
-   }
-}
-
-
-/**
- * Get the number of components in a pixel format.
- *
- * \param format pixel format.
- *
- * \return the number of components in the given format, or -1 if a bad format.
- */
-GLint
-_mesa_components_in_format( GLenum format )
-{
-   switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_COLOR_INDEX1_EXT:
-      case GL_COLOR_INDEX2_EXT:
-      case GL_COLOR_INDEX4_EXT:
-      case GL_COLOR_INDEX8_EXT:
-      case GL_COLOR_INDEX12_EXT:
-      case GL_COLOR_INDEX16_EXT:
-      case GL_STENCIL_INDEX:
-      case GL_DEPTH_COMPONENT:
-      case GL_RED:
-      case GL_RED_INTEGER_EXT:
-      case GL_GREEN:
-      case GL_GREEN_INTEGER_EXT:
-      case GL_BLUE:
-      case GL_BLUE_INTEGER_EXT:
-      case GL_ALPHA:
-      case GL_ALPHA_INTEGER_EXT:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_INTEGER_EXT:
-      case GL_INTENSITY:
-         return 1;
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      case GL_RG:
-	 return 2;
-      case GL_RGB:
-      case GL_RGB_INTEGER_EXT:
-	 return 3;
-      case GL_RGBA:
-      case GL_RGBA_INTEGER_EXT:
-	 return 4;
-      case GL_BGR:
-	 return 3;
-      case GL_BGRA:
-	 return 4;
-      case GL_ABGR_EXT:
-         return 4;
-      case GL_YCBCR_MESA:
-         return 2;
-      case GL_DEPTH_STENCIL_EXT:
-         return 2;
-      case GL_DUDV_ATI:
-      case GL_DU8DV8_ATI:
-         return 2;
-      default:
-         return -1;
-   }
-}
-
-
-/**
- * Get the bytes per pixel of pixel format type pair.
- *
- * \param format pixel format.
- * \param type pixel type.
- *
- * \return bytes per pixel, or -1 if a bad format or type was given.
- */
-GLint
-_mesa_bytes_per_pixel( GLenum format, GLenum type )
-{
-   GLint comps = _mesa_components_in_format( format );
-   if (comps < 0)
-      return -1;
-
-   switch (type) {
-      case GL_BITMAP:
-         return 0;  /* special case */
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-         return comps * sizeof(GLubyte);
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-         return comps * sizeof(GLshort);
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-         return comps * sizeof(GLint);
-      case GL_FLOAT:
-         return comps * sizeof(GLfloat);
-      case GL_HALF_FLOAT_ARB:
-         return comps * sizeof(GLhalfARB);
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-         if (format == GL_RGB || format == GL_BGR ||
-             format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
-            return sizeof(GLubyte);
-         else
-            return -1;  /* error */
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-         if (format == GL_RGB || format == GL_BGR ||
-             format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
-            return sizeof(GLushort);
-         else
-            return -1;  /* error */
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
-             format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
-            return sizeof(GLushort);
-         else
-            return -1;
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
-             format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
-            return sizeof(GLuint);
-         else
-            return -1;
-      case GL_UNSIGNED_SHORT_8_8_MESA:
-      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
-         if (format == GL_YCBCR_MESA)
-            return sizeof(GLushort);
-         else
-            return -1;
-      case GL_UNSIGNED_INT_24_8_EXT:
-         if (format == GL_DEPTH_STENCIL_EXT)
-            return sizeof(GLuint);
-         else
-            return -1;
-      default:
-         return -1;
-   }
-}
-
-
-/**
- * Test for a legal pixel format and type.
- *
- * \param format pixel format.
- * \param type pixel type.
- *
- * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE
- * otherwise.
- */
-GLboolean
-_mesa_is_legal_format_and_type(const struct gl_context *ctx,
-                               GLenum format, GLenum type)
-{
-   switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_STENCIL_INDEX:
-         switch (type) {
-            case GL_BITMAP:
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-#if 0 /* not legal!  see table 3.6 of the 1.5 spec */
-      case GL_INTENSITY:
-#endif
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_ALPHA:
-      case GL_DEPTH_COMPONENT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_RG:
-	 if (!ctx->Extensions.ARB_texture_rg)
-	    return GL_FALSE;
-
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_RGB:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-            case GL_UNSIGNED_BYTE_3_3_2:
-            case GL_UNSIGNED_BYTE_2_3_3_REV:
-            case GL_UNSIGNED_SHORT_5_6_5:
-            case GL_UNSIGNED_SHORT_5_6_5_REV:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_BGR:
-         switch (type) {
-            /* NOTE: no packed types are supported with BGR.  That's
-             * intentional, according to the GL spec.
-             */
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_RGBA:
-      case GL_BGRA:
-      case GL_ABGR_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-            case GL_UNSIGNED_SHORT_4_4_4_4:
-            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-            case GL_UNSIGNED_SHORT_5_5_5_1:
-            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-            case GL_UNSIGNED_INT_8_8_8_8:
-            case GL_UNSIGNED_INT_8_8_8_8_REV:
-            case GL_UNSIGNED_INT_10_10_10_2:
-            case GL_UNSIGNED_INT_2_10_10_10_REV:
-               return GL_TRUE;
-            case GL_HALF_FLOAT_ARB:
-               return ctx->Extensions.ARB_half_float_pixel;
-            default:
-               return GL_FALSE;
-         }
-      case GL_YCBCR_MESA:
-         if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
-             type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
-            return GL_TRUE;
-         else
-            return GL_FALSE;
-      case GL_DEPTH_STENCIL_EXT:
-         if (ctx->Extensions.EXT_packed_depth_stencil
-             && type == GL_UNSIGNED_INT_24_8_EXT)
-            return GL_TRUE;
-         else
-            return GL_FALSE;
-      case GL_DUDV_ATI:
-      case GL_DU8DV8_ATI:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_FLOAT:
-               return GL_TRUE;
-            default:
-               return GL_FALSE;
-         }
-
-      /* integer-valued formats */
-      case GL_RED_INTEGER_EXT:
-      case GL_GREEN_INTEGER_EXT:
-      case GL_BLUE_INTEGER_EXT:
-      case GL_ALPHA_INTEGER_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-               return ctx->Extensions.EXT_texture_integer;
-            default:
-               return GL_FALSE;
-         }
-
-      case GL_RGB_INTEGER_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_UNSIGNED_BYTE_3_3_2:
-            case GL_UNSIGNED_BYTE_2_3_3_REV:
-            case GL_UNSIGNED_SHORT_5_6_5:
-            case GL_UNSIGNED_SHORT_5_6_5_REV:
-               return ctx->Extensions.EXT_texture_integer;
-            default:
-               return GL_FALSE;
-         }
-
-      case GL_BGR_INTEGER_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            /* NOTE: no packed formats w/ BGR format */
-               return ctx->Extensions.EXT_texture_integer;
-            default:
-               return GL_FALSE;
-         }
-
-      case GL_RGBA_INTEGER_EXT:
-      case GL_BGRA_INTEGER_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-            case GL_UNSIGNED_SHORT_4_4_4_4:
-            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-            case GL_UNSIGNED_SHORT_5_5_5_1:
-            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-            case GL_UNSIGNED_INT_8_8_8_8:
-            case GL_UNSIGNED_INT_8_8_8_8_REV:
-            case GL_UNSIGNED_INT_10_10_10_2:
-            case GL_UNSIGNED_INT_2_10_10_10_REV:
-               return ctx->Extensions.EXT_texture_integer;
-            default:
-               return GL_FALSE;
-         }
-
-      case GL_LUMINANCE_INTEGER_EXT:
-      case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-         switch (type) {
-            case GL_BYTE:
-            case GL_UNSIGNED_BYTE:
-            case GL_SHORT:
-            case GL_UNSIGNED_SHORT:
-            case GL_INT:
-            case GL_UNSIGNED_INT:
-               return ctx->Extensions.EXT_texture_integer;
-            default:
-               return GL_FALSE;
-         }
-
-      default:
-         ; /* fall-through */
-   }
-   return GL_FALSE;
-}
-
-
-/**
- * Test if the given image format is a color/RGBA format (i.e., not color
- * index, depth, stencil, etc).
- * \param format  the image format value (may by an internal texture format)
- * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
- */
-GLboolean
-_mesa_is_color_format(GLenum format)
-{
-   switch (format) {
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-      case 1:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-      case 2:
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-      case GL_R8:
-      case GL_R16:
-      case GL_RG:
-      case GL_RG8:
-      case GL_RG16:
-      case 3:
-      case GL_RGB:
-      case GL_BGR:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-      case 4:
-      case GL_ABGR_EXT:
-      case GL_RGBA:
-      case GL_BGRA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-      /* float texture formats */
-      case GL_ALPHA16F_ARB:
-      case GL_ALPHA32F_ARB:
-      case GL_LUMINANCE16F_ARB:
-      case GL_LUMINANCE32F_ARB:
-      case GL_LUMINANCE_ALPHA16F_ARB:
-      case GL_LUMINANCE_ALPHA32F_ARB:
-      case GL_INTENSITY16F_ARB:
-      case GL_INTENSITY32F_ARB:
-      case GL_R16F:
-      case GL_R32F:
-      case GL_RG16F:
-      case GL_RG32F:
-      case GL_RGB16F_ARB:
-      case GL_RGB32F_ARB:
-      case GL_RGBA16F_ARB:
-      case GL_RGBA32F_ARB:
-      /* compressed formats */
-      case GL_COMPRESSED_ALPHA:
-      case GL_COMPRESSED_LUMINANCE:
-      case GL_COMPRESSED_LUMINANCE_ALPHA:
-      case GL_COMPRESSED_INTENSITY:
-      case GL_COMPRESSED_RED:
-      case GL_COMPRESSED_RG:
-      case GL_COMPRESSED_RGB:
-      case GL_COMPRESSED_RGBA:
-      case GL_RGB_S3TC:
-      case GL_RGB4_S3TC:
-      case GL_RGBA_S3TC:
-      case GL_RGBA4_S3TC:
-      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-      case GL_COMPRESSED_RGB_FXT1_3DFX:
-      case GL_COMPRESSED_RGBA_FXT1_3DFX:
-#if FEATURE_EXT_texture_sRGB
-      case GL_SRGB_EXT:
-      case GL_SRGB8_EXT:
-      case GL_SRGB_ALPHA_EXT:
-      case GL_SRGB8_ALPHA8_EXT:
-      case GL_SLUMINANCE_ALPHA_EXT:
-      case GL_SLUMINANCE8_ALPHA8_EXT:
-      case GL_SLUMINANCE_EXT:
-      case GL_SLUMINANCE8_EXT:
-      case GL_COMPRESSED_SRGB_EXT:
-      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      case GL_COMPRESSED_SLUMINANCE_EXT:
-      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-#endif /* FEATURE_EXT_texture_sRGB */
-      case GL_COMPRESSED_RED_RGTC1:
-      case GL_COMPRESSED_SIGNED_RED_RGTC1:
-      case GL_COMPRESSED_RG_RGTC2:
-      case GL_COMPRESSED_SIGNED_RG_RGTC2:
-      case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-      case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-      case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-      case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-      case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      /* signed, normalized texture formats */
-      case GL_RGBA_SNORM:
-      case GL_RGBA8_SNORM:
-      /* generic integer formats */
-      case GL_RED_INTEGER_EXT:
-      case GL_GREEN_INTEGER_EXT:
-      case GL_BLUE_INTEGER_EXT:
-      case GL_ALPHA_INTEGER_EXT:
-      case GL_RGB_INTEGER_EXT:
-      case GL_RGBA_INTEGER_EXT:
-      case GL_BGR_INTEGER_EXT:
-      case GL_BGRA_INTEGER_EXT:
-      case GL_LUMINANCE_INTEGER_EXT:
-      case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      /* sized integer formats */
-      case GL_RGBA32UI_EXT:
-      case GL_RGB32UI_EXT:
-      case GL_ALPHA32UI_EXT:
-      case GL_INTENSITY32UI_EXT:
-      case GL_LUMINANCE32UI_EXT:
-      case GL_LUMINANCE_ALPHA32UI_EXT:
-      case GL_RGBA16UI_EXT:
-      case GL_RGB16UI_EXT:
-      case GL_ALPHA16UI_EXT:
-      case GL_INTENSITY16UI_EXT:
-      case GL_LUMINANCE16UI_EXT:
-      case GL_LUMINANCE_ALPHA16UI_EXT:
-      case GL_RGBA8UI_EXT:
-      case GL_RGB8UI_EXT:
-      case GL_ALPHA8UI_EXT:
-      case GL_INTENSITY8UI_EXT:
-      case GL_LUMINANCE8UI_EXT:
-      case GL_LUMINANCE_ALPHA8UI_EXT:
-      case GL_RGBA32I_EXT:
-      case GL_RGB32I_EXT:
-      case GL_ALPHA32I_EXT:
-      case GL_INTENSITY32I_EXT:
-      case GL_LUMINANCE32I_EXT:
-      case GL_LUMINANCE_ALPHA32I_EXT:
-      case GL_RGBA16I_EXT:
-      case GL_RGB16I_EXT:
-      case GL_ALPHA16I_EXT:
-      case GL_INTENSITY16I_EXT:
-      case GL_LUMINANCE16I_EXT:
-      case GL_LUMINANCE_ALPHA16I_EXT:
-      case GL_RGBA8I_EXT:
-      case GL_RGB8I_EXT:
-      case GL_ALPHA8I_EXT:
-      case GL_INTENSITY8I_EXT:
-      case GL_LUMINANCE8I_EXT:
-      case GL_LUMINANCE_ALPHA8I_EXT:
-         return GL_TRUE;
-      case GL_YCBCR_MESA:  /* not considered to be RGB */
-         /* fall-through */
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a color index format.
- */
-GLboolean
-_mesa_is_index_format(GLenum format)
-{
-   switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_COLOR_INDEX1_EXT:
-      case GL_COLOR_INDEX2_EXT:
-      case GL_COLOR_INDEX4_EXT:
-      case GL_COLOR_INDEX8_EXT:
-      case GL_COLOR_INDEX12_EXT:
-      case GL_COLOR_INDEX16_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a depth component format.
- */
-GLboolean
-_mesa_is_depth_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH_COMPONENT:
-      case GL_DEPTH_COMPONENT16:
-      case GL_DEPTH_COMPONENT24:
-      case GL_DEPTH_COMPONENT32:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a stencil format.
- */
-GLboolean
-_mesa_is_stencil_format(GLenum format)
-{
-   switch (format) {
-      case GL_STENCIL_INDEX:
-      case GL_DEPTH_STENCIL:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a YCbCr format.
- */
-GLboolean
-_mesa_is_ycbcr_format(GLenum format)
-{
-   switch (format) {
-      case GL_YCBCR_MESA:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a depth+stencil format.
- */
-GLboolean
-_mesa_is_depthstencil_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH24_STENCIL8_EXT:
-      case GL_DEPTH_STENCIL_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a depth or stencil format.
- */
-GLboolean
-_mesa_is_depth_or_stencil_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH_COMPONENT:
-      case GL_DEPTH_COMPONENT16:
-      case GL_DEPTH_COMPONENT24:
-      case GL_DEPTH_COMPONENT32:
-      case GL_STENCIL_INDEX:
-      case GL_STENCIL_INDEX1_EXT:
-      case GL_STENCIL_INDEX4_EXT:
-      case GL_STENCIL_INDEX8_EXT:
-      case GL_STENCIL_INDEX16_EXT:
-      case GL_DEPTH_STENCIL_EXT:
-      case GL_DEPTH24_STENCIL8_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a dudv format.
- */
-GLboolean
-_mesa_is_dudv_format(GLenum format)
-{
-   switch (format) {
-      case GL_DUDV_ATI:
-      case GL_DU8DV8_ATI:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given format is an integer (non-normalized) format.
- */
-GLboolean
-_mesa_is_integer_format(GLenum format)
-{
-   switch (format) {
-   /* generic integer formats */
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-   /* specific integer formats */
-   case GL_RGBA32UI_EXT:
-   case GL_RGB32UI_EXT:
-   case GL_ALPHA32UI_EXT:
-   case GL_INTENSITY32UI_EXT:
-   case GL_LUMINANCE32UI_EXT:
-   case GL_LUMINANCE_ALPHA32UI_EXT:
-   case GL_RGBA16UI_EXT:
-   case GL_RGB16UI_EXT:
-   case GL_ALPHA16UI_EXT:
-   case GL_INTENSITY16UI_EXT:
-   case GL_LUMINANCE16UI_EXT:
-   case GL_LUMINANCE_ALPHA16UI_EXT:
-   case GL_RGBA8UI_EXT:
-   case GL_RGB8UI_EXT:
-   case GL_ALPHA8UI_EXT:
-   case GL_INTENSITY8UI_EXT:
-   case GL_LUMINANCE8UI_EXT:
-   case GL_LUMINANCE_ALPHA8UI_EXT:
-   case GL_RGBA32I_EXT:
-   case GL_RGB32I_EXT:
-   case GL_ALPHA32I_EXT:
-   case GL_INTENSITY32I_EXT:
-   case GL_LUMINANCE32I_EXT:
-   case GL_LUMINANCE_ALPHA32I_EXT:
-   case GL_RGBA16I_EXT:
-   case GL_RGB16I_EXT:
-   case GL_ALPHA16I_EXT:
-   case GL_INTENSITY16I_EXT:
-   case GL_LUMINANCE16I_EXT:
-   case GL_LUMINANCE_ALPHA16I_EXT:
-   case GL_RGBA8I_EXT:
-   case GL_RGB8I_EXT:
-   case GL_ALPHA8I_EXT:
-   case GL_INTENSITY8I_EXT:
-   case GL_LUMINANCE8I_EXT:
-   case GL_LUMINANCE_ALPHA8I_EXT:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if an image format is a supported compressed format.
- * \param format the internal format token provided by the user.
- * \return GL_TRUE if compressed, GL_FALSE if uncompressed
- */
-GLboolean
-_mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
-{
-   switch (format) {
-   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-      return ctx->Extensions.EXT_texture_compression_s3tc;
-   case GL_RGB_S3TC:
-   case GL_RGB4_S3TC:
-   case GL_RGBA_S3TC:
-   case GL_RGBA4_S3TC:
-      return ctx->Extensions.S3_s3tc;
-   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      return ctx->Extensions.EXT_texture_sRGB
-         && ctx->Extensions.EXT_texture_compression_s3tc;
-   case GL_COMPRESSED_RGB_FXT1_3DFX:
-   case GL_COMPRESSED_RGBA_FXT1_3DFX:
-      return ctx->Extensions.TDFX_texture_compression_FXT1;
-   case GL_COMPRESSED_RED_RGTC1:
-   case GL_COMPRESSED_SIGNED_RED_RGTC1:
-   case GL_COMPRESSED_RG_RGTC2:
-   case GL_COMPRESSED_SIGNED_RG_RGTC2:
-      return ctx->Extensions.ARB_texture_compression_rgtc;
-   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-      return ctx->Extensions.EXT_texture_compression_latc;
-   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      return ctx->Extensions.ATI_texture_compression_3dc;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Return the address of a specific pixel in an image (1D, 2D or 3D).
- *
- * Pixel unpacking/packing parameters are observed according to \p packing.
- *
- * \param dimensions either 1, 2 or 3 to indicate dimensionality of image
- * \param image  starting address of image data
- * \param width  the image width
- * \param height  theimage height
- * \param format  the pixel format
- * \param type  the pixel data type
- * \param packing  the pixelstore attributes
- * \param img  which image in the volume (0 for 1D or 2D images)
- * \param row  row of pixel in the image (0 for 1D images)
- * \param column column of pixel in the image
- * 
- * \return address of pixel on success, or NULL on error.
- *
- * \sa gl_pixelstore_attrib.
- */
-GLvoid *
-_mesa_image_address( GLuint dimensions,
-                     const struct gl_pixelstore_attrib *packing,
-                     const GLvoid *image,
-                     GLsizei width, GLsizei height,
-                     GLenum format, GLenum type,
-                     GLint img, GLint row, GLint column )
-{
-   GLint alignment;        /* 1, 2 or 4 */
-   GLint pixels_per_row;
-   GLint rows_per_image;
-   GLint skiprows;
-   GLint skippixels;
-   GLint skipimages;       /* for 3-D volume images */
-   GLubyte *pixel_addr;
-
-   ASSERT(dimensions >= 1 && dimensions <= 3);
-
-   alignment = packing->Alignment;
-   if (packing->RowLength > 0) {
-      pixels_per_row = packing->RowLength;
-   }
-   else {
-      pixels_per_row = width;
-   }
-   if (packing->ImageHeight > 0) {
-      rows_per_image = packing->ImageHeight;
-   }
-   else {
-      rows_per_image = height;
-   }
-
-   skippixels = packing->SkipPixels;
-   /* Note: SKIP_ROWS _is_ used for 1D images */
-   skiprows = packing->SkipRows;
-   /* Note: SKIP_IMAGES is only used for 3D images */
-   skipimages = (dimensions == 3) ? packing->SkipImages : 0;
-
-   if (type == GL_BITMAP) {
-      /* BITMAP data */
-      GLint comp_per_pixel;   /* components per pixel */
-      GLint bytes_per_comp;   /* bytes per component */
-      GLint bytes_per_row;
-      GLint bytes_per_image;
-
-      /* Compute bytes per component */
-      bytes_per_comp = _mesa_sizeof_packed_type( type );
-      if (bytes_per_comp < 0) {
-         return NULL;
-      }
-
-      /* Compute number of components per pixel */
-      comp_per_pixel = _mesa_components_in_format( format );
-      if (comp_per_pixel < 0) {
-         return NULL;
-      }
-
-      bytes_per_row = alignment
-                    * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
-
-      bytes_per_image = bytes_per_row * rows_per_image;
-
-      pixel_addr = (GLubyte *) image
-                 + (skipimages + img) * bytes_per_image
-                 + (skiprows + row) * bytes_per_row
-                 + (skippixels + column) / 8;
-   }
-   else {
-      /* Non-BITMAP data */
-      GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
-      GLint topOfImage;
-
-      bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
-
-      /* The pixel type and format should have been error checked earlier */
-      assert(bytes_per_pixel > 0);
-
-      bytes_per_row = pixels_per_row * bytes_per_pixel;
-      remainder = bytes_per_row % alignment;
-      if (remainder > 0)
-         bytes_per_row += (alignment - remainder);
-
-      ASSERT(bytes_per_row % alignment == 0);
-
-      bytes_per_image = bytes_per_row * rows_per_image;
-
-      if (packing->Invert) {
-         /* set pixel_addr to the last row */
-         topOfImage = bytes_per_row * (height - 1);
-         bytes_per_row = -bytes_per_row;
-      }
-      else {
-         topOfImage = 0;
-      }
-
-      /* compute final pixel address */
-      pixel_addr = (GLubyte *) image
-                 + (skipimages + img) * bytes_per_image
-                 + topOfImage
-                 + (skiprows + row) * bytes_per_row
-                 + (skippixels + column) * bytes_per_pixel;
-   }
-
-   return (GLvoid *) pixel_addr;
-}
-
-
-GLvoid *
-_mesa_image_address1d( const struct gl_pixelstore_attrib *packing,
-                       const GLvoid *image,
-                       GLsizei width,
-                       GLenum format, GLenum type,
-                       GLint column )
-{
-   return _mesa_image_address(1, packing, image, width, 1,
-                              format, type, 0, 0, column);
-}
-
-
-GLvoid *
-_mesa_image_address2d( const struct gl_pixelstore_attrib *packing,
-                       const GLvoid *image,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       GLint row, GLint column )
-{
-   return _mesa_image_address(2, packing, image, width, height,
-                              format, type, 0, row, column);
-}
-
-
-GLvoid *
-_mesa_image_address3d( const struct gl_pixelstore_attrib *packing,
-                       const GLvoid *image,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       GLint img, GLint row, GLint column )
-{
-   return _mesa_image_address(3, packing, image, width, height,
-                              format, type, img, row, column);
-}
-
-
-
-/**
- * Compute the stride (in bytes) between image rows.
- *
- * \param packing the pixelstore attributes
- * \param width image width.
- * \param format pixel format.
- * \param type pixel data type.
- * 
- * \return the stride in bytes for the given parameters, or -1 if error
- */
-GLint
-_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
-                        GLint width, GLenum format, GLenum type )
-{
-   GLint bytesPerRow, remainder;
-
-   ASSERT(packing);
-
-   if (type == GL_BITMAP) {
-      if (packing->RowLength == 0) {
-         bytesPerRow = (width + 7) / 8;
-      }
-      else {
-         bytesPerRow = (packing->RowLength + 7) / 8;
-      }
-   }
-   else {
-      /* Non-BITMAP data */
-      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
-      if (bytesPerPixel <= 0)
-         return -1;  /* error */
-      if (packing->RowLength == 0) {
-         bytesPerRow = bytesPerPixel * width;
-      }
-      else {
-         bytesPerRow = bytesPerPixel * packing->RowLength;
-      }
-   }
-
-   remainder = bytesPerRow % packing->Alignment;
-   if (remainder > 0) {
-      bytesPerRow += (packing->Alignment - remainder);
-   }
-
-   if (packing->Invert) {
-      /* negate the bytes per row (negative row stride) */
-      bytesPerRow = -bytesPerRow;
-   }
-
-   return bytesPerRow;
-}
-
-
-/*
- * Compute the stride between images in a 3D texture (in bytes) for the given
- * pixel packing parameters and image width, format and type.
- */
-GLint
-_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
-                          GLint width, GLint height,
-                          GLenum format, GLenum type )
-{
-   GLint bytesPerRow, bytesPerImage, remainder;
-
-   ASSERT(packing);
-
-   if (type == GL_BITMAP) {
-      if (packing->RowLength == 0) {
-         bytesPerRow = (width + 7) / 8;
-      }
-      else {
-         bytesPerRow = (packing->RowLength + 7) / 8;
-      }
-   }
-   else {
-      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
-
-      if (bytesPerPixel <= 0)
-         return -1;  /* error */
-      if (packing->RowLength == 0) {
-         bytesPerRow = bytesPerPixel * width;
-      }
-      else {
-         bytesPerRow = bytesPerPixel * packing->RowLength;
-      }
-   }
-
-   remainder = bytesPerRow % packing->Alignment;
-   if (remainder > 0)
-      bytesPerRow += (packing->Alignment - remainder);
-
-   if (packing->ImageHeight == 0)
-      bytesPerImage = bytesPerRow * height;
-   else
-      bytesPerImage = bytesPerRow * packing->ImageHeight;
-
-   return bytesPerImage;
-}
-
-
-
-/**
- * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel.
- * This is typically used to convert a bitmap into a GLubyte/pixel texture.
- * "On" bits will set texels to \p onValue.
- * "Off" bits will not modify texels.
- * \param width  src bitmap width in pixels
- * \param height  src bitmap height in pixels
- * \param unpack  bitmap unpacking state
- * \param bitmap  the src bitmap data
- * \param destBuffer  start of dest buffer
- * \param destStride  row stride in dest buffer
- * \param onValue  if bit is 1, set destBuffer pixel to this value
- */
-void
-_mesa_expand_bitmap(GLsizei width, GLsizei height,
-                    const struct gl_pixelstore_attrib *unpack,
-                    const GLubyte *bitmap,
-                    GLubyte *destBuffer, GLint destStride,
-                    GLubyte onValue)
-{
-   const GLubyte *srcRow = (const GLubyte *)
-      _mesa_image_address2d(unpack, bitmap, width, height,
-                            GL_COLOR_INDEX, GL_BITMAP, 0, 0);
-   const GLint srcStride = _mesa_image_row_stride(unpack, width,
-                                                  GL_COLOR_INDEX, GL_BITMAP);
-   GLint row, col;
-
-#define SET_PIXEL(COL, ROW) \
-   destBuffer[(ROW) * destStride + (COL)] = onValue;
-
-   for (row = 0; row < height; row++) {
-      const GLubyte *src = srcRow;
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-
-            if (*src & mask) {
-               SET_PIXEL(col, row);
-            }
-
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-
-            if (*src & mask) {
-               SET_PIXEL(col, row);
-            }
-
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-
-      srcRow += srcStride;
-   } /* row */
-
-#undef SET_PIXEL
-}
-
-
-
-
-/**
- * Convert an array of RGBA colors from one datatype to another.
- * NOTE: src may equal dst.  In that case, we use a temporary buffer.
- */
-void
-_mesa_convert_colors(GLenum srcType, const GLvoid *src,
-                     GLenum dstType, GLvoid *dst,
-                     GLuint count, const GLubyte mask[])
-{
-   GLuint tempBuffer[MAX_WIDTH][4];
-   const GLboolean useTemp = (src == dst);
-
-   ASSERT(srcType != dstType);
-
-   switch (srcType) {
-   case GL_UNSIGNED_BYTE:
-      if (dstType == GL_UNSIGNED_SHORT) {
-         const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
-         GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);
-               dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);
-               dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);
-               dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
-      }
-      else {
-         const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;
-         GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         ASSERT(dstType == GL_FLOAT);
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);
-               dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);
-               dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);
-               dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
-      }
-      break;
-   case GL_UNSIGNED_SHORT:
-      if (dstType == GL_UNSIGNED_BYTE) {
-         const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
-         GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);
-               dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);
-               dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);
-               dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
-      }
-      else {
-         const GLushort (*src2)[4] = (const GLushort (*)[4]) src;
-         GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         ASSERT(dstType == GL_FLOAT);
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);
-               dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);
-               dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);
-               dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));
-      }
-      break;
-   case GL_FLOAT:
-      if (dstType == GL_UNSIGNED_BYTE) {
-         const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
-         GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);
-               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));
-      }
-      else {
-         const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;
-         GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);
-         GLuint i;
-         ASSERT(dstType == GL_UNSIGNED_SHORT);
-         for (i = 0; i < count; i++) {
-            if (!mask || mask[i]) {
-               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);
-               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);
-               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);
-               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);
-            }
-         }
-         if (useTemp)
-            memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));
-      }
-      break;
-   default:
-      _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");
-   }
-}
-
-
-
-
-/**
- * Perform basic clipping for glDrawPixels.  The image's position and size
- * and the unpack SkipPixels and SkipRows are adjusted so that the image
- * region is entirely within the window and scissor bounds.
- * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).
- * If Pixel.ZoomY is -1, *destY will be changed to be the first row which
- * we'll actually write.  Beforehand, *destY-1 is the first drawing row.
- *
- * \return  GL_TRUE if image is ready for drawing or
- *          GL_FALSE if image was completely clipped away (draw nothing)
- */
-GLboolean
-_mesa_clip_drawpixels(const struct gl_context *ctx,
-                      GLint *destX, GLint *destY,
-                      GLsizei *width, GLsizei *height,
-                      struct gl_pixelstore_attrib *unpack)
-{
-   const struct gl_framebuffer *buffer = ctx->DrawBuffer;
-
-   if (unpack->RowLength == 0) {
-      unpack->RowLength = *width;
-   }
-
-   ASSERT(ctx->Pixel.ZoomX == 1.0F);
-   ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);
-
-   /* left clipping */
-   if (*destX < buffer->_Xmin) {
-      unpack->SkipPixels += (buffer->_Xmin - *destX);
-      *width -= (buffer->_Xmin - *destX);
-      *destX = buffer->_Xmin;
-   }
-   /* right clipping */
-   if (*destX + *width > buffer->_Xmax)
-      *width -= (*destX + *width - buffer->_Xmax);
-
-   if (*width <= 0)
-      return GL_FALSE;
-
-   if (ctx->Pixel.ZoomY == 1.0F) {
-      /* bottom clipping */
-      if (*destY < buffer->_Ymin) {
-         unpack->SkipRows += (buffer->_Ymin - *destY);
-         *height -= (buffer->_Ymin - *destY);
-         *destY = buffer->_Ymin;
-      }
-      /* top clipping */
-      if (*destY + *height > buffer->_Ymax)
-         *height -= (*destY + *height - buffer->_Ymax);
-   }
-   else { /* upside down */
-      /* top clipping */
-      if (*destY > buffer->_Ymax) {
-         unpack->SkipRows += (*destY - buffer->_Ymax);
-         *height -= (*destY - buffer->_Ymax);
-         *destY = buffer->_Ymax;
-      }
-      /* bottom clipping */
-      if (*destY - *height < buffer->_Ymin)
-         *height -= (buffer->_Ymin - (*destY - *height));
-      /* adjust destY so it's the first row to write to */
-      (*destY)--;
-   }
-
-   if (*height <= 0)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Perform clipping for glReadPixels.  The image's window position
- * and size, and the pack skipPixels, skipRows and rowLength are adjusted
- * so that the image region is entirely within the window bounds.
- * Note: this is different from _mesa_clip_drawpixels() in that the
- * scissor box is ignored, and we use the bounds of the current readbuffer
- * surface.
- *
- * \return  GL_TRUE if region to read is in bounds
- *          GL_FALSE if region is completely out of bounds (nothing to read)
- */
-GLboolean
-_mesa_clip_readpixels(const struct gl_context *ctx,
-                      GLint *srcX, GLint *srcY,
-                      GLsizei *width, GLsizei *height,
-                      struct gl_pixelstore_attrib *pack)
-{
-   const struct gl_framebuffer *buffer = ctx->ReadBuffer;
-
-   if (pack->RowLength == 0) {
-      pack->RowLength = *width;
-   }
-
-   /* left clipping */
-   if (*srcX < 0) {
-      pack->SkipPixels += (0 - *srcX);
-      *width -= (0 - *srcX);
-      *srcX = 0;
-   }
-   /* right clipping */
-   if (*srcX + *width > (GLsizei) buffer->Width)
-      *width -= (*srcX + *width - buffer->Width);
-
-   if (*width <= 0)
-      return GL_FALSE;
-
-   /* bottom clipping */
-   if (*srcY < 0) {
-      pack->SkipRows += (0 - *srcY);
-      *height -= (0 - *srcY);
-      *srcY = 0;
-   }
-   /* top clipping */
-   if (*srcY + *height > (GLsizei) buffer->Height)
-      *height -= (*srcY + *height - buffer->Height);
-
-   if (*height <= 0)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do clipping for a glCopyTexSubImage call.
- * The framebuffer source region might extend outside the framebuffer
- * bounds.  Clip the source region against the framebuffer bounds and
- * adjust the texture/dest position and size accordingly.
- *
- * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise.
- */
-GLboolean
-_mesa_clip_copytexsubimage(const struct gl_context *ctx,
-                           GLint *destX, GLint *destY,
-                           GLint *srcX, GLint *srcY,
-                           GLsizei *width, GLsizei *height)
-{
-   const struct gl_framebuffer *fb = ctx->ReadBuffer;
-   const GLint srcX0 = *srcX, srcY0 = *srcY;
-
-   if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height,
-                            srcX, srcY, width, height)) {
-      *destX = *destX + *srcX - srcX0;
-      *destY = *destY + *srcY - srcY0;
-
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-
-/**
- * Clip the rectangle defined by (x, y, width, height) against the bounds
- * specified by [xmin, xmax) and [ymin, ymax).
- * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.
- */
-GLboolean
-_mesa_clip_to_region(GLint xmin, GLint ymin,
-                     GLint xmax, GLint ymax,
-                     GLint *x, GLint *y,
-                     GLsizei *width, GLsizei *height )
-{
-   /* left clipping */
-   if (*x < xmin) {
-      *width -= (xmin - *x);
-      *x = xmin;
-   }
-
-   /* right clipping */
-   if (*x + *width > xmax)
-      *width -= (*x + *width - xmax);
-
-   if (*width <= 0)
-      return GL_FALSE;
-
-   /* bottom (or top) clipping */
-   if (*y < ymin) {
-      *height -= (ymin - *y);
-      *y = ymin;
-   }
-
-   /* top (or bottom) clipping */
-   if (*y + *height > ymax)
-      *height -= (*y + *height - ymax);
-
-   if (*height <= 0)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Clip dst coords against Xmax (or Ymax).
- */
-static INLINE void
-clip_right_or_top(GLint *srcX0, GLint *srcX1,
-                  GLint *dstX0, GLint *dstX1,
-                  GLint maxValue)
-{
-   GLfloat t, bias;
-
-   if (*dstX1 > maxValue) {
-      /* X1 outside right edge */
-      ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */
-      t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
-      /* chop off [t, 1] part */
-      ASSERT(t >= 0.0 && t <= 1.0);
-      *dstX1 = maxValue;
-      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F;
-      *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
-   }
-   else if (*dstX0 > maxValue) {
-      /* X0 outside right edge */
-      ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */
-      t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
-      /* chop off [t, 1] part */
-      ASSERT(t >= 0.0 && t <= 1.0);
-      *dstX0 = maxValue;
-      bias = (*srcX0 < *srcX1) ? -0.5F : 0.5F;
-      *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
-   }
-}
-
-
-/**
- * Clip dst coords against Xmin (or Ymin).
- */
-static INLINE void
-clip_left_or_bottom(GLint *srcX0, GLint *srcX1,
-                    GLint *dstX0, GLint *dstX1,
-                    GLint minValue)
-{
-   GLfloat t, bias;
-
-   if (*dstX0 < minValue) {
-      /* X0 outside left edge */
-      ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */
-      t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
-      /* chop off [0, t] part */
-      ASSERT(t >= 0.0 && t <= 1.0);
-      *dstX0 = minValue;
-      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; /* flipped??? */
-      *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
-   }
-   else if (*dstX1 < minValue) {
-      /* X1 outside left edge */
-      ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */
-      t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
-      /* chop off [0, t] part */
-      ASSERT(t >= 0.0 && t <= 1.0);
-      *dstX1 = minValue;
-      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F;
-      *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
-   }
-}
-
-
-/**
- * Do clipping of blit src/dest rectangles.
- * The dest rect is clipped against both the buffer bounds and scissor bounds.
- * The src rect is just clipped against the buffer bounds.
- *
- * When either the src or dest rect is clipped, the other is also clipped
- * proportionately!
- *
- * Note that X0 need not be less than X1 (same for Y) for either the source
- * and dest rects.  That makes the clipping a little trickier.
- *
- * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped
- */
-GLboolean
-_mesa_clip_blit(struct gl_context *ctx,
-                GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,
-                GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1)
-{
-   const GLint srcXmin = 0;
-   const GLint srcXmax = ctx->ReadBuffer->Width;
-   const GLint srcYmin = 0;
-   const GLint srcYmax = ctx->ReadBuffer->Height;
-
-   /* these include scissor bounds */
-   const GLint dstXmin = ctx->DrawBuffer->_Xmin;
-   const GLint dstXmax = ctx->DrawBuffer->_Xmax;
-   const GLint dstYmin = ctx->DrawBuffer->_Ymin;
-   const GLint dstYmax = ctx->DrawBuffer->_Ymax;
-
-   /*
-   printf("PreClipX:  src: %d .. %d  dst: %d .. %d\n",
-          *srcX0, *srcX1, *dstX0, *dstX1);
-   printf("PreClipY:  src: %d .. %d  dst: %d .. %d\n",
-          *srcY0, *srcY1, *dstY0, *dstY1);
-   */
-
-   /* trivial rejection tests */
-   if (*dstX0 == *dstX1)
-      return GL_FALSE; /* no width */
-   if (*dstX0 <= dstXmin && *dstX1 <= dstXmin)
-      return GL_FALSE; /* totally out (left) of bounds */
-   if (*dstX0 >= dstXmax && *dstX1 >= dstXmax)
-      return GL_FALSE; /* totally out (right) of bounds */
-
-   if (*dstY0 == *dstY1)
-      return GL_FALSE;
-   if (*dstY0 <= dstYmin && *dstY1 <= dstYmin)
-      return GL_FALSE;
-   if (*dstY0 >= dstYmax && *dstY1 >= dstYmax)
-      return GL_FALSE;
-
-   if (*srcX0 == *srcX1)
-      return GL_FALSE;
-   if (*srcX0 <= srcXmin && *srcX1 <= srcXmin)
-      return GL_FALSE;
-   if (*srcX0 >= srcXmax && *srcX1 >= srcXmax)
-      return GL_FALSE;
-
-   if (*srcY0 == *srcY1)
-      return GL_FALSE;
-   if (*srcY0 <= srcYmin && *srcY1 <= srcYmin)
-      return GL_FALSE;
-   if (*srcY0 >= srcYmax && *srcY1 >= srcYmax)
-      return GL_FALSE;
-
-   /*
-    * dest clip
-    */
-   clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax);
-   clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax);
-   clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin);
-   clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin);
-
-   /*
-    * src clip (just swap src/dst values from above)
-    */
-   clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax);
-   clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax);
-   clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin);
-   clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin);
-
-   /*
-   printf("PostClipX: src: %d .. %d  dst: %d .. %d\n",
-          *srcX0, *srcX1, *dstX0, *dstX1);
-   printf("PostClipY: src: %d .. %d  dst: %d .. %d\n",
-          *srcY0, *srcY1, *dstY0, *dstY1);
-   */
-
-   ASSERT(*dstX0 >= dstXmin);
-   ASSERT(*dstX0 <= dstXmax);
-   ASSERT(*dstX1 >= dstXmin);
-   ASSERT(*dstX1 <= dstXmax);
-
-   ASSERT(*dstY0 >= dstYmin);
-   ASSERT(*dstY0 <= dstYmax);
-   ASSERT(*dstY1 >= dstYmin);
-   ASSERT(*dstY1 <= dstYmax);
-
-   ASSERT(*srcX0 >= srcXmin);
-   ASSERT(*srcX0 <= srcXmax);
-   ASSERT(*srcX1 >= srcXmin);
-   ASSERT(*srcX1 <= srcXmax);
-
-   ASSERT(*srcY0 >= srcYmin);
-   ASSERT(*srcY0 <= srcYmax);
-   ASSERT(*srcY1 >= srcYmin);
-   ASSERT(*srcY1 <= srcYmax);
-
-   return GL_TRUE;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file image.c

+ * Image handling.

+ */

+

+

+#include "glheader.h"

+#include "colormac.h"

+#include "image.h"

+#include "imports.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+

+

+/**

+ * NOTE:

+ * Normally, BYTE_TO_FLOAT(0) returns 0.00392  That causes problems when

+ * we later convert the float to a packed integer value (such as for

+ * GL_RGB5_A1) because we'll wind up with a non-zero value.

+ *

+ * We redefine the macros here so zero is handled correctly.

+ */

+#undef BYTE_TO_FLOAT

+#define BYTE_TO_FLOAT(B)    ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))

+

+#undef SHORT_TO_FLOAT

+#define SHORT_TO_FLOAT(S)   ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))

+

+

+

+/** Compute ceiling of integer quotient of A divided by B. */

+#define CEILING( A, B )  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )

+

+

+/**

+ * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.

+ */

+GLboolean

+_mesa_type_is_packed(GLenum type)

+{

+   switch (type) {

+   case GL_UNSIGNED_BYTE_3_3_2:

+   case GL_UNSIGNED_BYTE_2_3_3_REV:

+   case MESA_UNSIGNED_BYTE_4_4:

+   case GL_UNSIGNED_SHORT_5_6_5:

+   case GL_UNSIGNED_SHORT_5_6_5_REV:

+   case GL_UNSIGNED_SHORT_4_4_4_4:

+   case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+   case GL_UNSIGNED_SHORT_5_5_5_1:

+   case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+   case GL_UNSIGNED_INT_8_8_8_8:

+   case GL_UNSIGNED_INT_8_8_8_8_REV:

+   case GL_UNSIGNED_INT_10_10_10_2:

+   case GL_UNSIGNED_INT_2_10_10_10_REV:

+   case GL_UNSIGNED_SHORT_8_8_MESA:

+   case GL_UNSIGNED_SHORT_8_8_REV_MESA:

+   case GL_UNSIGNED_INT_24_8_EXT:

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+

+/**

+ * Flip the order of the 2 bytes in each word in the given array.

+ *

+ * \param p array.

+ * \param n number of words.

+ */

+void

+_mesa_swap2( GLushort *p, GLuint n )

+{

+   GLuint i;

+   for (i = 0; i < n; i++) {

+      p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);

+   }

+}

+

+

+

+/*

+ * Flip the order of the 4 bytes in each word in the given array.

+ */

+void

+_mesa_swap4( GLuint *p, GLuint n )

+{

+   GLuint i, a, b;

+   for (i = 0; i < n; i++) {

+      b = p[i];

+      a =  (b >> 24)

+	| ((b >> 8) & 0xff00)

+	| ((b << 8) & 0xff0000)

+	| ((b << 24) & 0xff000000);

+      p[i] = a;

+   }

+}

+

+

+/**

+ * Get the size of a GL data type.

+ *

+ * \param type GL data type.

+ *

+ * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1

+ * if an invalid type enum.

+ */

+GLint

+_mesa_sizeof_type( GLenum type )

+{

+   switch (type) {

+      case GL_BITMAP:

+	 return 0;

+      case GL_UNSIGNED_BYTE:

+         return sizeof(GLubyte);

+      case GL_BYTE:

+	 return sizeof(GLbyte);

+      case GL_UNSIGNED_SHORT:

+	 return sizeof(GLushort);

+      case GL_SHORT:

+	 return sizeof(GLshort);

+      case GL_UNSIGNED_INT:

+	 return sizeof(GLuint);

+      case GL_INT:

+	 return sizeof(GLint);

+      case GL_FLOAT:

+	 return sizeof(GLfloat);

+      case GL_DOUBLE:

+	 return sizeof(GLdouble);

+      case GL_HALF_FLOAT_ARB:

+	 return sizeof(GLhalfARB);

+      case GL_FIXED:

+	 return sizeof(GLfixed);

+      default:

+         return -1;

+   }

+}

+

+

+/**

+ * Same as _mesa_sizeof_type() but also accepting the packed pixel

+ * format data types.

+ */

+GLint

+_mesa_sizeof_packed_type( GLenum type )

+{

+   switch (type) {

+      case GL_BITMAP:

+	 return 0;

+      case GL_UNSIGNED_BYTE:

+         return sizeof(GLubyte);

+      case GL_BYTE:

+	 return sizeof(GLbyte);

+      case GL_UNSIGNED_SHORT:

+	 return sizeof(GLushort);

+      case GL_SHORT:

+	 return sizeof(GLshort);

+      case GL_UNSIGNED_INT:

+	 return sizeof(GLuint);

+      case GL_INT:

+	 return sizeof(GLint);

+      case GL_HALF_FLOAT_ARB:

+	 return sizeof(GLhalfARB);

+      case GL_FLOAT:

+	 return sizeof(GLfloat);

+      case GL_UNSIGNED_BYTE_3_3_2:

+         return sizeof(GLubyte);

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+         return sizeof(GLubyte);

+      case MESA_UNSIGNED_BYTE_4_4:

+         return sizeof(GLubyte);

+      case GL_UNSIGNED_SHORT_5_6_5:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+         return sizeof(GLushort);

+      case GL_UNSIGNED_INT_8_8_8_8:

+         return sizeof(GLuint);

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+         return sizeof(GLuint);

+      case GL_UNSIGNED_INT_10_10_10_2:

+         return sizeof(GLuint);

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+         return sizeof(GLuint);

+      case GL_UNSIGNED_SHORT_8_8_MESA:

+      case GL_UNSIGNED_SHORT_8_8_REV_MESA:

+         return sizeof(GLushort);      

+      case GL_UNSIGNED_INT_24_8_EXT:

+         return sizeof(GLuint);

+      default:

+         return -1;

+   }

+}

+

+

+/**

+ * Get the number of components in a pixel format.

+ *

+ * \param format pixel format.

+ *

+ * \return the number of components in the given format, or -1 if a bad format.

+ */

+GLint

+_mesa_components_in_format( GLenum format )

+{

+   switch (format) {

+      case GL_COLOR_INDEX:

+      case GL_COLOR_INDEX1_EXT:

+      case GL_COLOR_INDEX2_EXT:

+      case GL_COLOR_INDEX4_EXT:

+      case GL_COLOR_INDEX8_EXT:

+      case GL_COLOR_INDEX12_EXT:

+      case GL_COLOR_INDEX16_EXT:

+      case GL_STENCIL_INDEX:

+      case GL_DEPTH_COMPONENT:

+      case GL_RED:

+      case GL_RED_INTEGER_EXT:

+      case GL_GREEN:

+      case GL_GREEN_INTEGER_EXT:

+      case GL_BLUE:

+      case GL_BLUE_INTEGER_EXT:

+      case GL_ALPHA:

+      case GL_ALPHA_INTEGER_EXT:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE_INTEGER_EXT:

+      case GL_INTENSITY:

+         return 1;

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      case GL_RG:

+	 return 2;

+      case GL_RGB:

+      case GL_RGB_INTEGER_EXT:

+	 return 3;

+      case GL_RGBA:

+      case GL_RGBA_INTEGER_EXT:

+	 return 4;

+      case GL_BGR:

+	 return 3;

+      case GL_BGRA:

+	 return 4;

+      case GL_ABGR_EXT:

+         return 4;

+      case GL_YCBCR_MESA:

+         return 2;

+      case GL_DEPTH_STENCIL_EXT:

+         return 2;

+      case GL_DUDV_ATI:

+      case GL_DU8DV8_ATI:

+         return 2;

+      default:

+         return -1;

+   }

+}

+

+

+/**

+ * Get the bytes per pixel of pixel format type pair.

+ *

+ * \param format pixel format.

+ * \param type pixel type.

+ *

+ * \return bytes per pixel, or -1 if a bad format or type was given.

+ */

+GLint

+_mesa_bytes_per_pixel( GLenum format, GLenum type )

+{

+   GLint comps = _mesa_components_in_format( format );

+   if (comps < 0)

+      return -1;

+

+   switch (type) {

+      case GL_BITMAP:

+         return 0;  /* special case */

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+         return comps * sizeof(GLubyte);

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+         return comps * sizeof(GLshort);

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+         return comps * sizeof(GLint);

+      case GL_FLOAT:

+         return comps * sizeof(GLfloat);

+      case GL_HALF_FLOAT_ARB:

+         return comps * sizeof(GLhalfARB);

+      case GL_UNSIGNED_BYTE_3_3_2:

+      case GL_UNSIGNED_BYTE_2_3_3_REV:

+         if (format == GL_RGB || format == GL_BGR ||

+             format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)

+            return sizeof(GLubyte);

+         else

+            return -1;  /* error */

+      case GL_UNSIGNED_SHORT_5_6_5:

+      case GL_UNSIGNED_SHORT_5_6_5_REV:

+         if (format == GL_RGB || format == GL_BGR ||

+             format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)

+            return sizeof(GLushort);

+         else

+            return -1;  /* error */

+      case GL_UNSIGNED_SHORT_4_4_4_4:

+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+      case GL_UNSIGNED_SHORT_5_5_5_1:

+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||

+             format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)

+            return sizeof(GLushort);

+         else

+            return -1;

+      case GL_UNSIGNED_INT_8_8_8_8:

+      case GL_UNSIGNED_INT_8_8_8_8_REV:

+      case GL_UNSIGNED_INT_10_10_10_2:

+      case GL_UNSIGNED_INT_2_10_10_10_REV:

+         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||

+             format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)

+            return sizeof(GLuint);

+         else

+            return -1;

+      case GL_UNSIGNED_SHORT_8_8_MESA:

+      case GL_UNSIGNED_SHORT_8_8_REV_MESA:

+         if (format == GL_YCBCR_MESA)

+            return sizeof(GLushort);

+         else

+            return -1;

+      case GL_UNSIGNED_INT_24_8_EXT:

+         if (format == GL_DEPTH_STENCIL_EXT)

+            return sizeof(GLuint);

+         else

+            return -1;

+      default:

+         return -1;

+   }

+}

+

+

+/**

+ * Test for a legal pixel format and type.

+ *

+ * \param format pixel format.

+ * \param type pixel type.

+ *

+ * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE

+ * otherwise.

+ */

+GLboolean

+_mesa_is_legal_format_and_type(const struct gl_context *ctx,

+                               GLenum format, GLenum type)

+{

+   switch (format) {

+      case GL_COLOR_INDEX:

+      case GL_STENCIL_INDEX:

+         switch (type) {

+            case GL_BITMAP:

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+#if 0 /* not legal!  see table 3.6 of the 1.5 spec */

+      case GL_INTENSITY:

+#endif

+      case GL_LUMINANCE:

+      case GL_LUMINANCE_ALPHA:

+      case GL_DEPTH_COMPONENT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_RG:

+	 if (!ctx->Extensions.ARB_texture_rg)

+	    return GL_FALSE;

+

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_RGB:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+            case GL_UNSIGNED_BYTE_3_3_2:

+            case GL_UNSIGNED_BYTE_2_3_3_REV:

+            case GL_UNSIGNED_SHORT_5_6_5:

+            case GL_UNSIGNED_SHORT_5_6_5_REV:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_BGR:

+         switch (type) {

+            /* NOTE: no packed types are supported with BGR.  That's

+             * intentional, according to the GL spec.

+             */

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_RGBA:

+      case GL_BGRA:

+      case GL_ABGR_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+            case GL_UNSIGNED_SHORT_4_4_4_4:

+            case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+            case GL_UNSIGNED_SHORT_5_5_5_1:

+            case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+            case GL_UNSIGNED_INT_8_8_8_8:

+            case GL_UNSIGNED_INT_8_8_8_8_REV:

+            case GL_UNSIGNED_INT_10_10_10_2:

+            case GL_UNSIGNED_INT_2_10_10_10_REV:

+               return GL_TRUE;

+            case GL_HALF_FLOAT_ARB:

+               return ctx->Extensions.ARB_half_float_pixel;

+            default:

+               return GL_FALSE;

+         }

+      case GL_YCBCR_MESA:

+         if (type == GL_UNSIGNED_SHORT_8_8_MESA ||

+             type == GL_UNSIGNED_SHORT_8_8_REV_MESA)

+            return GL_TRUE;

+         else

+            return GL_FALSE;

+      case GL_DEPTH_STENCIL_EXT:

+         if (ctx->Extensions.EXT_packed_depth_stencil

+             && type == GL_UNSIGNED_INT_24_8_EXT)

+            return GL_TRUE;

+         else

+            return GL_FALSE;

+      case GL_DUDV_ATI:

+      case GL_DU8DV8_ATI:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_FLOAT:

+               return GL_TRUE;

+            default:

+               return GL_FALSE;

+         }

+

+      /* integer-valued formats */

+      case GL_RED_INTEGER_EXT:

+      case GL_GREEN_INTEGER_EXT:

+      case GL_BLUE_INTEGER_EXT:

+      case GL_ALPHA_INTEGER_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+               return ctx->Extensions.EXT_texture_integer;

+            default:

+               return GL_FALSE;

+         }

+

+      case GL_RGB_INTEGER_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_UNSIGNED_BYTE_3_3_2:

+            case GL_UNSIGNED_BYTE_2_3_3_REV:

+            case GL_UNSIGNED_SHORT_5_6_5:

+            case GL_UNSIGNED_SHORT_5_6_5_REV:

+               return ctx->Extensions.EXT_texture_integer;

+            default:

+               return GL_FALSE;

+         }

+

+      case GL_BGR_INTEGER_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            /* NOTE: no packed formats w/ BGR format */

+               return ctx->Extensions.EXT_texture_integer;

+            default:

+               return GL_FALSE;

+         }

+

+      case GL_RGBA_INTEGER_EXT:

+      case GL_BGRA_INTEGER_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+            case GL_UNSIGNED_SHORT_4_4_4_4:

+            case GL_UNSIGNED_SHORT_4_4_4_4_REV:

+            case GL_UNSIGNED_SHORT_5_5_5_1:

+            case GL_UNSIGNED_SHORT_1_5_5_5_REV:

+            case GL_UNSIGNED_INT_8_8_8_8:

+            case GL_UNSIGNED_INT_8_8_8_8_REV:

+            case GL_UNSIGNED_INT_10_10_10_2:

+            case GL_UNSIGNED_INT_2_10_10_10_REV:

+               return ctx->Extensions.EXT_texture_integer;

+            default:

+               return GL_FALSE;

+         }

+

+      case GL_LUMINANCE_INTEGER_EXT:

+      case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+         switch (type) {

+            case GL_BYTE:

+            case GL_UNSIGNED_BYTE:

+            case GL_SHORT:

+            case GL_UNSIGNED_SHORT:

+            case GL_INT:

+            case GL_UNSIGNED_INT:

+               return ctx->Extensions.EXT_texture_integer;

+            default:

+               return GL_FALSE;

+         }

+

+      default:

+         ; /* fall-through */

+   }

+   return GL_FALSE;

+}

+

+

+/**

+ * Test if the given image format is a color/RGBA format (i.e., not color

+ * index, depth, stencil, etc).

+ * \param format  the image format value (may by an internal texture format)

+ * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.

+ */

+GLboolean

+_mesa_is_color_format(GLenum format)

+{

+   switch (format) {

+      case GL_RED:

+      case GL_GREEN:

+      case GL_BLUE:

+      case GL_ALPHA:

+      case GL_ALPHA4:

+      case GL_ALPHA8:

+      case GL_ALPHA12:

+      case GL_ALPHA16:

+      case 1:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE4:

+      case GL_LUMINANCE8:

+      case GL_LUMINANCE12:

+      case GL_LUMINANCE16:

+      case 2:

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE4_ALPHA4:

+      case GL_LUMINANCE6_ALPHA2:

+      case GL_LUMINANCE8_ALPHA8:

+      case GL_LUMINANCE12_ALPHA4:

+      case GL_LUMINANCE12_ALPHA12:

+      case GL_LUMINANCE16_ALPHA16:

+      case GL_INTENSITY:

+      case GL_INTENSITY4:

+      case GL_INTENSITY8:

+      case GL_INTENSITY12:

+      case GL_INTENSITY16:

+      case GL_R8:

+      case GL_R16:

+      case GL_RG:

+      case GL_RG8:

+      case GL_RG16:

+      case 3:

+      case GL_RGB:

+      case GL_BGR:

+      case GL_R3_G3_B2:

+      case GL_RGB4:

+      case GL_RGB5:

+      case GL_RGB8:

+      case GL_RGB10:

+      case GL_RGB12:

+      case GL_RGB16:

+      case 4:

+      case GL_ABGR_EXT:

+      case GL_RGBA:

+      case GL_BGRA:

+      case GL_RGBA2:

+      case GL_RGBA4:

+      case GL_RGB5_A1:

+      case GL_RGBA8:

+      case GL_RGB10_A2:

+      case GL_RGBA12:

+      case GL_RGBA16:

+      /* float texture formats */

+      case GL_ALPHA16F_ARB:

+      case GL_ALPHA32F_ARB:

+      case GL_LUMINANCE16F_ARB:

+      case GL_LUMINANCE32F_ARB:

+      case GL_LUMINANCE_ALPHA16F_ARB:

+      case GL_LUMINANCE_ALPHA32F_ARB:

+      case GL_INTENSITY16F_ARB:

+      case GL_INTENSITY32F_ARB:

+      case GL_R16F:

+      case GL_R32F:

+      case GL_RG16F:

+      case GL_RG32F:

+      case GL_RGB16F_ARB:

+      case GL_RGB32F_ARB:

+      case GL_RGBA16F_ARB:

+      case GL_RGBA32F_ARB:

+      /* compressed formats */

+      case GL_COMPRESSED_ALPHA:

+      case GL_COMPRESSED_LUMINANCE:

+      case GL_COMPRESSED_LUMINANCE_ALPHA:

+      case GL_COMPRESSED_INTENSITY:

+      case GL_COMPRESSED_RED:

+      case GL_COMPRESSED_RG:

+      case GL_COMPRESSED_RGB:

+      case GL_COMPRESSED_RGBA:

+      case GL_RGB_S3TC:

+      case GL_RGB4_S3TC:

+      case GL_RGBA_S3TC:

+      case GL_RGBA4_S3TC:

+      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+      case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+      case GL_COMPRESSED_RGB_FXT1_3DFX:

+      case GL_COMPRESSED_RGBA_FXT1_3DFX:

+#if FEATURE_EXT_texture_sRGB

+      case GL_SRGB_EXT:

+      case GL_SRGB8_EXT:

+      case GL_SRGB_ALPHA_EXT:

+      case GL_SRGB8_ALPHA8_EXT:

+      case GL_SLUMINANCE_ALPHA_EXT:

+      case GL_SLUMINANCE8_ALPHA8_EXT:

+      case GL_SLUMINANCE_EXT:

+      case GL_SLUMINANCE8_EXT:

+      case GL_COMPRESSED_SRGB_EXT:

+      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+      case GL_COMPRESSED_SLUMINANCE_EXT:

+      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+#endif /* FEATURE_EXT_texture_sRGB */

+      case GL_COMPRESSED_RED_RGTC1:

+      case GL_COMPRESSED_SIGNED_RED_RGTC1:

+      case GL_COMPRESSED_RG_RGTC2:

+      case GL_COMPRESSED_SIGNED_RG_RGTC2:

+      case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+      case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+      case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+      case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+      case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+      /* signed, normalized texture formats */

+      case GL_RGBA_SNORM:

+      case GL_RGBA8_SNORM:

+      /* generic integer formats */

+      case GL_RED_INTEGER_EXT:

+      case GL_GREEN_INTEGER_EXT:

+      case GL_BLUE_INTEGER_EXT:

+      case GL_ALPHA_INTEGER_EXT:

+      case GL_RGB_INTEGER_EXT:

+      case GL_RGBA_INTEGER_EXT:

+      case GL_BGR_INTEGER_EXT:

+      case GL_BGRA_INTEGER_EXT:

+      case GL_LUMINANCE_INTEGER_EXT:

+      case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      /* sized integer formats */

+      case GL_RGBA32UI_EXT:

+      case GL_RGB32UI_EXT:

+      case GL_ALPHA32UI_EXT:

+      case GL_INTENSITY32UI_EXT:

+      case GL_LUMINANCE32UI_EXT:

+      case GL_LUMINANCE_ALPHA32UI_EXT:

+      case GL_RGBA16UI_EXT:

+      case GL_RGB16UI_EXT:

+      case GL_ALPHA16UI_EXT:

+      case GL_INTENSITY16UI_EXT:

+      case GL_LUMINANCE16UI_EXT:

+      case GL_LUMINANCE_ALPHA16UI_EXT:

+      case GL_RGBA8UI_EXT:

+      case GL_RGB8UI_EXT:

+      case GL_ALPHA8UI_EXT:

+      case GL_INTENSITY8UI_EXT:

+      case GL_LUMINANCE8UI_EXT:

+      case GL_LUMINANCE_ALPHA8UI_EXT:

+      case GL_RGBA32I_EXT:

+      case GL_RGB32I_EXT:

+      case GL_ALPHA32I_EXT:

+      case GL_INTENSITY32I_EXT:

+      case GL_LUMINANCE32I_EXT:

+      case GL_LUMINANCE_ALPHA32I_EXT:

+      case GL_RGBA16I_EXT:

+      case GL_RGB16I_EXT:

+      case GL_ALPHA16I_EXT:

+      case GL_INTENSITY16I_EXT:

+      case GL_LUMINANCE16I_EXT:

+      case GL_LUMINANCE_ALPHA16I_EXT:

+      case GL_RGBA8I_EXT:

+      case GL_RGB8I_EXT:

+      case GL_ALPHA8I_EXT:

+      case GL_INTENSITY8I_EXT:

+      case GL_LUMINANCE8I_EXT:

+      case GL_LUMINANCE_ALPHA8I_EXT:

+         return GL_TRUE;

+      case GL_YCBCR_MESA:  /* not considered to be RGB */

+         /* fall-through */

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a color index format.

+ */

+GLboolean

+_mesa_is_index_format(GLenum format)

+{

+   switch (format) {

+      case GL_COLOR_INDEX:

+      case GL_COLOR_INDEX1_EXT:

+      case GL_COLOR_INDEX2_EXT:

+      case GL_COLOR_INDEX4_EXT:

+      case GL_COLOR_INDEX8_EXT:

+      case GL_COLOR_INDEX12_EXT:

+      case GL_COLOR_INDEX16_EXT:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a depth component format.

+ */

+GLboolean

+_mesa_is_depth_format(GLenum format)

+{

+   switch (format) {

+      case GL_DEPTH_COMPONENT:

+      case GL_DEPTH_COMPONENT16:

+      case GL_DEPTH_COMPONENT24:

+      case GL_DEPTH_COMPONENT32:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a stencil format.

+ */

+GLboolean

+_mesa_is_stencil_format(GLenum format)

+{

+   switch (format) {

+      case GL_STENCIL_INDEX:

+      case GL_DEPTH_STENCIL:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a YCbCr format.

+ */

+GLboolean

+_mesa_is_ycbcr_format(GLenum format)

+{

+   switch (format) {

+      case GL_YCBCR_MESA:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a depth+stencil format.

+ */

+GLboolean

+_mesa_is_depthstencil_format(GLenum format)

+{

+   switch (format) {

+      case GL_DEPTH24_STENCIL8_EXT:

+      case GL_DEPTH_STENCIL_EXT:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a depth or stencil format.

+ */

+GLboolean

+_mesa_is_depth_or_stencil_format(GLenum format)

+{

+   switch (format) {

+      case GL_DEPTH_COMPONENT:

+      case GL_DEPTH_COMPONENT16:

+      case GL_DEPTH_COMPONENT24:

+      case GL_DEPTH_COMPONENT32:

+      case GL_STENCIL_INDEX:

+      case GL_STENCIL_INDEX1_EXT:

+      case GL_STENCIL_INDEX4_EXT:

+      case GL_STENCIL_INDEX8_EXT:

+      case GL_STENCIL_INDEX16_EXT:

+      case GL_DEPTH_STENCIL_EXT:

+      case GL_DEPTH24_STENCIL8_EXT:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given image format is a dudv format.

+ */

+GLboolean

+_mesa_is_dudv_format(GLenum format)

+{

+   switch (format) {

+      case GL_DUDV_ATI:

+      case GL_DU8DV8_ATI:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if the given format is an integer (non-normalized) format.

+ */

+GLboolean

+_mesa_is_integer_format(GLenum format)

+{

+   switch (format) {

+   /* generic integer formats */

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+   /* specific integer formats */

+   case GL_RGBA32UI_EXT:

+   case GL_RGB32UI_EXT:

+   case GL_ALPHA32UI_EXT:

+   case GL_INTENSITY32UI_EXT:

+   case GL_LUMINANCE32UI_EXT:

+   case GL_LUMINANCE_ALPHA32UI_EXT:

+   case GL_RGBA16UI_EXT:

+   case GL_RGB16UI_EXT:

+   case GL_ALPHA16UI_EXT:

+   case GL_INTENSITY16UI_EXT:

+   case GL_LUMINANCE16UI_EXT:

+   case GL_LUMINANCE_ALPHA16UI_EXT:

+   case GL_RGBA8UI_EXT:

+   case GL_RGB8UI_EXT:

+   case GL_ALPHA8UI_EXT:

+   case GL_INTENSITY8UI_EXT:

+   case GL_LUMINANCE8UI_EXT:

+   case GL_LUMINANCE_ALPHA8UI_EXT:

+   case GL_RGBA32I_EXT:

+   case GL_RGB32I_EXT:

+   case GL_ALPHA32I_EXT:

+   case GL_INTENSITY32I_EXT:

+   case GL_LUMINANCE32I_EXT:

+   case GL_LUMINANCE_ALPHA32I_EXT:

+   case GL_RGBA16I_EXT:

+   case GL_RGB16I_EXT:

+   case GL_ALPHA16I_EXT:

+   case GL_INTENSITY16I_EXT:

+   case GL_LUMINANCE16I_EXT:

+   case GL_LUMINANCE_ALPHA16I_EXT:

+   case GL_RGBA8I_EXT:

+   case GL_RGB8I_EXT:

+   case GL_ALPHA8I_EXT:

+   case GL_INTENSITY8I_EXT:

+   case GL_LUMINANCE8I_EXT:

+   case GL_LUMINANCE_ALPHA8I_EXT:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test if an image format is a supported compressed format.

+ * \param format the internal format token provided by the user.

+ * \return GL_TRUE if compressed, GL_FALSE if uncompressed

+ */

+GLboolean

+_mesa_is_compressed_format(struct gl_context *ctx, GLenum format)

+{

+   switch (format) {

+   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+      return ctx->Extensions.EXT_texture_compression_s3tc;

+   case GL_RGB_S3TC:

+   case GL_RGB4_S3TC:

+   case GL_RGBA_S3TC:

+   case GL_RGBA4_S3TC:

+      return ctx->Extensions.S3_s3tc;

+   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+      return ctx->Extensions.EXT_texture_sRGB

+         && ctx->Extensions.EXT_texture_compression_s3tc;

+   case GL_COMPRESSED_RGB_FXT1_3DFX:

+   case GL_COMPRESSED_RGBA_FXT1_3DFX:

+      return ctx->Extensions.TDFX_texture_compression_FXT1;

+   case GL_COMPRESSED_RED_RGTC1:

+   case GL_COMPRESSED_SIGNED_RED_RGTC1:

+   case GL_COMPRESSED_RG_RGTC2:

+   case GL_COMPRESSED_SIGNED_RG_RGTC2:

+      return ctx->Extensions.ARB_texture_compression_rgtc;

+   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+      return ctx->Extensions.EXT_texture_compression_latc;

+   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+      return ctx->Extensions.ATI_texture_compression_3dc;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Return the address of a specific pixel in an image (1D, 2D or 3D).

+ *

+ * Pixel unpacking/packing parameters are observed according to \p packing.

+ *

+ * \param dimensions either 1, 2 or 3 to indicate dimensionality of image

+ * \param image  starting address of image data

+ * \param width  the image width

+ * \param height  theimage height

+ * \param format  the pixel format

+ * \param type  the pixel data type

+ * \param packing  the pixelstore attributes

+ * \param img  which image in the volume (0 for 1D or 2D images)

+ * \param row  row of pixel in the image (0 for 1D images)

+ * \param column column of pixel in the image

+ * 

+ * \return address of pixel on success, or NULL on error.

+ *

+ * \sa gl_pixelstore_attrib.

+ */

+GLvoid *

+_mesa_image_address( GLuint dimensions,

+                     const struct gl_pixelstore_attrib *packing,

+                     const GLvoid *image,

+                     GLsizei width, GLsizei height,

+                     GLenum format, GLenum type,

+                     GLint img, GLint row, GLint column )

+{

+   GLint alignment;        /* 1, 2 or 4 */

+   GLint pixels_per_row;

+   GLint rows_per_image;

+   GLint skiprows;

+   GLint skippixels;

+   GLint skipimages;       /* for 3-D volume images */

+   GLubyte *pixel_addr;

+

+   ASSERT(dimensions >= 1 && dimensions <= 3);

+

+   alignment = packing->Alignment;

+   if (packing->RowLength > 0) {

+      pixels_per_row = packing->RowLength;

+   }

+   else {

+      pixels_per_row = width;

+   }

+   if (packing->ImageHeight > 0) {

+      rows_per_image = packing->ImageHeight;

+   }

+   else {

+      rows_per_image = height;

+   }

+

+   skippixels = packing->SkipPixels;

+   /* Note: SKIP_ROWS _is_ used for 1D images */

+   skiprows = packing->SkipRows;

+   /* Note: SKIP_IMAGES is only used for 3D images */

+   skipimages = (dimensions == 3) ? packing->SkipImages : 0;

+

+   if (type == GL_BITMAP) {

+      /* BITMAP data */

+      GLint comp_per_pixel;   /* components per pixel */

+      GLint bytes_per_comp;   /* bytes per component */

+      GLint bytes_per_row;

+      GLint bytes_per_image;

+

+      /* Compute bytes per component */

+      bytes_per_comp = _mesa_sizeof_packed_type( type );

+      if (bytes_per_comp < 0) {

+         return NULL;

+      }

+

+      /* Compute number of components per pixel */

+      comp_per_pixel = _mesa_components_in_format( format );

+      if (comp_per_pixel < 0) {

+         return NULL;

+      }

+

+      bytes_per_row = alignment

+                    * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );

+

+      bytes_per_image = bytes_per_row * rows_per_image;

+

+      pixel_addr = (GLubyte *) image

+                 + (skipimages + img) * bytes_per_image

+                 + (skiprows + row) * bytes_per_row

+                 + (skippixels + column) / 8;

+   }

+   else {

+      /* Non-BITMAP data */

+      GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;

+      GLint topOfImage;

+

+      bytes_per_pixel = _mesa_bytes_per_pixel( format, type );

+

+      /* The pixel type and format should have been error checked earlier */

+      assert(bytes_per_pixel > 0);

+

+      bytes_per_row = pixels_per_row * bytes_per_pixel;

+      remainder = bytes_per_row % alignment;

+      if (remainder > 0)

+         bytes_per_row += (alignment - remainder);

+

+      ASSERT(bytes_per_row % alignment == 0);

+

+      bytes_per_image = bytes_per_row * rows_per_image;

+

+      if (packing->Invert) {

+         /* set pixel_addr to the last row */

+         topOfImage = bytes_per_row * (height - 1);

+         bytes_per_row = -bytes_per_row;

+      }

+      else {

+         topOfImage = 0;

+      }

+

+      /* compute final pixel address */

+      pixel_addr = (GLubyte *) image

+                 + (skipimages + img) * bytes_per_image

+                 + topOfImage

+                 + (skiprows + row) * bytes_per_row

+                 + (skippixels + column) * bytes_per_pixel;

+   }

+

+   return (GLvoid *) pixel_addr;

+}

+

+

+GLvoid *

+_mesa_image_address1d( const struct gl_pixelstore_attrib *packing,

+                       const GLvoid *image,

+                       GLsizei width,

+                       GLenum format, GLenum type,

+                       GLint column )

+{

+   return _mesa_image_address(1, packing, image, width, 1,

+                              format, type, 0, 0, column);

+}

+

+

+GLvoid *

+_mesa_image_address2d( const struct gl_pixelstore_attrib *packing,

+                       const GLvoid *image,

+                       GLsizei width, GLsizei height,

+                       GLenum format, GLenum type,

+                       GLint row, GLint column )

+{

+   return _mesa_image_address(2, packing, image, width, height,

+                              format, type, 0, row, column);

+}

+

+

+GLvoid *

+_mesa_image_address3d( const struct gl_pixelstore_attrib *packing,

+                       const GLvoid *image,

+                       GLsizei width, GLsizei height,

+                       GLenum format, GLenum type,

+                       GLint img, GLint row, GLint column )

+{

+   return _mesa_image_address(3, packing, image, width, height,

+                              format, type, img, row, column);

+}

+

+

+

+/**

+ * Compute the stride (in bytes) between image rows.

+ *

+ * \param packing the pixelstore attributes

+ * \param width image width.

+ * \param format pixel format.

+ * \param type pixel data type.

+ * 

+ * \return the stride in bytes for the given parameters, or -1 if error

+ */

+GLint

+_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,

+                        GLint width, GLenum format, GLenum type )

+{

+   GLint bytesPerRow, remainder;

+

+   ASSERT(packing);

+

+   if (type == GL_BITMAP) {

+      if (packing->RowLength == 0) {

+         bytesPerRow = (width + 7) / 8;

+      }

+      else {

+         bytesPerRow = (packing->RowLength + 7) / 8;

+      }

+   }

+   else {

+      /* Non-BITMAP data */

+      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);

+      if (bytesPerPixel <= 0)

+         return -1;  /* error */

+      if (packing->RowLength == 0) {

+         bytesPerRow = bytesPerPixel * width;

+      }

+      else {

+         bytesPerRow = bytesPerPixel * packing->RowLength;

+      }

+   }

+

+   remainder = bytesPerRow % packing->Alignment;

+   if (remainder > 0) {

+      bytesPerRow += (packing->Alignment - remainder);

+   }

+

+   if (packing->Invert) {

+      /* negate the bytes per row (negative row stride) */

+      bytesPerRow = -bytesPerRow;

+   }

+

+   return bytesPerRow;

+}

+

+

+/*

+ * Compute the stride between images in a 3D texture (in bytes) for the given

+ * pixel packing parameters and image width, format and type.

+ */

+GLint

+_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,

+                          GLint width, GLint height,

+                          GLenum format, GLenum type )

+{

+   GLint bytesPerRow, bytesPerImage, remainder;

+

+   ASSERT(packing);

+

+   if (type == GL_BITMAP) {

+      if (packing->RowLength == 0) {

+         bytesPerRow = (width + 7) / 8;

+      }

+      else {

+         bytesPerRow = (packing->RowLength + 7) / 8;

+      }

+   }

+   else {

+      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);

+

+      if (bytesPerPixel <= 0)

+         return -1;  /* error */

+      if (packing->RowLength == 0) {

+         bytesPerRow = bytesPerPixel * width;

+      }

+      else {

+         bytesPerRow = bytesPerPixel * packing->RowLength;

+      }

+   }

+

+   remainder = bytesPerRow % packing->Alignment;

+   if (remainder > 0)

+      bytesPerRow += (packing->Alignment - remainder);

+

+   if (packing->ImageHeight == 0)

+      bytesPerImage = bytesPerRow * height;

+   else

+      bytesPerImage = bytesPerRow * packing->ImageHeight;

+

+   return bytesPerImage;

+}

+

+

+

+/**

+ * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel.

+ * This is typically used to convert a bitmap into a GLubyte/pixel texture.

+ * "On" bits will set texels to \p onValue.

+ * "Off" bits will not modify texels.

+ * \param width  src bitmap width in pixels

+ * \param height  src bitmap height in pixels

+ * \param unpack  bitmap unpacking state

+ * \param bitmap  the src bitmap data

+ * \param destBuffer  start of dest buffer

+ * \param destStride  row stride in dest buffer

+ * \param onValue  if bit is 1, set destBuffer pixel to this value

+ */

+void

+_mesa_expand_bitmap(GLsizei width, GLsizei height,

+                    const struct gl_pixelstore_attrib *unpack,

+                    const GLubyte *bitmap,

+                    GLubyte *destBuffer, GLint destStride,

+                    GLubyte onValue)

+{

+   const GLubyte *srcRow = (const GLubyte *)

+      _mesa_image_address2d(unpack, bitmap, width, height,

+                            GL_COLOR_INDEX, GL_BITMAP, 0, 0);

+   const GLint srcStride = _mesa_image_row_stride(unpack, width,

+                                                  GL_COLOR_INDEX, GL_BITMAP);

+   GLint row, col;

+

+#define SET_PIXEL(COL, ROW) \

+   destBuffer[(ROW) * destStride + (COL)] = onValue;

+

+   for (row = 0; row < height; row++) {

+      const GLubyte *src = srcRow;

+

+      if (unpack->LsbFirst) {

+         /* Lsb first */

+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+

+            if (*src & mask) {

+               SET_PIXEL(col, row);

+            }

+

+            if (mask == 128U) {

+               src++;

+               mask = 1U;

+            }

+            else {

+               mask = mask << 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 1)

+            src++;

+      }

+      else {

+         /* Msb first */

+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+

+            if (*src & mask) {

+               SET_PIXEL(col, row);

+            }

+

+            if (mask == 1U) {

+               src++;

+               mask = 128U;

+            }

+            else {

+               mask = mask >> 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 128)

+            src++;

+      }

+

+      srcRow += srcStride;

+   } /* row */

+

+#undef SET_PIXEL

+}

+

+

+

+

+/**

+ * Convert an array of RGBA colors from one datatype to another.

+ * NOTE: src may equal dst.  In that case, we use a temporary buffer.

+ */

+void

+_mesa_convert_colors(GLenum srcType, const GLvoid *src,

+                     GLenum dstType, GLvoid *dst,

+                     GLuint count, const GLubyte mask[])

+{

+   GLuint tempBuffer[MAX_WIDTH][4];

+   const GLboolean useTemp = (src == dst);

+

+   ASSERT(srcType != dstType);

+

+   switch (srcType) {

+   case GL_UNSIGNED_BYTE:

+      if (dstType == GL_UNSIGNED_SHORT) {

+         const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;

+         GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]);

+               dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]);

+               dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]);

+               dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));

+      }

+      else {

+         const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src;

+         GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         ASSERT(dstType == GL_FLOAT);

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]);

+               dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]);

+               dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]);

+               dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));

+      }

+      break;

+   case GL_UNSIGNED_SHORT:

+      if (dstType == GL_UNSIGNED_BYTE) {

+         const GLushort (*src2)[4] = (const GLushort (*)[4]) src;

+         GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]);

+               dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]);

+               dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]);

+               dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));

+      }

+      else {

+         const GLushort (*src2)[4] = (const GLushort (*)[4]) src;

+         GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         ASSERT(dstType == GL_FLOAT);

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]);

+               dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]);

+               dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]);

+               dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat));

+      }

+      break;

+   case GL_FLOAT:

+      if (dstType == GL_UNSIGNED_BYTE) {

+         const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;

+         GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]);

+               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]);

+               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]);

+               UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte));

+      }

+      else {

+         const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src;

+         GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst);

+         GLuint i;

+         ASSERT(dstType == GL_UNSIGNED_SHORT);

+         for (i = 0; i < count; i++) {

+            if (!mask || mask[i]) {

+               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]);

+               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]);

+               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]);

+               UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]);

+            }

+         }

+         if (useTemp)

+            memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort));

+      }

+      break;

+   default:

+      _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors");

+   }

+}

+

+

+

+

+/**

+ * Perform basic clipping for glDrawPixels.  The image's position and size

+ * and the unpack SkipPixels and SkipRows are adjusted so that the image

+ * region is entirely within the window and scissor bounds.

+ * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1).

+ * If Pixel.ZoomY is -1, *destY will be changed to be the first row which

+ * we'll actually write.  Beforehand, *destY-1 is the first drawing row.

+ *

+ * \return  GL_TRUE if image is ready for drawing or

+ *          GL_FALSE if image was completely clipped away (draw nothing)

+ */

+GLboolean

+_mesa_clip_drawpixels(const struct gl_context *ctx,

+                      GLint *destX, GLint *destY,

+                      GLsizei *width, GLsizei *height,

+                      struct gl_pixelstore_attrib *unpack)

+{

+   const struct gl_framebuffer *buffer = ctx->DrawBuffer;

+

+   if (unpack->RowLength == 0) {

+      unpack->RowLength = *width;

+   }

+

+   ASSERT(ctx->Pixel.ZoomX == 1.0F);

+   ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F);

+

+   /* left clipping */

+   if (*destX < buffer->_Xmin) {

+      unpack->SkipPixels += (buffer->_Xmin - *destX);

+      *width -= (buffer->_Xmin - *destX);

+      *destX = buffer->_Xmin;

+   }

+   /* right clipping */

+   if (*destX + *width > buffer->_Xmax)

+      *width -= (*destX + *width - buffer->_Xmax);

+

+   if (*width <= 0)

+      return GL_FALSE;

+

+   if (ctx->Pixel.ZoomY == 1.0F) {

+      /* bottom clipping */

+      if (*destY < buffer->_Ymin) {

+         unpack->SkipRows += (buffer->_Ymin - *destY);

+         *height -= (buffer->_Ymin - *destY);

+         *destY = buffer->_Ymin;

+      }

+      /* top clipping */

+      if (*destY + *height > buffer->_Ymax)

+         *height -= (*destY + *height - buffer->_Ymax);

+   }

+   else { /* upside down */

+      /* top clipping */

+      if (*destY > buffer->_Ymax) {

+         unpack->SkipRows += (*destY - buffer->_Ymax);

+         *height -= (*destY - buffer->_Ymax);

+         *destY = buffer->_Ymax;

+      }

+      /* bottom clipping */

+      if (*destY - *height < buffer->_Ymin)

+         *height -= (buffer->_Ymin - (*destY - *height));

+      /* adjust destY so it's the first row to write to */

+      (*destY)--;

+   }

+

+   if (*height <= 0)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Perform clipping for glReadPixels.  The image's window position

+ * and size, and the pack skipPixels, skipRows and rowLength are adjusted

+ * so that the image region is entirely within the window bounds.

+ * Note: this is different from _mesa_clip_drawpixels() in that the

+ * scissor box is ignored, and we use the bounds of the current readbuffer

+ * surface.

+ *

+ * \return  GL_TRUE if region to read is in bounds

+ *          GL_FALSE if region is completely out of bounds (nothing to read)

+ */

+GLboolean

+_mesa_clip_readpixels(const struct gl_context *ctx,

+                      GLint *srcX, GLint *srcY,

+                      GLsizei *width, GLsizei *height,

+                      struct gl_pixelstore_attrib *pack)

+{

+   const struct gl_framebuffer *buffer = ctx->ReadBuffer;

+

+   if (pack->RowLength == 0) {

+      pack->RowLength = *width;

+   }

+

+   /* left clipping */

+   if (*srcX < 0) {

+      pack->SkipPixels += (0 - *srcX);

+      *width -= (0 - *srcX);

+      *srcX = 0;

+   }

+   /* right clipping */

+   if (*srcX + *width > (GLsizei) buffer->Width)

+      *width -= (*srcX + *width - buffer->Width);

+

+   if (*width <= 0)

+      return GL_FALSE;

+

+   /* bottom clipping */

+   if (*srcY < 0) {

+      pack->SkipRows += (0 - *srcY);

+      *height -= (0 - *srcY);

+      *srcY = 0;

+   }

+   /* top clipping */

+   if (*srcY + *height > (GLsizei) buffer->Height)

+      *height -= (*srcY + *height - buffer->Height);

+

+   if (*height <= 0)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do clipping for a glCopyTexSubImage call.

+ * The framebuffer source region might extend outside the framebuffer

+ * bounds.  Clip the source region against the framebuffer bounds and

+ * adjust the texture/dest position and size accordingly.

+ *

+ * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise.

+ */

+GLboolean

+_mesa_clip_copytexsubimage(const struct gl_context *ctx,

+                           GLint *destX, GLint *destY,

+                           GLint *srcX, GLint *srcY,

+                           GLsizei *width, GLsizei *height)

+{

+   const struct gl_framebuffer *fb = ctx->ReadBuffer;

+   const GLint srcX0 = *srcX, srcY0 = *srcY;

+

+   if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height,

+                            srcX, srcY, width, height)) {

+      *destX = *destX + *srcX - srcX0;

+      *destY = *destY + *srcY - srcY0;

+

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * Clip the rectangle defined by (x, y, width, height) against the bounds

+ * specified by [xmin, xmax) and [ymin, ymax).

+ * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise.

+ */

+GLboolean

+_mesa_clip_to_region(GLint xmin, GLint ymin,

+                     GLint xmax, GLint ymax,

+                     GLint *x, GLint *y,

+                     GLsizei *width, GLsizei *height )

+{

+   /* left clipping */

+   if (*x < xmin) {

+      *width -= (xmin - *x);

+      *x = xmin;

+   }

+

+   /* right clipping */

+   if (*x + *width > xmax)

+      *width -= (*x + *width - xmax);

+

+   if (*width <= 0)

+      return GL_FALSE;

+

+   /* bottom (or top) clipping */

+   if (*y < ymin) {

+      *height -= (ymin - *y);

+      *y = ymin;

+   }

+

+   /* top (or bottom) clipping */

+   if (*y + *height > ymax)

+      *height -= (*y + *height - ymax);

+

+   if (*height <= 0)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Clip dst coords against Xmax (or Ymax).

+ */

+static INLINE void

+clip_right_or_top(GLint *srcX0, GLint *srcX1,

+                  GLint *dstX0, GLint *dstX1,

+                  GLint maxValue)

+{

+   GLfloat t, bias;

+

+   if (*dstX1 > maxValue) {

+      /* X1 outside right edge */

+      ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */

+      t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);

+      /* chop off [t, 1] part */

+      ASSERT(t >= 0.0 && t <= 1.0);

+      *dstX1 = maxValue;

+      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F;

+      *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);

+   }

+   else if (*dstX0 > maxValue) {

+      /* X0 outside right edge */

+      ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */

+      t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);

+      /* chop off [t, 1] part */

+      ASSERT(t >= 0.0 && t <= 1.0);

+      *dstX0 = maxValue;

+      bias = (*srcX0 < *srcX1) ? -0.5F : 0.5F;

+      *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);

+   }

+}

+

+

+/**

+ * Clip dst coords against Xmin (or Ymin).

+ */

+static INLINE void

+clip_left_or_bottom(GLint *srcX0, GLint *srcX1,

+                    GLint *dstX0, GLint *dstX1,

+                    GLint minValue)

+{

+   GLfloat t, bias;

+

+   if (*dstX0 < minValue) {

+      /* X0 outside left edge */

+      ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */

+      t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);

+      /* chop off [0, t] part */

+      ASSERT(t >= 0.0 && t <= 1.0);

+      *dstX0 = minValue;

+      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; /* flipped??? */

+      *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);

+   }

+   else if (*dstX1 < minValue) {

+      /* X1 outside left edge */

+      ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */

+      t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);

+      /* chop off [0, t] part */

+      ASSERT(t >= 0.0 && t <= 1.0);

+      *dstX1 = minValue;

+      bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F;

+      *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);

+   }

+}

+

+

+/**

+ * Do clipping of blit src/dest rectangles.

+ * The dest rect is clipped against both the buffer bounds and scissor bounds.

+ * The src rect is just clipped against the buffer bounds.

+ *

+ * When either the src or dest rect is clipped, the other is also clipped

+ * proportionately!

+ *

+ * Note that X0 need not be less than X1 (same for Y) for either the source

+ * and dest rects.  That makes the clipping a little trickier.

+ *

+ * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped

+ */

+GLboolean

+_mesa_clip_blit(struct gl_context *ctx,

+                GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,

+                GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1)

+{

+   const GLint srcXmin = 0;

+   const GLint srcXmax = ctx->ReadBuffer->Width;

+   const GLint srcYmin = 0;

+   const GLint srcYmax = ctx->ReadBuffer->Height;

+

+   /* these include scissor bounds */

+   const GLint dstXmin = ctx->DrawBuffer->_Xmin;

+   const GLint dstXmax = ctx->DrawBuffer->_Xmax;

+   const GLint dstYmin = ctx->DrawBuffer->_Ymin;

+   const GLint dstYmax = ctx->DrawBuffer->_Ymax;

+

+   /*

+   printf("PreClipX:  src: %d .. %d  dst: %d .. %d\n",

+          *srcX0, *srcX1, *dstX0, *dstX1);

+   printf("PreClipY:  src: %d .. %d  dst: %d .. %d\n",

+          *srcY0, *srcY1, *dstY0, *dstY1);

+   */

+

+   /* trivial rejection tests */

+   if (*dstX0 == *dstX1)

+      return GL_FALSE; /* no width */

+   if (*dstX0 <= dstXmin && *dstX1 <= dstXmin)

+      return GL_FALSE; /* totally out (left) of bounds */

+   if (*dstX0 >= dstXmax && *dstX1 >= dstXmax)

+      return GL_FALSE; /* totally out (right) of bounds */

+

+   if (*dstY0 == *dstY1)

+      return GL_FALSE;

+   if (*dstY0 <= dstYmin && *dstY1 <= dstYmin)

+      return GL_FALSE;

+   if (*dstY0 >= dstYmax && *dstY1 >= dstYmax)

+      return GL_FALSE;

+

+   if (*srcX0 == *srcX1)

+      return GL_FALSE;

+   if (*srcX0 <= srcXmin && *srcX1 <= srcXmin)

+      return GL_FALSE;

+   if (*srcX0 >= srcXmax && *srcX1 >= srcXmax)

+      return GL_FALSE;

+

+   if (*srcY0 == *srcY1)

+      return GL_FALSE;

+   if (*srcY0 <= srcYmin && *srcY1 <= srcYmin)

+      return GL_FALSE;

+   if (*srcY0 >= srcYmax && *srcY1 >= srcYmax)

+      return GL_FALSE;

+

+   /*

+    * dest clip

+    */

+   clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax);

+   clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax);

+   clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin);

+   clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin);

+

+   /*

+    * src clip (just swap src/dst values from above)

+    */

+   clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax);

+   clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax);

+   clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin);

+   clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin);

+

+   /*

+   printf("PostClipX: src: %d .. %d  dst: %d .. %d\n",

+          *srcX0, *srcX1, *dstX0, *dstX1);

+   printf("PostClipY: src: %d .. %d  dst: %d .. %d\n",

+          *srcY0, *srcY1, *dstY0, *dstY1);

+   */

+

+   ASSERT(*dstX0 >= dstXmin);

+   ASSERT(*dstX0 <= dstXmax);

+   ASSERT(*dstX1 >= dstXmin);

+   ASSERT(*dstX1 <= dstXmax);

+

+   ASSERT(*dstY0 >= dstYmin);

+   ASSERT(*dstY0 <= dstYmax);

+   ASSERT(*dstY1 >= dstYmin);

+   ASSERT(*dstY1 <= dstYmax);

+

+   ASSERT(*srcX0 >= srcXmin);

+   ASSERT(*srcX0 <= srcXmax);

+   ASSERT(*srcX1 >= srcXmin);

+   ASSERT(*srcX1 <= srcXmax);

+

+   ASSERT(*srcY0 >= srcYmin);

+   ASSERT(*srcY0 <= srcYmax);

+   ASSERT(*srcY1 >= srcYmin);

+   ASSERT(*srcY1 <= srcYmax);

+

+   return GL_TRUE;

+}

diff --git a/mesalib/src/mesa/main/imports.c b/mesalib/src/mesa/main/imports.c
index bf89815f2..3f856402f 100644
--- a/mesalib/src/mesa/main/imports.c
+++ b/mesalib/src/mesa/main/imports.c
@@ -1,1028 +1,1028 @@
-/**
- * \file imports.c
- * Standard C library function wrappers.
- * 
- * Imports are services which the device driver or window system or
- * operating system provides to the core renderer.  The core renderer (Mesa)
- * will call these functions in order to do memory allocation, simple I/O,
- * etc.
- *
- * Some drivers will want to override/replace this file with something
- * specialized, but that'll be rare.
- *
- * Eventually, I want to move roll the glheader.h file into this.
- *
- * \todo Functions still needed:
- * - scanf
- * - qsort
- * - rand and RAND_MAX
- */
-
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-#include "imports.h"
-#include "context.h"
-#include "mtypes.h"
-#include "version.h"
-
-#ifdef _GNU_SOURCE
-#include <locale.h>
-#ifdef __APPLE__
-#include <xlocale.h>
-#endif
-#endif
-
-
-#define MAXSTRING 4000  /* for vsnprintf() */
-
-#ifdef WIN32
-#define vsnprintf _vsnprintf
-#elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )
-extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
-#ifdef __VMS
-#include "vsnprintf.c"
-#endif
-#endif
-
-/**********************************************************************/
-/** \name Memory */
-/*@{*/
-
-/**
- * Allocate aligned memory.
- *
- * \param bytes number of bytes to allocate.
- * \param alignment alignment (must be greater than zero).
- * 
- * Allocates extra memory to accommodate rounding up the address for
- * alignment and to record the real malloc address.
- *
- * \sa _mesa_align_free().
- */
-void *
-_mesa_align_malloc(size_t bytes, unsigned long alignment)
-{
-#if defined(HAVE_POSIX_MEMALIGN)
-   void *mem;
-   int err = posix_memalign(& mem, alignment, bytes);
-   if (err)
-      return NULL;
-   return mem;
-#elif defined(_WIN32) && defined(_MSC_VER)
-   return _aligned_malloc(bytes, alignment);
-#else
-   uintptr_t ptr, buf;
-
-   ASSERT( alignment > 0 );
-
-   ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *));
-   if (!ptr)
-      return NULL;
-
-   buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
-   *(uintptr_t *)(buf - sizeof(void *)) = ptr;
-
-#ifdef DEBUG
-   /* mark the non-aligned area */
-   while ( ptr < buf - sizeof(void *) ) {
-      *(unsigned long *)ptr = 0xcdcdcdcd;
-      ptr += sizeof(unsigned long);
-   }
-#endif
-
-   return (void *) buf;
-#endif /* defined(HAVE_POSIX_MEMALIGN) */
-}
-
-/**
- * Same as _mesa_align_malloc(), but using calloc(1, ) instead of
- * malloc()
- */
-void *
-_mesa_align_calloc(size_t bytes, unsigned long alignment)
-{
-#if defined(HAVE_POSIX_MEMALIGN)
-   void *mem;
-   
-   mem = _mesa_align_malloc(bytes, alignment);
-   if (mem != NULL) {
-      (void) memset(mem, 0, bytes);
-   }
-
-   return mem;
-#elif defined(_WIN32) && defined(_MSC_VER)
-   void *mem;
-
-   mem = _aligned_malloc(bytes, alignment);
-   if (mem != NULL) {
-      (void) memset(mem, 0, bytes);
-   }
-
-   return mem;
-#else
-   uintptr_t ptr, buf;
-
-   ASSERT( alignment > 0 );
-
-   ptr = (uintptr_t) calloc(1, bytes + alignment + sizeof(void *));
-   if (!ptr)
-      return NULL;
-
-   buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
-   *(uintptr_t *)(buf - sizeof(void *)) = ptr;
-
-#ifdef DEBUG
-   /* mark the non-aligned area */
-   while ( ptr < buf - sizeof(void *) ) {
-      *(unsigned long *)ptr = 0xcdcdcdcd;
-      ptr += sizeof(unsigned long);
-   }
-#endif
-
-   return (void *)buf;
-#endif /* defined(HAVE_POSIX_MEMALIGN) */
-}
-
-/**
- * Free memory which was allocated with either _mesa_align_malloc()
- * or _mesa_align_calloc().
- * \param ptr pointer to the memory to be freed.
- * The actual address to free is stored in the word immediately before the
- * address the client sees.
- */
-void
-_mesa_align_free(void *ptr)
-{
-#if defined(HAVE_POSIX_MEMALIGN)
-   free(ptr);
-#elif defined(_WIN32) && defined(_MSC_VER)
-   _aligned_free(ptr);
-#else
-   void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
-   void *realAddr = *cubbyHole;
-   free(realAddr);
-#endif /* defined(HAVE_POSIX_MEMALIGN) */
-}
-
-/**
- * Reallocate memory, with alignment.
- */
-void *
-_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
-                    unsigned long alignment)
-{
-#if defined(_WIN32) && defined(_MSC_VER)
-   (void) oldSize;
-   return _aligned_realloc(oldBuffer, newSize, alignment);
-#else
-   const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
-   void *newBuf = _mesa_align_malloc(newSize, alignment);
-   if (newBuf && oldBuffer && copySize > 0) {
-      memcpy(newBuf, oldBuffer, copySize);
-   }
-   if (oldBuffer)
-      _mesa_align_free(oldBuffer);
-   return newBuf;
-#endif
-}
-
-
-
-/** Reallocate memory */
-void *
-_mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize)
-{
-   const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
-   void *newBuffer = malloc(newSize);
-   if (newBuffer && oldBuffer && copySize > 0)
-      memcpy(newBuffer, oldBuffer, copySize);
-   if (oldBuffer)
-      free(oldBuffer);
-   return newBuffer;
-}
-
-/**
- * Fill memory with a constant 16bit word.
- * \param dst destination pointer.
- * \param val value.
- * \param n number of words.
- */
-void
-_mesa_memset16( unsigned short *dst, unsigned short val, size_t n )
-{
-   while (n-- > 0)
-      *dst++ = val;
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Math */
-/*@{*/
-
-/** Wrapper around sqrt() */
-double
-_mesa_sqrtd(double x)
-{
-   return sqrt(x);
-}
-
-
-/*
- * A High Speed, Low Precision Square Root
- * by Paul Lalonde and Robert Dawson
- * from "Graphics Gems", Academic Press, 1990
- *
- * SPARC implementation of a fast square root by table
- * lookup.
- * SPARC floating point format is as follows:
- *
- * BIT 31 	30 	23 	22 	0
- *     sign	exponent	mantissa
- */
-static short sqrttab[0x100];    /* declare table of square roots */
-
-void
-_mesa_init_sqrt_table(void)
-{
-#if defined(USE_IEEE) && !defined(DEBUG)
-   unsigned short i;
-   fi_type fi;     /* to access the bits of a float in  C quickly  */
-                   /* we use a union defined in glheader.h         */
-
-   for(i=0; i<= 0x7f; i++) {
-      fi.i = 0;
-
-      /*
-       * Build a float with the bit pattern i as mantissa
-       * and an exponent of 0, stored as 127
-       */
-
-      fi.i = (i << 16) | (127 << 23);
-      fi.f = _mesa_sqrtd(fi.f);
-
-      /*
-       * Take the square root then strip the first 7 bits of
-       * the mantissa into the table
-       */
-
-      sqrttab[i] = (fi.i & 0x7fffff) >> 16;
-
-      /*
-       * Repeat the process, this time with an exponent of
-       * 1, stored as 128
-       */
-
-      fi.i = 0;
-      fi.i = (i << 16) | (128 << 23);
-      fi.f = sqrt(fi.f);
-      sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
-   }
-#else
-   (void) sqrttab;  /* silence compiler warnings */
-#endif /*HAVE_FAST_MATH*/
-}
-
-
-/**
- * Single precision square root.
- */
-float
-_mesa_sqrtf( float x )
-{
-#if defined(USE_IEEE) && !defined(DEBUG)
-   fi_type num;
-                                /* to access the bits of a float in C
-                                 * we use a union from glheader.h     */
-
-   short e;                     /* the exponent */
-   if (x == 0.0F) return 0.0F;  /* check for square root of 0 */
-   num.f = x;
-   e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */
-                                /* exponent is stored with 127 added */
-   num.i &= 0x7fffff;           /* leave only the mantissa */
-   if (e & 0x01) num.i |= 0x800000;
-                                /* the exponent is odd so we have to */
-                                /* look it up in the second half of  */
-                                /* the lookup table, so we set the   */
-                                /* high bit                                */
-   e >>= 1;                     /* divide the exponent by two */
-                                /* note that in C the shift */
-                                /* operators are sign preserving */
-                                /* for signed operands */
-   /* Do the table lookup, based on the quaternary mantissa,
-    * then reconstruct the result back into a float
-    */
-   num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
-
-   return num.f;
-#else
-   return (float) _mesa_sqrtd((double) x);
-#endif
-}
-
-
-/**
- inv_sqrt - A single precision 1/sqrt routine for IEEE format floats.
- written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk
- and Vesa Karvonen.
-*/
-float
-_mesa_inv_sqrtf(float n)
-{
-#if defined(USE_IEEE) && !defined(DEBUG)
-        float r0, x0, y0;
-        float r1, x1, y1;
-        float r2, x2, y2;
-#if 0 /* not used, see below -BP */
-        float r3, x3, y3;
-#endif
-        fi_type u;
-        unsigned int magic;
-
-        /*
-         Exponent part of the magic number -
-
-         We want to:
-         1. subtract the bias from the exponent,
-         2. negate it
-         3. divide by two (rounding towards -inf)
-         4. add the bias back
-
-         Which is the same as subtracting the exponent from 381 and dividing
-         by 2.
-
-         floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2)
-        */
-
-        magic = 381 << 23;
-
-        /*
-         Significand part of magic number -
-
-         With the current magic number, "(magic - u.i) >> 1" will give you:
-
-         for 1 <= u.f <= 2: 1.25 - u.f / 4
-         for 2 <= u.f <= 4: 1.00 - u.f / 8
-
-         This isn't a bad approximation of 1/sqrt.  The maximum difference from
-         1/sqrt will be around .06.  After three Newton-Raphson iterations, the
-         maximum difference is less than 4.5e-8.  (Which is actually close
-         enough to make the following bias academic...)
-
-         To get a better approximation you can add a bias to the magic
-         number.  For example, if you subtract 1/2 of the maximum difference in
-         the first approximation (.03), you will get the following function:
-
-         for 1 <= u.f <= 2:    1.22 - u.f / 4
-         for 2 <= u.f <= 3.76: 0.97 - u.f / 8
-         for 3.76 <= u.f <= 4: 0.72 - u.f / 16
-         (The 3.76 to 4 range is where the result is < .5.)
-
-         This is the closest possible initial approximation, but with a maximum
-         error of 8e-11 after three NR iterations, it is still not perfect.  If
-         you subtract 0.0332281 instead of .03, the maximum error will be
-         2.5e-11 after three NR iterations, which should be about as close as
-         is possible.
-
-         for 1 <= u.f <= 2:    1.2167719 - u.f / 4
-         for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8
-         for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16
-
-        */
-
-        magic -= (int)(0.0332281 * (1 << 25));
-
-        u.f = n;
-        u.i = (magic - u.i) >> 1;
-
-        /*
-         Instead of Newton-Raphson, we use Goldschmidt's algorithm, which
-         allows more parallelism.  From what I understand, the parallelism
-         comes at the cost of less precision, because it lets error
-         accumulate across iterations.
-        */
-        x0 = 1.0f;
-        y0 = 0.5f * n;
-        r0 = u.f;
-
-        x1 = x0 * r0;
-        y1 = y0 * r0 * r0;
-        r1 = 1.5f - y1;
-
-        x2 = x1 * r1;
-        y2 = y1 * r1 * r1;
-        r2 = 1.5f - y2;
-
-#if 1
-        return x2 * r2;  /* we can stop here, and be conformant -BP */
-#else
-        x3 = x2 * r2;
-        y3 = y2 * r2 * r2;
-        r3 = 1.5f - y3;
-
-        return x3 * r3;
-#endif
-#else
-        return (float) (1.0 / sqrt(n));
-#endif
-}
-
-#ifndef __GNUC__
-/**
- * Find the first bit set in a word.
- */
-int
-_mesa_ffs(int32_t i)
-{
-#if (defined(_WIN32) ) || defined(__IBMC__) || defined(__IBMCPP__)
-   register int bit = 0;
-   if (i != 0) {
-      if ((i & 0xffff) == 0) {
-         bit += 16;
-         i >>= 16;
-      }
-      if ((i & 0xff) == 0) {
-         bit += 8;
-         i >>= 8;
-      }
-      if ((i & 0xf) == 0) {
-         bit += 4;
-         i >>= 4;
-      }
-      while ((i & 1) == 0) {
-         bit++;
-         i >>= 1;
-      }
-      bit++;
-   }
-   return bit;
-#else
-   return ffs(i);
-#endif
-}
-
-
-/**
- * Find position of first bit set in given value.
- * XXX Warning: this function can only be used on 64-bit systems!
- * \return  position of least-significant bit set, starting at 1, return zero
- *          if no bits set.
- */
-int
-_mesa_ffsll(int64_t val)
-{
-   int bit;
-
-   assert(sizeof(val) == 8);
-
-   bit = _mesa_ffs((int32_t)val);
-   if (bit != 0)
-      return bit;
-
-   bit = _mesa_ffs((int32_t)(val >> 32));
-   if (bit != 0)
-      return 32 + bit;
-
-   return 0;
-}
-
-
-#if ((_GNUC__ == 3 && __GNUC_MINOR__ < 4) || __GNUC__ < 4)
-/**
- * Return number of bits set in given GLuint.
- */
-unsigned int
-_mesa_bitcount(unsigned int n)
-{
-   unsigned int bits;
-   for (bits = 0; n > 0; n = n >> 1) {
-      bits += (n & 1);
-   }
-   return bits;
-}
-#endif
-#endif
-
-
-/**
- * Convert a 4-byte float to a 2-byte half float.
- * Based on code from:
- * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
- */
-GLhalfARB
-_mesa_float_to_half(float val)
-{
-   const fi_type fi = {val};
-   const int flt_m = fi.i & 0x7fffff;
-   const int flt_e = (fi.i >> 23) & 0xff;
-   const int flt_s = (fi.i >> 31) & 0x1;
-   int s, e, m = 0;
-   GLhalfARB result;
-   
-   /* sign bit */
-   s = flt_s;
-
-   /* handle special cases */
-   if ((flt_e == 0) && (flt_m == 0)) {
-      /* zero */
-      /* m = 0; - already set */
-      e = 0;
-   }
-   else if ((flt_e == 0) && (flt_m != 0)) {
-      /* denorm -- denorm float maps to 0 half */
-      /* m = 0; - already set */
-      e = 0;
-   }
-   else if ((flt_e == 0xff) && (flt_m == 0)) {
-      /* infinity */
-      /* m = 0; - already set */
-      e = 31;
-   }
-   else if ((flt_e == 0xff) && (flt_m != 0)) {
-      /* NaN */
-      m = 1;
-      e = 31;
-   }
-   else {
-      /* regular number */
-      const int new_exp = flt_e - 127;
-      if (new_exp < -24) {
-         /* this maps to 0 */
-         /* m = 0; - already set */
-         e = 0;
-      }
-      else if (new_exp < -14) {
-         /* this maps to a denorm */
-         unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/
-         e = 0;
-         switch (exp_val) {
-            case 0:
-               _mesa_warning(NULL,
-                   "float_to_half: logical error in denorm creation!\n");
-               /* m = 0; - already set */
-               break;
-            case 1: m = 512 + (flt_m >> 14); break;
-            case 2: m = 256 + (flt_m >> 15); break;
-            case 3: m = 128 + (flt_m >> 16); break;
-            case 4: m = 64 + (flt_m >> 17); break;
-            case 5: m = 32 + (flt_m >> 18); break;
-            case 6: m = 16 + (flt_m >> 19); break;
-            case 7: m = 8 + (flt_m >> 20); break;
-            case 8: m = 4 + (flt_m >> 21); break;
-            case 9: m = 2 + (flt_m >> 22); break;
-            case 10: m = 1; break;
-         }
-      }
-      else if (new_exp > 15) {
-         /* map this value to infinity */
-         /* m = 0; - already set */
-         e = 31;
-      }
-      else {
-         /* regular */
-         e = new_exp + 15;
-         m = flt_m >> 13;
-      }
-   }
-
-   result = (s << 15) | (e << 10) | m;
-   return result;
-}
-
-
-/**
- * Convert a 2-byte half float to a 4-byte float.
- * Based on code from:
- * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
- */
-float
-_mesa_half_to_float(GLhalfARB val)
-{
-   /* XXX could also use a 64K-entry lookup table */
-   const int m = val & 0x3ff;
-   const int e = (val >> 10) & 0x1f;
-   const int s = (val >> 15) & 0x1;
-   int flt_m, flt_e, flt_s;
-   fi_type fi;
-   float result;
-
-   /* sign bit */
-   flt_s = s;
-
-   /* handle special cases */
-   if ((e == 0) && (m == 0)) {
-      /* zero */
-      flt_m = 0;
-      flt_e = 0;
-   }
-   else if ((e == 0) && (m != 0)) {
-      /* denorm -- denorm half will fit in non-denorm single */
-      const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
-      float mantissa = ((float) (m)) / 1024.0f;
-      float sign = s ? -1.0f : 1.0f;
-      return sign * mantissa * half_denorm;
-   }
-   else if ((e == 31) && (m == 0)) {
-      /* infinity */
-      flt_e = 0xff;
-      flt_m = 0;
-   }
-   else if ((e == 31) && (m != 0)) {
-      /* NaN */
-      flt_e = 0xff;
-      flt_m = 1;
-   }
-   else {
-      /* regular */
-      flt_e = e + 112;
-      flt_m = m << 13;
-   }
-
-   fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;
-   result = fi.f;
-   return result;
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Sort & Search */
-/*@{*/
-
-/**
- * Wrapper for bsearch().
- */
-void *
-_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 
-               int (*compar)(const void *, const void *) )
-{
-#if defined(_WIN32_WCE)
-   void *mid;
-   int cmp;
-   while (nmemb) {
-      nmemb >>= 1;
-      mid = (char *)base + nmemb * size;
-      cmp = (*compar)(key, mid);
-      if (cmp == 0)
-	 return mid;
-      if (cmp > 0) {
-	 base = (char *)mid + size;
-	 --nmemb;
-      }
-   }
-   return NULL;
-#else
-   return bsearch(key, base, nmemb, size, compar);
-#endif
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Environment vars */
-/*@{*/
-
-/**
- * Wrapper for getenv().
- */
-char *
-_mesa_getenv( const char *var )
-{
-#if defined(_XBOX) || defined(_WIN32_WCE)
-   return NULL;
-#else
-   return getenv(var);
-#endif
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name String */
-/*@{*/
-
-/**
- * Implemented using malloc() and strcpy.
- * Note that NULL is handled accordingly.
- */
-char *
-_mesa_strdup( const char *s )
-{
-   if (s) {
-      size_t l = strlen(s);
-      char *s2 = (char *) malloc(l + 1);
-      if (s2)
-         strcpy(s2, s);
-      return s2;
-   }
-   else {
-      return NULL;
-   }
-}
-
-/** Wrapper around strtof() */
-float
-_mesa_strtof( const char *s, char **end )
-{
-#if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__)
-   static locale_t loc = NULL;
-   if (!loc) {
-      loc = newlocale(LC_CTYPE_MASK, "C", NULL);
-   }
-   return strtof_l(s, end, loc);
-#elif defined(_ISOC99_SOURCE) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
-   return strtof(s, end);
-#else
-   return (float)strtod(s, end);
-#endif
-}
-
-/** Compute simple checksum/hash for a string */
-unsigned int
-_mesa_str_checksum(const char *str)
-{
-   /* This could probably be much better */
-   unsigned int sum, i;
-   const char *c;
-   sum = i = 1;
-   for (c = str; *c; c++, i++)
-      sum += *c * (i % 100);
-   return sum + i;
-}
-
-
-/*@}*/
-
-
-/** Wrapper around vsnprintf() */
-int
-_mesa_snprintf( char *str, size_t size, const char *fmt, ... )
-{
-   int r;
-   va_list args;
-   va_start( args, fmt );  
-   r = vsnprintf( str, size, fmt, args );
-   va_end( args );
-   return r;
-}
-
-
-/**********************************************************************/
-/** \name Diagnostics */
-/*@{*/
-
-static void
-output_if_debug(const char *prefixString, const char *outputString,
-                GLboolean newline)
-{
-   static int debug = -1;
-
-   /* Check the MESA_DEBUG environment variable if it hasn't
-    * been checked yet.  We only have to check it once...
-    */
-   if (debug == -1) {
-      char *env = _mesa_getenv("MESA_DEBUG");
-
-      /* In a debug build, we print warning messages *unless*
-       * MESA_DEBUG is 0.  In a non-debug build, we don't
-       * print warning messages *unless* MESA_DEBUG is
-       * set *to any value*.
-       */
-#ifdef DEBUG
-      debug = (env != NULL && atoi(env) == 0) ? 0 : 1;
-#else
-      debug = (env != NULL) ? 1 : 0;
-#endif
-   }
-
-   /* Now only print the string if we're required to do so. */
-   if (debug) {
-      fprintf(stderr, "%s: %s", prefixString, outputString);
-      if (newline)
-         fprintf(stderr, "\n");
-
-#if defined(_WIN32) && !defined(_WIN32_WCE)
-      /* stderr from windows applications without console is not usually 
-       * visible, so communicate with the debugger instead */ 
-      {
-         char buf[4096];
-         _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
-         OutputDebugStringA(buf);
-      }
-#endif
-   }
-}
-
-
-/**
- * Return string version of GL error code.
- */
-static const char *
-error_string( GLenum error )
-{
-   switch (error) {
-   case GL_NO_ERROR:
-      return "GL_NO_ERROR";
-   case GL_INVALID_VALUE:
-      return "GL_INVALID_VALUE";
-   case GL_INVALID_ENUM:
-      return "GL_INVALID_ENUM";
-   case GL_INVALID_OPERATION:
-      return "GL_INVALID_OPERATION";
-   case GL_STACK_OVERFLOW:
-      return "GL_STACK_OVERFLOW";
-   case GL_STACK_UNDERFLOW:
-      return "GL_STACK_UNDERFLOW";
-   case GL_OUT_OF_MEMORY:
-      return "GL_OUT_OF_MEMORY";
-   case GL_TABLE_TOO_LARGE:
-      return "GL_TABLE_TOO_LARGE";
-   case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
-      return "GL_INVALID_FRAMEBUFFER_OPERATION";
-   default:
-      return "unknown";
-   }
-}
-
-
-/**
- * When a new type of error is recorded, print a message describing
- * previous errors which were accumulated.
- */
-static void
-flush_delayed_errors( struct gl_context *ctx )
-{
-   char s[MAXSTRING];
-
-   if (ctx->ErrorDebugCount) {
-      _mesa_snprintf(s, MAXSTRING, "%d similar %s errors", 
-                     ctx->ErrorDebugCount,
-                     error_string(ctx->ErrorValue));
-
-      output_if_debug("Mesa", s, GL_TRUE);
-
-      ctx->ErrorDebugCount = 0;
-   }
-}
-
-
-/**
- * Report a warning (a recoverable error condition) to stderr if
- * either DEBUG is defined or the MESA_DEBUG env var is set.
- *
- * \param ctx GL context.
- * \param fmtString printf()-like format string.
- */
-void
-_mesa_warning( struct gl_context *ctx, const char *fmtString, ... )
-{
-   char str[MAXSTRING];
-   va_list args;
-   va_start( args, fmtString );  
-   (void) vsnprintf( str, MAXSTRING, fmtString, args );
-   va_end( args );
-   
-   if (ctx)
-      flush_delayed_errors( ctx );
-
-   output_if_debug("Mesa warning", str, GL_TRUE);
-}
-
-
-/**
- * Report an internal implementation problem.
- * Prints the message to stderr via fprintf().
- *
- * \param ctx GL context.
- * \param fmtString problem description string.
- */
-void
-_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )
-{
-   va_list args;
-   char str[MAXSTRING];
-   (void) ctx;
-
-   va_start( args, fmtString );  
-   vsnprintf( str, MAXSTRING, fmtString, args );
-   va_end( args );
-
-   fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
-   fprintf(stderr, "Please report at bugs.freedesktop.org\n");
-}
-
-
-/**
- * Record an OpenGL state error.  These usually occur when the user
- * passes invalid parameters to a GL function.
- *
- * If debugging is enabled (either at compile-time via the DEBUG macro, or
- * run-time via the MESA_DEBUG environment variable), report the error with
- * _mesa_debug().
- * 
- * \param ctx the GL context.
- * \param error the error value.
- * \param fmtString printf() style format string, followed by optional args
- */
-void
-_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
-{
-   static GLint debug = -1;
-
-   /* Check debug environment variable only once:
-    */
-   if (debug == -1) {
-      const char *debugEnv = _mesa_getenv("MESA_DEBUG");
-
-#ifdef DEBUG
-      if (debugEnv && strstr(debugEnv, "silent"))
-         debug = GL_FALSE;
-      else
-         debug = GL_TRUE;
-#else
-      if (debugEnv)
-         debug = GL_TRUE;
-      else
-         debug = GL_FALSE;
-#endif
-   }
-
-   if (debug) {      
-      if (ctx->ErrorValue == error &&
-          ctx->ErrorDebugFmtString == fmtString) {
-         ctx->ErrorDebugCount++;
-      }
-      else {
-         char s[MAXSTRING], s2[MAXSTRING];
-         va_list args;
-
-         flush_delayed_errors( ctx );
-         
-         va_start(args, fmtString);
-         vsnprintf(s, MAXSTRING, fmtString, args);
-         va_end(args);
-
-         _mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);
-         output_if_debug("Mesa: User error", s2, GL_TRUE);
-         
-         ctx->ErrorDebugFmtString = fmtString;
-         ctx->ErrorDebugCount = 0;
-      }
-   }
-
-   _mesa_record_error(ctx, error);
-}
-
-
-/**
- * Report debug information.  Print error message to stderr via fprintf().
- * No-op if DEBUG mode not enabled.
- * 
- * \param ctx GL context.
- * \param fmtString printf()-style format string, followed by optional args.
- */
-void
-_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... )
-{
-#ifdef DEBUG
-   char s[MAXSTRING];
-   va_list args;
-   va_start(args, fmtString);
-   vsnprintf(s, MAXSTRING, fmtString, args);
-   va_end(args);
-   output_if_debug("Mesa", s, GL_FALSE);
-#endif /* DEBUG */
-   (void) ctx;
-   (void) fmtString;
-}
-
-/*@}*/
+/**

+ * \file imports.c

+ * Standard C library function wrappers.

+ * 

+ * Imports are services which the device driver or window system or

+ * operating system provides to the core renderer.  The core renderer (Mesa)

+ * will call these functions in order to do memory allocation, simple I/O,

+ * etc.

+ *

+ * Some drivers will want to override/replace this file with something

+ * specialized, but that'll be rare.

+ *

+ * Eventually, I want to move roll the glheader.h file into this.

+ *

+ * \todo Functions still needed:

+ * - scanf

+ * - qsort

+ * - rand and RAND_MAX

+ */

+

+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+

+#include "imports.h"

+#include "context.h"

+#include "mtypes.h"

+#include "version.h"

+

+#ifdef _GNU_SOURCE

+#include <locale.h>

+#ifdef __APPLE__

+#include <xlocale.h>

+#endif

+#endif

+

+

+#define MAXSTRING 4000  /* for vsnprintf() */

+

+#ifdef WIN32

+#define vsnprintf _vsnprintf

+#elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )

+extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);

+#ifdef __VMS

+#include "vsnprintf.c"

+#endif

+#endif

+

+/**********************************************************************/

+/** \name Memory */

+/*@{*/

+

+/**

+ * Allocate aligned memory.

+ *

+ * \param bytes number of bytes to allocate.

+ * \param alignment alignment (must be greater than zero).

+ * 

+ * Allocates extra memory to accommodate rounding up the address for

+ * alignment and to record the real malloc address.

+ *

+ * \sa _mesa_align_free().

+ */

+void *

+_mesa_align_malloc(size_t bytes, unsigned long alignment)

+{

+#if defined(HAVE_POSIX_MEMALIGN)

+   void *mem;

+   int err = posix_memalign(& mem, alignment, bytes);

+   if (err)

+      return NULL;

+   return mem;

+#elif defined(_WIN32) && defined(_MSC_VER)

+   return _aligned_malloc(bytes, alignment);

+#else

+   uintptr_t ptr, buf;

+

+   ASSERT( alignment > 0 );

+

+   ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *));

+   if (!ptr)

+      return NULL;

+

+   buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);

+   *(uintptr_t *)(buf - sizeof(void *)) = ptr;

+

+#ifdef DEBUG

+   /* mark the non-aligned area */

+   while ( ptr < buf - sizeof(void *) ) {

+      *(unsigned long *)ptr = 0xcdcdcdcd;

+      ptr += sizeof(unsigned long);

+   }

+#endif

+

+   return (void *) buf;

+#endif /* defined(HAVE_POSIX_MEMALIGN) */

+}

+

+/**

+ * Same as _mesa_align_malloc(), but using calloc(1, ) instead of

+ * malloc()

+ */

+void *

+_mesa_align_calloc(size_t bytes, unsigned long alignment)

+{

+#if defined(HAVE_POSIX_MEMALIGN)

+   void *mem;

+   

+   mem = _mesa_align_malloc(bytes, alignment);

+   if (mem != NULL) {

+      (void) memset(mem, 0, bytes);

+   }

+

+   return mem;

+#elif defined(_WIN32) && defined(_MSC_VER)

+   void *mem;

+

+   mem = _aligned_malloc(bytes, alignment);

+   if (mem != NULL) {

+      (void) memset(mem, 0, bytes);

+   }

+

+   return mem;

+#else

+   uintptr_t ptr, buf;

+

+   ASSERT( alignment > 0 );

+

+   ptr = (uintptr_t) calloc(1, bytes + alignment + sizeof(void *));

+   if (!ptr)

+      return NULL;

+

+   buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);

+   *(uintptr_t *)(buf - sizeof(void *)) = ptr;

+

+#ifdef DEBUG

+   /* mark the non-aligned area */

+   while ( ptr < buf - sizeof(void *) ) {

+      *(unsigned long *)ptr = 0xcdcdcdcd;

+      ptr += sizeof(unsigned long);

+   }

+#endif

+

+   return (void *)buf;

+#endif /* defined(HAVE_POSIX_MEMALIGN) */

+}

+

+/**

+ * Free memory which was allocated with either _mesa_align_malloc()

+ * or _mesa_align_calloc().

+ * \param ptr pointer to the memory to be freed.

+ * The actual address to free is stored in the word immediately before the

+ * address the client sees.

+ */

+void

+_mesa_align_free(void *ptr)

+{

+#if defined(HAVE_POSIX_MEMALIGN)

+   free(ptr);

+#elif defined(_WIN32) && defined(_MSC_VER)

+   _aligned_free(ptr);

+#else

+   void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));

+   void *realAddr = *cubbyHole;

+   free(realAddr);

+#endif /* defined(HAVE_POSIX_MEMALIGN) */

+}

+

+/**

+ * Reallocate memory, with alignment.

+ */

+void *

+_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,

+                    unsigned long alignment)

+{

+#if defined(_WIN32) && defined(_MSC_VER)

+   (void) oldSize;

+   return _aligned_realloc(oldBuffer, newSize, alignment);

+#else

+   const size_t copySize = (oldSize < newSize) ? oldSize : newSize;

+   void *newBuf = _mesa_align_malloc(newSize, alignment);

+   if (newBuf && oldBuffer && copySize > 0) {

+      memcpy(newBuf, oldBuffer, copySize);

+   }

+   if (oldBuffer)

+      _mesa_align_free(oldBuffer);

+   return newBuf;

+#endif

+}

+

+

+

+/** Reallocate memory */

+void *

+_mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize)

+{

+   const size_t copySize = (oldSize < newSize) ? oldSize : newSize;

+   void *newBuffer = malloc(newSize);

+   if (newBuffer && oldBuffer && copySize > 0)

+      memcpy(newBuffer, oldBuffer, copySize);

+   if (oldBuffer)

+      free(oldBuffer);

+   return newBuffer;

+}

+

+/**

+ * Fill memory with a constant 16bit word.

+ * \param dst destination pointer.

+ * \param val value.

+ * \param n number of words.

+ */

+void

+_mesa_memset16( unsigned short *dst, unsigned short val, size_t n )

+{

+   while (n-- > 0)

+      *dst++ = val;

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Math */

+/*@{*/

+

+/** Wrapper around sqrt() */

+double

+_mesa_sqrtd(double x)

+{

+   return sqrt(x);

+}

+

+

+/*

+ * A High Speed, Low Precision Square Root

+ * by Paul Lalonde and Robert Dawson

+ * from "Graphics Gems", Academic Press, 1990

+ *

+ * SPARC implementation of a fast square root by table

+ * lookup.

+ * SPARC floating point format is as follows:

+ *

+ * BIT 31 	30 	23 	22 	0

+ *     sign	exponent	mantissa

+ */

+static short sqrttab[0x100];    /* declare table of square roots */

+

+void

+_mesa_init_sqrt_table(void)

+{

+#if defined(USE_IEEE) && !defined(DEBUG)

+   unsigned short i;

+   fi_type fi;     /* to access the bits of a float in  C quickly  */

+                   /* we use a union defined in glheader.h         */

+

+   for(i=0; i<= 0x7f; i++) {

+      fi.i = 0;

+

+      /*

+       * Build a float with the bit pattern i as mantissa

+       * and an exponent of 0, stored as 127

+       */

+

+      fi.i = (i << 16) | (127 << 23);

+      fi.f = _mesa_sqrtd(fi.f);

+

+      /*

+       * Take the square root then strip the first 7 bits of

+       * the mantissa into the table

+       */

+

+      sqrttab[i] = (fi.i & 0x7fffff) >> 16;

+

+      /*

+       * Repeat the process, this time with an exponent of

+       * 1, stored as 128

+       */

+

+      fi.i = 0;

+      fi.i = (i << 16) | (128 << 23);

+      fi.f = sqrt(fi.f);

+      sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;

+   }

+#else

+   (void) sqrttab;  /* silence compiler warnings */

+#endif /*HAVE_FAST_MATH*/

+}

+

+

+/**

+ * Single precision square root.

+ */

+float

+_mesa_sqrtf( float x )

+{

+#if defined(USE_IEEE) && !defined(DEBUG)

+   fi_type num;

+                                /* to access the bits of a float in C

+                                 * we use a union from glheader.h     */

+

+   short e;                     /* the exponent */

+   if (x == 0.0F) return 0.0F;  /* check for square root of 0 */

+   num.f = x;

+   e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */

+                                /* exponent is stored with 127 added */

+   num.i &= 0x7fffff;           /* leave only the mantissa */

+   if (e & 0x01) num.i |= 0x800000;

+                                /* the exponent is odd so we have to */

+                                /* look it up in the second half of  */

+                                /* the lookup table, so we set the   */

+                                /* high bit                                */

+   e >>= 1;                     /* divide the exponent by two */

+                                /* note that in C the shift */

+                                /* operators are sign preserving */

+                                /* for signed operands */

+   /* Do the table lookup, based on the quaternary mantissa,

+    * then reconstruct the result back into a float

+    */

+   num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);

+

+   return num.f;

+#else

+   return (float) _mesa_sqrtd((double) x);

+#endif

+}

+

+

+/**

+ inv_sqrt - A single precision 1/sqrt routine for IEEE format floats.

+ written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk

+ and Vesa Karvonen.

+*/

+float

+_mesa_inv_sqrtf(float n)

+{

+#if defined(USE_IEEE) && !defined(DEBUG)

+        float r0, x0, y0;

+        float r1, x1, y1;

+        float r2, x2, y2;

+#if 0 /* not used, see below -BP */

+        float r3, x3, y3;

+#endif

+        fi_type u;

+        unsigned int magic;

+

+        /*

+         Exponent part of the magic number -

+

+         We want to:

+         1. subtract the bias from the exponent,

+         2. negate it

+         3. divide by two (rounding towards -inf)

+         4. add the bias back

+

+         Which is the same as subtracting the exponent from 381 and dividing

+         by 2.

+

+         floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2)

+        */

+

+        magic = 381 << 23;

+

+        /*

+         Significand part of magic number -

+

+         With the current magic number, "(magic - u.i) >> 1" will give you:

+

+         for 1 <= u.f <= 2: 1.25 - u.f / 4

+         for 2 <= u.f <= 4: 1.00 - u.f / 8

+

+         This isn't a bad approximation of 1/sqrt.  The maximum difference from

+         1/sqrt will be around .06.  After three Newton-Raphson iterations, the

+         maximum difference is less than 4.5e-8.  (Which is actually close

+         enough to make the following bias academic...)

+

+         To get a better approximation you can add a bias to the magic

+         number.  For example, if you subtract 1/2 of the maximum difference in

+         the first approximation (.03), you will get the following function:

+

+         for 1 <= u.f <= 2:    1.22 - u.f / 4

+         for 2 <= u.f <= 3.76: 0.97 - u.f / 8

+         for 3.76 <= u.f <= 4: 0.72 - u.f / 16

+         (The 3.76 to 4 range is where the result is < .5.)

+

+         This is the closest possible initial approximation, but with a maximum

+         error of 8e-11 after three NR iterations, it is still not perfect.  If

+         you subtract 0.0332281 instead of .03, the maximum error will be

+         2.5e-11 after three NR iterations, which should be about as close as

+         is possible.

+

+         for 1 <= u.f <= 2:    1.2167719 - u.f / 4

+         for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8

+         for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16

+

+        */

+

+        magic -= (int)(0.0332281 * (1 << 25));

+

+        u.f = n;

+        u.i = (magic - u.i) >> 1;

+

+        /*

+         Instead of Newton-Raphson, we use Goldschmidt's algorithm, which

+         allows more parallelism.  From what I understand, the parallelism

+         comes at the cost of less precision, because it lets error

+         accumulate across iterations.

+        */

+        x0 = 1.0f;

+        y0 = 0.5f * n;

+        r0 = u.f;

+

+        x1 = x0 * r0;

+        y1 = y0 * r0 * r0;

+        r1 = 1.5f - y1;

+

+        x2 = x1 * r1;

+        y2 = y1 * r1 * r1;

+        r2 = 1.5f - y2;

+

+#if 1

+        return x2 * r2;  /* we can stop here, and be conformant -BP */

+#else

+        x3 = x2 * r2;

+        y3 = y2 * r2 * r2;

+        r3 = 1.5f - y3;

+

+        return x3 * r3;

+#endif

+#else

+        return (float) (1.0 / sqrt(n));

+#endif

+}

+

+#ifndef __GNUC__

+/**

+ * Find the first bit set in a word.

+ */

+int

+_mesa_ffs(int32_t i)

+{

+#if (defined(_WIN32) ) || defined(__IBMC__) || defined(__IBMCPP__)

+   register int bit = 0;

+   if (i != 0) {

+      if ((i & 0xffff) == 0) {

+         bit += 16;

+         i >>= 16;

+      }

+      if ((i & 0xff) == 0) {

+         bit += 8;

+         i >>= 8;

+      }

+      if ((i & 0xf) == 0) {

+         bit += 4;

+         i >>= 4;

+      }

+      while ((i & 1) == 0) {

+         bit++;

+         i >>= 1;

+      }

+      bit++;

+   }

+   return bit;

+#else

+   return ffs(i);

+#endif

+}

+

+

+/**

+ * Find position of first bit set in given value.

+ * XXX Warning: this function can only be used on 64-bit systems!

+ * \return  position of least-significant bit set, starting at 1, return zero

+ *          if no bits set.

+ */

+int

+_mesa_ffsll(int64_t val)

+{

+   int bit;

+

+   assert(sizeof(val) == 8);

+

+   bit = _mesa_ffs((int32_t)val);

+   if (bit != 0)

+      return bit;

+

+   bit = _mesa_ffs((int32_t)(val >> 32));

+   if (bit != 0)

+      return 32 + bit;

+

+   return 0;

+}

+

+

+#if ((_GNUC__ == 3 && __GNUC_MINOR__ < 4) || __GNUC__ < 4)

+/**

+ * Return number of bits set in given GLuint.

+ */

+unsigned int

+_mesa_bitcount(unsigned int n)

+{

+   unsigned int bits;

+   for (bits = 0; n > 0; n = n >> 1) {

+      bits += (n & 1);

+   }

+   return bits;

+}

+#endif

+#endif

+

+

+/**

+ * Convert a 4-byte float to a 2-byte half float.

+ * Based on code from:

+ * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html

+ */

+GLhalfARB

+_mesa_float_to_half(float val)

+{

+   const fi_type fi = {val};

+   const int flt_m = fi.i & 0x7fffff;

+   const int flt_e = (fi.i >> 23) & 0xff;

+   const int flt_s = (fi.i >> 31) & 0x1;

+   int s, e, m = 0;

+   GLhalfARB result;

+   

+   /* sign bit */

+   s = flt_s;

+

+   /* handle special cases */

+   if ((flt_e == 0) && (flt_m == 0)) {

+      /* zero */

+      /* m = 0; - already set */

+      e = 0;

+   }

+   else if ((flt_e == 0) && (flt_m != 0)) {

+      /* denorm -- denorm float maps to 0 half */

+      /* m = 0; - already set */

+      e = 0;

+   }

+   else if ((flt_e == 0xff) && (flt_m == 0)) {

+      /* infinity */

+      /* m = 0; - already set */

+      e = 31;

+   }

+   else if ((flt_e == 0xff) && (flt_m != 0)) {

+      /* NaN */

+      m = 1;

+      e = 31;

+   }

+   else {

+      /* regular number */

+      const int new_exp = flt_e - 127;

+      if (new_exp < -24) {

+         /* this maps to 0 */

+         /* m = 0; - already set */

+         e = 0;

+      }

+      else if (new_exp < -14) {

+         /* this maps to a denorm */

+         unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/

+         e = 0;

+         switch (exp_val) {

+            case 0:

+               _mesa_warning(NULL,

+                   "float_to_half: logical error in denorm creation!\n");

+               /* m = 0; - already set */

+               break;

+            case 1: m = 512 + (flt_m >> 14); break;

+            case 2: m = 256 + (flt_m >> 15); break;

+            case 3: m = 128 + (flt_m >> 16); break;

+            case 4: m = 64 + (flt_m >> 17); break;

+            case 5: m = 32 + (flt_m >> 18); break;

+            case 6: m = 16 + (flt_m >> 19); break;

+            case 7: m = 8 + (flt_m >> 20); break;

+            case 8: m = 4 + (flt_m >> 21); break;

+            case 9: m = 2 + (flt_m >> 22); break;

+            case 10: m = 1; break;

+         }

+      }

+      else if (new_exp > 15) {

+         /* map this value to infinity */

+         /* m = 0; - already set */

+         e = 31;

+      }

+      else {

+         /* regular */

+         e = new_exp + 15;

+         m = flt_m >> 13;

+      }

+   }

+

+   result = (s << 15) | (e << 10) | m;

+   return result;

+}

+

+

+/**

+ * Convert a 2-byte half float to a 4-byte float.

+ * Based on code from:

+ * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html

+ */

+float

+_mesa_half_to_float(GLhalfARB val)

+{

+   /* XXX could also use a 64K-entry lookup table */

+   const int m = val & 0x3ff;

+   const int e = (val >> 10) & 0x1f;

+   const int s = (val >> 15) & 0x1;

+   int flt_m, flt_e, flt_s;

+   fi_type fi;

+   float result;

+

+   /* sign bit */

+   flt_s = s;

+

+   /* handle special cases */

+   if ((e == 0) && (m == 0)) {

+      /* zero */

+      flt_m = 0;

+      flt_e = 0;

+   }

+   else if ((e == 0) && (m != 0)) {

+      /* denorm -- denorm half will fit in non-denorm single */

+      const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */

+      float mantissa = ((float) (m)) / 1024.0f;

+      float sign = s ? -1.0f : 1.0f;

+      return sign * mantissa * half_denorm;

+   }

+   else if ((e == 31) && (m == 0)) {

+      /* infinity */

+      flt_e = 0xff;

+      flt_m = 0;

+   }

+   else if ((e == 31) && (m != 0)) {

+      /* NaN */

+      flt_e = 0xff;

+      flt_m = 1;

+   }

+   else {

+      /* regular */

+      flt_e = e + 112;

+      flt_m = m << 13;

+   }

+

+   fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;

+   result = fi.f;

+   return result;

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Sort & Search */

+/*@{*/

+

+/**

+ * Wrapper for bsearch().

+ */

+void *

+_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 

+               int (*compar)(const void *, const void *) )

+{

+#if defined(_WIN32_WCE)

+   void *mid;

+   int cmp;

+   while (nmemb) {

+      nmemb >>= 1;

+      mid = (char *)base + nmemb * size;

+      cmp = (*compar)(key, mid);

+      if (cmp == 0)

+	 return mid;

+      if (cmp > 0) {

+	 base = (char *)mid + size;

+	 --nmemb;

+      }

+   }

+   return NULL;

+#else

+   return bsearch(key, base, nmemb, size, compar);

+#endif

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Environment vars */

+/*@{*/

+

+/**

+ * Wrapper for getenv().

+ */

+char *

+_mesa_getenv( const char *var )

+{

+#if defined(_XBOX) || defined(_WIN32_WCE)

+   return NULL;

+#else

+   return getenv(var);

+#endif

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name String */

+/*@{*/

+

+/**

+ * Implemented using malloc() and strcpy.

+ * Note that NULL is handled accordingly.

+ */

+char *

+_mesa_strdup( const char *s )

+{

+   if (s) {

+      size_t l = strlen(s);

+      char *s2 = (char *) malloc(l + 1);

+      if (s2)

+         strcpy(s2, s);

+      return s2;

+   }

+   else {

+      return NULL;

+   }

+}

+

+/** Wrapper around strtof() */

+float

+_mesa_strtof( const char *s, char **end )

+{

+#if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__)

+   static locale_t loc = NULL;

+   if (!loc) {

+      loc = newlocale(LC_CTYPE_MASK, "C", NULL);

+   }

+   return strtof_l(s, end, loc);

+#elif defined(_ISOC99_SOURCE) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)

+   return strtof(s, end);

+#else

+   return (float)strtod(s, end);

+#endif

+}

+

+/** Compute simple checksum/hash for a string */

+unsigned int

+_mesa_str_checksum(const char *str)

+{

+   /* This could probably be much better */

+   unsigned int sum, i;

+   const char *c;

+   sum = i = 1;

+   for (c = str; *c; c++, i++)

+      sum += *c * (i % 100);

+   return sum + i;

+}

+

+

+/*@}*/

+

+

+/** Wrapper around vsnprintf() */

+int

+_mesa_snprintf( char *str, size_t size, const char *fmt, ... )

+{

+   int r;

+   va_list args;

+   va_start( args, fmt );  

+   r = vsnprintf( str, size, fmt, args );

+   va_end( args );

+   return r;

+}

+

+

+/**********************************************************************/

+/** \name Diagnostics */

+/*@{*/

+

+static void

+output_if_debug(const char *prefixString, const char *outputString,

+                GLboolean newline)

+{

+   static int debug = -1;

+

+   /* Check the MESA_DEBUG environment variable if it hasn't

+    * been checked yet.  We only have to check it once...

+    */

+   if (debug == -1) {

+      char *env = _mesa_getenv("MESA_DEBUG");

+

+      /* In a debug build, we print warning messages *unless*

+       * MESA_DEBUG is 0.  In a non-debug build, we don't

+       * print warning messages *unless* MESA_DEBUG is

+       * set *to any value*.

+       */

+#ifdef DEBUG

+      debug = (env != NULL && atoi(env) == 0) ? 0 : 1;

+#else

+      debug = (env != NULL) ? 1 : 0;

+#endif

+   }

+

+   /* Now only print the string if we're required to do so. */

+   if (debug) {

+      fprintf(stderr, "%s: %s", prefixString, outputString);

+      if (newline)

+         fprintf(stderr, "\n");

+

+#if defined(_WIN32) && !defined(_WIN32_WCE)

+      /* stderr from windows applications without console is not usually 

+       * visible, so communicate with the debugger instead */ 

+      {

+         char buf[4096];

+         _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");

+         OutputDebugStringA(buf);

+      }

+#endif

+   }

+}

+

+

+/**

+ * Return string version of GL error code.

+ */

+static const char *

+error_string( GLenum error )

+{

+   switch (error) {

+   case GL_NO_ERROR:

+      return "GL_NO_ERROR";

+   case GL_INVALID_VALUE:

+      return "GL_INVALID_VALUE";

+   case GL_INVALID_ENUM:

+      return "GL_INVALID_ENUM";

+   case GL_INVALID_OPERATION:

+      return "GL_INVALID_OPERATION";

+   case GL_STACK_OVERFLOW:

+      return "GL_STACK_OVERFLOW";

+   case GL_STACK_UNDERFLOW:

+      return "GL_STACK_UNDERFLOW";

+   case GL_OUT_OF_MEMORY:

+      return "GL_OUT_OF_MEMORY";

+   case GL_TABLE_TOO_LARGE:

+      return "GL_TABLE_TOO_LARGE";

+   case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:

+      return "GL_INVALID_FRAMEBUFFER_OPERATION";

+   default:

+      return "unknown";

+   }

+}

+

+

+/**

+ * When a new type of error is recorded, print a message describing

+ * previous errors which were accumulated.

+ */

+static void

+flush_delayed_errors( struct gl_context *ctx )

+{

+   char s[MAXSTRING];

+

+   if (ctx->ErrorDebugCount) {

+      _mesa_snprintf(s, MAXSTRING, "%d similar %s errors", 

+                     ctx->ErrorDebugCount,

+                     error_string(ctx->ErrorValue));

+

+      output_if_debug("Mesa", s, GL_TRUE);

+

+      ctx->ErrorDebugCount = 0;

+   }

+}

+

+

+/**

+ * Report a warning (a recoverable error condition) to stderr if

+ * either DEBUG is defined or the MESA_DEBUG env var is set.

+ *

+ * \param ctx GL context.

+ * \param fmtString printf()-like format string.

+ */

+void

+_mesa_warning( struct gl_context *ctx, const char *fmtString, ... )

+{

+   char str[MAXSTRING];

+   va_list args;

+   va_start( args, fmtString );  

+   (void) vsnprintf( str, MAXSTRING, fmtString, args );

+   va_end( args );

+   

+   if (ctx)

+      flush_delayed_errors( ctx );

+

+   output_if_debug("Mesa warning", str, GL_TRUE);

+}

+

+

+/**

+ * Report an internal implementation problem.

+ * Prints the message to stderr via fprintf().

+ *

+ * \param ctx GL context.

+ * \param fmtString problem description string.

+ */

+void

+_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )

+{

+   va_list args;

+   char str[MAXSTRING];

+   (void) ctx;

+

+   va_start( args, fmtString );  

+   vsnprintf( str, MAXSTRING, fmtString, args );

+   va_end( args );

+

+   fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);

+   fprintf(stderr, "Please report at bugs.freedesktop.org\n");

+}

+

+

+/**

+ * Record an OpenGL state error.  These usually occur when the user

+ * passes invalid parameters to a GL function.

+ *

+ * If debugging is enabled (either at compile-time via the DEBUG macro, or

+ * run-time via the MESA_DEBUG environment variable), report the error with

+ * _mesa_debug().

+ * 

+ * \param ctx the GL context.

+ * \param error the error value.

+ * \param fmtString printf() style format string, followed by optional args

+ */

+void

+_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )

+{

+   static GLint debug = -1;

+

+   /* Check debug environment variable only once:

+    */

+   if (debug == -1) {

+      const char *debugEnv = _mesa_getenv("MESA_DEBUG");

+

+#ifdef DEBUG

+      if (debugEnv && strstr(debugEnv, "silent"))

+         debug = GL_FALSE;

+      else

+         debug = GL_TRUE;

+#else

+      if (debugEnv)

+         debug = GL_TRUE;

+      else

+         debug = GL_FALSE;

+#endif

+   }

+

+   if (debug) {      

+      if (ctx->ErrorValue == error &&

+          ctx->ErrorDebugFmtString == fmtString) {

+         ctx->ErrorDebugCount++;

+      }

+      else {

+         char s[MAXSTRING], s2[MAXSTRING];

+         va_list args;

+

+         flush_delayed_errors( ctx );

+         

+         va_start(args, fmtString);

+         vsnprintf(s, MAXSTRING, fmtString, args);

+         va_end(args);

+

+         _mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);

+         output_if_debug("Mesa: User error", s2, GL_TRUE);

+         

+         ctx->ErrorDebugFmtString = fmtString;

+         ctx->ErrorDebugCount = 0;

+      }

+   }

+

+   _mesa_record_error(ctx, error);

+}

+

+

+/**

+ * Report debug information.  Print error message to stderr via fprintf().

+ * No-op if DEBUG mode not enabled.

+ * 

+ * \param ctx GL context.

+ * \param fmtString printf()-style format string, followed by optional args.

+ */

+void

+_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... )

+{

+#ifdef DEBUG

+   char s[MAXSTRING];

+   va_list args;

+   va_start(args, fmtString);

+   vsnprintf(s, MAXSTRING, fmtString, args);

+   va_end(args);

+   output_if_debug("Mesa", s, GL_FALSE);

+#endif /* DEBUG */

+   (void) ctx;

+   (void) fmtString;

+}

+

+/*@}*/

diff --git a/mesalib/src/mesa/main/imports.h b/mesalib/src/mesa/main/imports.h
index ce7baabe2..315c4119d 100644
--- a/mesalib/src/mesa/main/imports.h
+++ b/mesalib/src/mesa/main/imports.h
@@ -1,621 +1,621 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file imports.h
- * Standard C library function wrappers.
- *
- * This file provides wrappers for all the standard C library functions
- * like malloc(), free(), printf(), getenv(), etc.
- */
-
-
-#ifndef IMPORTS_H
-#define IMPORTS_H
-
-
-#include "compiler.h"
-#include "glheader.h"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**********************************************************************/
-/** Memory macros */
-/*@{*/
-
-/** Allocate \p BYTES bytes */
-#define MALLOC(BYTES)      malloc(BYTES)
-/** Allocate and zero \p BYTES bytes */
-#define CALLOC(BYTES)      calloc(1, BYTES)
-/** Allocate a structure of type \p T */
-#define MALLOC_STRUCT(T)   (struct T *) malloc(sizeof(struct T))
-/** Allocate and zero a structure of type \p T */
-#define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
-/** Free memory */
-#define FREE(PTR)          free(PTR)
-
-/*@}*/
-
-
-/*
- * For GL_ARB_vertex_buffer_object we need to treat vertex array pointers
- * as offsets into buffer stores.  Since the vertex array pointer and
- * buffer store pointer are both pointers and we need to add them, we use
- * this macro.
- * Both pointers/offsets are expressed in bytes.
- */
-#define ADD_POINTERS(A, B)  ( (GLubyte *) (A) + (uintptr_t) (B) )
-
-
-/**
- * Sometimes we treat GLfloats as GLints.  On x86 systems, moving a float
- * as a int (thereby using integer registers instead of FP registers) is
- * a performance win.  Typically, this can be done with ordinary casts.
- * But with gcc's -fstrict-aliasing flag (which defaults to on in gcc 3.0)
- * these casts generate warnings.
- * The following union typedef is used to solve that.
- */
-typedef union { GLfloat f; GLint i; } fi_type;
-
-
-
-/**********************************************************************
- * Math macros
- */
-
-#define MAX_GLUSHORT	0xffff
-#define MAX_GLUINT	0xffffffff
-
-/* Degrees to radians conversion: */
-#define DEG2RAD (M_PI/180.0)
-
-
-/***
- *** SQRTF: single-precision square root
- ***/
-#if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */
-#  define SQRTF(X)  _mesa_sqrtf(X)
-#else
-#  define SQRTF(X)  (float) sqrt((float) (X))
-#endif
-
-
-/***
- *** INV_SQRTF: single-precision inverse square root
- ***/
-#if 0
-#define INV_SQRTF(X) _mesa_inv_sqrt(X)
-#else
-#define INV_SQRTF(X) (1.0F / SQRTF(X))  /* this is faster on a P4 */
-#endif
-
-
-/**
- * \name Work-arounds for platforms that lack C99 math functions
- */
-/*@{*/
-#if (!defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE < 600)) && !defined(_ISOC99_SOURCE) \
-   && (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)) \
-   && (!defined(_MSC_VER) || (_MSC_VER < 1400))
-#define acosf(f) ((float) acos(f))
-#define asinf(f) ((float) asin(f))
-#define atan2f(x,y) ((float) atan2(x,y))
-#define atanf(f) ((float) atan(f))
-#define cielf(f) ((float) ciel(f))
-#define cosf(f) ((float) cos(f))
-#define coshf(f) ((float) cosh(f))
-#define expf(f) ((float) exp(f))
-#define exp2f(f) ((float) exp2(f))
-#define floorf(f) ((float) floor(f))
-#define logf(f) ((float) log(f))
-#define log2f(f) ((float) log2(f))
-#define powf(x,y) ((float) pow(x,y))
-#define sinf(f) ((float) sin(f))
-#define sinhf(f) ((float) sinh(f))
-#define sqrtf(f) ((float) sqrt(f))
-#define tanf(f) ((float) tan(f))
-#define tanhf(f) ((float) tanh(f))
-#define acoshf(f) ((float) acosh(f))
-#define asinhf(f) ((float) asinh(f))
-#define atanhf(f) ((float) atanh(f))
-#endif
-
-#if defined(_MSC_VER)
-static INLINE float truncf(float x) { return x < 0.0f ? ceilf(x) : floorf(x); }
-static INLINE float exp2f(float x) { return powf(2.0f, x); }
-static INLINE float log2f(float x) { return logf(x) * 1.442695041f; }
-static INLINE float asinhf(float x) { return logf(x + sqrtf(x * x + 1.0f)); }
-static INLINE float acoshf(float x) { return logf(x + sqrtf(x * x - 1.0f)); }
-static INLINE float atanhf(float x) { return (logf(1.0f + x) - logf(1.0f - x)) / 2.0f; }
-static INLINE int isblank(int ch) { return ch == ' ' || ch == '\t'; }
-#define strtoll(p, e, b) _strtoi64(p, e, b)
-#endif
-/*@}*/
-
-/***
- *** LOG2: Log base 2 of float
- ***/
-#ifdef USE_IEEE
-#if 0
-/* This is pretty fast, but not accurate enough (only 2 fractional bits).
- * Based on code from http://www.stereopsis.com/log2.html
- */
-static INLINE GLfloat LOG2(GLfloat x)
-{
-   const GLfloat y = x * x * x * x;
-   const GLuint ix = *((GLuint *) &y);
-   const GLuint exp = (ix >> 23) & 0xFF;
-   const GLint log2 = ((GLint) exp) - 127;
-   return (GLfloat) log2 * (1.0 / 4.0);  /* 4, because of x^4 above */
-}
-#endif
-/* Pretty fast, and accurate.
- * Based on code from http://www.flipcode.com/totd/
- */
-static INLINE GLfloat LOG2(GLfloat val)
-{
-   fi_type num;
-   GLint log_2;
-   num.f = val;
-   log_2 = ((num.i >> 23) & 255) - 128;
-   num.i &= ~(255 << 23);
-   num.i += 127 << 23;
-   num.f = ((-1.0f/3) * num.f + 2) * num.f - 2.0f/3;
-   return num.f + log_2;
-}
-#else
-/*
- * NOTE: log_base_2(x) = log(x) / log(2)
- * NOTE: 1.442695 = 1/log(2).
- */
-#define LOG2(x)  ((GLfloat) (log(x) * 1.442695F))
-#endif
-
-
-/***
- *** IS_INF_OR_NAN: test if float is infinite or NaN
- ***/
-#ifdef USE_IEEE
-static INLINE int IS_INF_OR_NAN( float x )
-{
-   fi_type tmp;
-   tmp.f = x;
-   return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31);
-}
-#elif defined(isfinite)
-#define IS_INF_OR_NAN(x)        (!isfinite(x))
-#elif defined(finite)
-#define IS_INF_OR_NAN(x)        (!finite(x))
-#elif defined(__VMS)
-#define IS_INF_OR_NAN(x)        (!finite(x))
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#define IS_INF_OR_NAN(x)        (!isfinite(x))
-#else
-#define IS_INF_OR_NAN(x)        (!finite(x))
-#endif
-
-
-/***
- *** IS_NEGATIVE: test if float is negative
- ***/
-#if defined(USE_IEEE)
-static INLINE int GET_FLOAT_BITS( float x )
-{
-   fi_type fi;
-   fi.f = x;
-   return fi.i;
-}
-#define IS_NEGATIVE(x) (GET_FLOAT_BITS(x) < 0)
-#else
-#define IS_NEGATIVE(x) (x < 0.0F)
-#endif
-
-
-/***
- *** DIFFERENT_SIGNS: test if two floats have opposite signs
- ***/
-#if defined(USE_IEEE)
-#define DIFFERENT_SIGNS(x,y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1<<31))
-#else
-/* Could just use (x*y<0) except for the flatshading requirements.
- * Maybe there's a better way?
- */
-#define DIFFERENT_SIGNS(x,y) ((x) * (y) <= 0.0F && (x) - (y) != 0.0F)
-#endif
-
-
-/***
- *** CEILF: ceiling of float
- *** FLOORF: floor of float
- *** FABSF: absolute value of float
- *** LOGF: the natural logarithm (base e) of the value
- *** EXPF: raise e to the value
- *** LDEXPF: multiply value by an integral power of two
- *** FREXPF: extract mantissa and exponent from value
- ***/
-#if defined(__gnu_linux__)
-/* C99 functions */
-#define CEILF(x)   ceilf(x)
-#define FLOORF(x)  floorf(x)
-#define FABSF(x)   fabsf(x)
-#define LOGF(x)    logf(x)
-#define EXPF(x)    expf(x)
-#define LDEXPF(x,y)  ldexpf(x,y)
-#define FREXPF(x,y)  frexpf(x,y)
-#else
-#define CEILF(x)   ((GLfloat) ceil(x))
-#define FLOORF(x)  ((GLfloat) floor(x))
-#define FABSF(x)   ((GLfloat) fabs(x))
-#define LOGF(x)    ((GLfloat) log(x))
-#define EXPF(x)    ((GLfloat) exp(x))
-#define LDEXPF(x,y)  ((GLfloat) ldexp(x,y))
-#define FREXPF(x,y)  ((GLfloat) frexp(x,y))
-#endif
-
-
-/***
- *** IROUND: return (as an integer) float rounded to nearest integer
- ***/
-#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)
-static INLINE int iround(float f)
-{
-   int r;
-   __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st");
-   return r;
-}
-#define IROUND(x)  iround(x)
-#elif defined(USE_X86_ASM) && defined(_MSC_VER)
-static INLINE int iround(float f)
-{
-   int r;
-   _asm {
-	 fld f
-	 fistp r
-	}
-   return r;
-}
-#define IROUND(x)  iround(x)
-#elif defined(__WATCOMC__) && defined(__386__)
-long iround(float f);
-#pragma aux iround =                    \
-	"push   eax"                        \
-	"fistp  dword ptr [esp]"            \
-	"pop    eax"                        \
-	parm [8087]                         \
-	value [eax]                         \
-	modify exact [eax];
-#define IROUND(x)  iround(x)
-#else
-#define IROUND(f)  ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
-#endif
-
-#define IROUND64(f)  ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
-
-/***
- *** IROUND_POS: return (as an integer) positive float rounded to nearest int
- ***/
-#ifdef DEBUG
-#define IROUND_POS(f) (assert((f) >= 0.0F), IROUND(f))
-#else
-#define IROUND_POS(f) (IROUND(f))
-#endif
-
-
-/***
- *** IFLOOR: return (as an integer) floor of float
- ***/
-#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)
-/*
- * IEEE floor for computers that round to nearest or even.
- * 'f' must be between -4194304 and 4194303.
- * This floor operation is done by "(iround(f + .5) + iround(f - .5)) >> 1",
- * but uses some IEEE specific tricks for better speed.
- * Contributed by Josh Vanderhoof
- */
-static INLINE int ifloor(float f)
-{
-   int ai, bi;
-   double af, bf;
-   af = (3 << 22) + 0.5 + (double)f;
-   bf = (3 << 22) + 0.5 - (double)f;
-   /* GCC generates an extra fstp/fld without this. */
-   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");
-   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");
-   return (ai - bi) >> 1;
-}
-#define IFLOOR(x)  ifloor(x)
-#elif defined(USE_IEEE)
-static INLINE int ifloor(float f)
-{
-   int ai, bi;
-   double af, bf;
-   fi_type u;
-
-   af = (3 << 22) + 0.5 + (double)f;
-   bf = (3 << 22) + 0.5 - (double)f;
-   u.f = (float) af;  ai = u.i;
-   u.f = (float) bf;  bi = u.i;
-   return (ai - bi) >> 1;
-}
-#define IFLOOR(x)  ifloor(x)
-#else
-static INLINE int ifloor(float f)
-{
-   int i = IROUND(f);
-   return (i > f) ? i - 1 : i;
-}
-#define IFLOOR(x)  ifloor(x)
-#endif
-
-
-/***
- *** ICEIL: return (as an integer) ceiling of float
- ***/
-#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)
-/*
- * IEEE ceil for computers that round to nearest or even.
- * 'f' must be between -4194304 and 4194303.
- * This ceil operation is done by "(iround(f + .5) + iround(f - .5) + 1) >> 1",
- * but uses some IEEE specific tricks for better speed.
- * Contributed by Josh Vanderhoof
- */
-static INLINE int iceil(float f)
-{
-   int ai, bi;
-   double af, bf;
-   af = (3 << 22) + 0.5 + (double)f;
-   bf = (3 << 22) + 0.5 - (double)f;
-   /* GCC generates an extra fstp/fld without this. */
-   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");
-   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");
-   return (ai - bi + 1) >> 1;
-}
-#define ICEIL(x)  iceil(x)
-#elif defined(USE_IEEE)
-static INLINE int iceil(float f)
-{
-   int ai, bi;
-   double af, bf;
-   fi_type u;
-   af = (3 << 22) + 0.5 + (double)f;
-   bf = (3 << 22) + 0.5 - (double)f;
-   u.f = (float) af; ai = u.i;
-   u.f = (float) bf; bi = u.i;
-   return (ai - bi + 1) >> 1;
-}
-#define ICEIL(x)  iceil(x)
-#else
-static INLINE int iceil(float f)
-{
-   int i = IROUND(f);
-   return (i < f) ? i + 1 : i;
-}
-#define ICEIL(x)  iceil(x)
-#endif
-
-
-/**
- * Is x a power of two?
- */
-static INLINE int
-_mesa_is_pow_two(int x)
-{
-   return !(x & (x - 1));
-}
-
-/**
- * Round given integer to next higer power of two
- * If X is zero result is undefined.
- *
- * Source for the fallback implementation is
- * Sean Eron Anderson's webpage "Bit Twiddling Hacks"
- * http://graphics.stanford.edu/~seander/bithacks.html
- *
- * When using builtin function have to do some work
- * for case when passed values 1 to prevent hiting
- * undefined result from __builtin_clz. Undefined
- * results would be different depending on optimization
- * level used for build.
- */
-static INLINE int32_t
-_mesa_next_pow_two_32(uint32_t x)
-{
-#if defined(__GNUC__) && \
-	((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)
-	uint32_t y = (x != 1);
-	return (1 + y) << ((__builtin_clz(x - y) ^ 31) );
-#else
-	x--;
-	x |= x >> 1;
-	x |= x >> 2;
-	x |= x >> 4;
-	x |= x >> 8;
-	x |= x >> 16;
-	x++;
-	return x;
-#endif
-}
-
-static INLINE int64_t
-_mesa_next_pow_two_64(uint64_t x)
-{
-#if defined(__GNUC__) && \
-	((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)
-	uint64_t y = (x != 1);
-	if (sizeof(x) == sizeof(long))
-		return (1 + y) << ((__builtin_clzl(x - y) ^ 63));
-	else
-		return (1 + y) << ((__builtin_clzll(x - y) ^ 63));
-#else
-	x--;
-	x |= x >> 1;
-	x |= x >> 2;
-	x |= x >> 4;
-	x |= x >> 8;
-	x |= x >> 16;
-	x |= x >> 32;
-	x++;
-	return x;
-#endif
-}
-
-
-/**
- * Return 1 if this is a little endian machine, 0 if big endian.
- */
-static INLINE GLboolean
-_mesa_little_endian(void)
-{
-   const GLuint ui = 1; /* intentionally not static */
-   return *((const GLubyte *) &ui);
-}
-
-
-
-/**********************************************************************
- * Functions
- */
-
-extern void *
-_mesa_align_malloc( size_t bytes, unsigned long alignment );
-
-extern void *
-_mesa_align_calloc( size_t bytes, unsigned long alignment );
-
-extern void
-_mesa_align_free( void *ptr );
-
-extern void *
-_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
-                    unsigned long alignment);
-
-extern void *
-_mesa_exec_malloc( GLuint size );
-
-extern void 
-_mesa_exec_free( void *addr );
-
-extern void *
-_mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize );
-
-extern void
-_mesa_memset16( unsigned short *dst, unsigned short val, size_t n );
-
-extern double
-_mesa_sqrtd(double x);
-
-extern float
-_mesa_sqrtf(float x);
-
-extern float
-_mesa_inv_sqrtf(float x);
-
-extern void
-_mesa_init_sqrt_table(void);
-
-#ifdef __GNUC__
-
-#ifdef __MINGW32__
-#define ffs __builtin_ffs
-#define ffsll __builtin_ffsll
-#endif
-
-#define _mesa_ffs(i)  ffs(i)
-#define _mesa_ffsll(i)  ffsll(i)
-
-#if ((_GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)
-#define _mesa_bitcount(i) __builtin_popcount(i)
-#else
-extern unsigned int
-_mesa_bitcount(unsigned int n);
-#endif
-
-#else
-extern int
-_mesa_ffs(int32_t i);
-
-extern int
-_mesa_ffsll(int64_t i);
-
-extern unsigned int
-_mesa_bitcount(unsigned int n);
-#endif
-
-extern GLhalfARB
-_mesa_float_to_half(float f);
-
-extern float
-_mesa_half_to_float(GLhalfARB h);
-
-
-extern void *
-_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 
-               int (*compar)(const void *, const void *) );
-
-extern char *
-_mesa_getenv( const char *var );
-
-extern char *
-_mesa_strdup( const char *s );
-
-extern float
-_mesa_strtof( const char *s, char **end );
-
-extern unsigned int
-_mesa_str_checksum(const char *str);
-
-extern int
-_mesa_snprintf( char *str, size_t size, const char *fmt, ... ) PRINTFLIKE(3, 4);
-
-struct gl_context;
-
-extern void
-_mesa_warning( struct gl_context *gc, const char *fmtString, ... ) PRINTFLIKE(2, 3);
-
-extern void
-_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3);
-
-extern void
-_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) PRINTFLIKE(3, 4);
-
-extern void
-_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3);
-
-
-#if defined(_MSC_VER) && !defined(snprintf)
-#define snprintf _snprintf
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* IMPORTS_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file imports.h

+ * Standard C library function wrappers.

+ *

+ * This file provides wrappers for all the standard C library functions

+ * like malloc(), free(), printf(), getenv(), etc.

+ */

+

+

+#ifndef IMPORTS_H

+#define IMPORTS_H

+

+

+#include "compiler.h"

+#include "glheader.h"

+

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+

+/**********************************************************************/

+/** Memory macros */

+/*@{*/

+

+/** Allocate \p BYTES bytes */

+#define MALLOC(BYTES)      malloc(BYTES)

+/** Allocate and zero \p BYTES bytes */

+#define CALLOC(BYTES)      calloc(1, BYTES)

+/** Allocate a structure of type \p T */

+#define MALLOC_STRUCT(T)   (struct T *) malloc(sizeof(struct T))

+/** Allocate and zero a structure of type \p T */

+#define CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))

+/** Free memory */

+#define FREE(PTR)          free(PTR)

+

+/*@}*/

+

+

+/*

+ * For GL_ARB_vertex_buffer_object we need to treat vertex array pointers

+ * as offsets into buffer stores.  Since the vertex array pointer and

+ * buffer store pointer are both pointers and we need to add them, we use

+ * this macro.

+ * Both pointers/offsets are expressed in bytes.

+ */

+#define ADD_POINTERS(A, B)  ( (GLubyte *) (A) + (uintptr_t) (B) )

+

+

+/**

+ * Sometimes we treat GLfloats as GLints.  On x86 systems, moving a float

+ * as a int (thereby using integer registers instead of FP registers) is

+ * a performance win.  Typically, this can be done with ordinary casts.

+ * But with gcc's -fstrict-aliasing flag (which defaults to on in gcc 3.0)

+ * these casts generate warnings.

+ * The following union typedef is used to solve that.

+ */

+typedef union { GLfloat f; GLint i; } fi_type;

+

+

+

+/**********************************************************************

+ * Math macros

+ */

+

+#define MAX_GLUSHORT	0xffff

+#define MAX_GLUINT	0xffffffff

+

+/* Degrees to radians conversion: */

+#define DEG2RAD (M_PI/180.0)

+

+

+/***

+ *** SQRTF: single-precision square root

+ ***/

+#if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */

+#  define SQRTF(X)  _mesa_sqrtf(X)

+#else

+#  define SQRTF(X)  (float) sqrt((float) (X))

+#endif

+

+

+/***

+ *** INV_SQRTF: single-precision inverse square root

+ ***/

+#if 0

+#define INV_SQRTF(X) _mesa_inv_sqrt(X)

+#else

+#define INV_SQRTF(X) (1.0F / SQRTF(X))  /* this is faster on a P4 */

+#endif

+

+

+/**

+ * \name Work-arounds for platforms that lack C99 math functions

+ */

+/*@{*/

+#if (!defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE < 600)) && !defined(_ISOC99_SOURCE) \

+   && (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)) \

+   && (!defined(_MSC_VER) || (_MSC_VER < 1400))

+#define acosf(f) ((float) acos(f))

+#define asinf(f) ((float) asin(f))

+#define atan2f(x,y) ((float) atan2(x,y))

+#define atanf(f) ((float) atan(f))

+#define cielf(f) ((float) ciel(f))

+#define cosf(f) ((float) cos(f))

+#define coshf(f) ((float) cosh(f))

+#define expf(f) ((float) exp(f))

+#define exp2f(f) ((float) exp2(f))

+#define floorf(f) ((float) floor(f))

+#define logf(f) ((float) log(f))

+#define log2f(f) ((float) log2(f))

+#define powf(x,y) ((float) pow(x,y))

+#define sinf(f) ((float) sin(f))

+#define sinhf(f) ((float) sinh(f))

+#define sqrtf(f) ((float) sqrt(f))

+#define tanf(f) ((float) tan(f))

+#define tanhf(f) ((float) tanh(f))

+#define acoshf(f) ((float) acosh(f))

+#define asinhf(f) ((float) asinh(f))

+#define atanhf(f) ((float) atanh(f))

+#endif

+

+#if defined(_MSC_VER)

+static INLINE float truncf(float x) { return x < 0.0f ? ceilf(x) : floorf(x); }

+static INLINE float exp2f(float x) { return powf(2.0f, x); }

+static INLINE float log2f(float x) { return logf(x) * 1.442695041f; }

+static INLINE float asinhf(float x) { return logf(x + sqrtf(x * x + 1.0f)); }

+static INLINE float acoshf(float x) { return logf(x + sqrtf(x * x - 1.0f)); }

+static INLINE float atanhf(float x) { return (logf(1.0f + x) - logf(1.0f - x)) / 2.0f; }

+static INLINE int isblank(int ch) { return ch == ' ' || ch == '\t'; }

+#define strtoll(p, e, b) _strtoi64(p, e, b)

+#endif

+/*@}*/

+

+/***

+ *** LOG2: Log base 2 of float

+ ***/

+#ifdef USE_IEEE

+#if 0

+/* This is pretty fast, but not accurate enough (only 2 fractional bits).

+ * Based on code from http://www.stereopsis.com/log2.html

+ */

+static INLINE GLfloat LOG2(GLfloat x)

+{

+   const GLfloat y = x * x * x * x;

+   const GLuint ix = *((GLuint *) &y);

+   const GLuint exp = (ix >> 23) & 0xFF;

+   const GLint log2 = ((GLint) exp) - 127;

+   return (GLfloat) log2 * (1.0 / 4.0);  /* 4, because of x^4 above */

+}

+#endif

+/* Pretty fast, and accurate.

+ * Based on code from http://www.flipcode.com/totd/

+ */

+static INLINE GLfloat LOG2(GLfloat val)

+{

+   fi_type num;

+   GLint log_2;

+   num.f = val;

+   log_2 = ((num.i >> 23) & 255) - 128;

+   num.i &= ~(255 << 23);

+   num.i += 127 << 23;

+   num.f = ((-1.0f/3) * num.f + 2) * num.f - 2.0f/3;

+   return num.f + log_2;

+}

+#else

+/*

+ * NOTE: log_base_2(x) = log(x) / log(2)

+ * NOTE: 1.442695 = 1/log(2).

+ */

+#define LOG2(x)  ((GLfloat) (log(x) * 1.442695F))

+#endif

+

+

+/***

+ *** IS_INF_OR_NAN: test if float is infinite or NaN

+ ***/

+#ifdef USE_IEEE

+static INLINE int IS_INF_OR_NAN( float x )

+{

+   fi_type tmp;

+   tmp.f = x;

+   return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31);

+}

+#elif defined(isfinite)

+#define IS_INF_OR_NAN(x)        (!isfinite(x))

+#elif defined(finite)

+#define IS_INF_OR_NAN(x)        (!finite(x))

+#elif defined(__VMS)

+#define IS_INF_OR_NAN(x)        (!finite(x))

+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

+#define IS_INF_OR_NAN(x)        (!isfinite(x))

+#else

+#define IS_INF_OR_NAN(x)        (!finite(x))

+#endif

+

+

+/***

+ *** IS_NEGATIVE: test if float is negative

+ ***/

+#if defined(USE_IEEE)

+static INLINE int GET_FLOAT_BITS( float x )

+{

+   fi_type fi;

+   fi.f = x;

+   return fi.i;

+}

+#define IS_NEGATIVE(x) (GET_FLOAT_BITS(x) < 0)

+#else

+#define IS_NEGATIVE(x) (x < 0.0F)

+#endif

+

+

+/***

+ *** DIFFERENT_SIGNS: test if two floats have opposite signs

+ ***/

+#if defined(USE_IEEE)

+#define DIFFERENT_SIGNS(x,y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1<<31))

+#else

+/* Could just use (x*y<0) except for the flatshading requirements.

+ * Maybe there's a better way?

+ */

+#define DIFFERENT_SIGNS(x,y) ((x) * (y) <= 0.0F && (x) - (y) != 0.0F)

+#endif

+

+

+/***

+ *** CEILF: ceiling of float

+ *** FLOORF: floor of float

+ *** FABSF: absolute value of float

+ *** LOGF: the natural logarithm (base e) of the value

+ *** EXPF: raise e to the value

+ *** LDEXPF: multiply value by an integral power of two

+ *** FREXPF: extract mantissa and exponent from value

+ ***/

+#if defined(__gnu_linux__)

+/* C99 functions */

+#define CEILF(x)   ceilf(x)

+#define FLOORF(x)  floorf(x)

+#define FABSF(x)   fabsf(x)

+#define LOGF(x)    logf(x)

+#define EXPF(x)    expf(x)

+#define LDEXPF(x,y)  ldexpf(x,y)

+#define FREXPF(x,y)  frexpf(x,y)

+#else

+#define CEILF(x)   ((GLfloat) ceil(x))

+#define FLOORF(x)  ((GLfloat) floor(x))

+#define FABSF(x)   ((GLfloat) fabs(x))

+#define LOGF(x)    ((GLfloat) log(x))

+#define EXPF(x)    ((GLfloat) exp(x))

+#define LDEXPF(x,y)  ((GLfloat) ldexp(x,y))

+#define FREXPF(x,y)  ((GLfloat) frexp(x,y))

+#endif

+

+

+/***

+ *** IROUND: return (as an integer) float rounded to nearest integer

+ ***/

+#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)

+static INLINE int iround(float f)

+{

+   int r;

+   __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st");

+   return r;

+}

+#define IROUND(x)  iround(x)

+#elif defined(USE_X86_ASM) && defined(_MSC_VER)

+static INLINE int iround(float f)

+{

+   int r;

+   _asm {

+	 fld f

+	 fistp r

+	}

+   return r;

+}

+#define IROUND(x)  iround(x)

+#elif defined(__WATCOMC__) && defined(__386__)

+long iround(float f);

+#pragma aux iround =                    \

+	"push   eax"                        \

+	"fistp  dword ptr [esp]"            \

+	"pop    eax"                        \

+	parm [8087]                         \

+	value [eax]                         \

+	modify exact [eax];

+#define IROUND(x)  iround(x)

+#else

+#define IROUND(f)  ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))

+#endif

+

+#define IROUND64(f)  ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))

+

+/***

+ *** IROUND_POS: return (as an integer) positive float rounded to nearest int

+ ***/

+#ifdef DEBUG

+#define IROUND_POS(f) (assert((f) >= 0.0F), IROUND(f))

+#else

+#define IROUND_POS(f) (IROUND(f))

+#endif

+

+

+/***

+ *** IFLOOR: return (as an integer) floor of float

+ ***/

+#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)

+/*

+ * IEEE floor for computers that round to nearest or even.

+ * 'f' must be between -4194304 and 4194303.

+ * This floor operation is done by "(iround(f + .5) + iround(f - .5)) >> 1",

+ * but uses some IEEE specific tricks for better speed.

+ * Contributed by Josh Vanderhoof

+ */

+static INLINE int ifloor(float f)

+{

+   int ai, bi;

+   double af, bf;

+   af = (3 << 22) + 0.5 + (double)f;

+   bf = (3 << 22) + 0.5 - (double)f;

+   /* GCC generates an extra fstp/fld without this. */

+   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");

+   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");

+   return (ai - bi) >> 1;

+}

+#define IFLOOR(x)  ifloor(x)

+#elif defined(USE_IEEE)

+static INLINE int ifloor(float f)

+{

+   int ai, bi;

+   double af, bf;

+   fi_type u;

+

+   af = (3 << 22) + 0.5 + (double)f;

+   bf = (3 << 22) + 0.5 - (double)f;

+   u.f = (float) af;  ai = u.i;

+   u.f = (float) bf;  bi = u.i;

+   return (ai - bi) >> 1;

+}

+#define IFLOOR(x)  ifloor(x)

+#else

+static INLINE int ifloor(float f)

+{

+   int i = IROUND(f);

+   return (i > f) ? i - 1 : i;

+}

+#define IFLOOR(x)  ifloor(x)

+#endif

+

+

+/***

+ *** ICEIL: return (as an integer) ceiling of float

+ ***/

+#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)

+/*

+ * IEEE ceil for computers that round to nearest or even.

+ * 'f' must be between -4194304 and 4194303.

+ * This ceil operation is done by "(iround(f + .5) + iround(f - .5) + 1) >> 1",

+ * but uses some IEEE specific tricks for better speed.

+ * Contributed by Josh Vanderhoof

+ */

+static INLINE int iceil(float f)

+{

+   int ai, bi;

+   double af, bf;

+   af = (3 << 22) + 0.5 + (double)f;

+   bf = (3 << 22) + 0.5 - (double)f;

+   /* GCC generates an extra fstp/fld without this. */

+   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");

+   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");

+   return (ai - bi + 1) >> 1;

+}

+#define ICEIL(x)  iceil(x)

+#elif defined(USE_IEEE)

+static INLINE int iceil(float f)

+{

+   int ai, bi;

+   double af, bf;

+   fi_type u;

+   af = (3 << 22) + 0.5 + (double)f;

+   bf = (3 << 22) + 0.5 - (double)f;

+   u.f = (float) af; ai = u.i;

+   u.f = (float) bf; bi = u.i;

+   return (ai - bi + 1) >> 1;

+}

+#define ICEIL(x)  iceil(x)

+#else

+static INLINE int iceil(float f)

+{

+   int i = IROUND(f);

+   return (i < f) ? i + 1 : i;

+}

+#define ICEIL(x)  iceil(x)

+#endif

+

+

+/**

+ * Is x a power of two?

+ */

+static INLINE int

+_mesa_is_pow_two(int x)

+{

+   return !(x & (x - 1));

+}

+

+/**

+ * Round given integer to next higer power of two

+ * If X is zero result is undefined.

+ *

+ * Source for the fallback implementation is

+ * Sean Eron Anderson's webpage "Bit Twiddling Hacks"

+ * http://graphics.stanford.edu/~seander/bithacks.html

+ *

+ * When using builtin function have to do some work

+ * for case when passed values 1 to prevent hiting

+ * undefined result from __builtin_clz. Undefined

+ * results would be different depending on optimization

+ * level used for build.

+ */

+static INLINE int32_t

+_mesa_next_pow_two_32(uint32_t x)

+{

+#if defined(__GNUC__) && \

+	((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)

+	uint32_t y = (x != 1);

+	return (1 + y) << ((__builtin_clz(x - y) ^ 31) );

+#else

+	x--;

+	x |= x >> 1;

+	x |= x >> 2;

+	x |= x >> 4;

+	x |= x >> 8;

+	x |= x >> 16;

+	x++;

+	return x;

+#endif

+}

+

+static INLINE int64_t

+_mesa_next_pow_two_64(uint64_t x)

+{

+#if defined(__GNUC__) && \

+	((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)

+	uint64_t y = (x != 1);

+	if (sizeof(x) == sizeof(long))

+		return (1 + y) << ((__builtin_clzl(x - y) ^ 63));

+	else

+		return (1 + y) << ((__builtin_clzll(x - y) ^ 63));

+#else

+	x--;

+	x |= x >> 1;

+	x |= x >> 2;

+	x |= x >> 4;

+	x |= x >> 8;

+	x |= x >> 16;

+	x |= x >> 32;

+	x++;

+	return x;

+#endif

+}

+

+

+/**

+ * Return 1 if this is a little endian machine, 0 if big endian.

+ */

+static INLINE GLboolean

+_mesa_little_endian(void)

+{

+   const GLuint ui = 1; /* intentionally not static */

+   return *((const GLubyte *) &ui);

+}

+

+

+

+/**********************************************************************

+ * Functions

+ */

+

+extern void *

+_mesa_align_malloc( size_t bytes, unsigned long alignment );

+

+extern void *

+_mesa_align_calloc( size_t bytes, unsigned long alignment );

+

+extern void

+_mesa_align_free( void *ptr );

+

+extern void *

+_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,

+                    unsigned long alignment);

+

+extern void *

+_mesa_exec_malloc( GLuint size );

+

+extern void 

+_mesa_exec_free( void *addr );

+

+extern void *

+_mesa_realloc( void *oldBuffer, size_t oldSize, size_t newSize );

+

+extern void

+_mesa_memset16( unsigned short *dst, unsigned short val, size_t n );

+

+extern double

+_mesa_sqrtd(double x);

+

+extern float

+_mesa_sqrtf(float x);

+

+extern float

+_mesa_inv_sqrtf(float x);

+

+extern void

+_mesa_init_sqrt_table(void);

+

+#ifdef __GNUC__

+

+#ifdef __MINGW32__

+#define ffs __builtin_ffs

+#define ffsll __builtin_ffsll

+#endif

+

+#define _mesa_ffs(i)  ffs(i)

+#define _mesa_ffsll(i)  ffsll(i)

+

+#if ((_GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)

+#define _mesa_bitcount(i) __builtin_popcount(i)

+#else

+extern unsigned int

+_mesa_bitcount(unsigned int n);

+#endif

+

+#else

+extern int

+_mesa_ffs(int32_t i);

+

+extern int

+_mesa_ffsll(int64_t i);

+

+extern unsigned int

+_mesa_bitcount(unsigned int n);

+#endif

+

+extern GLhalfARB

+_mesa_float_to_half(float f);

+

+extern float

+_mesa_half_to_float(GLhalfARB h);

+

+

+extern void *

+_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size, 

+               int (*compar)(const void *, const void *) );

+

+extern char *

+_mesa_getenv( const char *var );

+

+extern char *

+_mesa_strdup( const char *s );

+

+extern float

+_mesa_strtof( const char *s, char **end );

+

+extern unsigned int

+_mesa_str_checksum(const char *str);

+

+extern int

+_mesa_snprintf( char *str, size_t size, const char *fmt, ... ) PRINTFLIKE(3, 4);

+

+struct gl_context;

+

+extern void

+_mesa_warning( struct gl_context *gc, const char *fmtString, ... ) PRINTFLIKE(2, 3);

+

+extern void

+_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3);

+

+extern void

+_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) PRINTFLIKE(3, 4);

+

+extern void

+_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3);

+

+

+#if defined(_MSC_VER) && !defined(snprintf)

+#define snprintf _snprintf

+#endif

+

+

+#ifdef __cplusplus

+}

+#endif

+

+

+#endif /* IMPORTS_H */

diff --git a/mesalib/src/mesa/main/lines.c b/mesalib/src/mesa/main/lines.c
index 79bf5679d..1df409f45 100644
--- a/mesalib/src/mesa/main/lines.c
+++ b/mesalib/src/mesa/main/lines.c
@@ -1,117 +1,117 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * Copyright (C) 1999-2006  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "context.h"
-#include "lines.h"
-#include "macros.h"
-#include "mtypes.h"
-
-
-/**
- * Set the line width.
- *
- * \param width line width in pixels.
- *
- * \sa glLineWidth().
- */
-void GLAPIENTRY
-_mesa_LineWidth( GLfloat width )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glLineWidth %f\n", width);
-
-   if (width<=0.0) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glLineWidth" );
-      return;
-   }
-
-   if (ctx->Line.Width == width)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_LINE);
-   ctx->Line.Width = width;
-
-   if (ctx->Driver.LineWidth)
-      ctx->Driver.LineWidth(ctx, width);
-}
-
-
-/**
- * Set the line stipple pattern.
- *
- * \param factor pattern scale factor.
- * \param pattern bit pattern.
- * 
- * \sa glLineStipple().
- *
- * Updates gl_line_attrib::StippleFactor and gl_line_attrib::StipplePattern. On
- * change flushes the vertices and notifies the driver via
- * the dd_function_table::LineStipple callback.
- */
-void GLAPIENTRY
-_mesa_LineStipple( GLint factor, GLushort pattern )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glLineStipple %d %u\n", factor, pattern);
-
-   factor = CLAMP( factor, 1, 256 );
-
-   if (ctx->Line.StippleFactor == factor &&
-       ctx->Line.StipplePattern == pattern)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_LINE);
-   ctx->Line.StippleFactor = factor;
-   ctx->Line.StipplePattern = pattern;
-
-   if (ctx->Driver.LineStipple)
-      ctx->Driver.LineStipple( ctx, factor, pattern );
-}
-
-
-/**
- * Initialize the context line state.
- *
- * \param ctx GL context.
- *
- * Initializes __struct gl_contextRec::Line and line related constants in
- * __struct gl_contextRec::Const.
- */
-void GLAPIENTRY
-_mesa_init_line( struct gl_context * ctx )
-{
-   ctx->Line.SmoothFlag = GL_FALSE;
-   ctx->Line.StippleFlag = GL_FALSE;
-   ctx->Line.Width = 1.0;
-   ctx->Line.StipplePattern = 0xffff;
-   ctx->Line.StippleFactor = 1;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "context.h"

+#include "lines.h"

+#include "macros.h"

+#include "mtypes.h"

+

+

+/**

+ * Set the line width.

+ *

+ * \param width line width in pixels.

+ *

+ * \sa glLineWidth().

+ */

+void GLAPIENTRY

+_mesa_LineWidth( GLfloat width )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glLineWidth %f\n", width);

+

+   if (width<=0.0) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glLineWidth" );

+      return;

+   }

+

+   if (ctx->Line.Width == width)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_LINE);

+   ctx->Line.Width = width;

+

+   if (ctx->Driver.LineWidth)

+      ctx->Driver.LineWidth(ctx, width);

+}

+

+

+/**

+ * Set the line stipple pattern.

+ *

+ * \param factor pattern scale factor.

+ * \param pattern bit pattern.

+ * 

+ * \sa glLineStipple().

+ *

+ * Updates gl_line_attrib::StippleFactor and gl_line_attrib::StipplePattern. On

+ * change flushes the vertices and notifies the driver via

+ * the dd_function_table::LineStipple callback.

+ */

+void GLAPIENTRY

+_mesa_LineStipple( GLint factor, GLushort pattern )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glLineStipple %d %u\n", factor, pattern);

+

+   factor = CLAMP( factor, 1, 256 );

+

+   if (ctx->Line.StippleFactor == factor &&

+       ctx->Line.StipplePattern == pattern)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_LINE);

+   ctx->Line.StippleFactor = factor;

+   ctx->Line.StipplePattern = pattern;

+

+   if (ctx->Driver.LineStipple)

+      ctx->Driver.LineStipple( ctx, factor, pattern );

+}

+

+

+/**

+ * Initialize the context line state.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes __struct gl_contextRec::Line and line related constants in

+ * __struct gl_contextRec::Const.

+ */

+void GLAPIENTRY

+_mesa_init_line( struct gl_context * ctx )

+{

+   ctx->Line.SmoothFlag = GL_FALSE;

+   ctx->Line.StippleFlag = GL_FALSE;

+   ctx->Line.Width = 1.0;

+   ctx->Line.StipplePattern = 0xffff;

+   ctx->Line.StippleFactor = 1;

+}

diff --git a/mesalib/src/mesa/main/mipmap.c b/mesalib/src/mesa/main/mipmap.c
index e594160ad..b12399ee6 100644
--- a/mesalib/src/mesa/main/mipmap.c
+++ b/mesalib/src/mesa/main/mipmap.c
@@ -1,2027 +1,2027 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file mipmap.c  mipmap generation and teximage resizing functions.
- */
-
-#include "imports.h"
-#include "formats.h"
-#include "mipmap.h"
-#include "mtypes.h"
-#include "teximage.h"
-#include "texstore.h"
-#include "image.h"
-
-
-
-static GLint
-bytes_per_pixel(GLenum datatype, GLuint comps)
-{
-   GLint b = _mesa_sizeof_packed_type(datatype);
-   assert(b >= 0);
-
-   if (_mesa_type_is_packed(datatype))
-       return b;
-   else
-       return b * comps;
-}
-
-
-/**
- * \name Support macros for do_row and do_row_3d
- *
- * The macro madness is here for two reasons.  First, it compacts the code
- * slightly.  Second, it makes it much easier to adjust the specifics of the
- * filter to tune the rounding characteristics.
- */
-/*@{*/
-#define DECLARE_ROW_POINTERS(t, e) \
-      const t(*rowA)[e] = (const t(*)[e]) srcRowA; \
-      const t(*rowB)[e] = (const t(*)[e]) srcRowB; \
-      const t(*rowC)[e] = (const t(*)[e]) srcRowC; \
-      const t(*rowD)[e] = (const t(*)[e]) srcRowD; \
-      t(*dst)[e] = (t(*)[e]) dstRow
-
-#define DECLARE_ROW_POINTERS0(t) \
-      const t *rowA = (const t *) srcRowA; \
-      const t *rowB = (const t *) srcRowB; \
-      const t *rowC = (const t *) srcRowC; \
-      const t *rowD = (const t *) srcRowD; \
-      t *dst = (t *) dstRow
-
-#define FILTER_SUM_3D(Aj, Ak, Bj, Bk, Cj, Ck, Dj, Dk) \
-   ((unsigned) Aj + (unsigned) Ak \
-    + (unsigned) Bj + (unsigned) Bk \
-    + (unsigned) Cj + (unsigned) Ck \
-    + (unsigned) Dj + (unsigned) Dk \
-    + 4) >> 3
-
-#define FILTER_3D(e) \
-   do { \
-      dst[i][e] = FILTER_SUM_3D(rowA[j][e], rowA[k][e], \
-                                rowB[j][e], rowB[k][e], \
-                                rowC[j][e], rowC[k][e], \
-                                rowD[j][e], rowD[k][e]); \
-   } while(0)
-
-#define FILTER_SUM_3D_SIGNED(Aj, Ak, Bj, Bk, Cj, Ck, Dj, Dk) \
-   (Aj + Ak \
-    + Bj + Bk \
-    + Cj + Ck \
-    + Dj + Dk \
-    + 4) / 8
-
-#define FILTER_3D_SIGNED(e) \
-   do { \
-      dst[i][e] = FILTER_SUM_3D_SIGNED(rowA[j][e], rowA[k][e], \
-                                       rowB[j][e], rowB[k][e], \
-                                       rowC[j][e], rowC[k][e], \
-                                       rowD[j][e], rowD[k][e]); \
-   } while(0)
-
-#define FILTER_F_3D(e) \
-   do { \
-      dst[i][e] = (rowA[j][e] + rowA[k][e] \
-                   + rowB[j][e] + rowB[k][e] \
-                   + rowC[j][e] + rowC[k][e] \
-                   + rowD[j][e] + rowD[k][e]) * 0.125F; \
-   } while(0)
-
-#define FILTER_HF_3D(e) \
-   do { \
-      const GLfloat aj = _mesa_half_to_float(rowA[j][e]); \
-      const GLfloat ak = _mesa_half_to_float(rowA[k][e]); \
-      const GLfloat bj = _mesa_half_to_float(rowB[j][e]); \
-      const GLfloat bk = _mesa_half_to_float(rowB[k][e]); \
-      const GLfloat cj = _mesa_half_to_float(rowC[j][e]); \
-      const GLfloat ck = _mesa_half_to_float(rowC[k][e]); \
-      const GLfloat dj = _mesa_half_to_float(rowD[j][e]); \
-      const GLfloat dk = _mesa_half_to_float(rowD[k][e]); \
-      dst[i][e] = _mesa_float_to_half((aj + ak + bj + bk + cj + ck + dj + dk) \
-                                      * 0.125F); \
-   } while(0)
-/*@}*/
-
-
-/**
- * Average together two rows of a source image to produce a single new
- * row in the dest image.  It's legal for the two source rows to point
- * to the same data.  The source width must be equal to either the
- * dest width or two times the dest width.
- * \param datatype  GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_FLOAT, etc.
- * \param comps  number of components per pixel (1..4)
- */
-static void
-do_row(GLenum datatype, GLuint comps, GLint srcWidth,
-       const GLvoid *srcRowA, const GLvoid *srcRowB,
-       GLint dstWidth, GLvoid *dstRow)
-{
-   const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;
-   const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;
-
-   ASSERT(comps >= 1);
-   ASSERT(comps <= 4);
-
-   /* This assertion is no longer valid with non-power-of-2 textures
-   assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);
-   */
-
-   if (datatype == GL_UNSIGNED_BYTE && comps == 4) {
-      GLuint i, j, k;
-      const GLubyte(*rowA)[4] = (const GLubyte(*)[4]) srcRowA;
-      const GLubyte(*rowB)[4] = (const GLubyte(*)[4]) srcRowB;
-      GLubyte(*dst)[4] = (GLubyte(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_BYTE && comps == 3) {
-      GLuint i, j, k;
-      const GLubyte(*rowA)[3] = (const GLubyte(*)[3]) srcRowA;
-      const GLubyte(*rowB)[3] = (const GLubyte(*)[3]) srcRowB;
-      GLubyte(*dst)[3] = (GLubyte(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_BYTE && comps == 2) {
-      GLuint i, j, k;
-      const GLubyte(*rowA)[2] = (const GLubyte(*)[2]) srcRowA;
-      const GLubyte(*rowB)[2] = (const GLubyte(*)[2]) srcRowB;
-      GLubyte(*dst)[2] = (GLubyte(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) >> 2;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) >> 2;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_BYTE && comps == 1) {
-      GLuint i, j, k;
-      const GLubyte *rowA = (const GLubyte *) srcRowA;
-      const GLubyte *rowB = (const GLubyte *) srcRowB;
-      GLubyte *dst = (GLubyte *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) >> 2;
-      }
-   }
-
-   else if (datatype == GL_BYTE && comps == 4) {
-      GLuint i, j, k;
-      const GLbyte(*rowA)[4] = (const GLbyte(*)[4]) srcRowA;
-      const GLbyte(*rowB)[4] = (const GLbyte(*)[4]) srcRowB;
-      GLbyte(*dst)[4] = (GLbyte(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
-      }
-   }
-   else if (datatype == GL_BYTE && comps == 3) {
-      GLuint i, j, k;
-      const GLbyte(*rowA)[3] = (const GLbyte(*)[3]) srcRowA;
-      const GLbyte(*rowB)[3] = (const GLbyte(*)[3]) srcRowB;
-      GLbyte(*dst)[3] = (GLbyte(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-      }
-   }
-   else if (datatype == GL_BYTE && comps == 2) {
-      GLuint i, j, k;
-      const GLbyte(*rowA)[2] = (const GLbyte(*)[2]) srcRowA;
-      const GLbyte(*rowB)[2] = (const GLbyte(*)[2]) srcRowB;
-      GLbyte(*dst)[2] = (GLbyte(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-      }
-   }
-   else if (datatype == GL_BYTE && comps == 1) {
-      GLuint i, j, k;
-      const GLbyte *rowA = (const GLbyte *) srcRowA;
-      const GLbyte *rowB = (const GLbyte *) srcRowB;
-      GLbyte *dst = (GLbyte *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
-      }
-   }
-
-   else if (datatype == GL_UNSIGNED_SHORT && comps == 4) {
-      GLuint i, j, k;
-      const GLushort(*rowA)[4] = (const GLushort(*)[4]) srcRowA;
-      const GLushort(*rowB)[4] = (const GLushort(*)[4]) srcRowB;
-      GLushort(*dst)[4] = (GLushort(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT && comps == 3) {
-      GLuint i, j, k;
-      const GLushort(*rowA)[3] = (const GLushort(*)[3]) srcRowA;
-      const GLushort(*rowB)[3] = (const GLushort(*)[3]) srcRowB;
-      GLushort(*dst)[3] = (GLushort(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT && comps == 2) {
-      GLuint i, j, k;
-      const GLushort(*rowA)[2] = (const GLushort(*)[2]) srcRowA;
-      const GLushort(*rowB)[2] = (const GLushort(*)[2]) srcRowB;
-      GLushort(*dst)[2] = (GLushort(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT && comps == 1) {
-      GLuint i, j, k;
-      const GLushort *rowA = (const GLushort *) srcRowA;
-      const GLushort *rowB = (const GLushort *) srcRowB;
-      GLushort *dst = (GLushort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
-      }
-   }
-
-   else if (datatype == GL_SHORT && comps == 4) {
-      GLuint i, j, k;
-      const GLshort(*rowA)[4] = (const GLshort(*)[4]) srcRowA;
-      const GLshort(*rowB)[4] = (const GLshort(*)[4]) srcRowB;
-      GLshort(*dst)[4] = (GLshort(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
-      }
-   }
-   else if (datatype == GL_SHORT && comps == 3) {
-      GLuint i, j, k;
-      const GLshort(*rowA)[3] = (const GLshort(*)[3]) srcRowA;
-      const GLshort(*rowB)[3] = (const GLshort(*)[3]) srcRowB;
-      GLshort(*dst)[3] = (GLshort(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
-      }
-   }
-   else if (datatype == GL_SHORT && comps == 2) {
-      GLuint i, j, k;
-      const GLshort(*rowA)[2] = (const GLshort(*)[2]) srcRowA;
-      const GLshort(*rowB)[2] = (const GLshort(*)[2]) srcRowB;
-      GLshort(*dst)[2] = (GLshort(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
-      }
-   }
-   else if (datatype == GL_SHORT && comps == 1) {
-      GLuint i, j, k;
-      const GLshort *rowA = (const GLshort *) srcRowA;
-      const GLshort *rowB = (const GLshort *) srcRowB;
-      GLshort *dst = (GLshort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
-      }
-   }
-
-   else if (datatype == GL_FLOAT && comps == 4) {
-      GLuint i, j, k;
-      const GLfloat(*rowA)[4] = (const GLfloat(*)[4]) srcRowA;
-      const GLfloat(*rowB)[4] = (const GLfloat(*)[4]) srcRowB;
-      GLfloat(*dst)[4] = (GLfloat(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] +
-                      rowB[j][0] + rowB[k][0]) * 0.25F;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] +
-                      rowB[j][1] + rowB[k][1]) * 0.25F;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] +
-                      rowB[j][2] + rowB[k][2]) * 0.25F;
-         dst[i][3] = (rowA[j][3] + rowA[k][3] +
-                      rowB[j][3] + rowB[k][3]) * 0.25F;
-      }
-   }
-   else if (datatype == GL_FLOAT && comps == 3) {
-      GLuint i, j, k;
-      const GLfloat(*rowA)[3] = (const GLfloat(*)[3]) srcRowA;
-      const GLfloat(*rowB)[3] = (const GLfloat(*)[3]) srcRowB;
-      GLfloat(*dst)[3] = (GLfloat(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] +
-                      rowB[j][0] + rowB[k][0]) * 0.25F;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] +
-                      rowB[j][1] + rowB[k][1]) * 0.25F;
-         dst[i][2] = (rowA[j][2] + rowA[k][2] +
-                      rowB[j][2] + rowB[k][2]) * 0.25F;
-      }
-   }
-   else if (datatype == GL_FLOAT && comps == 2) {
-      GLuint i, j, k;
-      const GLfloat(*rowA)[2] = (const GLfloat(*)[2]) srcRowA;
-      const GLfloat(*rowB)[2] = (const GLfloat(*)[2]) srcRowB;
-      GLfloat(*dst)[2] = (GLfloat(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i][0] = (rowA[j][0] + rowA[k][0] +
-                      rowB[j][0] + rowB[k][0]) * 0.25F;
-         dst[i][1] = (rowA[j][1] + rowA[k][1] +
-                      rowB[j][1] + rowB[k][1]) * 0.25F;
-      }
-   }
-   else if (datatype == GL_FLOAT && comps == 1) {
-      GLuint i, j, k;
-      const GLfloat *rowA = (const GLfloat *) srcRowA;
-      const GLfloat *rowB = (const GLfloat *) srcRowB;
-      GLfloat *dst = (GLfloat *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) * 0.25F;
-      }
-   }
-
-   else if (datatype == GL_HALF_FLOAT_ARB && comps == 4) {
-      GLuint i, j, k, comp;
-      const GLhalfARB(*rowA)[4] = (const GLhalfARB(*)[4]) srcRowA;
-      const GLhalfARB(*rowB)[4] = (const GLhalfARB(*)[4]) srcRowB;
-      GLhalfARB(*dst)[4] = (GLhalfARB(*)[4]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         for (comp = 0; comp < 4; comp++) {
-            GLfloat aj, ak, bj, bk;
-            aj = _mesa_half_to_float(rowA[j][comp]);
-            ak = _mesa_half_to_float(rowA[k][comp]);
-            bj = _mesa_half_to_float(rowB[j][comp]);
-            bk = _mesa_half_to_float(rowB[k][comp]);
-            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
-         }
-      }
-   }
-   else if (datatype == GL_HALF_FLOAT_ARB && comps == 3) {
-      GLuint i, j, k, comp;
-      const GLhalfARB(*rowA)[3] = (const GLhalfARB(*)[3]) srcRowA;
-      const GLhalfARB(*rowB)[3] = (const GLhalfARB(*)[3]) srcRowB;
-      GLhalfARB(*dst)[3] = (GLhalfARB(*)[3]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         for (comp = 0; comp < 3; comp++) {
-            GLfloat aj, ak, bj, bk;
-            aj = _mesa_half_to_float(rowA[j][comp]);
-            ak = _mesa_half_to_float(rowA[k][comp]);
-            bj = _mesa_half_to_float(rowB[j][comp]);
-            bk = _mesa_half_to_float(rowB[k][comp]);
-            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
-         }
-      }
-   }
-   else if (datatype == GL_HALF_FLOAT_ARB && comps == 2) {
-      GLuint i, j, k, comp;
-      const GLhalfARB(*rowA)[2] = (const GLhalfARB(*)[2]) srcRowA;
-      const GLhalfARB(*rowB)[2] = (const GLhalfARB(*)[2]) srcRowB;
-      GLhalfARB(*dst)[2] = (GLhalfARB(*)[2]) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         for (comp = 0; comp < 2; comp++) {
-            GLfloat aj, ak, bj, bk;
-            aj = _mesa_half_to_float(rowA[j][comp]);
-            ak = _mesa_half_to_float(rowA[k][comp]);
-            bj = _mesa_half_to_float(rowB[j][comp]);
-            bk = _mesa_half_to_float(rowB[k][comp]);
-            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
-         }
-      }
-   }
-   else if (datatype == GL_HALF_FLOAT_ARB && comps == 1) {
-      GLuint i, j, k;
-      const GLhalfARB *rowA = (const GLhalfARB *) srcRowA;
-      const GLhalfARB *rowB = (const GLhalfARB *) srcRowB;
-      GLhalfARB *dst = (GLhalfARB *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         GLfloat aj, ak, bj, bk;
-         aj = _mesa_half_to_float(rowA[j]);
-         ak = _mesa_half_to_float(rowA[k]);
-         bj = _mesa_half_to_float(rowB[j]);
-         bk = _mesa_half_to_float(rowB[k]);
-         dst[i] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);
-      }
-   }
-
-   else if (datatype == GL_UNSIGNED_INT && comps == 1) {
-      GLuint i, j, k;
-      const GLuint *rowA = (const GLuint *) srcRowA;
-      const GLuint *rowB = (const GLuint *) srcRowB;
-      GLuint *dst = (GLuint *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         dst[i] = (GLfloat)(rowA[j] / 4 + rowA[k] / 4 + rowB[j] / 4 + rowB[k] / 4);
-      }
-   }
-
-   else if (datatype == GL_UNSIGNED_SHORT_5_6_5 && comps == 3) {
-      GLuint i, j, k;
-      const GLushort *rowA = (const GLushort *) srcRowA;
-      const GLushort *rowB = (const GLushort *) srcRowB;
-      GLushort *dst = (GLushort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x1f;
-         const GLint rowAr1 = rowA[k] & 0x1f;
-         const GLint rowBr0 = rowB[j] & 0x1f;
-         const GLint rowBr1 = rowB[k] & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 5) & 0x3f;
-         const GLint rowAg1 = (rowA[k] >> 5) & 0x3f;
-         const GLint rowBg0 = (rowB[j] >> 5) & 0x3f;
-         const GLint rowBg1 = (rowB[k] >> 5) & 0x3f;
-         const GLint rowAb0 = (rowA[j] >> 11) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 11) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 11) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 11) & 0x1f;
-         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
-         dst[i] = (blue << 11) | (green << 5) | red;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT_4_4_4_4 && comps == 4) {
-      GLuint i, j, k;
-      const GLushort *rowA = (const GLushort *) srcRowA;
-      const GLushort *rowB = (const GLushort *) srcRowB;
-      GLushort *dst = (GLushort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0xf;
-         const GLint rowAr1 = rowA[k] & 0xf;
-         const GLint rowBr0 = rowB[j] & 0xf;
-         const GLint rowBr1 = rowB[k] & 0xf;
-         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;
-         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;
-         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;
-         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;
-         const GLint rowAb0 = (rowA[j] >> 8) & 0xf;
-         const GLint rowAb1 = (rowA[k] >> 8) & 0xf;
-         const GLint rowBb0 = (rowB[j] >> 8) & 0xf;
-         const GLint rowBb1 = (rowB[k] >> 8) & 0xf;
-         const GLint rowAa0 = (rowA[j] >> 12) & 0xf;
-         const GLint rowAa1 = (rowA[k] >> 12) & 0xf;
-         const GLint rowBa0 = (rowB[j] >> 12) & 0xf;
-         const GLint rowBa1 = (rowB[k] >> 12) & 0xf;
-         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
-         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
-         dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV && comps == 4) {
-      GLuint i, j, k;
-      const GLushort *rowA = (const GLushort *) srcRowA;
-      const GLushort *rowB = (const GLushort *) srcRowB;
-      GLushort *dst = (GLushort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x1f;
-         const GLint rowAr1 = rowA[k] & 0x1f;
-         const GLint rowBr0 = rowB[j] & 0x1f;
-         const GLint rowBr1 = rowB[k] & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 5) & 0x1f;
-         const GLint rowAg1 = (rowA[k] >> 5) & 0x1f;
-         const GLint rowBg0 = (rowB[j] >> 5) & 0x1f;
-         const GLint rowBg1 = (rowB[k] >> 5) & 0x1f;
-         const GLint rowAb0 = (rowA[j] >> 10) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 10) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 10) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 10) & 0x1f;
-         const GLint rowAa0 = (rowA[j] >> 15) & 0x1;
-         const GLint rowAa1 = (rowA[k] >> 15) & 0x1;
-         const GLint rowBa0 = (rowB[j] >> 15) & 0x1;
-         const GLint rowBa1 = (rowB[k] >> 15) & 0x1;
-         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
-         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
-         dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;
-      }
-   }
-   else if (datatype == GL_UNSIGNED_SHORT_5_5_5_1 && comps == 4) {
-      GLuint i, j, k;
-      const GLushort *rowA = (const GLushort *) srcRowA;
-      const GLushort *rowB = (const GLushort *) srcRowB;
-      GLushort *dst = (GLushort *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = (rowA[j] >> 11) & 0x1f;
-         const GLint rowAr1 = (rowA[k] >> 11) & 0x1f;
-         const GLint rowBr0 = (rowB[j] >> 11) & 0x1f;
-         const GLint rowBr1 = (rowB[k] >> 11) & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 6) & 0x1f;
-         const GLint rowAg1 = (rowA[k] >> 6) & 0x1f;
-         const GLint rowBg0 = (rowB[j] >> 6) & 0x1f;
-         const GLint rowBg1 = (rowB[k] >> 6) & 0x1f;
-         const GLint rowAb0 = (rowA[j] >> 1) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 1) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 1) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 1) & 0x1f;
-         const GLint rowAa0 = (rowA[j] & 0x1);
-         const GLint rowAa1 = (rowA[k] & 0x1);
-         const GLint rowBa0 = (rowB[j] & 0x1);
-         const GLint rowBa1 = (rowB[k] & 0x1);
-         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
-         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;
-         dst[i] = (red << 11) | (green << 6) | (blue << 1) | alpha;
-      }
-   }
-
-   else if (datatype == GL_UNSIGNED_BYTE_3_3_2 && comps == 3) {
-      GLuint i, j, k;
-      const GLubyte *rowA = (const GLubyte *) srcRowA;
-      const GLubyte *rowB = (const GLubyte *) srcRowB;
-      GLubyte *dst = (GLubyte *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x3;
-         const GLint rowAr1 = rowA[k] & 0x3;
-         const GLint rowBr0 = rowB[j] & 0x3;
-         const GLint rowBr1 = rowB[k] & 0x3;
-         const GLint rowAg0 = (rowA[j] >> 2) & 0x7;
-         const GLint rowAg1 = (rowA[k] >> 2) & 0x7;
-         const GLint rowBg0 = (rowB[j] >> 2) & 0x7;
-         const GLint rowBg1 = (rowB[k] >> 2) & 0x7;
-         const GLint rowAb0 = (rowA[j] >> 5) & 0x7;
-         const GLint rowAb1 = (rowA[k] >> 5) & 0x7;
-         const GLint rowBb0 = (rowB[j] >> 5) & 0x7;
-         const GLint rowBb1 = (rowB[k] >> 5) & 0x7;
-         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;
-         dst[i] = (blue << 5) | (green << 2) | red;
-      }
-   }
-
-   else if (datatype == MESA_UNSIGNED_BYTE_4_4 && comps == 2) {
-      GLuint i, j, k;
-      const GLubyte *rowA = (const GLubyte *) srcRowA;
-      const GLubyte *rowB = (const GLubyte *) srcRowB;
-      GLubyte *dst = (GLubyte *) dstRow;
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0xf;
-         const GLint rowAr1 = rowA[k] & 0xf;
-         const GLint rowBr0 = rowB[j] & 0xf;
-         const GLint rowBr1 = rowB[k] & 0xf;
-         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;
-         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;
-         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;
-         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;
-         const GLint r = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;
-         const GLint g = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;
-         dst[i] = (g << 4) | r;
-      }
-   }
-
-   else {
-      _mesa_problem(NULL, "bad format in do_row()");
-   }
-}
-
-
-/**
- * Average together four rows of a source image to produce a single new
- * row in the dest image.  It's legal for the two source rows to point
- * to the same data.  The source width must be equal to either the
- * dest width or two times the dest width.
- *
- * \param datatype  GL pixel type \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT,
- *                  \c GL_FLOAT, etc.
- * \param comps     number of components per pixel (1..4)
- * \param srcWidth  Width of a row in the source data
- * \param srcRowA   Pointer to one of the rows of source data
- * \param srcRowB   Pointer to one of the rows of source data
- * \param srcRowC   Pointer to one of the rows of source data
- * \param srcRowD   Pointer to one of the rows of source data
- * \param dstWidth  Width of a row in the destination data
- * \param srcRowA   Pointer to the row of destination data
- */
-static void
-do_row_3D(GLenum datatype, GLuint comps, GLint srcWidth,
-          const GLvoid *srcRowA, const GLvoid *srcRowB,
-          const GLvoid *srcRowC, const GLvoid *srcRowD,
-          GLint dstWidth, GLvoid *dstRow)
-{
-   const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;
-   const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;
-   GLuint i, j, k;
-
-   ASSERT(comps >= 1);
-   ASSERT(comps <= 4);
-
-   if ((datatype == GL_UNSIGNED_BYTE) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLubyte, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-         FILTER_3D(3);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLubyte, 3);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLubyte, 2);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLubyte, 1);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-      }
-   }
-   else if ((datatype == GL_BYTE) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLbyte, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D_SIGNED(0);
-         FILTER_3D_SIGNED(1);
-         FILTER_3D_SIGNED(2);
-         FILTER_3D_SIGNED(3);
-      }
-   }
-   else if ((datatype == GL_BYTE) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLbyte, 3);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D_SIGNED(0);
-         FILTER_3D_SIGNED(1);
-         FILTER_3D_SIGNED(2);
-      }
-   }
-   else if ((datatype == GL_BYTE) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLbyte, 2);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D_SIGNED(0);
-         FILTER_3D_SIGNED(1);
-       }
-   }
-   else if ((datatype == GL_BYTE) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLbyte, 1);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D_SIGNED(0);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLushort, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-         FILTER_3D(3);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLushort, 3);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLushort, 2);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLushort, 1);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-      }
-   }
-   else if ((datatype == GL_SHORT) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLshort, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-         FILTER_3D(3);
-      }
-   }
-   else if ((datatype == GL_SHORT) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLshort, 3);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-         FILTER_3D(2);
-      }
-   }
-   else if ((datatype == GL_SHORT) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLshort, 2);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-         FILTER_3D(1);
-      }
-   }
-   else if ((datatype == GL_SHORT) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLshort, 1);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_3D(0);
-      }
-   }
-   else if ((datatype == GL_FLOAT) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLfloat, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_F_3D(0);
-         FILTER_F_3D(1);
-         FILTER_F_3D(2);
-         FILTER_F_3D(3);
-      }
-   }
-   else if ((datatype == GL_FLOAT) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLfloat, 3);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_F_3D(0);
-         FILTER_F_3D(1);
-         FILTER_F_3D(2);
-      }
-   }
-   else if ((datatype == GL_FLOAT) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLfloat, 2);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_F_3D(0);
-         FILTER_F_3D(1);
-      }
-   }
-   else if ((datatype == GL_FLOAT) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLfloat, 1);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_F_3D(0);
-      }
-   }
-   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 4)) {
-      DECLARE_ROW_POINTERS(GLhalfARB, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_HF_3D(0);
-         FILTER_HF_3D(1);
-         FILTER_HF_3D(2);
-         FILTER_HF_3D(3);
-      }
-   }
-   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 3)) {
-      DECLARE_ROW_POINTERS(GLhalfARB, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_HF_3D(0);
-         FILTER_HF_3D(1);
-         FILTER_HF_3D(2);
-      }
-   }
-   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 2)) {
-      DECLARE_ROW_POINTERS(GLhalfARB, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_HF_3D(0);
-         FILTER_HF_3D(1);
-      }
-   }
-   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 1)) {
-      DECLARE_ROW_POINTERS(GLhalfARB, 4);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         FILTER_HF_3D(0);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_INT) && (comps == 1)) {
-      const GLuint *rowA = (const GLuint *) srcRowA;
-      const GLuint *rowB = (const GLuint *) srcRowB;
-      const GLuint *rowC = (const GLuint *) srcRowC;
-      const GLuint *rowD = (const GLuint *) srcRowD;
-      GLfloat *dst = (GLfloat *) dstRow;
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const uint64_t tmp = (((uint64_t) rowA[j] + (uint64_t) rowA[k])
-                               + ((uint64_t) rowB[j] + (uint64_t) rowB[k])
-                               + ((uint64_t) rowC[j] + (uint64_t) rowC[k])
-                               + ((uint64_t) rowD[j] + (uint64_t) rowD[k]));
-         dst[i] = (GLfloat)((double) tmp * 0.125);
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT_5_6_5) && (comps == 3)) {
-      DECLARE_ROW_POINTERS0(GLushort);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x1f;
-         const GLint rowAr1 = rowA[k] & 0x1f;
-         const GLint rowBr0 = rowB[j] & 0x1f;
-         const GLint rowBr1 = rowB[k] & 0x1f;
-         const GLint rowCr0 = rowC[j] & 0x1f;
-         const GLint rowCr1 = rowC[k] & 0x1f;
-         const GLint rowDr0 = rowD[j] & 0x1f;
-         const GLint rowDr1 = rowD[k] & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 5) & 0x3f;
-         const GLint rowAg1 = (rowA[k] >> 5) & 0x3f;
-         const GLint rowBg0 = (rowB[j] >> 5) & 0x3f;
-         const GLint rowBg1 = (rowB[k] >> 5) & 0x3f;
-         const GLint rowCg0 = (rowC[j] >> 5) & 0x3f;
-         const GLint rowCg1 = (rowC[k] >> 5) & 0x3f;
-         const GLint rowDg0 = (rowD[j] >> 5) & 0x3f;
-         const GLint rowDg1 = (rowD[k] >> 5) & 0x3f;
-         const GLint rowAb0 = (rowA[j] >> 11) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 11) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 11) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 11) & 0x1f;
-         const GLint rowCb0 = (rowC[j] >> 11) & 0x1f;
-         const GLint rowCb1 = (rowC[k] >> 11) & 0x1f;
-         const GLint rowDb0 = (rowD[j] >> 11) & 0x1f;
-         const GLint rowDb1 = (rowD[k] >> 11) & 0x1f;
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,
-                                       rowCb0, rowCb1, rowDb0, rowDb1);
-         dst[i] = (b << 11) | (g << 5) | r;
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT_4_4_4_4) && (comps == 4)) {
-      DECLARE_ROW_POINTERS0(GLushort);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0xf;
-         const GLint rowAr1 = rowA[k] & 0xf;
-         const GLint rowBr0 = rowB[j] & 0xf;
-         const GLint rowBr1 = rowB[k] & 0xf;
-         const GLint rowCr0 = rowC[j] & 0xf;
-         const GLint rowCr1 = rowC[k] & 0xf;
-         const GLint rowDr0 = rowD[j] & 0xf;
-         const GLint rowDr1 = rowD[k] & 0xf;
-         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;
-         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;
-         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;
-         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;
-         const GLint rowCg0 = (rowC[j] >> 4) & 0xf;
-         const GLint rowCg1 = (rowC[k] >> 4) & 0xf;
-         const GLint rowDg0 = (rowD[j] >> 4) & 0xf;
-         const GLint rowDg1 = (rowD[k] >> 4) & 0xf;
-         const GLint rowAb0 = (rowA[j] >> 8) & 0xf;
-         const GLint rowAb1 = (rowA[k] >> 8) & 0xf;
-         const GLint rowBb0 = (rowB[j] >> 8) & 0xf;
-         const GLint rowBb1 = (rowB[k] >> 8) & 0xf;
-         const GLint rowCb0 = (rowC[j] >> 8) & 0xf;
-         const GLint rowCb1 = (rowC[k] >> 8) & 0xf;
-         const GLint rowDb0 = (rowD[j] >> 8) & 0xf;
-         const GLint rowDb1 = (rowD[k] >> 8) & 0xf;
-         const GLint rowAa0 = (rowA[j] >> 12) & 0xf;
-         const GLint rowAa1 = (rowA[k] >> 12) & 0xf;
-         const GLint rowBa0 = (rowB[j] >> 12) & 0xf;
-         const GLint rowBa1 = (rowB[k] >> 12) & 0xf;
-         const GLint rowCa0 = (rowC[j] >> 12) & 0xf;
-         const GLint rowCa1 = (rowC[k] >> 12) & 0xf;
-         const GLint rowDa0 = (rowD[j] >> 12) & 0xf;
-         const GLint rowDa1 = (rowD[k] >> 12) & 0xf;
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,
-                                       rowCb0, rowCb1, rowDb0, rowDb1);
-         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,
-                                       rowCa0, rowCa1, rowDa0, rowDa1);
-
-         dst[i] = (a << 12) | (b << 8) | (g << 4) | r;
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV) && (comps == 4)) {
-      DECLARE_ROW_POINTERS0(GLushort);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x1f;
-         const GLint rowAr1 = rowA[k] & 0x1f;
-         const GLint rowBr0 = rowB[j] & 0x1f;
-         const GLint rowBr1 = rowB[k] & 0x1f;
-         const GLint rowCr0 = rowC[j] & 0x1f;
-         const GLint rowCr1 = rowC[k] & 0x1f;
-         const GLint rowDr0 = rowD[j] & 0x1f;
-         const GLint rowDr1 = rowD[k] & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 5) & 0x1f;
-         const GLint rowAg1 = (rowA[k] >> 5) & 0x1f;
-         const GLint rowBg0 = (rowB[j] >> 5) & 0x1f;
-         const GLint rowBg1 = (rowB[k] >> 5) & 0x1f;
-         const GLint rowCg0 = (rowC[j] >> 5) & 0x1f;
-         const GLint rowCg1 = (rowC[k] >> 5) & 0x1f;
-         const GLint rowDg0 = (rowD[j] >> 5) & 0x1f;
-         const GLint rowDg1 = (rowD[k] >> 5) & 0x1f;
-         const GLint rowAb0 = (rowA[j] >> 10) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 10) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 10) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 10) & 0x1f;
-         const GLint rowCb0 = (rowC[j] >> 10) & 0x1f;
-         const GLint rowCb1 = (rowC[k] >> 10) & 0x1f;
-         const GLint rowDb0 = (rowD[j] >> 10) & 0x1f;
-         const GLint rowDb1 = (rowD[k] >> 10) & 0x1f;
-         const GLint rowAa0 = (rowA[j] >> 15) & 0x1;
-         const GLint rowAa1 = (rowA[k] >> 15) & 0x1;
-         const GLint rowBa0 = (rowB[j] >> 15) & 0x1;
-         const GLint rowBa1 = (rowB[k] >> 15) & 0x1;
-         const GLint rowCa0 = (rowC[j] >> 15) & 0x1;
-         const GLint rowCa1 = (rowC[k] >> 15) & 0x1;
-         const GLint rowDa0 = (rowD[j] >> 15) & 0x1;
-         const GLint rowDa1 = (rowD[k] >> 15) & 0x1;
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,
-                                       rowCb0, rowCb1, rowDb0, rowDb1);
-         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,
-                                       rowCa0, rowCa1, rowDa0, rowDa1);
-
-         dst[i] = (a << 15) | (b << 10) | (g << 5) | r;
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_SHORT_5_5_5_1) && (comps == 4)) {
-      DECLARE_ROW_POINTERS0(GLushort);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = (rowA[j] >> 11) & 0x1f;
-         const GLint rowAr1 = (rowA[k] >> 11) & 0x1f;
-         const GLint rowBr0 = (rowB[j] >> 11) & 0x1f;
-         const GLint rowBr1 = (rowB[k] >> 11) & 0x1f;
-         const GLint rowCr0 = (rowC[j] >> 11) & 0x1f;
-         const GLint rowCr1 = (rowC[k] >> 11) & 0x1f;
-         const GLint rowDr0 = (rowD[j] >> 11) & 0x1f;
-         const GLint rowDr1 = (rowD[k] >> 11) & 0x1f;
-         const GLint rowAg0 = (rowA[j] >> 6) & 0x1f;
-         const GLint rowAg1 = (rowA[k] >> 6) & 0x1f;
-         const GLint rowBg0 = (rowB[j] >> 6) & 0x1f;
-         const GLint rowBg1 = (rowB[k] >> 6) & 0x1f;
-         const GLint rowCg0 = (rowC[j] >> 6) & 0x1f;
-         const GLint rowCg1 = (rowC[k] >> 6) & 0x1f;
-         const GLint rowDg0 = (rowD[j] >> 6) & 0x1f;
-         const GLint rowDg1 = (rowD[k] >> 6) & 0x1f;
-         const GLint rowAb0 = (rowA[j] >> 1) & 0x1f;
-         const GLint rowAb1 = (rowA[k] >> 1) & 0x1f;
-         const GLint rowBb0 = (rowB[j] >> 1) & 0x1f;
-         const GLint rowBb1 = (rowB[k] >> 1) & 0x1f;
-         const GLint rowCb0 = (rowC[j] >> 1) & 0x1f;
-         const GLint rowCb1 = (rowC[k] >> 1) & 0x1f;
-         const GLint rowDb0 = (rowD[j] >> 1) & 0x1f;
-         const GLint rowDb1 = (rowD[k] >> 1) & 0x1f;
-         const GLint rowAa0 = (rowA[j] & 0x1);
-         const GLint rowAa1 = (rowA[k] & 0x1);
-         const GLint rowBa0 = (rowB[j] & 0x1);
-         const GLint rowBa1 = (rowB[k] & 0x1);
-         const GLint rowCa0 = (rowC[j] & 0x1);
-         const GLint rowCa1 = (rowC[k] & 0x1);
-         const GLint rowDa0 = (rowD[j] & 0x1);
-         const GLint rowDa1 = (rowD[k] & 0x1);
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,
-                                       rowCb0, rowCb1, rowDb0, rowDb1);
-         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,
-                                       rowCa0, rowCa1, rowDa0, rowDa1);
-
-         dst[i] = (r << 11) | (g << 6) | (b << 1) | a;
-      }
-   }
-   else if ((datatype == GL_UNSIGNED_BYTE_3_3_2) && (comps == 3)) {
-      DECLARE_ROW_POINTERS0(GLubyte);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0x3;
-         const GLint rowAr1 = rowA[k] & 0x3;
-         const GLint rowBr0 = rowB[j] & 0x3;
-         const GLint rowBr1 = rowB[k] & 0x3;
-         const GLint rowCr0 = rowC[j] & 0x3;
-         const GLint rowCr1 = rowC[k] & 0x3;
-         const GLint rowDr0 = rowD[j] & 0x3;
-         const GLint rowDr1 = rowD[k] & 0x3;
-         const GLint rowAg0 = (rowA[j] >> 2) & 0x7;
-         const GLint rowAg1 = (rowA[k] >> 2) & 0x7;
-         const GLint rowBg0 = (rowB[j] >> 2) & 0x7;
-         const GLint rowBg1 = (rowB[k] >> 2) & 0x7;
-         const GLint rowCg0 = (rowC[j] >> 2) & 0x7;
-         const GLint rowCg1 = (rowC[k] >> 2) & 0x7;
-         const GLint rowDg0 = (rowD[j] >> 2) & 0x7;
-         const GLint rowDg1 = (rowD[k] >> 2) & 0x7;
-         const GLint rowAb0 = (rowA[j] >> 5) & 0x7;
-         const GLint rowAb1 = (rowA[k] >> 5) & 0x7;
-         const GLint rowBb0 = (rowB[j] >> 5) & 0x7;
-         const GLint rowBb1 = (rowB[k] >> 5) & 0x7;
-         const GLint rowCb0 = (rowC[j] >> 5) & 0x7;
-         const GLint rowCb1 = (rowC[k] >> 5) & 0x7;
-         const GLint rowDb0 = (rowD[j] >> 5) & 0x7;
-         const GLint rowDb1 = (rowD[k] >> 5) & 0x7;
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,
-                                       rowCb0, rowCb1, rowDb0, rowDb1);
-         dst[i] = (b << 5) | (g << 2) | r;
-      }
-   }
-   else if (datatype == MESA_UNSIGNED_BYTE_4_4 && comps == 2) {
-      DECLARE_ROW_POINTERS0(GLubyte);
-
-      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
-           i++, j += colStride, k += colStride) {
-         const GLint rowAr0 = rowA[j] & 0xf;
-         const GLint rowAr1 = rowA[k] & 0xf;
-         const GLint rowBr0 = rowB[j] & 0xf;
-         const GLint rowBr1 = rowB[k] & 0xf;
-         const GLint rowCr0 = rowC[j] & 0xf;
-         const GLint rowCr1 = rowC[k] & 0xf;
-         const GLint rowDr0 = rowD[j] & 0xf;
-         const GLint rowDr1 = rowD[k] & 0xf;
-         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;
-         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;
-         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;
-         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;
-         const GLint rowCg0 = (rowC[j] >> 4) & 0xf;
-         const GLint rowCg1 = (rowC[k] >> 4) & 0xf;
-         const GLint rowDg0 = (rowD[j] >> 4) & 0xf;
-         const GLint rowDg1 = (rowD[k] >> 4) & 0xf;
-         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,
-                                       rowCr0, rowCr1, rowDr0, rowDr1);
-         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,
-                                       rowCg0, rowCg1, rowDg0, rowDg1);
-         dst[i] = (g << 4) | r;
-      }
-   }
-   else {
-      _mesa_problem(NULL, "bad format in do_row()");
-   }
-}
-
-
-/*
- * These functions generate a 1/2-size mipmap image from a source image.
- * Texture borders are handled by copying or averaging the source image's
- * border texels, depending on the scale-down factor.
- */
-
-static void
-make_1d_mipmap(GLenum datatype, GLuint comps, GLint border,
-               GLint srcWidth, const GLubyte *srcPtr,
-               GLint dstWidth, GLubyte *dstPtr)
-{
-   const GLint bpt = bytes_per_pixel(datatype, comps);
-   const GLubyte *src;
-   GLubyte *dst;
-
-   /* skip the border pixel, if any */
-   src = srcPtr + border * bpt;
-   dst = dstPtr + border * bpt;
-
-   /* we just duplicate the input row, kind of hack, saves code */
-   do_row(datatype, comps, srcWidth - 2 * border, src, src,
-          dstWidth - 2 * border, dst);
-
-   if (border) {
-      /* copy left-most pixel from source */
-      assert(dstPtr);
-      assert(srcPtr);
-      memcpy(dstPtr, srcPtr, bpt);
-      /* copy right-most pixel from source */
-      memcpy(dstPtr + (dstWidth - 1) * bpt,
-             srcPtr + (srcWidth - 1) * bpt,
-             bpt);
-   }
-}
-
-
-static void
-make_2d_mipmap(GLenum datatype, GLuint comps, GLint border,
-               GLint srcWidth, GLint srcHeight,
-	       const GLubyte *srcPtr, GLint srcRowStride,
-               GLint dstWidth, GLint dstHeight,
-	       GLubyte *dstPtr, GLint dstRowStride)
-{
-   const GLint bpt = bytes_per_pixel(datatype, comps);
-   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
-   const GLint dstWidthNB = dstWidth - 2 * border;
-   const GLint dstHeightNB = dstHeight - 2 * border;
-   const GLint srcRowBytes = bpt * srcRowStride;
-   const GLint dstRowBytes = bpt * dstRowStride;
-   const GLubyte *srcA, *srcB;
-   GLubyte *dst;
-   GLint row, srcRowStep;
-
-   /* Compute src and dst pointers, skipping any border */
-   srcA = srcPtr + border * ((srcWidth + 1) * bpt);
-   if (srcHeight > 1 && srcHeight > dstHeight) {
-      /* sample from two source rows */
-      srcB = srcA + srcRowBytes;
-      srcRowStep = 2;
-   }
-   else {
-      /* sample from one source row */
-      srcB = srcA;
-      srcRowStep = 1;
-   }
-
-   dst = dstPtr + border * ((dstWidth + 1) * bpt);
-
-   for (row = 0; row < dstHeightNB; row++) {
-      do_row(datatype, comps, srcWidthNB, srcA, srcB,
-             dstWidthNB, dst);
-      srcA += srcRowStep * srcRowBytes;
-      srcB += srcRowStep * srcRowBytes;
-      dst += dstRowBytes;
-   }
-
-   /* This is ugly but probably won't be used much */
-   if (border > 0) {
-      /* fill in dest border */
-      /* lower-left border pixel */
-      assert(dstPtr);
-      assert(srcPtr);
-      memcpy(dstPtr, srcPtr, bpt);
-      /* lower-right border pixel */
-      memcpy(dstPtr + (dstWidth - 1) * bpt,
-             srcPtr + (srcWidth - 1) * bpt, bpt);
-      /* upper-left border pixel */
-      memcpy(dstPtr + dstWidth * (dstHeight - 1) * bpt,
-             srcPtr + srcWidth * (srcHeight - 1) * bpt, bpt);
-      /* upper-right border pixel */
-      memcpy(dstPtr + (dstWidth * dstHeight - 1) * bpt,
-             srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
-      /* lower border */
-      do_row(datatype, comps, srcWidthNB,
-             srcPtr + bpt,
-             srcPtr + bpt,
-             dstWidthNB, dstPtr + bpt);
-      /* upper border */
-      do_row(datatype, comps, srcWidthNB,
-             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
-             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
-             dstWidthNB,
-             dstPtr + (dstWidth * (dstHeight - 1) + 1) * bpt);
-      /* left and right borders */
-      if (srcHeight == dstHeight) {
-         /* copy border pixel from src to dst */
-         for (row = 1; row < srcHeight; row++) {
-            memcpy(dstPtr + dstWidth * row * bpt,
-                   srcPtr + srcWidth * row * bpt, bpt);
-            memcpy(dstPtr + (dstWidth * row + dstWidth - 1) * bpt,
-                   srcPtr + (srcWidth * row + srcWidth - 1) * bpt, bpt);
-         }
-      }
-      else {
-         /* average two src pixels each dest pixel */
-         for (row = 0; row < dstHeightNB; row += 2) {
-            do_row(datatype, comps, 1,
-                   srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
-                   srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
-                   1, dstPtr + (dstWidth * row + 1) * bpt);
-            do_row(datatype, comps, 1,
-                   srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
-                   srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
-                   1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
-         }
-      }
-   }
-}
-
-
-static void
-make_3d_mipmap(GLenum datatype, GLuint comps, GLint border,
-               GLint srcWidth, GLint srcHeight, GLint srcDepth,
-               const GLubyte *srcPtr, GLint srcRowStride,
-               GLint dstWidth, GLint dstHeight, GLint dstDepth,
-               GLubyte *dstPtr, GLint dstRowStride)
-{
-   const GLint bpt = bytes_per_pixel(datatype, comps);
-   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
-   const GLint srcDepthNB = srcDepth - 2 * border;
-   const GLint dstWidthNB = dstWidth - 2 * border;
-   const GLint dstHeightNB = dstHeight - 2 * border;
-   const GLint dstDepthNB = dstDepth - 2 * border;
-   GLint img, row;
-   GLint bytesPerSrcImage, bytesPerDstImage;
-   GLint bytesPerSrcRow, bytesPerDstRow;
-   GLint srcImageOffset, srcRowOffset;
-
-   (void) srcDepthNB; /* silence warnings */
-
-
-   bytesPerSrcImage = srcWidth * srcHeight * bpt;
-   bytesPerDstImage = dstWidth * dstHeight * bpt;
-
-   bytesPerSrcRow = srcWidth * bpt;
-   bytesPerDstRow = dstWidth * bpt;
-
-   /* Offset between adjacent src images to be averaged together */
-   srcImageOffset = (srcDepth == dstDepth) ? 0 : bytesPerSrcImage;
-
-   /* Offset between adjacent src rows to be averaged together */
-   srcRowOffset = (srcHeight == dstHeight) ? 0 : srcWidth * bpt;
-
-   /*
-    * Need to average together up to 8 src pixels for each dest pixel.
-    * Break that down into 3 operations:
-    *   1. take two rows from source image and average them together.
-    *   2. take two rows from next source image and average them together.
-    *   3. take the two averaged rows and average them for the final dst row.
-    */
-
-   /*
-   printf("mip3d %d x %d x %d  ->  %d x %d x %d\n",
-          srcWidth, srcHeight, srcDepth, dstWidth, dstHeight, dstDepth);
-   */
-
-   for (img = 0; img < dstDepthNB; img++) {
-      /* first source image pointer, skipping border */
-      const GLubyte *imgSrcA = srcPtr
-         + (bytesPerSrcImage + bytesPerSrcRow + border) * bpt * border
-         + img * (bytesPerSrcImage + srcImageOffset);
-      /* second source image pointer, skipping border */
-      const GLubyte *imgSrcB = imgSrcA + srcImageOffset;
-      /* address of the dest image, skipping border */
-      GLubyte *imgDst = dstPtr
-         + (bytesPerDstImage + bytesPerDstRow + border) * bpt * border
-         + img * bytesPerDstImage;
-
-      /* setup the four source row pointers and the dest row pointer */
-      const GLubyte *srcImgARowA = imgSrcA;
-      const GLubyte *srcImgARowB = imgSrcA + srcRowOffset;
-      const GLubyte *srcImgBRowA = imgSrcB;
-      const GLubyte *srcImgBRowB = imgSrcB + srcRowOffset;
-      GLubyte *dstImgRow = imgDst;
-
-      for (row = 0; row < dstHeightNB; row++) {
-         do_row_3D(datatype, comps, srcWidthNB, 
-                   srcImgARowA, srcImgARowB,
-                   srcImgBRowA, srcImgBRowB,
-                   dstWidthNB, dstImgRow);
-
-         /* advance to next rows */
-         srcImgARowA += bytesPerSrcRow + srcRowOffset;
-         srcImgARowB += bytesPerSrcRow + srcRowOffset;
-         srcImgBRowA += bytesPerSrcRow + srcRowOffset;
-         srcImgBRowB += bytesPerSrcRow + srcRowOffset;
-         dstImgRow += bytesPerDstRow;
-      }
-   }
-
-
-   /* Luckily we can leverage the make_2d_mipmap() function here! */
-   if (border > 0) {
-      /* do front border image */
-      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight, srcPtr, srcRowStride,
-                     dstWidth, dstHeight, dstPtr, dstRowStride);
-      /* do back border image */
-      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight,
-                     srcPtr + bytesPerSrcImage * (srcDepth - 1), srcRowStride,
-                     dstWidth, dstHeight,
-                     dstPtr + bytesPerDstImage * (dstDepth - 1), dstRowStride);
-      /* do four remaining border edges that span the image slices */
-      if (srcDepth == dstDepth) {
-         /* just copy border pixels from src to dst */
-         for (img = 0; img < dstDepthNB; img++) {
-            const GLubyte *src;
-            GLubyte *dst;
-
-            /* do border along [img][row=0][col=0] */
-            src = srcPtr + (img + 1) * bytesPerSrcImage;
-            dst = dstPtr + (img + 1) * bytesPerDstImage;
-            memcpy(dst, src, bpt);
-
-            /* do border along [img][row=dstHeight-1][col=0] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (srcHeight - 1) * bytesPerSrcRow;
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (dstHeight - 1) * bytesPerDstRow;
-            memcpy(dst, src, bpt);
-
-            /* do border along [img][row=0][col=dstWidth-1] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (srcWidth - 1) * bpt;
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (dstWidth - 1) * bpt;
-            memcpy(dst, src, bpt);
-
-            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (bytesPerSrcImage - bpt);
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (bytesPerDstImage - bpt);
-            memcpy(dst, src, bpt);
-         }
-      }
-      else {
-         /* average border pixels from adjacent src image pairs */
-         ASSERT(srcDepthNB == 2 * dstDepthNB);
-         for (img = 0; img < dstDepthNB; img++) {
-            const GLubyte *src;
-            GLubyte *dst;
-
-            /* do border along [img][row=0][col=0] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage;
-            dst = dstPtr + (img + 1) * bytesPerDstImage;
-            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
-
-            /* do border along [img][row=dstHeight-1][col=0] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (srcHeight - 1) * bytesPerSrcRow;
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (dstHeight - 1) * bytesPerDstRow;
-            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
-
-            /* do border along [img][row=0][col=dstWidth-1] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (srcWidth - 1) * bpt;
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (dstWidth - 1) * bpt;
-            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
-
-            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */
-            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
-                         + (bytesPerSrcImage - bpt);
-            dst = dstPtr + (img + 1) * bytesPerDstImage
-                         + (bytesPerDstImage - bpt);
-            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);
-         }
-      }
-   }
-}
-
-
-static void
-make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
-                     GLint srcWidth, const GLubyte *srcPtr, GLuint srcRowStride,
-                     GLint dstWidth, GLint dstHeight,
-		     GLubyte *dstPtr, GLuint dstRowStride )
-{
-   const GLint bpt = bytes_per_pixel(datatype, comps);
-   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
-   const GLint dstWidthNB = dstWidth - 2 * border;
-   const GLint dstHeightNB = dstHeight - 2 * border;
-   const GLint srcRowBytes = bpt * srcRowStride;
-   const GLint dstRowBytes = bpt * dstRowStride;
-   const GLubyte *src;
-   GLubyte *dst;
-   GLint row;
-
-   /* Compute src and dst pointers, skipping any border */
-   src = srcPtr + border * ((srcWidth + 1) * bpt);
-   dst = dstPtr + border * ((dstWidth + 1) * bpt);
-
-   for (row = 0; row < dstHeightNB; row++) {
-      do_row(datatype, comps, srcWidthNB, src, src,
-             dstWidthNB, dst);
-      src += srcRowBytes;
-      dst += dstRowBytes;
-   }
-
-   if (border) {
-      /* copy left-most pixel from source */
-      assert(dstPtr);
-      assert(srcPtr);
-      memcpy(dstPtr, srcPtr, bpt);
-      /* copy right-most pixel from source */
-      memcpy(dstPtr + (dstWidth - 1) * bpt,
-             srcPtr + (srcWidth - 1) * bpt,
-             bpt);
-   }
-}
-
-
-/**
- * \bug
- * There is quite a bit of refactoring that could be done with this function
- * and \c make_2d_mipmap.
- */
-static void
-make_2d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
-                     GLint srcWidth, GLint srcHeight,
-		     const GLubyte *srcPtr, GLint srcRowStride,
-                     GLint dstWidth, GLint dstHeight, GLint dstDepth,
-                     GLubyte *dstPtr, GLint dstRowStride)
-{
-   const GLint bpt = bytes_per_pixel(datatype, comps);
-   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
-   const GLint dstWidthNB = dstWidth - 2 * border;
-   const GLint dstHeightNB = dstHeight - 2 * border;
-   const GLint dstDepthNB = dstDepth - 2 * border;
-   const GLint srcRowBytes = bpt * srcRowStride;
-   const GLint dstRowBytes = bpt * dstRowStride;
-   const GLubyte *srcA, *srcB;
-   GLubyte *dst;
-   GLint layer;
-   GLint row;
-
-   /* Compute src and dst pointers, skipping any border */
-   srcA = srcPtr + border * ((srcWidth + 1) * bpt);
-   if (srcHeight > 1) 
-      srcB = srcA + srcRowBytes;
-   else
-      srcB = srcA;
-   dst = dstPtr + border * ((dstWidth + 1) * bpt);
-
-   for (layer = 0; layer < dstDepthNB; layer++) {
-      for (row = 0; row < dstHeightNB; row++) {
-         do_row(datatype, comps, srcWidthNB, srcA, srcB,
-                dstWidthNB, dst);
-         srcA += 2 * srcRowBytes;
-         srcB += 2 * srcRowBytes;
-         dst += dstRowBytes;
-      }
-
-      /* This is ugly but probably won't be used much */
-      if (border > 0) {
-         /* fill in dest border */
-         /* lower-left border pixel */
-         assert(dstPtr);
-         assert(srcPtr);
-         memcpy(dstPtr, srcPtr, bpt);
-         /* lower-right border pixel */
-         memcpy(dstPtr + (dstWidth - 1) * bpt,
-                srcPtr + (srcWidth - 1) * bpt, bpt);
-         /* upper-left border pixel */
-         memcpy(dstPtr + dstWidth * (dstHeight - 1) * bpt,
-                srcPtr + srcWidth * (srcHeight - 1) * bpt, bpt);
-         /* upper-right border pixel */
-         memcpy(dstPtr + (dstWidth * dstHeight - 1) * bpt,
-                srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
-         /* lower border */
-         do_row(datatype, comps, srcWidthNB,
-                srcPtr + bpt,
-                srcPtr + bpt,
-                dstWidthNB, dstPtr + bpt);
-         /* upper border */
-         do_row(datatype, comps, srcWidthNB,
-                srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
-                srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
-                dstWidthNB,
-                dstPtr + (dstWidth * (dstHeight - 1) + 1) * bpt);
-         /* left and right borders */
-         if (srcHeight == dstHeight) {
-            /* copy border pixel from src to dst */
-            for (row = 1; row < srcHeight; row++) {
-               memcpy(dstPtr + dstWidth * row * bpt,
-                      srcPtr + srcWidth * row * bpt, bpt);
-               memcpy(dstPtr + (dstWidth * row + dstWidth - 1) * bpt,
-                      srcPtr + (srcWidth * row + srcWidth - 1) * bpt, bpt);
-            }
-         }
-         else {
-            /* average two src pixels each dest pixel */
-            for (row = 0; row < dstHeightNB; row += 2) {
-               do_row(datatype, comps, 1,
-                      srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
-                      srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
-                      1, dstPtr + (dstWidth * row + 1) * bpt);
-               do_row(datatype, comps, 1,
-                      srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
-                      srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
-                      1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
-            }
-         }
-      }
-   }
-}
-
-
-/**
- * Down-sample a texture image to produce the next lower mipmap level.
- * \param comps  components per texel (1, 2, 3 or 4)
- * \param srcRowStride  stride between source rows, in texels
- * \param dstRowStride  stride between destination rows, in texels
- */
-void
-_mesa_generate_mipmap_level(GLenum target,
-                            GLenum datatype, GLuint comps,
-                            GLint border,
-                            GLint srcWidth, GLint srcHeight, GLint srcDepth,
-                            const GLubyte *srcData,
-                            GLint srcRowStride,
-                            GLint dstWidth, GLint dstHeight, GLint dstDepth,
-                            GLubyte *dstData,
-                            GLint dstRowStride)
-{
-   /*
-    * We use simple 2x2 averaging to compute the next mipmap level.
-    */
-   switch (target) {
-   case GL_TEXTURE_1D:
-      make_1d_mipmap(datatype, comps, border,
-                     srcWidth, srcData,
-                     dstWidth, dstData);
-      break;
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-      make_2d_mipmap(datatype, comps, border,
-                     srcWidth, srcHeight, srcData, srcRowStride,
-                     dstWidth, dstHeight, dstData, dstRowStride);
-      break;
-   case GL_TEXTURE_3D:
-      make_3d_mipmap(datatype, comps, border,
-                     srcWidth, srcHeight, srcDepth,
-                     srcData, srcRowStride,
-                     dstWidth, dstHeight, dstDepth,
-                     dstData, dstRowStride);
-      break;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      make_1d_stack_mipmap(datatype, comps, border,
-                           srcWidth, srcData, srcRowStride,
-                           dstWidth, dstHeight,
-                           dstData, dstRowStride);
-      break;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      make_2d_stack_mipmap(datatype, comps, border,
-                           srcWidth, srcHeight,
-                           srcData, srcRowStride,
-                           dstWidth, dstHeight,
-                           dstDepth, dstData, dstRowStride);
-      break;
-   case GL_TEXTURE_RECTANGLE_NV:
-      /* no mipmaps, do nothing */
-      break;
-   default:
-      _mesa_problem(NULL, "bad dimensions in _mesa_generate_mipmaps");
-      return;
-   }
-}
-
-
-/**
- * compute next (level+1) image size
- * \return GL_FALSE if no smaller size can be generated (eg. src is 1x1x1 size)
- */
-static GLboolean
-next_mipmap_level_size(GLenum target, GLint border,
-                       GLint srcWidth, GLint srcHeight, GLint srcDepth,
-                       GLint *dstWidth, GLint *dstHeight, GLint *dstDepth)
-{
-   if (srcWidth - 2 * border > 1) {
-      *dstWidth = (srcWidth - 2 * border) / 2 + 2 * border;
-   }
-   else {
-      *dstWidth = srcWidth; /* can't go smaller */
-   }
-
-   if ((srcHeight - 2 * border > 1) && 
-       (target != GL_TEXTURE_1D_ARRAY_EXT)) {
-      *dstHeight = (srcHeight - 2 * border) / 2 + 2 * border;
-   }
-   else {
-      *dstHeight = srcHeight; /* can't go smaller */
-   }
-
-   if ((srcDepth - 2 * border > 1) &&
-       (target != GL_TEXTURE_2D_ARRAY_EXT)) {
-      *dstDepth = (srcDepth - 2 * border) / 2 + 2 * border;
-   }
-   else {
-      *dstDepth = srcDepth; /* can't go smaller */
-   }
-
-   if (*dstWidth == srcWidth &&
-       *dstHeight == srcHeight &&
-       *dstDepth == srcDepth) {
-      return GL_FALSE;
-   }
-   else {
-      return GL_TRUE;
-   }
-}
-
-
-
-
-/**
- * Automatic mipmap generation.
- * This is the fallback/default function for ctx->Driver.GenerateMipmap().
- * Generate a complete set of mipmaps from texObj's BaseLevel image.
- * Stop at texObj's MaxLevel or when we get to the 1x1 texture.
- * For cube maps, target will be one of
- * GL_TEXTURE_CUBE_MAP_POSITIVE/NEGATIVE_X/Y/Z; never GL_TEXTURE_CUBE_MAP.
- */
-void
-_mesa_generate_mipmap(struct gl_context *ctx, GLenum target,
-                      struct gl_texture_object *texObj)
-{
-   const struct gl_texture_image *srcImage;
-   gl_format convertFormat;
-   const GLubyte *srcData = NULL;
-   GLubyte *dstData = NULL;
-   GLint level, maxLevels;
-   GLenum datatype;
-   GLuint comps;
-
-   ASSERT(texObj);
-   srcImage = _mesa_select_tex_image(ctx, texObj, target, texObj->BaseLevel);
-   ASSERT(srcImage);
-
-   maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
-   ASSERT(maxLevels > 0);  /* bad target */
-
-   /* Find convertFormat - the format that do_row() will process */
-
-   if (_mesa_is_format_compressed(srcImage->TexFormat)) {
-      /* setup for compressed textures - need to allocate temporary
-       * image buffers to hold uncompressed images.
-       */
-      GLuint row;
-      GLint  components, size;
-      GLchan *dst;
-
-      assert(texObj->Target == GL_TEXTURE_2D ||
-             texObj->Target == GL_TEXTURE_CUBE_MAP_ARB);
-
-      if (srcImage->_BaseFormat == GL_RGB) {
-         convertFormat = MESA_FORMAT_RGB888;
-         components = 3;
-      } else if (srcImage->_BaseFormat == GL_RED) {
-         convertFormat = MESA_FORMAT_R8;
-         components = 1;
-      } else if (srcImage->_BaseFormat == GL_RG) {
-         convertFormat = MESA_FORMAT_RG88;
-         components = 2;
-      } else if (srcImage->_BaseFormat == GL_RGBA) {
-         convertFormat = MESA_FORMAT_RGBA8888;
-         components = 4;
-      } else if (srcImage->_BaseFormat == GL_LUMINANCE) {
-         convertFormat = MESA_FORMAT_L8;
-         components = 1;
-      } else if (srcImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
-         convertFormat = MESA_FORMAT_AL88;
-         components = 2;
-      } else {
-         _mesa_problem(ctx, "bad srcImage->_BaseFormat in _mesa_generate_mipmaps");
-         return;
-      }
-
-      /* allocate storage for uncompressed GL_RGB or GL_RGBA images */
-      size = _mesa_bytes_per_pixel(srcImage->_BaseFormat, CHAN_TYPE)
-         * srcImage->Width * srcImage->Height * srcImage->Depth + 20;
-      /* 20 extra bytes, just be safe when calling last FetchTexel */
-      srcData = (GLubyte *) malloc(size);
-      if (!srcData) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");
-         return;
-      }
-      dstData = (GLubyte *) malloc(size / 2);  /* 1/4 would probably be OK */
-      if (!dstData) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");
-         free((void *) srcData);
-         return;
-      }
-
-      /* decompress base image here */
-      dst = (GLchan *) srcData;
-      for (row = 0; row < srcImage->Height; row++) {
-         GLuint col;
-         for (col = 0; col < srcImage->Width; col++) {
-            srcImage->FetchTexelc(srcImage, col, row, 0, dst);
-            dst += components;
-         }
-      }
-   }
-   else {
-      /* uncompressed */
-      convertFormat = srcImage->TexFormat;
-   }
-
-   _mesa_format_to_type_and_comps(convertFormat, &datatype, &comps);
-
-   for (level = texObj->BaseLevel; level < texObj->MaxLevel
-           && level < maxLevels - 1; level++) {
-      /* generate image[level+1] from image[level] */
-      const struct gl_texture_image *srcImage;
-      struct gl_texture_image *dstImage;
-      GLint srcWidth, srcHeight, srcDepth;
-      GLint dstWidth, dstHeight, dstDepth;
-      GLint border;
-      GLboolean nextLevel;
-
-      /* get src image parameters */
-      srcImage = _mesa_select_tex_image(ctx, texObj, target, level);
-      ASSERT(srcImage);
-      srcWidth = srcImage->Width;
-      srcHeight = srcImage->Height;
-      srcDepth = srcImage->Depth;
-      border = srcImage->Border;
-
-      nextLevel = next_mipmap_level_size(target, border,
-                                         srcWidth, srcHeight, srcDepth,
-                                         &dstWidth, &dstHeight, &dstDepth);
-      if (!nextLevel) {
-         /* all done */
-         if (_mesa_is_format_compressed(srcImage->TexFormat)) {
-            free((void *) srcData);
-            free(dstData);
-         }
-         return;
-      }
-
-      /* get dest gl_texture_image */
-      dstImage = _mesa_get_tex_image(ctx, texObj, target, level + 1);
-      if (!dstImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
-         return;
-      }
-
-      /* Free old image data */
-      if (dstImage->Data)
-         ctx->Driver.FreeTexImageData(ctx, dstImage);
-
-      /* initialize new image */
-      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
-                                 dstDepth, border, srcImage->InternalFormat,
-                                 srcImage->TexFormat);
-      dstImage->DriverData = NULL;
-      dstImage->FetchTexelc = srcImage->FetchTexelc;
-      dstImage->FetchTexelf = srcImage->FetchTexelf;
-
-      /* Alloc new teximage data buffer */
-      {
-         GLuint size = _mesa_format_image_size(dstImage->TexFormat,
-                                               dstWidth, dstHeight, dstDepth);
-         dstImage->Data = _mesa_alloc_texmemory(size);
-         if (!dstImage->Data) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
-            return;
-         }
-      }
-
-      /* Setup src and dest data pointers */
-      if (_mesa_is_format_compressed(dstImage->TexFormat)) {
-         /* srcData and dstData are already set */
-         ASSERT(srcData);
-         ASSERT(dstData);
-      }
-      else {
-         srcData = (const GLubyte *) srcImage->Data;
-         dstData = (GLubyte *) dstImage->Data;
-      }
-
-      ASSERT(dstImage->TexFormat);
-      ASSERT(dstImage->FetchTexelc);
-      ASSERT(dstImage->FetchTexelf);
-
-      _mesa_generate_mipmap_level(target, datatype, comps, border,
-                                  srcWidth, srcHeight, srcDepth, 
-                                  srcData, srcImage->RowStride,
-                                  dstWidth, dstHeight, dstDepth, 
-                                  dstData, dstImage->RowStride);
-
-
-      if (_mesa_is_format_compressed(dstImage->TexFormat)) {
-         GLubyte *temp;
-         /* compress image from dstData into dstImage->Data */
-         const GLenum srcFormat = _mesa_get_format_base_format(convertFormat);
-         GLint dstRowStride
-            = _mesa_format_row_stride(dstImage->TexFormat, dstWidth);
-         ASSERT(srcFormat == GL_RGB || srcFormat == GL_RGBA);
-
-         _mesa_texstore(ctx, 2, dstImage->_BaseFormat,
-                        dstImage->TexFormat,
-                        dstImage->Data,
-                        0, 0, 0, /* dstX/Y/Zoffset */
-                        dstRowStride, 0, /* strides */
-                        dstWidth, dstHeight, 1, /* size */
-                        srcFormat, CHAN_TYPE,
-                        dstData, /* src data, actually */
-                        &ctx->DefaultPacking);
-
-         /* swap src and dest pointers */
-         temp = (GLubyte *) srcData;
-         srcData = dstData;
-         dstData = temp;
-      }
-
-   } /* loop over mipmap levels */
-}
-
-
-/**
- * Helper function for drivers which need to rescale texture images to
- * certain aspect ratios.
- * Nearest filtering only (for broken hardware that can't support
- * all aspect ratios).  This can be made a lot faster, but I don't
- * really care enough...
- */
-void
-_mesa_rescale_teximage2d(GLuint bytesPerPixel,
-			 GLuint srcStrideInPixels,
-			 GLuint dstRowStride,
-			 GLint srcWidth, GLint srcHeight,
-			 GLint dstWidth, GLint dstHeight,
-			 const GLvoid *srcImage, GLvoid *dstImage)
-{
-   GLint row, col;
-
-#define INNER_LOOP( TYPE, HOP, WOP )					\
-   for ( row = 0 ; row < dstHeight ; row++ ) {				\
-      GLint srcRow = row HOP hScale;					\
-      for ( col = 0 ; col < dstWidth ; col++ ) {			\
-	 GLint srcCol = col WOP wScale;					\
-	 dst[col] = src[srcRow * srcStrideInPixels + srcCol];		\
-      }									\
-      dst = (TYPE *) ((GLubyte *) dst + dstRowStride);			\
-   }									\
-
-#define RESCALE_IMAGE( TYPE )						\
-do {									\
-   const TYPE *src = (const TYPE *)srcImage;				\
-   TYPE *dst = (TYPE *)dstImage;					\
-									\
-   if ( srcHeight < dstHeight ) {					\
-      const GLint hScale = dstHeight / srcHeight;			\
-      if ( srcWidth < dstWidth ) {					\
-	 const GLint wScale = dstWidth / srcWidth;			\
-	 INNER_LOOP( TYPE, /, / );					\
-      }									\
-      else {								\
-	 const GLint wScale = srcWidth / dstWidth;			\
-	 INNER_LOOP( TYPE, /, * );					\
-      }									\
-   }									\
-   else {								\
-      const GLint hScale = srcHeight / dstHeight;			\
-      if ( srcWidth < dstWidth ) {					\
-	 const GLint wScale = dstWidth / srcWidth;			\
-	 INNER_LOOP( TYPE, *, / );					\
-      }									\
-      else {								\
-	 const GLint wScale = srcWidth / dstWidth;			\
-	 INNER_LOOP( TYPE, *, * );					\
-      }									\
-   }									\
-} while (0)
-
-   switch ( bytesPerPixel ) {
-   case 4:
-      RESCALE_IMAGE( GLuint );
-      break;
-
-   case 2:
-      RESCALE_IMAGE( GLushort );
-      break;
-
-   case 1:
-      RESCALE_IMAGE( GLubyte );
-      break;
-   default:
-      _mesa_problem(NULL,"unexpected bytes/pixel in _mesa_rescale_teximage2d");
-   }
-}
-
-
-/**
- * Upscale an image by replication, not (typical) stretching.
- * We use this when the image width or height is less than a
- * certain size (4, 8) and we need to upscale an image.
- */
-void
-_mesa_upscale_teximage2d(GLsizei inWidth, GLsizei inHeight,
-                         GLsizei outWidth, GLsizei outHeight,
-                         GLint comps, const GLchan *src, GLint srcRowStride,
-                         GLchan *dest )
-{
-   GLint i, j, k;
-
-   ASSERT(outWidth >= inWidth);
-   ASSERT(outHeight >= inHeight);
-#if 0
-   ASSERT(inWidth == 1 || inWidth == 2 || inHeight == 1 || inHeight == 2);
-   ASSERT((outWidth & 3) == 0);
-   ASSERT((outHeight & 3) == 0);
-#endif
-
-   for (i = 0; i < outHeight; i++) {
-      const GLint ii = i % inHeight;
-      for (j = 0; j < outWidth; j++) {
-         const GLint jj = j % inWidth;
-         for (k = 0; k < comps; k++) {
-            dest[(i * outWidth + j) * comps + k]
-               = src[ii * srcRowStride + jj * comps + k];
-         }
-      }
-   }
-}
-
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file mipmap.c  mipmap generation and teximage resizing functions.

+ */

+

+#include "imports.h"

+#include "formats.h"

+#include "mipmap.h"

+#include "mtypes.h"

+#include "teximage.h"

+#include "texstore.h"

+#include "image.h"

+

+

+

+static GLint

+bytes_per_pixel(GLenum datatype, GLuint comps)

+{

+   GLint b = _mesa_sizeof_packed_type(datatype);

+   assert(b >= 0);

+

+   if (_mesa_type_is_packed(datatype))

+       return b;

+   else

+       return b * comps;

+}

+

+

+/**

+ * \name Support macros for do_row and do_row_3d

+ *

+ * The macro madness is here for two reasons.  First, it compacts the code

+ * slightly.  Second, it makes it much easier to adjust the specifics of the

+ * filter to tune the rounding characteristics.

+ */

+/*@{*/

+#define DECLARE_ROW_POINTERS(t, e) \

+      const t(*rowA)[e] = (const t(*)[e]) srcRowA; \

+      const t(*rowB)[e] = (const t(*)[e]) srcRowB; \

+      const t(*rowC)[e] = (const t(*)[e]) srcRowC; \

+      const t(*rowD)[e] = (const t(*)[e]) srcRowD; \

+      t(*dst)[e] = (t(*)[e]) dstRow

+

+#define DECLARE_ROW_POINTERS0(t) \

+      const t *rowA = (const t *) srcRowA; \

+      const t *rowB = (const t *) srcRowB; \

+      const t *rowC = (const t *) srcRowC; \

+      const t *rowD = (const t *) srcRowD; \

+      t *dst = (t *) dstRow

+

+#define FILTER_SUM_3D(Aj, Ak, Bj, Bk, Cj, Ck, Dj, Dk) \

+   ((unsigned) Aj + (unsigned) Ak \

+    + (unsigned) Bj + (unsigned) Bk \

+    + (unsigned) Cj + (unsigned) Ck \

+    + (unsigned) Dj + (unsigned) Dk \

+    + 4) >> 3

+

+#define FILTER_3D(e) \

+   do { \

+      dst[i][e] = FILTER_SUM_3D(rowA[j][e], rowA[k][e], \

+                                rowB[j][e], rowB[k][e], \

+                                rowC[j][e], rowC[k][e], \

+                                rowD[j][e], rowD[k][e]); \

+   } while(0)

+

+#define FILTER_SUM_3D_SIGNED(Aj, Ak, Bj, Bk, Cj, Ck, Dj, Dk) \

+   (Aj + Ak \

+    + Bj + Bk \

+    + Cj + Ck \

+    + Dj + Dk \

+    + 4) / 8

+

+#define FILTER_3D_SIGNED(e) \

+   do { \

+      dst[i][e] = FILTER_SUM_3D_SIGNED(rowA[j][e], rowA[k][e], \

+                                       rowB[j][e], rowB[k][e], \

+                                       rowC[j][e], rowC[k][e], \

+                                       rowD[j][e], rowD[k][e]); \

+   } while(0)

+

+#define FILTER_F_3D(e) \

+   do { \

+      dst[i][e] = (rowA[j][e] + rowA[k][e] \

+                   + rowB[j][e] + rowB[k][e] \

+                   + rowC[j][e] + rowC[k][e] \

+                   + rowD[j][e] + rowD[k][e]) * 0.125F; \

+   } while(0)

+

+#define FILTER_HF_3D(e) \

+   do { \

+      const GLfloat aj = _mesa_half_to_float(rowA[j][e]); \

+      const GLfloat ak = _mesa_half_to_float(rowA[k][e]); \

+      const GLfloat bj = _mesa_half_to_float(rowB[j][e]); \

+      const GLfloat bk = _mesa_half_to_float(rowB[k][e]); \

+      const GLfloat cj = _mesa_half_to_float(rowC[j][e]); \

+      const GLfloat ck = _mesa_half_to_float(rowC[k][e]); \

+      const GLfloat dj = _mesa_half_to_float(rowD[j][e]); \

+      const GLfloat dk = _mesa_half_to_float(rowD[k][e]); \

+      dst[i][e] = _mesa_float_to_half((aj + ak + bj + bk + cj + ck + dj + dk) \

+                                      * 0.125F); \

+   } while(0)

+/*@}*/

+

+

+/**

+ * Average together two rows of a source image to produce a single new

+ * row in the dest image.  It's legal for the two source rows to point

+ * to the same data.  The source width must be equal to either the

+ * dest width or two times the dest width.

+ * \param datatype  GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_FLOAT, etc.

+ * \param comps  number of components per pixel (1..4)

+ */

+static void

+do_row(GLenum datatype, GLuint comps, GLint srcWidth,

+       const GLvoid *srcRowA, const GLvoid *srcRowB,

+       GLint dstWidth, GLvoid *dstRow)

+{

+   const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;

+   const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;

+

+   ASSERT(comps >= 1);

+   ASSERT(comps <= 4);

+

+   /* This assertion is no longer valid with non-power-of-2 textures

+   assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);

+   */

+

+   if (datatype == GL_UNSIGNED_BYTE && comps == 4) {

+      GLuint i, j, k;

+      const GLubyte(*rowA)[4] = (const GLubyte(*)[4]) srcRowA;

+      const GLubyte(*rowB)[4] = (const GLubyte(*)[4]) srcRowB;

+      GLubyte(*dst)[4] = (GLubyte(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_BYTE && comps == 3) {

+      GLuint i, j, k;

+      const GLubyte(*rowA)[3] = (const GLubyte(*)[3]) srcRowA;

+      const GLubyte(*rowB)[3] = (const GLubyte(*)[3]) srcRowB;

+      GLubyte(*dst)[3] = (GLubyte(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_BYTE && comps == 2) {

+      GLuint i, j, k;

+      const GLubyte(*rowA)[2] = (const GLubyte(*)[2]) srcRowA;

+      const GLubyte(*rowB)[2] = (const GLubyte(*)[2]) srcRowB;

+      GLubyte(*dst)[2] = (GLubyte(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) >> 2;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) >> 2;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_BYTE && comps == 1) {

+      GLuint i, j, k;

+      const GLubyte *rowA = (const GLubyte *) srcRowA;

+      const GLubyte *rowB = (const GLubyte *) srcRowB;

+      GLubyte *dst = (GLubyte *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) >> 2;

+      }

+   }

+

+   else if (datatype == GL_BYTE && comps == 4) {

+      GLuint i, j, k;

+      const GLbyte(*rowA)[4] = (const GLbyte(*)[4]) srcRowA;

+      const GLbyte(*rowB)[4] = (const GLbyte(*)[4]) srcRowB;

+      GLbyte(*dst)[4] = (GLbyte(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;

+      }

+   }

+   else if (datatype == GL_BYTE && comps == 3) {

+      GLuint i, j, k;

+      const GLbyte(*rowA)[3] = (const GLbyte(*)[3]) srcRowA;

+      const GLbyte(*rowB)[3] = (const GLbyte(*)[3]) srcRowB;

+      GLbyte(*dst)[3] = (GLbyte(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+      }

+   }

+   else if (datatype == GL_BYTE && comps == 2) {

+      GLuint i, j, k;

+      const GLbyte(*rowA)[2] = (const GLbyte(*)[2]) srcRowA;

+      const GLbyte(*rowB)[2] = (const GLbyte(*)[2]) srcRowB;

+      GLbyte(*dst)[2] = (GLbyte(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+      }

+   }

+   else if (datatype == GL_BYTE && comps == 1) {

+      GLuint i, j, k;

+      const GLbyte *rowA = (const GLbyte *) srcRowA;

+      const GLbyte *rowB = (const GLbyte *) srcRowB;

+      GLbyte *dst = (GLbyte *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;

+      }

+   }

+

+   else if (datatype == GL_UNSIGNED_SHORT && comps == 4) {

+      GLuint i, j, k;

+      const GLushort(*rowA)[4] = (const GLushort(*)[4]) srcRowA;

+      const GLushort(*rowB)[4] = (const GLushort(*)[4]) srcRowB;

+      GLushort(*dst)[4] = (GLushort(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT && comps == 3) {

+      GLuint i, j, k;

+      const GLushort(*rowA)[3] = (const GLushort(*)[3]) srcRowA;

+      const GLushort(*rowB)[3] = (const GLushort(*)[3]) srcRowB;

+      GLushort(*dst)[3] = (GLushort(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT && comps == 2) {

+      GLuint i, j, k;

+      const GLushort(*rowA)[2] = (const GLushort(*)[2]) srcRowA;

+      const GLushort(*rowB)[2] = (const GLushort(*)[2]) srcRowB;

+      GLushort(*dst)[2] = (GLushort(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT && comps == 1) {

+      GLuint i, j, k;

+      const GLushort *rowA = (const GLushort *) srcRowA;

+      const GLushort *rowB = (const GLushort *) srcRowB;

+      GLushort *dst = (GLushort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;

+      }

+   }

+

+   else if (datatype == GL_SHORT && comps == 4) {

+      GLuint i, j, k;

+      const GLshort(*rowA)[4] = (const GLshort(*)[4]) srcRowA;

+      const GLshort(*rowB)[4] = (const GLshort(*)[4]) srcRowB;

+      GLshort(*dst)[4] = (GLshort(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;

+      }

+   }

+   else if (datatype == GL_SHORT && comps == 3) {

+      GLuint i, j, k;

+      const GLshort(*rowA)[3] = (const GLshort(*)[3]) srcRowA;

+      const GLshort(*rowB)[3] = (const GLshort(*)[3]) srcRowB;

+      GLshort(*dst)[3] = (GLshort(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;

+      }

+   }

+   else if (datatype == GL_SHORT && comps == 2) {

+      GLuint i, j, k;

+      const GLshort(*rowA)[2] = (const GLshort(*)[2]) srcRowA;

+      const GLshort(*rowB)[2] = (const GLshort(*)[2]) srcRowB;

+      GLshort(*dst)[2] = (GLshort(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;

+      }

+   }

+   else if (datatype == GL_SHORT && comps == 1) {

+      GLuint i, j, k;

+      const GLshort *rowA = (const GLshort *) srcRowA;

+      const GLshort *rowB = (const GLshort *) srcRowB;

+      GLshort *dst = (GLshort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;

+      }

+   }

+

+   else if (datatype == GL_FLOAT && comps == 4) {

+      GLuint i, j, k;

+      const GLfloat(*rowA)[4] = (const GLfloat(*)[4]) srcRowA;

+      const GLfloat(*rowB)[4] = (const GLfloat(*)[4]) srcRowB;

+      GLfloat(*dst)[4] = (GLfloat(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] +

+                      rowB[j][0] + rowB[k][0]) * 0.25F;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] +

+                      rowB[j][1] + rowB[k][1]) * 0.25F;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] +

+                      rowB[j][2] + rowB[k][2]) * 0.25F;

+         dst[i][3] = (rowA[j][3] + rowA[k][3] +

+                      rowB[j][3] + rowB[k][3]) * 0.25F;

+      }

+   }

+   else if (datatype == GL_FLOAT && comps == 3) {

+      GLuint i, j, k;

+      const GLfloat(*rowA)[3] = (const GLfloat(*)[3]) srcRowA;

+      const GLfloat(*rowB)[3] = (const GLfloat(*)[3]) srcRowB;

+      GLfloat(*dst)[3] = (GLfloat(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] +

+                      rowB[j][0] + rowB[k][0]) * 0.25F;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] +

+                      rowB[j][1] + rowB[k][1]) * 0.25F;

+         dst[i][2] = (rowA[j][2] + rowA[k][2] +

+                      rowB[j][2] + rowB[k][2]) * 0.25F;

+      }

+   }

+   else if (datatype == GL_FLOAT && comps == 2) {

+      GLuint i, j, k;

+      const GLfloat(*rowA)[2] = (const GLfloat(*)[2]) srcRowA;

+      const GLfloat(*rowB)[2] = (const GLfloat(*)[2]) srcRowB;

+      GLfloat(*dst)[2] = (GLfloat(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i][0] = (rowA[j][0] + rowA[k][0] +

+                      rowB[j][0] + rowB[k][0]) * 0.25F;

+         dst[i][1] = (rowA[j][1] + rowA[k][1] +

+                      rowB[j][1] + rowB[k][1]) * 0.25F;

+      }

+   }

+   else if (datatype == GL_FLOAT && comps == 1) {

+      GLuint i, j, k;

+      const GLfloat *rowA = (const GLfloat *) srcRowA;

+      const GLfloat *rowB = (const GLfloat *) srcRowB;

+      GLfloat *dst = (GLfloat *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) * 0.25F;

+      }

+   }

+

+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 4) {

+      GLuint i, j, k, comp;

+      const GLhalfARB(*rowA)[4] = (const GLhalfARB(*)[4]) srcRowA;

+      const GLhalfARB(*rowB)[4] = (const GLhalfARB(*)[4]) srcRowB;

+      GLhalfARB(*dst)[4] = (GLhalfARB(*)[4]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         for (comp = 0; comp < 4; comp++) {

+            GLfloat aj, ak, bj, bk;

+            aj = _mesa_half_to_float(rowA[j][comp]);

+            ak = _mesa_half_to_float(rowA[k][comp]);

+            bj = _mesa_half_to_float(rowB[j][comp]);

+            bk = _mesa_half_to_float(rowB[k][comp]);

+            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);

+         }

+      }

+   }

+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 3) {

+      GLuint i, j, k, comp;

+      const GLhalfARB(*rowA)[3] = (const GLhalfARB(*)[3]) srcRowA;

+      const GLhalfARB(*rowB)[3] = (const GLhalfARB(*)[3]) srcRowB;

+      GLhalfARB(*dst)[3] = (GLhalfARB(*)[3]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         for (comp = 0; comp < 3; comp++) {

+            GLfloat aj, ak, bj, bk;

+            aj = _mesa_half_to_float(rowA[j][comp]);

+            ak = _mesa_half_to_float(rowA[k][comp]);

+            bj = _mesa_half_to_float(rowB[j][comp]);

+            bk = _mesa_half_to_float(rowB[k][comp]);

+            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);

+         }

+      }

+   }

+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 2) {

+      GLuint i, j, k, comp;

+      const GLhalfARB(*rowA)[2] = (const GLhalfARB(*)[2]) srcRowA;

+      const GLhalfARB(*rowB)[2] = (const GLhalfARB(*)[2]) srcRowB;

+      GLhalfARB(*dst)[2] = (GLhalfARB(*)[2]) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         for (comp = 0; comp < 2; comp++) {

+            GLfloat aj, ak, bj, bk;

+            aj = _mesa_half_to_float(rowA[j][comp]);

+            ak = _mesa_half_to_float(rowA[k][comp]);

+            bj = _mesa_half_to_float(rowB[j][comp]);

+            bk = _mesa_half_to_float(rowB[k][comp]);

+            dst[i][comp] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);

+         }

+      }

+   }

+   else if (datatype == GL_HALF_FLOAT_ARB && comps == 1) {

+      GLuint i, j, k;

+      const GLhalfARB *rowA = (const GLhalfARB *) srcRowA;

+      const GLhalfARB *rowB = (const GLhalfARB *) srcRowB;

+      GLhalfARB *dst = (GLhalfARB *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         GLfloat aj, ak, bj, bk;

+         aj = _mesa_half_to_float(rowA[j]);

+         ak = _mesa_half_to_float(rowA[k]);

+         bj = _mesa_half_to_float(rowB[j]);

+         bk = _mesa_half_to_float(rowB[k]);

+         dst[i] = _mesa_float_to_half((aj + ak + bj + bk) * 0.25F);

+      }

+   }

+

+   else if (datatype == GL_UNSIGNED_INT && comps == 1) {

+      GLuint i, j, k;

+      const GLuint *rowA = (const GLuint *) srcRowA;

+      const GLuint *rowB = (const GLuint *) srcRowB;

+      GLuint *dst = (GLuint *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         dst[i] = (GLfloat)(rowA[j] / 4 + rowA[k] / 4 + rowB[j] / 4 + rowB[k] / 4);

+      }

+   }

+

+   else if (datatype == GL_UNSIGNED_SHORT_5_6_5 && comps == 3) {

+      GLuint i, j, k;

+      const GLushort *rowA = (const GLushort *) srcRowA;

+      const GLushort *rowB = (const GLushort *) srcRowB;

+      GLushort *dst = (GLushort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x1f;

+         const GLint rowAr1 = rowA[k] & 0x1f;

+         const GLint rowBr0 = rowB[j] & 0x1f;

+         const GLint rowBr1 = rowB[k] & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 5) & 0x3f;

+         const GLint rowAg1 = (rowA[k] >> 5) & 0x3f;

+         const GLint rowBg0 = (rowB[j] >> 5) & 0x3f;

+         const GLint rowBg1 = (rowB[k] >> 5) & 0x3f;

+         const GLint rowAb0 = (rowA[j] >> 11) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 11) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 11) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 11) & 0x1f;

+         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;

+         dst[i] = (blue << 11) | (green << 5) | red;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT_4_4_4_4 && comps == 4) {

+      GLuint i, j, k;

+      const GLushort *rowA = (const GLushort *) srcRowA;

+      const GLushort *rowB = (const GLushort *) srcRowB;

+      GLushort *dst = (GLushort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0xf;

+         const GLint rowAr1 = rowA[k] & 0xf;

+         const GLint rowBr0 = rowB[j] & 0xf;

+         const GLint rowBr1 = rowB[k] & 0xf;

+         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;

+         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;

+         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;

+         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;

+         const GLint rowAb0 = (rowA[j] >> 8) & 0xf;

+         const GLint rowAb1 = (rowA[k] >> 8) & 0xf;

+         const GLint rowBb0 = (rowB[j] >> 8) & 0xf;

+         const GLint rowBb1 = (rowB[k] >> 8) & 0xf;

+         const GLint rowAa0 = (rowA[j] >> 12) & 0xf;

+         const GLint rowAa1 = (rowA[k] >> 12) & 0xf;

+         const GLint rowBa0 = (rowB[j] >> 12) & 0xf;

+         const GLint rowBa1 = (rowB[k] >> 12) & 0xf;

+         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;

+         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;

+         dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV && comps == 4) {

+      GLuint i, j, k;

+      const GLushort *rowA = (const GLushort *) srcRowA;

+      const GLushort *rowB = (const GLushort *) srcRowB;

+      GLushort *dst = (GLushort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x1f;

+         const GLint rowAr1 = rowA[k] & 0x1f;

+         const GLint rowBr0 = rowB[j] & 0x1f;

+         const GLint rowBr1 = rowB[k] & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 5) & 0x1f;

+         const GLint rowAg1 = (rowA[k] >> 5) & 0x1f;

+         const GLint rowBg0 = (rowB[j] >> 5) & 0x1f;

+         const GLint rowBg1 = (rowB[k] >> 5) & 0x1f;

+         const GLint rowAb0 = (rowA[j] >> 10) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 10) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 10) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 10) & 0x1f;

+         const GLint rowAa0 = (rowA[j] >> 15) & 0x1;

+         const GLint rowAa1 = (rowA[k] >> 15) & 0x1;

+         const GLint rowBa0 = (rowB[j] >> 15) & 0x1;

+         const GLint rowBa1 = (rowB[k] >> 15) & 0x1;

+         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;

+         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;

+         dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;

+      }

+   }

+   else if (datatype == GL_UNSIGNED_SHORT_5_5_5_1 && comps == 4) {

+      GLuint i, j, k;

+      const GLushort *rowA = (const GLushort *) srcRowA;

+      const GLushort *rowB = (const GLushort *) srcRowB;

+      GLushort *dst = (GLushort *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = (rowA[j] >> 11) & 0x1f;

+         const GLint rowAr1 = (rowA[k] >> 11) & 0x1f;

+         const GLint rowBr0 = (rowB[j] >> 11) & 0x1f;

+         const GLint rowBr1 = (rowB[k] >> 11) & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 6) & 0x1f;

+         const GLint rowAg1 = (rowA[k] >> 6) & 0x1f;

+         const GLint rowBg0 = (rowB[j] >> 6) & 0x1f;

+         const GLint rowBg1 = (rowB[k] >> 6) & 0x1f;

+         const GLint rowAb0 = (rowA[j] >> 1) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 1) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 1) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 1) & 0x1f;

+         const GLint rowAa0 = (rowA[j] & 0x1);

+         const GLint rowAa1 = (rowA[k] & 0x1);

+         const GLint rowBa0 = (rowB[j] & 0x1);

+         const GLint rowBa1 = (rowB[k] & 0x1);

+         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;

+         const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 2;

+         dst[i] = (red << 11) | (green << 6) | (blue << 1) | alpha;

+      }

+   }

+

+   else if (datatype == GL_UNSIGNED_BYTE_3_3_2 && comps == 3) {

+      GLuint i, j, k;

+      const GLubyte *rowA = (const GLubyte *) srcRowA;

+      const GLubyte *rowB = (const GLubyte *) srcRowB;

+      GLubyte *dst = (GLubyte *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x3;

+         const GLint rowAr1 = rowA[k] & 0x3;

+         const GLint rowBr0 = rowB[j] & 0x3;

+         const GLint rowBr1 = rowB[k] & 0x3;

+         const GLint rowAg0 = (rowA[j] >> 2) & 0x7;

+         const GLint rowAg1 = (rowA[k] >> 2) & 0x7;

+         const GLint rowBg0 = (rowB[j] >> 2) & 0x7;

+         const GLint rowBg1 = (rowB[k] >> 2) & 0x7;

+         const GLint rowAb0 = (rowA[j] >> 5) & 0x7;

+         const GLint rowAb1 = (rowA[k] >> 5) & 0x7;

+         const GLint rowBb0 = (rowB[j] >> 5) & 0x7;

+         const GLint rowBb1 = (rowB[k] >> 5) & 0x7;

+         const GLint red = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         const GLint blue = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 2;

+         dst[i] = (blue << 5) | (green << 2) | red;

+      }

+   }

+

+   else if (datatype == MESA_UNSIGNED_BYTE_4_4 && comps == 2) {

+      GLuint i, j, k;

+      const GLubyte *rowA = (const GLubyte *) srcRowA;

+      const GLubyte *rowB = (const GLubyte *) srcRowB;

+      GLubyte *dst = (GLubyte *) dstRow;

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0xf;

+         const GLint rowAr1 = rowA[k] & 0xf;

+         const GLint rowBr0 = rowB[j] & 0xf;

+         const GLint rowBr1 = rowB[k] & 0xf;

+         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;

+         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;

+         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;

+         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;

+         const GLint r = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 2;

+         const GLint g = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 2;

+         dst[i] = (g << 4) | r;

+      }

+   }

+

+   else {

+      _mesa_problem(NULL, "bad format in do_row()");

+   }

+}

+

+

+/**

+ * Average together four rows of a source image to produce a single new

+ * row in the dest image.  It's legal for the two source rows to point

+ * to the same data.  The source width must be equal to either the

+ * dest width or two times the dest width.

+ *

+ * \param datatype  GL pixel type \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT,

+ *                  \c GL_FLOAT, etc.

+ * \param comps     number of components per pixel (1..4)

+ * \param srcWidth  Width of a row in the source data

+ * \param srcRowA   Pointer to one of the rows of source data

+ * \param srcRowB   Pointer to one of the rows of source data

+ * \param srcRowC   Pointer to one of the rows of source data

+ * \param srcRowD   Pointer to one of the rows of source data

+ * \param dstWidth  Width of a row in the destination data

+ * \param srcRowA   Pointer to the row of destination data

+ */

+static void

+do_row_3D(GLenum datatype, GLuint comps, GLint srcWidth,

+          const GLvoid *srcRowA, const GLvoid *srcRowB,

+          const GLvoid *srcRowC, const GLvoid *srcRowD,

+          GLint dstWidth, GLvoid *dstRow)

+{

+   const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;

+   const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;

+   GLuint i, j, k;

+

+   ASSERT(comps >= 1);

+   ASSERT(comps <= 4);

+

+   if ((datatype == GL_UNSIGNED_BYTE) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLubyte, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+         FILTER_3D(3);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLubyte, 3);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLubyte, 2);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_BYTE) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLubyte, 1);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+      }

+   }

+   else if ((datatype == GL_BYTE) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLbyte, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D_SIGNED(0);

+         FILTER_3D_SIGNED(1);

+         FILTER_3D_SIGNED(2);

+         FILTER_3D_SIGNED(3);

+      }

+   }

+   else if ((datatype == GL_BYTE) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLbyte, 3);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D_SIGNED(0);

+         FILTER_3D_SIGNED(1);

+         FILTER_3D_SIGNED(2);

+      }

+   }

+   else if ((datatype == GL_BYTE) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLbyte, 2);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D_SIGNED(0);

+         FILTER_3D_SIGNED(1);

+       }

+   }

+   else if ((datatype == GL_BYTE) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLbyte, 1);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D_SIGNED(0);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLushort, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+         FILTER_3D(3);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLushort, 3);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLushort, 2);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLushort, 1);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+      }

+   }

+   else if ((datatype == GL_SHORT) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLshort, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+         FILTER_3D(3);

+      }

+   }

+   else if ((datatype == GL_SHORT) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLshort, 3);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+         FILTER_3D(2);

+      }

+   }

+   else if ((datatype == GL_SHORT) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLshort, 2);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+         FILTER_3D(1);

+      }

+   }

+   else if ((datatype == GL_SHORT) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLshort, 1);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_3D(0);

+      }

+   }

+   else if ((datatype == GL_FLOAT) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLfloat, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_F_3D(0);

+         FILTER_F_3D(1);

+         FILTER_F_3D(2);

+         FILTER_F_3D(3);

+      }

+   }

+   else if ((datatype == GL_FLOAT) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLfloat, 3);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_F_3D(0);

+         FILTER_F_3D(1);

+         FILTER_F_3D(2);

+      }

+   }

+   else if ((datatype == GL_FLOAT) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLfloat, 2);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_F_3D(0);

+         FILTER_F_3D(1);

+      }

+   }

+   else if ((datatype == GL_FLOAT) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLfloat, 1);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_F_3D(0);

+      }

+   }

+   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 4)) {

+      DECLARE_ROW_POINTERS(GLhalfARB, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_HF_3D(0);

+         FILTER_HF_3D(1);

+         FILTER_HF_3D(2);

+         FILTER_HF_3D(3);

+      }

+   }

+   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 3)) {

+      DECLARE_ROW_POINTERS(GLhalfARB, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_HF_3D(0);

+         FILTER_HF_3D(1);

+         FILTER_HF_3D(2);

+      }

+   }

+   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 2)) {

+      DECLARE_ROW_POINTERS(GLhalfARB, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_HF_3D(0);

+         FILTER_HF_3D(1);

+      }

+   }

+   else if ((datatype == GL_HALF_FLOAT_ARB) && (comps == 1)) {

+      DECLARE_ROW_POINTERS(GLhalfARB, 4);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         FILTER_HF_3D(0);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_INT) && (comps == 1)) {

+      const GLuint *rowA = (const GLuint *) srcRowA;

+      const GLuint *rowB = (const GLuint *) srcRowB;

+      const GLuint *rowC = (const GLuint *) srcRowC;

+      const GLuint *rowD = (const GLuint *) srcRowD;

+      GLfloat *dst = (GLfloat *) dstRow;

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const uint64_t tmp = (((uint64_t) rowA[j] + (uint64_t) rowA[k])

+                               + ((uint64_t) rowB[j] + (uint64_t) rowB[k])

+                               + ((uint64_t) rowC[j] + (uint64_t) rowC[k])

+                               + ((uint64_t) rowD[j] + (uint64_t) rowD[k]));

+         dst[i] = (GLfloat)((double) tmp * 0.125);

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT_5_6_5) && (comps == 3)) {

+      DECLARE_ROW_POINTERS0(GLushort);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x1f;

+         const GLint rowAr1 = rowA[k] & 0x1f;

+         const GLint rowBr0 = rowB[j] & 0x1f;

+         const GLint rowBr1 = rowB[k] & 0x1f;

+         const GLint rowCr0 = rowC[j] & 0x1f;

+         const GLint rowCr1 = rowC[k] & 0x1f;

+         const GLint rowDr0 = rowD[j] & 0x1f;

+         const GLint rowDr1 = rowD[k] & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 5) & 0x3f;

+         const GLint rowAg1 = (rowA[k] >> 5) & 0x3f;

+         const GLint rowBg0 = (rowB[j] >> 5) & 0x3f;

+         const GLint rowBg1 = (rowB[k] >> 5) & 0x3f;

+         const GLint rowCg0 = (rowC[j] >> 5) & 0x3f;

+         const GLint rowCg1 = (rowC[k] >> 5) & 0x3f;

+         const GLint rowDg0 = (rowD[j] >> 5) & 0x3f;

+         const GLint rowDg1 = (rowD[k] >> 5) & 0x3f;

+         const GLint rowAb0 = (rowA[j] >> 11) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 11) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 11) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 11) & 0x1f;

+         const GLint rowCb0 = (rowC[j] >> 11) & 0x1f;

+         const GLint rowCb1 = (rowC[k] >> 11) & 0x1f;

+         const GLint rowDb0 = (rowD[j] >> 11) & 0x1f;

+         const GLint rowDb1 = (rowD[k] >> 11) & 0x1f;

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,

+                                       rowCb0, rowCb1, rowDb0, rowDb1);

+         dst[i] = (b << 11) | (g << 5) | r;

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT_4_4_4_4) && (comps == 4)) {

+      DECLARE_ROW_POINTERS0(GLushort);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0xf;

+         const GLint rowAr1 = rowA[k] & 0xf;

+         const GLint rowBr0 = rowB[j] & 0xf;

+         const GLint rowBr1 = rowB[k] & 0xf;

+         const GLint rowCr0 = rowC[j] & 0xf;

+         const GLint rowCr1 = rowC[k] & 0xf;

+         const GLint rowDr0 = rowD[j] & 0xf;

+         const GLint rowDr1 = rowD[k] & 0xf;

+         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;

+         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;

+         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;

+         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;

+         const GLint rowCg0 = (rowC[j] >> 4) & 0xf;

+         const GLint rowCg1 = (rowC[k] >> 4) & 0xf;

+         const GLint rowDg0 = (rowD[j] >> 4) & 0xf;

+         const GLint rowDg1 = (rowD[k] >> 4) & 0xf;

+         const GLint rowAb0 = (rowA[j] >> 8) & 0xf;

+         const GLint rowAb1 = (rowA[k] >> 8) & 0xf;

+         const GLint rowBb0 = (rowB[j] >> 8) & 0xf;

+         const GLint rowBb1 = (rowB[k] >> 8) & 0xf;

+         const GLint rowCb0 = (rowC[j] >> 8) & 0xf;

+         const GLint rowCb1 = (rowC[k] >> 8) & 0xf;

+         const GLint rowDb0 = (rowD[j] >> 8) & 0xf;

+         const GLint rowDb1 = (rowD[k] >> 8) & 0xf;

+         const GLint rowAa0 = (rowA[j] >> 12) & 0xf;

+         const GLint rowAa1 = (rowA[k] >> 12) & 0xf;

+         const GLint rowBa0 = (rowB[j] >> 12) & 0xf;

+         const GLint rowBa1 = (rowB[k] >> 12) & 0xf;

+         const GLint rowCa0 = (rowC[j] >> 12) & 0xf;

+         const GLint rowCa1 = (rowC[k] >> 12) & 0xf;

+         const GLint rowDa0 = (rowD[j] >> 12) & 0xf;

+         const GLint rowDa1 = (rowD[k] >> 12) & 0xf;

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,

+                                       rowCb0, rowCb1, rowDb0, rowDb1);

+         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,

+                                       rowCa0, rowCa1, rowDa0, rowDa1);

+

+         dst[i] = (a << 12) | (b << 8) | (g << 4) | r;

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT_1_5_5_5_REV) && (comps == 4)) {

+      DECLARE_ROW_POINTERS0(GLushort);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x1f;

+         const GLint rowAr1 = rowA[k] & 0x1f;

+         const GLint rowBr0 = rowB[j] & 0x1f;

+         const GLint rowBr1 = rowB[k] & 0x1f;

+         const GLint rowCr0 = rowC[j] & 0x1f;

+         const GLint rowCr1 = rowC[k] & 0x1f;

+         const GLint rowDr0 = rowD[j] & 0x1f;

+         const GLint rowDr1 = rowD[k] & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 5) & 0x1f;

+         const GLint rowAg1 = (rowA[k] >> 5) & 0x1f;

+         const GLint rowBg0 = (rowB[j] >> 5) & 0x1f;

+         const GLint rowBg1 = (rowB[k] >> 5) & 0x1f;

+         const GLint rowCg0 = (rowC[j] >> 5) & 0x1f;

+         const GLint rowCg1 = (rowC[k] >> 5) & 0x1f;

+         const GLint rowDg0 = (rowD[j] >> 5) & 0x1f;

+         const GLint rowDg1 = (rowD[k] >> 5) & 0x1f;

+         const GLint rowAb0 = (rowA[j] >> 10) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 10) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 10) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 10) & 0x1f;

+         const GLint rowCb0 = (rowC[j] >> 10) & 0x1f;

+         const GLint rowCb1 = (rowC[k] >> 10) & 0x1f;

+         const GLint rowDb0 = (rowD[j] >> 10) & 0x1f;

+         const GLint rowDb1 = (rowD[k] >> 10) & 0x1f;

+         const GLint rowAa0 = (rowA[j] >> 15) & 0x1;

+         const GLint rowAa1 = (rowA[k] >> 15) & 0x1;

+         const GLint rowBa0 = (rowB[j] >> 15) & 0x1;

+         const GLint rowBa1 = (rowB[k] >> 15) & 0x1;

+         const GLint rowCa0 = (rowC[j] >> 15) & 0x1;

+         const GLint rowCa1 = (rowC[k] >> 15) & 0x1;

+         const GLint rowDa0 = (rowD[j] >> 15) & 0x1;

+         const GLint rowDa1 = (rowD[k] >> 15) & 0x1;

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,

+                                       rowCb0, rowCb1, rowDb0, rowDb1);

+         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,

+                                       rowCa0, rowCa1, rowDa0, rowDa1);

+

+         dst[i] = (a << 15) | (b << 10) | (g << 5) | r;

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_SHORT_5_5_5_1) && (comps == 4)) {

+      DECLARE_ROW_POINTERS0(GLushort);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = (rowA[j] >> 11) & 0x1f;

+         const GLint rowAr1 = (rowA[k] >> 11) & 0x1f;

+         const GLint rowBr0 = (rowB[j] >> 11) & 0x1f;

+         const GLint rowBr1 = (rowB[k] >> 11) & 0x1f;

+         const GLint rowCr0 = (rowC[j] >> 11) & 0x1f;

+         const GLint rowCr1 = (rowC[k] >> 11) & 0x1f;

+         const GLint rowDr0 = (rowD[j] >> 11) & 0x1f;

+         const GLint rowDr1 = (rowD[k] >> 11) & 0x1f;

+         const GLint rowAg0 = (rowA[j] >> 6) & 0x1f;

+         const GLint rowAg1 = (rowA[k] >> 6) & 0x1f;

+         const GLint rowBg0 = (rowB[j] >> 6) & 0x1f;

+         const GLint rowBg1 = (rowB[k] >> 6) & 0x1f;

+         const GLint rowCg0 = (rowC[j] >> 6) & 0x1f;

+         const GLint rowCg1 = (rowC[k] >> 6) & 0x1f;

+         const GLint rowDg0 = (rowD[j] >> 6) & 0x1f;

+         const GLint rowDg1 = (rowD[k] >> 6) & 0x1f;

+         const GLint rowAb0 = (rowA[j] >> 1) & 0x1f;

+         const GLint rowAb1 = (rowA[k] >> 1) & 0x1f;

+         const GLint rowBb0 = (rowB[j] >> 1) & 0x1f;

+         const GLint rowBb1 = (rowB[k] >> 1) & 0x1f;

+         const GLint rowCb0 = (rowC[j] >> 1) & 0x1f;

+         const GLint rowCb1 = (rowC[k] >> 1) & 0x1f;

+         const GLint rowDb0 = (rowD[j] >> 1) & 0x1f;

+         const GLint rowDb1 = (rowD[k] >> 1) & 0x1f;

+         const GLint rowAa0 = (rowA[j] & 0x1);

+         const GLint rowAa1 = (rowA[k] & 0x1);

+         const GLint rowBa0 = (rowB[j] & 0x1);

+         const GLint rowBa1 = (rowB[k] & 0x1);

+         const GLint rowCa0 = (rowC[j] & 0x1);

+         const GLint rowCa1 = (rowC[k] & 0x1);

+         const GLint rowDa0 = (rowD[j] & 0x1);

+         const GLint rowDa1 = (rowD[k] & 0x1);

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,

+                                       rowCb0, rowCb1, rowDb0, rowDb1);

+         const GLint a = FILTER_SUM_3D(rowAa0, rowAa1, rowBa0, rowBa1,

+                                       rowCa0, rowCa1, rowDa0, rowDa1);

+

+         dst[i] = (r << 11) | (g << 6) | (b << 1) | a;

+      }

+   }

+   else if ((datatype == GL_UNSIGNED_BYTE_3_3_2) && (comps == 3)) {

+      DECLARE_ROW_POINTERS0(GLubyte);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0x3;

+         const GLint rowAr1 = rowA[k] & 0x3;

+         const GLint rowBr0 = rowB[j] & 0x3;

+         const GLint rowBr1 = rowB[k] & 0x3;

+         const GLint rowCr0 = rowC[j] & 0x3;

+         const GLint rowCr1 = rowC[k] & 0x3;

+         const GLint rowDr0 = rowD[j] & 0x3;

+         const GLint rowDr1 = rowD[k] & 0x3;

+         const GLint rowAg0 = (rowA[j] >> 2) & 0x7;

+         const GLint rowAg1 = (rowA[k] >> 2) & 0x7;

+         const GLint rowBg0 = (rowB[j] >> 2) & 0x7;

+         const GLint rowBg1 = (rowB[k] >> 2) & 0x7;

+         const GLint rowCg0 = (rowC[j] >> 2) & 0x7;

+         const GLint rowCg1 = (rowC[k] >> 2) & 0x7;

+         const GLint rowDg0 = (rowD[j] >> 2) & 0x7;

+         const GLint rowDg1 = (rowD[k] >> 2) & 0x7;

+         const GLint rowAb0 = (rowA[j] >> 5) & 0x7;

+         const GLint rowAb1 = (rowA[k] >> 5) & 0x7;

+         const GLint rowBb0 = (rowB[j] >> 5) & 0x7;

+         const GLint rowBb1 = (rowB[k] >> 5) & 0x7;

+         const GLint rowCb0 = (rowC[j] >> 5) & 0x7;

+         const GLint rowCb1 = (rowC[k] >> 5) & 0x7;

+         const GLint rowDb0 = (rowD[j] >> 5) & 0x7;

+         const GLint rowDb1 = (rowD[k] >> 5) & 0x7;

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         const GLint b = FILTER_SUM_3D(rowAb0, rowAb1, rowBb0, rowBb1,

+                                       rowCb0, rowCb1, rowDb0, rowDb1);

+         dst[i] = (b << 5) | (g << 2) | r;

+      }

+   }

+   else if (datatype == MESA_UNSIGNED_BYTE_4_4 && comps == 2) {

+      DECLARE_ROW_POINTERS0(GLubyte);

+

+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;

+           i++, j += colStride, k += colStride) {

+         const GLint rowAr0 = rowA[j] & 0xf;

+         const GLint rowAr1 = rowA[k] & 0xf;

+         const GLint rowBr0 = rowB[j] & 0xf;

+         const GLint rowBr1 = rowB[k] & 0xf;

+         const GLint rowCr0 = rowC[j] & 0xf;

+         const GLint rowCr1 = rowC[k] & 0xf;

+         const GLint rowDr0 = rowD[j] & 0xf;

+         const GLint rowDr1 = rowD[k] & 0xf;

+         const GLint rowAg0 = (rowA[j] >> 4) & 0xf;

+         const GLint rowAg1 = (rowA[k] >> 4) & 0xf;

+         const GLint rowBg0 = (rowB[j] >> 4) & 0xf;

+         const GLint rowBg1 = (rowB[k] >> 4) & 0xf;

+         const GLint rowCg0 = (rowC[j] >> 4) & 0xf;

+         const GLint rowCg1 = (rowC[k] >> 4) & 0xf;

+         const GLint rowDg0 = (rowD[j] >> 4) & 0xf;

+         const GLint rowDg1 = (rowD[k] >> 4) & 0xf;

+         const GLint r = FILTER_SUM_3D(rowAr0, rowAr1, rowBr0, rowBr1,

+                                       rowCr0, rowCr1, rowDr0, rowDr1);

+         const GLint g = FILTER_SUM_3D(rowAg0, rowAg1, rowBg0, rowBg1,

+                                       rowCg0, rowCg1, rowDg0, rowDg1);

+         dst[i] = (g << 4) | r;

+      }

+   }

+   else {

+      _mesa_problem(NULL, "bad format in do_row()");

+   }

+}

+

+

+/*

+ * These functions generate a 1/2-size mipmap image from a source image.

+ * Texture borders are handled by copying or averaging the source image's

+ * border texels, depending on the scale-down factor.

+ */

+

+static void

+make_1d_mipmap(GLenum datatype, GLuint comps, GLint border,

+               GLint srcWidth, const GLubyte *srcPtr,

+               GLint dstWidth, GLubyte *dstPtr)

+{

+   const GLint bpt = bytes_per_pixel(datatype, comps);

+   const GLubyte *src;

+   GLubyte *dst;

+

+   /* skip the border pixel, if any */

+   src = srcPtr + border * bpt;

+   dst = dstPtr + border * bpt;

+

+   /* we just duplicate the input row, kind of hack, saves code */

+   do_row(datatype, comps, srcWidth - 2 * border, src, src,

+          dstWidth - 2 * border, dst);

+

+   if (border) {

+      /* copy left-most pixel from source */

+      assert(dstPtr);

+      assert(srcPtr);

+      memcpy(dstPtr, srcPtr, bpt);

+      /* copy right-most pixel from source */

+      memcpy(dstPtr + (dstWidth - 1) * bpt,

+             srcPtr + (srcWidth - 1) * bpt,

+             bpt);

+   }

+}

+

+

+static void

+make_2d_mipmap(GLenum datatype, GLuint comps, GLint border,

+               GLint srcWidth, GLint srcHeight,

+	       const GLubyte *srcPtr, GLint srcRowStride,

+               GLint dstWidth, GLint dstHeight,

+	       GLubyte *dstPtr, GLint dstRowStride)

+{

+   const GLint bpt = bytes_per_pixel(datatype, comps);

+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */

+   const GLint dstWidthNB = dstWidth - 2 * border;

+   const GLint dstHeightNB = dstHeight - 2 * border;

+   const GLint srcRowBytes = bpt * srcRowStride;

+   const GLint dstRowBytes = bpt * dstRowStride;

+   const GLubyte *srcA, *srcB;

+   GLubyte *dst;

+   GLint row, srcRowStep;

+

+   /* Compute src and dst pointers, skipping any border */

+   srcA = srcPtr + border * ((srcWidth + 1) * bpt);

+   if (srcHeight > 1 && srcHeight > dstHeight) {

+      /* sample from two source rows */

+      srcB = srcA + srcRowBytes;

+      srcRowStep = 2;

+   }

+   else {

+      /* sample from one source row */

+      srcB = srcA;

+      srcRowStep = 1;

+   }

+

+   dst = dstPtr + border * ((dstWidth + 1) * bpt);

+

+   for (row = 0; row < dstHeightNB; row++) {

+      do_row(datatype, comps, srcWidthNB, srcA, srcB,

+             dstWidthNB, dst);

+      srcA += srcRowStep * srcRowBytes;

+      srcB += srcRowStep * srcRowBytes;

+      dst += dstRowBytes;

+   }

+

+   /* This is ugly but probably won't be used much */

+   if (border > 0) {

+      /* fill in dest border */

+      /* lower-left border pixel */

+      assert(dstPtr);

+      assert(srcPtr);

+      memcpy(dstPtr, srcPtr, bpt);

+      /* lower-right border pixel */

+      memcpy(dstPtr + (dstWidth - 1) * bpt,

+             srcPtr + (srcWidth - 1) * bpt, bpt);

+      /* upper-left border pixel */

+      memcpy(dstPtr + dstWidth * (dstHeight - 1) * bpt,

+             srcPtr + srcWidth * (srcHeight - 1) * bpt, bpt);

+      /* upper-right border pixel */

+      memcpy(dstPtr + (dstWidth * dstHeight - 1) * bpt,

+             srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);

+      /* lower border */

+      do_row(datatype, comps, srcWidthNB,

+             srcPtr + bpt,

+             srcPtr + bpt,

+             dstWidthNB, dstPtr + bpt);

+      /* upper border */

+      do_row(datatype, comps, srcWidthNB,

+             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,

+             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,

+             dstWidthNB,

+             dstPtr + (dstWidth * (dstHeight - 1) + 1) * bpt);

+      /* left and right borders */

+      if (srcHeight == dstHeight) {

+         /* copy border pixel from src to dst */

+         for (row = 1; row < srcHeight; row++) {

+            memcpy(dstPtr + dstWidth * row * bpt,

+                   srcPtr + srcWidth * row * bpt, bpt);

+            memcpy(dstPtr + (dstWidth * row + dstWidth - 1) * bpt,

+                   srcPtr + (srcWidth * row + srcWidth - 1) * bpt, bpt);

+         }

+      }

+      else {

+         /* average two src pixels each dest pixel */

+         for (row = 0; row < dstHeightNB; row += 2) {

+            do_row(datatype, comps, 1,

+                   srcPtr + (srcWidth * (row * 2 + 1)) * bpt,

+                   srcPtr + (srcWidth * (row * 2 + 2)) * bpt,

+                   1, dstPtr + (dstWidth * row + 1) * bpt);

+            do_row(datatype, comps, 1,

+                   srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,

+                   srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,

+                   1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);

+         }

+      }

+   }

+}

+

+

+static void

+make_3d_mipmap(GLenum datatype, GLuint comps, GLint border,

+               GLint srcWidth, GLint srcHeight, GLint srcDepth,

+               const GLubyte *srcPtr, GLint srcRowStride,

+               GLint dstWidth, GLint dstHeight, GLint dstDepth,

+               GLubyte *dstPtr, GLint dstRowStride)

+{

+   const GLint bpt = bytes_per_pixel(datatype, comps);

+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */

+   const GLint srcDepthNB = srcDepth - 2 * border;

+   const GLint dstWidthNB = dstWidth - 2 * border;

+   const GLint dstHeightNB = dstHeight - 2 * border;

+   const GLint dstDepthNB = dstDepth - 2 * border;

+   GLint img, row;

+   GLint bytesPerSrcImage, bytesPerDstImage;

+   GLint bytesPerSrcRow, bytesPerDstRow;

+   GLint srcImageOffset, srcRowOffset;

+

+   (void) srcDepthNB; /* silence warnings */

+

+

+   bytesPerSrcImage = srcWidth * srcHeight * bpt;

+   bytesPerDstImage = dstWidth * dstHeight * bpt;

+

+   bytesPerSrcRow = srcWidth * bpt;

+   bytesPerDstRow = dstWidth * bpt;

+

+   /* Offset between adjacent src images to be averaged together */

+   srcImageOffset = (srcDepth == dstDepth) ? 0 : bytesPerSrcImage;

+

+   /* Offset between adjacent src rows to be averaged together */

+   srcRowOffset = (srcHeight == dstHeight) ? 0 : srcWidth * bpt;

+

+   /*

+    * Need to average together up to 8 src pixels for each dest pixel.

+    * Break that down into 3 operations:

+    *   1. take two rows from source image and average them together.

+    *   2. take two rows from next source image and average them together.

+    *   3. take the two averaged rows and average them for the final dst row.

+    */

+

+   /*

+   printf("mip3d %d x %d x %d  ->  %d x %d x %d\n",

+          srcWidth, srcHeight, srcDepth, dstWidth, dstHeight, dstDepth);

+   */

+

+   for (img = 0; img < dstDepthNB; img++) {

+      /* first source image pointer, skipping border */

+      const GLubyte *imgSrcA = srcPtr

+         + (bytesPerSrcImage + bytesPerSrcRow + border) * bpt * border

+         + img * (bytesPerSrcImage + srcImageOffset);

+      /* second source image pointer, skipping border */

+      const GLubyte *imgSrcB = imgSrcA + srcImageOffset;

+      /* address of the dest image, skipping border */

+      GLubyte *imgDst = dstPtr

+         + (bytesPerDstImage + bytesPerDstRow + border) * bpt * border

+         + img * bytesPerDstImage;

+

+      /* setup the four source row pointers and the dest row pointer */

+      const GLubyte *srcImgARowA = imgSrcA;

+      const GLubyte *srcImgARowB = imgSrcA + srcRowOffset;

+      const GLubyte *srcImgBRowA = imgSrcB;

+      const GLubyte *srcImgBRowB = imgSrcB + srcRowOffset;

+      GLubyte *dstImgRow = imgDst;

+

+      for (row = 0; row < dstHeightNB; row++) {

+         do_row_3D(datatype, comps, srcWidthNB, 

+                   srcImgARowA, srcImgARowB,

+                   srcImgBRowA, srcImgBRowB,

+                   dstWidthNB, dstImgRow);

+

+         /* advance to next rows */

+         srcImgARowA += bytesPerSrcRow + srcRowOffset;

+         srcImgARowB += bytesPerSrcRow + srcRowOffset;

+         srcImgBRowA += bytesPerSrcRow + srcRowOffset;

+         srcImgBRowB += bytesPerSrcRow + srcRowOffset;

+         dstImgRow += bytesPerDstRow;

+      }

+   }

+

+

+   /* Luckily we can leverage the make_2d_mipmap() function here! */

+   if (border > 0) {

+      /* do front border image */

+      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight, srcPtr, srcRowStride,

+                     dstWidth, dstHeight, dstPtr, dstRowStride);

+      /* do back border image */

+      make_2d_mipmap(datatype, comps, 1, srcWidth, srcHeight,

+                     srcPtr + bytesPerSrcImage * (srcDepth - 1), srcRowStride,

+                     dstWidth, dstHeight,

+                     dstPtr + bytesPerDstImage * (dstDepth - 1), dstRowStride);

+      /* do four remaining border edges that span the image slices */

+      if (srcDepth == dstDepth) {

+         /* just copy border pixels from src to dst */

+         for (img = 0; img < dstDepthNB; img++) {

+            const GLubyte *src;

+            GLubyte *dst;

+

+            /* do border along [img][row=0][col=0] */

+            src = srcPtr + (img + 1) * bytesPerSrcImage;

+            dst = dstPtr + (img + 1) * bytesPerDstImage;

+            memcpy(dst, src, bpt);

+

+            /* do border along [img][row=dstHeight-1][col=0] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (srcHeight - 1) * bytesPerSrcRow;

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (dstHeight - 1) * bytesPerDstRow;

+            memcpy(dst, src, bpt);

+

+            /* do border along [img][row=0][col=dstWidth-1] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (srcWidth - 1) * bpt;

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (dstWidth - 1) * bpt;

+            memcpy(dst, src, bpt);

+

+            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (bytesPerSrcImage - bpt);

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (bytesPerDstImage - bpt);

+            memcpy(dst, src, bpt);

+         }

+      }

+      else {

+         /* average border pixels from adjacent src image pairs */

+         ASSERT(srcDepthNB == 2 * dstDepthNB);

+         for (img = 0; img < dstDepthNB; img++) {

+            const GLubyte *src;

+            GLubyte *dst;

+

+            /* do border along [img][row=0][col=0] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage;

+            dst = dstPtr + (img + 1) * bytesPerDstImage;

+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);

+

+            /* do border along [img][row=dstHeight-1][col=0] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (srcHeight - 1) * bytesPerSrcRow;

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (dstHeight - 1) * bytesPerDstRow;

+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);

+

+            /* do border along [img][row=0][col=dstWidth-1] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (srcWidth - 1) * bpt;

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (dstWidth - 1) * bpt;

+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);

+

+            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */

+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage

+                         + (bytesPerSrcImage - bpt);

+            dst = dstPtr + (img + 1) * bytesPerDstImage

+                         + (bytesPerDstImage - bpt);

+            do_row(datatype, comps, 1, src, src + srcImageOffset, 1, dst);

+         }

+      }

+   }

+}

+

+

+static void

+make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,

+                     GLint srcWidth, const GLubyte *srcPtr, GLuint srcRowStride,

+                     GLint dstWidth, GLint dstHeight,

+		     GLubyte *dstPtr, GLuint dstRowStride )

+{

+   const GLint bpt = bytes_per_pixel(datatype, comps);

+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */

+   const GLint dstWidthNB = dstWidth - 2 * border;

+   const GLint dstHeightNB = dstHeight - 2 * border;

+   const GLint srcRowBytes = bpt * srcRowStride;

+   const GLint dstRowBytes = bpt * dstRowStride;

+   const GLubyte *src;

+   GLubyte *dst;

+   GLint row;

+

+   /* Compute src and dst pointers, skipping any border */

+   src = srcPtr + border * ((srcWidth + 1) * bpt);

+   dst = dstPtr + border * ((dstWidth + 1) * bpt);

+

+   for (row = 0; row < dstHeightNB; row++) {

+      do_row(datatype, comps, srcWidthNB, src, src,

+             dstWidthNB, dst);

+      src += srcRowBytes;

+      dst += dstRowBytes;

+   }

+

+   if (border) {

+      /* copy left-most pixel from source */

+      assert(dstPtr);

+      assert(srcPtr);

+      memcpy(dstPtr, srcPtr, bpt);

+      /* copy right-most pixel from source */

+      memcpy(dstPtr + (dstWidth - 1) * bpt,

+             srcPtr + (srcWidth - 1) * bpt,

+             bpt);

+   }

+}

+

+

+/**

+ * \bug

+ * There is quite a bit of refactoring that could be done with this function

+ * and \c make_2d_mipmap.

+ */

+static void

+make_2d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,

+                     GLint srcWidth, GLint srcHeight,

+		     const GLubyte *srcPtr, GLint srcRowStride,

+                     GLint dstWidth, GLint dstHeight, GLint dstDepth,

+                     GLubyte *dstPtr, GLint dstRowStride)

+{

+   const GLint bpt = bytes_per_pixel(datatype, comps);

+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */

+   const GLint dstWidthNB = dstWidth - 2 * border;

+   const GLint dstHeightNB = dstHeight - 2 * border;

+   const GLint dstDepthNB = dstDepth - 2 * border;

+   const GLint srcRowBytes = bpt * srcRowStride;

+   const GLint dstRowBytes = bpt * dstRowStride;

+   const GLubyte *srcA, *srcB;

+   GLubyte *dst;

+   GLint layer;

+   GLint row;

+

+   /* Compute src and dst pointers, skipping any border */

+   srcA = srcPtr + border * ((srcWidth + 1) * bpt);

+   if (srcHeight > 1) 

+      srcB = srcA + srcRowBytes;

+   else

+      srcB = srcA;

+   dst = dstPtr + border * ((dstWidth + 1) * bpt);

+

+   for (layer = 0; layer < dstDepthNB; layer++) {

+      for (row = 0; row < dstHeightNB; row++) {

+         do_row(datatype, comps, srcWidthNB, srcA, srcB,

+                dstWidthNB, dst);

+         srcA += 2 * srcRowBytes;

+         srcB += 2 * srcRowBytes;

+         dst += dstRowBytes;

+      }

+

+      /* This is ugly but probably won't be used much */

+      if (border > 0) {

+         /* fill in dest border */

+         /* lower-left border pixel */

+         assert(dstPtr);

+         assert(srcPtr);

+         memcpy(dstPtr, srcPtr, bpt);

+         /* lower-right border pixel */

+         memcpy(dstPtr + (dstWidth - 1) * bpt,

+                srcPtr + (srcWidth - 1) * bpt, bpt);

+         /* upper-left border pixel */

+         memcpy(dstPtr + dstWidth * (dstHeight - 1) * bpt,

+                srcPtr + srcWidth * (srcHeight - 1) * bpt, bpt);

+         /* upper-right border pixel */

+         memcpy(dstPtr + (dstWidth * dstHeight - 1) * bpt,

+                srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);

+         /* lower border */

+         do_row(datatype, comps, srcWidthNB,

+                srcPtr + bpt,

+                srcPtr + bpt,

+                dstWidthNB, dstPtr + bpt);

+         /* upper border */

+         do_row(datatype, comps, srcWidthNB,

+                srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,

+                srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,

+                dstWidthNB,

+                dstPtr + (dstWidth * (dstHeight - 1) + 1) * bpt);

+         /* left and right borders */

+         if (srcHeight == dstHeight) {

+            /* copy border pixel from src to dst */

+            for (row = 1; row < srcHeight; row++) {

+               memcpy(dstPtr + dstWidth * row * bpt,

+                      srcPtr + srcWidth * row * bpt, bpt);

+               memcpy(dstPtr + (dstWidth * row + dstWidth - 1) * bpt,

+                      srcPtr + (srcWidth * row + srcWidth - 1) * bpt, bpt);

+            }

+         }

+         else {

+            /* average two src pixels each dest pixel */

+            for (row = 0; row < dstHeightNB; row += 2) {

+               do_row(datatype, comps, 1,

+                      srcPtr + (srcWidth * (row * 2 + 1)) * bpt,

+                      srcPtr + (srcWidth * (row * 2 + 2)) * bpt,

+                      1, dstPtr + (dstWidth * row + 1) * bpt);

+               do_row(datatype, comps, 1,

+                      srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,

+                      srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,

+                      1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);

+            }

+         }

+      }

+   }

+}

+

+

+/**

+ * Down-sample a texture image to produce the next lower mipmap level.

+ * \param comps  components per texel (1, 2, 3 or 4)

+ * \param srcRowStride  stride between source rows, in texels

+ * \param dstRowStride  stride between destination rows, in texels

+ */

+void

+_mesa_generate_mipmap_level(GLenum target,

+                            GLenum datatype, GLuint comps,

+                            GLint border,

+                            GLint srcWidth, GLint srcHeight, GLint srcDepth,

+                            const GLubyte *srcData,

+                            GLint srcRowStride,

+                            GLint dstWidth, GLint dstHeight, GLint dstDepth,

+                            GLubyte *dstData,

+                            GLint dstRowStride)

+{

+   /*

+    * We use simple 2x2 averaging to compute the next mipmap level.

+    */

+   switch (target) {

+   case GL_TEXTURE_1D:

+      make_1d_mipmap(datatype, comps, border,

+                     srcWidth, srcData,

+                     dstWidth, dstData);

+      break;

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+      make_2d_mipmap(datatype, comps, border,

+                     srcWidth, srcHeight, srcData, srcRowStride,

+                     dstWidth, dstHeight, dstData, dstRowStride);

+      break;

+   case GL_TEXTURE_3D:

+      make_3d_mipmap(datatype, comps, border,

+                     srcWidth, srcHeight, srcDepth,

+                     srcData, srcRowStride,

+                     dstWidth, dstHeight, dstDepth,

+                     dstData, dstRowStride);

+      break;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+      make_1d_stack_mipmap(datatype, comps, border,

+                           srcWidth, srcData, srcRowStride,

+                           dstWidth, dstHeight,

+                           dstData, dstRowStride);

+      break;

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      make_2d_stack_mipmap(datatype, comps, border,

+                           srcWidth, srcHeight,

+                           srcData, srcRowStride,

+                           dstWidth, dstHeight,

+                           dstDepth, dstData, dstRowStride);

+      break;

+   case GL_TEXTURE_RECTANGLE_NV:

+      /* no mipmaps, do nothing */

+      break;

+   default:

+      _mesa_problem(NULL, "bad dimensions in _mesa_generate_mipmaps");

+      return;

+   }

+}

+

+

+/**

+ * compute next (level+1) image size

+ * \return GL_FALSE if no smaller size can be generated (eg. src is 1x1x1 size)

+ */

+static GLboolean

+next_mipmap_level_size(GLenum target, GLint border,

+                       GLint srcWidth, GLint srcHeight, GLint srcDepth,

+                       GLint *dstWidth, GLint *dstHeight, GLint *dstDepth)

+{

+   if (srcWidth - 2 * border > 1) {

+      *dstWidth = (srcWidth - 2 * border) / 2 + 2 * border;

+   }

+   else {

+      *dstWidth = srcWidth; /* can't go smaller */

+   }

+

+   if ((srcHeight - 2 * border > 1) && 

+       (target != GL_TEXTURE_1D_ARRAY_EXT)) {

+      *dstHeight = (srcHeight - 2 * border) / 2 + 2 * border;

+   }

+   else {

+      *dstHeight = srcHeight; /* can't go smaller */

+   }

+

+   if ((srcDepth - 2 * border > 1) &&

+       (target != GL_TEXTURE_2D_ARRAY_EXT)) {

+      *dstDepth = (srcDepth - 2 * border) / 2 + 2 * border;

+   }

+   else {

+      *dstDepth = srcDepth; /* can't go smaller */

+   }

+

+   if (*dstWidth == srcWidth &&

+       *dstHeight == srcHeight &&

+       *dstDepth == srcDepth) {

+      return GL_FALSE;

+   }

+   else {

+      return GL_TRUE;

+   }

+}

+

+

+

+

+/**

+ * Automatic mipmap generation.

+ * This is the fallback/default function for ctx->Driver.GenerateMipmap().

+ * Generate a complete set of mipmaps from texObj's BaseLevel image.

+ * Stop at texObj's MaxLevel or when we get to the 1x1 texture.

+ * For cube maps, target will be one of

+ * GL_TEXTURE_CUBE_MAP_POSITIVE/NEGATIVE_X/Y/Z; never GL_TEXTURE_CUBE_MAP.

+ */

+void

+_mesa_generate_mipmap(struct gl_context *ctx, GLenum target,

+                      struct gl_texture_object *texObj)

+{

+   const struct gl_texture_image *srcImage;

+   gl_format convertFormat;

+   const GLubyte *srcData = NULL;

+   GLubyte *dstData = NULL;

+   GLint level, maxLevels;

+   GLenum datatype;

+   GLuint comps;

+

+   ASSERT(texObj);

+   srcImage = _mesa_select_tex_image(ctx, texObj, target, texObj->BaseLevel);

+   ASSERT(srcImage);

+

+   maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);

+   ASSERT(maxLevels > 0);  /* bad target */

+

+   /* Find convertFormat - the format that do_row() will process */

+

+   if (_mesa_is_format_compressed(srcImage->TexFormat)) {

+      /* setup for compressed textures - need to allocate temporary

+       * image buffers to hold uncompressed images.

+       */

+      GLuint row;

+      GLint  components, size;

+      GLchan *dst;

+

+      assert(texObj->Target == GL_TEXTURE_2D ||

+             texObj->Target == GL_TEXTURE_CUBE_MAP_ARB);

+

+      if (srcImage->_BaseFormat == GL_RGB) {

+         convertFormat = MESA_FORMAT_RGB888;

+         components = 3;

+      } else if (srcImage->_BaseFormat == GL_RED) {

+         convertFormat = MESA_FORMAT_R8;

+         components = 1;

+      } else if (srcImage->_BaseFormat == GL_RG) {

+         convertFormat = MESA_FORMAT_RG88;

+         components = 2;

+      } else if (srcImage->_BaseFormat == GL_RGBA) {

+         convertFormat = MESA_FORMAT_RGBA8888;

+         components = 4;

+      } else if (srcImage->_BaseFormat == GL_LUMINANCE) {

+         convertFormat = MESA_FORMAT_L8;

+         components = 1;

+      } else if (srcImage->_BaseFormat == GL_LUMINANCE_ALPHA) {

+         convertFormat = MESA_FORMAT_AL88;

+         components = 2;

+      } else {

+         _mesa_problem(ctx, "bad srcImage->_BaseFormat in _mesa_generate_mipmaps");

+         return;

+      }

+

+      /* allocate storage for uncompressed GL_RGB or GL_RGBA images */

+      size = _mesa_bytes_per_pixel(srcImage->_BaseFormat, CHAN_TYPE)

+         * srcImage->Width * srcImage->Height * srcImage->Depth + 20;

+      /* 20 extra bytes, just be safe when calling last FetchTexel */

+      srcData = (GLubyte *) malloc(size);

+      if (!srcData) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");

+         return;

+      }

+      dstData = (GLubyte *) malloc(size / 2);  /* 1/4 would probably be OK */

+      if (!dstData) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");

+         free((void *) srcData);

+         return;

+      }

+

+      /* decompress base image here */

+      dst = (GLchan *) srcData;

+      for (row = 0; row < srcImage->Height; row++) {

+         GLuint col;

+         for (col = 0; col < srcImage->Width; col++) {

+            srcImage->FetchTexelc(srcImage, col, row, 0, dst);

+            dst += components;

+         }

+      }

+   }

+   else {

+      /* uncompressed */

+      convertFormat = srcImage->TexFormat;

+   }

+

+   _mesa_format_to_type_and_comps(convertFormat, &datatype, &comps);

+

+   for (level = texObj->BaseLevel; level < texObj->MaxLevel

+           && level < maxLevels - 1; level++) {

+      /* generate image[level+1] from image[level] */

+      const struct gl_texture_image *srcImage;

+      struct gl_texture_image *dstImage;

+      GLint srcWidth, srcHeight, srcDepth;

+      GLint dstWidth, dstHeight, dstDepth;

+      GLint border;

+      GLboolean nextLevel;

+

+      /* get src image parameters */

+      srcImage = _mesa_select_tex_image(ctx, texObj, target, level);

+      ASSERT(srcImage);

+      srcWidth = srcImage->Width;

+      srcHeight = srcImage->Height;

+      srcDepth = srcImage->Depth;

+      border = srcImage->Border;

+

+      nextLevel = next_mipmap_level_size(target, border,

+                                         srcWidth, srcHeight, srcDepth,

+                                         &dstWidth, &dstHeight, &dstDepth);

+      if (!nextLevel) {

+         /* all done */

+         if (_mesa_is_format_compressed(srcImage->TexFormat)) {

+            free((void *) srcData);

+            free(dstData);

+         }

+         return;

+      }

+

+      /* get dest gl_texture_image */

+      dstImage = _mesa_get_tex_image(ctx, texObj, target, level + 1);

+      if (!dstImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");

+         return;

+      }

+

+      /* Free old image data */

+      if (dstImage->Data)

+         ctx->Driver.FreeTexImageData(ctx, dstImage);

+

+      /* initialize new image */

+      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,

+                                 dstDepth, border, srcImage->InternalFormat,

+                                 srcImage->TexFormat);

+      dstImage->DriverData = NULL;

+      dstImage->FetchTexelc = srcImage->FetchTexelc;

+      dstImage->FetchTexelf = srcImage->FetchTexelf;

+

+      /* Alloc new teximage data buffer */

+      {

+         GLuint size = _mesa_format_image_size(dstImage->TexFormat,

+                                               dstWidth, dstHeight, dstDepth);

+         dstImage->Data = _mesa_alloc_texmemory(size);

+         if (!dstImage->Data) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");

+            return;

+         }

+      }

+

+      /* Setup src and dest data pointers */

+      if (_mesa_is_format_compressed(dstImage->TexFormat)) {

+         /* srcData and dstData are already set */

+         ASSERT(srcData);

+         ASSERT(dstData);

+      }

+      else {

+         srcData = (const GLubyte *) srcImage->Data;

+         dstData = (GLubyte *) dstImage->Data;

+      }

+

+      ASSERT(dstImage->TexFormat);

+      ASSERT(dstImage->FetchTexelc);

+      ASSERT(dstImage->FetchTexelf);

+

+      _mesa_generate_mipmap_level(target, datatype, comps, border,

+                                  srcWidth, srcHeight, srcDepth, 

+                                  srcData, srcImage->RowStride,

+                                  dstWidth, dstHeight, dstDepth, 

+                                  dstData, dstImage->RowStride);

+

+

+      if (_mesa_is_format_compressed(dstImage->TexFormat)) {

+         GLubyte *temp;

+         /* compress image from dstData into dstImage->Data */

+         const GLenum srcFormat = _mesa_get_format_base_format(convertFormat);

+         GLint dstRowStride

+            = _mesa_format_row_stride(dstImage->TexFormat, dstWidth);

+         ASSERT(srcFormat == GL_RGB || srcFormat == GL_RGBA);

+

+         _mesa_texstore(ctx, 2, dstImage->_BaseFormat,

+                        dstImage->TexFormat,

+                        dstImage->Data,

+                        0, 0, 0, /* dstX/Y/Zoffset */

+                        dstRowStride, 0, /* strides */

+                        dstWidth, dstHeight, 1, /* size */

+                        srcFormat, CHAN_TYPE,

+                        dstData, /* src data, actually */

+                        &ctx->DefaultPacking);

+

+         /* swap src and dest pointers */

+         temp = (GLubyte *) srcData;

+         srcData = dstData;

+         dstData = temp;

+      }

+

+   } /* loop over mipmap levels */

+}

+

+

+/**

+ * Helper function for drivers which need to rescale texture images to

+ * certain aspect ratios.

+ * Nearest filtering only (for broken hardware that can't support

+ * all aspect ratios).  This can be made a lot faster, but I don't

+ * really care enough...

+ */

+void

+_mesa_rescale_teximage2d(GLuint bytesPerPixel,

+			 GLuint srcStrideInPixels,

+			 GLuint dstRowStride,

+			 GLint srcWidth, GLint srcHeight,

+			 GLint dstWidth, GLint dstHeight,

+			 const GLvoid *srcImage, GLvoid *dstImage)

+{

+   GLint row, col;

+

+#define INNER_LOOP( TYPE, HOP, WOP )					\

+   for ( row = 0 ; row < dstHeight ; row++ ) {				\

+      GLint srcRow = row HOP hScale;					\

+      for ( col = 0 ; col < dstWidth ; col++ ) {			\

+	 GLint srcCol = col WOP wScale;					\

+	 dst[col] = src[srcRow * srcStrideInPixels + srcCol];		\

+      }									\

+      dst = (TYPE *) ((GLubyte *) dst + dstRowStride);			\

+   }									\

+

+#define RESCALE_IMAGE( TYPE )						\

+do {									\

+   const TYPE *src = (const TYPE *)srcImage;				\

+   TYPE *dst = (TYPE *)dstImage;					\

+									\

+   if ( srcHeight < dstHeight ) {					\

+      const GLint hScale = dstHeight / srcHeight;			\

+      if ( srcWidth < dstWidth ) {					\

+	 const GLint wScale = dstWidth / srcWidth;			\

+	 INNER_LOOP( TYPE, /, / );					\

+      }									\

+      else {								\

+	 const GLint wScale = srcWidth / dstWidth;			\

+	 INNER_LOOP( TYPE, /, * );					\

+      }									\

+   }									\

+   else {								\

+      const GLint hScale = srcHeight / dstHeight;			\

+      if ( srcWidth < dstWidth ) {					\

+	 const GLint wScale = dstWidth / srcWidth;			\

+	 INNER_LOOP( TYPE, *, / );					\

+      }									\

+      else {								\

+	 const GLint wScale = srcWidth / dstWidth;			\

+	 INNER_LOOP( TYPE, *, * );					\

+      }									\

+   }									\

+} while (0)

+

+   switch ( bytesPerPixel ) {

+   case 4:

+      RESCALE_IMAGE( GLuint );

+      break;

+

+   case 2:

+      RESCALE_IMAGE( GLushort );

+      break;

+

+   case 1:

+      RESCALE_IMAGE( GLubyte );

+      break;

+   default:

+      _mesa_problem(NULL,"unexpected bytes/pixel in _mesa_rescale_teximage2d");

+   }

+}

+

+

+/**

+ * Upscale an image by replication, not (typical) stretching.

+ * We use this when the image width or height is less than a

+ * certain size (4, 8) and we need to upscale an image.

+ */

+void

+_mesa_upscale_teximage2d(GLsizei inWidth, GLsizei inHeight,

+                         GLsizei outWidth, GLsizei outHeight,

+                         GLint comps, const GLchan *src, GLint srcRowStride,

+                         GLchan *dest )

+{

+   GLint i, j, k;

+

+   ASSERT(outWidth >= inWidth);

+   ASSERT(outHeight >= inHeight);

+#if 0

+   ASSERT(inWidth == 1 || inWidth == 2 || inHeight == 1 || inHeight == 2);

+   ASSERT((outWidth & 3) == 0);

+   ASSERT((outHeight & 3) == 0);

+#endif

+

+   for (i = 0; i < outHeight; i++) {

+      const GLint ii = i % inHeight;

+      for (j = 0; j < outWidth; j++) {

+         const GLint jj = j % inWidth;

+         for (k = 0; k < comps; k++) {

+            dest[(i * outWidth + j) * comps + k]

+               = src[ii * srcRowStride + jj * comps + k];

+         }

+      }

+   }

+}

+

diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 695d93652..4e530a268 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -1,3360 +1,3360 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file mtypes.h
- * Main Mesa data structures.
- *
- * Please try to mark derived values with a leading underscore ('_').
- */
-
-#ifndef MTYPES_H
-#define MTYPES_H
-
-
-#include "main/glheader.h"
-#include "main/config.h"
-#include "main/mfeatures.h"
-#include "glapi/glapi.h"
-#include "math/m_matrix.h"	/* GLmatrix */
-#include "main/simple_list.h"	/* struct simple_node */
-#include "main/formats.h"       /* MESA_FORMAT_COUNT */
-
-
-/**
- * Color channel data type.
- */
-#if CHAN_BITS == 8
-   typedef GLubyte GLchan;
-#define CHAN_MAX 255
-#define CHAN_MAXF 255.0F
-#define CHAN_TYPE GL_UNSIGNED_BYTE
-#elif CHAN_BITS == 16
-   typedef GLushort GLchan;
-#define CHAN_MAX 65535
-#define CHAN_MAXF 65535.0F
-#define CHAN_TYPE GL_UNSIGNED_SHORT
-#elif CHAN_BITS == 32
-   typedef GLfloat GLchan;
-#define CHAN_MAX 1.0
-#define CHAN_MAXF 1.0F
-#define CHAN_TYPE GL_FLOAT
-#else
-#error "illegal number of color channel bits"
-#endif
-
-
-/**
- * Stencil buffer data type.
- */
-#if STENCIL_BITS==8
-   typedef GLubyte GLstencil;
-#elif STENCIL_BITS==16
-   typedef GLushort GLstencil;
-#else
-#  error "illegal number of stencil bits"
-#endif
-
-
-/**
- * \name 64-bit extension of GLbitfield.
- */
-/*@{*/
-typedef GLuint64 GLbitfield64;
-
-/** Set a single bit */
-#define BITFIELD64_BIT(b)      (1ULL << (b))
-
-
-/**
- * \name Some forward type declarations
- */
-/*@{*/
-struct _mesa_HashTable;
-struct gl_attrib_node;
-struct gl_list_extensions;
-struct gl_meta_state;
-struct gl_pixelstore_attrib;
-struct gl_program_cache;
-struct gl_texture_format;
-struct gl_texture_image;
-struct gl_texture_object;
-struct gl_context;
-struct st_context;
-/*@}*/
-
-
-/** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */
-#define PRIM_OUTSIDE_BEGIN_END   (GL_POLYGON+1)
-#define PRIM_INSIDE_UNKNOWN_PRIM (GL_POLYGON+2)
-#define PRIM_UNKNOWN             (GL_POLYGON+3)
-
-
-/**
- * Shader stages. Note that these will become 5 with tessellation.
- * These MUST have the same values as gallium's PIPE_SHADER_*
- */
-typedef enum
-{
-   MESA_SHADER_VERTEX = 0,
-   MESA_SHADER_FRAGMENT = 1,
-   MESA_SHADER_GEOMETRY = 2,
-   MESA_SHADER_TYPES = 3
-} gl_shader_type;
-
-
-
-/**
- * Indexes for vertex program attributes.
- * GL_NV_vertex_program aliases generic attributes over the conventional
- * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.
- * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the
- * generic attributes are distinct/separate).
- */
-typedef enum
-{
-   VERT_ATTRIB_POS = 0,
-   VERT_ATTRIB_WEIGHT = 1,
-   VERT_ATTRIB_NORMAL = 2,
-   VERT_ATTRIB_COLOR0 = 3,
-   VERT_ATTRIB_COLOR1 = 4,
-   VERT_ATTRIB_FOG = 5,
-   VERT_ATTRIB_COLOR_INDEX = 6,
-   VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/
-   VERT_ATTRIB_EDGEFLAG = 7,
-   VERT_ATTRIB_TEX0 = 8,
-   VERT_ATTRIB_TEX1 = 9,
-   VERT_ATTRIB_TEX2 = 10,
-   VERT_ATTRIB_TEX3 = 11,
-   VERT_ATTRIB_TEX4 = 12,
-   VERT_ATTRIB_TEX5 = 13,
-   VERT_ATTRIB_TEX6 = 14,
-   VERT_ATTRIB_TEX7 = 15,
-   VERT_ATTRIB_GENERIC0 = 16,
-   VERT_ATTRIB_GENERIC1 = 17,
-   VERT_ATTRIB_GENERIC2 = 18,
-   VERT_ATTRIB_GENERIC3 = 19,
-   VERT_ATTRIB_GENERIC4 = 20,
-   VERT_ATTRIB_GENERIC5 = 21,
-   VERT_ATTRIB_GENERIC6 = 22,
-   VERT_ATTRIB_GENERIC7 = 23,
-   VERT_ATTRIB_GENERIC8 = 24,
-   VERT_ATTRIB_GENERIC9 = 25,
-   VERT_ATTRIB_GENERIC10 = 26,
-   VERT_ATTRIB_GENERIC11 = 27,
-   VERT_ATTRIB_GENERIC12 = 28,
-   VERT_ATTRIB_GENERIC13 = 29,
-   VERT_ATTRIB_GENERIC14 = 30,
-   VERT_ATTRIB_GENERIC15 = 31,
-   VERT_ATTRIB_MAX = 32
-} gl_vert_attrib;
-
-/**
- * Bitflags for vertex attributes.
- * These are used in bitfields in many places.
- */
-/*@{*/
-#define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)
-#define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)
-#define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)
-#define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)
-#define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)
-#define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)
-#define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)
-#define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)
-#define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)
-#define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)
-#define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)
-#define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)
-#define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)
-#define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)
-#define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)
-#define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)
-#define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)
-#define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)
-#define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)
-#define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)
-#define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)
-#define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)
-#define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)
-#define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)
-#define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)
-#define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)
-#define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)
-#define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)
-#define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)
-#define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)
-#define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)
-#define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)
-
-#define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))
-#define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))
-/*@}*/
-
-
-/**
- * Indexes for vertex program result attributes
- */
-typedef enum
-{
-   VERT_RESULT_HPOS = 0,
-   VERT_RESULT_COL0 = 1,
-   VERT_RESULT_COL1 = 2,
-   VERT_RESULT_FOGC = 3,
-   VERT_RESULT_TEX0 = 4,
-   VERT_RESULT_TEX1 = 5,
-   VERT_RESULT_TEX2 = 6,
-   VERT_RESULT_TEX3 = 7,
-   VERT_RESULT_TEX4 = 8,
-   VERT_RESULT_TEX5 = 9,
-   VERT_RESULT_TEX6 = 10,
-   VERT_RESULT_TEX7 = 11,
-   VERT_RESULT_PSIZ = 12,
-   VERT_RESULT_BFC0 = 13,
-   VERT_RESULT_BFC1 = 14,
-   VERT_RESULT_EDGE = 15,
-   VERT_RESULT_VAR0 = 16,  /**< shader varying */
-   VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)
-} gl_vert_result;
-
-
-/*********************************************/
-
-/**
- * Indexes for geometry program attributes.
- */
-typedef enum
-{
-   GEOM_ATTRIB_POSITION = 0,
-   GEOM_ATTRIB_COLOR0 = 1,
-   GEOM_ATTRIB_COLOR1 = 2,
-   GEOM_ATTRIB_SECONDARY_COLOR0 = 3,
-   GEOM_ATTRIB_SECONDARY_COLOR1 = 4,
-   GEOM_ATTRIB_FOG_FRAG_COORD = 5,
-   GEOM_ATTRIB_POINT_SIZE = 6,
-   GEOM_ATTRIB_CLIP_VERTEX = 7,
-   GEOM_ATTRIB_PRIMITIVE_ID = 8,
-   GEOM_ATTRIB_TEX_COORD = 9,
-
-   GEOM_ATTRIB_VAR0 = 16,
-   GEOM_ATTRIB_MAX = (GEOM_ATTRIB_VAR0 + MAX_VARYING)
-} gl_geom_attrib;
-
-/**
- * Bitflags for geometry attributes.
- * These are used in bitfields in many places.
- */
-/*@{*/
-#define GEOM_BIT_COLOR0      (1 << GEOM_ATTRIB_COLOR0)
-#define GEOM_BIT_COLOR1      (1 << GEOM_ATTRIB_COLOR1)
-#define GEOM_BIT_SCOLOR0     (1 << GEOM_ATTRIB_SECONDARY_COLOR0)
-#define GEOM_BIT_SCOLOR1     (1 << GEOM_ATTRIB_SECONDARY_COLOR1)
-#define GEOM_BIT_TEX_COORD   (1 << GEOM_ATTRIB_TEX_COORD)
-#define GEOM_BIT_FOG_COORD   (1 << GEOM_ATTRIB_FOG_FRAG_COORD)
-#define GEOM_BIT_POSITION    (1 << GEOM_ATTRIB_POSITION)
-#define GEOM_BIT_POINT_SIDE  (1 << GEOM_ATTRIB_POINT_SIZE)
-#define GEOM_BIT_CLIP_VERTEX (1 << GEOM_ATTRIB_CLIP_VERTEX)
-#define GEOM_BIT_PRIM_ID     (1 << GEOM_ATTRIB_PRIMITIVE_ID)
-#define GEOM_BIT_VAR0        (1 << GEOM_ATTRIB_VAR0)
-
-#define GEOM_BIT_VAR(g)  (1 << (GEOM_BIT_VAR0 + (g)))
-/*@}*/
-
-
-/**
- * Indexes for geometry program result attributes
- */
-typedef enum
-{
-   GEOM_RESULT_POS  = 0,
-   GEOM_RESULT_COL0  = 1,
-   GEOM_RESULT_COL1  = 2,
-   GEOM_RESULT_SCOL0 = 3,
-   GEOM_RESULT_SCOL1 = 4,
-   GEOM_RESULT_FOGC = 5,
-   GEOM_RESULT_TEX0 = 6,
-   GEOM_RESULT_TEX1 = 7,
-   GEOM_RESULT_TEX2 = 8,
-   GEOM_RESULT_TEX3 = 9,
-   GEOM_RESULT_TEX4 = 10,
-   GEOM_RESULT_TEX5 = 11,
-   GEOM_RESULT_TEX6 = 12,
-   GEOM_RESULT_TEX7 = 13,
-   GEOM_RESULT_PSIZ = 14,
-   GEOM_RESULT_CLPV = 15,
-   GEOM_RESULT_PRID = 16,
-   GEOM_RESULT_LAYR = 17,
-   GEOM_RESULT_VAR0 = 18,  /**< shader varying, should really be 16 */
-   /* ### we need to -2 because var0 is 18 instead 16 like in the others */
-   GEOM_RESULT_MAX  =  (GEOM_RESULT_VAR0 + MAX_VARYING - 2)
-} gl_geom_result;
-
-
-/**
- * Indexes for fragment program input attributes.
- */
-typedef enum
-{
-   FRAG_ATTRIB_WPOS = 0,
-   FRAG_ATTRIB_COL0 = 1,
-   FRAG_ATTRIB_COL1 = 2,
-   FRAG_ATTRIB_FOGC = 3,
-   FRAG_ATTRIB_TEX0 = 4,
-   FRAG_ATTRIB_TEX1 = 5,
-   FRAG_ATTRIB_TEX2 = 6,
-   FRAG_ATTRIB_TEX3 = 7,
-   FRAG_ATTRIB_TEX4 = 8,
-   FRAG_ATTRIB_TEX5 = 9,
-   FRAG_ATTRIB_TEX6 = 10,
-   FRAG_ATTRIB_TEX7 = 11,
-   FRAG_ATTRIB_FACE = 12,  /**< front/back face */
-   FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */
-   FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */
-   FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)
-} gl_frag_attrib;
-
-/**
- * Bitflags for fragment program input attributes.
- */
-/*@{*/
-#define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)
-#define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)
-#define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)
-#define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)
-#define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)
-#define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)
-#define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)
-#define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)
-#define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)
-#define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)
-#define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)
-#define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)
-#define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)
-#define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)
-#define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)
-
-#define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))
-#define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))
-
-#define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|	\
-			   FRAG_BIT_TEX1|	\
-			   FRAG_BIT_TEX2|	\
-			   FRAG_BIT_TEX3|	\
-			   FRAG_BIT_TEX4|	\
-			   FRAG_BIT_TEX5|	\
-			   FRAG_BIT_TEX6|	\
-			   FRAG_BIT_TEX7)
-/*@}*/
-
-
-/**
- * Fragment program results
- */
-typedef enum
-{
-   FRAG_RESULT_DEPTH = 0,
-   FRAG_RESULT_STENCIL = 1,
-   FRAG_RESULT_COLOR = 2,
-   FRAG_RESULT_DATA0 = 3,
-   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)
-} gl_frag_result;
-
-
-/**
- * Indexes for all renderbuffers
- */
-typedef enum
-{
-   /* the four standard color buffers */
-   BUFFER_FRONT_LEFT,
-   BUFFER_BACK_LEFT,
-   BUFFER_FRONT_RIGHT,
-   BUFFER_BACK_RIGHT,
-   BUFFER_DEPTH,
-   BUFFER_STENCIL,
-   BUFFER_ACCUM,
-   /* optional aux buffer */
-   BUFFER_AUX0,
-   /* generic renderbuffers */
-   BUFFER_COLOR0,
-   BUFFER_COLOR1,
-   BUFFER_COLOR2,
-   BUFFER_COLOR3,
-   BUFFER_COLOR4,
-   BUFFER_COLOR5,
-   BUFFER_COLOR6,
-   BUFFER_COLOR7,
-   BUFFER_COUNT
-} gl_buffer_index;
-
-/**
- * Bit flags for all renderbuffers
- */
-#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)
-#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)
-#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)
-#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)
-#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)
-#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)
-#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)
-#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)
-#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)
-#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)
-#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)
-#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)
-#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)
-#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)
-#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)
-#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)
-#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)
-#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)
-#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)
-
-/**
- * Mask of all the color buffer bits (but not accum).
- */
-#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \
-                            BUFFER_BIT_BACK_LEFT | \
-                            BUFFER_BIT_FRONT_RIGHT | \
-                            BUFFER_BIT_BACK_RIGHT | \
-                            BUFFER_BIT_AUX0 | \
-                            BUFFER_BIT_COLOR0 | \
-                            BUFFER_BIT_COLOR1 | \
-                            BUFFER_BIT_COLOR2 | \
-                            BUFFER_BIT_COLOR3 | \
-                            BUFFER_BIT_COLOR4 | \
-                            BUFFER_BIT_COLOR5 | \
-                            BUFFER_BIT_COLOR6 | \
-                            BUFFER_BIT_COLOR7)
-
-
-/**
- * Framebuffer configuration (aka visual / pixelformat)
- * Note: some of these fields should be boolean, but it appears that
- * code in drivers/dri/common/util.c requires int-sized fields.
- */
-struct gl_config
-{
-   GLboolean rgbMode;
-   GLboolean floatMode;
-   GLboolean colorIndexMode;  /* XXX is this used anywhere? */
-   GLuint doubleBufferMode;
-   GLuint stereoMode;
-
-   GLboolean haveAccumBuffer;
-   GLboolean haveDepthBuffer;
-   GLboolean haveStencilBuffer;
-
-   GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */
-   GLuint redMask, greenMask, blueMask, alphaMask;
-   GLint rgbBits;		/* total bits for rgb */
-   GLint indexBits;		/* total bits for colorindex */
-
-   GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
-   GLint depthBits;
-   GLint stencilBits;
-
-   GLint numAuxBuffers;
-
-   GLint level;
-
-   /* EXT_visual_rating / GLX 1.2 */
-   GLint visualRating;
-
-   /* EXT_visual_info / GLX 1.2 */
-   GLint transparentPixel;
-   /*    colors are floats scaled to ints */
-   GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
-   GLint transparentIndex;
-
-   /* ARB_multisample / SGIS_multisample */
-   GLint sampleBuffers;
-   GLint samples;
-
-   /* SGIX_pbuffer / GLX 1.3 */
-   GLint maxPbufferWidth;
-   GLint maxPbufferHeight;
-   GLint maxPbufferPixels;
-   GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */
-   GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */
-
-   /* OML_swap_method */
-   GLint swapMethod;
-
-   /* EXT_texture_from_pixmap */
-   GLint bindToTextureRgb;
-   GLint bindToTextureRgba;
-   GLint bindToMipmapTexture;
-   GLint bindToTextureTargets;
-   GLint yInverted;
-
-   /* EXT_framebuffer_sRGB */
-   GLint sRGBCapable;
-};
-
-
-/**
- * Data structure for color tables
- */
-struct gl_color_table
-{
-   GLenum InternalFormat;      /**< The user-specified format */
-   GLenum _BaseFormat;         /**< GL_ALPHA, GL_RGBA, GL_RGB, etc */
-   GLuint Size;                /**< number of entries in table */
-   GLfloat *TableF;            /**< Color table, floating point values */
-   GLubyte *TableUB;           /**< Color table, ubyte values */
-   GLubyte RedSize;
-   GLubyte GreenSize;
-   GLubyte BlueSize;
-   GLubyte AlphaSize;
-   GLubyte LuminanceSize;
-   GLubyte IntensitySize;
-};
-
-
-/**
- * \name Bit flags used for updating material values.
- */
-/*@{*/
-#define MAT_ATTRIB_FRONT_AMBIENT           0 
-#define MAT_ATTRIB_BACK_AMBIENT            1
-#define MAT_ATTRIB_FRONT_DIFFUSE           2 
-#define MAT_ATTRIB_BACK_DIFFUSE            3
-#define MAT_ATTRIB_FRONT_SPECULAR          4 
-#define MAT_ATTRIB_BACK_SPECULAR           5
-#define MAT_ATTRIB_FRONT_EMISSION          6
-#define MAT_ATTRIB_BACK_EMISSION           7
-#define MAT_ATTRIB_FRONT_SHININESS         8
-#define MAT_ATTRIB_BACK_SHININESS          9
-#define MAT_ATTRIB_FRONT_INDEXES           10
-#define MAT_ATTRIB_BACK_INDEXES            11
-#define MAT_ATTRIB_MAX                     12
-
-#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))  
-#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))  
-#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 
-#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 
-#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))
-#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))  
-
-#define MAT_INDEX_AMBIENT  0
-#define MAT_INDEX_DIFFUSE  1
-#define MAT_INDEX_SPECULAR 2
-
-#define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)
-#define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)
-#define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)
-#define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)
-#define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)
-#define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)
-#define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)
-#define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)
-#define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)
-#define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)
-#define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)
-#define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)
-
-
-#define FRONT_MATERIAL_BITS	(MAT_BIT_FRONT_EMISSION | 	\
-				 MAT_BIT_FRONT_AMBIENT |	\
-				 MAT_BIT_FRONT_DIFFUSE | 	\
-				 MAT_BIT_FRONT_SPECULAR |	\
-				 MAT_BIT_FRONT_SHININESS | 	\
-				 MAT_BIT_FRONT_INDEXES)
-
-#define BACK_MATERIAL_BITS	(MAT_BIT_BACK_EMISSION |	\
-				 MAT_BIT_BACK_AMBIENT |		\
-				 MAT_BIT_BACK_DIFFUSE |		\
-				 MAT_BIT_BACK_SPECULAR |	\
-				 MAT_BIT_BACK_SHININESS |	\
-				 MAT_BIT_BACK_INDEXES)
-
-#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
-/*@}*/
-
-
-#define EXP_TABLE_SIZE 512	/**< Specular exponent lookup table sizes */
-#define SHINE_TABLE_SIZE 256	/**< Material shininess lookup table sizes */
-
-/**
- * Material shininess lookup table.
- */
-struct gl_shine_tab
-{
-   struct gl_shine_tab *next, *prev;
-   GLfloat tab[SHINE_TABLE_SIZE+1];
-   GLfloat shininess;
-   GLuint refcount;
-};
-
-
-/**
- * Light source state.
- */
-struct gl_light
-{
-   struct gl_light *next;	/**< double linked list with sentinel */
-   struct gl_light *prev;
-
-   GLfloat Ambient[4];		/**< ambient color */
-   GLfloat Diffuse[4];		/**< diffuse color */
-   GLfloat Specular[4];		/**< specular color */
-   GLfloat EyePosition[4];	/**< position in eye coordinates */
-   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */
-   GLfloat SpotExponent;
-   GLfloat SpotCutoff;		/**< in degrees */
-   GLfloat _CosCutoffNeg;	/**< = cos(SpotCutoff) */
-   GLfloat _CosCutoff;		/**< = MAX(0, cos(SpotCutoff)) */
-   GLfloat ConstantAttenuation;
-   GLfloat LinearAttenuation;
-   GLfloat QuadraticAttenuation;
-   GLboolean Enabled;		/**< On/off flag */
-
-   /** 
-    * \name Derived fields
-    */
-   /*@{*/
-   GLbitfield _Flags;		/**< State */
-
-   GLfloat _Position[4];	/**< position in eye/obj coordinates */
-   GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */
-   GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */
-   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */
-   GLfloat _VP_inf_spot_attenuation;
-
-   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */
-   GLfloat _MatAmbient[2][3];	/**< material ambient * light ambient */
-   GLfloat _MatDiffuse[2][3];	/**< material diffuse * light diffuse */
-   GLfloat _MatSpecular[2][3];	/**< material spec * light specular */
-   GLfloat _dli;		/**< CI diffuse light intensity */
-   GLfloat _sli;		/**< CI specular light intensity */
-   /*@}*/
-};
-
-
-/**
- * Light model state.
- */
-struct gl_lightmodel
-{
-   GLfloat Ambient[4];		/**< ambient color */
-   GLboolean LocalViewer;	/**< Local (or infinite) view point? */
-   GLboolean TwoSide;		/**< Two (or one) sided lighting? */
-   GLenum ColorControl;		/**< either GL_SINGLE_COLOR
-				 *    or GL_SEPARATE_SPECULAR_COLOR */
-};
-
-
-/**
- * Material state.
- */
-struct gl_material
-{
-   GLfloat Attrib[MAT_ATTRIB_MAX][4];
-};
-
-
-/**
- * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)
- */
-struct gl_accum_attrib
-{
-   GLfloat ClearColor[4];	/**< Accumulation buffer clear color */
-};
-
-
-/**
- * Color buffer attribute group (GL_COLOR_BUFFER_BIT).
- */
-struct gl_colorbuffer_attrib
-{
-   GLuint ClearIndex;			/**< Index to use for glClear */
-   GLclampf ClearColor[4];		/**< Color to use for glClear */
-
-   GLuint IndexMask;			/**< Color index write mask */
-   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */
-
-   GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */
-
-   /** 
-    * \name alpha testing
-    */
-   /*@{*/
-   GLboolean AlphaEnabled;		/**< Alpha test enabled flag */
-   GLenum AlphaFunc;			/**< Alpha test function */
-   GLclampf AlphaRef;			/**< Alpha reference value */
-   /*@}*/
-
-   /** 
-    * \name Blending
-    */
-   /*@{*/
-   GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */
-   GLfloat BlendColor[4];		/**< Blending color */
-   struct
-   {
-      GLenum SrcRGB;             /**< RGB blend source term */
-      GLenum DstRGB;             /**< RGB blend dest term */
-      GLenum SrcA;               /**< Alpha blend source term */
-      GLenum DstA;               /**< Alpha blend dest term */
-      GLenum EquationRGB;        /**< GL_ADD, GL_SUBTRACT, etc. */
-      GLenum EquationA;          /**< GL_ADD, GL_SUBTRACT, etc. */
-   } Blend[MAX_DRAW_BUFFERS];
-   /** Are the blend func terms currently different for each buffer/target? */
-   GLboolean _BlendFuncPerBuffer;
-   /** Are the blend equations currently different for each buffer/target? */
-   GLboolean _BlendEquationPerBuffer;
-   /*@}*/
-
-   /** 
-    * \name Logic op
-    */
-   /*@{*/
-   GLenum LogicOp;			/**< Logic operator */
-   GLboolean IndexLogicOpEnabled;	/**< Color index logic op enabled flag */
-   GLboolean ColorLogicOpEnabled;	/**< RGBA logic op enabled flag */
-   GLboolean _LogicOpEnabled;		/**< RGBA logic op + EXT_blend_logic_op enabled flag */
-   /*@}*/
-
-   GLboolean DitherFlag;		/**< Dither enable flag */
-
-   GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
-   GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
-
-   GLboolean sRGBEnabled;	/**< Framebuffer sRGB blending/updating requested */
-};
-
-
-/**
- * Current attribute group (GL_CURRENT_BIT).
- */
-struct gl_current_attrib
-{
-   /**
-    * \name Current vertex attributes.
-    * \note Values are valid only after FLUSH_VERTICES has been called.
-    * \note Index and Edgeflag current values are stored as floats in the 
-    * SIX and SEVEN attribute slots.
-    */
-   GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */
-
-   /**
-    * \name Current raster position attributes (always valid).
-    * \note This set of attributes is very similar to the SWvertex struct.
-    */
-   /*@{*/
-   GLfloat RasterPos[4];
-   GLfloat RasterDistance;
-   GLfloat RasterColor[4];
-   GLfloat RasterSecondaryColor[4];
-   GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];
-   GLboolean RasterPosValid;
-   /*@}*/
-};
-
-
-/**
- * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).
- */
-struct gl_depthbuffer_attrib
-{
-   GLenum Func;			/**< Function for depth buffer compare */
-   GLclampd Clear;		/**< Value to clear depth buffer to */
-   GLboolean Test;		/**< Depth buffering enabled flag */
-   GLboolean Mask;		/**< Depth buffer writable? */
-   GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */
-   GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */
-};
-
-
-/**
- * Evaluator attribute group (GL_EVAL_BIT).
- */
-struct gl_eval_attrib
-{
-   /**
-    * \name Enable bits 
-    */
-   /*@{*/
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean AutoNormal;
-   /*@}*/
-   
-   /**
-    * \name Map Grid endpoints and divisions and calculated du values
-    */
-   /*@{*/
-   GLint MapGrid1un;
-   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
-   GLint MapGrid2un, MapGrid2vn;
-   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
-   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
-   /*@}*/
-};
-
-
-/**
- * Fog attribute group (GL_FOG_BIT).
- */
-struct gl_fog_attrib
-{
-   GLboolean Enabled;		/**< Fog enabled flag */
-   GLfloat Color[4];		/**< Fog color */
-   GLfloat Density;		/**< Density >= 0.0 */
-   GLfloat Start;		/**< Start distance in eye coords */
-   GLfloat End;			/**< End distance in eye coords */
-   GLfloat Index;		/**< Fog index */
-   GLenum Mode;			/**< Fog mode */
-   GLboolean ColorSumEnabled;
-   GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */
-   GLfloat _Scale;		/**< (End == Start) ? 1.0 : 1.0 / (End - Start) */
-};
-
-
-/**
- * \brief Layout qualifiers for gl_FragDepth.
- *
- * Extension AMD_conservative_depth allows gl_FragDepth to be redeclared with
- * a layout qualifier.
- *
- * \see enum ir_depth_layout
- */
-enum gl_frag_depth_layout {
-    FRAG_DEPTH_LAYOUT_NONE, /**< No layout is specified. */
-    FRAG_DEPTH_LAYOUT_ANY,
-    FRAG_DEPTH_LAYOUT_GREATER,
-    FRAG_DEPTH_LAYOUT_LESS,
-    FRAG_DEPTH_LAYOUT_UNCHANGED
-};
-
-
-/** 
- * Hint attribute group (GL_HINT_BIT).
- * 
- * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.
- */
-struct gl_hint_attrib
-{
-   GLenum PerspectiveCorrection;
-   GLenum PointSmooth;
-   GLenum LineSmooth;
-   GLenum PolygonSmooth;
-   GLenum Fog;
-   GLenum ClipVolumeClipping;   /**< GL_EXT_clip_volume_hint */
-   GLenum TextureCompression;   /**< GL_ARB_texture_compression */
-   GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */
-   GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
-};
-
-/**
- * Light state flags.
- */
-/*@{*/
-#define LIGHT_SPOT         0x1
-#define LIGHT_LOCAL_VIEWER 0x2
-#define LIGHT_POSITIONAL   0x4
-#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
-/*@}*/
-
-
-/**
- * Lighting attribute group (GL_LIGHT_BIT).
- */
-struct gl_light_attrib
-{
-   struct gl_light Light[MAX_LIGHTS];	/**< Array of light sources */
-   struct gl_lightmodel Model;		/**< Lighting model */
-
-   /**
-    * Must flush FLUSH_VERTICES before referencing:
-    */
-   /*@{*/
-   struct gl_material Material; 	/**< Includes front & back values */
-   /*@}*/
-
-   GLboolean Enabled;			/**< Lighting enabled flag */
-   GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */
-   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */
-   GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */
-   GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */
-   GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */
-   GLboolean ColorMaterialEnabled;
-   GLenum ClampVertexColor;
-
-   struct gl_light EnabledList;         /**< List sentinel */
-
-   /** 
-    * Derived state for optimizations: 
-    */
-   /*@{*/
-   GLboolean _NeedEyeCoords;		
-   GLboolean _NeedVertices;		/**< Use fast shader? */
-   GLbitfield _Flags;		        /**< LIGHT_* flags, see above */
-   GLfloat _BaseColor[2][3];
-   /*@}*/
-};
-
-
-/**
- * Line attribute group (GL_LINE_BIT).
- */
-struct gl_line_attrib
-{
-   GLboolean SmoothFlag;	/**< GL_LINE_SMOOTH enabled? */
-   GLboolean StippleFlag;	/**< GL_LINE_STIPPLE enabled? */
-   GLushort StipplePattern;	/**< Stipple pattern */
-   GLint StippleFactor;		/**< Stipple repeat factor */
-   GLfloat Width;		/**< Line width */
-};
-
-
-/**
- * Display list attribute group (GL_LIST_BIT).
- */
-struct gl_list_attrib
-{
-   GLuint ListBase;
-};
-
-
-/**
- * Multisample attribute group (GL_MULTISAMPLE_BIT).
- */
-struct gl_multisample_attrib
-{
-   GLboolean Enabled;
-   GLboolean _Enabled;   /**< true if Enabled and multisample buffer */
-   GLboolean SampleAlphaToCoverage;
-   GLboolean SampleAlphaToOne;
-   GLboolean SampleCoverage;
-   GLfloat SampleCoverageValue;
-   GLboolean SampleCoverageInvert;
-};
-
-
-/**
- * A pixelmap (see glPixelMap)
- */
-struct gl_pixelmap
-{
-   GLint Size;
-   GLfloat Map[MAX_PIXEL_MAP_TABLE];
-   GLubyte Map8[MAX_PIXEL_MAP_TABLE];  /**< converted to 8-bit color */
-};
-
-
-/**
- * Collection of all pixelmaps
- */
-struct gl_pixelmaps
-{
-   struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */
-   struct gl_pixelmap GtoG;
-   struct gl_pixelmap BtoB;
-   struct gl_pixelmap AtoA;
-   struct gl_pixelmap ItoR;
-   struct gl_pixelmap ItoG;
-   struct gl_pixelmap ItoB;
-   struct gl_pixelmap ItoA;
-   struct gl_pixelmap ItoI;
-   struct gl_pixelmap StoS;
-};
-
-
-/**
- * Pixel attribute group (GL_PIXEL_MODE_BIT).
- */
-struct gl_pixel_attrib
-{
-   GLenum ReadBuffer;		/**< source buffer for glRead/CopyPixels() */
-
-   /*--- Begin Pixel Transfer State ---*/
-   /* Fields are in the order in which they're applied... */
-
-   /** Scale & Bias (index shift, offset) */
-   /*@{*/
-   GLfloat RedBias, RedScale;
-   GLfloat GreenBias, GreenScale;
-   GLfloat BlueBias, BlueScale;
-   GLfloat AlphaBias, AlphaScale;
-   GLfloat DepthBias, DepthScale;
-   GLint IndexShift, IndexOffset;
-   /*@}*/
-
-   /* Pixel Maps */
-   /* Note: actual pixel maps are not part of this attrib group */
-   GLboolean MapColorFlag;
-   GLboolean MapStencilFlag;
-
-   /*--- End Pixel Transfer State ---*/
-
-   /** glPixelZoom */
-   GLfloat ZoomX, ZoomY;
-};
-
-
-/**
- * Point attribute group (GL_POINT_BIT).
- */
-struct gl_point_attrib
-{
-   GLboolean SmoothFlag;	/**< True if GL_POINT_SMOOTH is enabled */
-   GLfloat Size;		/**< User-specified point size */
-   GLfloat Params[3];		/**< GL_EXT_point_parameters */
-   GLfloat MinSize, MaxSize;	/**< GL_EXT_point_parameters */
-   GLfloat Threshold;		/**< GL_EXT_point_parameters */
-   GLboolean _Attenuated;	/**< True if Params != [1, 0, 0] */
-   GLboolean PointSprite;	/**< GL_NV/ARB_point_sprite */
-   GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/
-   GLenum SpriteRMode;		/**< GL_NV_point_sprite (only!) */
-   GLenum SpriteOrigin;		/**< GL_ARB_point_sprite */
-};
-
-
-/**
- * Polygon attribute group (GL_POLYGON_BIT).
- */
-struct gl_polygon_attrib
-{
-   GLenum FrontFace;		/**< Either GL_CW or GL_CCW */
-   GLenum FrontMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */
-   GLenum BackMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */
-   GLboolean _FrontBit;		/**< 0=GL_CCW, 1=GL_CW */
-   GLboolean CullFlag;		/**< Culling on/off flag */
-   GLboolean SmoothFlag;	/**< True if GL_POLYGON_SMOOTH is enabled */
-   GLboolean StippleFlag;	/**< True if GL_POLYGON_STIPPLE is enabled */
-   GLenum CullFaceMode;		/**< Culling mode GL_FRONT or GL_BACK */
-   GLfloat OffsetFactor;	/**< Polygon offset factor, from user */
-   GLfloat OffsetUnits;		/**< Polygon offset units, from user */
-   GLboolean OffsetPoint;	/**< Offset in GL_POINT mode */
-   GLboolean OffsetLine;	/**< Offset in GL_LINE mode */
-   GLboolean OffsetFill;	/**< Offset in GL_FILL mode */
-};
-
-
-/**
- * Scissor attributes (GL_SCISSOR_BIT).
- */
-struct gl_scissor_attrib
-{
-   GLboolean Enabled;		/**< Scissor test enabled? */
-   GLint X, Y;			/**< Lower left corner of box */
-   GLsizei Width, Height;	/**< Size of box */
-};
-
-
-/**
- * Stencil attribute group (GL_STENCIL_BUFFER_BIT).
- *
- * Three sets of stencil data are tracked so that OpenGL 2.0,
- * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported
- * simultaneously.  In each of the stencil state arrays, element 0 corresponds
- * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /
- * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the
- * GL_EXT_stencil_two_side GL_BACK state.
- *
- * The derived value \c _BackFace is either 1 or 2 depending on whether or
- * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.
- *
- * The derived value \c _TestTwoSide is set when the front-face and back-face
- * stencil state are different.
- */
-struct gl_stencil_attrib
-{
-   GLboolean Enabled;		/**< Enabled flag */
-   GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */
-   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */
-   GLboolean _Enabled;          /**< Enabled and stencil buffer present */
-   GLboolean _TestTwoSide;
-   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */
-   GLenum Function[3];		/**< Stencil function */
-   GLenum FailFunc[3];		/**< Fail function */
-   GLenum ZPassFunc[3];		/**< Depth buffer pass function */
-   GLenum ZFailFunc[3];		/**< Depth buffer fail function */
-   GLint Ref[3];		/**< Reference value */
-   GLuint ValueMask[3];		/**< Value mask */
-   GLuint WriteMask[3];		/**< Write mask */
-   GLuint Clear;		/**< Clear value */
-};
-
-
-/**
- * An index for each type of texture object.  These correspond to the GL
- * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.
- * Note: the order is from highest priority to lowest priority.
- */
-typedef enum
-{
-   TEXTURE_2D_ARRAY_INDEX,
-   TEXTURE_1D_ARRAY_INDEX,
-   TEXTURE_CUBE_INDEX,
-   TEXTURE_3D_INDEX,
-   TEXTURE_RECT_INDEX,
-   TEXTURE_2D_INDEX,
-   TEXTURE_1D_INDEX,
-   NUM_TEXTURE_TARGETS
-} gl_texture_index;
-
-
-/**
- * Bit flags for each type of texture object
- * Used for Texture.Unit[]._ReallyEnabled flags.
- */
-/*@{*/
-#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
-#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
-#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)
-#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
-#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)
-#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
-#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
-/*@}*/
-
-
-/**
- * TexGenEnabled flags.
- */
-/*@{*/
-#define S_BIT 1
-#define T_BIT 2
-#define R_BIT 4
-#define Q_BIT 8
-#define STR_BITS (S_BIT | T_BIT | R_BIT)
-/*@}*/
-
-
-/**
- * Bit flag versions of the corresponding GL_ constants.
- */
-/*@{*/
-#define TEXGEN_SPHERE_MAP        0x1
-#define TEXGEN_OBJ_LINEAR        0x2
-#define TEXGEN_EYE_LINEAR        0x4
-#define TEXGEN_REFLECTION_MAP_NV 0x8
-#define TEXGEN_NORMAL_MAP_NV     0x10
-
-#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV)
-#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV     | \
-				  TEXGEN_EYE_LINEAR)
-/*@}*/
-
-
-
-/** Tex-gen enabled for texture unit? */
-#define ENABLE_TEXGEN(unit) (1 << (unit))
-
-/** Non-identity texture matrix for texture unit? */
-#define ENABLE_TEXMAT(unit) (1 << (unit))
-
-
-/**
- * Texel fetch function prototype.  We use texel fetch functions to
- * extract RGBA, color indexes and depth components out of 1D, 2D and 3D
- * texture images.  These functions help to isolate us from the gritty
- * details of all the various texture image encodings.
- * 
- * \param texImage texture image.
- * \param col texel column.
- * \param row texel row.
- * \param img texel image level/layer.
- * \param texelOut output texel (up to 4 GLchans)
- */
-typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,
-                                 GLint col, GLint row, GLint img,
-                                 GLchan *texelOut );
-
-/**
- * As above, but returns floats.
- * Used for depth component images and for upcoming signed/float
- * texture images.
- */
-typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,
-                                 GLint col, GLint row, GLint img,
-                                 GLfloat *texelOut );
-
-
-typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,
-                               GLint col, GLint row, GLint img,
-                               const void *texel);
-
-
-/**
- * Texture image state.  Describes the dimensions of a texture image,
- * the texel format and pointers to Texel Fetch functions.
- */
-struct gl_texture_image
-{
-   GLint InternalFormat;	/**< Internal format as given by the user */
-   GLenum _BaseFormat;		/**< Either GL_RGB, GL_RGBA, GL_ALPHA,
-				 *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,
-				 *   GL_INTENSITY, GL_COLOR_INDEX,
-				 *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT
-                                 *   only. Used for choosing TexEnv arithmetic.
-				 */
-   gl_format TexFormat;         /**< The actual texture memory format */
-
-   GLuint Border;		/**< 0 or 1 */
-   GLuint Width;		/**< = 2^WidthLog2 + 2*Border */
-   GLuint Height;		/**< = 2^HeightLog2 + 2*Border */
-   GLuint Depth;		/**< = 2^DepthLog2 + 2*Border */
-   GLuint Width2;		/**< = Width - 2*Border */
-   GLuint Height2;		/**< = Height - 2*Border */
-   GLuint Depth2;		/**< = Depth - 2*Border */
-   GLuint WidthLog2;		/**< = log2(Width2) */
-   GLuint HeightLog2;		/**< = log2(Height2) */
-   GLuint DepthLog2;		/**< = log2(Depth2) */
-   GLuint MaxLog2;		/**< = MAX(WidthLog2, HeightLog2) */
-   GLfloat WidthScale;		/**< used for mipmap LOD computation */
-   GLfloat HeightScale;		/**< used for mipmap LOD computation */
-   GLfloat DepthScale;		/**< used for mipmap LOD computation */
-   GLboolean IsClientData;	/**< Data owned by client? */
-   GLboolean _IsPowerOfTwo;	/**< Are all dimensions powers of two? */
-
-   struct gl_texture_object *TexObject;  /**< Pointer back to parent object */
-
-   FetchTexelFuncC FetchTexelc;	/**< GLchan texel fetch function pointer */
-   FetchTexelFuncF FetchTexelf;	/**< Float texel fetch function pointer */
-
-   GLuint RowStride;		/**< Padded width in units of texels */
-   GLuint *ImageOffsets;        /**< if 3D texture: array [Depth] of offsets to
-                                     each 2D slice in 'Data', in texels */
-   GLvoid *Data;		/**< Image data, accessed via FetchTexel() */
-
-   /**
-    * \name For device driver:
-    */
-   /*@{*/
-   void *DriverData;		/**< Arbitrary device driver data */
-   /*@}*/
-};
-
-
-/**
- * Indexes for cube map faces.
- */
-typedef enum
-{
-   FACE_POS_X = 0,
-   FACE_NEG_X = 1,
-   FACE_POS_Y = 2,
-   FACE_NEG_Y = 3,
-   FACE_POS_Z = 4,
-   FACE_NEG_Z = 5,
-   MAX_FACES = 6
-} gl_face_index;
-
-
-/**
- * Texture object state.  Contains the array of mipmap images, border color,
- * wrap modes, filter modes, shadow/texcompare state, and the per-texture
- * color palette.
- */
-struct gl_texture_object
-{
-   _glthread_Mutex Mutex;	/**< for thread safety */
-   GLint RefCount;		/**< reference count */
-   GLuint Name;			/**< the user-visible texture object ID */
-   GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
-   GLfloat Priority;		/**< in [0,1] */
-   union {
-      GLfloat f[4];
-      GLuint ui[4];
-      GLint i[4];
-   } BorderColor;               /**< Interpreted according to texture format */
-   GLenum WrapS;		/**< S-axis texture image wrap mode */
-   GLenum WrapT;		/**< T-axis texture image wrap mode */
-   GLenum WrapR;		/**< R-axis texture image wrap mode */
-   GLenum MinFilter;		/**< minification filter */
-   GLenum MagFilter;		/**< magnification filter */
-   GLfloat MinLod;		/**< min lambda, OpenGL 1.2 */
-   GLfloat MaxLod;		/**< max lambda, OpenGL 1.2 */
-   GLfloat LodBias;		/**< OpenGL 1.4 */
-   GLint BaseLevel;		/**< min mipmap level, OpenGL 1.2 */
-   GLint MaxLevel;		/**< max mipmap level, OpenGL 1.2 */
-   GLfloat MaxAnisotropy;	/**< GL_EXT_texture_filter_anisotropic */
-   GLenum CompareMode;		/**< GL_ARB_shadow */
-   GLenum CompareFunc;		/**< GL_ARB_shadow */
-   GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */
-   GLenum DepthMode;		/**< GL_ARB_depth_texture */
-   GLint _MaxLevel;		/**< actual max mipmap level (q in the spec) */
-   GLfloat _MaxLambda;		/**< = _MaxLevel - BaseLevel (q - b in spec) */
-   GLint CropRect[4];           /**< GL_OES_draw_texture */
-   GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */
-   GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */
-   GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */
-   GLboolean _Complete;		/**< Is texture object complete? */
-   GLboolean _RenderToTexture;  /**< Any rendering to this texture? */
-   GLboolean Purgeable;         /**< Is the buffer purgeable under memory pressure? */
-   GLenum sRGBDecode;           /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
-
-   /** Actual texture images, indexed by [cube face] and [mipmap level] */
-   struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
-
-   /** GL_EXT_paletted_texture */
-   struct gl_color_table Palette;
-
-   /**
-    * \name For device driver.
-    * Note: instead of attaching driver data to this pointer, it's preferable
-    * to instead use this struct as a base class for your own texture object
-    * class.  Driver->NewTextureObject() can be used to implement the
-    * allocation.
-    */
-   void *DriverData;	/**< Arbitrary device driver data */
-};
-
-
-/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */
-#define MAX_COMBINER_TERMS 4
-
-
-/**
- * Texture combine environment state.
- */
-struct gl_tex_env_combine_state
-{
-   GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
-   GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
-   /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
-   GLenum SourceRGB[MAX_COMBINER_TERMS];
-   GLenum SourceA[MAX_COMBINER_TERMS];
-   /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
-   GLenum OperandRGB[MAX_COMBINER_TERMS];
-   GLenum OperandA[MAX_COMBINER_TERMS];
-   GLuint ScaleShiftRGB; /**< 0, 1 or 2 */
-   GLuint ScaleShiftA;   /**< 0, 1 or 2 */
-   GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */
-   GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */
-};
-
-
-/**
- * Texture coord generation state.
- */
-struct gl_texgen
-{
-   GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
-   GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
-   GLfloat ObjectPlane[4];
-   GLfloat EyePlane[4];
-};
-
-
-/**
- * Texture unit state.  Contains enable flags, texture environment/function/
- * combiners, texgen state, pointers to current texture objects and
- * post-filter color tables.
- */
-struct gl_texture_unit
-{
-   GLbitfield Enabled;          /**< bitmask of TEXTURE_*_BIT flags */
-   GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */
-
-   GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
-   GLfloat EnvColor[4];
-
-   struct gl_texgen GenS;
-   struct gl_texgen GenT;
-   struct gl_texgen GenR;
-   struct gl_texgen GenQ;
-   GLbitfield TexGenEnabled;	/**< Bitwise-OR of [STRQ]_BIT values */
-   GLbitfield _GenFlags;	/**< Bitwise-OR of Gen[STRQ]._ModeBit */
-
-   GLfloat LodBias;		/**< for biasing mipmap levels */
-   GLenum BumpTarget;
-   GLfloat RotMatrix[4]; /* 2x2 matrix */
-
-   /** 
-    * \name GL_EXT_texture_env_combine 
-    */
-   struct gl_tex_env_combine_state Combine;
-
-   /**
-    * Derived state based on \c EnvMode and the \c BaseFormat of the
-    * currently enabled texture.
-    */
-   struct gl_tex_env_combine_state _EnvMode;
-
-   /**
-    * Currently enabled combiner state.  This will point to either
-    * \c Combine or \c _EnvMode.
-    */
-   struct gl_tex_env_combine_state *_CurrentCombine;
-
-   /** Current texture object pointers */
-   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
-
-   /** Points to highest priority, complete and enabled texture object */
-   struct gl_texture_object *_Current;
-};
-
-
-/**
- * Texture attribute group (GL_TEXTURE_BIT).
- */
-struct gl_texture_attrib
-{
-   GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */
-   struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
-
-   struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
-
-   /** GL_ARB_seamless_cubemap */
-   GLboolean CubeMapSeamless;
-
-   /** GL_EXT_shared_texture_palette */
-   GLboolean SharedPalette;
-   struct gl_color_table Palette;
-
-   /** Texture units/samplers used by vertex or fragment texturing */
-   GLbitfield _EnabledUnits;
-
-   /** Texture coord units/sets used for fragment texturing */
-   GLbitfield _EnabledCoordUnits;
-
-   /** Texture coord units that have texgen enabled */
-   GLbitfield _TexGenEnabled;
-
-   /** Texture coord units that have non-identity matrices */
-   GLbitfield _TexMatEnabled;
-
-   /** Bitwise-OR of all Texture.Unit[i]._GenFlags */
-   GLbitfield _GenFlags;
-};
-
-
-/**
- * Transformation attribute group (GL_TRANSFORM_BIT).
- */
-struct gl_transform_attrib
-{
-   GLenum MatrixMode;				/**< Matrix mode */
-   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];	/**< User clip planes */
-   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];	/**< derived */
-   GLbitfield ClipPlanesEnabled;                /**< on/off bitmask */
-   GLboolean Normalize;				/**< Normalize all normals? */
-   GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */
-   GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */
-   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */
-
-   GLfloat CullEyePos[4];
-   GLfloat CullObjPos[4];
-};
-
-
-/**
- * Viewport attribute group (GL_VIEWPORT_BIT).
- */
-struct gl_viewport_attrib
-{
-   GLint X, Y;			/**< position */
-   GLsizei Width, Height;	/**< size */
-   GLfloat Near, Far;		/**< Depth buffer range */
-   GLmatrix _WindowMap;		/**< Mapping transformation as a matrix. */
-};
-
-
-/**
- * GL_ARB_vertex/pixel_buffer_object buffer object
- */
-struct gl_buffer_object
-{
-   _glthread_Mutex Mutex;
-   GLint RefCount;
-   GLuint Name;
-   GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
-   GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */
-   GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */
-   /** Fields describing a mapped buffer */
-   /*@{*/
-   GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
-   GLvoid *Pointer;     /**< User-space address of mapping */
-   GLintptr Offset;     /**< Mapped offset */
-   GLsizeiptr Length;   /**< Mapped length */
-   /*@}*/
-   GLboolean Written;   /**< Ever written to? (for debugging) */
-   GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
-};
-
-
-/**
- * Client pixel packing/unpacking attributes
- */
-struct gl_pixelstore_attrib
-{
-   GLint Alignment;
-   GLint RowLength;
-   GLint SkipPixels;
-   GLint SkipRows;
-   GLint ImageHeight;
-   GLint SkipImages;
-   GLboolean SwapBytes;
-   GLboolean LsbFirst;
-   GLboolean ClientStorage; /**< GL_APPLE_client_storage */
-   GLboolean Invert;        /**< GL_MESA_pack_invert */
-   struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */
-};
-
-
-/**
- * Client vertex array attributes
- */
-struct gl_client_array
-{
-   GLint Size;                  /**< components per element (1,2,3,4) */
-   GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */
-   GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */
-   GLsizei Stride;		/**< user-specified stride */
-   GLsizei StrideB;		/**< actual stride in bytes */
-   const GLubyte *Ptr;          /**< Points to array data */
-   GLboolean Enabled;		/**< Enabled flag is a boolean */
-   GLboolean Normalized;        /**< GL_ARB_vertex_program */
-   GLboolean Integer;           /**< Integer-valued? */
-   GLuint InstanceDivisor;      /**< GL_ARB_instanced_arrays */
-   GLuint _ElementSize;         /**< size of each element in bytes */
-
-   struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */
-   GLuint _MaxElement;          /**< max element index into array buffer + 1 */
-};
-
-
-/**
- * Collection of vertex arrays.  Defined by the GL_APPLE_vertex_array_object
- * extension, but a nice encapsulation in any case.
- */
-struct gl_array_object
-{
-   /** Name of the array object as received from glGenVertexArrayAPPLE. */
-   GLuint Name;
-
-   GLint RefCount;
-   _glthread_Mutex Mutex;
-   GLboolean VBOonly;  /**< require all arrays to live in VBOs? */
-
-   /** Conventional vertex arrays */
-   /*@{*/
-   struct gl_client_array Vertex;
-   struct gl_client_array Weight;
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array SecondaryColor;
-   struct gl_client_array FogCoord;
-   struct gl_client_array Index;
-   struct gl_client_array EdgeFlag;
-   struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];
-   struct gl_client_array PointSize;
-   /*@}*/
-
-   /**
-    * Generic arrays for vertex programs/shaders.
-    * For NV vertex programs, these attributes alias and take priority
-    * over the conventional attribs above.  For ARB vertex programs and
-    * GLSL vertex shaders, these attributes are separate.
-    */
-   struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
-
-   /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */
-   GLbitfield _Enabled;
-
-   /**
-    * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs
-    * we can determine the max legal (in bounds) glDrawElements array index.
-    */
-   GLuint _MaxElement;
-};
-
-
-/**
- * Vertex array state
- */
-struct gl_array_attrib
-{
-   /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */
-   struct gl_array_object *ArrayObj;
-
-   /** The default vertex array object */
-   struct gl_array_object *DefaultArrayObj;
-
-   /** Array objects (GL_ARB/APPLE_vertex_array_object) */
-   struct _mesa_HashTable *Objects;
-
-   GLint ActiveTexture;		/**< Client Active Texture */
-   GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */
-   GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */
-
-   /** GL 3.1 (slightly different from GL_NV_primitive_restart) */
-   GLboolean PrimitiveRestart;
-   GLuint RestartIndex;
-
-   GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */
-   GLboolean RebindArrays; /**< whether the VBO module should rebind arrays */
-
-   /* GL_ARB_vertex_buffer_object */
-   struct gl_buffer_object *ArrayBufferObj;
-   struct gl_buffer_object *ElementArrayBufferObj;
-};
-
-
-/**
- * Feedback buffer state
- */
-struct gl_feedback
-{
-   GLenum Type;
-   GLbitfield _Mask;    /**< FB_* bits */
-   GLfloat *Buffer;
-   GLuint BufferSize;
-   GLuint Count;
-};
-
-
-/**
- * Selection buffer state
- */
-struct gl_selection
-{
-   GLuint *Buffer;	/**< selection buffer */
-   GLuint BufferSize;	/**< size of the selection buffer */
-   GLuint BufferCount;	/**< number of values in the selection buffer */
-   GLuint Hits;		/**< number of records in the selection buffer */
-   GLuint NameStackDepth; /**< name stack depth */
-   GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */
-   GLboolean HitFlag;	/**< hit flag */
-   GLfloat HitMinZ;	/**< minimum hit depth */
-   GLfloat HitMaxZ;	/**< maximum hit depth */
-};
-
-
-/**
- * 1-D Evaluator control points
- */
-struct gl_1d_map
-{
-   GLuint Order;	/**< Number of control points */
-   GLfloat u1, u2, du;	/**< u1, u2, 1.0/(u2-u1) */
-   GLfloat *Points;	/**< Points to contiguous control points */
-};
-
-
-/**
- * 2-D Evaluator control points
- */
-struct gl_2d_map
-{
-   GLuint Uorder;		/**< Number of control points in U dimension */
-   GLuint Vorder;		/**< Number of control points in V dimension */
-   GLfloat u1, u2, du;
-   GLfloat v1, v2, dv;
-   GLfloat *Points;		/**< Points to contiguous control points */
-};
-
-
-/**
- * All evaluator control point state
- */
-struct gl_evaluators
-{
-   /** 
-    * \name 1-D maps
-    */
-   /*@{*/
-   struct gl_1d_map Map1Vertex3;
-   struct gl_1d_map Map1Vertex4;
-   struct gl_1d_map Map1Index;
-   struct gl_1d_map Map1Color4;
-   struct gl_1d_map Map1Normal;
-   struct gl_1d_map Map1Texture1;
-   struct gl_1d_map Map1Texture2;
-   struct gl_1d_map Map1Texture3;
-   struct gl_1d_map Map1Texture4;
-   struct gl_1d_map Map1Attrib[16];  /**< GL_NV_vertex_program */
-   /*@}*/
-
-   /** 
-    * \name 2-D maps 
-    */
-   /*@{*/
-   struct gl_2d_map Map2Vertex3;
-   struct gl_2d_map Map2Vertex4;
-   struct gl_2d_map Map2Index;
-   struct gl_2d_map Map2Color4;
-   struct gl_2d_map Map2Normal;
-   struct gl_2d_map Map2Texture1;
-   struct gl_2d_map Map2Texture2;
-   struct gl_2d_map Map2Texture3;
-   struct gl_2d_map Map2Texture4;
-   struct gl_2d_map Map2Attrib[16];  /**< GL_NV_vertex_program */
-   /*@}*/
-};
-
-
-/**
- * Names of the various vertex/fragment program register files, etc.
- *
- * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)
- * All values should fit in a 4-bit field.
- *
- * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM,
- * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to
- * be "uniform" variables since they can only be set outside glBegin/End.
- * They're also all stored in the same Parameters array.
- */
-typedef enum
-{
-   PROGRAM_TEMPORARY,   /**< machine->Temporary[] */
-   PROGRAM_INPUT,       /**< machine->Inputs[] */
-   PROGRAM_OUTPUT,      /**< machine->Outputs[] */
-   PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */
-   PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */
-   PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */
-   PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */
-   PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */
-   PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */
-   PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */
-   PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */
-   PROGRAM_ADDRESS,     /**< machine->AddressReg */
-   PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */
-   PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */
-   PROGRAM_UNDEFINED,   /**< Invalid/TBD value */
-   PROGRAM_FILE_MAX
-} gl_register_file;
-
-
-/**
- * If the register file is PROGRAM_SYSTEM_VALUE, the register index will be
- * one of these values.
- */
-typedef enum
-{
-   SYSTEM_VALUE_FRONT_FACE,  /**< Fragment shader only (not done yet) */
-   SYSTEM_VALUE_INSTANCE_ID, /**< Vertex shader only */
-   SYSTEM_VALUE_MAX          /**< Number of values */
-} gl_system_value;
-
-
-/** Vertex and fragment instructions */
-struct prog_instruction;
-struct gl_program_parameter_list;
-struct gl_uniform_list;
-
-
-/**
- * Base class for any kind of program object
- */
-struct gl_program
-{
-   GLuint Id;
-   GLubyte *String;  /**< Null-terminated program text */
-   GLint RefCount;
-   GLenum Target;    /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */
-   GLenum Format;    /**< String encoding format */
-   GLboolean Resident;
-
-   struct prog_instruction *Instructions;
-
-   GLbitfield InputsRead;     /**< Bitmask of which input regs are read */
-   GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */
-   GLbitfield SystemValuesRead;   /**< Bitmask of SYSTEM_VALUE_x inputs used */
-   GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   /**< PROG_PARAM_BIT_x flags */
-   GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */
-   GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  /**< TEXTURE_x_BIT bitmask */
-   GLbitfield SamplersUsed;   /**< Bitfield of which samplers are used */
-   GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */
-
-
-   /** Named parameters, constants, etc. from program text */
-   struct gl_program_parameter_list *Parameters;
-   /** Numbered local parameters */
-   GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];
-
-   /** Vertex/fragment shader varying vars */
-   struct gl_program_parameter_list *Varying;
-   /** Vertex program user-defined attributes */
-   struct gl_program_parameter_list *Attributes;
-
-   /** Map from sampler unit to texture unit (set by glUniform1i()) */
-   GLubyte SamplerUnits[MAX_SAMPLERS];
-   /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
-   gl_texture_index SamplerTargets[MAX_SAMPLERS];
-
-   /** Bitmask of which register files are read/written with indirect
-    * addressing.  Mask of (1 << PROGRAM_x) bits.
-    */
-   GLbitfield IndirectRegisterFiles;
-
-   /** Logical counts */
-   /*@{*/
-   GLuint NumInstructions;
-   GLuint NumTemporaries;
-   GLuint NumParameters;
-   GLuint NumAttributes;
-   GLuint NumAddressRegs;
-   GLuint NumAluInstructions;
-   GLuint NumTexInstructions;
-   GLuint NumTexIndirections;
-   /*@}*/
-   /** Native, actual h/w counts */
-   /*@{*/
-   GLuint NumNativeInstructions;
-   GLuint NumNativeTemporaries;
-   GLuint NumNativeParameters;
-   GLuint NumNativeAttributes;
-   GLuint NumNativeAddressRegs;
-   GLuint NumNativeAluInstructions;
-   GLuint NumNativeTexInstructions;
-   GLuint NumNativeTexIndirections;
-   /*@}*/
-};
-
-
-/** Vertex program object */
-struct gl_vertex_program
-{
-   struct gl_program Base;   /**< base class */
-   GLboolean IsNVProgram;    /**< is this a GL_NV_vertex_program program? */
-   GLboolean IsPositionInvariant;
-};
-
-
-/** Geometry program object */
-struct gl_geometry_program
-{
-   struct gl_program Base;   /**< base class */
-
-   GLint VerticesOut;
-   GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
-                           GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
-   GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
-};
-
-
-/** Fragment program object */
-struct gl_fragment_program
-{
-   struct gl_program Base;   /**< base class */
-   GLenum FogOption;
-   GLboolean UsesKill;          /**< shader uses KIL instruction */
-   GLboolean OriginUpperLeft;
-   GLboolean PixelCenterInteger;
-   enum gl_frag_depth_layout FragDepthLayout;
-};
-
-
-/**
- * State common to vertex and fragment programs.
- */
-struct gl_program_state
-{
-   GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */
-   const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */
-};
-
-
-/**
- * Context state for vertex programs.
- */
-struct gl_vertex_program_state
-{
-   GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
-   GLboolean _Enabled;           /**< Enabled and _valid_ user program? */
-   GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
-   GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
-   struct gl_vertex_program *Current;  /**< User-bound vertex program */
-
-   /** Currently enabled and valid vertex program (including internal
-    * programs, user-defined vertex programs and GLSL vertex shaders).
-    * This is the program we must use when rendering.
-    */
-   struct gl_vertex_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /* For GL_NV_vertex_program only: */
-   GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];
-   GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];
-
-   /** Should fixed-function T&L be implemented with a vertex prog? */
-   GLboolean _MaintainTnlProgram;
-
-   /** Program to emulate fixed-function T&L (see above) */
-   struct gl_vertex_program *_TnlProgram;
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-
-   GLboolean _Overriden;
-};
-
-
-/**
- * Context state for geometry programs.
- */
-struct gl_geometry_program_state
-{
-   GLboolean Enabled;               /**< GL_ARB_GEOMETRY_SHADER4 */
-   GLboolean _Enabled;              /**< Enabled and valid program? */
-   struct gl_geometry_program *Current;  /**< user-bound geometry program */
-
-   /** Currently enabled and valid program (including internal programs
-    * and compiled shader programs).
-    */
-   struct gl_geometry_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-};
-
-/**
- * Context state for fragment programs.
- */
-struct gl_fragment_program_state
-{
-   GLboolean Enabled;     /**< User-set fragment program enable flag */
-   GLboolean _Enabled;    /**< Enabled and _valid_ user program? */
-   struct gl_fragment_program *Current;  /**< User-bound fragment program */
-
-   /** Currently enabled and valid fragment program (including internal
-    * programs, user-defined fragment programs and GLSL fragment shaders).
-    * This is the program we must use when rendering.
-    */
-   struct gl_fragment_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /** Should fixed-function texturing be implemented with a fragment prog? */
-   GLboolean _MaintainTexEnvProgram;
-
-   /** Program to emulate fixed-function texture env/combine (see above) */
-   struct gl_fragment_program *_TexEnvProgram;
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-};
-
-
-/**
- * ATI_fragment_shader runtime state
- */
-#define ATI_FS_INPUT_PRIMARY 0
-#define ATI_FS_INPUT_SECONDARY 1
-
-struct atifs_instruction;
-struct atifs_setupinst;
-
-/**
- * ATI fragment shader
- */
-struct ati_fragment_shader
-{
-   GLuint Id;
-   GLint RefCount;
-   struct atifs_instruction *Instructions[2];
-   struct atifs_setupinst *SetupInst[2];
-   GLfloat Constants[8][4];
-   GLbitfield LocalConstDef;  /**< Indicates which constants have been set */
-   GLubyte numArithInstr[2];
-   GLubyte regsAssigned[2];
-   GLubyte NumPasses;         /**< 1 or 2 */
-   GLubyte cur_pass;
-   GLubyte last_optype;
-   GLboolean interpinp1;
-   GLboolean isValid;
-   GLuint swizzlerq;
-};
-
-/**
- * Context state for GL_ATI_fragment_shader
- */
-struct gl_ati_fragment_shader_state
-{
-   GLboolean Enabled;
-   GLboolean _Enabled;                  /**< enabled and valid shader? */
-   GLboolean Compiling;
-   GLfloat GlobalConstants[8][4];
-   struct ati_fragment_shader *Current;
-};
-
-
-/**
- * Occlusion/timer query object.
- */
-struct gl_query_object
-{
-   GLenum Target;      /**< The query target, when active */
-   GLuint Id;          /**< hash table ID/name */
-   GLuint64EXT Result; /**< the counter */
-   GLboolean Active;   /**< inside Begin/EndQuery */
-   GLboolean Ready;    /**< result is ready? */
-};
-
-
-/**
- * Context state for query objects.
- */
-struct gl_query_state
-{
-   struct _mesa_HashTable *QueryObjects;
-   struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */
-   struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */
-
-   /** GL_NV_conditional_render */
-   struct gl_query_object *CondRenderQuery;
-
-   /** GL_EXT_transform_feedback */
-   struct gl_query_object *PrimitivesGenerated;
-   struct gl_query_object *PrimitivesWritten;
-
-   /** GL_ARB_timer_query */
-   struct gl_query_object *TimeElapsed;
-
-   GLenum CondRenderMode;
-};
-
-
-/** Sync object state */
-struct gl_sync_object {
-   struct simple_node link;
-   GLenum Type;               /**< GL_SYNC_FENCE */
-   GLuint Name;               /**< Fence name */
-   GLint RefCount;            /**< Reference count */
-   GLboolean DeletePending;   /**< Object was deleted while there were still
-			       * live references (e.g., sync not yet finished)
-			       */
-   GLenum SyncCondition;
-   GLbitfield Flags;          /**< Flags passed to glFenceSync */
-   GLuint StatusFlag:1;       /**< Has the sync object been signaled? */
-};
-
-
-/** Set by #pragma directives */
-struct gl_sl_pragmas
-{
-   GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */
-   GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */
-   GLboolean Optimize;  /**< defaults on */
-   GLboolean Debug;     /**< defaults off */
-};
-
-
-/**
- * A GLSL vertex or fragment shader object.
- */
-struct gl_shader
-{
-   GLenum Type;  /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */
-   GLuint Name;  /**< AKA the handle */
-   GLint RefCount;  /**< Reference count */
-   GLboolean DeletePending;
-   GLboolean CompileStatus;
-   const GLchar *Source;  /**< Source code string */
-   GLuint SourceChecksum;       /**< for debug/logging purposes */
-   struct gl_program *Program;  /**< Post-compile assembly code */
-   GLchar *InfoLog;
-   struct gl_sl_pragmas Pragmas;
-
-   unsigned Version;       /**< GLSL version used for linking */
-
-   struct exec_list *ir;
-   struct glsl_symbol_table *symbols;
-
-   /** Shaders containing built-in functions that are used for linking. */
-   struct gl_shader *builtins_to_link[16];
-   unsigned num_builtins_to_link;
-};
-
-
-/**
- * A GLSL program object.
- * Basically a linked collection of vertex and fragment shaders.
- */
-struct gl_shader_program
-{
-   GLenum Type;  /**< Always GL_SHADER_PROGRAM (internal token) */
-   GLuint Name;  /**< aka handle or ID */
-   GLint RefCount;  /**< Reference count */
-   GLboolean DeletePending;
-
-   GLuint NumShaders;          /**< number of attached shaders */
-   struct gl_shader **Shaders; /**< List of attached the shaders */
-
-   /** User-defined attribute bindings (glBindAttribLocation) */
-   struct gl_program_parameter_list *Attributes;
-
-   /** Transform feedback varyings */
-   struct {
-      GLenum BufferMode;
-      GLuint NumVarying;
-      GLchar **VaryingNames;  /**< Array [NumVarying] of char * */
-   } TransformFeedback;
-
-   /** Geometry shader state - copied into gl_geometry_program at link time */
-   struct {
-      GLint VerticesOut;
-      GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
-                              GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
-      GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
-   } Geom;
-
-   /* post-link info: */
-   struct gl_vertex_program *VertexProgram;     /**< Linked vertex program */
-   struct gl_fragment_program *FragmentProgram; /**< Linked fragment prog */
-   struct gl_geometry_program *GeometryProgram; /**< Linked geometry prog */
-   struct gl_uniform_list *Uniforms;
-   struct gl_program_parameter_list *Varying;
-   GLboolean LinkStatus;   /**< GL_LINK_STATUS */
-   GLboolean Validated;
-   GLboolean _Used;        /**< Ever used for drawing? */
-   GLchar *InfoLog;
-
-   unsigned Version;       /**< GLSL version used for linking */
-
-   /**
-    * Per-stage shaders resulting from the first stage of linking.
-    *
-    * Set of linked shaders for this program.  The array is accessed using the
-    * \c MESA_SHADER_* defines.  Entries for non-existent stages will be
-    * \c NULL.
-    */
-   struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES];
-};   
-
-
-#define GLSL_DUMP      0x1  /**< Dump shaders to stdout */
-#define GLSL_LOG       0x2  /**< Write shaders to files */
-#define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */
-#define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */
-#define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */
-#define GLSL_NOP_VERT 0x20  /**< Force no-op vertex shaders */
-#define GLSL_NOP_FRAG 0x40  /**< Force no-op fragment shaders */
-#define GLSL_USE_PROG 0x80  /**< Log glUseProgram calls */
-
-
-/**
- * Context state for GLSL vertex/fragment shaders.
- */
-struct gl_shader_state
-{
-   /**
-    * Programs used for rendering
-    *
-    * There is a separate program set for each shader stage.  If
-    * GL_EXT_separate_shader_objects is not supported, each of these must point
-    * to \c NULL or to the same program.
-    */
-   struct gl_shader_program *CurrentVertexProgram;
-   struct gl_shader_program *CurrentGeometryProgram;
-   struct gl_shader_program *CurrentFragmentProgram;
-
-   /**
-    * Program used by glUniform calls.
-    *
-    * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.
-    */
-   struct gl_shader_program *ActiveProgram;
-
-   void *MemPool;
-
-   GLbitfield Flags;                    /**< Mask of GLSL_x flags */
-};
-
-/**
- * Compiler options for a single GLSL shaders type
- */
-struct gl_shader_compiler_options
-{
-   /** Driver-selectable options: */
-   GLboolean EmitCondCodes;             /**< Use condition codes? */
-   GLboolean EmitNVTempInitialization;  /**< 0-fill NV temp registers */
-   /**
-    * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't
-    * support control flow.
-    */
-   GLboolean EmitNoIfs;
-   GLboolean EmitNoLoops;
-   GLboolean EmitNoFunctions;
-   GLboolean EmitNoCont;                  /**< Emit CONT opcode? */
-   GLboolean EmitNoMainReturn;            /**< Emit CONT/RET opcodes? */
-   GLboolean EmitNoNoise;                 /**< Emit NOISE opcodes? */
-   GLboolean EmitNoPow;                   /**< Emit POW opcodes? */
-
-   /**
-    * \name Forms of indirect addressing the driver cannot do.
-    */
-   /*@{*/
-   GLboolean EmitNoIndirectInput;   /**< No indirect addressing of inputs */
-   GLboolean EmitNoIndirectOutput;  /**< No indirect addressing of outputs */
-   GLboolean EmitNoIndirectTemp;    /**< No indirect addressing of temps */
-   GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */
-   /*@}*/
-
-   GLuint MaxUnrollIterations;
-
-   struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */
-};
-
-/**
- * Transform feedback object state
- */
-struct gl_transform_feedback_object
-{
-   GLuint Name;  /**< AKA the object ID */
-   GLint RefCount;
-   GLboolean Active;  /**< Is transform feedback enabled? */
-   GLboolean Paused;  /**< Is transform feedback paused? */
-
-   /** The feedback buffers */
-   GLuint BufferNames[MAX_FEEDBACK_ATTRIBS];
-   struct gl_buffer_object *Buffers[MAX_FEEDBACK_ATTRIBS];
-
-   /** Start of feedback data in dest buffer */
-   GLintptr Offset[MAX_FEEDBACK_ATTRIBS];
-   /** Max data to put into dest buffer (in bytes) */
-   GLsizeiptr Size[MAX_FEEDBACK_ATTRIBS];
-};
-
-
-/**
- * Context state for transform feedback.
- */
-struct gl_transform_feedback
-{
-   GLenum Mode;       /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
-
-   GLboolean RasterDiscard;  /**< GL_RASTERIZER_DISCARD */
-
-   /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */
-   struct gl_buffer_object *CurrentBuffer;
-
-   /** The table of all transform feedback objects */
-   struct _mesa_HashTable *Objects;
-
-   /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */
-   struct gl_transform_feedback_object *CurrentObject;
-
-   /** The default xform-fb object (Name==0) */
-   struct gl_transform_feedback_object *DefaultObject;
-};
-
-
-
-/**
- * State which can be shared by multiple contexts:
- */
-struct gl_shared_state
-{
-   _glthread_Mutex Mutex;		   /**< for thread safety */
-   GLint RefCount;			   /**< Reference count */
-   struct _mesa_HashTable *DisplayList;	   /**< Display lists hash table */
-   struct _mesa_HashTable *TexObjects;	   /**< Texture objects hash table */
-
-   /** Default texture objects (shared by all texture units) */
-   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];
-
-   /** Fallback texture used when a bound texture is incomplete */
-   struct gl_texture_object *FallbackTex;
-
-   /**
-    * \name Thread safety and statechange notification for texture
-    * objects. 
-    *
-    * \todo Improve the granularity of locking.
-    */
-   /*@{*/
-   _glthread_Mutex TexMutex;		/**< texobj thread safety */
-   GLuint TextureStateStamp;	        /**< state notification for shared tex */
-   /*@}*/
-
-   /** Default buffer object for vertex arrays that aren't in VBOs */
-   struct gl_buffer_object *NullBufferObj;
-
-   /**
-    * \name Vertex/geometry/fragment programs
-    */
-   /*@{*/
-   struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */
-   struct gl_vertex_program *DefaultVertexProgram;
-   struct gl_fragment_program *DefaultFragmentProgram;
-   struct gl_geometry_program *DefaultGeometryProgram;
-   /*@}*/
-
-   /* GL_ATI_fragment_shader */
-   struct _mesa_HashTable *ATIShaders;
-   struct ati_fragment_shader *DefaultFragmentShader;
-
-   struct _mesa_HashTable *BufferObjects;
-
-   /** Table of both gl_shader and gl_shader_program objects */
-   struct _mesa_HashTable *ShaderObjects;
-
-   /* GL_EXT_framebuffer_object */
-   struct _mesa_HashTable *RenderBuffers;
-   struct _mesa_HashTable *FrameBuffers;
-
-   /* GL_ARB_sync */
-   struct simple_node SyncObjects;
-
-   void *DriverData;  /**< Device driver shared state */
-};
-
-
-
-
-/**
- * A renderbuffer stores colors or depth values or stencil values.
- * A framebuffer object will have a collection of these.
- * Data are read/written to the buffer with a handful of Get/Put functions.
- *
- * Instances of this object are allocated with the Driver's NewRenderbuffer
- * hook.  Drivers will likely wrap this class inside a driver-specific
- * class to simulate inheritance.
- */
-struct gl_renderbuffer
-{
-#define RB_MAGIC 0xaabbccdd
-   int Magic; /** XXX TEMPORARY DEBUG INFO */
-   _glthread_Mutex Mutex;		   /**< for thread safety */
-   GLuint ClassID;        /**< Useful for drivers */
-   GLuint Name;
-   GLint RefCount;
-   GLuint Width, Height;
-   GLboolean Purgeable;   /**< Is the buffer purgeable under memory pressure? */
-
-   GLenum InternalFormat; /**< The user-specified format */
-   GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
-                               GL_STENCIL_INDEX. */
-   gl_format Format;      /**< The actual renderbuffer memory format */
-
-   GLubyte NumSamples;
-
-   GLenum DataType;      /**< Type of values passed to the Get/Put functions */
-   GLvoid *Data;        /**< This may not be used by some kinds of RBs */
-
-   GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */
-
-   /* Used to wrap one renderbuffer around another: */
-   struct gl_renderbuffer *Wrapped;
-
-   /* Delete this renderbuffer */
-   void (*Delete)(struct gl_renderbuffer *rb);
-
-   /* Allocate new storage for this renderbuffer */
-   GLboolean (*AllocStorage)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                             GLenum internalFormat,
-                             GLuint width, GLuint height);
-
-   /* Lock/Unlock are called before/after calling the Get/Put functions.
-    * Not sure this is the right place for these yet.
-   void (*Lock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
-   void (*Unlock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
-    */
-
-   /* Return a pointer to the element/pixel at (x,y).
-    * Should return NULL if the buffer memory can't be directly addressed.
-    */
-   void *(*GetPointer)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                       GLint x, GLint y);
-
-   /* Get/Read a row of values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*GetRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                  GLint x, GLint y, void *values);
-
-   /* Get/Read values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*GetValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     const GLint x[], const GLint y[], void *values);
-
-   /* Put/Write a row of values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                  GLint x, GLint y, const void *values, const GLubyte *mask);
-
-   /* Put/Write a row of RGB values.  This is a special-case routine that's
-    * only used for RGBA renderbuffers when the source data is GL_RGB. That's
-    * a common case for glDrawPixels and some triangle routines.
-    * The values will be of format GL_RGB and type DataType.
-    */
-   void (*PutRowRGB)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                    GLint x, GLint y, const void *values, const GLubyte *mask);
-
-
-   /* Put/Write a row of identical values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutMonoRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     GLint x, GLint y, const void *value, const GLubyte *mask);
-
-   /* Put/Write values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     const GLint x[], const GLint y[], const void *values,
-                     const GLubyte *mask);
-   /* Put/Write identical values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutMonoValues)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                         GLuint count, const GLint x[], const GLint y[],
-                         const void *value, const GLubyte *mask);
-};
-
-
-/**
- * A renderbuffer attachment points to either a texture object (and specifies
- * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.
- */
-struct gl_renderbuffer_attachment
-{
-   GLenum Type;  /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
-   GLboolean Complete;
-
-   /**
-    * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the
-    * application supplied renderbuffer object.
-    */
-   struct gl_renderbuffer *Renderbuffer;
-
-   /**
-    * If \c Type is \c GL_TEXTURE, this stores a pointer to the application
-    * supplied texture object.
-    */
-   struct gl_texture_object *Texture;
-   GLuint TextureLevel; /**< Attached mipmap level. */
-   GLuint CubeMapFace;  /**< 0 .. 5, for cube map textures. */
-   GLuint Zoffset;      /**< Slice for 3D textures,  or layer for both 1D
-                         * and 2D array textures */
-};
-
-
-/**
- * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).
- * In C++ terms, think of this as a base class from which device drivers
- * will make derived classes.
- */
-struct gl_framebuffer
-{
-   _glthread_Mutex Mutex;  /**< for thread safety */
-   /**
-    * If zero, this is a window system framebuffer.  If non-zero, this
-    * is a FBO framebuffer; note that for some devices (i.e. those with
-    * a natural pixel coordinate system for FBOs that differs from the
-    * OpenGL/Mesa coordinate system), this means that the viewport,
-    * polygon face orientation, and polygon stipple will have to be inverted.
-    */
-   GLuint Name;
-
-   GLint RefCount;
-   GLboolean DeletePending;
-
-   /**
-    * The framebuffer's visual. Immutable if this is a window system buffer.
-    * Computed from attachments if user-made FBO.
-    */
-   struct gl_config Visual;
-
-   GLboolean Initialized;
-
-   GLuint Width, Height;	/**< size of frame buffer in pixels */
-
-   /** \name  Drawing bounds (Intersection of buffer size and scissor box) */
-   /*@{*/
-   GLint _Xmin, _Xmax;  /**< inclusive */
-   GLint _Ymin, _Ymax;  /**< exclusive */
-   /*@}*/
-
-   /** \name  Derived Z buffer stuff */
-   /*@{*/
-   GLuint _DepthMax;	/**< Max depth buffer value */
-   GLfloat _DepthMaxF;	/**< Float max depth buffer value */
-   GLfloat _MRD;	/**< minimum resolvable difference in Z values */
-   /*@}*/
-
-   /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
-   GLenum _Status;
-
-   /** Integer color values */
-   GLboolean _IntegerColor;
-
-   /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
-   struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
-
-   /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
-    * attribute group and GL_PIXEL attribute group, respectively.
-    */
-   GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
-   GLenum ColorReadBuffer;
-
-   /** Computed from ColorDraw/ReadBuffer above */
-   GLuint _NumColorDrawBuffers;
-   GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */
-   GLint _ColorReadBufferIndex; /* -1 = None */
-   struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
-   struct gl_renderbuffer *_ColorReadBuffer;
-
-   /** The Actual depth/stencil buffers to use.  May be wrappers around the
-    * depth/stencil buffers attached above. */
-   struct gl_renderbuffer *_DepthBuffer;
-   struct gl_renderbuffer *_StencilBuffer;
-
-   /** Delete this framebuffer */
-   void (*Delete)(struct gl_framebuffer *fb);
-};
-
-
-/**
- * Precision info for shader datatypes.  See glGetShaderPrecisionFormat().
- */
-struct gl_precision
-{
-   GLushort RangeMin;   /**< min value exponent */
-   GLushort RangeMax;   /**< max value exponent */
-   GLushort Precision;  /**< number of mantissa bits */
-};
-
-
-/**
- * Limits for vertex and fragment programs/shaders.
- */
-struct gl_program_constants
-{
-   /* logical limits */
-   GLuint MaxInstructions;
-   GLuint MaxAluInstructions;
-   GLuint MaxTexInstructions;
-   GLuint MaxTexIndirections;
-   GLuint MaxAttribs;
-   GLuint MaxTemps;
-   GLuint MaxAddressRegs;
-   GLuint MaxAddressOffset;  /**< [-MaxAddressOffset, MaxAddressOffset-1] */
-   GLuint MaxParameters;
-   GLuint MaxLocalParams;
-   GLuint MaxEnvParams;
-   /* native/hardware limits */
-   GLuint MaxNativeInstructions;
-   GLuint MaxNativeAluInstructions;
-   GLuint MaxNativeTexInstructions;
-   GLuint MaxNativeTexIndirections;
-   GLuint MaxNativeAttribs;
-   GLuint MaxNativeTemps;
-   GLuint MaxNativeAddressRegs;
-   GLuint MaxNativeParameters;
-   /* For shaders */
-   GLuint MaxUniformComponents;
-   /* GL_ARB_geometry_shader4 */
-   GLuint MaxGeometryTextureImageUnits;
-   GLuint MaxGeometryVaryingComponents;
-   GLuint MaxVertexVaryingComponents;
-   GLuint MaxGeometryUniformComponents;
-   GLuint MaxGeometryOutputVertices;
-   GLuint MaxGeometryTotalOutputComponents;
-   /* ES 2.0 and GL_ARB_ES2_compatibility */
-   struct gl_precision LowFloat, MediumFloat, HighFloat;
-   struct gl_precision LowInt, MediumInt, HighInt;
-};
-
-
-/**
- * Constants which may be overridden by device driver during context creation
- * but are never changed after that.
- */
-struct gl_constants
-{
-   GLint MaxTextureMbytes;      /**< Max memory per image, in MB */
-   GLint MaxTextureLevels;      /**< Max mipmap levels. */ 
-   GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */
-   GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */
-   GLint MaxArrayTextureLayers; /**< Max layers in array textures */
-   GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */
-   GLuint MaxTextureCoordUnits;
-   GLuint MaxTextureImageUnits;
-   GLuint MaxVertexTextureImageUnits;
-   GLuint MaxCombinedTextureImageUnits;
-   GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */
-   GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */
-   GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */
-
-   GLuint MaxArrayLockSize;
-
-   GLint SubPixelBits;
-
-   GLfloat MinPointSize, MaxPointSize;	     /**< aliased */
-   GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */
-   GLfloat PointSizeGranularity;
-   GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */
-   GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */
-   GLfloat LineWidthGranularity;
-
-   GLuint MaxColorTableSize;
-
-   GLuint MaxClipPlanes;
-   GLuint MaxLights;
-   GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */
-   GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */
-
-   GLuint MaxViewportWidth, MaxViewportHeight;
-
-   struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */
-   struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */
-   struct gl_program_constants GeometryProgram;  /**< GL_ARB_geometry_shader4 */
-   GLuint MaxProgramMatrices;
-   GLuint MaxProgramMatrixStackDepth;
-
-   /** vertex array / buffer object bounds checking */
-   GLboolean CheckArrayBounds;
-
-   GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */
-
-   GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */
-   GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */
-   GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */
-
-   GLuint MaxVarying;  /**< Number of float[4] varying parameters */
-
-   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */
-
-   /** Which texture units support GL_ATI_envmap_bumpmap as targets */
-   GLbitfield SupportedBumpUnits;
-
-   /**
-    * Maximum amount of time, measured in nanseconds, that the server can wait.
-    */
-   GLuint64 MaxServerWaitTimeout;
-
-   /** GL_EXT_provoking_vertex */
-   GLboolean QuadsFollowProvokingVertexConvention;
-
-   /** OpenGL version 3.0 */
-   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
-
-   /** OpenGL version 3.2 */
-   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */
-
-   /** GL_EXT_transform_feedback */
-   GLuint MaxTransformFeedbackSeparateAttribs;
-   GLuint MaxTransformFeedbackSeparateComponents;
-   GLuint MaxTransformFeedbackInterleavedComponents;
-
-   /** GL_EXT_gpu_shader4 */
-   GLint MinProgramTexelOffset, MaxProgramTexelOffset;
-
-   /* GL_EXT_framebuffer_sRGB */
-   GLboolean sRGBCapable; /* can enable sRGB blend/update on FBOs */
-};
-
-
-/**
- * Enable flag for each OpenGL extension.  Different device drivers will
- * enable different extensions at runtime.
- */
-struct gl_extensions
-{
-   GLboolean dummy;  /* don't remove this! */
-   GLboolean dummy_true;  /* Set true by _mesa_init_extensions(). */
-   GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */
-   GLboolean ARB_ES2_compatibility;
-   GLboolean ARB_blend_func_extended;
-   GLboolean ARB_copy_buffer;
-   GLboolean ARB_depth_buffer_float;
-   GLboolean ARB_depth_clamp;
-   GLboolean ARB_depth_texture;
-   GLboolean ARB_draw_buffers;
-   GLboolean ARB_draw_buffers_blend;
-   GLboolean ARB_draw_elements_base_vertex;
-   GLboolean ARB_draw_instanced;
-   GLboolean ARB_fragment_coord_conventions;
-   GLboolean ARB_fragment_program;
-   GLboolean ARB_fragment_program_shadow;
-   GLboolean ARB_fragment_shader;
-   GLboolean ARB_framebuffer_object;
-   GLboolean ARB_explicit_attrib_location;
-   GLboolean ARB_geometry_shader4;
-   GLboolean ARB_half_float_pixel;
-   GLboolean ARB_half_float_vertex;
-   GLboolean ARB_instanced_arrays;
-   GLboolean ARB_map_buffer_range;
-   GLboolean ARB_multisample;
-   GLboolean ARB_multitexture;
-   GLboolean ARB_occlusion_query;
-   GLboolean ARB_occlusion_query2;
-   GLboolean ARB_point_sprite;
-   GLboolean ARB_sampler_objects;
-   GLboolean ARB_seamless_cube_map;
-   GLboolean ARB_shader_objects;
-   GLboolean ARB_shader_stencil_export;
-   GLboolean ARB_shading_language_100;
-   GLboolean ARB_shadow;
-   GLboolean ARB_shadow_ambient;
-   GLboolean ARB_sync;
-   GLboolean ARB_texture_border_clamp;
-   GLboolean ARB_texture_buffer_object;
-   GLboolean ARB_texture_compression;
-   GLboolean ARB_texture_compression_rgtc;
-   GLboolean ARB_texture_cube_map;
-   GLboolean ARB_texture_env_combine;
-   GLboolean ARB_texture_env_crossbar;
-   GLboolean ARB_texture_env_dot3;
-   GLboolean ARB_texture_float;
-   GLboolean ARB_texture_mirrored_repeat;
-   GLboolean ARB_texture_multisample;
-   GLboolean ARB_texture_non_power_of_two;
-   GLboolean ARB_texture_rg;
-   GLboolean ARB_texture_rgb10_a2ui;
-   GLboolean ARB_timer_query;
-   GLboolean ARB_transform_feedback2;
-   GLboolean ARB_transpose_matrix;
-   GLboolean ARB_uniform_buffer_object;
-   GLboolean ARB_vertex_array_object;
-   GLboolean ARB_vertex_buffer_object;
-   GLboolean ARB_vertex_program;
-   GLboolean ARB_vertex_shader;
-   GLboolean ARB_vertex_type_2_10_10_10_rev;
-   GLboolean ARB_window_pos;
-   GLboolean EXT_abgr;
-   GLboolean EXT_bgra;
-   GLboolean EXT_blend_color;
-   GLboolean EXT_blend_equation_separate;
-   GLboolean EXT_blend_func_separate;
-   GLboolean EXT_blend_logic_op;
-   GLboolean EXT_blend_minmax;
-   GLboolean EXT_blend_subtract;
-   GLboolean EXT_clip_volume_hint;
-   GLboolean EXT_compiled_vertex_array;
-   GLboolean EXT_copy_texture;
-   GLboolean EXT_depth_bounds_test;
-   GLboolean EXT_draw_buffers2;
-   GLboolean EXT_draw_range_elements;
-   GLboolean EXT_fog_coord;
-   GLboolean EXT_framebuffer_blit;
-   GLboolean EXT_framebuffer_multisample;
-   GLboolean EXT_framebuffer_object;
-   GLboolean EXT_framebuffer_sRGB;
-   GLboolean EXT_gpu_program_parameters;
-   GLboolean EXT_gpu_shader4;
-   GLboolean EXT_multi_draw_arrays;
-   GLboolean EXT_paletted_texture;
-   GLboolean EXT_packed_depth_stencil;
-   GLboolean EXT_packed_float;
-   GLboolean EXT_packed_pixels;
-   GLboolean EXT_pixel_buffer_object;
-   GLboolean EXT_point_parameters;
-   GLboolean EXT_polygon_offset;
-   GLboolean EXT_provoking_vertex;
-   GLboolean EXT_rescale_normal;
-   GLboolean EXT_shadow_funcs;
-   GLboolean EXT_secondary_color;
-   GLboolean EXT_separate_shader_objects;
-   GLboolean EXT_separate_specular_color;
-   GLboolean EXT_shared_texture_palette;
-   GLboolean EXT_stencil_wrap;
-   GLboolean EXT_stencil_two_side;
-   GLboolean EXT_subtexture;
-   GLboolean EXT_texture;
-   GLboolean EXT_texture_object;
-   GLboolean EXT_texture3D;
-   GLboolean EXT_texture_array;
-   GLboolean EXT_texture_compression_latc;
-   GLboolean EXT_texture_compression_s3tc;
-   GLboolean EXT_texture_env_add;
-   GLboolean EXT_texture_env_combine;
-   GLboolean EXT_texture_env_dot3;
-   GLboolean EXT_texture_filter_anisotropic;
-   GLboolean EXT_texture_integer;
-   GLboolean EXT_texture_lod_bias;
-   GLboolean EXT_texture_mirror_clamp;
-   GLboolean EXT_texture_shared_exponent;
-   GLboolean EXT_texture_sRGB;
-   GLboolean EXT_texture_sRGB_decode;
-   GLboolean EXT_texture_swizzle;
-   GLboolean EXT_transform_feedback;
-   GLboolean EXT_timer_query;
-   GLboolean EXT_vertex_array;
-   GLboolean EXT_vertex_array_bgra;
-   GLboolean EXT_vertex_array_set;
-   GLboolean OES_standard_derivatives;
-   /* vendor extensions */
-   GLboolean AMD_conservative_depth;
-   GLboolean APPLE_client_storage;
-   GLboolean APPLE_packed_pixels;
-   GLboolean APPLE_vertex_array_object;
-   GLboolean APPLE_object_purgeable;
-   GLboolean ATI_envmap_bumpmap;
-   GLboolean ATI_texture_compression_3dc;
-   GLboolean ATI_texture_mirror_once;
-   GLboolean ATI_texture_env_combine3;
-   GLboolean ATI_fragment_shader;
-   GLboolean ATI_separate_stencil;
-   GLboolean IBM_rasterpos_clip;
-   GLboolean IBM_multimode_draw_arrays;
-   GLboolean MESA_pack_invert;
-   GLboolean MESA_resize_buffers;
-   GLboolean MESA_ycbcr_texture;
-   GLboolean MESA_texture_array;
-   GLboolean MESA_texture_signed_rgba;
-   GLboolean NV_blend_square;
-   GLboolean NV_conditional_render;
-   GLboolean NV_fragment_program;
-   GLboolean NV_fragment_program_option;
-   GLboolean NV_light_max_exponent;
-   GLboolean NV_point_sprite;
-   GLboolean NV_primitive_restart;
-   GLboolean NV_texgen_reflection;
-   GLboolean NV_texture_env_combine4;
-   GLboolean NV_texture_rectangle;
-   GLboolean NV_vertex_program;
-   GLboolean NV_vertex_program1_1;
-   GLboolean OES_read_format;
-   GLboolean SGIS_generate_mipmap;
-   GLboolean SGIS_texture_edge_clamp;
-   GLboolean SGIS_texture_lod;
-   GLboolean TDFX_texture_compression_FXT1;
-   GLboolean S3_s3tc;
-   GLboolean OES_EGL_image;
-   GLboolean OES_draw_texture;
-   GLboolean EXT_texture_format_BGRA8888;
-   GLboolean extension_sentinel;
-   /** The extension string */
-   const GLubyte *String;
-   /** Number of supported extensions */
-   GLuint Count;
-};
-
-
-/**
- * A stack of matrices (projection, modelview, color, texture, etc).
- */
-struct gl_matrix_stack
-{
-   GLmatrix *Top;      /**< points into Stack */
-   GLmatrix *Stack;    /**< array [MaxDepth] of GLmatrix */
-   GLuint Depth;       /**< 0 <= Depth < MaxDepth */
-   GLuint MaxDepth;    /**< size of Stack[] array */
-   GLuint DirtyFlag;   /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */
-};
-
-
-/**
- * \name Bits for image transfer operations 
- * \sa __struct gl_contextRec::ImageTransferState.
- */
-/*@{*/
-#define IMAGE_SCALE_BIAS_BIT                      0x1
-#define IMAGE_SHIFT_OFFSET_BIT                    0x2
-#define IMAGE_MAP_COLOR_BIT                       0x4
-#define IMAGE_CLAMP_BIT                           0x800
-
-
-/** Pixel Transfer ops */
-#define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT |			\
-		    IMAGE_SHIFT_OFFSET_BIT |			\
-		    IMAGE_MAP_COLOR_BIT)
-
-/**
- * \name Bits to indicate what state has changed.  
- */
-/*@{*/
-#define _NEW_MODELVIEW         (1 << 0)   /**< gl_context::ModelView */
-#define _NEW_PROJECTION        (1 << 1)   /**< gl_context::Projection */
-#define _NEW_TEXTURE_MATRIX    (1 << 2)   /**< gl_context::TextureMatrix */
-#define _NEW_COLOR             (1 << 3)   /**< gl_context::Color */
-#define _NEW_DEPTH             (1 << 4)   /**< gl_context::Depth */
-#define _NEW_EVAL              (1 << 5)   /**< gl_context::Eval, EvalMap */
-#define _NEW_FOG               (1 << 6)   /**< gl_context::Fog */
-#define _NEW_HINT              (1 << 7)   /**< gl_context::Hint */
-#define _NEW_LIGHT             (1 << 8)   /**< gl_context::Light */
-#define _NEW_LINE              (1 << 9)   /**< gl_context::Line */
-#define _NEW_PIXEL             (1 << 10)  /**< gl_context::Pixel */
-#define _NEW_POINT             (1 << 11)  /**< gl_context::Point */
-#define _NEW_POLYGON           (1 << 12)  /**< gl_context::Polygon */
-#define _NEW_POLYGONSTIPPLE    (1 << 13)  /**< gl_context::PolygonStipple */
-#define _NEW_SCISSOR           (1 << 14)  /**< gl_context::Scissor */
-#define _NEW_STENCIL           (1 << 15)  /**< gl_context::Stencil */
-#define _NEW_TEXTURE           (1 << 16)  /**< gl_context::Texture */
-#define _NEW_TRANSFORM         (1 << 17)  /**< gl_context::Transform */
-#define _NEW_VIEWPORT          (1 << 18)  /**< gl_context::Viewport */
-#define _NEW_PACKUNPACK        (1 << 19)  /**< gl_context::Pack, Unpack */
-#define _NEW_ARRAY             (1 << 20)  /**< gl_context::Array */
-#define _NEW_RENDERMODE        (1 << 21)  /**< gl_context::RenderMode, etc */
-#define _NEW_BUFFERS           (1 << 22)  /**< gl_context::Visual, DrawBuffer, */
-#define _NEW_CURRENT_ATTRIB    (1 << 23)  /**< gl_context::Current */
-#define _NEW_MULTISAMPLE       (1 << 24)  /**< gl_context::Multisample */
-#define _NEW_TRACK_MATRIX      (1 << 25)  /**< gl_context::VertexProgram */
-#define _NEW_PROGRAM           (1 << 26)  /**< New program/shader state */
-#define _NEW_PROGRAM_CONSTANTS (1 << 27)
-#define _NEW_BUFFER_OBJECT     (1 << 28)
-#define _NEW_ALL ~0
-/*@}*/
-
-
-/**
- * \name Bits to track array state changes 
- *
- * Also used to summarize array enabled.
- */
-/*@{*/
-#define _NEW_ARRAY_VERTEX           VERT_BIT_POS
-#define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT
-#define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL
-#define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0
-#define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1
-#define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG
-#define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX
-#define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG
-#define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */
-#define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0
-#define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1
-#define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2
-#define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3
-#define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4
-#define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5
-#define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6
-#define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7
-#define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */
-#define _NEW_ARRAY_ALL              0xffffffff
-
-
-#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
-#define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))
-/*@}*/
-
-
-
-/**
- * \name A bunch of flags that we think might be useful to drivers.
- * 
- * Set in the __struct gl_contextRec::_TriangleCaps bitfield.
- */
-/*@{*/
-#define DD_FLATSHADE                0x1
-#define DD_SEPARATE_SPECULAR        0x2
-#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */
-#define DD_TRI_LIGHT_TWOSIDE        0x8
-#define DD_TRI_UNFILLED             0x10
-#define DD_TRI_SMOOTH               0x20
-#define DD_TRI_STIPPLE              0x40
-#define DD_TRI_OFFSET               0x80
-#define DD_LINE_SMOOTH              0x100
-#define DD_LINE_STIPPLE             0x200
-#define DD_POINT_SMOOTH             0x400
-#define DD_POINT_ATTEN              0x800
-#define DD_TRI_TWOSTENCIL           0x1000
-/*@}*/
-
-
-/**
- * \name Define the state changes under which each of these bits might change
- */
-/*@{*/
-#define _DD_NEW_FLATSHADE                _NEW_LIGHT
-#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)
-#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON
-#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT
-#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON
-#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON
-#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON
-#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON
-#define _DD_NEW_LINE_SMOOTH              _NEW_LINE
-#define _DD_NEW_LINE_STIPPLE             _NEW_LINE
-#define _DD_NEW_LINE_WIDTH               _NEW_LINE
-#define _DD_NEW_POINT_SMOOTH             _NEW_POINT
-#define _DD_NEW_POINT_SIZE               _NEW_POINT
-#define _DD_NEW_POINT_ATTEN              _NEW_POINT
-/*@}*/
-
-
-/**
- * Composite state flags
- */
-/*@{*/
-#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\
-                                           _NEW_TEXTURE |	\
-                                           _NEW_POINT |		\
-                                           _NEW_PROGRAM |	\
-                                           _NEW_MODELVIEW)
-
-#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\
-                                           _NEW_TEXTURE)
-
-#define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL)
-/*@}*/
-
-
-
-
-/* This has to be included here. */
-#include "dd.h"
-
-
-/**
- * Display list flags.
- * Strictly this is a tnl-private concept, but it doesn't seem
- * worthwhile adding a tnl private structure just to hold this one bit
- * of information:
- */
-#define DLIST_DANGLING_REFS     0x1 
-
-
-/** Opaque declaration of display list payload data type */
-union gl_dlist_node;
-
-
-/**
- * Provide a location where information about a display list can be
- * collected.  Could be extended with driverPrivate structures,
- * etc. in the future.
- */
-struct gl_display_list
-{
-   GLuint Name;
-   GLbitfield Flags;  /**< DLIST_x flags */
-   /** The dlist commands are in a linked list of nodes */
-   union gl_dlist_node *Head;
-};
-
-
-/**
- * State used during display list compilation and execution.
- */
-struct gl_dlist_state
-{
-   GLuint CallDepth;		/**< Current recursion calling depth */
-
-   struct gl_display_list *CurrentList; /**< List currently being compiled */
-   union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */
-   GLuint CurrentPos;		/**< Index into current block of nodes */
-
-   GLvertexformat ListVtxfmt;
-
-   GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];
-   GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];
-   
-   GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];
-   GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];
-
-   GLubyte ActiveIndex;
-   GLfloat CurrentIndex;
-   
-   GLubyte ActiveEdgeFlag;
-   GLboolean CurrentEdgeFlag;
-
-   struct {
-      /* State known to have been set by the currently-compiling display
-       * list.  Used to eliminate some redundant state changes.
-       */
-      GLenum ShadeModel;
-   } Current;
-};
-
-
-/**
- * Enum for the OpenGL APIs we know about and may support.
- */
-typedef enum
-{
-   API_OPENGL,
-   API_OPENGLES,
-   API_OPENGLES2
-} gl_api;
-
-
-/**
- * Mesa rendering context.
- *
- * This is the central context data structure for Mesa.  Almost all
- * OpenGL state is contained in this structure.
- * Think of this as a base class from which device drivers will derive
- * sub classes.
- *
- * The struct gl_context typedef names this structure.
- */
-struct gl_context
-{
-   /** State possibly shared with other contexts in the address space */
-   struct gl_shared_state *Shared;
-
-   /** \name API function pointer tables */
-   /*@{*/
-   gl_api API;
-   struct _glapi_table *Save;	/**< Display list save functions */
-   struct _glapi_table *Exec;	/**< Execute functions */
-   struct _glapi_table *CurrentDispatch;  /**< == Save or Exec !! */
-   /*@}*/
-
-   struct gl_config Visual;
-   struct gl_framebuffer *DrawBuffer;	/**< buffer for writing */
-   struct gl_framebuffer *ReadBuffer;	/**< buffer for reading */
-   struct gl_framebuffer *WinSysDrawBuffer;  /**< set with MakeCurrent */
-   struct gl_framebuffer *WinSysReadBuffer;  /**< set with MakeCurrent */
-
-   /**
-    * Device driver function pointer table
-    */
-   struct dd_function_table Driver;
-
-   void *DriverCtx;	/**< Points to device driver context/state */
-
-   /** Core/Driver constants */
-   struct gl_constants Const;
-
-   /** \name The various 4x4 matrix stacks */
-   /*@{*/
-   struct gl_matrix_stack ModelviewMatrixStack;
-   struct gl_matrix_stack ProjectionMatrixStack;
-   struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];
-   struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];
-   struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */
-   /*@}*/
-
-   /** Combined modelview and projection matrix */
-   GLmatrix _ModelProjectMatrix;
-
-   /** \name Display lists */
-   struct gl_dlist_state ListState;
-
-   GLboolean ExecuteFlag;	/**< Execute GL commands? */
-   GLboolean CompileFlag;	/**< Compile GL commands into display list? */
-
-   /** Extension information */
-   struct gl_extensions Extensions;
-
-   /** Version info */
-   GLuint VersionMajor, VersionMinor;
-   char *VersionString;
-
-   /** \name State attribute stack (for glPush/PopAttrib) */
-   /*@{*/
-   GLuint AttribStackDepth;
-   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
-   /*@}*/
-
-   /** \name Renderer attribute groups
-    * 
-    * We define a struct for each attribute group to make pushing and popping
-    * attributes easy.  Also it's a good organization.
-    */
-   /*@{*/
-   struct gl_accum_attrib	Accum;		/**< Accum buffer attributes */
-   struct gl_colorbuffer_attrib	Color;		/**< Color buffer attributes */
-   struct gl_current_attrib	Current;	/**< Current attributes */
-   struct gl_depthbuffer_attrib	Depth;		/**< Depth buffer attributes */
-   struct gl_eval_attrib	Eval;		/**< Eval attributes */
-   struct gl_fog_attrib		Fog;		/**< Fog attributes */
-   struct gl_hint_attrib	Hint;		/**< Hint attributes */
-   struct gl_light_attrib	Light;		/**< Light attributes */
-   struct gl_line_attrib	Line;		/**< Line attributes */
-   struct gl_list_attrib	List;		/**< List attributes */
-   struct gl_multisample_attrib Multisample;
-   struct gl_pixel_attrib	Pixel;		/**< Pixel attributes */
-   struct gl_point_attrib	Point;		/**< Point attributes */
-   struct gl_polygon_attrib	Polygon;	/**< Polygon attributes */
-   GLuint PolygonStipple[32];			/**< Polygon stipple */
-   struct gl_scissor_attrib	Scissor;	/**< Scissor attributes */
-   struct gl_stencil_attrib	Stencil;	/**< Stencil buffer attributes */
-   struct gl_texture_attrib	Texture;	/**< Texture attributes */
-   struct gl_transform_attrib	Transform;	/**< Transformation attributes */
-   struct gl_viewport_attrib	Viewport;	/**< Viewport attributes */
-   /*@}*/
-
-   /** \name Client attribute stack */
-   /*@{*/
-   GLuint ClientAttribStackDepth;
-   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
-   /*@}*/
-
-   /** \name Client attribute groups */
-   /*@{*/
-   struct gl_array_attrib	Array;	/**< Vertex arrays */
-   struct gl_pixelstore_attrib	Pack;	/**< Pixel packing */
-   struct gl_pixelstore_attrib	Unpack;	/**< Pixel unpacking */
-   struct gl_pixelstore_attrib	DefaultPacking;	/**< Default params */
-   /*@}*/
-
-   /** \name Other assorted state (not pushed/popped on attribute stack) */
-   /*@{*/
-   struct gl_pixelmaps          PixelMaps;
-
-   struct gl_evaluators EvalMap;   /**< All evaluators */
-   struct gl_feedback   Feedback;  /**< Feedback */
-   struct gl_selection  Select;    /**< Selection */
-
-   struct gl_program_state Program;  /**< general program state */
-   struct gl_vertex_program_state VertexProgram;
-   struct gl_fragment_program_state FragmentProgram;
-   struct gl_geometry_program_state GeometryProgram;
-   struct gl_ati_fragment_shader_state ATIFragmentShader;
-
-   struct gl_shader_state Shader; /**< GLSL shader object state */
-   struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES];
-
-   struct gl_query_state Query;  /**< occlusion, timer queries */
-
-   struct gl_transform_feedback TransformFeedback;
-
-   struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */
-   struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */
-   /*@}*/
-
-   struct gl_meta_state *Meta;  /**< for "meta" operations */
-
-   /* GL_EXT_framebuffer_object */
-   struct gl_renderbuffer *CurrentRenderbuffer;
-
-   GLenum ErrorValue;        /**< Last error code */
-
-   /**
-    * Recognize and silence repeated error debug messages in buggy apps.
-    */
-   const char *ErrorDebugFmtString;
-   GLuint ErrorDebugCount;
-
-   GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
-   GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */
-
-   GLboolean ViewportInitialized;  /**< has viewport size been initialized? */
-
-   GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */
-
-   /** \name Derived state */
-   /*@{*/
-   /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before
-    * state validation so they need to always be current.
-    */
-   GLbitfield _TriangleCaps;
-   GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */
-   GLfloat _EyeZDir[3];
-   GLfloat _ModelViewInvScale;
-   GLboolean _NeedEyeCoords;
-   GLboolean _ForceEyeCoords; 
-
-   GLuint TextureStateTimestamp; /**< detect changes to shared state */
-
-   struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */
-   struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */
-   /**@}*/
-
-   struct gl_list_extensions *ListExt; /**< driver dlist extensions */
-
-   /** \name For debugging/development only */
-   /*@{*/
-   GLboolean FirstTimeCurrent;
-   /*@}*/
-
-   /** software compression/decompression supported or not */
-   GLboolean Mesa_DXTn;
-
-   GLboolean TextureFormatSupported[MESA_FORMAT_COUNT];
-
-   /** 
-    * Use dp4 (rather than mul/mad) instructions for position
-    * transformation?
-    */
-   GLboolean mvp_with_dp4;
-
-   /**
-    * \name Hooks for module contexts.  
-    *
-    * These will eventually live in the driver or elsewhere.
-    */
-   /*@{*/
-   void *swrast_context;
-   void *swsetup_context;
-   void *swtnl_context;
-   void *swtnl_im;
-   struct st_context *st;
-   void *aelt_context;
-   /*@}*/
-};
-
-
-#ifdef DEBUG
-extern int MESA_VERBOSE;
-extern int MESA_DEBUG_FLAGS;
-# define MESA_FUNCTION __FUNCTION__
-#else
-# define MESA_VERBOSE 0
-# define MESA_DEBUG_FLAGS 0
-# define MESA_FUNCTION "a function"
-# ifndef NDEBUG
-#  define NDEBUG
-# endif
-#endif
-
-
-/** The MESA_VERBOSE var is a bitmask of these flags */
-enum _verbose
-{
-   VERBOSE_VARRAY		= 0x0001,
-   VERBOSE_TEXTURE		= 0x0002,
-   VERBOSE_MATERIAL		= 0x0004,
-   VERBOSE_PIPELINE		= 0x0008,
-   VERBOSE_DRIVER		= 0x0010,
-   VERBOSE_STATE		= 0x0020,
-   VERBOSE_API			= 0x0040,
-   VERBOSE_DISPLAY_LIST		= 0x0100,
-   VERBOSE_LIGHTING		= 0x0200,
-   VERBOSE_PRIMS		= 0x0400,
-   VERBOSE_VERTS		= 0x0800,
-   VERBOSE_DISASSEM		= 0x1000,
-   VERBOSE_DRAW                 = 0x2000,
-   VERBOSE_SWAPBUFFERS          = 0x4000
-};
-
-
-/** The MESA_DEBUG_FLAGS var is a bitmask of these flags */
-enum _debug
-{
-   DEBUG_ALWAYS_FLUSH		= 0x1
-};
-
-
-
-#endif /* MTYPES_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file mtypes.h

+ * Main Mesa data structures.

+ *

+ * Please try to mark derived values with a leading underscore ('_').

+ */

+

+#ifndef MTYPES_H

+#define MTYPES_H

+

+

+#include "main/glheader.h"

+#include "main/config.h"

+#include "main/mfeatures.h"

+#include "glapi/glapi.h"

+#include "math/m_matrix.h"	/* GLmatrix */

+#include "main/simple_list.h"	/* struct simple_node */

+#include "main/formats.h"       /* MESA_FORMAT_COUNT */

+

+

+/**

+ * Color channel data type.

+ */

+#if CHAN_BITS == 8

+   typedef GLubyte GLchan;

+#define CHAN_MAX 255

+#define CHAN_MAXF 255.0F

+#define CHAN_TYPE GL_UNSIGNED_BYTE

+#elif CHAN_BITS == 16

+   typedef GLushort GLchan;

+#define CHAN_MAX 65535

+#define CHAN_MAXF 65535.0F

+#define CHAN_TYPE GL_UNSIGNED_SHORT

+#elif CHAN_BITS == 32

+   typedef GLfloat GLchan;

+#define CHAN_MAX 1.0

+#define CHAN_MAXF 1.0F

+#define CHAN_TYPE GL_FLOAT

+#else

+#error "illegal number of color channel bits"

+#endif

+

+

+/**

+ * Stencil buffer data type.

+ */

+#if STENCIL_BITS==8

+   typedef GLubyte GLstencil;

+#elif STENCIL_BITS==16

+   typedef GLushort GLstencil;

+#else

+#  error "illegal number of stencil bits"

+#endif

+

+

+/**

+ * \name 64-bit extension of GLbitfield.

+ */

+/*@{*/

+typedef GLuint64 GLbitfield64;

+

+/** Set a single bit */

+#define BITFIELD64_BIT(b)      (1ULL << (b))

+

+

+/**

+ * \name Some forward type declarations

+ */

+/*@{*/

+struct _mesa_HashTable;

+struct gl_attrib_node;

+struct gl_list_extensions;

+struct gl_meta_state;

+struct gl_pixelstore_attrib;

+struct gl_program_cache;

+struct gl_texture_format;

+struct gl_texture_image;

+struct gl_texture_object;

+struct gl_context;

+struct st_context;

+/*@}*/

+

+

+/** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */

+#define PRIM_OUTSIDE_BEGIN_END   (GL_POLYGON+1)

+#define PRIM_INSIDE_UNKNOWN_PRIM (GL_POLYGON+2)

+#define PRIM_UNKNOWN             (GL_POLYGON+3)

+

+

+/**

+ * Shader stages. Note that these will become 5 with tessellation.

+ * These MUST have the same values as gallium's PIPE_SHADER_*

+ */

+typedef enum

+{

+   MESA_SHADER_VERTEX = 0,

+   MESA_SHADER_FRAGMENT = 1,

+   MESA_SHADER_GEOMETRY = 2,

+   MESA_SHADER_TYPES = 3

+} gl_shader_type;

+

+

+

+/**

+ * Indexes for vertex program attributes.

+ * GL_NV_vertex_program aliases generic attributes over the conventional

+ * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.

+ * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the

+ * generic attributes are distinct/separate).

+ */

+typedef enum

+{

+   VERT_ATTRIB_POS = 0,

+   VERT_ATTRIB_WEIGHT = 1,

+   VERT_ATTRIB_NORMAL = 2,

+   VERT_ATTRIB_COLOR0 = 3,

+   VERT_ATTRIB_COLOR1 = 4,

+   VERT_ATTRIB_FOG = 5,

+   VERT_ATTRIB_COLOR_INDEX = 6,

+   VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/

+   VERT_ATTRIB_EDGEFLAG = 7,

+   VERT_ATTRIB_TEX0 = 8,

+   VERT_ATTRIB_TEX1 = 9,

+   VERT_ATTRIB_TEX2 = 10,

+   VERT_ATTRIB_TEX3 = 11,

+   VERT_ATTRIB_TEX4 = 12,

+   VERT_ATTRIB_TEX5 = 13,

+   VERT_ATTRIB_TEX6 = 14,

+   VERT_ATTRIB_TEX7 = 15,

+   VERT_ATTRIB_GENERIC0 = 16,

+   VERT_ATTRIB_GENERIC1 = 17,

+   VERT_ATTRIB_GENERIC2 = 18,

+   VERT_ATTRIB_GENERIC3 = 19,

+   VERT_ATTRIB_GENERIC4 = 20,

+   VERT_ATTRIB_GENERIC5 = 21,

+   VERT_ATTRIB_GENERIC6 = 22,

+   VERT_ATTRIB_GENERIC7 = 23,

+   VERT_ATTRIB_GENERIC8 = 24,

+   VERT_ATTRIB_GENERIC9 = 25,

+   VERT_ATTRIB_GENERIC10 = 26,

+   VERT_ATTRIB_GENERIC11 = 27,

+   VERT_ATTRIB_GENERIC12 = 28,

+   VERT_ATTRIB_GENERIC13 = 29,

+   VERT_ATTRIB_GENERIC14 = 30,

+   VERT_ATTRIB_GENERIC15 = 31,

+   VERT_ATTRIB_MAX = 32

+} gl_vert_attrib;

+

+/**

+ * Bitflags for vertex attributes.

+ * These are used in bitfields in many places.

+ */

+/*@{*/

+#define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)

+#define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)

+#define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)

+#define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)

+#define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)

+#define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)

+#define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)

+#define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)

+#define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)

+#define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)

+#define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)

+#define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)

+#define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)

+#define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)

+#define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)

+#define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)

+#define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)

+#define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)

+#define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)

+#define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)

+#define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)

+#define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)

+#define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)

+#define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)

+#define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)

+#define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)

+#define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)

+#define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)

+#define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)

+#define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)

+#define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)

+#define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)

+

+#define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))

+#define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))

+/*@}*/

+

+

+/**

+ * Indexes for vertex program result attributes

+ */

+typedef enum

+{

+   VERT_RESULT_HPOS = 0,

+   VERT_RESULT_COL0 = 1,

+   VERT_RESULT_COL1 = 2,

+   VERT_RESULT_FOGC = 3,

+   VERT_RESULT_TEX0 = 4,

+   VERT_RESULT_TEX1 = 5,

+   VERT_RESULT_TEX2 = 6,

+   VERT_RESULT_TEX3 = 7,

+   VERT_RESULT_TEX4 = 8,

+   VERT_RESULT_TEX5 = 9,

+   VERT_RESULT_TEX6 = 10,

+   VERT_RESULT_TEX7 = 11,

+   VERT_RESULT_PSIZ = 12,

+   VERT_RESULT_BFC0 = 13,

+   VERT_RESULT_BFC1 = 14,

+   VERT_RESULT_EDGE = 15,

+   VERT_RESULT_VAR0 = 16,  /**< shader varying */

+   VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)

+} gl_vert_result;

+

+

+/*********************************************/

+

+/**

+ * Indexes for geometry program attributes.

+ */

+typedef enum

+{

+   GEOM_ATTRIB_POSITION = 0,

+   GEOM_ATTRIB_COLOR0 = 1,

+   GEOM_ATTRIB_COLOR1 = 2,

+   GEOM_ATTRIB_SECONDARY_COLOR0 = 3,

+   GEOM_ATTRIB_SECONDARY_COLOR1 = 4,

+   GEOM_ATTRIB_FOG_FRAG_COORD = 5,

+   GEOM_ATTRIB_POINT_SIZE = 6,

+   GEOM_ATTRIB_CLIP_VERTEX = 7,

+   GEOM_ATTRIB_PRIMITIVE_ID = 8,

+   GEOM_ATTRIB_TEX_COORD = 9,

+

+   GEOM_ATTRIB_VAR0 = 16,

+   GEOM_ATTRIB_MAX = (GEOM_ATTRIB_VAR0 + MAX_VARYING)

+} gl_geom_attrib;

+

+/**

+ * Bitflags for geometry attributes.

+ * These are used in bitfields in many places.

+ */

+/*@{*/

+#define GEOM_BIT_COLOR0      (1 << GEOM_ATTRIB_COLOR0)

+#define GEOM_BIT_COLOR1      (1 << GEOM_ATTRIB_COLOR1)

+#define GEOM_BIT_SCOLOR0     (1 << GEOM_ATTRIB_SECONDARY_COLOR0)

+#define GEOM_BIT_SCOLOR1     (1 << GEOM_ATTRIB_SECONDARY_COLOR1)

+#define GEOM_BIT_TEX_COORD   (1 << GEOM_ATTRIB_TEX_COORD)

+#define GEOM_BIT_FOG_COORD   (1 << GEOM_ATTRIB_FOG_FRAG_COORD)

+#define GEOM_BIT_POSITION    (1 << GEOM_ATTRIB_POSITION)

+#define GEOM_BIT_POINT_SIDE  (1 << GEOM_ATTRIB_POINT_SIZE)

+#define GEOM_BIT_CLIP_VERTEX (1 << GEOM_ATTRIB_CLIP_VERTEX)

+#define GEOM_BIT_PRIM_ID     (1 << GEOM_ATTRIB_PRIMITIVE_ID)

+#define GEOM_BIT_VAR0        (1 << GEOM_ATTRIB_VAR0)

+

+#define GEOM_BIT_VAR(g)  (1 << (GEOM_BIT_VAR0 + (g)))

+/*@}*/

+

+

+/**

+ * Indexes for geometry program result attributes

+ */

+typedef enum

+{

+   GEOM_RESULT_POS  = 0,

+   GEOM_RESULT_COL0  = 1,

+   GEOM_RESULT_COL1  = 2,

+   GEOM_RESULT_SCOL0 = 3,

+   GEOM_RESULT_SCOL1 = 4,

+   GEOM_RESULT_FOGC = 5,

+   GEOM_RESULT_TEX0 = 6,

+   GEOM_RESULT_TEX1 = 7,

+   GEOM_RESULT_TEX2 = 8,

+   GEOM_RESULT_TEX3 = 9,

+   GEOM_RESULT_TEX4 = 10,

+   GEOM_RESULT_TEX5 = 11,

+   GEOM_RESULT_TEX6 = 12,

+   GEOM_RESULT_TEX7 = 13,

+   GEOM_RESULT_PSIZ = 14,

+   GEOM_RESULT_CLPV = 15,

+   GEOM_RESULT_PRID = 16,

+   GEOM_RESULT_LAYR = 17,

+   GEOM_RESULT_VAR0 = 18,  /**< shader varying, should really be 16 */

+   /* ### we need to -2 because var0 is 18 instead 16 like in the others */

+   GEOM_RESULT_MAX  =  (GEOM_RESULT_VAR0 + MAX_VARYING - 2)

+} gl_geom_result;

+

+

+/**

+ * Indexes for fragment program input attributes.

+ */

+typedef enum

+{

+   FRAG_ATTRIB_WPOS = 0,

+   FRAG_ATTRIB_COL0 = 1,

+   FRAG_ATTRIB_COL1 = 2,

+   FRAG_ATTRIB_FOGC = 3,

+   FRAG_ATTRIB_TEX0 = 4,

+   FRAG_ATTRIB_TEX1 = 5,

+   FRAG_ATTRIB_TEX2 = 6,

+   FRAG_ATTRIB_TEX3 = 7,

+   FRAG_ATTRIB_TEX4 = 8,

+   FRAG_ATTRIB_TEX5 = 9,

+   FRAG_ATTRIB_TEX6 = 10,

+   FRAG_ATTRIB_TEX7 = 11,

+   FRAG_ATTRIB_FACE = 12,  /**< front/back face */

+   FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */

+   FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */

+   FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)

+} gl_frag_attrib;

+

+/**

+ * Bitflags for fragment program input attributes.

+ */

+/*@{*/

+#define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)

+#define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)

+#define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)

+#define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)

+#define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)

+#define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)

+#define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)

+#define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)

+#define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)

+#define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)

+#define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)

+#define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)

+#define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)

+#define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)

+#define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)

+

+#define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))

+#define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))

+

+#define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|	\

+			   FRAG_BIT_TEX1|	\

+			   FRAG_BIT_TEX2|	\

+			   FRAG_BIT_TEX3|	\

+			   FRAG_BIT_TEX4|	\

+			   FRAG_BIT_TEX5|	\

+			   FRAG_BIT_TEX6|	\

+			   FRAG_BIT_TEX7)

+/*@}*/

+

+

+/**

+ * Fragment program results

+ */

+typedef enum

+{

+   FRAG_RESULT_DEPTH = 0,

+   FRAG_RESULT_STENCIL = 1,

+   FRAG_RESULT_COLOR = 2,

+   FRAG_RESULT_DATA0 = 3,

+   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)

+} gl_frag_result;

+

+

+/**

+ * Indexes for all renderbuffers

+ */

+typedef enum

+{

+   /* the four standard color buffers */

+   BUFFER_FRONT_LEFT,

+   BUFFER_BACK_LEFT,

+   BUFFER_FRONT_RIGHT,

+   BUFFER_BACK_RIGHT,

+   BUFFER_DEPTH,

+   BUFFER_STENCIL,

+   BUFFER_ACCUM,

+   /* optional aux buffer */

+   BUFFER_AUX0,

+   /* generic renderbuffers */

+   BUFFER_COLOR0,

+   BUFFER_COLOR1,

+   BUFFER_COLOR2,

+   BUFFER_COLOR3,

+   BUFFER_COLOR4,

+   BUFFER_COLOR5,

+   BUFFER_COLOR6,

+   BUFFER_COLOR7,

+   BUFFER_COUNT

+} gl_buffer_index;

+

+/**

+ * Bit flags for all renderbuffers

+ */

+#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)

+#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)

+#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)

+#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)

+#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)

+#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)

+#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)

+#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)

+#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)

+#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)

+#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)

+#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)

+#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)

+#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)

+#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)

+#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)

+#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)

+#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)

+#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)

+

+/**

+ * Mask of all the color buffer bits (but not accum).

+ */

+#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \

+                            BUFFER_BIT_BACK_LEFT | \

+                            BUFFER_BIT_FRONT_RIGHT | \

+                            BUFFER_BIT_BACK_RIGHT | \

+                            BUFFER_BIT_AUX0 | \

+                            BUFFER_BIT_COLOR0 | \

+                            BUFFER_BIT_COLOR1 | \

+                            BUFFER_BIT_COLOR2 | \

+                            BUFFER_BIT_COLOR3 | \

+                            BUFFER_BIT_COLOR4 | \

+                            BUFFER_BIT_COLOR5 | \

+                            BUFFER_BIT_COLOR6 | \

+                            BUFFER_BIT_COLOR7)

+

+

+/**

+ * Framebuffer configuration (aka visual / pixelformat)

+ * Note: some of these fields should be boolean, but it appears that

+ * code in drivers/dri/common/util.c requires int-sized fields.

+ */

+struct gl_config

+{

+   GLboolean rgbMode;

+   GLboolean floatMode;

+   GLboolean colorIndexMode;  /* XXX is this used anywhere? */

+   GLuint doubleBufferMode;

+   GLuint stereoMode;

+

+   GLboolean haveAccumBuffer;

+   GLboolean haveDepthBuffer;

+   GLboolean haveStencilBuffer;

+

+   GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */

+   GLuint redMask, greenMask, blueMask, alphaMask;

+   GLint rgbBits;		/* total bits for rgb */

+   GLint indexBits;		/* total bits for colorindex */

+

+   GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;

+   GLint depthBits;

+   GLint stencilBits;

+

+   GLint numAuxBuffers;

+

+   GLint level;

+

+   /* EXT_visual_rating / GLX 1.2 */

+   GLint visualRating;

+

+   /* EXT_visual_info / GLX 1.2 */

+   GLint transparentPixel;

+   /*    colors are floats scaled to ints */

+   GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;

+   GLint transparentIndex;

+

+   /* ARB_multisample / SGIS_multisample */

+   GLint sampleBuffers;

+   GLint samples;

+

+   /* SGIX_pbuffer / GLX 1.3 */

+   GLint maxPbufferWidth;

+   GLint maxPbufferHeight;

+   GLint maxPbufferPixels;

+   GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */

+   GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */

+

+   /* OML_swap_method */

+   GLint swapMethod;

+

+   /* EXT_texture_from_pixmap */

+   GLint bindToTextureRgb;

+   GLint bindToTextureRgba;

+   GLint bindToMipmapTexture;

+   GLint bindToTextureTargets;

+   GLint yInverted;

+

+   /* EXT_framebuffer_sRGB */

+   GLint sRGBCapable;

+};

+

+

+/**

+ * Data structure for color tables

+ */

+struct gl_color_table

+{

+   GLenum InternalFormat;      /**< The user-specified format */

+   GLenum _BaseFormat;         /**< GL_ALPHA, GL_RGBA, GL_RGB, etc */

+   GLuint Size;                /**< number of entries in table */

+   GLfloat *TableF;            /**< Color table, floating point values */

+   GLubyte *TableUB;           /**< Color table, ubyte values */

+   GLubyte RedSize;

+   GLubyte GreenSize;

+   GLubyte BlueSize;

+   GLubyte AlphaSize;

+   GLubyte LuminanceSize;

+   GLubyte IntensitySize;

+};

+

+

+/**

+ * \name Bit flags used for updating material values.

+ */

+/*@{*/

+#define MAT_ATTRIB_FRONT_AMBIENT           0 

+#define MAT_ATTRIB_BACK_AMBIENT            1

+#define MAT_ATTRIB_FRONT_DIFFUSE           2 

+#define MAT_ATTRIB_BACK_DIFFUSE            3

+#define MAT_ATTRIB_FRONT_SPECULAR          4 

+#define MAT_ATTRIB_BACK_SPECULAR           5

+#define MAT_ATTRIB_FRONT_EMISSION          6

+#define MAT_ATTRIB_BACK_EMISSION           7

+#define MAT_ATTRIB_FRONT_SHININESS         8

+#define MAT_ATTRIB_BACK_SHININESS          9

+#define MAT_ATTRIB_FRONT_INDEXES           10

+#define MAT_ATTRIB_BACK_INDEXES            11

+#define MAT_ATTRIB_MAX                     12

+

+#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))  

+#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))  

+#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 

+#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 

+#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))

+#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))  

+

+#define MAT_INDEX_AMBIENT  0

+#define MAT_INDEX_DIFFUSE  1

+#define MAT_INDEX_SPECULAR 2

+

+#define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)

+#define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)

+#define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)

+#define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)

+#define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)

+#define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)

+#define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)

+#define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)

+#define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)

+#define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)

+#define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)

+#define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)

+

+

+#define FRONT_MATERIAL_BITS	(MAT_BIT_FRONT_EMISSION | 	\

+				 MAT_BIT_FRONT_AMBIENT |	\

+				 MAT_BIT_FRONT_DIFFUSE | 	\

+				 MAT_BIT_FRONT_SPECULAR |	\

+				 MAT_BIT_FRONT_SHININESS | 	\

+				 MAT_BIT_FRONT_INDEXES)

+

+#define BACK_MATERIAL_BITS	(MAT_BIT_BACK_EMISSION |	\

+				 MAT_BIT_BACK_AMBIENT |		\

+				 MAT_BIT_BACK_DIFFUSE |		\

+				 MAT_BIT_BACK_SPECULAR |	\

+				 MAT_BIT_BACK_SHININESS |	\

+				 MAT_BIT_BACK_INDEXES)

+

+#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)

+/*@}*/

+

+

+#define EXP_TABLE_SIZE 512	/**< Specular exponent lookup table sizes */

+#define SHINE_TABLE_SIZE 256	/**< Material shininess lookup table sizes */

+

+/**

+ * Material shininess lookup table.

+ */

+struct gl_shine_tab

+{

+   struct gl_shine_tab *next, *prev;

+   GLfloat tab[SHINE_TABLE_SIZE+1];

+   GLfloat shininess;

+   GLuint refcount;

+};

+

+

+/**

+ * Light source state.

+ */

+struct gl_light

+{

+   struct gl_light *next;	/**< double linked list with sentinel */

+   struct gl_light *prev;

+

+   GLfloat Ambient[4];		/**< ambient color */

+   GLfloat Diffuse[4];		/**< diffuse color */

+   GLfloat Specular[4];		/**< specular color */

+   GLfloat EyePosition[4];	/**< position in eye coordinates */

+   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */

+   GLfloat SpotExponent;

+   GLfloat SpotCutoff;		/**< in degrees */

+   GLfloat _CosCutoffNeg;	/**< = cos(SpotCutoff) */

+   GLfloat _CosCutoff;		/**< = MAX(0, cos(SpotCutoff)) */

+   GLfloat ConstantAttenuation;

+   GLfloat LinearAttenuation;

+   GLfloat QuadraticAttenuation;

+   GLboolean Enabled;		/**< On/off flag */

+

+   /** 

+    * \name Derived fields

+    */

+   /*@{*/

+   GLbitfield _Flags;		/**< State */

+

+   GLfloat _Position[4];	/**< position in eye/obj coordinates */

+   GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */

+   GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */

+   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */

+   GLfloat _VP_inf_spot_attenuation;

+

+   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */

+   GLfloat _MatAmbient[2][3];	/**< material ambient * light ambient */

+   GLfloat _MatDiffuse[2][3];	/**< material diffuse * light diffuse */

+   GLfloat _MatSpecular[2][3];	/**< material spec * light specular */

+   GLfloat _dli;		/**< CI diffuse light intensity */

+   GLfloat _sli;		/**< CI specular light intensity */

+   /*@}*/

+};

+

+

+/**

+ * Light model state.

+ */

+struct gl_lightmodel

+{

+   GLfloat Ambient[4];		/**< ambient color */

+   GLboolean LocalViewer;	/**< Local (or infinite) view point? */

+   GLboolean TwoSide;		/**< Two (or one) sided lighting? */

+   GLenum ColorControl;		/**< either GL_SINGLE_COLOR

+				 *    or GL_SEPARATE_SPECULAR_COLOR */

+};

+

+

+/**

+ * Material state.

+ */

+struct gl_material

+{

+   GLfloat Attrib[MAT_ATTRIB_MAX][4];

+};

+

+

+/**

+ * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)

+ */

+struct gl_accum_attrib

+{

+   GLfloat ClearColor[4];	/**< Accumulation buffer clear color */

+};

+

+

+/**

+ * Color buffer attribute group (GL_COLOR_BUFFER_BIT).

+ */

+struct gl_colorbuffer_attrib

+{

+   GLuint ClearIndex;			/**< Index to use for glClear */

+   GLclampf ClearColor[4];		/**< Color to use for glClear */

+

+   GLuint IndexMask;			/**< Color index write mask */

+   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */

+

+   GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */

+

+   /** 

+    * \name alpha testing

+    */

+   /*@{*/

+   GLboolean AlphaEnabled;		/**< Alpha test enabled flag */

+   GLenum AlphaFunc;			/**< Alpha test function */

+   GLclampf AlphaRef;			/**< Alpha reference value */

+   /*@}*/

+

+   /** 

+    * \name Blending

+    */

+   /*@{*/

+   GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */

+   GLfloat BlendColor[4];		/**< Blending color */

+   struct

+   {

+      GLenum SrcRGB;             /**< RGB blend source term */

+      GLenum DstRGB;             /**< RGB blend dest term */

+      GLenum SrcA;               /**< Alpha blend source term */

+      GLenum DstA;               /**< Alpha blend dest term */

+      GLenum EquationRGB;        /**< GL_ADD, GL_SUBTRACT, etc. */

+      GLenum EquationA;          /**< GL_ADD, GL_SUBTRACT, etc. */

+   } Blend[MAX_DRAW_BUFFERS];

+   /** Are the blend func terms currently different for each buffer/target? */

+   GLboolean _BlendFuncPerBuffer;

+   /** Are the blend equations currently different for each buffer/target? */

+   GLboolean _BlendEquationPerBuffer;

+   /*@}*/

+

+   /** 

+    * \name Logic op

+    */

+   /*@{*/

+   GLenum LogicOp;			/**< Logic operator */

+   GLboolean IndexLogicOpEnabled;	/**< Color index logic op enabled flag */

+   GLboolean ColorLogicOpEnabled;	/**< RGBA logic op enabled flag */

+   GLboolean _LogicOpEnabled;		/**< RGBA logic op + EXT_blend_logic_op enabled flag */

+   /*@}*/

+

+   GLboolean DitherFlag;		/**< Dither enable flag */

+

+   GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

+   GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

+

+   GLboolean sRGBEnabled;	/**< Framebuffer sRGB blending/updating requested */

+};

+

+

+/**

+ * Current attribute group (GL_CURRENT_BIT).

+ */

+struct gl_current_attrib

+{

+   /**

+    * \name Current vertex attributes.

+    * \note Values are valid only after FLUSH_VERTICES has been called.

+    * \note Index and Edgeflag current values are stored as floats in the 

+    * SIX and SEVEN attribute slots.

+    */

+   GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */

+

+   /**

+    * \name Current raster position attributes (always valid).

+    * \note This set of attributes is very similar to the SWvertex struct.

+    */

+   /*@{*/

+   GLfloat RasterPos[4];

+   GLfloat RasterDistance;

+   GLfloat RasterColor[4];

+   GLfloat RasterSecondaryColor[4];

+   GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];

+   GLboolean RasterPosValid;

+   /*@}*/

+};

+

+

+/**

+ * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).

+ */

+struct gl_depthbuffer_attrib

+{

+   GLenum Func;			/**< Function for depth buffer compare */

+   GLclampd Clear;		/**< Value to clear depth buffer to */

+   GLboolean Test;		/**< Depth buffering enabled flag */

+   GLboolean Mask;		/**< Depth buffer writable? */

+   GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */

+   GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */

+};

+

+

+/**

+ * Evaluator attribute group (GL_EVAL_BIT).

+ */

+struct gl_eval_attrib

+{

+   /**

+    * \name Enable bits 

+    */

+   /*@{*/

+   GLboolean Map1Color4;

+   GLboolean Map1Index;

+   GLboolean Map1Normal;

+   GLboolean Map1TextureCoord1;

+   GLboolean Map1TextureCoord2;

+   GLboolean Map1TextureCoord3;

+   GLboolean Map1TextureCoord4;

+   GLboolean Map1Vertex3;

+   GLboolean Map1Vertex4;

+   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */

+   GLboolean Map2Color4;

+   GLboolean Map2Index;

+   GLboolean Map2Normal;

+   GLboolean Map2TextureCoord1;

+   GLboolean Map2TextureCoord2;

+   GLboolean Map2TextureCoord3;

+   GLboolean Map2TextureCoord4;

+   GLboolean Map2Vertex3;

+   GLboolean Map2Vertex4;

+   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */

+   GLboolean AutoNormal;

+   /*@}*/

+   

+   /**

+    * \name Map Grid endpoints and divisions and calculated du values

+    */

+   /*@{*/

+   GLint MapGrid1un;

+   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;

+   GLint MapGrid2un, MapGrid2vn;

+   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;

+   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;

+   /*@}*/

+};

+

+

+/**

+ * Fog attribute group (GL_FOG_BIT).

+ */

+struct gl_fog_attrib

+{

+   GLboolean Enabled;		/**< Fog enabled flag */

+   GLfloat Color[4];		/**< Fog color */

+   GLfloat Density;		/**< Density >= 0.0 */

+   GLfloat Start;		/**< Start distance in eye coords */

+   GLfloat End;			/**< End distance in eye coords */

+   GLfloat Index;		/**< Fog index */

+   GLenum Mode;			/**< Fog mode */

+   GLboolean ColorSumEnabled;

+   GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */

+   GLfloat _Scale;		/**< (End == Start) ? 1.0 : 1.0 / (End - Start) */

+};

+

+

+/**

+ * \brief Layout qualifiers for gl_FragDepth.

+ *

+ * Extension AMD_conservative_depth allows gl_FragDepth to be redeclared with

+ * a layout qualifier.

+ *

+ * \see enum ir_depth_layout

+ */

+enum gl_frag_depth_layout {

+    FRAG_DEPTH_LAYOUT_NONE, /**< No layout is specified. */

+    FRAG_DEPTH_LAYOUT_ANY,

+    FRAG_DEPTH_LAYOUT_GREATER,

+    FRAG_DEPTH_LAYOUT_LESS,

+    FRAG_DEPTH_LAYOUT_UNCHANGED

+};

+

+

+/** 

+ * Hint attribute group (GL_HINT_BIT).

+ * 

+ * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.

+ */

+struct gl_hint_attrib

+{

+   GLenum PerspectiveCorrection;

+   GLenum PointSmooth;

+   GLenum LineSmooth;

+   GLenum PolygonSmooth;

+   GLenum Fog;

+   GLenum ClipVolumeClipping;   /**< GL_EXT_clip_volume_hint */

+   GLenum TextureCompression;   /**< GL_ARB_texture_compression */

+   GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */

+   GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */

+};

+

+/**

+ * Light state flags.

+ */

+/*@{*/

+#define LIGHT_SPOT         0x1

+#define LIGHT_LOCAL_VIEWER 0x2

+#define LIGHT_POSITIONAL   0x4

+#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)

+/*@}*/

+

+

+/**

+ * Lighting attribute group (GL_LIGHT_BIT).

+ */

+struct gl_light_attrib

+{

+   struct gl_light Light[MAX_LIGHTS];	/**< Array of light sources */

+   struct gl_lightmodel Model;		/**< Lighting model */

+

+   /**

+    * Must flush FLUSH_VERTICES before referencing:

+    */

+   /*@{*/

+   struct gl_material Material; 	/**< Includes front & back values */

+   /*@}*/

+

+   GLboolean Enabled;			/**< Lighting enabled flag */

+   GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */

+   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */

+   GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */

+   GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */

+   GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */

+   GLboolean ColorMaterialEnabled;

+   GLenum ClampVertexColor;

+

+   struct gl_light EnabledList;         /**< List sentinel */

+

+   /** 

+    * Derived state for optimizations: 

+    */

+   /*@{*/

+   GLboolean _NeedEyeCoords;		

+   GLboolean _NeedVertices;		/**< Use fast shader? */

+   GLbitfield _Flags;		        /**< LIGHT_* flags, see above */

+   GLfloat _BaseColor[2][3];

+   /*@}*/

+};

+

+

+/**

+ * Line attribute group (GL_LINE_BIT).

+ */

+struct gl_line_attrib

+{

+   GLboolean SmoothFlag;	/**< GL_LINE_SMOOTH enabled? */

+   GLboolean StippleFlag;	/**< GL_LINE_STIPPLE enabled? */

+   GLushort StipplePattern;	/**< Stipple pattern */

+   GLint StippleFactor;		/**< Stipple repeat factor */

+   GLfloat Width;		/**< Line width */

+};

+

+

+/**

+ * Display list attribute group (GL_LIST_BIT).

+ */

+struct gl_list_attrib

+{

+   GLuint ListBase;

+};

+

+

+/**

+ * Multisample attribute group (GL_MULTISAMPLE_BIT).

+ */

+struct gl_multisample_attrib

+{

+   GLboolean Enabled;

+   GLboolean _Enabled;   /**< true if Enabled and multisample buffer */

+   GLboolean SampleAlphaToCoverage;

+   GLboolean SampleAlphaToOne;

+   GLboolean SampleCoverage;

+   GLfloat SampleCoverageValue;

+   GLboolean SampleCoverageInvert;

+};

+

+

+/**

+ * A pixelmap (see glPixelMap)

+ */

+struct gl_pixelmap

+{

+   GLint Size;

+   GLfloat Map[MAX_PIXEL_MAP_TABLE];

+   GLubyte Map8[MAX_PIXEL_MAP_TABLE];  /**< converted to 8-bit color */

+};

+

+

+/**

+ * Collection of all pixelmaps

+ */

+struct gl_pixelmaps

+{

+   struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */

+   struct gl_pixelmap GtoG;

+   struct gl_pixelmap BtoB;

+   struct gl_pixelmap AtoA;

+   struct gl_pixelmap ItoR;

+   struct gl_pixelmap ItoG;

+   struct gl_pixelmap ItoB;

+   struct gl_pixelmap ItoA;

+   struct gl_pixelmap ItoI;

+   struct gl_pixelmap StoS;

+};

+

+

+/**

+ * Pixel attribute group (GL_PIXEL_MODE_BIT).

+ */

+struct gl_pixel_attrib

+{

+   GLenum ReadBuffer;		/**< source buffer for glRead/CopyPixels() */

+

+   /*--- Begin Pixel Transfer State ---*/

+   /* Fields are in the order in which they're applied... */

+

+   /** Scale & Bias (index shift, offset) */

+   /*@{*/

+   GLfloat RedBias, RedScale;

+   GLfloat GreenBias, GreenScale;

+   GLfloat BlueBias, BlueScale;

+   GLfloat AlphaBias, AlphaScale;

+   GLfloat DepthBias, DepthScale;

+   GLint IndexShift, IndexOffset;

+   /*@}*/

+

+   /* Pixel Maps */

+   /* Note: actual pixel maps are not part of this attrib group */

+   GLboolean MapColorFlag;

+   GLboolean MapStencilFlag;

+

+   /*--- End Pixel Transfer State ---*/

+

+   /** glPixelZoom */

+   GLfloat ZoomX, ZoomY;

+};

+

+

+/**

+ * Point attribute group (GL_POINT_BIT).

+ */

+struct gl_point_attrib

+{

+   GLboolean SmoothFlag;	/**< True if GL_POINT_SMOOTH is enabled */

+   GLfloat Size;		/**< User-specified point size */

+   GLfloat Params[3];		/**< GL_EXT_point_parameters */

+   GLfloat MinSize, MaxSize;	/**< GL_EXT_point_parameters */

+   GLfloat Threshold;		/**< GL_EXT_point_parameters */

+   GLboolean _Attenuated;	/**< True if Params != [1, 0, 0] */

+   GLboolean PointSprite;	/**< GL_NV/ARB_point_sprite */

+   GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/

+   GLenum SpriteRMode;		/**< GL_NV_point_sprite (only!) */

+   GLenum SpriteOrigin;		/**< GL_ARB_point_sprite */

+};

+

+

+/**

+ * Polygon attribute group (GL_POLYGON_BIT).

+ */

+struct gl_polygon_attrib

+{

+   GLenum FrontFace;		/**< Either GL_CW or GL_CCW */

+   GLenum FrontMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

+   GLenum BackMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

+   GLboolean _FrontBit;		/**< 0=GL_CCW, 1=GL_CW */

+   GLboolean CullFlag;		/**< Culling on/off flag */

+   GLboolean SmoothFlag;	/**< True if GL_POLYGON_SMOOTH is enabled */

+   GLboolean StippleFlag;	/**< True if GL_POLYGON_STIPPLE is enabled */

+   GLenum CullFaceMode;		/**< Culling mode GL_FRONT or GL_BACK */

+   GLfloat OffsetFactor;	/**< Polygon offset factor, from user */

+   GLfloat OffsetUnits;		/**< Polygon offset units, from user */

+   GLboolean OffsetPoint;	/**< Offset in GL_POINT mode */

+   GLboolean OffsetLine;	/**< Offset in GL_LINE mode */

+   GLboolean OffsetFill;	/**< Offset in GL_FILL mode */

+};

+

+

+/**

+ * Scissor attributes (GL_SCISSOR_BIT).

+ */

+struct gl_scissor_attrib

+{

+   GLboolean Enabled;		/**< Scissor test enabled? */

+   GLint X, Y;			/**< Lower left corner of box */

+   GLsizei Width, Height;	/**< Size of box */

+};

+

+

+/**

+ * Stencil attribute group (GL_STENCIL_BUFFER_BIT).

+ *

+ * Three sets of stencil data are tracked so that OpenGL 2.0,

+ * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported

+ * simultaneously.  In each of the stencil state arrays, element 0 corresponds

+ * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /

+ * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the

+ * GL_EXT_stencil_two_side GL_BACK state.

+ *

+ * The derived value \c _BackFace is either 1 or 2 depending on whether or

+ * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.

+ *

+ * The derived value \c _TestTwoSide is set when the front-face and back-face

+ * stencil state are different.

+ */

+struct gl_stencil_attrib

+{

+   GLboolean Enabled;		/**< Enabled flag */

+   GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */

+   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */

+   GLboolean _Enabled;          /**< Enabled and stencil buffer present */

+   GLboolean _TestTwoSide;

+   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */

+   GLenum Function[3];		/**< Stencil function */

+   GLenum FailFunc[3];		/**< Fail function */

+   GLenum ZPassFunc[3];		/**< Depth buffer pass function */

+   GLenum ZFailFunc[3];		/**< Depth buffer fail function */

+   GLint Ref[3];		/**< Reference value */

+   GLuint ValueMask[3];		/**< Value mask */

+   GLuint WriteMask[3];		/**< Write mask */

+   GLuint Clear;		/**< Clear value */

+};

+

+

+/**

+ * An index for each type of texture object.  These correspond to the GL

+ * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.

+ * Note: the order is from highest priority to lowest priority.

+ */

+typedef enum

+{

+   TEXTURE_2D_ARRAY_INDEX,

+   TEXTURE_1D_ARRAY_INDEX,

+   TEXTURE_CUBE_INDEX,

+   TEXTURE_3D_INDEX,

+   TEXTURE_RECT_INDEX,

+   TEXTURE_2D_INDEX,

+   TEXTURE_1D_INDEX,

+   NUM_TEXTURE_TARGETS

+} gl_texture_index;

+

+

+/**

+ * Bit flags for each type of texture object

+ * Used for Texture.Unit[]._ReallyEnabled flags.

+ */

+/*@{*/

+#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)

+#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)

+#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)

+#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)

+#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)

+#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)

+#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)

+/*@}*/

+

+

+/**

+ * TexGenEnabled flags.

+ */

+/*@{*/

+#define S_BIT 1

+#define T_BIT 2

+#define R_BIT 4

+#define Q_BIT 8

+#define STR_BITS (S_BIT | T_BIT | R_BIT)

+/*@}*/

+

+

+/**

+ * Bit flag versions of the corresponding GL_ constants.

+ */

+/*@{*/

+#define TEXGEN_SPHERE_MAP        0x1

+#define TEXGEN_OBJ_LINEAR        0x2

+#define TEXGEN_EYE_LINEAR        0x4

+#define TEXGEN_REFLECTION_MAP_NV 0x8

+#define TEXGEN_NORMAL_MAP_NV     0x10

+

+#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \

+				  TEXGEN_REFLECTION_MAP_NV | \

+				  TEXGEN_NORMAL_MAP_NV)

+#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \

+				  TEXGEN_REFLECTION_MAP_NV | \

+				  TEXGEN_NORMAL_MAP_NV     | \

+				  TEXGEN_EYE_LINEAR)

+/*@}*/

+

+

+

+/** Tex-gen enabled for texture unit? */

+#define ENABLE_TEXGEN(unit) (1 << (unit))

+

+/** Non-identity texture matrix for texture unit? */

+#define ENABLE_TEXMAT(unit) (1 << (unit))

+

+

+/**

+ * Texel fetch function prototype.  We use texel fetch functions to

+ * extract RGBA, color indexes and depth components out of 1D, 2D and 3D

+ * texture images.  These functions help to isolate us from the gritty

+ * details of all the various texture image encodings.

+ * 

+ * \param texImage texture image.

+ * \param col texel column.

+ * \param row texel row.

+ * \param img texel image level/layer.

+ * \param texelOut output texel (up to 4 GLchans)

+ */

+typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,

+                                 GLint col, GLint row, GLint img,

+                                 GLchan *texelOut );

+

+/**

+ * As above, but returns floats.

+ * Used for depth component images and for upcoming signed/float

+ * texture images.

+ */

+typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,

+                                 GLint col, GLint row, GLint img,

+                                 GLfloat *texelOut );

+

+

+typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,

+                               GLint col, GLint row, GLint img,

+                               const void *texel);

+

+

+/**

+ * Texture image state.  Describes the dimensions of a texture image,

+ * the texel format and pointers to Texel Fetch functions.

+ */

+struct gl_texture_image

+{

+   GLint InternalFormat;	/**< Internal format as given by the user */

+   GLenum _BaseFormat;		/**< Either GL_RGB, GL_RGBA, GL_ALPHA,

+				 *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,

+				 *   GL_INTENSITY, GL_COLOR_INDEX,

+				 *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT

+                                 *   only. Used for choosing TexEnv arithmetic.

+				 */

+   gl_format TexFormat;         /**< The actual texture memory format */

+

+   GLuint Border;		/**< 0 or 1 */

+   GLuint Width;		/**< = 2^WidthLog2 + 2*Border */

+   GLuint Height;		/**< = 2^HeightLog2 + 2*Border */

+   GLuint Depth;		/**< = 2^DepthLog2 + 2*Border */

+   GLuint Width2;		/**< = Width - 2*Border */

+   GLuint Height2;		/**< = Height - 2*Border */

+   GLuint Depth2;		/**< = Depth - 2*Border */

+   GLuint WidthLog2;		/**< = log2(Width2) */

+   GLuint HeightLog2;		/**< = log2(Height2) */

+   GLuint DepthLog2;		/**< = log2(Depth2) */

+   GLuint MaxLog2;		/**< = MAX(WidthLog2, HeightLog2) */

+   GLfloat WidthScale;		/**< used for mipmap LOD computation */

+   GLfloat HeightScale;		/**< used for mipmap LOD computation */

+   GLfloat DepthScale;		/**< used for mipmap LOD computation */

+   GLboolean IsClientData;	/**< Data owned by client? */

+   GLboolean _IsPowerOfTwo;	/**< Are all dimensions powers of two? */

+

+   struct gl_texture_object *TexObject;  /**< Pointer back to parent object */

+

+   FetchTexelFuncC FetchTexelc;	/**< GLchan texel fetch function pointer */

+   FetchTexelFuncF FetchTexelf;	/**< Float texel fetch function pointer */

+

+   GLuint RowStride;		/**< Padded width in units of texels */

+   GLuint *ImageOffsets;        /**< if 3D texture: array [Depth] of offsets to

+                                     each 2D slice in 'Data', in texels */

+   GLvoid *Data;		/**< Image data, accessed via FetchTexel() */

+

+   /**

+    * \name For device driver:

+    */

+   /*@{*/

+   void *DriverData;		/**< Arbitrary device driver data */

+   /*@}*/

+};

+

+

+/**

+ * Indexes for cube map faces.

+ */

+typedef enum

+{

+   FACE_POS_X = 0,

+   FACE_NEG_X = 1,

+   FACE_POS_Y = 2,

+   FACE_NEG_Y = 3,

+   FACE_POS_Z = 4,

+   FACE_NEG_Z = 5,

+   MAX_FACES = 6

+} gl_face_index;

+

+

+/**

+ * Texture object state.  Contains the array of mipmap images, border color,

+ * wrap modes, filter modes, shadow/texcompare state, and the per-texture

+ * color palette.

+ */

+struct gl_texture_object

+{

+   _glthread_Mutex Mutex;	/**< for thread safety */

+   GLint RefCount;		/**< reference count */

+   GLuint Name;			/**< the user-visible texture object ID */

+   GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */

+   GLfloat Priority;		/**< in [0,1] */

+   union {

+      GLfloat f[4];

+      GLuint ui[4];

+      GLint i[4];

+   } BorderColor;               /**< Interpreted according to texture format */

+   GLenum WrapS;		/**< S-axis texture image wrap mode */

+   GLenum WrapT;		/**< T-axis texture image wrap mode */

+   GLenum WrapR;		/**< R-axis texture image wrap mode */

+   GLenum MinFilter;		/**< minification filter */

+   GLenum MagFilter;		/**< magnification filter */

+   GLfloat MinLod;		/**< min lambda, OpenGL 1.2 */

+   GLfloat MaxLod;		/**< max lambda, OpenGL 1.2 */

+   GLfloat LodBias;		/**< OpenGL 1.4 */

+   GLint BaseLevel;		/**< min mipmap level, OpenGL 1.2 */

+   GLint MaxLevel;		/**< max mipmap level, OpenGL 1.2 */

+   GLfloat MaxAnisotropy;	/**< GL_EXT_texture_filter_anisotropic */

+   GLenum CompareMode;		/**< GL_ARB_shadow */

+   GLenum CompareFunc;		/**< GL_ARB_shadow */

+   GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */

+   GLenum DepthMode;		/**< GL_ARB_depth_texture */

+   GLint _MaxLevel;		/**< actual max mipmap level (q in the spec) */

+   GLfloat _MaxLambda;		/**< = _MaxLevel - BaseLevel (q - b in spec) */

+   GLint CropRect[4];           /**< GL_OES_draw_texture */

+   GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */

+   GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */

+   GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */

+   GLboolean _Complete;		/**< Is texture object complete? */

+   GLboolean _RenderToTexture;  /**< Any rendering to this texture? */

+   GLboolean Purgeable;         /**< Is the buffer purgeable under memory pressure? */

+   GLenum sRGBDecode;           /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */

+

+   /** Actual texture images, indexed by [cube face] and [mipmap level] */

+   struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];

+

+   /** GL_EXT_paletted_texture */

+   struct gl_color_table Palette;

+

+   /**

+    * \name For device driver.

+    * Note: instead of attaching driver data to this pointer, it's preferable

+    * to instead use this struct as a base class for your own texture object

+    * class.  Driver->NewTextureObject() can be used to implement the

+    * allocation.

+    */

+   void *DriverData;	/**< Arbitrary device driver data */

+};

+

+

+/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */

+#define MAX_COMBINER_TERMS 4

+

+

+/**

+ * Texture combine environment state.

+ */

+struct gl_tex_env_combine_state

+{

+   GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */

+   GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */

+   /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */

+   GLenum SourceRGB[MAX_COMBINER_TERMS];

+   GLenum SourceA[MAX_COMBINER_TERMS];

+   /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */

+   GLenum OperandRGB[MAX_COMBINER_TERMS];

+   GLenum OperandA[MAX_COMBINER_TERMS];

+   GLuint ScaleShiftRGB; /**< 0, 1 or 2 */

+   GLuint ScaleShiftA;   /**< 0, 1 or 2 */

+   GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */

+   GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */

+};

+

+

+/**

+ * Texture coord generation state.

+ */

+struct gl_texgen

+{

+   GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */

+   GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */

+   GLfloat ObjectPlane[4];

+   GLfloat EyePlane[4];

+};

+

+

+/**

+ * Texture unit state.  Contains enable flags, texture environment/function/

+ * combiners, texgen state, pointers to current texture objects and

+ * post-filter color tables.

+ */

+struct gl_texture_unit

+{

+   GLbitfield Enabled;          /**< bitmask of TEXTURE_*_BIT flags */

+   GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */

+

+   GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */

+   GLfloat EnvColor[4];

+

+   struct gl_texgen GenS;

+   struct gl_texgen GenT;

+   struct gl_texgen GenR;

+   struct gl_texgen GenQ;

+   GLbitfield TexGenEnabled;	/**< Bitwise-OR of [STRQ]_BIT values */

+   GLbitfield _GenFlags;	/**< Bitwise-OR of Gen[STRQ]._ModeBit */

+

+   GLfloat LodBias;		/**< for biasing mipmap levels */

+   GLenum BumpTarget;

+   GLfloat RotMatrix[4]; /* 2x2 matrix */

+

+   /** 

+    * \name GL_EXT_texture_env_combine 

+    */

+   struct gl_tex_env_combine_state Combine;

+

+   /**

+    * Derived state based on \c EnvMode and the \c BaseFormat of the

+    * currently enabled texture.

+    */

+   struct gl_tex_env_combine_state _EnvMode;

+

+   /**

+    * Currently enabled combiner state.  This will point to either

+    * \c Combine or \c _EnvMode.

+    */

+   struct gl_tex_env_combine_state *_CurrentCombine;

+

+   /** Current texture object pointers */

+   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];

+

+   /** Points to highest priority, complete and enabled texture object */

+   struct gl_texture_object *_Current;

+};

+

+

+/**

+ * Texture attribute group (GL_TEXTURE_BIT).

+ */

+struct gl_texture_attrib

+{

+   GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */

+   struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];

+

+   struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];

+

+   /** GL_ARB_seamless_cubemap */

+   GLboolean CubeMapSeamless;

+

+   /** GL_EXT_shared_texture_palette */

+   GLboolean SharedPalette;

+   struct gl_color_table Palette;

+

+   /** Texture units/samplers used by vertex or fragment texturing */

+   GLbitfield _EnabledUnits;

+

+   /** Texture coord units/sets used for fragment texturing */

+   GLbitfield _EnabledCoordUnits;

+

+   /** Texture coord units that have texgen enabled */

+   GLbitfield _TexGenEnabled;

+

+   /** Texture coord units that have non-identity matrices */

+   GLbitfield _TexMatEnabled;

+

+   /** Bitwise-OR of all Texture.Unit[i]._GenFlags */

+   GLbitfield _GenFlags;

+};

+

+

+/**

+ * Transformation attribute group (GL_TRANSFORM_BIT).

+ */

+struct gl_transform_attrib

+{

+   GLenum MatrixMode;				/**< Matrix mode */

+   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];	/**< User clip planes */

+   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];	/**< derived */

+   GLbitfield ClipPlanesEnabled;                /**< on/off bitmask */

+   GLboolean Normalize;				/**< Normalize all normals? */

+   GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */

+   GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */

+   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */

+

+   GLfloat CullEyePos[4];

+   GLfloat CullObjPos[4];

+};

+

+

+/**

+ * Viewport attribute group (GL_VIEWPORT_BIT).

+ */

+struct gl_viewport_attrib

+{

+   GLint X, Y;			/**< position */

+   GLsizei Width, Height;	/**< size */

+   GLfloat Near, Far;		/**< Depth buffer range */

+   GLmatrix _WindowMap;		/**< Mapping transformation as a matrix. */

+};

+

+

+/**

+ * GL_ARB_vertex/pixel_buffer_object buffer object

+ */

+struct gl_buffer_object

+{

+   _glthread_Mutex Mutex;

+   GLint RefCount;

+   GLuint Name;

+   GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */

+   GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */

+   GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */

+   /** Fields describing a mapped buffer */

+   /*@{*/

+   GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */

+   GLvoid *Pointer;     /**< User-space address of mapping */

+   GLintptr Offset;     /**< Mapped offset */

+   GLsizeiptr Length;   /**< Mapped length */

+   /*@}*/

+   GLboolean Written;   /**< Ever written to? (for debugging) */

+   GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */

+};

+

+

+/**

+ * Client pixel packing/unpacking attributes

+ */

+struct gl_pixelstore_attrib

+{

+   GLint Alignment;

+   GLint RowLength;

+   GLint SkipPixels;

+   GLint SkipRows;

+   GLint ImageHeight;

+   GLint SkipImages;

+   GLboolean SwapBytes;

+   GLboolean LsbFirst;

+   GLboolean ClientStorage; /**< GL_APPLE_client_storage */

+   GLboolean Invert;        /**< GL_MESA_pack_invert */

+   struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */

+};

+

+

+/**

+ * Client vertex array attributes

+ */

+struct gl_client_array

+{

+   GLint Size;                  /**< components per element (1,2,3,4) */

+   GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */

+   GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */

+   GLsizei Stride;		/**< user-specified stride */

+   GLsizei StrideB;		/**< actual stride in bytes */

+   const GLubyte *Ptr;          /**< Points to array data */

+   GLboolean Enabled;		/**< Enabled flag is a boolean */

+   GLboolean Normalized;        /**< GL_ARB_vertex_program */

+   GLboolean Integer;           /**< Integer-valued? */

+   GLuint InstanceDivisor;      /**< GL_ARB_instanced_arrays */

+   GLuint _ElementSize;         /**< size of each element in bytes */

+

+   struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */

+   GLuint _MaxElement;          /**< max element index into array buffer + 1 */

+};

+

+

+/**

+ * Collection of vertex arrays.  Defined by the GL_APPLE_vertex_array_object

+ * extension, but a nice encapsulation in any case.

+ */

+struct gl_array_object

+{

+   /** Name of the array object as received from glGenVertexArrayAPPLE. */

+   GLuint Name;

+

+   GLint RefCount;

+   _glthread_Mutex Mutex;

+   GLboolean VBOonly;  /**< require all arrays to live in VBOs? */

+

+   /** Conventional vertex arrays */

+   /*@{*/

+   struct gl_client_array Vertex;

+   struct gl_client_array Weight;

+   struct gl_client_array Normal;

+   struct gl_client_array Color;

+   struct gl_client_array SecondaryColor;

+   struct gl_client_array FogCoord;

+   struct gl_client_array Index;

+   struct gl_client_array EdgeFlag;

+   struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];

+   struct gl_client_array PointSize;

+   /*@}*/

+

+   /**

+    * Generic arrays for vertex programs/shaders.

+    * For NV vertex programs, these attributes alias and take priority

+    * over the conventional attribs above.  For ARB vertex programs and

+    * GLSL vertex shaders, these attributes are separate.

+    */

+   struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];

+

+   /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */

+   GLbitfield _Enabled;

+

+   /**

+    * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs

+    * we can determine the max legal (in bounds) glDrawElements array index.

+    */

+   GLuint _MaxElement;

+};

+

+

+/**

+ * Vertex array state

+ */

+struct gl_array_attrib

+{

+   /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */

+   struct gl_array_object *ArrayObj;

+

+   /** The default vertex array object */

+   struct gl_array_object *DefaultArrayObj;

+

+   /** Array objects (GL_ARB/APPLE_vertex_array_object) */

+   struct _mesa_HashTable *Objects;

+

+   GLint ActiveTexture;		/**< Client Active Texture */

+   GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */

+   GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */

+

+   /** GL 3.1 (slightly different from GL_NV_primitive_restart) */

+   GLboolean PrimitiveRestart;

+   GLuint RestartIndex;

+

+   GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */

+   GLboolean RebindArrays; /**< whether the VBO module should rebind arrays */

+

+   /* GL_ARB_vertex_buffer_object */

+   struct gl_buffer_object *ArrayBufferObj;

+   struct gl_buffer_object *ElementArrayBufferObj;

+};

+

+

+/**

+ * Feedback buffer state

+ */

+struct gl_feedback

+{

+   GLenum Type;

+   GLbitfield _Mask;    /**< FB_* bits */

+   GLfloat *Buffer;

+   GLuint BufferSize;

+   GLuint Count;

+};

+

+

+/**

+ * Selection buffer state

+ */

+struct gl_selection

+{

+   GLuint *Buffer;	/**< selection buffer */

+   GLuint BufferSize;	/**< size of the selection buffer */

+   GLuint BufferCount;	/**< number of values in the selection buffer */

+   GLuint Hits;		/**< number of records in the selection buffer */

+   GLuint NameStackDepth; /**< name stack depth */

+   GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */

+   GLboolean HitFlag;	/**< hit flag */

+   GLfloat HitMinZ;	/**< minimum hit depth */

+   GLfloat HitMaxZ;	/**< maximum hit depth */

+};

+

+

+/**

+ * 1-D Evaluator control points

+ */

+struct gl_1d_map

+{

+   GLuint Order;	/**< Number of control points */

+   GLfloat u1, u2, du;	/**< u1, u2, 1.0/(u2-u1) */

+   GLfloat *Points;	/**< Points to contiguous control points */

+};

+

+

+/**

+ * 2-D Evaluator control points

+ */

+struct gl_2d_map

+{

+   GLuint Uorder;		/**< Number of control points in U dimension */

+   GLuint Vorder;		/**< Number of control points in V dimension */

+   GLfloat u1, u2, du;

+   GLfloat v1, v2, dv;

+   GLfloat *Points;		/**< Points to contiguous control points */

+};

+

+

+/**

+ * All evaluator control point state

+ */

+struct gl_evaluators

+{

+   /** 

+    * \name 1-D maps

+    */

+   /*@{*/

+   struct gl_1d_map Map1Vertex3;

+   struct gl_1d_map Map1Vertex4;

+   struct gl_1d_map Map1Index;

+   struct gl_1d_map Map1Color4;

+   struct gl_1d_map Map1Normal;

+   struct gl_1d_map Map1Texture1;

+   struct gl_1d_map Map1Texture2;

+   struct gl_1d_map Map1Texture3;

+   struct gl_1d_map Map1Texture4;

+   struct gl_1d_map Map1Attrib[16];  /**< GL_NV_vertex_program */

+   /*@}*/

+

+   /** 

+    * \name 2-D maps 

+    */

+   /*@{*/

+   struct gl_2d_map Map2Vertex3;

+   struct gl_2d_map Map2Vertex4;

+   struct gl_2d_map Map2Index;

+   struct gl_2d_map Map2Color4;

+   struct gl_2d_map Map2Normal;

+   struct gl_2d_map Map2Texture1;

+   struct gl_2d_map Map2Texture2;

+   struct gl_2d_map Map2Texture3;

+   struct gl_2d_map Map2Texture4;

+   struct gl_2d_map Map2Attrib[16];  /**< GL_NV_vertex_program */

+   /*@}*/

+};

+

+

+/**

+ * Names of the various vertex/fragment program register files, etc.

+ *

+ * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)

+ * All values should fit in a 4-bit field.

+ *

+ * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM,

+ * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to

+ * be "uniform" variables since they can only be set outside glBegin/End.

+ * They're also all stored in the same Parameters array.

+ */

+typedef enum

+{

+   PROGRAM_TEMPORARY,   /**< machine->Temporary[] */

+   PROGRAM_INPUT,       /**< machine->Inputs[] */

+   PROGRAM_OUTPUT,      /**< machine->Outputs[] */

+   PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */

+   PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */

+   PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */

+   PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */

+   PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */

+   PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */

+   PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */

+   PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */

+   PROGRAM_ADDRESS,     /**< machine->AddressReg */

+   PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */

+   PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */

+   PROGRAM_UNDEFINED,   /**< Invalid/TBD value */

+   PROGRAM_FILE_MAX

+} gl_register_file;

+

+

+/**

+ * If the register file is PROGRAM_SYSTEM_VALUE, the register index will be

+ * one of these values.

+ */

+typedef enum

+{

+   SYSTEM_VALUE_FRONT_FACE,  /**< Fragment shader only (not done yet) */

+   SYSTEM_VALUE_INSTANCE_ID, /**< Vertex shader only */

+   SYSTEM_VALUE_MAX          /**< Number of values */

+} gl_system_value;

+

+

+/** Vertex and fragment instructions */

+struct prog_instruction;

+struct gl_program_parameter_list;

+struct gl_uniform_list;

+

+

+/**

+ * Base class for any kind of program object

+ */

+struct gl_program

+{

+   GLuint Id;

+   GLubyte *String;  /**< Null-terminated program text */

+   GLint RefCount;

+   GLenum Target;    /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */

+   GLenum Format;    /**< String encoding format */

+   GLboolean Resident;

+

+   struct prog_instruction *Instructions;

+

+   GLbitfield InputsRead;     /**< Bitmask of which input regs are read */

+   GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */

+   GLbitfield SystemValuesRead;   /**< Bitmask of SYSTEM_VALUE_x inputs used */

+   GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   /**< PROG_PARAM_BIT_x flags */

+   GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */

+   GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  /**< TEXTURE_x_BIT bitmask */

+   GLbitfield SamplersUsed;   /**< Bitfield of which samplers are used */

+   GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */

+

+

+   /** Named parameters, constants, etc. from program text */

+   struct gl_program_parameter_list *Parameters;

+   /** Numbered local parameters */

+   GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];

+

+   /** Vertex/fragment shader varying vars */

+   struct gl_program_parameter_list *Varying;

+   /** Vertex program user-defined attributes */

+   struct gl_program_parameter_list *Attributes;

+

+   /** Map from sampler unit to texture unit (set by glUniform1i()) */

+   GLubyte SamplerUnits[MAX_SAMPLERS];

+   /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */

+   gl_texture_index SamplerTargets[MAX_SAMPLERS];

+

+   /** Bitmask of which register files are read/written with indirect

+    * addressing.  Mask of (1 << PROGRAM_x) bits.

+    */

+   GLbitfield IndirectRegisterFiles;

+

+   /** Logical counts */

+   /*@{*/

+   GLuint NumInstructions;

+   GLuint NumTemporaries;

+   GLuint NumParameters;

+   GLuint NumAttributes;

+   GLuint NumAddressRegs;

+   GLuint NumAluInstructions;

+   GLuint NumTexInstructions;

+   GLuint NumTexIndirections;

+   /*@}*/

+   /** Native, actual h/w counts */

+   /*@{*/

+   GLuint NumNativeInstructions;

+   GLuint NumNativeTemporaries;

+   GLuint NumNativeParameters;

+   GLuint NumNativeAttributes;

+   GLuint NumNativeAddressRegs;

+   GLuint NumNativeAluInstructions;

+   GLuint NumNativeTexInstructions;

+   GLuint NumNativeTexIndirections;

+   /*@}*/

+};

+

+

+/** Vertex program object */

+struct gl_vertex_program

+{

+   struct gl_program Base;   /**< base class */

+   GLboolean IsNVProgram;    /**< is this a GL_NV_vertex_program program? */

+   GLboolean IsPositionInvariant;

+};

+

+

+/** Geometry program object */

+struct gl_geometry_program

+{

+   struct gl_program Base;   /**< base class */

+

+   GLint VerticesOut;

+   GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,

+                           GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */

+   GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */

+};

+

+

+/** Fragment program object */

+struct gl_fragment_program

+{

+   struct gl_program Base;   /**< base class */

+   GLenum FogOption;

+   GLboolean UsesKill;          /**< shader uses KIL instruction */

+   GLboolean OriginUpperLeft;

+   GLboolean PixelCenterInteger;

+   enum gl_frag_depth_layout FragDepthLayout;

+};

+

+

+/**

+ * State common to vertex and fragment programs.

+ */

+struct gl_program_state

+{

+   GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */

+   const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */

+};

+

+

+/**

+ * Context state for vertex programs.

+ */

+struct gl_vertex_program_state

+{

+   GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */

+   GLboolean _Enabled;           /**< Enabled and _valid_ user program? */

+   GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */

+   GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */

+   struct gl_vertex_program *Current;  /**< User-bound vertex program */

+

+   /** Currently enabled and valid vertex program (including internal

+    * programs, user-defined vertex programs and GLSL vertex shaders).

+    * This is the program we must use when rendering.

+    */

+   struct gl_vertex_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /* For GL_NV_vertex_program only: */

+   GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];

+   GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];

+

+   /** Should fixed-function T&L be implemented with a vertex prog? */

+   GLboolean _MaintainTnlProgram;

+

+   /** Program to emulate fixed-function T&L (see above) */

+   struct gl_vertex_program *_TnlProgram;

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+

+   GLboolean _Overriden;

+};

+

+

+/**

+ * Context state for geometry programs.

+ */

+struct gl_geometry_program_state

+{

+   GLboolean Enabled;               /**< GL_ARB_GEOMETRY_SHADER4 */

+   GLboolean _Enabled;              /**< Enabled and valid program? */

+   struct gl_geometry_program *Current;  /**< user-bound geometry program */

+

+   /** Currently enabled and valid program (including internal programs

+    * and compiled shader programs).

+    */

+   struct gl_geometry_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+};

+

+/**

+ * Context state for fragment programs.

+ */

+struct gl_fragment_program_state

+{

+   GLboolean Enabled;     /**< User-set fragment program enable flag */

+   GLboolean _Enabled;    /**< Enabled and _valid_ user program? */

+   struct gl_fragment_program *Current;  /**< User-bound fragment program */

+

+   /** Currently enabled and valid fragment program (including internal

+    * programs, user-defined fragment programs and GLSL fragment shaders).

+    * This is the program we must use when rendering.

+    */

+   struct gl_fragment_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /** Should fixed-function texturing be implemented with a fragment prog? */

+   GLboolean _MaintainTexEnvProgram;

+

+   /** Program to emulate fixed-function texture env/combine (see above) */

+   struct gl_fragment_program *_TexEnvProgram;

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+};

+

+

+/**

+ * ATI_fragment_shader runtime state

+ */

+#define ATI_FS_INPUT_PRIMARY 0

+#define ATI_FS_INPUT_SECONDARY 1

+

+struct atifs_instruction;

+struct atifs_setupinst;

+

+/**

+ * ATI fragment shader

+ */

+struct ati_fragment_shader

+{

+   GLuint Id;

+   GLint RefCount;

+   struct atifs_instruction *Instructions[2];

+   struct atifs_setupinst *SetupInst[2];

+   GLfloat Constants[8][4];

+   GLbitfield LocalConstDef;  /**< Indicates which constants have been set */

+   GLubyte numArithInstr[2];

+   GLubyte regsAssigned[2];

+   GLubyte NumPasses;         /**< 1 or 2 */

+   GLubyte cur_pass;

+   GLubyte last_optype;

+   GLboolean interpinp1;

+   GLboolean isValid;

+   GLuint swizzlerq;

+};

+

+/**

+ * Context state for GL_ATI_fragment_shader

+ */

+struct gl_ati_fragment_shader_state

+{

+   GLboolean Enabled;

+   GLboolean _Enabled;                  /**< enabled and valid shader? */

+   GLboolean Compiling;

+   GLfloat GlobalConstants[8][4];

+   struct ati_fragment_shader *Current;

+};

+

+

+/**

+ * Occlusion/timer query object.

+ */

+struct gl_query_object

+{

+   GLenum Target;      /**< The query target, when active */

+   GLuint Id;          /**< hash table ID/name */

+   GLuint64EXT Result; /**< the counter */

+   GLboolean Active;   /**< inside Begin/EndQuery */

+   GLboolean Ready;    /**< result is ready? */

+};

+

+

+/**

+ * Context state for query objects.

+ */

+struct gl_query_state

+{

+   struct _mesa_HashTable *QueryObjects;

+   struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */

+   struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */

+

+   /** GL_NV_conditional_render */

+   struct gl_query_object *CondRenderQuery;

+

+   /** GL_EXT_transform_feedback */

+   struct gl_query_object *PrimitivesGenerated;

+   struct gl_query_object *PrimitivesWritten;

+

+   /** GL_ARB_timer_query */

+   struct gl_query_object *TimeElapsed;

+

+   GLenum CondRenderMode;

+};

+

+

+/** Sync object state */

+struct gl_sync_object {

+   struct simple_node link;

+   GLenum Type;               /**< GL_SYNC_FENCE */

+   GLuint Name;               /**< Fence name */

+   GLint RefCount;            /**< Reference count */

+   GLboolean DeletePending;   /**< Object was deleted while there were still

+			       * live references (e.g., sync not yet finished)

+			       */

+   GLenum SyncCondition;

+   GLbitfield Flags;          /**< Flags passed to glFenceSync */

+   GLuint StatusFlag:1;       /**< Has the sync object been signaled? */

+};

+

+

+/** Set by #pragma directives */

+struct gl_sl_pragmas

+{

+   GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */

+   GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */

+   GLboolean Optimize;  /**< defaults on */

+   GLboolean Debug;     /**< defaults off */

+};

+

+

+/**

+ * A GLSL vertex or fragment shader object.

+ */

+struct gl_shader

+{

+   GLenum Type;  /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */

+   GLuint Name;  /**< AKA the handle */

+   GLint RefCount;  /**< Reference count */

+   GLboolean DeletePending;

+   GLboolean CompileStatus;

+   const GLchar *Source;  /**< Source code string */

+   GLuint SourceChecksum;       /**< for debug/logging purposes */

+   struct gl_program *Program;  /**< Post-compile assembly code */

+   GLchar *InfoLog;

+   struct gl_sl_pragmas Pragmas;

+

+   unsigned Version;       /**< GLSL version used for linking */

+

+   struct exec_list *ir;

+   struct glsl_symbol_table *symbols;

+

+   /** Shaders containing built-in functions that are used for linking. */

+   struct gl_shader *builtins_to_link[16];

+   unsigned num_builtins_to_link;

+};

+

+

+/**

+ * A GLSL program object.

+ * Basically a linked collection of vertex and fragment shaders.

+ */

+struct gl_shader_program

+{

+   GLenum Type;  /**< Always GL_SHADER_PROGRAM (internal token) */

+   GLuint Name;  /**< aka handle or ID */

+   GLint RefCount;  /**< Reference count */

+   GLboolean DeletePending;

+

+   GLuint NumShaders;          /**< number of attached shaders */

+   struct gl_shader **Shaders; /**< List of attached the shaders */

+

+   /** User-defined attribute bindings (glBindAttribLocation) */

+   struct gl_program_parameter_list *Attributes;

+

+   /** Transform feedback varyings */

+   struct {

+      GLenum BufferMode;

+      GLuint NumVarying;

+      GLchar **VaryingNames;  /**< Array [NumVarying] of char * */

+   } TransformFeedback;

+

+   /** Geometry shader state - copied into gl_geometry_program at link time */

+   struct {

+      GLint VerticesOut;

+      GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,

+                              GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */

+      GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */

+   } Geom;

+

+   /* post-link info: */

+   struct gl_vertex_program *VertexProgram;     /**< Linked vertex program */

+   struct gl_fragment_program *FragmentProgram; /**< Linked fragment prog */

+   struct gl_geometry_program *GeometryProgram; /**< Linked geometry prog */

+   struct gl_uniform_list *Uniforms;

+   struct gl_program_parameter_list *Varying;

+   GLboolean LinkStatus;   /**< GL_LINK_STATUS */

+   GLboolean Validated;

+   GLboolean _Used;        /**< Ever used for drawing? */

+   GLchar *InfoLog;

+

+   unsigned Version;       /**< GLSL version used for linking */

+

+   /**

+    * Per-stage shaders resulting from the first stage of linking.

+    *

+    * Set of linked shaders for this program.  The array is accessed using the

+    * \c MESA_SHADER_* defines.  Entries for non-existent stages will be

+    * \c NULL.

+    */

+   struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES];

+};   

+

+

+#define GLSL_DUMP      0x1  /**< Dump shaders to stdout */

+#define GLSL_LOG       0x2  /**< Write shaders to files */

+#define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */

+#define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */

+#define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */

+#define GLSL_NOP_VERT 0x20  /**< Force no-op vertex shaders */

+#define GLSL_NOP_FRAG 0x40  /**< Force no-op fragment shaders */

+#define GLSL_USE_PROG 0x80  /**< Log glUseProgram calls */

+

+

+/**

+ * Context state for GLSL vertex/fragment shaders.

+ */

+struct gl_shader_state

+{

+   /**

+    * Programs used for rendering

+    *

+    * There is a separate program set for each shader stage.  If

+    * GL_EXT_separate_shader_objects is not supported, each of these must point

+    * to \c NULL or to the same program.

+    */

+   struct gl_shader_program *CurrentVertexProgram;

+   struct gl_shader_program *CurrentGeometryProgram;

+   struct gl_shader_program *CurrentFragmentProgram;

+

+   /**

+    * Program used by glUniform calls.

+    *

+    * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.

+    */

+   struct gl_shader_program *ActiveProgram;

+

+   void *MemPool;

+

+   GLbitfield Flags;                    /**< Mask of GLSL_x flags */

+};

+

+/**

+ * Compiler options for a single GLSL shaders type

+ */

+struct gl_shader_compiler_options

+{

+   /** Driver-selectable options: */

+   GLboolean EmitCondCodes;             /**< Use condition codes? */

+   GLboolean EmitNVTempInitialization;  /**< 0-fill NV temp registers */

+   /**

+    * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't

+    * support control flow.

+    */

+   GLboolean EmitNoIfs;

+   GLboolean EmitNoLoops;

+   GLboolean EmitNoFunctions;

+   GLboolean EmitNoCont;                  /**< Emit CONT opcode? */

+   GLboolean EmitNoMainReturn;            /**< Emit CONT/RET opcodes? */

+   GLboolean EmitNoNoise;                 /**< Emit NOISE opcodes? */

+   GLboolean EmitNoPow;                   /**< Emit POW opcodes? */

+

+   /**

+    * \name Forms of indirect addressing the driver cannot do.

+    */

+   /*@{*/

+   GLboolean EmitNoIndirectInput;   /**< No indirect addressing of inputs */

+   GLboolean EmitNoIndirectOutput;  /**< No indirect addressing of outputs */

+   GLboolean EmitNoIndirectTemp;    /**< No indirect addressing of temps */

+   GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */

+   /*@}*/

+

+   GLuint MaxUnrollIterations;

+

+   struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */

+};

+

+/**

+ * Transform feedback object state

+ */

+struct gl_transform_feedback_object

+{

+   GLuint Name;  /**< AKA the object ID */

+   GLint RefCount;

+   GLboolean Active;  /**< Is transform feedback enabled? */

+   GLboolean Paused;  /**< Is transform feedback paused? */

+

+   /** The feedback buffers */

+   GLuint BufferNames[MAX_FEEDBACK_ATTRIBS];

+   struct gl_buffer_object *Buffers[MAX_FEEDBACK_ATTRIBS];

+

+   /** Start of feedback data in dest buffer */

+   GLintptr Offset[MAX_FEEDBACK_ATTRIBS];

+   /** Max data to put into dest buffer (in bytes) */

+   GLsizeiptr Size[MAX_FEEDBACK_ATTRIBS];

+};

+

+

+/**

+ * Context state for transform feedback.

+ */

+struct gl_transform_feedback

+{

+   GLenum Mode;       /**< GL_POINTS, GL_LINES or GL_TRIANGLES */

+

+   GLboolean RasterDiscard;  /**< GL_RASTERIZER_DISCARD */

+

+   /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */

+   struct gl_buffer_object *CurrentBuffer;

+

+   /** The table of all transform feedback objects */

+   struct _mesa_HashTable *Objects;

+

+   /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */

+   struct gl_transform_feedback_object *CurrentObject;

+

+   /** The default xform-fb object (Name==0) */

+   struct gl_transform_feedback_object *DefaultObject;

+};

+

+

+

+/**

+ * State which can be shared by multiple contexts:

+ */

+struct gl_shared_state

+{

+   _glthread_Mutex Mutex;		   /**< for thread safety */

+   GLint RefCount;			   /**< Reference count */

+   struct _mesa_HashTable *DisplayList;	   /**< Display lists hash table */

+   struct _mesa_HashTable *TexObjects;	   /**< Texture objects hash table */

+

+   /** Default texture objects (shared by all texture units) */

+   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];

+

+   /** Fallback texture used when a bound texture is incomplete */

+   struct gl_texture_object *FallbackTex;

+

+   /**

+    * \name Thread safety and statechange notification for texture

+    * objects. 

+    *

+    * \todo Improve the granularity of locking.

+    */

+   /*@{*/

+   _glthread_Mutex TexMutex;		/**< texobj thread safety */

+   GLuint TextureStateStamp;	        /**< state notification for shared tex */

+   /*@}*/

+

+   /** Default buffer object for vertex arrays that aren't in VBOs */

+   struct gl_buffer_object *NullBufferObj;

+

+   /**

+    * \name Vertex/geometry/fragment programs

+    */

+   /*@{*/

+   struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */

+   struct gl_vertex_program *DefaultVertexProgram;

+   struct gl_fragment_program *DefaultFragmentProgram;

+   struct gl_geometry_program *DefaultGeometryProgram;

+   /*@}*/

+

+   /* GL_ATI_fragment_shader */

+   struct _mesa_HashTable *ATIShaders;

+   struct ati_fragment_shader *DefaultFragmentShader;

+

+   struct _mesa_HashTable *BufferObjects;

+

+   /** Table of both gl_shader and gl_shader_program objects */

+   struct _mesa_HashTable *ShaderObjects;

+

+   /* GL_EXT_framebuffer_object */

+   struct _mesa_HashTable *RenderBuffers;

+   struct _mesa_HashTable *FrameBuffers;

+

+   /* GL_ARB_sync */

+   struct simple_node SyncObjects;

+

+   void *DriverData;  /**< Device driver shared state */

+};

+

+

+

+

+/**

+ * A renderbuffer stores colors or depth values or stencil values.

+ * A framebuffer object will have a collection of these.

+ * Data are read/written to the buffer with a handful of Get/Put functions.

+ *

+ * Instances of this object are allocated with the Driver's NewRenderbuffer

+ * hook.  Drivers will likely wrap this class inside a driver-specific

+ * class to simulate inheritance.

+ */

+struct gl_renderbuffer

+{

+#define RB_MAGIC 0xaabbccdd

+   int Magic; /** XXX TEMPORARY DEBUG INFO */

+   _glthread_Mutex Mutex;		   /**< for thread safety */

+   GLuint ClassID;        /**< Useful for drivers */

+   GLuint Name;

+   GLint RefCount;

+   GLuint Width, Height;

+   GLboolean Purgeable;   /**< Is the buffer purgeable under memory pressure? */

+

+   GLenum InternalFormat; /**< The user-specified format */

+   GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or

+                               GL_STENCIL_INDEX. */

+   gl_format Format;      /**< The actual renderbuffer memory format */

+

+   GLubyte NumSamples;

+

+   GLenum DataType;      /**< Type of values passed to the Get/Put functions */

+   GLvoid *Data;        /**< This may not be used by some kinds of RBs */

+

+   GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */

+

+   /* Used to wrap one renderbuffer around another: */

+   struct gl_renderbuffer *Wrapped;

+

+   /* Delete this renderbuffer */

+   void (*Delete)(struct gl_renderbuffer *rb);

+

+   /* Allocate new storage for this renderbuffer */

+   GLboolean (*AllocStorage)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                             GLenum internalFormat,

+                             GLuint width, GLuint height);

+

+   /* Lock/Unlock are called before/after calling the Get/Put functions.

+    * Not sure this is the right place for these yet.

+   void (*Lock)(struct gl_context *ctx, struct gl_renderbuffer *rb);

+   void (*Unlock)(struct gl_context *ctx, struct gl_renderbuffer *rb);

+    */

+

+   /* Return a pointer to the element/pixel at (x,y).

+    * Should return NULL if the buffer memory can't be directly addressed.

+    */

+   void *(*GetPointer)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       GLint x, GLint y);

+

+   /* Get/Read a row of values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*GetRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                  GLint x, GLint y, void *values);

+

+   /* Get/Read values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*GetValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     const GLint x[], const GLint y[], void *values);

+

+   /* Put/Write a row of values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                  GLint x, GLint y, const void *values, const GLubyte *mask);

+

+   /* Put/Write a row of RGB values.  This is a special-case routine that's

+    * only used for RGBA renderbuffers when the source data is GL_RGB. That's

+    * a common case for glDrawPixels and some triangle routines.

+    * The values will be of format GL_RGB and type DataType.

+    */

+   void (*PutRowRGB)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                    GLint x, GLint y, const void *values, const GLubyte *mask);

+

+

+   /* Put/Write a row of identical values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutMonoRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     GLint x, GLint y, const void *value, const GLubyte *mask);

+

+   /* Put/Write values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     const GLint x[], const GLint y[], const void *values,

+                     const GLubyte *mask);

+   /* Put/Write identical values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutMonoValues)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                         GLuint count, const GLint x[], const GLint y[],

+                         const void *value, const GLubyte *mask);

+};

+

+

+/**

+ * A renderbuffer attachment points to either a texture object (and specifies

+ * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.

+ */

+struct gl_renderbuffer_attachment

+{

+   GLenum Type;  /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */

+   GLboolean Complete;

+

+   /**

+    * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the

+    * application supplied renderbuffer object.

+    */

+   struct gl_renderbuffer *Renderbuffer;

+

+   /**

+    * If \c Type is \c GL_TEXTURE, this stores a pointer to the application

+    * supplied texture object.

+    */

+   struct gl_texture_object *Texture;

+   GLuint TextureLevel; /**< Attached mipmap level. */

+   GLuint CubeMapFace;  /**< 0 .. 5, for cube map textures. */

+   GLuint Zoffset;      /**< Slice for 3D textures,  or layer for both 1D

+                         * and 2D array textures */

+};

+

+

+/**

+ * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).

+ * In C++ terms, think of this as a base class from which device drivers

+ * will make derived classes.

+ */

+struct gl_framebuffer

+{

+   _glthread_Mutex Mutex;  /**< for thread safety */

+   /**

+    * If zero, this is a window system framebuffer.  If non-zero, this

+    * is a FBO framebuffer; note that for some devices (i.e. those with

+    * a natural pixel coordinate system for FBOs that differs from the

+    * OpenGL/Mesa coordinate system), this means that the viewport,

+    * polygon face orientation, and polygon stipple will have to be inverted.

+    */

+   GLuint Name;

+

+   GLint RefCount;

+   GLboolean DeletePending;

+

+   /**

+    * The framebuffer's visual. Immutable if this is a window system buffer.

+    * Computed from attachments if user-made FBO.

+    */

+   struct gl_config Visual;

+

+   GLboolean Initialized;

+

+   GLuint Width, Height;	/**< size of frame buffer in pixels */

+

+   /** \name  Drawing bounds (Intersection of buffer size and scissor box) */

+   /*@{*/

+   GLint _Xmin, _Xmax;  /**< inclusive */

+   GLint _Ymin, _Ymax;  /**< exclusive */

+   /*@}*/

+

+   /** \name  Derived Z buffer stuff */

+   /*@{*/

+   GLuint _DepthMax;	/**< Max depth buffer value */

+   GLfloat _DepthMaxF;	/**< Float max depth buffer value */

+   GLfloat _MRD;	/**< minimum resolvable difference in Z values */

+   /*@}*/

+

+   /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */

+   GLenum _Status;

+

+   /** Integer color values */

+   GLboolean _IntegerColor;

+

+   /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */

+   struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];

+

+   /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER

+    * attribute group and GL_PIXEL attribute group, respectively.

+    */

+   GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];

+   GLenum ColorReadBuffer;

+

+   /** Computed from ColorDraw/ReadBuffer above */

+   GLuint _NumColorDrawBuffers;

+   GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */

+   GLint _ColorReadBufferIndex; /* -1 = None */

+   struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];

+   struct gl_renderbuffer *_ColorReadBuffer;

+

+   /** The Actual depth/stencil buffers to use.  May be wrappers around the

+    * depth/stencil buffers attached above. */

+   struct gl_renderbuffer *_DepthBuffer;

+   struct gl_renderbuffer *_StencilBuffer;

+

+   /** Delete this framebuffer */

+   void (*Delete)(struct gl_framebuffer *fb);

+};

+

+

+/**

+ * Precision info for shader datatypes.  See glGetShaderPrecisionFormat().

+ */

+struct gl_precision

+{

+   GLushort RangeMin;   /**< min value exponent */

+   GLushort RangeMax;   /**< max value exponent */

+   GLushort Precision;  /**< number of mantissa bits */

+};

+

+

+/**

+ * Limits for vertex and fragment programs/shaders.

+ */

+struct gl_program_constants

+{

+   /* logical limits */

+   GLuint MaxInstructions;

+   GLuint MaxAluInstructions;

+   GLuint MaxTexInstructions;

+   GLuint MaxTexIndirections;

+   GLuint MaxAttribs;

+   GLuint MaxTemps;

+   GLuint MaxAddressRegs;

+   GLuint MaxAddressOffset;  /**< [-MaxAddressOffset, MaxAddressOffset-1] */

+   GLuint MaxParameters;

+   GLuint MaxLocalParams;

+   GLuint MaxEnvParams;

+   /* native/hardware limits */

+   GLuint MaxNativeInstructions;

+   GLuint MaxNativeAluInstructions;

+   GLuint MaxNativeTexInstructions;

+   GLuint MaxNativeTexIndirections;

+   GLuint MaxNativeAttribs;

+   GLuint MaxNativeTemps;

+   GLuint MaxNativeAddressRegs;

+   GLuint MaxNativeParameters;

+   /* For shaders */

+   GLuint MaxUniformComponents;

+   /* GL_ARB_geometry_shader4 */

+   GLuint MaxGeometryTextureImageUnits;

+   GLuint MaxGeometryVaryingComponents;

+   GLuint MaxVertexVaryingComponents;

+   GLuint MaxGeometryUniformComponents;

+   GLuint MaxGeometryOutputVertices;

+   GLuint MaxGeometryTotalOutputComponents;

+   /* ES 2.0 and GL_ARB_ES2_compatibility */

+   struct gl_precision LowFloat, MediumFloat, HighFloat;

+   struct gl_precision LowInt, MediumInt, HighInt;

+};

+

+

+/**

+ * Constants which may be overridden by device driver during context creation

+ * but are never changed after that.

+ */

+struct gl_constants

+{

+   GLint MaxTextureMbytes;      /**< Max memory per image, in MB */

+   GLint MaxTextureLevels;      /**< Max mipmap levels. */ 

+   GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */

+   GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */

+   GLint MaxArrayTextureLayers; /**< Max layers in array textures */

+   GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */

+   GLuint MaxTextureCoordUnits;

+   GLuint MaxTextureImageUnits;

+   GLuint MaxVertexTextureImageUnits;

+   GLuint MaxCombinedTextureImageUnits;

+   GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */

+   GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */

+   GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */

+

+   GLuint MaxArrayLockSize;

+

+   GLint SubPixelBits;

+

+   GLfloat MinPointSize, MaxPointSize;	     /**< aliased */

+   GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */

+   GLfloat PointSizeGranularity;

+   GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */

+   GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */

+   GLfloat LineWidthGranularity;

+

+   GLuint MaxColorTableSize;

+

+   GLuint MaxClipPlanes;

+   GLuint MaxLights;

+   GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */

+   GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */

+

+   GLuint MaxViewportWidth, MaxViewportHeight;

+

+   struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */

+   struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */

+   struct gl_program_constants GeometryProgram;  /**< GL_ARB_geometry_shader4 */

+   GLuint MaxProgramMatrices;

+   GLuint MaxProgramMatrixStackDepth;

+

+   /** vertex array / buffer object bounds checking */

+   GLboolean CheckArrayBounds;

+

+   GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */

+

+   GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */

+   GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */

+   GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */

+

+   GLuint MaxVarying;  /**< Number of float[4] varying parameters */

+

+   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */

+

+   /** Which texture units support GL_ATI_envmap_bumpmap as targets */

+   GLbitfield SupportedBumpUnits;

+

+   /**

+    * Maximum amount of time, measured in nanseconds, that the server can wait.

+    */

+   GLuint64 MaxServerWaitTimeout;

+

+   /** GL_EXT_provoking_vertex */

+   GLboolean QuadsFollowProvokingVertexConvention;

+

+   /** OpenGL version 3.0 */

+   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */

+

+   /** OpenGL version 3.2 */

+   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */

+

+   /** GL_EXT_transform_feedback */

+   GLuint MaxTransformFeedbackSeparateAttribs;

+   GLuint MaxTransformFeedbackSeparateComponents;

+   GLuint MaxTransformFeedbackInterleavedComponents;

+

+   /** GL_EXT_gpu_shader4 */

+   GLint MinProgramTexelOffset, MaxProgramTexelOffset;

+

+   /* GL_EXT_framebuffer_sRGB */

+   GLboolean sRGBCapable; /* can enable sRGB blend/update on FBOs */

+};

+

+

+/**

+ * Enable flag for each OpenGL extension.  Different device drivers will

+ * enable different extensions at runtime.

+ */

+struct gl_extensions

+{

+   GLboolean dummy;  /* don't remove this! */

+   GLboolean dummy_true;  /* Set true by _mesa_init_extensions(). */

+   GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */

+   GLboolean ARB_ES2_compatibility;

+   GLboolean ARB_blend_func_extended;

+   GLboolean ARB_copy_buffer;

+   GLboolean ARB_depth_buffer_float;

+   GLboolean ARB_depth_clamp;

+   GLboolean ARB_depth_texture;

+   GLboolean ARB_draw_buffers;

+   GLboolean ARB_draw_buffers_blend;

+   GLboolean ARB_draw_elements_base_vertex;

+   GLboolean ARB_draw_instanced;

+   GLboolean ARB_fragment_coord_conventions;

+   GLboolean ARB_fragment_program;

+   GLboolean ARB_fragment_program_shadow;

+   GLboolean ARB_fragment_shader;

+   GLboolean ARB_framebuffer_object;

+   GLboolean ARB_explicit_attrib_location;

+   GLboolean ARB_geometry_shader4;

+   GLboolean ARB_half_float_pixel;

+   GLboolean ARB_half_float_vertex;

+   GLboolean ARB_instanced_arrays;

+   GLboolean ARB_map_buffer_range;

+   GLboolean ARB_multisample;

+   GLboolean ARB_multitexture;

+   GLboolean ARB_occlusion_query;

+   GLboolean ARB_occlusion_query2;

+   GLboolean ARB_point_sprite;

+   GLboolean ARB_sampler_objects;

+   GLboolean ARB_seamless_cube_map;

+   GLboolean ARB_shader_objects;

+   GLboolean ARB_shader_stencil_export;

+   GLboolean ARB_shading_language_100;

+   GLboolean ARB_shadow;

+   GLboolean ARB_shadow_ambient;

+   GLboolean ARB_sync;

+   GLboolean ARB_texture_border_clamp;

+   GLboolean ARB_texture_buffer_object;

+   GLboolean ARB_texture_compression;

+   GLboolean ARB_texture_compression_rgtc;

+   GLboolean ARB_texture_cube_map;

+   GLboolean ARB_texture_env_combine;

+   GLboolean ARB_texture_env_crossbar;

+   GLboolean ARB_texture_env_dot3;

+   GLboolean ARB_texture_float;

+   GLboolean ARB_texture_mirrored_repeat;

+   GLboolean ARB_texture_multisample;

+   GLboolean ARB_texture_non_power_of_two;

+   GLboolean ARB_texture_rg;

+   GLboolean ARB_texture_rgb10_a2ui;

+   GLboolean ARB_timer_query;

+   GLboolean ARB_transform_feedback2;

+   GLboolean ARB_transpose_matrix;

+   GLboolean ARB_uniform_buffer_object;

+   GLboolean ARB_vertex_array_object;

+   GLboolean ARB_vertex_buffer_object;

+   GLboolean ARB_vertex_program;

+   GLboolean ARB_vertex_shader;

+   GLboolean ARB_vertex_type_2_10_10_10_rev;

+   GLboolean ARB_window_pos;

+   GLboolean EXT_abgr;

+   GLboolean EXT_bgra;

+   GLboolean EXT_blend_color;

+   GLboolean EXT_blend_equation_separate;

+   GLboolean EXT_blend_func_separate;

+   GLboolean EXT_blend_logic_op;

+   GLboolean EXT_blend_minmax;

+   GLboolean EXT_blend_subtract;

+   GLboolean EXT_clip_volume_hint;

+   GLboolean EXT_compiled_vertex_array;

+   GLboolean EXT_copy_texture;

+   GLboolean EXT_depth_bounds_test;

+   GLboolean EXT_draw_buffers2;

+   GLboolean EXT_draw_range_elements;

+   GLboolean EXT_fog_coord;

+   GLboolean EXT_framebuffer_blit;

+   GLboolean EXT_framebuffer_multisample;

+   GLboolean EXT_framebuffer_object;

+   GLboolean EXT_framebuffer_sRGB;

+   GLboolean EXT_gpu_program_parameters;

+   GLboolean EXT_gpu_shader4;

+   GLboolean EXT_multi_draw_arrays;

+   GLboolean EXT_paletted_texture;

+   GLboolean EXT_packed_depth_stencil;

+   GLboolean EXT_packed_float;

+   GLboolean EXT_packed_pixels;

+   GLboolean EXT_pixel_buffer_object;

+   GLboolean EXT_point_parameters;

+   GLboolean EXT_polygon_offset;

+   GLboolean EXT_provoking_vertex;

+   GLboolean EXT_rescale_normal;

+   GLboolean EXT_shadow_funcs;

+   GLboolean EXT_secondary_color;

+   GLboolean EXT_separate_shader_objects;

+   GLboolean EXT_separate_specular_color;

+   GLboolean EXT_shared_texture_palette;

+   GLboolean EXT_stencil_wrap;

+   GLboolean EXT_stencil_two_side;

+   GLboolean EXT_subtexture;

+   GLboolean EXT_texture;

+   GLboolean EXT_texture_object;

+   GLboolean EXT_texture3D;

+   GLboolean EXT_texture_array;

+   GLboolean EXT_texture_compression_latc;

+   GLboolean EXT_texture_compression_s3tc;

+   GLboolean EXT_texture_env_add;

+   GLboolean EXT_texture_env_combine;

+   GLboolean EXT_texture_env_dot3;

+   GLboolean EXT_texture_filter_anisotropic;

+   GLboolean EXT_texture_integer;

+   GLboolean EXT_texture_lod_bias;

+   GLboolean EXT_texture_mirror_clamp;

+   GLboolean EXT_texture_shared_exponent;

+   GLboolean EXT_texture_sRGB;

+   GLboolean EXT_texture_sRGB_decode;

+   GLboolean EXT_texture_swizzle;

+   GLboolean EXT_transform_feedback;

+   GLboolean EXT_timer_query;

+   GLboolean EXT_vertex_array;

+   GLboolean EXT_vertex_array_bgra;

+   GLboolean EXT_vertex_array_set;

+   GLboolean OES_standard_derivatives;

+   /* vendor extensions */

+   GLboolean AMD_conservative_depth;

+   GLboolean APPLE_client_storage;

+   GLboolean APPLE_packed_pixels;

+   GLboolean APPLE_vertex_array_object;

+   GLboolean APPLE_object_purgeable;

+   GLboolean ATI_envmap_bumpmap;

+   GLboolean ATI_texture_compression_3dc;

+   GLboolean ATI_texture_mirror_once;

+   GLboolean ATI_texture_env_combine3;

+   GLboolean ATI_fragment_shader;

+   GLboolean ATI_separate_stencil;

+   GLboolean IBM_rasterpos_clip;

+   GLboolean IBM_multimode_draw_arrays;

+   GLboolean MESA_pack_invert;

+   GLboolean MESA_resize_buffers;

+   GLboolean MESA_ycbcr_texture;

+   GLboolean MESA_texture_array;

+   GLboolean MESA_texture_signed_rgba;

+   GLboolean NV_blend_square;

+   GLboolean NV_conditional_render;

+   GLboolean NV_fragment_program;

+   GLboolean NV_fragment_program_option;

+   GLboolean NV_light_max_exponent;

+   GLboolean NV_point_sprite;

+   GLboolean NV_primitive_restart;

+   GLboolean NV_texgen_reflection;

+   GLboolean NV_texture_env_combine4;

+   GLboolean NV_texture_rectangle;

+   GLboolean NV_vertex_program;

+   GLboolean NV_vertex_program1_1;

+   GLboolean OES_read_format;

+   GLboolean SGIS_generate_mipmap;

+   GLboolean SGIS_texture_edge_clamp;

+   GLboolean SGIS_texture_lod;

+   GLboolean TDFX_texture_compression_FXT1;

+   GLboolean S3_s3tc;

+   GLboolean OES_EGL_image;

+   GLboolean OES_draw_texture;

+   GLboolean EXT_texture_format_BGRA8888;

+   GLboolean extension_sentinel;

+   /** The extension string */

+   const GLubyte *String;

+   /** Number of supported extensions */

+   GLuint Count;

+};

+

+

+/**

+ * A stack of matrices (projection, modelview, color, texture, etc).

+ */

+struct gl_matrix_stack

+{

+   GLmatrix *Top;      /**< points into Stack */

+   GLmatrix *Stack;    /**< array [MaxDepth] of GLmatrix */

+   GLuint Depth;       /**< 0 <= Depth < MaxDepth */

+   GLuint MaxDepth;    /**< size of Stack[] array */

+   GLuint DirtyFlag;   /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */

+};

+

+

+/**

+ * \name Bits for image transfer operations 

+ * \sa __struct gl_contextRec::ImageTransferState.

+ */

+/*@{*/

+#define IMAGE_SCALE_BIAS_BIT                      0x1

+#define IMAGE_SHIFT_OFFSET_BIT                    0x2

+#define IMAGE_MAP_COLOR_BIT                       0x4

+#define IMAGE_CLAMP_BIT                           0x800

+

+

+/** Pixel Transfer ops */

+#define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT |			\

+		    IMAGE_SHIFT_OFFSET_BIT |			\

+		    IMAGE_MAP_COLOR_BIT)

+

+/**

+ * \name Bits to indicate what state has changed.  

+ */

+/*@{*/

+#define _NEW_MODELVIEW         (1 << 0)   /**< gl_context::ModelView */

+#define _NEW_PROJECTION        (1 << 1)   /**< gl_context::Projection */

+#define _NEW_TEXTURE_MATRIX    (1 << 2)   /**< gl_context::TextureMatrix */

+#define _NEW_COLOR             (1 << 3)   /**< gl_context::Color */

+#define _NEW_DEPTH             (1 << 4)   /**< gl_context::Depth */

+#define _NEW_EVAL              (1 << 5)   /**< gl_context::Eval, EvalMap */

+#define _NEW_FOG               (1 << 6)   /**< gl_context::Fog */

+#define _NEW_HINT              (1 << 7)   /**< gl_context::Hint */

+#define _NEW_LIGHT             (1 << 8)   /**< gl_context::Light */

+#define _NEW_LINE              (1 << 9)   /**< gl_context::Line */

+#define _NEW_PIXEL             (1 << 10)  /**< gl_context::Pixel */

+#define _NEW_POINT             (1 << 11)  /**< gl_context::Point */

+#define _NEW_POLYGON           (1 << 12)  /**< gl_context::Polygon */

+#define _NEW_POLYGONSTIPPLE    (1 << 13)  /**< gl_context::PolygonStipple */

+#define _NEW_SCISSOR           (1 << 14)  /**< gl_context::Scissor */

+#define _NEW_STENCIL           (1 << 15)  /**< gl_context::Stencil */

+#define _NEW_TEXTURE           (1 << 16)  /**< gl_context::Texture */

+#define _NEW_TRANSFORM         (1 << 17)  /**< gl_context::Transform */

+#define _NEW_VIEWPORT          (1 << 18)  /**< gl_context::Viewport */

+#define _NEW_PACKUNPACK        (1 << 19)  /**< gl_context::Pack, Unpack */

+#define _NEW_ARRAY             (1 << 20)  /**< gl_context::Array */

+#define _NEW_RENDERMODE        (1 << 21)  /**< gl_context::RenderMode, etc */

+#define _NEW_BUFFERS           (1 << 22)  /**< gl_context::Visual, DrawBuffer, */

+#define _NEW_CURRENT_ATTRIB    (1 << 23)  /**< gl_context::Current */

+#define _NEW_MULTISAMPLE       (1 << 24)  /**< gl_context::Multisample */

+#define _NEW_TRACK_MATRIX      (1 << 25)  /**< gl_context::VertexProgram */

+#define _NEW_PROGRAM           (1 << 26)  /**< New program/shader state */

+#define _NEW_PROGRAM_CONSTANTS (1 << 27)

+#define _NEW_BUFFER_OBJECT     (1 << 28)

+#define _NEW_ALL ~0

+/*@}*/

+

+

+/**

+ * \name Bits to track array state changes 

+ *

+ * Also used to summarize array enabled.

+ */

+/*@{*/

+#define _NEW_ARRAY_VERTEX           VERT_BIT_POS

+#define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT

+#define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL

+#define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0

+#define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1

+#define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG

+#define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX

+#define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG

+#define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */

+#define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0

+#define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1

+#define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2

+#define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3

+#define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4

+#define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5

+#define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6

+#define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7

+#define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */

+#define _NEW_ARRAY_ALL              0xffffffff

+

+

+#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))

+#define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))

+/*@}*/

+

+

+

+/**

+ * \name A bunch of flags that we think might be useful to drivers.

+ * 

+ * Set in the __struct gl_contextRec::_TriangleCaps bitfield.

+ */

+/*@{*/

+#define DD_FLATSHADE                0x1

+#define DD_SEPARATE_SPECULAR        0x2

+#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */

+#define DD_TRI_LIGHT_TWOSIDE        0x8

+#define DD_TRI_UNFILLED             0x10

+#define DD_TRI_SMOOTH               0x20

+#define DD_TRI_STIPPLE              0x40

+#define DD_TRI_OFFSET               0x80

+#define DD_LINE_SMOOTH              0x100

+#define DD_LINE_STIPPLE             0x200

+#define DD_POINT_SMOOTH             0x400

+#define DD_POINT_ATTEN              0x800

+#define DD_TRI_TWOSTENCIL           0x1000

+/*@}*/

+

+

+/**

+ * \name Define the state changes under which each of these bits might change

+ */

+/*@{*/

+#define _DD_NEW_FLATSHADE                _NEW_LIGHT

+#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)

+#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON

+#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT

+#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON

+#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON

+#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON

+#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON

+#define _DD_NEW_LINE_SMOOTH              _NEW_LINE

+#define _DD_NEW_LINE_STIPPLE             _NEW_LINE

+#define _DD_NEW_LINE_WIDTH               _NEW_LINE

+#define _DD_NEW_POINT_SMOOTH             _NEW_POINT

+#define _DD_NEW_POINT_SIZE               _NEW_POINT

+#define _DD_NEW_POINT_ATTEN              _NEW_POINT

+/*@}*/

+

+

+/**

+ * Composite state flags

+ */

+/*@{*/

+#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\

+                                           _NEW_TEXTURE |	\

+                                           _NEW_POINT |		\

+                                           _NEW_PROGRAM |	\

+                                           _NEW_MODELVIEW)

+

+#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\

+                                           _NEW_TEXTURE)

+

+#define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL)

+/*@}*/

+

+

+

+

+/* This has to be included here. */

+#include "dd.h"

+

+

+/**

+ * Display list flags.

+ * Strictly this is a tnl-private concept, but it doesn't seem

+ * worthwhile adding a tnl private structure just to hold this one bit

+ * of information:

+ */

+#define DLIST_DANGLING_REFS     0x1 

+

+

+/** Opaque declaration of display list payload data type */

+union gl_dlist_node;

+

+

+/**

+ * Provide a location where information about a display list can be

+ * collected.  Could be extended with driverPrivate structures,

+ * etc. in the future.

+ */

+struct gl_display_list

+{

+   GLuint Name;

+   GLbitfield Flags;  /**< DLIST_x flags */

+   /** The dlist commands are in a linked list of nodes */

+   union gl_dlist_node *Head;

+};

+

+

+/**

+ * State used during display list compilation and execution.

+ */

+struct gl_dlist_state

+{

+   GLuint CallDepth;		/**< Current recursion calling depth */

+

+   struct gl_display_list *CurrentList; /**< List currently being compiled */

+   union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */

+   GLuint CurrentPos;		/**< Index into current block of nodes */

+

+   GLvertexformat ListVtxfmt;

+

+   GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];

+   GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];

+   

+   GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];

+   GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];

+

+   GLubyte ActiveIndex;

+   GLfloat CurrentIndex;

+   

+   GLubyte ActiveEdgeFlag;

+   GLboolean CurrentEdgeFlag;

+

+   struct {

+      /* State known to have been set by the currently-compiling display

+       * list.  Used to eliminate some redundant state changes.

+       */

+      GLenum ShadeModel;

+   } Current;

+};

+

+

+/**

+ * Enum for the OpenGL APIs we know about and may support.

+ */

+typedef enum

+{

+   API_OPENGL,

+   API_OPENGLES,

+   API_OPENGLES2

+} gl_api;

+

+

+/**

+ * Mesa rendering context.

+ *

+ * This is the central context data structure for Mesa.  Almost all

+ * OpenGL state is contained in this structure.

+ * Think of this as a base class from which device drivers will derive

+ * sub classes.

+ *

+ * The struct gl_context typedef names this structure.

+ */

+struct gl_context

+{

+   /** State possibly shared with other contexts in the address space */

+   struct gl_shared_state *Shared;

+

+   /** \name API function pointer tables */

+   /*@{*/

+   gl_api API;

+   struct _glapi_table *Save;	/**< Display list save functions */

+   struct _glapi_table *Exec;	/**< Execute functions */

+   struct _glapi_table *CurrentDispatch;  /**< == Save or Exec !! */

+   /*@}*/

+

+   struct gl_config Visual;

+   struct gl_framebuffer *DrawBuffer;	/**< buffer for writing */

+   struct gl_framebuffer *ReadBuffer;	/**< buffer for reading */

+   struct gl_framebuffer *WinSysDrawBuffer;  /**< set with MakeCurrent */

+   struct gl_framebuffer *WinSysReadBuffer;  /**< set with MakeCurrent */

+

+   /**

+    * Device driver function pointer table

+    */

+   struct dd_function_table Driver;

+

+   void *DriverCtx;	/**< Points to device driver context/state */

+

+   /** Core/Driver constants */

+   struct gl_constants Const;

+

+   /** \name The various 4x4 matrix stacks */

+   /*@{*/

+   struct gl_matrix_stack ModelviewMatrixStack;

+   struct gl_matrix_stack ProjectionMatrixStack;

+   struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];

+   struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];

+   struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */

+   /*@}*/

+

+   /** Combined modelview and projection matrix */

+   GLmatrix _ModelProjectMatrix;

+

+   /** \name Display lists */

+   struct gl_dlist_state ListState;

+

+   GLboolean ExecuteFlag;	/**< Execute GL commands? */

+   GLboolean CompileFlag;	/**< Compile GL commands into display list? */

+

+   /** Extension information */

+   struct gl_extensions Extensions;

+

+   /** Version info */

+   GLuint VersionMajor, VersionMinor;

+   char *VersionString;

+

+   /** \name State attribute stack (for glPush/PopAttrib) */

+   /*@{*/

+   GLuint AttribStackDepth;

+   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];

+   /*@}*/

+

+   /** \name Renderer attribute groups

+    * 

+    * We define a struct for each attribute group to make pushing and popping

+    * attributes easy.  Also it's a good organization.

+    */

+   /*@{*/

+   struct gl_accum_attrib	Accum;		/**< Accum buffer attributes */

+   struct gl_colorbuffer_attrib	Color;		/**< Color buffer attributes */

+   struct gl_current_attrib	Current;	/**< Current attributes */

+   struct gl_depthbuffer_attrib	Depth;		/**< Depth buffer attributes */

+   struct gl_eval_attrib	Eval;		/**< Eval attributes */

+   struct gl_fog_attrib		Fog;		/**< Fog attributes */

+   struct gl_hint_attrib	Hint;		/**< Hint attributes */

+   struct gl_light_attrib	Light;		/**< Light attributes */

+   struct gl_line_attrib	Line;		/**< Line attributes */

+   struct gl_list_attrib	List;		/**< List attributes */

+   struct gl_multisample_attrib Multisample;

+   struct gl_pixel_attrib	Pixel;		/**< Pixel attributes */

+   struct gl_point_attrib	Point;		/**< Point attributes */

+   struct gl_polygon_attrib	Polygon;	/**< Polygon attributes */

+   GLuint PolygonStipple[32];			/**< Polygon stipple */

+   struct gl_scissor_attrib	Scissor;	/**< Scissor attributes */

+   struct gl_stencil_attrib	Stencil;	/**< Stencil buffer attributes */

+   struct gl_texture_attrib	Texture;	/**< Texture attributes */

+   struct gl_transform_attrib	Transform;	/**< Transformation attributes */

+   struct gl_viewport_attrib	Viewport;	/**< Viewport attributes */

+   /*@}*/

+

+   /** \name Client attribute stack */

+   /*@{*/

+   GLuint ClientAttribStackDepth;

+   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];

+   /*@}*/

+

+   /** \name Client attribute groups */

+   /*@{*/

+   struct gl_array_attrib	Array;	/**< Vertex arrays */

+   struct gl_pixelstore_attrib	Pack;	/**< Pixel packing */

+   struct gl_pixelstore_attrib	Unpack;	/**< Pixel unpacking */

+   struct gl_pixelstore_attrib	DefaultPacking;	/**< Default params */

+   /*@}*/

+

+   /** \name Other assorted state (not pushed/popped on attribute stack) */

+   /*@{*/

+   struct gl_pixelmaps          PixelMaps;

+

+   struct gl_evaluators EvalMap;   /**< All evaluators */

+   struct gl_feedback   Feedback;  /**< Feedback */

+   struct gl_selection  Select;    /**< Selection */

+

+   struct gl_program_state Program;  /**< general program state */

+   struct gl_vertex_program_state VertexProgram;

+   struct gl_fragment_program_state FragmentProgram;

+   struct gl_geometry_program_state GeometryProgram;

+   struct gl_ati_fragment_shader_state ATIFragmentShader;

+

+   struct gl_shader_state Shader; /**< GLSL shader object state */

+   struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES];

+

+   struct gl_query_state Query;  /**< occlusion, timer queries */

+

+   struct gl_transform_feedback TransformFeedback;

+

+   struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */

+   struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */

+   /*@}*/

+

+   struct gl_meta_state *Meta;  /**< for "meta" operations */

+

+   /* GL_EXT_framebuffer_object */

+   struct gl_renderbuffer *CurrentRenderbuffer;

+

+   GLenum ErrorValue;        /**< Last error code */

+

+   /**

+    * Recognize and silence repeated error debug messages in buggy apps.

+    */

+   const char *ErrorDebugFmtString;

+   GLuint ErrorDebugCount;

+

+   GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */

+   GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */

+

+   GLboolean ViewportInitialized;  /**< has viewport size been initialized? */

+

+   GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */

+

+   /** \name Derived state */

+   /*@{*/

+   /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before

+    * state validation so they need to always be current.

+    */

+   GLbitfield _TriangleCaps;

+   GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */

+   GLfloat _EyeZDir[3];

+   GLfloat _ModelViewInvScale;

+   GLboolean _NeedEyeCoords;

+   GLboolean _ForceEyeCoords; 

+

+   GLuint TextureStateTimestamp; /**< detect changes to shared state */

+

+   struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */

+   struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */

+   /**@}*/

+

+   struct gl_list_extensions *ListExt; /**< driver dlist extensions */

+

+   /** \name For debugging/development only */

+   /*@{*/

+   GLboolean FirstTimeCurrent;

+   /*@}*/

+

+   /** software compression/decompression supported or not */

+   GLboolean Mesa_DXTn;

+

+   GLboolean TextureFormatSupported[MESA_FORMAT_COUNT];

+

+   /** 

+    * Use dp4 (rather than mul/mad) instructions for position

+    * transformation?

+    */

+   GLboolean mvp_with_dp4;

+

+   /**

+    * \name Hooks for module contexts.  

+    *

+    * These will eventually live in the driver or elsewhere.

+    */

+   /*@{*/

+   void *swrast_context;

+   void *swsetup_context;

+   void *swtnl_context;

+   void *swtnl_im;

+   struct st_context *st;

+   void *aelt_context;

+   /*@}*/

+};

+

+

+#ifdef DEBUG

+extern int MESA_VERBOSE;

+extern int MESA_DEBUG_FLAGS;

+# define MESA_FUNCTION __FUNCTION__

+#else

+# define MESA_VERBOSE 0

+# define MESA_DEBUG_FLAGS 0

+# define MESA_FUNCTION "a function"

+# ifndef NDEBUG

+#  define NDEBUG

+# endif

+#endif

+

+

+/** The MESA_VERBOSE var is a bitmask of these flags */

+enum _verbose

+{

+   VERBOSE_VARRAY		= 0x0001,

+   VERBOSE_TEXTURE		= 0x0002,

+   VERBOSE_MATERIAL		= 0x0004,

+   VERBOSE_PIPELINE		= 0x0008,

+   VERBOSE_DRIVER		= 0x0010,

+   VERBOSE_STATE		= 0x0020,

+   VERBOSE_API			= 0x0040,

+   VERBOSE_DISPLAY_LIST		= 0x0100,

+   VERBOSE_LIGHTING		= 0x0200,

+   VERBOSE_PRIMS		= 0x0400,

+   VERBOSE_VERTS		= 0x0800,

+   VERBOSE_DISASSEM		= 0x1000,

+   VERBOSE_DRAW                 = 0x2000,

+   VERBOSE_SWAPBUFFERS          = 0x4000

+};

+

+

+/** The MESA_DEBUG_FLAGS var is a bitmask of these flags */

+enum _debug

+{

+   DEBUG_ALWAYS_FLUSH		= 0x1

+};

+

+

+

+#endif /* MTYPES_H */

diff --git a/mesalib/src/mesa/main/pixel.c b/mesalib/src/mesa/main/pixel.c
index 195fa234b..55e368c36 100644
--- a/mesalib/src/mesa/main/pixel.c
+++ b/mesalib/src/mesa/main/pixel.c
@@ -1,699 +1,699 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file pixel.c
- * Pixel transfer functions (glPixelZoom, glPixelMap, glPixelTransfer)
- */
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "colormac.h"
-#include "context.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "pixel.h"
-#include "pbo.h"
-#include "mtypes.h"
-#include "main/dispatch.h"
-
-
-#if FEATURE_pixel_transfer
-
-
-/**********************************************************************/
-/*****                    glPixelZoom                             *****/
-/**********************************************************************/
-
-static void GLAPIENTRY
-_mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (ctx->Pixel.ZoomX == xfactor &&
-       ctx->Pixel.ZoomY == yfactor)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_PIXEL);
-   ctx->Pixel.ZoomX = xfactor;
-   ctx->Pixel.ZoomY = yfactor;
-}
-
-
-
-/**********************************************************************/
-/*****                         glPixelMap                         *****/
-/**********************************************************************/
-
-/**
- * Return pointer to a pixelmap by name.
- */
-static struct gl_pixelmap *
-get_pixelmap(struct gl_context *ctx, GLenum map)
-{
-   switch (map) {
-   case GL_PIXEL_MAP_I_TO_I:
-      return &ctx->PixelMaps.ItoI;
-   case GL_PIXEL_MAP_S_TO_S:
-      return &ctx->PixelMaps.StoS;
-   case GL_PIXEL_MAP_I_TO_R:
-      return &ctx->PixelMaps.ItoR;
-   case GL_PIXEL_MAP_I_TO_G:
-      return &ctx->PixelMaps.ItoG;
-   case GL_PIXEL_MAP_I_TO_B:
-      return &ctx->PixelMaps.ItoB;
-   case GL_PIXEL_MAP_I_TO_A:
-      return &ctx->PixelMaps.ItoA;
-   case GL_PIXEL_MAP_R_TO_R:
-      return &ctx->PixelMaps.RtoR;
-   case GL_PIXEL_MAP_G_TO_G:
-      return &ctx->PixelMaps.GtoG;
-   case GL_PIXEL_MAP_B_TO_B:
-      return &ctx->PixelMaps.BtoB;
-   case GL_PIXEL_MAP_A_TO_A:
-      return &ctx->PixelMaps.AtoA;
-   default:
-      return NULL;
-   }
-}
-
-
-/**
- * Helper routine used by the other _mesa_PixelMap() functions.
- */
-static void
-store_pixelmap(struct gl_context *ctx, GLenum map, GLsizei mapsize,
-               const GLfloat *values)
-{
-   GLint i;
-   struct gl_pixelmap *pm = get_pixelmap(ctx, map);
-   if (!pm) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelMap(map)");
-      return;
-   }
-
-   switch (map) {
-   case GL_PIXEL_MAP_S_TO_S:
-      /* special case */
-      ctx->PixelMaps.StoS.Size = mapsize;
-      for (i = 0; i < mapsize; i++) {
-         ctx->PixelMaps.StoS.Map[i] = (GLfloat)IROUND(values[i]);
-      }
-      break;
-   case GL_PIXEL_MAP_I_TO_I:
-      /* special case */
-      ctx->PixelMaps.ItoI.Size = mapsize;
-      for (i = 0; i < mapsize; i++) {
-         ctx->PixelMaps.ItoI.Map[i] = values[i];
-      }
-      break;
-   default:
-      /* general case */
-      pm->Size = mapsize;
-      for (i = 0; i < mapsize; i++) {
-         GLfloat val = CLAMP(values[i], 0.0F, 1.0F);
-         pm->Map[i] = val;
-         pm->Map8[i] = (GLint) (val * 255.0F);
-      }
-   }
-}
-
-
-/**
- * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().
- */
-static GLboolean
-validate_pbo_access(struct gl_context *ctx, struct gl_pixelstore_attrib *pack,
-                    GLsizei mapsize, GLenum format, GLenum type,
-                    const GLvoid *ptr)
-{
-   GLboolean ok;
-
-   /* Note, need to use DefaultPacking and Unpack's buffer object */
-   _mesa_reference_buffer_object(ctx,
-                                 &ctx->DefaultPacking.BufferObj,
-                                 pack->BufferObj);
-
-   ok = _mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                  format, type, ptr);
-
-   /* restore */
-   _mesa_reference_buffer_object(ctx,
-                                 &ctx->DefaultPacking.BufferObj,
-                                 ctx->Shared->NullBufferObj);
-
-   if (!ok) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glPixelMap(invalid PBO access)");
-   }
-   return ok;
-}
-
-
-static void GLAPIENTRY
-_mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
-   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
-      return;
-   }
-
-   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
-      /* test that mapsize is a power of two */
-      if (!_mesa_is_pow_two(mapsize)) {
-	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
-         return;
-      }
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PIXEL);
-
-   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
-                            GL_INTENSITY, GL_FLOAT, values)) {
-      return;
-   }
-
-   values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapfv(PBO is mapped)");
-      }
-      return;
-   }
-
-   store_pixelmap(ctx, map, mapsize, values);
-
-   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
-}
-
-
-static void GLAPIENTRY
-_mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
-{
-   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
-      return;
-   }
-
-   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
-      /* test that mapsize is a power of two */
-      if (!_mesa_is_pow_two(mapsize)) {
-	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
-         return;
-      }
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PIXEL);
-
-   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
-                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {
-      return;
-   }
-
-   values = (const GLuint *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapuiv(PBO is mapped)");
-      }
-      return;
-   }
-
-   /* convert to floats */
-   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
-      GLint i;
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = (GLfloat) values[i];
-      }
-   }
-   else {
-      GLint i;
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = UINT_TO_FLOAT( values[i] );
-      }
-   }
-
-   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
-
-   store_pixelmap(ctx, map, mapsize, fvalues);
-}
-
-
-static void GLAPIENTRY
-_mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
-{
-   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
-      return;
-   }
-
-   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
-      /* test that mapsize is a power of two */
-      if (!_mesa_is_pow_two(mapsize)) {
-	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
-         return;
-      }
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PIXEL);
-
-   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
-                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {
-      return;
-   }
-
-   values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapusv(PBO is mapped)");
-      }
-      return;
-   }
-
-   /* convert to floats */
-   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
-      GLint i;
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = (GLfloat) values[i];
-      }
-   }
-   else {
-      GLint i;
-      for (i = 0; i < mapsize; i++) {
-         fvalues[i] = USHORT_TO_FLOAT( values[i] );
-      }
-   }
-
-   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
-
-   store_pixelmap(ctx, map, mapsize, fvalues);
-}
-
-
-static void GLAPIENTRY
-_mesa_GetPixelMapfv( GLenum map, GLfloat *values )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint mapsize, i;
-   const struct gl_pixelmap *pm;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   pm = get_pixelmap(ctx, map);
-   if (!pm) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapfv(map)");
-      return;
-   }
-
-   mapsize = pm->Size;
-
-   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
-                            GL_INTENSITY, GL_FLOAT, values)) {
-      return;
-   }
-
-   values = (GLfloat *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapfv(PBO is mapped)");
-      }
-      return;
-   }
-
-   if (map == GL_PIXEL_MAP_S_TO_S) {
-      /* special case */
-      for (i = 0; i < mapsize; i++) {
-         values[i] = (GLfloat) ctx->PixelMaps.StoS.Map[i];
-      }
-   }
-   else {
-      memcpy(values, pm->Map, mapsize * sizeof(GLfloat));
-   }
-
-   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
-}
-
-
-static void GLAPIENTRY
-_mesa_GetPixelMapuiv( GLenum map, GLuint *values )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint mapsize, i;
-   const struct gl_pixelmap *pm;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   pm = get_pixelmap(ctx, map);
-   if (!pm) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapuiv(map)");
-      return;
-   }
-   mapsize = pm->Size;
-
-   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
-                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {
-      return;
-   }
-
-   values = (GLuint *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapuiv(PBO is mapped)");
-      }
-      return;
-   }
-
-   if (map == GL_PIXEL_MAP_S_TO_S) {
-      /* special case */
-      memcpy(values, ctx->PixelMaps.StoS.Map, mapsize * sizeof(GLint));
-   }
-   else {
-      for (i = 0; i < mapsize; i++) {
-         values[i] = FLOAT_TO_UINT( pm->Map[i] );
-      }
-   }
-
-   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
-}
-
-
-static void GLAPIENTRY
-_mesa_GetPixelMapusv( GLenum map, GLushort *values )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint mapsize, i;
-   const struct gl_pixelmap *pm;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   pm = get_pixelmap(ctx, map);
-   if (!pm) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapusv(map)");
-      return;
-   }
-   mapsize = pm->Size;
-
-   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
-                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {
-      return;
-   }
-
-   values = (GLushort *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
-   if (!values) {
-      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapusv(PBO is mapped)");
-      }
-      return;
-   }
-
-   switch (map) {
-   /* special cases */
-   case GL_PIXEL_MAP_I_TO_I:
-      for (i = 0; i < mapsize; i++) {
-         values[i] = (GLushort) CLAMP(ctx->PixelMaps.ItoI.Map[i], 0.0, 65535.);
-      }
-      break;
-   case GL_PIXEL_MAP_S_TO_S:
-      for (i = 0; i < mapsize; i++) {
-         values[i] = (GLushort) CLAMP(ctx->PixelMaps.StoS.Map[i], 0.0, 65535.);
-      }
-      break;
-   default:
-      for (i = 0; i < mapsize; i++) {
-         CLAMPED_FLOAT_TO_USHORT(values[i], pm->Map[i] );
-      }
-   }
-
-   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
-}
-
-
-
-/**********************************************************************/
-/*****                       glPixelTransfer                      *****/
-/**********************************************************************/
-
-
-/*
- * Implements glPixelTransfer[fi] whether called immediately or from a
- * display list.
- */
-static void GLAPIENTRY
-_mesa_PixelTransferf( GLenum pname, GLfloat param )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   switch (pname) {
-      case GL_MAP_COLOR:
-         if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
-	 break;
-      case GL_MAP_STENCIL:
-         if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
-	 break;
-      case GL_INDEX_SHIFT:
-         if (ctx->Pixel.IndexShift == (GLint) param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.IndexShift = (GLint) param;
-	 break;
-      case GL_INDEX_OFFSET:
-         if (ctx->Pixel.IndexOffset == (GLint) param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.IndexOffset = (GLint) param;
-	 break;
-      case GL_RED_SCALE:
-         if (ctx->Pixel.RedScale == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.RedScale = param;
-	 break;
-      case GL_RED_BIAS:
-         if (ctx->Pixel.RedBias == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.RedBias = param;
-	 break;
-      case GL_GREEN_SCALE:
-         if (ctx->Pixel.GreenScale == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.GreenScale = param;
-	 break;
-      case GL_GREEN_BIAS:
-         if (ctx->Pixel.GreenBias == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.GreenBias = param;
-	 break;
-      case GL_BLUE_SCALE:
-         if (ctx->Pixel.BlueScale == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.BlueScale = param;
-	 break;
-      case GL_BLUE_BIAS:
-         if (ctx->Pixel.BlueBias == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.BlueBias = param;
-	 break;
-      case GL_ALPHA_SCALE:
-         if (ctx->Pixel.AlphaScale == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.AlphaScale = param;
-	 break;
-      case GL_ALPHA_BIAS:
-         if (ctx->Pixel.AlphaBias == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.AlphaBias = param;
-	 break;
-      case GL_DEPTH_SCALE:
-         if (ctx->Pixel.DepthScale == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.DepthScale = param;
-	 break;
-      case GL_DEPTH_BIAS:
-         if (ctx->Pixel.DepthBias == param)
-	    return;
-	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
-         ctx->Pixel.DepthBias = param;
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
-         return;
-   }
-}
-
-
-static void GLAPIENTRY
-_mesa_PixelTransferi( GLenum pname, GLint param )
-{
-   _mesa_PixelTransferf( pname, (GLfloat) param );
-}
-
-
-
-/**********************************************************************/
-/*****                    State Management                        *****/
-/**********************************************************************/
-
-/*
- * Return a bitmask of IMAGE_*_BIT flags which to indicate which
- * pixel transfer operations are enabled.
- */
-static void
-update_image_transfer_state(struct gl_context *ctx)
-{
-   GLuint mask = 0;
-
-   if (ctx->Pixel.RedScale   != 1.0F || ctx->Pixel.RedBias   != 0.0F ||
-       ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
-       ctx->Pixel.BlueScale  != 1.0F || ctx->Pixel.BlueBias  != 0.0F ||
-       ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
-      mask |= IMAGE_SCALE_BIAS_BIT;
-
-   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
-      mask |= IMAGE_SHIFT_OFFSET_BIT;
-
-   if (ctx->Pixel.MapColorFlag)
-      mask |= IMAGE_MAP_COLOR_BIT;
-
-   ctx->_ImageTransferState = mask;
-}
-
-
-/**
- * Update mesa pixel transfer derived state.
- */
-void _mesa_update_pixel( struct gl_context *ctx, GLuint new_state )
-{
-   if (new_state & _MESA_NEW_TRANSFER_STATE)
-      update_image_transfer_state(ctx);
-}
-
-
-void
-_mesa_init_pixel_dispatch(struct _glapi_table *disp)
-{
-   SET_GetPixelMapfv(disp, _mesa_GetPixelMapfv);
-   SET_GetPixelMapuiv(disp, _mesa_GetPixelMapuiv);
-   SET_GetPixelMapusv(disp, _mesa_GetPixelMapusv);
-   SET_PixelMapfv(disp, _mesa_PixelMapfv);
-   SET_PixelMapuiv(disp, _mesa_PixelMapuiv);
-   SET_PixelMapusv(disp, _mesa_PixelMapusv);
-   SET_PixelTransferf(disp, _mesa_PixelTransferf);
-   SET_PixelTransferi(disp, _mesa_PixelTransferi);
-   SET_PixelZoom(disp, _mesa_PixelZoom);
-}
-
-
-#endif /* FEATURE_pixel_transfer */
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-static void
-init_pixelmap(struct gl_pixelmap *map)
-{
-   map->Size = 1;
-   map->Map[0] = 0.0;
-   map->Map8[0] = 0;
-}
-
-
-/**
- * Initialize the context's PIXEL attribute group.
- */
-void
-_mesa_init_pixel( struct gl_context *ctx )
-{
-   /* Pixel group */
-   ctx->Pixel.RedBias = 0.0;
-   ctx->Pixel.RedScale = 1.0;
-   ctx->Pixel.GreenBias = 0.0;
-   ctx->Pixel.GreenScale = 1.0;
-   ctx->Pixel.BlueBias = 0.0;
-   ctx->Pixel.BlueScale = 1.0;
-   ctx->Pixel.AlphaBias = 0.0;
-   ctx->Pixel.AlphaScale = 1.0;
-   ctx->Pixel.DepthBias = 0.0;
-   ctx->Pixel.DepthScale = 1.0;
-   ctx->Pixel.IndexOffset = 0;
-   ctx->Pixel.IndexShift = 0;
-   ctx->Pixel.ZoomX = 1.0;
-   ctx->Pixel.ZoomY = 1.0;
-   ctx->Pixel.MapColorFlag = GL_FALSE;
-   ctx->Pixel.MapStencilFlag = GL_FALSE;
-   init_pixelmap(&ctx->PixelMaps.StoS);
-   init_pixelmap(&ctx->PixelMaps.ItoI);
-   init_pixelmap(&ctx->PixelMaps.ItoR);
-   init_pixelmap(&ctx->PixelMaps.ItoG);
-   init_pixelmap(&ctx->PixelMaps.ItoB);
-   init_pixelmap(&ctx->PixelMaps.ItoA);
-   init_pixelmap(&ctx->PixelMaps.RtoR);
-   init_pixelmap(&ctx->PixelMaps.GtoG);
-   init_pixelmap(&ctx->PixelMaps.BtoB);
-   init_pixelmap(&ctx->PixelMaps.AtoA);
-
-   if (ctx->Visual.doubleBufferMode) {
-      ctx->Pixel.ReadBuffer = GL_BACK;
-   }
-   else {
-      ctx->Pixel.ReadBuffer = GL_FRONT;
-   }
-
-   /* Miscellaneous */
-   ctx->_ImageTransferState = 0;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file pixel.c

+ * Pixel transfer functions (glPixelZoom, glPixelMap, glPixelTransfer)

+ */

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "colormac.h"

+#include "context.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "pixel.h"

+#include "pbo.h"

+#include "mtypes.h"

+#include "main/dispatch.h"

+

+

+#if FEATURE_pixel_transfer

+

+

+/**********************************************************************/

+/*****                    glPixelZoom                             *****/

+/**********************************************************************/

+

+static void GLAPIENTRY

+_mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (ctx->Pixel.ZoomX == xfactor &&

+       ctx->Pixel.ZoomY == yfactor)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_PIXEL);

+   ctx->Pixel.ZoomX = xfactor;

+   ctx->Pixel.ZoomY = yfactor;

+}

+

+

+

+/**********************************************************************/

+/*****                         glPixelMap                         *****/

+/**********************************************************************/

+

+/**

+ * Return pointer to a pixelmap by name.

+ */

+static struct gl_pixelmap *

+get_pixelmap(struct gl_context *ctx, GLenum map)

+{

+   switch (map) {

+   case GL_PIXEL_MAP_I_TO_I:

+      return &ctx->PixelMaps.ItoI;

+   case GL_PIXEL_MAP_S_TO_S:

+      return &ctx->PixelMaps.StoS;

+   case GL_PIXEL_MAP_I_TO_R:

+      return &ctx->PixelMaps.ItoR;

+   case GL_PIXEL_MAP_I_TO_G:

+      return &ctx->PixelMaps.ItoG;

+   case GL_PIXEL_MAP_I_TO_B:

+      return &ctx->PixelMaps.ItoB;

+   case GL_PIXEL_MAP_I_TO_A:

+      return &ctx->PixelMaps.ItoA;

+   case GL_PIXEL_MAP_R_TO_R:

+      return &ctx->PixelMaps.RtoR;

+   case GL_PIXEL_MAP_G_TO_G:

+      return &ctx->PixelMaps.GtoG;

+   case GL_PIXEL_MAP_B_TO_B:

+      return &ctx->PixelMaps.BtoB;

+   case GL_PIXEL_MAP_A_TO_A:

+      return &ctx->PixelMaps.AtoA;

+   default:

+      return NULL;

+   }

+}

+

+

+/**

+ * Helper routine used by the other _mesa_PixelMap() functions.

+ */

+static void

+store_pixelmap(struct gl_context *ctx, GLenum map, GLsizei mapsize,

+               const GLfloat *values)

+{

+   GLint i;

+   struct gl_pixelmap *pm = get_pixelmap(ctx, map);

+   if (!pm) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelMap(map)");

+      return;

+   }

+

+   switch (map) {

+   case GL_PIXEL_MAP_S_TO_S:

+      /* special case */

+      ctx->PixelMaps.StoS.Size = mapsize;

+      for (i = 0; i < mapsize; i++) {

+         ctx->PixelMaps.StoS.Map[i] = (GLfloat)IROUND(values[i]);

+      }

+      break;

+   case GL_PIXEL_MAP_I_TO_I:

+      /* special case */

+      ctx->PixelMaps.ItoI.Size = mapsize;

+      for (i = 0; i < mapsize; i++) {

+         ctx->PixelMaps.ItoI.Map[i] = values[i];

+      }

+      break;

+   default:

+      /* general case */

+      pm->Size = mapsize;

+      for (i = 0; i < mapsize; i++) {

+         GLfloat val = CLAMP(values[i], 0.0F, 1.0F);

+         pm->Map[i] = val;

+         pm->Map8[i] = (GLint) (val * 255.0F);

+      }

+   }

+}

+

+

+/**

+ * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().

+ */

+static GLboolean

+validate_pbo_access(struct gl_context *ctx, struct gl_pixelstore_attrib *pack,

+                    GLsizei mapsize, GLenum format, GLenum type,

+                    const GLvoid *ptr)

+{

+   GLboolean ok;

+

+   /* Note, need to use DefaultPacking and Unpack's buffer object */

+   _mesa_reference_buffer_object(ctx,

+                                 &ctx->DefaultPacking.BufferObj,

+                                 pack->BufferObj);

+

+   ok = _mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,

+                                  format, type, ptr);

+

+   /* restore */

+   _mesa_reference_buffer_object(ctx,

+                                 &ctx->DefaultPacking.BufferObj,

+                                 ctx->Shared->NullBufferObj);

+

+   if (!ok) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glPixelMap(invalid PBO access)");

+   }

+   return ok;

+}

+

+

+static void GLAPIENTRY

+_mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */

+   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );

+      return;

+   }

+

+   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {

+      /* test that mapsize is a power of two */

+      if (!_mesa_is_pow_two(mapsize)) {

+	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );

+         return;

+      }

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PIXEL);

+

+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,

+                            GL_INTENSITY, GL_FLOAT, values)) {

+      return;

+   }

+

+   values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glPixelMapfv(PBO is mapped)");

+      }

+      return;

+   }

+

+   store_pixelmap(ctx, map, mapsize, values);

+

+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);

+}

+

+

+static void GLAPIENTRY

+_mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )

+{

+   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );

+      return;

+   }

+

+   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {

+      /* test that mapsize is a power of two */

+      if (!_mesa_is_pow_two(mapsize)) {

+	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );

+         return;

+      }

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PIXEL);

+

+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,

+                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {

+      return;

+   }

+

+   values = (const GLuint *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glPixelMapuiv(PBO is mapped)");

+      }

+      return;

+   }

+

+   /* convert to floats */

+   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {

+      GLint i;

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = (GLfloat) values[i];

+      }

+   }

+   else {

+      GLint i;

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = UINT_TO_FLOAT( values[i] );

+      }

+   }

+

+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);

+

+   store_pixelmap(ctx, map, mapsize, fvalues);

+}

+

+

+static void GLAPIENTRY

+_mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )

+{

+   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );

+      return;

+   }

+

+   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {

+      /* test that mapsize is a power of two */

+      if (!_mesa_is_pow_two(mapsize)) {

+	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );

+         return;

+      }

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PIXEL);

+

+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,

+                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {

+      return;

+   }

+

+   values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glPixelMapusv(PBO is mapped)");

+      }

+      return;

+   }

+

+   /* convert to floats */

+   if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {

+      GLint i;

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = (GLfloat) values[i];

+      }

+   }

+   else {

+      GLint i;

+      for (i = 0; i < mapsize; i++) {

+         fvalues[i] = USHORT_TO_FLOAT( values[i] );

+      }

+   }

+

+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);

+

+   store_pixelmap(ctx, map, mapsize, fvalues);

+}

+

+

+static void GLAPIENTRY

+_mesa_GetPixelMapfv( GLenum map, GLfloat *values )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint mapsize, i;

+   const struct gl_pixelmap *pm;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   pm = get_pixelmap(ctx, map);

+   if (!pm) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapfv(map)");

+      return;

+   }

+

+   mapsize = pm->Size;

+

+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,

+                            GL_INTENSITY, GL_FLOAT, values)) {

+      return;

+   }

+

+   values = (GLfloat *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetPixelMapfv(PBO is mapped)");

+      }

+      return;

+   }

+

+   if (map == GL_PIXEL_MAP_S_TO_S) {

+      /* special case */

+      for (i = 0; i < mapsize; i++) {

+         values[i] = (GLfloat) ctx->PixelMaps.StoS.Map[i];

+      }

+   }

+   else {

+      memcpy(values, pm->Map, mapsize * sizeof(GLfloat));

+   }

+

+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);

+}

+

+

+static void GLAPIENTRY

+_mesa_GetPixelMapuiv( GLenum map, GLuint *values )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint mapsize, i;

+   const struct gl_pixelmap *pm;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   pm = get_pixelmap(ctx, map);

+   if (!pm) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapuiv(map)");

+      return;

+   }

+   mapsize = pm->Size;

+

+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,

+                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {

+      return;

+   }

+

+   values = (GLuint *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetPixelMapuiv(PBO is mapped)");

+      }

+      return;

+   }

+

+   if (map == GL_PIXEL_MAP_S_TO_S) {

+      /* special case */

+      memcpy(values, ctx->PixelMaps.StoS.Map, mapsize * sizeof(GLint));

+   }

+   else {

+      for (i = 0; i < mapsize; i++) {

+         values[i] = FLOAT_TO_UINT( pm->Map[i] );

+      }

+   }

+

+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);

+}

+

+

+static void GLAPIENTRY

+_mesa_GetPixelMapusv( GLenum map, GLushort *values )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint mapsize, i;

+   const struct gl_pixelmap *pm;

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   pm = get_pixelmap(ctx, map);

+   if (!pm) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapusv(map)");

+      return;

+   }

+   mapsize = pm->Size;

+

+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,

+                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {

+      return;

+   }

+

+   values = (GLushort *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);

+   if (!values) {

+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetPixelMapusv(PBO is mapped)");

+      }

+      return;

+   }

+

+   switch (map) {

+   /* special cases */

+   case GL_PIXEL_MAP_I_TO_I:

+      for (i = 0; i < mapsize; i++) {

+         values[i] = (GLushort) CLAMP(ctx->PixelMaps.ItoI.Map[i], 0.0, 65535.);

+      }

+      break;

+   case GL_PIXEL_MAP_S_TO_S:

+      for (i = 0; i < mapsize; i++) {

+         values[i] = (GLushort) CLAMP(ctx->PixelMaps.StoS.Map[i], 0.0, 65535.);

+      }

+      break;

+   default:

+      for (i = 0; i < mapsize; i++) {

+         CLAMPED_FLOAT_TO_USHORT(values[i], pm->Map[i] );

+      }

+   }

+

+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);

+}

+

+

+

+/**********************************************************************/

+/*****                       glPixelTransfer                      *****/

+/**********************************************************************/

+

+

+/*

+ * Implements glPixelTransfer[fi] whether called immediately or from a

+ * display list.

+ */

+static void GLAPIENTRY

+_mesa_PixelTransferf( GLenum pname, GLfloat param )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   switch (pname) {

+      case GL_MAP_COLOR:

+         if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;

+	 break;

+      case GL_MAP_STENCIL:

+         if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;

+	 break;

+      case GL_INDEX_SHIFT:

+         if (ctx->Pixel.IndexShift == (GLint) param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.IndexShift = (GLint) param;

+	 break;

+      case GL_INDEX_OFFSET:

+         if (ctx->Pixel.IndexOffset == (GLint) param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.IndexOffset = (GLint) param;

+	 break;

+      case GL_RED_SCALE:

+         if (ctx->Pixel.RedScale == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.RedScale = param;

+	 break;

+      case GL_RED_BIAS:

+         if (ctx->Pixel.RedBias == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.RedBias = param;

+	 break;

+      case GL_GREEN_SCALE:

+         if (ctx->Pixel.GreenScale == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.GreenScale = param;

+	 break;

+      case GL_GREEN_BIAS:

+         if (ctx->Pixel.GreenBias == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.GreenBias = param;

+	 break;

+      case GL_BLUE_SCALE:

+         if (ctx->Pixel.BlueScale == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.BlueScale = param;

+	 break;

+      case GL_BLUE_BIAS:

+         if (ctx->Pixel.BlueBias == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.BlueBias = param;

+	 break;

+      case GL_ALPHA_SCALE:

+         if (ctx->Pixel.AlphaScale == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.AlphaScale = param;

+	 break;

+      case GL_ALPHA_BIAS:

+         if (ctx->Pixel.AlphaBias == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.AlphaBias = param;

+	 break;

+      case GL_DEPTH_SCALE:

+         if (ctx->Pixel.DepthScale == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.DepthScale = param;

+	 break;

+      case GL_DEPTH_BIAS:

+         if (ctx->Pixel.DepthBias == param)

+	    return;

+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);

+         ctx->Pixel.DepthBias = param;

+	 break;

+      default:

+         _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );

+         return;

+   }

+}

+

+

+static void GLAPIENTRY

+_mesa_PixelTransferi( GLenum pname, GLint param )

+{

+   _mesa_PixelTransferf( pname, (GLfloat) param );

+}

+

+

+

+/**********************************************************************/

+/*****                    State Management                        *****/

+/**********************************************************************/

+

+/*

+ * Return a bitmask of IMAGE_*_BIT flags which to indicate which

+ * pixel transfer operations are enabled.

+ */

+static void

+update_image_transfer_state(struct gl_context *ctx)

+{

+   GLuint mask = 0;

+

+   if (ctx->Pixel.RedScale   != 1.0F || ctx->Pixel.RedBias   != 0.0F ||

+       ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||

+       ctx->Pixel.BlueScale  != 1.0F || ctx->Pixel.BlueBias  != 0.0F ||

+       ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)

+      mask |= IMAGE_SCALE_BIAS_BIT;

+

+   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)

+      mask |= IMAGE_SHIFT_OFFSET_BIT;

+

+   if (ctx->Pixel.MapColorFlag)

+      mask |= IMAGE_MAP_COLOR_BIT;

+

+   ctx->_ImageTransferState = mask;

+}

+

+

+/**

+ * Update mesa pixel transfer derived state.

+ */

+void _mesa_update_pixel( struct gl_context *ctx, GLuint new_state )

+{

+   if (new_state & _MESA_NEW_TRANSFER_STATE)

+      update_image_transfer_state(ctx);

+}

+

+

+void

+_mesa_init_pixel_dispatch(struct _glapi_table *disp)

+{

+   SET_GetPixelMapfv(disp, _mesa_GetPixelMapfv);

+   SET_GetPixelMapuiv(disp, _mesa_GetPixelMapuiv);

+   SET_GetPixelMapusv(disp, _mesa_GetPixelMapusv);

+   SET_PixelMapfv(disp, _mesa_PixelMapfv);

+   SET_PixelMapuiv(disp, _mesa_PixelMapuiv);

+   SET_PixelMapusv(disp, _mesa_PixelMapusv);

+   SET_PixelTransferf(disp, _mesa_PixelTransferf);

+   SET_PixelTransferi(disp, _mesa_PixelTransferi);

+   SET_PixelZoom(disp, _mesa_PixelZoom);

+}

+

+

+#endif /* FEATURE_pixel_transfer */

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+static void

+init_pixelmap(struct gl_pixelmap *map)

+{

+   map->Size = 1;

+   map->Map[0] = 0.0;

+   map->Map8[0] = 0;

+}

+

+

+/**

+ * Initialize the context's PIXEL attribute group.

+ */

+void

+_mesa_init_pixel( struct gl_context *ctx )

+{

+   /* Pixel group */

+   ctx->Pixel.RedBias = 0.0;

+   ctx->Pixel.RedScale = 1.0;

+   ctx->Pixel.GreenBias = 0.0;

+   ctx->Pixel.GreenScale = 1.0;

+   ctx->Pixel.BlueBias = 0.0;

+   ctx->Pixel.BlueScale = 1.0;

+   ctx->Pixel.AlphaBias = 0.0;

+   ctx->Pixel.AlphaScale = 1.0;

+   ctx->Pixel.DepthBias = 0.0;

+   ctx->Pixel.DepthScale = 1.0;

+   ctx->Pixel.IndexOffset = 0;

+   ctx->Pixel.IndexShift = 0;

+   ctx->Pixel.ZoomX = 1.0;

+   ctx->Pixel.ZoomY = 1.0;

+   ctx->Pixel.MapColorFlag = GL_FALSE;

+   ctx->Pixel.MapStencilFlag = GL_FALSE;

+   init_pixelmap(&ctx->PixelMaps.StoS);

+   init_pixelmap(&ctx->PixelMaps.ItoI);

+   init_pixelmap(&ctx->PixelMaps.ItoR);

+   init_pixelmap(&ctx->PixelMaps.ItoG);

+   init_pixelmap(&ctx->PixelMaps.ItoB);

+   init_pixelmap(&ctx->PixelMaps.ItoA);

+   init_pixelmap(&ctx->PixelMaps.RtoR);

+   init_pixelmap(&ctx->PixelMaps.GtoG);

+   init_pixelmap(&ctx->PixelMaps.BtoB);

+   init_pixelmap(&ctx->PixelMaps.AtoA);

+

+   if (ctx->Visual.doubleBufferMode) {

+      ctx->Pixel.ReadBuffer = GL_BACK;

+   }

+   else {

+      ctx->Pixel.ReadBuffer = GL_FRONT;

+   }

+

+   /* Miscellaneous */

+   ctx->_ImageTransferState = 0;

+}

diff --git a/mesalib/src/mesa/main/polygon.c b/mesalib/src/mesa/main/polygon.c
index ff4232ecc..3ad375901 100644
--- a/mesalib/src/mesa/main/polygon.c
+++ b/mesalib/src/mesa/main/polygon.c
@@ -1,322 +1,322 @@
-/**
- * \file polygon.c
- * Polygon operations.
- */
-
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "context.h"
-#include "image.h"
-#include "enums.h"
-#include "pack.h"
-#include "pbo.h"
-#include "polygon.h"
-#include "mtypes.h"
-
-
-/**
- * Specify whether to cull front- or back-facing facets.
- *
- * \param mode culling mode.
- *
- * \sa glCullFace().
- *
- * Verifies the parameter and updates gl_polygon_attrib::CullFaceMode. On
- * change, flushes the vertices and notifies the driver via
- * the dd_function_table::CullFace callback.
- */
-void GLAPIENTRY
-_mesa_CullFace( GLenum mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glCullFace %s\n", _mesa_lookup_enum_by_nr(mode));
-
-   if (mode!=GL_FRONT && mode!=GL_BACK && mode!=GL_FRONT_AND_BACK) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glCullFace" );
-      return;
-   }
-
-   if (ctx->Polygon.CullFaceMode == mode)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_POLYGON);
-   ctx->Polygon.CullFaceMode = mode;
-
-   if (ctx->Driver.CullFace)
-      ctx->Driver.CullFace( ctx, mode );
-}
-
-
-/**
- * Define front- and back-facing 
- *
- * \param mode orientation of front-facing polygons.
- *
- * \sa glFrontFace().
- *
- * Verifies the parameter and updates gl_polygon_attrib::FrontFace. On change
- * flushes the vertices and notifies the driver via
- * the dd_function_table::FrontFace callback.
- */
-void GLAPIENTRY
-_mesa_FrontFace( GLenum mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glFrontFace %s\n", _mesa_lookup_enum_by_nr(mode));
-
-   if (mode!=GL_CW && mode!=GL_CCW) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glFrontFace" );
-      return;
-   }
-
-   if (ctx->Polygon.FrontFace == mode)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_POLYGON);
-   ctx->Polygon.FrontFace = mode;
-
-   ctx->Polygon._FrontBit = (GLboolean) (mode == GL_CW);
-
-   if (ctx->Driver.FrontFace)
-      ctx->Driver.FrontFace( ctx, mode );
-}
-
-
-/**
- * Set the polygon rasterization mode.
- *
- * \param face the polygons which \p mode applies to.
- * \param mode how polygons should be rasterized.
- *
- * \sa glPolygonMode(). 
- * 
- * Verifies the parameters and updates gl_polygon_attrib::FrontMode and
- * gl_polygon_attrib::BackMode. On change flushes the vertices and notifies the
- * driver via the dd_function_table::PolygonMode callback.
- */
-void GLAPIENTRY
-_mesa_PolygonMode( GLenum face, GLenum mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glPolygonMode %s %s\n",
-                  _mesa_lookup_enum_by_nr(face),
-                  _mesa_lookup_enum_by_nr(mode));
-
-   if (mode!=GL_POINT && mode!=GL_LINE && mode!=GL_FILL) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(mode)" );
-      return;
-   }
-
-   switch (face) {
-   case GL_FRONT:
-      if (ctx->Polygon.FrontMode == mode)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.FrontMode = mode;
-      break;
-   case GL_FRONT_AND_BACK:
-      if (ctx->Polygon.FrontMode == mode &&
-	  ctx->Polygon.BackMode == mode)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.FrontMode = mode;
-      ctx->Polygon.BackMode = mode;
-      break;
-   case GL_BACK:
-      if (ctx->Polygon.BackMode == mode)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.BackMode = mode;
-      break;
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
-      return;
-   }
-
-   if (ctx->Polygon.FrontMode == GL_FILL && ctx->Polygon.BackMode == GL_FILL)
-      ctx->_TriangleCaps &= ~DD_TRI_UNFILLED;
-   else
-      ctx->_TriangleCaps |= DD_TRI_UNFILLED;
-
-   if (ctx->Driver.PolygonMode)
-      ctx->Driver.PolygonMode(ctx, face, mode);
-}
-
-#if _HAVE_FULL_GL
-
-
-/**
- * This routine updates the ctx->Polygon.Stipple state.
- * If we're getting the stipple data from a PBO, we map the buffer
- * in order to access the data.
- * In any case, we obey the current pixel unpacking parameters when fetching
- * the stipple data.
- *
- * In the future, this routine should be used as a fallback, called via
- * ctx->Driver.PolygonStipple().  We'll have to update all the DRI drivers
- * too.
- */
-void
-_mesa_polygon_stipple(struct gl_context *ctx, const GLubyte *pattern)
-{
-   pattern = _mesa_map_validate_pbo_source(ctx, 2,
-                                           &ctx->Unpack, 32, 32, 1,
-                                           GL_COLOR_INDEX, GL_BITMAP, pattern,
-                                           "glPolygonStipple");
-   if (!pattern)
-      return;
-
-   _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);
-
-   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
-}
-
-
-/**
- * Called by glPolygonStipple.
- */
-void GLAPIENTRY
-_mesa_PolygonStipple( const GLubyte *pattern )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glPolygonStipple\n");
-
-   FLUSH_VERTICES(ctx, _NEW_POLYGONSTIPPLE);
-
-   _mesa_polygon_stipple(ctx, pattern);
-
-   if (ctx->Driver.PolygonStipple)
-      ctx->Driver.PolygonStipple(ctx, pattern);
-}
-
-
-/**
- * Called by glPolygonStipple.
- */
-void GLAPIENTRY
-_mesa_GetPolygonStipple( GLubyte *dest )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glGetPolygonStipple\n");
-
-   dest = _mesa_map_validate_pbo_dest(ctx, 2,
-                                      &ctx->Pack, 32, 32, 1,
-                                      GL_COLOR_INDEX, GL_BITMAP, dest,
-                                      "glGetPolygonStipple");
-   if (!dest)
-      return;
-
-   _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack);
-
-   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
-}
-
-
-void GLAPIENTRY
-_mesa_PolygonOffset( GLfloat factor, GLfloat units )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glPolygonOffset %f %f\n", factor, units);
-
-   if (ctx->Polygon.OffsetFactor == factor &&
-       ctx->Polygon.OffsetUnits == units)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_POLYGON);
-   ctx->Polygon.OffsetFactor = factor;
-   ctx->Polygon.OffsetUnits = units;
-
-   if (ctx->Driver.PolygonOffset)
-      ctx->Driver.PolygonOffset( ctx, factor, units );
-}
-
-
-void GLAPIENTRY
-_mesa_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   /* XXX mult by DepthMaxF here??? */
-   _mesa_PolygonOffset(factor, bias * ctx->DrawBuffer->_DepthMaxF );
-}
-
-#endif
-
-
-/**********************************************************************/
-/** \name Initialization */
-/*@{*/
-
-/**
- * Initialize the context polygon state.
- *
- * \param ctx GL context.
- *
- * Initializes __struct gl_contextRec::Polygon and __struct gl_contextRec::PolygonStipple
- * attribute groups.
- */
-void _mesa_init_polygon( struct gl_context * ctx )
-{
-   /* Polygon group */
-   ctx->Polygon.CullFlag = GL_FALSE;
-   ctx->Polygon.CullFaceMode = GL_BACK;
-   ctx->Polygon.FrontFace = GL_CCW;
-   ctx->Polygon._FrontBit = 0;
-   ctx->Polygon.FrontMode = GL_FILL;
-   ctx->Polygon.BackMode = GL_FILL;
-   ctx->Polygon.SmoothFlag = GL_FALSE;
-   ctx->Polygon.StippleFlag = GL_FALSE;
-   ctx->Polygon.OffsetFactor = 0.0F;
-   ctx->Polygon.OffsetUnits = 0.0F;
-   ctx->Polygon.OffsetPoint = GL_FALSE;
-   ctx->Polygon.OffsetLine = GL_FALSE;
-   ctx->Polygon.OffsetFill = GL_FALSE;
-
-
-   /* Polygon Stipple group */
-   memset( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
-}
-
-/*@}*/
+/**

+ * \file polygon.c

+ * Polygon operations.

+ */

+

+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "context.h"

+#include "image.h"

+#include "enums.h"

+#include "pack.h"

+#include "pbo.h"

+#include "polygon.h"

+#include "mtypes.h"

+

+

+/**

+ * Specify whether to cull front- or back-facing facets.

+ *

+ * \param mode culling mode.

+ *

+ * \sa glCullFace().

+ *

+ * Verifies the parameter and updates gl_polygon_attrib::CullFaceMode. On

+ * change, flushes the vertices and notifies the driver via

+ * the dd_function_table::CullFace callback.

+ */

+void GLAPIENTRY

+_mesa_CullFace( GLenum mode )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glCullFace %s\n", _mesa_lookup_enum_by_nr(mode));

+

+   if (mode!=GL_FRONT && mode!=GL_BACK && mode!=GL_FRONT_AND_BACK) {

+      _mesa_error( ctx, GL_INVALID_ENUM, "glCullFace" );

+      return;

+   }

+

+   if (ctx->Polygon.CullFaceMode == mode)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_POLYGON);

+   ctx->Polygon.CullFaceMode = mode;

+

+   if (ctx->Driver.CullFace)

+      ctx->Driver.CullFace( ctx, mode );

+}

+

+

+/**

+ * Define front- and back-facing 

+ *

+ * \param mode orientation of front-facing polygons.

+ *

+ * \sa glFrontFace().

+ *

+ * Verifies the parameter and updates gl_polygon_attrib::FrontFace. On change

+ * flushes the vertices and notifies the driver via

+ * the dd_function_table::FrontFace callback.

+ */

+void GLAPIENTRY

+_mesa_FrontFace( GLenum mode )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glFrontFace %s\n", _mesa_lookup_enum_by_nr(mode));

+

+   if (mode!=GL_CW && mode!=GL_CCW) {

+      _mesa_error( ctx, GL_INVALID_ENUM, "glFrontFace" );

+      return;

+   }

+

+   if (ctx->Polygon.FrontFace == mode)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_POLYGON);

+   ctx->Polygon.FrontFace = mode;

+

+   ctx->Polygon._FrontBit = (GLboolean) (mode == GL_CW);

+

+   if (ctx->Driver.FrontFace)

+      ctx->Driver.FrontFace( ctx, mode );

+}

+

+

+/**

+ * Set the polygon rasterization mode.

+ *

+ * \param face the polygons which \p mode applies to.

+ * \param mode how polygons should be rasterized.

+ *

+ * \sa glPolygonMode(). 

+ * 

+ * Verifies the parameters and updates gl_polygon_attrib::FrontMode and

+ * gl_polygon_attrib::BackMode. On change flushes the vertices and notifies the

+ * driver via the dd_function_table::PolygonMode callback.

+ */

+void GLAPIENTRY

+_mesa_PolygonMode( GLenum face, GLenum mode )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glPolygonMode %s %s\n",

+                  _mesa_lookup_enum_by_nr(face),

+                  _mesa_lookup_enum_by_nr(mode));

+

+   if (mode!=GL_POINT && mode!=GL_LINE && mode!=GL_FILL) {

+      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(mode)" );

+      return;

+   }

+

+   switch (face) {

+   case GL_FRONT:

+      if (ctx->Polygon.FrontMode == mode)

+	 return;

+      FLUSH_VERTICES(ctx, _NEW_POLYGON);

+      ctx->Polygon.FrontMode = mode;

+      break;

+   case GL_FRONT_AND_BACK:

+      if (ctx->Polygon.FrontMode == mode &&

+	  ctx->Polygon.BackMode == mode)

+	 return;

+      FLUSH_VERTICES(ctx, _NEW_POLYGON);

+      ctx->Polygon.FrontMode = mode;

+      ctx->Polygon.BackMode = mode;

+      break;

+   case GL_BACK:

+      if (ctx->Polygon.BackMode == mode)

+	 return;

+      FLUSH_VERTICES(ctx, _NEW_POLYGON);

+      ctx->Polygon.BackMode = mode;

+      break;

+   default:

+      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );

+      return;

+   }

+

+   if (ctx->Polygon.FrontMode == GL_FILL && ctx->Polygon.BackMode == GL_FILL)

+      ctx->_TriangleCaps &= ~DD_TRI_UNFILLED;

+   else

+      ctx->_TriangleCaps |= DD_TRI_UNFILLED;

+

+   if (ctx->Driver.PolygonMode)

+      ctx->Driver.PolygonMode(ctx, face, mode);

+}

+

+#if _HAVE_FULL_GL

+

+

+/**

+ * This routine updates the ctx->Polygon.Stipple state.

+ * If we're getting the stipple data from a PBO, we map the buffer

+ * in order to access the data.

+ * In any case, we obey the current pixel unpacking parameters when fetching

+ * the stipple data.

+ *

+ * In the future, this routine should be used as a fallback, called via

+ * ctx->Driver.PolygonStipple().  We'll have to update all the DRI drivers

+ * too.

+ */

+void

+_mesa_polygon_stipple(struct gl_context *ctx, const GLubyte *pattern)

+{

+   pattern = _mesa_map_validate_pbo_source(ctx, 2,

+                                           &ctx->Unpack, 32, 32, 1,

+                                           GL_COLOR_INDEX, GL_BITMAP, pattern,

+                                           "glPolygonStipple");

+   if (!pattern)

+      return;

+

+   _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);

+

+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);

+}

+

+

+/**

+ * Called by glPolygonStipple.

+ */

+void GLAPIENTRY

+_mesa_PolygonStipple( const GLubyte *pattern )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glPolygonStipple\n");

+

+   FLUSH_VERTICES(ctx, _NEW_POLYGONSTIPPLE);

+

+   _mesa_polygon_stipple(ctx, pattern);

+

+   if (ctx->Driver.PolygonStipple)

+      ctx->Driver.PolygonStipple(ctx, pattern);

+}

+

+

+/**

+ * Called by glPolygonStipple.

+ */

+void GLAPIENTRY

+_mesa_GetPolygonStipple( GLubyte *dest )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glGetPolygonStipple\n");

+

+   dest = _mesa_map_validate_pbo_dest(ctx, 2,

+                                      &ctx->Pack, 32, 32, 1,

+                                      GL_COLOR_INDEX, GL_BITMAP, dest,

+                                      "glGetPolygonStipple");

+   if (!dest)

+      return;

+

+   _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack);

+

+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);

+}

+

+

+void GLAPIENTRY

+_mesa_PolygonOffset( GLfloat factor, GLfloat units )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE&VERBOSE_API)

+      _mesa_debug(ctx, "glPolygonOffset %f %f\n", factor, units);

+

+   if (ctx->Polygon.OffsetFactor == factor &&

+       ctx->Polygon.OffsetUnits == units)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_POLYGON);

+   ctx->Polygon.OffsetFactor = factor;

+   ctx->Polygon.OffsetUnits = units;

+

+   if (ctx->Driver.PolygonOffset)

+      ctx->Driver.PolygonOffset( ctx, factor, units );

+}

+

+

+void GLAPIENTRY

+_mesa_PolygonOffsetEXT( GLfloat factor, GLfloat bias )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   /* XXX mult by DepthMaxF here??? */

+   _mesa_PolygonOffset(factor, bias * ctx->DrawBuffer->_DepthMaxF );

+}

+

+#endif

+

+

+/**********************************************************************/

+/** \name Initialization */

+/*@{*/

+

+/**

+ * Initialize the context polygon state.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes __struct gl_contextRec::Polygon and __struct gl_contextRec::PolygonStipple

+ * attribute groups.

+ */

+void _mesa_init_polygon( struct gl_context * ctx )

+{

+   /* Polygon group */

+   ctx->Polygon.CullFlag = GL_FALSE;

+   ctx->Polygon.CullFaceMode = GL_BACK;

+   ctx->Polygon.FrontFace = GL_CCW;

+   ctx->Polygon._FrontBit = 0;

+   ctx->Polygon.FrontMode = GL_FILL;

+   ctx->Polygon.BackMode = GL_FILL;

+   ctx->Polygon.SmoothFlag = GL_FALSE;

+   ctx->Polygon.StippleFlag = GL_FALSE;

+   ctx->Polygon.OffsetFactor = 0.0F;

+   ctx->Polygon.OffsetUnits = 0.0F;

+   ctx->Polygon.OffsetPoint = GL_FALSE;

+   ctx->Polygon.OffsetLine = GL_FALSE;

+   ctx->Polygon.OffsetFill = GL_FALSE;

+

+

+   /* Polygon Stipple group */

+   memset( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );

+}

+

+/*@}*/

diff --git a/mesalib/src/mesa/main/queryobj.c b/mesalib/src/mesa/main/queryobj.c
index fa35c6ce5..dc9f18a65 100644
--- a/mesalib/src/mesa/main/queryobj.c
+++ b/mesalib/src/mesa/main/queryobj.c
@@ -1,623 +1,623 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "glheader.h"
-#include "context.h"
-#include "enums.h"
-#include "hash.h"
-#include "imports.h"
-#include "queryobj.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "main/dispatch.h"
-
-
-#if FEATURE_queryobj
-
-
-/**
- * Allocate a new query object.  This is a fallback routine called via
- * ctx->Driver.NewQueryObject().
- * \param ctx - rendering context
- * \param id - the new object's ID
- * \return pointer to new query_object object or NULL if out of memory.
- */
-static struct gl_query_object *
-_mesa_new_query_object(struct gl_context *ctx, GLuint id)
-{
-   struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);
-   (void) ctx;
-   if (q) {
-      q->Id = id;
-      q->Result = 0;
-      q->Active = GL_FALSE;
-      q->Ready = GL_TRUE;   /* correct, see spec */
-   }
-   return q;
-}
-
-
-/**
- * Begin a query.  Software driver fallback.
- * Called via ctx->Driver.BeginQuery().
- */
-static void
-_mesa_begin_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* no-op */
-}
-
-
-/**
- * End a query.  Software driver fallback.
- * Called via ctx->Driver.EndQuery().
- */
-static void
-_mesa_end_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   q->Ready = GL_TRUE;
-}
-
-
-/**
- * Wait for query to complete.  Software driver fallback.
- * Called via ctx->Driver.WaitQuery().
- */
-static void
-_mesa_wait_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* For software drivers, _mesa_end_query() should have completed the query.
-    * For real hardware, implement a proper WaitQuery() driver function,
-    * which may require issuing a flush.
-    */
-   assert(q->Ready);
-}
-
-
-/**
- * Check if a query results are ready.  Software driver fallback.
- * Called via ctx->Driver.CheckQuery().
- */
-static void
-_mesa_check_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* No-op for sw rendering.
-    * HW drivers may need to flush at this time.
-    */
-}
-
-
-/**
- * Delete a query object.  Called via ctx->Driver.DeleteQuery().
- * Not removed from hash table here.
- */
-static void
-_mesa_delete_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   free(q);
-}
-
-
-void
-_mesa_init_query_object_functions(struct dd_function_table *driver)
-{
-   driver->NewQueryObject = _mesa_new_query_object;
-   driver->DeleteQuery = _mesa_delete_query;
-   driver->BeginQuery = _mesa_begin_query;
-   driver->EndQuery = _mesa_end_query;
-   driver->WaitQuery = _mesa_wait_query;
-   driver->CheckQuery = _mesa_check_query;
-}
-
-
-/**
- * Return pointer to the query object binding point for the given target.
- * \return NULL if invalid target, else the address of binding point
- */
-static struct gl_query_object **
-get_query_binding_point(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_SAMPLES_PASSED_ARB:
-      if (ctx->Extensions.ARB_occlusion_query)
-         return &ctx->Query.CurrentOcclusionObject;
-      else
-         return NULL;
-   case GL_ANY_SAMPLES_PASSED:
-      if (ctx->Extensions.ARB_occlusion_query2)
-         return &ctx->Query.CurrentOcclusionObject;
-      else
-         return NULL;
-   case GL_TIME_ELAPSED_EXT:
-      if (ctx->Extensions.EXT_timer_query)
-         return &ctx->Query.CurrentTimerObject;
-      else
-         return NULL;
-#if FEATURE_EXT_transform_feedback
-   case GL_PRIMITIVES_GENERATED:
-      if (ctx->Extensions.EXT_transform_feedback)
-         return &ctx->Query.PrimitivesGenerated;
-      else
-         return NULL;
-   case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-      if (ctx->Extensions.EXT_transform_feedback)
-         return &ctx->Query.PrimitivesWritten;
-      else
-         return NULL;
-#endif
-   default:
-      return NULL;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GenQueriesARB(GLsizei n, GLuint *ids)
-{
-   GLuint first;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGenQueries(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenQueriesARB(n < 0)");
-      return;
-   }
-
-   /* No query objects can be active at this time! */
-   if (ctx->Query.CurrentOcclusionObject ||
-       ctx->Query.CurrentTimerObject) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGenQueriesARB");
-      return;
-   }
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Query.QueryObjects, n);
-   if (first) {
-      GLsizei i;
-      for (i = 0; i < n; i++) {
-         struct gl_query_object *q
-            = ctx->Driver.NewQueryObject(ctx, first + i);
-         if (!q) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenQueriesARB");
-            return;
-         }
-         ids[i] = first + i;
-         _mesa_HashInsert(ctx->Query.QueryObjects, first + i, q);
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteQueriesARB(GLsizei n, const GLuint *ids)
-{
-   GLint i;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDeleeteQueries(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteQueriesARB(n < 0)");
-      return;
-   }
-
-   /* No query objects can be active at this time! */
-   if (ctx->Query.CurrentOcclusionObject ||
-       ctx->Query.CurrentTimerObject) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteQueriesARB");
-      return;
-   }
-
-   for (i = 0; i < n; i++) {
-      if (ids[i] > 0) {
-         struct gl_query_object *q = _mesa_lookup_query_object(ctx, ids[i]);
-         if (q) {
-            ASSERT(!q->Active); /* should be caught earlier */
-            _mesa_HashRemove(ctx->Query.QueryObjects, ids[i]);
-            ctx->Driver.DeleteQuery(ctx, q);
-         }
-      }
-   }
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsQueryARB(GLuint id)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glIsQuery(%u)\n", id);
-
-   if (id && _mesa_lookup_query_object(ctx, id))
-      return GL_TRUE;
-   else
-      return GL_FALSE;
-}
-
-
-static void GLAPIENTRY
-_mesa_BeginQueryARB(GLenum target, GLuint id)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBeginQuery(%s, %u)\n",
-                  _mesa_lookup_enum_by_nr(target), id);
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");
-      return;
-   }
-
-   if (id == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginQueryARB(id==0)");
-      return;
-   }
-
-   q = _mesa_lookup_query_object(ctx, id);
-   if (!q) {
-      /* create new object */
-      q = ctx->Driver.NewQueryObject(ctx, id);
-      if (!q) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQueryARB");
-         return;
-      }
-      _mesa_HashInsert(ctx->Query.QueryObjects, id, q);
-   }
-   else {
-      /* pre-existing object */
-      if (q->Active) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glBeginQueryARB(query already active)");
-         return;
-      }
-   }
-
-   q->Target = target;
-   q->Active = GL_TRUE;
-   q->Result = 0;
-   q->Ready = GL_FALSE;
-
-   /* XXX should probably refcount query objects */
-   *bindpt = q;
-
-   ctx->Driver.BeginQuery(ctx, q);
-}
-
-
-static void GLAPIENTRY
-_mesa_EndQueryARB(GLenum target)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glEndQuery(%s)\n", _mesa_lookup_enum_by_nr(target));
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
-      return;
-   }
-
-   /* XXX should probably refcount query objects */
-   q = *bindpt;
-   *bindpt = NULL;
-
-   if (!q || !q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glEndQueryARB(no matching glBeginQueryARB)");
-      return;
-   }
-
-   q->Active = GL_FALSE;
-   ctx->Driver.EndQuery(ctx, q);
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryiv(%s, %s)\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  _mesa_lookup_enum_by_nr(pname));
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");
-      return;
-   }
-
-   q = *bindpt;
-
-   switch (pname) {
-      case GL_QUERY_COUNTER_BITS_ARB:
-         *params = 8 * sizeof(q->Result);
-         break;
-      case GL_CURRENT_QUERY_ARB:
-         *params = q ? q->Id : 0;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(pname)");
-         return;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectiv(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectivARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         /* if result is too large for returned type, clamp to max value */
-         if (q->Target == GL_ANY_SAMPLES_PASSED) {
-            if (q->Result)
-               *params = GL_TRUE;
-            else
-               *params = GL_FALSE;
-         } else {
-            if (q->Result > 0x7fffffff) {
-               *params = 0x7fffffff;
-            }
-            else {
-               *params = (GLint)q->Result;
-            }
-         }
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectivARB(pname)");
-         return;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectuiv(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectuivARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         /* if result is too large for returned type, clamp to max value */
-         if (q->Target == GL_ANY_SAMPLES_PASSED) {
-            if (q->Result)
-               *params = GL_TRUE;
-            else
-               *params = GL_FALSE;
-         } else {
-            if (q->Result > 0xffffffff) {
-               *params = 0xffffffff;
-            }
-            else {
-               *params = (GLuint)q->Result;
-            }
-         }
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectuivARB(pname)");
-         return;
-   }
-}
-
-
-/**
- * New with GL_EXT_timer_query
- */
-static void GLAPIENTRY
-_mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjecti64v(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectui64vARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         *params = q->Result;
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjecti64vARB(pname)");
-         return;
-   }
-}
-
-
-/**
- * New with GL_EXT_timer_query
- */
-static void GLAPIENTRY
-_mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectui64v(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectuui64vARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         *params = q->Result;
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectui64vARB(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_init_queryobj_dispatch(struct _glapi_table *disp)
-{
-   SET_GenQueriesARB(disp, _mesa_GenQueriesARB);
-   SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);
-   SET_IsQueryARB(disp, _mesa_IsQueryARB);
-   SET_BeginQueryARB(disp, _mesa_BeginQueryARB);
-   SET_EndQueryARB(disp, _mesa_EndQueryARB);
-   SET_GetQueryivARB(disp, _mesa_GetQueryivARB);
-   SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);
-   SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);
-
-   SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);
-   SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);
-}
-
-
-#endif /* FEATURE_queryobj */
-
-
-/**
- * Allocate/init the context state related to query objects.
- */
-void
-_mesa_init_queryobj(struct gl_context *ctx)
-{
-   ctx->Query.QueryObjects = _mesa_NewHashTable();
-   ctx->Query.CurrentOcclusionObject = NULL;
-}
-
-
-/**
- * Callback for deleting a query object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_queryobj_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_query_object *q= (struct gl_query_object *) data;
-   struct gl_context *ctx = (struct gl_context *)userData;
-   ctx->Driver.DeleteQuery(ctx, q);
-}
-
-
-/**
- * Free the context state related to query objects.
- */
-void
-_mesa_free_queryobj_data(struct gl_context *ctx)
-{
-   _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);
-   _mesa_DeleteHashTable(ctx->Query.QueryObjects);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "glheader.h"

+#include "context.h"

+#include "enums.h"

+#include "hash.h"

+#include "imports.h"

+#include "queryobj.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "main/dispatch.h"

+

+

+#if FEATURE_queryobj

+

+

+/**

+ * Allocate a new query object.  This is a fallback routine called via

+ * ctx->Driver.NewQueryObject().

+ * \param ctx - rendering context

+ * \param id - the new object's ID

+ * \return pointer to new query_object object or NULL if out of memory.

+ */

+struct gl_query_object *

+_mesa_new_query_object(struct gl_context *ctx, GLuint id)

+{

+   struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);

+   (void) ctx;

+   if (q) {

+      q->Id = id;

+      q->Result = 0;

+      q->Active = GL_FALSE;

+      q->Ready = GL_TRUE;   /* correct, see spec */

+   }

+   return q;

+}

+

+

+/**

+ * Begin a query.  Software driver fallback.

+ * Called via ctx->Driver.BeginQuery().

+ */

+void

+_mesa_begin_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* no-op */

+}

+

+

+/**

+ * End a query.  Software driver fallback.

+ * Called via ctx->Driver.EndQuery().

+ */

+void

+_mesa_end_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   q->Ready = GL_TRUE;

+}

+

+

+/**

+ * Wait for query to complete.  Software driver fallback.

+ * Called via ctx->Driver.WaitQuery().

+ */

+void

+_mesa_wait_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* For software drivers, _mesa_end_query() should have completed the query.

+    * For real hardware, implement a proper WaitQuery() driver function,

+    * which may require issuing a flush.

+    */

+   assert(q->Ready);

+}

+

+

+/**

+ * Check if a query results are ready.  Software driver fallback.

+ * Called via ctx->Driver.CheckQuery().

+ */

+static void

+_mesa_check_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* No-op for sw rendering.

+    * HW drivers may need to flush at this time.

+    */

+}

+

+

+/**

+ * Delete a query object.  Called via ctx->Driver.DeleteQuery().

+ * Not removed from hash table here.

+ */

+void

+_mesa_delete_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   free(q);

+}

+

+

+void

+_mesa_init_query_object_functions(struct dd_function_table *driver)

+{

+   driver->NewQueryObject = _mesa_new_query_object;

+   driver->DeleteQuery = _mesa_delete_query;

+   driver->BeginQuery = _mesa_begin_query;

+   driver->EndQuery = _mesa_end_query;

+   driver->WaitQuery = _mesa_wait_query;

+   driver->CheckQuery = _mesa_check_query;

+}

+

+

+/**

+ * Return pointer to the query object binding point for the given target.

+ * \return NULL if invalid target, else the address of binding point

+ */

+static struct gl_query_object **

+get_query_binding_point(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_SAMPLES_PASSED_ARB:

+      if (ctx->Extensions.ARB_occlusion_query)

+         return &ctx->Query.CurrentOcclusionObject;

+      else

+         return NULL;

+   case GL_ANY_SAMPLES_PASSED:

+      if (ctx->Extensions.ARB_occlusion_query2)

+         return &ctx->Query.CurrentOcclusionObject;

+      else

+         return NULL;

+   case GL_TIME_ELAPSED_EXT:

+      if (ctx->Extensions.EXT_timer_query)

+         return &ctx->Query.CurrentTimerObject;

+      else

+         return NULL;

+#if FEATURE_EXT_transform_feedback

+   case GL_PRIMITIVES_GENERATED:

+      if (ctx->Extensions.EXT_transform_feedback)

+         return &ctx->Query.PrimitivesGenerated;

+      else

+         return NULL;

+   case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:

+      if (ctx->Extensions.EXT_transform_feedback)

+         return &ctx->Query.PrimitivesWritten;

+      else

+         return NULL;

+#endif

+   default:

+      return NULL;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GenQueriesARB(GLsizei n, GLuint *ids)

+{

+   GLuint first;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGenQueries(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenQueriesARB(n < 0)");

+      return;

+   }

+

+   /* No query objects can be active at this time! */

+   if (ctx->Query.CurrentOcclusionObject ||

+       ctx->Query.CurrentTimerObject) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGenQueriesARB");

+      return;

+   }

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Query.QueryObjects, n);

+   if (first) {

+      GLsizei i;

+      for (i = 0; i < n; i++) {

+         struct gl_query_object *q

+            = ctx->Driver.NewQueryObject(ctx, first + i);

+         if (!q) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenQueriesARB");

+            return;

+         }

+         ids[i] = first + i;

+         _mesa_HashInsert(ctx->Query.QueryObjects, first + i, q);

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteQueriesARB(GLsizei n, const GLuint *ids)

+{

+   GLint i;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDeleeteQueries(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteQueriesARB(n < 0)");

+      return;

+   }

+

+   /* No query objects can be active at this time! */

+   if (ctx->Query.CurrentOcclusionObject ||

+       ctx->Query.CurrentTimerObject) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteQueriesARB");

+      return;

+   }

+

+   for (i = 0; i < n; i++) {

+      if (ids[i] > 0) {

+         struct gl_query_object *q = _mesa_lookup_query_object(ctx, ids[i]);

+         if (q) {

+            ASSERT(!q->Active); /* should be caught earlier */

+            _mesa_HashRemove(ctx->Query.QueryObjects, ids[i]);

+            ctx->Driver.DeleteQuery(ctx, q);

+         }

+      }

+   }

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsQueryARB(GLuint id)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glIsQuery(%u)\n", id);

+

+   if (id && _mesa_lookup_query_object(ctx, id))

+      return GL_TRUE;

+   else

+      return GL_FALSE;

+}

+

+

+static void GLAPIENTRY

+_mesa_BeginQueryARB(GLenum target, GLuint id)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBeginQuery(%s, %u)\n",

+                  _mesa_lookup_enum_by_nr(target), id);

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");

+      return;

+   }

+

+   if (id == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginQueryARB(id==0)");

+      return;

+   }

+

+   q = _mesa_lookup_query_object(ctx, id);

+   if (!q) {

+      /* create new object */

+      q = ctx->Driver.NewQueryObject(ctx, id);

+      if (!q) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQueryARB");

+         return;

+      }

+      _mesa_HashInsert(ctx->Query.QueryObjects, id, q);

+   }

+   else {

+      /* pre-existing object */

+      if (q->Active) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glBeginQueryARB(query already active)");

+         return;

+      }

+   }

+

+   q->Target = target;

+   q->Active = GL_TRUE;

+   q->Result = 0;

+   q->Ready = GL_FALSE;

+

+   /* XXX should probably refcount query objects */

+   *bindpt = q;

+

+   ctx->Driver.BeginQuery(ctx, q);

+}

+

+

+static void GLAPIENTRY

+_mesa_EndQueryARB(GLenum target)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glEndQuery(%s)\n", _mesa_lookup_enum_by_nr(target));

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");

+      return;

+   }

+

+   /* XXX should probably refcount query objects */

+   q = *bindpt;

+   *bindpt = NULL;

+

+   if (!q || !q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glEndQueryARB(no matching glBeginQueryARB)");

+      return;

+   }

+

+   q->Active = GL_FALSE;

+   ctx->Driver.EndQuery(ctx, q);

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryiv(%s, %s)\n",

+                  _mesa_lookup_enum_by_nr(target),

+                  _mesa_lookup_enum_by_nr(pname));

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");

+      return;

+   }

+

+   q = *bindpt;

+

+   switch (pname) {

+      case GL_QUERY_COUNTER_BITS_ARB:

+         *params = 8 * sizeof(q->Result);

+         break;

+      case GL_CURRENT_QUERY_ARB:

+         *params = q ? q->Id : 0;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(pname)");

+         return;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectiv(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectivARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         /* if result is too large for returned type, clamp to max value */

+         if (q->Target == GL_ANY_SAMPLES_PASSED) {

+            if (q->Result)

+               *params = GL_TRUE;

+            else

+               *params = GL_FALSE;

+         } else {

+            if (q->Result > 0x7fffffff) {

+               *params = 0x7fffffff;

+            }

+            else {

+               *params = (GLint)q->Result;

+            }

+         }

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectivARB(pname)");

+         return;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectuiv(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectuivARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         /* if result is too large for returned type, clamp to max value */

+         if (q->Target == GL_ANY_SAMPLES_PASSED) {

+            if (q->Result)

+               *params = GL_TRUE;

+            else

+               *params = GL_FALSE;

+         } else {

+            if (q->Result > 0xffffffff) {

+               *params = 0xffffffff;

+            }

+            else {

+               *params = (GLuint)q->Result;

+            }

+         }

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectuivARB(pname)");

+         return;

+   }

+}

+

+

+/**

+ * New with GL_EXT_timer_query

+ */

+static void GLAPIENTRY

+_mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjecti64v(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectui64vARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         *params = q->Result;

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjecti64vARB(pname)");

+         return;

+   }

+}

+

+

+/**

+ * New with GL_EXT_timer_query

+ */

+static void GLAPIENTRY

+_mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectui64v(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectuui64vARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         *params = q->Result;

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectui64vARB(pname)");

+         return;

+   }

+}

+

+

+void

+_mesa_init_queryobj_dispatch(struct _glapi_table *disp)

+{

+   SET_GenQueriesARB(disp, _mesa_GenQueriesARB);

+   SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);

+   SET_IsQueryARB(disp, _mesa_IsQueryARB);

+   SET_BeginQueryARB(disp, _mesa_BeginQueryARB);

+   SET_EndQueryARB(disp, _mesa_EndQueryARB);

+   SET_GetQueryivARB(disp, _mesa_GetQueryivARB);

+   SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);

+   SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);

+

+   SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);

+   SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);

+}

+

+

+#endif /* FEATURE_queryobj */

+

+

+/**

+ * Allocate/init the context state related to query objects.

+ */

+void

+_mesa_init_queryobj(struct gl_context *ctx)

+{

+   ctx->Query.QueryObjects = _mesa_NewHashTable();

+   ctx->Query.CurrentOcclusionObject = NULL;

+}

+

+

+/**

+ * Callback for deleting a query object.  Called by _mesa_HashDeleteAll().

+ */

+static void

+delete_queryobj_cb(GLuint id, void *data, void *userData)

+{

+   struct gl_query_object *q= (struct gl_query_object *) data;

+   struct gl_context *ctx = (struct gl_context *)userData;

+   ctx->Driver.DeleteQuery(ctx, q);

+}

+

+

+/**

+ * Free the context state related to query objects.

+ */

+void

+_mesa_free_queryobj_data(struct gl_context *ctx)

+{

+   _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);

+   _mesa_DeleteHashTable(ctx->Query.QueryObjects);

+}

diff --git a/mesalib/src/mesa/main/readpix.c b/mesalib/src/mesa/main/readpix.c
index 6e09a52c8..e8b889d92 100644
--- a/mesalib/src/mesa/main/readpix.c
+++ b/mesalib/src/mesa/main/readpix.c
@@ -1,244 +1,244 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "glheader.h"
-#include "imports.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "enums.h"
-#include "readpix.h"
-#include "framebuffer.h"
-#include "formats.h"
-#include "image.h"
-#include "mtypes.h"
-#include "pbo.h"
-#include "state.h"
-
-
-/**
- * Do error checking of the format/type parameters to glReadPixels and
- * glDrawPixels.
- * \param drawing if GL_TRUE do checking for DrawPixels, else do checking
- *                for ReadPixels.
- * \return GL_TRUE if error detected, GL_FALSE if no errors
- */
-GLboolean
-_mesa_error_check_format_type(struct gl_context *ctx, GLenum format, GLenum type,
-                              GLboolean drawing)
-{
-   const char *readDraw = drawing ? "Draw" : "Read";
-   const GLboolean reading = !drawing;
-
-   /* state validation should have already been done */
-   ASSERT(ctx->NewState == 0x0);
-
-   if (ctx->Extensions.EXT_packed_depth_stencil
-       && type == GL_UNSIGNED_INT_24_8_EXT
-       && format != GL_DEPTH_STENCIL_EXT) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "gl%sPixels(format is not GL_DEPTH_STENCIL_EXT)", readDraw);
-      return GL_TRUE;
-   }
-
-   /* basic combinations test */
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "gl%sPixels(format or type)", readDraw);
-      return GL_TRUE;
-   }
-
-   /* additional checks */
-   switch (format) {
-   case GL_RG:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE_ALPHA:
-   case GL_RGB:
-   case GL_BGR:
-   case GL_RGBA:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      if (!drawing) {
-         /* reading */
-         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glReadPixels(no color buffer)");
-            return GL_TRUE;
-         }
-      }
-      break;
-   case GL_COLOR_INDEX:
-      if (drawing) {
-         if (ctx->PixelMaps.ItoR.Size == 0 ||
-	     ctx->PixelMaps.ItoG.Size == 0 ||
-	     ctx->PixelMaps.ItoB.Size == 0) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                   "glDrawPixels(drawing color index pixels into RGB buffer)");
-            return GL_TRUE;
-         }
-      }
-      else {
-         /* reading */
-         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glReadPixels(no color buffer)");
-            return GL_TRUE;
-         }
-         /* We no longer support CI-mode color buffers so trying to read
-          * GL_COLOR_INDEX pixels is always an error.
-          */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glReadPixels(color buffer is RGB)");
-         return GL_TRUE;
-      }
-      break;
-   case GL_STENCIL_INDEX:
-      if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
-          (reading && !_mesa_source_buffer_exists(ctx, format))) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "gl%sPixels(no stencil buffer)", readDraw);
-         return GL_TRUE;
-      }
-      break;
-   case GL_DEPTH_COMPONENT:
-      if ((drawing && !_mesa_dest_buffer_exists(ctx, format))) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "gl%sPixels(no depth buffer)", readDraw);
-         return GL_TRUE;
-      }
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      if (!ctx->Extensions.EXT_packed_depth_stencil ||
-          type != GL_UNSIGNED_INT_24_8_EXT) {
-         _mesa_error(ctx, GL_INVALID_ENUM, "gl%sPixels(type)", readDraw);
-         return GL_TRUE;
-      }
-      if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
-          (reading && !_mesa_source_buffer_exists(ctx, format))) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "gl%sPixels(no depth or stencil buffer)", readDraw);
-         return GL_TRUE;
-      }
-      break;
-   default:
-      /* this should have been caught in _mesa_is_legal_format_type() */
-      _mesa_problem(ctx, "unexpected format in _mesa_%sPixels", readDraw);
-      return GL_TRUE;
-   }
-
-   /* no errors */
-   return GL_FALSE;
-}
-      
-
-
-void GLAPIENTRY
-_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
-		  GLenum format, GLenum type, GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   FLUSH_CURRENT(ctx, 0);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glReadPixels(%d, %d, %s, %s, %p)\n",
-                  width, height,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type),
-                  pixels);
-
-   if (width < 0 || height < 0) {
-      _mesa_error( ctx, GL_INVALID_VALUE,
-                   "glReadPixels(width=%d height=%d)", width, height );
-      return;
-   }
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   if (_mesa_error_check_format_type(ctx, format, type, GL_FALSE)) {
-      /* found an error */
-      return;
-   }
-
-   /* Check that the destination format and source buffer are both
-    * integer-valued or both non-integer-valued.
-    */
-   if (ctx->Extensions.EXT_texture_integer && _mesa_is_color_format(format)) {
-      const struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-      const GLboolean srcInteger = _mesa_is_format_integer_color(rb->Format);
-      const GLboolean dstInteger = _mesa_is_integer_format(format);
-      if (dstInteger != srcInteger) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glReadPixels(integer / non-integer format mismatch");
-         return;
-      }
-   }
-
-   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "glReadPixels(incomplete framebuffer)" );
-      return;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, format)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(no readbuffer)");
-      return;
-   }
-
-   if (width == 0 || height == 0)
-      return; /* nothing to do */
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glReadPixels(invalid PBO access)");
-         return;
-      }
-
-      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
-         /* buffer is mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)");
-         return;
-      }
-   }
-
-   ctx->Driver.ReadPixels(ctx, x, y, width, height,
-			  format, type, &ctx->Pack, pixels);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+#include "glheader.h"

+#include "imports.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "enums.h"

+#include "readpix.h"

+#include "framebuffer.h"

+#include "formats.h"

+#include "image.h"

+#include "mtypes.h"

+#include "pbo.h"

+#include "state.h"

+

+

+/**

+ * Do error checking of the format/type parameters to glReadPixels and

+ * glDrawPixels.

+ * \param drawing if GL_TRUE do checking for DrawPixels, else do checking

+ *                for ReadPixels.

+ * \return GL_TRUE if error detected, GL_FALSE if no errors

+ */

+GLboolean

+_mesa_error_check_format_type(struct gl_context *ctx, GLenum format, GLenum type,

+                              GLboolean drawing)

+{

+   const char *readDraw = drawing ? "Draw" : "Read";

+   const GLboolean reading = !drawing;

+

+   /* state validation should have already been done */

+   ASSERT(ctx->NewState == 0x0);

+

+   if (ctx->Extensions.EXT_packed_depth_stencil

+       && type == GL_UNSIGNED_INT_24_8_EXT

+       && format != GL_DEPTH_STENCIL_EXT) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "gl%sPixels(format is not GL_DEPTH_STENCIL_EXT)", readDraw);

+      return GL_TRUE;

+   }

+

+   /* basic combinations test */

+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "gl%sPixels(format or type)", readDraw);

+      return GL_TRUE;

+   }

+

+   /* additional checks */

+   switch (format) {

+   case GL_RG:

+   case GL_RED:

+   case GL_GREEN:

+   case GL_BLUE:

+   case GL_ALPHA:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE_ALPHA:

+   case GL_RGB:

+   case GL_BGR:

+   case GL_RGBA:

+   case GL_BGRA:

+   case GL_ABGR_EXT:

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      if (!drawing) {

+         /* reading */

+         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                        "glReadPixels(no color buffer)");

+            return GL_TRUE;

+         }

+      }

+      break;

+   case GL_COLOR_INDEX:

+      if (drawing) {

+         if (ctx->PixelMaps.ItoR.Size == 0 ||

+	     ctx->PixelMaps.ItoG.Size == 0 ||

+	     ctx->PixelMaps.ItoB.Size == 0) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                   "glDrawPixels(drawing color index pixels into RGB buffer)");

+            return GL_TRUE;

+         }

+      }

+      else {

+         /* reading */

+         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                        "glReadPixels(no color buffer)");

+            return GL_TRUE;

+         }

+         /* We no longer support CI-mode color buffers so trying to read

+          * GL_COLOR_INDEX pixels is always an error.

+          */

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glReadPixels(color buffer is RGB)");

+         return GL_TRUE;

+      }

+      break;

+   case GL_STENCIL_INDEX:

+      if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||

+          (reading && !_mesa_source_buffer_exists(ctx, format))) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "gl%sPixels(no stencil buffer)", readDraw);

+         return GL_TRUE;

+      }

+      break;

+   case GL_DEPTH_COMPONENT:

+      if ((drawing && !_mesa_dest_buffer_exists(ctx, format))) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "gl%sPixels(no depth buffer)", readDraw);

+         return GL_TRUE;

+      }

+      break;

+   case GL_DEPTH_STENCIL_EXT:

+      if (!ctx->Extensions.EXT_packed_depth_stencil ||

+          type != GL_UNSIGNED_INT_24_8_EXT) {

+         _mesa_error(ctx, GL_INVALID_ENUM, "gl%sPixels(type)", readDraw);

+         return GL_TRUE;

+      }

+      if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||

+          (reading && !_mesa_source_buffer_exists(ctx, format))) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "gl%sPixels(no depth or stencil buffer)", readDraw);

+         return GL_TRUE;

+      }

+      break;

+   default:

+      /* this should have been caught in _mesa_is_legal_format_type() */

+      _mesa_problem(ctx, "unexpected format in _mesa_%sPixels", readDraw);

+      return GL_TRUE;

+   }

+

+   /* no errors */

+   return GL_FALSE;

+}

+      

+

+

+void GLAPIENTRY

+_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,

+		  GLenum format, GLenum type, GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   FLUSH_CURRENT(ctx, 0);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glReadPixels(%d, %d, %s, %s, %p)\n",

+                  width, height,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type),

+                  pixels);

+

+   if (width < 0 || height < 0) {

+      _mesa_error( ctx, GL_INVALID_VALUE,

+                   "glReadPixels(width=%d height=%d)", width, height );

+      return;

+   }

+

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   if (_mesa_error_check_format_type(ctx, format, type, GL_FALSE)) {

+      /* found an error */

+      return;

+   }

+

+   /* Check that the destination format and source buffer are both

+    * integer-valued or both non-integer-valued.

+    */

+   if (ctx->Extensions.EXT_texture_integer && _mesa_is_color_format(format)) {

+      const struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;

+      const GLboolean srcInteger = _mesa_is_format_integer_color(rb->Format);

+      const GLboolean dstInteger = _mesa_is_integer_format(format);

+      if (dstInteger != srcInteger) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glReadPixels(integer / non-integer format mismatch");

+         return;

+      }

+   }

+

+   if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                  "glReadPixels(incomplete framebuffer)" );

+      return;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, format)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(no readbuffer)");

+      return;

+   }

+

+   if (width == 0 || height == 0)

+      return; /* nothing to do */

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1,

+                                     format, type, pixels)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glReadPixels(invalid PBO access)");

+         return;

+      }

+

+      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {

+         /* buffer is mapped - that's an error */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)");

+         return;

+      }

+   }

+

+   ctx->Driver.ReadPixels(ctx, x, y, width, height,

+			  format, type, &ctx->Pack, pixels);

+}

diff --git a/mesalib/src/mesa/main/shaderapi.c b/mesalib/src/mesa/main/shaderapi.c
index 11b0f884f..252cda845 100644
--- a/mesalib/src/mesa/main/shaderapi.c
+++ b/mesalib/src/mesa/main/shaderapi.c
@@ -1,1942 +1,1942 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009-2010  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file shaderapi.c
- * \author Brian Paul
- *
- * Implementation of GLSL-related API functions.
- * The glUniform* functions are in uniforms.c
- *
- *
- * XXX things to do:
- * 1. Check that the right error code is generated for all _mesa_error() calls.
- * 2. Insert FLUSH_VERTICES calls in various places
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/dispatch.h"
-#include "main/enums.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/shaderapi.h"
-#include "main/shaderobj.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "program/prog_uniform.h"
-#include "ralloc.h"
-#include <stdbool.h>
-#include "../glsl/glsl_parser_extras.h"
-
-/** Define this to enable shader substitution (see below) */
-#define SHADER_SUBST 0
-
-
-/**
- * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
- */
-static GLbitfield
-get_shader_flags(void)
-{
-   GLbitfield flags = 0x0;
-   const char *env = _mesa_getenv("MESA_GLSL");
-
-   if (env) {
-      if (strstr(env, "dump"))
-         flags |= GLSL_DUMP;
-      if (strstr(env, "log"))
-         flags |= GLSL_LOG;
-      if (strstr(env, "nopvert"))
-         flags |= GLSL_NOP_VERT;
-      if (strstr(env, "nopfrag"))
-         flags |= GLSL_NOP_FRAG;
-      if (strstr(env, "nopt"))
-         flags |= GLSL_NO_OPT;
-      else if (strstr(env, "opt"))
-         flags |= GLSL_OPT;
-      if (strstr(env, "uniform"))
-         flags |= GLSL_UNIFORMS;
-      if (strstr(env, "useprog"))
-         flags |= GLSL_USE_PROG;
-   }
-
-   return flags;
-}
-
-
-/**
- * Initialize context's shader state.
- */
-void
-_mesa_init_shader_state(struct gl_context *ctx)
-{
-   /* Device drivers may override these to control what kind of instructions
-    * are generated by the GLSL compiler.
-    */
-   struct gl_shader_compiler_options options;
-   gl_shader_type sh;
-
-   memset(&options, 0, sizeof(options));
-   options.MaxUnrollIterations = 32;
-
-   /* Default pragma settings */
-   options.DefaultPragmas.Optimize = GL_TRUE;
-
-   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)
-      memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
-
-   ctx->Shader.Flags = get_shader_flags();
-}
-
-
-/**
- * Free the per-context shader-related state.
- */
-void
-_mesa_free_shader_state(struct gl_context *ctx)
-{
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,
-				  NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,
-				  NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
-}
-
-
-/**
- * Return the size of the given GLSL datatype, in floats (components).
- */
-GLint
-_mesa_sizeof_glsl_type(GLenum type)
-{
-   switch (type) {
-   case GL_FLOAT:
-   case GL_INT:
-   case GL_BOOL:
-   case GL_SAMPLER_1D:
-   case GL_SAMPLER_2D:
-   case GL_SAMPLER_3D:
-   case GL_SAMPLER_CUBE:
-   case GL_SAMPLER_1D_SHADOW:
-   case GL_SAMPLER_2D_SHADOW:
-   case GL_SAMPLER_2D_RECT_ARB:
-   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
-   case GL_SAMPLER_1D_ARRAY_EXT:
-   case GL_SAMPLER_2D_ARRAY_EXT:
-   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
-   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
-   case GL_SAMPLER_CUBE_SHADOW_EXT:
-      return 1;
-   case GL_FLOAT_VEC2:
-   case GL_INT_VEC2:
-   case GL_UNSIGNED_INT_VEC2:
-   case GL_BOOL_VEC2:
-      return 2;
-   case GL_FLOAT_VEC3:
-   case GL_INT_VEC3:
-   case GL_UNSIGNED_INT_VEC3:
-   case GL_BOOL_VEC3:
-      return 3;
-   case GL_FLOAT_VEC4:
-   case GL_INT_VEC4:
-   case GL_UNSIGNED_INT_VEC4:
-   case GL_BOOL_VEC4:
-      return 4;
-   case GL_FLOAT_MAT2:
-   case GL_FLOAT_MAT2x3:
-   case GL_FLOAT_MAT2x4:
-      return 8; /* two float[4] vectors */
-   case GL_FLOAT_MAT3:
-   case GL_FLOAT_MAT3x2:
-   case GL_FLOAT_MAT3x4:
-      return 12; /* three float[4] vectors */
-   case GL_FLOAT_MAT4:
-   case GL_FLOAT_MAT4x2:
-   case GL_FLOAT_MAT4x3:
-      return 16;  /* four float[4] vectors */
-   default:
-      _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");
-      return 1;
-   }
-}
-
-
-/**
- * Copy string from <src> to <dst>, up to maxLength characters, returning
- * length of <dst> in <length>.
- * \param src  the strings source
- * \param maxLength  max chars to copy
- * \param length  returns number of chars copied
- * \param dst  the string destination
- */
-void
-_mesa_copy_string(GLchar *dst, GLsizei maxLength,
-                  GLsizei *length, const GLchar *src)
-{
-   GLsizei len;
-   for (len = 0; len < maxLength - 1 && src && src[len]; len++)
-      dst[len] = src[len];
-   if (maxLength > 0)
-      dst[len] = 0;
-   if (length)
-      *length = len;
-}
-
-
-
-/**
- * Confirm that the a shader type is valid and supported by the implementation
- *
- * \param ctx   Current GL context
- * \param type  Shader target
- *
- */
-static bool
-validate_shader_target(const struct gl_context *ctx, GLenum type)
-{
-   switch (type) {
-#if FEATURE_ARB_fragment_shader
-   case GL_FRAGMENT_SHADER:
-      return ctx->Extensions.ARB_fragment_shader;
-#endif
-#if FEATURE_ARB_vertex_shader
-   case GL_VERTEX_SHADER:
-      return ctx->Extensions.ARB_vertex_shader;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_SHADER_ARB:
-      return ctx->Extensions.ARB_geometry_shader4;
-#endif
-   default:
-      return false;
-   }
-}
-
-
-/**
- * Find the length of the longest transform feedback varying name
- * which was specified with glTransformFeedbackVaryings().
- */
-static GLint
-longest_feedback_varying_name(const struct gl_shader_program *shProg)
-{
-   GLuint i;
-   GLint max = 0;
-   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
-      GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);
-      if (len > max)
-         max = len;
-   }
-   return max;
-}
-
-
-
-static GLboolean
-is_program(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
-   return shProg ? GL_TRUE : GL_FALSE;
-}
-
-
-static GLboolean
-is_shader(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
-   return shader ? GL_TRUE : GL_FALSE;
-}
-
-
-/**
- * Attach shader to a shader program.
- */
-static void
-attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
-{
-   struct gl_shader_program *shProg;
-   struct gl_shader *sh;
-   GLuint i, n;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
-   if (!shProg)
-      return;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
-   if (!sh) {
-      return;
-   }
-
-   n = shProg->NumShaders;
-   for (i = 0; i < n; i++) {
-      if (shProg->Shaders[i] == sh) {
-         /* The shader is already attched to this program.  The
-          * GL_ARB_shader_objects spec says:
-          *
-          *     "The error INVALID_OPERATION is generated by AttachObjectARB
-          *     if <obj> is already attached to <containerObj>."
-          */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
-         return;
-      }
-   }
-
-   /* grow list */
-   shProg->Shaders = (struct gl_shader **)
-      _mesa_realloc(shProg->Shaders,
-                    n * sizeof(struct gl_shader *),
-                    (n + 1) * sizeof(struct gl_shader *));
-   if (!shProg->Shaders) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
-      return;
-   }
-
-   /* append */
-   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
-   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
-   shProg->NumShaders++;
-}
-
-
-static GLint
-get_attrib_location(struct gl_context *ctx, GLuint program, const GLchar *name)
-{
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
-
-   if (!shProg) {
-      return -1;
-   }
-
-   if (!shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetAttribLocation(program not linked)");
-      return -1;
-   }
-
-   if (!name)
-      return -1;
-
-   if (shProg->VertexProgram) {
-      const struct gl_program_parameter_list *attribs =
-         shProg->VertexProgram->Base.Attributes;
-      if (attribs) {
-         GLint i = _mesa_lookup_parameter_index(attribs, -1, name);
-         if (i >= 0) {
-            return attribs->Parameters[i].StateIndexes[0];
-         }
-      }
-   }
-   return -1;
-}
-
-
-static void
-bind_attrib_location(struct gl_context *ctx, GLuint program, GLuint index,
-                     const GLchar *name)
-{
-   struct gl_shader_program *shProg;
-   const GLint size = -1; /* unknown size */
-   GLint i, oldIndex;
-   GLenum datatype = GL_FLOAT_VEC4;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program,
-                                            "glBindAttribLocation");
-   if (!shProg) {
-      return;
-   }
-
-   if (!name)
-      return;
-
-   if (strncmp(name, "gl_", 3) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glBindAttribLocation(illegal name)");
-      return;
-   }
-
-   if (index >= ctx->Const.VertexProgram.MaxAttribs) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
-      return;
-   }
-
-   if (shProg->LinkStatus) {
-      /* get current index/location for the attribute */
-      oldIndex = get_attrib_location(ctx, program, name);
-   }
-   else {
-      oldIndex = -1;
-   }
-
-   /* this will replace the current value if it's already in the list */
-   i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
-   if (i < 0) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
-      return;
-   }
-
-   /*
-    * Note that this attribute binding won't go into effect until
-    * glLinkProgram is called again.
-    */
-}
-
-
-static void
-bind_frag_data_location(struct gl_context *ctx, GLuint program,
-                        GLuint colorNumber, const GLchar *name)
-{
-   _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");
-}
-
-
-static GLuint
-create_shader(struct gl_context *ctx, GLenum type)
-{
-   struct gl_shader *sh;
-   GLuint name;
-
-   if (!validate_shader_target(ctx, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
-      return 0;
-   }
-
-   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
-   sh = ctx->Driver.NewShader(ctx, name, type);
-   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
-
-   return name;
-}
-
-
-static GLuint 
-create_shader_program(struct gl_context *ctx)
-{
-   GLuint name;
-   struct gl_shader_program *shProg;
-
-   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
-
-   shProg = ctx->Driver.NewShaderProgram(ctx, name);
-
-   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
-
-   assert(shProg->RefCount == 1);
-
-   return name;
-}
-
-
-/**
- * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
- * DeleteProgramARB.
- */
-static void
-delete_shader_program(struct gl_context *ctx, GLuint name)
-{
-   /*
-    * NOTE: deleting shaders/programs works a bit differently than
-    * texture objects (and buffer objects, etc).  Shader/program
-    * handles/IDs exist in the hash table until the object is really
-    * deleted (refcount==0).  With texture objects, the handle/ID is
-    * removed from the hash table in glDeleteTextures() while the tex
-    * object itself might linger until its refcount goes to zero.
-    */
-   struct gl_shader_program *shProg;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
-   if (!shProg)
-      return;
-
-   shProg->DeletePending = GL_TRUE;
-
-   /* effectively, decr shProg's refcount */
-   _mesa_reference_shader_program(ctx, &shProg, NULL);
-}
-
-
-static void
-delete_shader(struct gl_context *ctx, GLuint shader)
-{
-   struct gl_shader *sh;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
-   if (!sh)
-      return;
-
-   sh->DeletePending = GL_TRUE;
-
-   /* effectively, decr sh's refcount */
-   _mesa_reference_shader(ctx, &sh, NULL);
-}
-
-
-static void
-detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
-{
-   struct gl_shader_program *shProg;
-   GLuint n;
-   GLuint i, j;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
-   if (!shProg)
-      return;
-
-   n = shProg->NumShaders;
-
-   for (i = 0; i < n; i++) {
-      if (shProg->Shaders[i]->Name == shader) {
-         /* found it */
-         struct gl_shader **newList;
-
-         /* release */
-         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
-
-         /* alloc new, smaller array */
-         newList = (struct gl_shader **)
-            malloc((n - 1) * sizeof(struct gl_shader *));
-         if (!newList) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
-            return;
-         }
-         for (j = 0; j < i; j++) {
-            newList[j] = shProg->Shaders[j];
-         }
-         while (++i < n)
-            newList[j++] = shProg->Shaders[i];
-         free(shProg->Shaders);
-
-         shProg->Shaders = newList;
-         shProg->NumShaders = n - 1;
-
-#ifdef DEBUG
-         /* sanity check */
-         {
-            for (j = 0; j < shProg->NumShaders; j++) {
-               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
-                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
-               assert(shProg->Shaders[j]->RefCount > 0);
-            }
-         }
-#endif
-
-         return;
-      }
-   }
-
-   /* not found */
-   {
-      GLenum err;
-      if (is_shader(ctx, shader))
-         err = GL_INVALID_OPERATION;
-      else if (is_program(ctx, shader))
-         err = GL_INVALID_OPERATION;
-      else
-         err = GL_INVALID_VALUE;
-      _mesa_error(ctx, err, "glDetachProgram(shader)");
-      return;
-   }
-}
-
-
-static void
-get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,
-                  GLsizei maxLength, GLsizei *length, GLint *size,
-                  GLenum *type, GLchar *nameOut)
-{
-   const struct gl_program_parameter_list *attribs = NULL;
-   struct gl_shader_program *shProg;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
-   if (!shProg)
-      return;
-
-   if (shProg->VertexProgram)
-      attribs = shProg->VertexProgram->Base.Attributes;
-
-   if (!attribs || index >= attribs->NumParameters) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
-      return;
-   }
-
-   _mesa_copy_string(nameOut, maxLength, length,
-                     attribs->Parameters[index].Name);
-
-   if (size)
-      *size = attribs->Parameters[index].Size
-         / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);
-
-   if (type)
-      *type = attribs->Parameters[index].DataType;
-}
-
-
-/**
- * Return list of shaders attached to shader program.
- */
-static void
-get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
-                     GLsizei *count, GLuint *obj)
-{
-   struct gl_shader_program *shProg =
-      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
-   if (shProg) {
-      GLuint i;
-      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
-         obj[i] = shProg->Shaders[i]->Name;
-      }
-      if (count)
-         *count = i;
-   }
-}
-
-
-static GLint
-get_frag_data_location(struct gl_context *ctx, GLuint program,
-                       const GLchar *name)
-{
-   _mesa_problem(ctx, "get_frag_data_location() not implemented yet");
-   return -1;
-}
-
-
-
-/**
- * glGetHandleARB() - return ID/name of currently bound shader program.
- */
-static GLuint
-get_handle(struct gl_context *ctx, GLenum pname)
-{
-   if (pname == GL_PROGRAM_OBJECT_ARB) {
-      if (ctx->Shader.ActiveProgram)
-         return ctx->Shader.ActiveProgram->Name;
-      else
-         return 0;
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
-      return 0;
-   }
-}
-
-
-/**
- * glGetProgramiv() - get shader program state.
- * Note that this is for GLSL shader programs, not ARB vertex/fragment
- * programs (see glGetProgramivARB).
- */
-static void
-get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
-{
-   const struct gl_program_parameter_list *attribs;
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program(ctx, program);
-
-   if (!shProg) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
-      return;
-   }
-
-   if (shProg->VertexProgram)
-      attribs = shProg->VertexProgram->Base.Attributes;
-   else
-      attribs = NULL;
-
-   switch (pname) {
-   case GL_DELETE_STATUS:
-      *params = shProg->DeletePending;
-      break; 
-   case GL_LINK_STATUS:
-      *params = shProg->LinkStatus;
-      break;
-   case GL_VALIDATE_STATUS:
-      *params = shProg->Validated;
-      break;
-   case GL_INFO_LOG_LENGTH:
-      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
-      break;
-   case GL_ATTACHED_SHADERS:
-      *params = shProg->NumShaders;
-      break;
-   case GL_ACTIVE_ATTRIBUTES:
-      *params = attribs ? attribs->NumParameters : 0;
-      break;
-   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
-      *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
-      break;
-   case GL_ACTIVE_UNIFORMS:
-      *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
-      break;
-   case GL_ACTIVE_UNIFORM_MAX_LENGTH:
-      *params = _mesa_longest_uniform_name(shProg->Uniforms);
-      if (*params > 0)
-         (*params)++;  /* add one for terminating zero */
-      break;
-   case GL_PROGRAM_BINARY_LENGTH_OES:
-      *params = 0;
-      break;
-#if FEATURE_EXT_transform_feedback
-   case GL_TRANSFORM_FEEDBACK_VARYINGS:
-      *params = shProg->TransformFeedback.NumVarying;
-      break;
-   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
-      *params = longest_feedback_varying_name(shProg) + 1;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
-      *params = shProg->TransformFeedback.BufferMode;
-      break;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_VERTICES_OUT_ARB:
-      *params = shProg->Geom.VerticesOut;
-      break;
-   case GL_GEOMETRY_INPUT_TYPE_ARB:
-      *params = shProg->Geom.InputType;
-      break;
-   case GL_GEOMETRY_OUTPUT_TYPE_ARB:
-      *params = shProg->Geom.OutputType;
-      break;
-#endif
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
-      return;
-   }
-}
-
-
-/**
- * glGetShaderiv() - get GLSL shader state
- */
-static void
-get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
-{
-   struct gl_shader *shader =
-      _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
-
-   if (!shader) {
-      return;
-   }
-
-   switch (pname) {
-   case GL_SHADER_TYPE:
-      *params = shader->Type;
-      break;
-   case GL_DELETE_STATUS:
-      *params = shader->DeletePending;
-      break;
-   case GL_COMPILE_STATUS:
-      *params = shader->CompileStatus;
-      break;
-   case GL_INFO_LOG_LENGTH:
-      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
-      break;
-   case GL_SHADER_SOURCE_LENGTH:
-      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
-      return;
-   }
-}
-
-
-static void
-get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
-                     GLsizei *length, GLchar *infoLog)
-{
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program(ctx, program);
-   if (!shProg) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
-      return;
-   }
-   _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
-}
-
-
-static void
-get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
-                    GLsizei *length, GLchar *infoLog)
-{
-   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
-   if (!sh) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
-      return;
-   }
-   _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
-}
-
-
-/**
- * Return shader source code.
- */
-static void
-get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
-                  GLsizei *length, GLchar *sourceOut)
-{
-   struct gl_shader *sh;
-   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
-   if (!sh) {
-      return;
-   }
-   _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
-}
-
-
-/**
- * Set/replace shader source code.
- */
-static void
-shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
-{
-   struct gl_shader *sh;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
-   if (!sh)
-      return;
-
-   /* free old shader source string and install new one */
-   if (sh->Source) {
-      free((void *) sh->Source);
-   }
-   sh->Source = source;
-   sh->CompileStatus = GL_FALSE;
-#ifdef DEBUG
-   sh->SourceChecksum = _mesa_str_checksum(sh->Source);
-#endif
-}
-
-
-/**
- * Compile a shader.
- */
-static void
-compile_shader(struct gl_context *ctx, GLuint shaderObj)
-{
-   struct gl_shader *sh;
-   struct gl_shader_compiler_options *options;
-
-   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
-   if (!sh)
-      return;
-
-   options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];
-
-   /* set default pragma state for shader */
-   sh->Pragmas = options->DefaultPragmas;
-
-   /* this call will set the sh->CompileStatus field to indicate if
-    * compilation was successful.
-    */
-   _mesa_glsl_compile_shader(ctx, sh);
-}
-
-
-/**
- * Link a program's shaders.
- */
-static void
-link_program(struct gl_context *ctx, GLuint program)
-{
-   struct gl_shader_program *shProg;
-   struct gl_transform_feedback_object *obj =
-      ctx->TransformFeedback.CurrentObject;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
-   if (!shProg)
-      return;
-
-   if (obj->Active
-       && (shProg == ctx->Shader.CurrentVertexProgram
-	   || shProg == ctx->Shader.CurrentGeometryProgram
-	   || shProg == ctx->Shader.CurrentFragmentProgram)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glLinkProgram(transform feedback active");
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-
-   _mesa_glsl_link_shader(ctx, shProg);
-
-   /* debug code */
-   if (0) {
-      GLuint i;
-
-      printf("Link %u shaders in program %u: %s\n",
-                   shProg->NumShaders, shProg->Name,
-                   shProg->LinkStatus ? "Success" : "Failed");
-
-      for (i = 0; i < shProg->NumShaders; i++) {
-         printf(" shader %u, type 0x%x\n",
-                      shProg->Shaders[i]->Name,
-                      shProg->Shaders[i]->Type);
-      }
-   }
-}
-
-
-/**
- * Print basic shader info (for debug).
- */
-static void
-print_shader_info(const struct gl_shader_program *shProg)
-{
-   GLuint i;
-
-   printf("Mesa: glUseProgram(%u)\n", shProg->Name);
-   for (i = 0; i < shProg->NumShaders; i++) {
-      const char *s;
-      switch (shProg->Shaders[i]->Type) {
-      case GL_VERTEX_SHADER:
-         s = "vertex";
-         break;
-      case GL_FRAGMENT_SHADER:
-         s = "fragment";
-         break;
-      case GL_GEOMETRY_SHADER:
-         s = "geometry";
-         break;
-      default:
-         s = "";
-      }
-      printf("  %s shader %u, checksum %u\n", s, 
-	     shProg->Shaders[i]->Name,
-	     shProg->Shaders[i]->SourceChecksum);
-   }
-   if (shProg->VertexProgram)
-      printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);
-   if (shProg->FragmentProgram)
-      printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);
-}
-
-
-/**
- * Use the named shader program for subsequent glUniform calls
- */
-void
-_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
-		     const char *caller)
-{
-   if ((shProg != NULL) && !shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-		  "%s(program %u not linked)", caller, shProg->Name);
-      return;
-   }
-
-   if (ctx->Shader.ActiveProgram != shProg) {
-      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
-   }
-}
-
-/**
- */
-static bool
-use_shader_program(struct gl_context *ctx, GLenum type,
-		   struct gl_shader_program *shProg)
-{
-   struct gl_shader_program **target;
-
-   switch (type) {
-#if FEATURE_ARB_vertex_shader
-   case GL_VERTEX_SHADER:
-      target = &ctx->Shader.CurrentVertexProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_SHADER_ARB:
-      target = &ctx->Shader.CurrentGeometryProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-#if FEATURE_ARB_fragment_shader
-   case GL_FRAGMENT_SHADER:
-      target = &ctx->Shader.CurrentFragmentProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-   default:
-      return false;
-   }
-
-   if (*target != shProg) {
-      FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
-      _mesa_reference_shader_program(ctx, target, shProg);
-      return true;
-   }
-
-   return false;
-}
-
-/**
- * Use the named shader program for subsequent rendering.
- */
-void
-_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
-{
-   use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
-   use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
-   use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
-   _mesa_active_program(ctx, shProg, "glUseProgram");
-
-   if (ctx->Driver.UseProgram)
-      ctx->Driver.UseProgram(ctx, shProg);
-}
-
-
-/**
- * Validate a program's samplers.
- * Specifically, check that there aren't two samplers of different types
- * pointing to the same texture unit.
- * \return GL_TRUE if valid, GL_FALSE if invalid
- */
-static GLboolean
-validate_samplers(const struct gl_program *prog, char *errMsg)
-{
-   static const char *targetName[] = {
-      "TEXTURE_2D_ARRAY",
-      "TEXTURE_1D_ARRAY",
-      "TEXTURE_CUBE",
-      "TEXTURE_3D",
-      "TEXTURE_RECT",
-      "TEXTURE_2D",
-      "TEXTURE_1D",
-   };
-   GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
-   GLbitfield samplersUsed = prog->SamplersUsed;
-   GLuint i;
-
-   assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
-
-   if (samplersUsed == 0x0)
-      return GL_TRUE;
-
-   for (i = 0; i < Elements(targetUsed); i++)
-      targetUsed[i] = -1;
-
-   /* walk over bits which are set in 'samplers' */
-   while (samplersUsed) {
-      GLuint unit;
-      gl_texture_index target;
-      GLint sampler = _mesa_ffs(samplersUsed) - 1;
-      assert(sampler >= 0);
-      assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
-      unit = prog->SamplerUnits[sampler];
-      target = prog->SamplerTargets[sampler];
-      if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {
-         _mesa_snprintf(errMsg, 100,
-		  "Texture unit %d is accessed both as %s and %s",
-		  unit, targetName[targetUsed[unit]], targetName[target]);
-         return GL_FALSE;
-      }
-      targetUsed[unit] = target;
-      samplersUsed ^= (1 << sampler);
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do validation of the given shader program.
- * \param errMsg  returns error message if validation fails.
- * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
- */
-static GLboolean
-validate_shader_program(const struct gl_shader_program *shProg,
-                        char *errMsg)
-{
-   const struct gl_vertex_program *vp = shProg->VertexProgram;
-   const struct gl_fragment_program *fp = shProg->FragmentProgram;
-
-   if (!shProg->LinkStatus) {
-      return GL_FALSE;
-   }
-
-   /* From the GL spec, a program is invalid if any of these are true:
-
-     any two active samplers in the current program object are of
-     different types, but refer to the same texture image unit,
-
-     any active sampler in the current program object refers to a texture
-     image unit where fixed-function fragment processing accesses a
-     texture target that does not match the sampler type, or 
-
-     the sum of the number of active samplers in the program and the
-     number of texture image units enabled for fixed-function fragment
-     processing exceeds the combined limit on the total number of texture
-     image units allowed.
-   */
-
-
-   /*
-    * Check: any two active samplers in the current program object are of
-    * different types, but refer to the same texture image unit,
-    */
-   if (vp && !validate_samplers(&vp->Base, errMsg)) {
-      return GL_FALSE;
-   }
-   if (fp && !validate_samplers(&fp->Base, errMsg)) {
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Called via glValidateProgram()
- */
-static void
-validate_program(struct gl_context *ctx, GLuint program)
-{
-   struct gl_shader_program *shProg;
-   char errMsg[100];
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
-   if (!shProg) {
-      return;
-   }
-
-   shProg->Validated = validate_shader_program(shProg, errMsg);
-   if (!shProg->Validated) {
-      /* update info log */
-      if (shProg->InfoLog) {
-         ralloc_free(shProg->InfoLog);
-      }
-      shProg->InfoLog = ralloc_strdup(shProg, errMsg);
-   }
-}
-
-
-
-void GLAPIENTRY
-_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   attach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_AttachShader(GLuint program, GLuint shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   attach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,
-                            const GLcharARB *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   bind_attrib_location(ctx, program, index, name);
-}
-
-
-/* GL_EXT_gpu_shader4, GL3 */
-void GLAPIENTRY
-_mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
-                           const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   bind_frag_data_location(ctx, program, colorNumber, name);
-}
-
-
-void GLAPIENTRY
-_mesa_CompileShaderARB(GLhandleARB shaderObj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
-   compile_shader(ctx, shaderObj);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_CreateShader(GLenum type)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
-   return create_shader(ctx, type);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_CreateShaderObjectARB(GLenum type)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return create_shader(ctx, type);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_CreateProgram(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCreateProgram\n");
-   return create_shader_program(ctx);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_CreateProgramObjectARB(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return create_shader_program(ctx);
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteObjectARB(GLhandleARB obj)
-{
-   if (MESA_VERBOSE & VERBOSE_API) {
-      GET_CURRENT_CONTEXT(ctx);
-      _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
-   }
-
-   if (obj) {
-      GET_CURRENT_CONTEXT(ctx);
-      if (is_program(ctx, obj)) {
-         delete_shader_program(ctx, obj);
-      }
-      else if (is_shader(ctx, obj)) {
-         delete_shader(ctx, obj);
-      }
-      else {
-         /* error? */
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteProgram(GLuint name)
-{
-   if (name) {
-      GET_CURRENT_CONTEXT(ctx);
-      delete_shader_program(ctx, name);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteShader(GLuint name)
-{
-   if (name) {
-      GET_CURRENT_CONTEXT(ctx);
-      delete_shader(ctx, name);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   detach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_DetachShader(GLuint program, GLuint shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   detach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
-                         GLsizei maxLength, GLsizei * length, GLint * size,
-                         GLenum * type, GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
-}
-
-
-void GLAPIENTRY
-_mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
-                            GLsizei * count, GLhandleARB * obj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_attached_shaders(ctx, container, maxCount, count, obj);
-}
-
-
-void GLAPIENTRY
-_mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
-                         GLsizei *count, GLuint *obj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_attached_shaders(ctx, program, maxCount, count, obj);
-}
-
-
-GLint GLAPIENTRY
-_mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_attrib_location(ctx, program, name);
-}
-
-
-/* GL_EXT_gpu_shader4, GL3 */
-GLint GLAPIENTRY
-_mesa_GetFragDataLocation(GLuint program, const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_frag_data_location(ctx, program, name);
-}
-
-
-
-void GLAPIENTRY
-_mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
-                    GLcharARB * infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (is_program(ctx, object)) {
-      get_program_info_log(ctx, object, maxLength, length, infoLog);
-   }
-   else if (is_shader(ctx, object)) {
-      get_shader_info_log(ctx, object, maxLength, length, infoLog);
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   /* Implement in terms of GetProgramiv, GetShaderiv */
-   if (is_program(ctx, object)) {
-      if (pname == GL_OBJECT_TYPE_ARB) {
-	 *params = GL_PROGRAM_OBJECT_ARB;
-      }
-      else {
-	 get_programiv(ctx, object, pname, params);
-      }
-   }
-   else if (is_shader(ctx, object)) {
-      if (pname == GL_OBJECT_TYPE_ARB) {
-	 *params = GL_SHADER_OBJECT_ARB;
-      }
-      else {
-	 get_shaderiv(ctx, object, pname, params);
-      }
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
-                              GLfloat *params)
-{
-   GLint iparams[1];  /* XXX is one element enough? */
-   _mesa_GetObjectParameterivARB(object, pname, iparams);
-   params[0] = (GLfloat) iparams[0];
-}
-
-
-void GLAPIENTRY
-_mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_programiv(ctx, program, pname, params);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shaderiv(ctx, shader, pname, params);
-}
-
-
-void GLAPIENTRY
-_mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
-                        GLsizei *length, GLchar *infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_program_info_log(ctx, program, bufSize, length, infoLog);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
-                       GLsizei *length, GLchar *infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shader_info_log(ctx, shader, bufSize, length, infoLog);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
-                         GLsizei *length, GLcharARB *sourceOut)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shader_source(ctx, shader, maxLength, length, sourceOut);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_GetHandleARB(GLenum pname)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_handle(ctx, pname);
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsProgram(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return is_program(ctx, name);
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsShader(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return is_shader(ctx, name);
-}
-
-
-void GLAPIENTRY
-_mesa_LinkProgramARB(GLhandleARB programObj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   link_program(ctx, programObj);
-}
-
-
-
-/**
- * Read shader source code from a file.
- * Useful for debugging to override an app's shader.
- */
-static GLcharARB *
-read_shader(const char *fname)
-{
-   const int max = 50*1000;
-   FILE *f = fopen(fname, "r");
-   GLcharARB *buffer, *shader;
-   int len;
-
-   if (!f) {
-      return NULL;
-   }
-
-   buffer = (char *) malloc(max);
-   len = fread(buffer, 1, max, f);
-   buffer[len] = 0;
-
-   fclose(f);
-
-   shader = _mesa_strdup(buffer);
-   free(buffer);
-
-   return shader;
-}
-
-
-/**
- * Called via glShaderSource() and glShaderSourceARB() API functions.
- * Basically, concatenate the source code strings into one long string
- * and pass it to _mesa_shader_source().
- */
-void GLAPIENTRY
-_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
-                      const GLcharARB ** string, const GLint * length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint *offsets;
-   GLsizei i, totalLength;
-   GLcharARB *source;
-   GLuint checksum;
-
-   if (!shaderObj || string == NULL) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
-      return;
-   }
-
-   /*
-    * This array holds offsets of where the appropriate string ends, thus the
-    * last element will be set to the total length of the source code.
-    */
-   offsets = (GLint *) malloc(count * sizeof(GLint));
-   if (offsets == NULL) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
-      return;
-   }
-
-   for (i = 0; i < count; i++) {
-      if (string[i] == NULL) {
-         free((GLvoid *) offsets);
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");
-         return;
-      }
-      if (length == NULL || length[i] < 0)
-         offsets[i] = strlen(string[i]);
-      else
-         offsets[i] = length[i];
-      /* accumulate string lengths */
-      if (i > 0)
-         offsets[i] += offsets[i - 1];
-   }
-
-   /* Total length of source string is sum off all strings plus two.
-    * One extra byte for terminating zero, another extra byte to silence
-    * valgrind warnings in the parser/grammer code.
-    */
-   totalLength = offsets[count - 1] + 2;
-   source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
-   if (source == NULL) {
-      free((GLvoid *) offsets);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
-      return;
-   }
-
-   for (i = 0; i < count; i++) {
-      GLint start = (i > 0) ? offsets[i - 1] : 0;
-      memcpy(source + start, string[i],
-             (offsets[i] - start) * sizeof(GLcharARB));
-   }
-   source[totalLength - 1] = '\0';
-   source[totalLength - 2] = '\0';
-
-   if (SHADER_SUBST) {
-      /* Compute the shader's source code checksum then try to open a file
-       * named newshader_<CHECKSUM>.  If it exists, use it in place of the
-       * original shader source code.  For debugging.
-       */
-      char filename[100];
-      GLcharARB *newSource;
-
-      checksum = _mesa_str_checksum(source);
-
-      _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
-
-      newSource = read_shader(filename);
-      if (newSource) {
-         fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
-                       shaderObj, checksum, filename);
-         free(source);
-         source = newSource;
-      }
-   }      
-
-   shader_source(ctx, shaderObj, source);
-
-   if (SHADER_SUBST) {
-      struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
-      if (sh)
-         sh->SourceChecksum = checksum; /* save original checksum */
-   }
-
-   free(offsets);
-}
-
-
-void GLAPIENTRY
-_mesa_UseProgramObjectARB(GLhandleARB program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg;
-   struct gl_transform_feedback_object *obj =
-      ctx->TransformFeedback.CurrentObject;
-
-   if (obj->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glUseProgram(transform feedback active)");
-      return;
-   }
-
-   if (program) {
-      shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
-      if (!shProg) {
-         return;
-      }
-      if (!shProg->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glUseProgram(program %u not linked)", program);
-         return;
-      }
-
-      /* debug code */
-      if (ctx->Shader.Flags & GLSL_USE_PROG) {
-         print_shader_info(shProg);
-      }
-   }
-   else {
-      shProg = NULL;
-   }
-
-   _mesa_use_program(ctx, shProg);
-}
-
-
-void GLAPIENTRY
-_mesa_ValidateProgramARB(GLhandleARB program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   validate_program(ctx, program);
-}
-
-#ifdef FEATURE_ES2
-
-void GLAPIENTRY
-_mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
-                               GLint* range, GLint* precision)
-{
-   const struct gl_program_constants *limits;
-   const struct gl_precision *p;
-   GET_CURRENT_CONTEXT(ctx);
-
-   switch (shadertype) {
-   case GL_VERTEX_SHADER:
-      limits = &ctx->Const.VertexProgram;
-      break;
-   case GL_FRAGMENT_SHADER:
-      limits = &ctx->Const.FragmentProgram;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetShaderPrecisionFormat(shadertype)");
-      return;
-   }
-
-   switch (precisiontype) {
-   case GL_LOW_FLOAT:
-      p = &limits->LowFloat;
-      break;
-   case GL_MEDIUM_FLOAT:
-      p = &limits->MediumFloat;
-      break;
-   case GL_HIGH_FLOAT:
-      p = &limits->HighFloat;
-      break;
-   case GL_LOW_INT:
-      p = &limits->LowInt;
-      break;
-   case GL_MEDIUM_INT:
-      p = &limits->MediumInt;
-      break;
-   case GL_HIGH_INT:
-      p = &limits->HighInt;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetShaderPrecisionFormat(precisiontype)");
-      return;
-   }
-
-   range[0] = p->RangeMin;
-   range[1] = p->RangeMax;
-   precision[0] = p->Precision;
-}
-
-
-void GLAPIENTRY
-_mesa_ReleaseShaderCompiler(void)
-{
-   _mesa_destroy_shader_compiler_caches();
-}
-
-
-void GLAPIENTRY
-_mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
-                   const void* binary, GLint length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) n;
-   (void) shaders;
-   (void) binaryformat;
-   (void) binary;
-   (void) length;
-   _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
-}
-
-#endif /* FEATURE_ES2 */
-
-
-#if FEATURE_ARB_geometry_shader4
-
-void GLAPIENTRY
-_mesa_ProgramParameteriARB(GLuint program, GLenum pname,
-                           GLint value)
-{
-   struct gl_shader_program *shProg;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program,
-                                            "glProgramParameteri");
-   if (!shProg)
-      return;
-
-   switch (pname) {
-   case GL_GEOMETRY_VERTICES_OUT_ARB:
-      if (value < 1 ||
-          (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
-                     value);
-         return;
-      }
-      shProg->Geom.VerticesOut = value;
-      break;
-   case GL_GEOMETRY_INPUT_TYPE_ARB:
-      switch (value) {
-      case GL_POINTS:
-      case GL_LINES:
-      case GL_LINES_ADJACENCY_ARB:
-      case GL_TRIANGLES:
-      case GL_TRIANGLES_ADJACENCY_ARB:
-         shProg->Geom.InputType = value;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(geometry input type = %s",
-                     _mesa_lookup_enum_by_nr(value));
-         return;
-      }
-      break;
-   case GL_GEOMETRY_OUTPUT_TYPE_ARB:
-      switch (value) {
-      case GL_POINTS:
-      case GL_LINE_STRIP:
-      case GL_TRIANGLE_STRIP:
-         shProg->Geom.OutputType = value;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(geometry output type = %s",
-                     _mesa_lookup_enum_by_nr(value));
-         return;
-      }
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
-                  _mesa_lookup_enum_by_nr(pname));
-      break;
-   }
-}
-
-#endif
-
-void
-_mesa_use_shader_program(struct gl_context *ctx, GLenum type,
-			 struct gl_shader_program *shProg)
-{
-   use_shader_program(ctx, type, shProg);
-
-   if (ctx->Driver.UseProgram)
-      ctx->Driver.UseProgram(ctx, shProg);
-}
-
-void GLAPIENTRY
-_mesa_UseShaderProgramEXT(GLenum type, GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg = NULL;
-
-   if (!validate_shader_target(ctx, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
-      return;
-   }
-
-   if (ctx->TransformFeedback.CurrentObject->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glUseShaderProgramEXT(transform feedback is active)");
-      return;
-   }
-
-   if (program) {
-      shProg = _mesa_lookup_shader_program_err(ctx, program,
-					       "glUseShaderProgramEXT");
-      if (shProg == NULL)
-	 return;
-
-      if (!shProg->LinkStatus) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION,
-		     "glUseShaderProgramEXT(program not linked)");
-	 return;
-      }
-   }
-
-   _mesa_use_shader_program(ctx, type, shProg);
-}
-
-void GLAPIENTRY
-_mesa_ActiveProgramEXT(GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg = (program != 0)
-      ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
-      : NULL;
-
-   _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
-   return;
-}
-
-GLuint GLAPIENTRY
-_mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLuint shader = create_shader(ctx, type);
-   GLuint program = 0;
-
-   if (shader) {
-      shader_source(ctx, shader, _mesa_strdup(string));
-      compile_shader(ctx, shader);
-
-      program = create_shader_program(ctx);
-      if (program) {
-	 struct gl_shader_program *shProg;
-	 struct gl_shader *sh;
-	 GLint compiled = GL_FALSE;
-
-	 shProg = _mesa_lookup_shader_program(ctx, program);
-	 sh = _mesa_lookup_shader(ctx, shader);
-
-	 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
-	 if (compiled) {
-	    attach_shader(ctx, program, shader);
-	    link_program(ctx, program);
-	    detach_shader(ctx, program, shader);
-
-#if 0
-	    /* Possibly... */
-	    if (active-user-defined-varyings-in-linked-program) {
-	       append-error-to-info-log;
-	       shProg->LinkStatus = GL_FALSE;
-	    }
-#endif
-	 }
-
-	 ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
-      }
-
-      delete_shader(ctx, shader);
-   }
-
-   return program;
-}
-
-/**
- * Plug in shader-related functions into API dispatch table.
- */
-void
-_mesa_init_shader_dispatch(struct _glapi_table *exec)
-{
-#if FEATURE_GL
-   /* GL_ARB_vertex/fragment_shader */
-   SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
-   SET_GetHandleARB(exec, _mesa_GetHandleARB);
-   SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
-   SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
-   SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
-   SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
-   SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
-   SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
-   SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
-   SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
-   SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
-   SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
-   SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
-   SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
-   SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
-   SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
-
-   /* OpenGL 2.0 */
-   SET_AttachShader(exec, _mesa_AttachShader);
-   SET_CreateProgram(exec, _mesa_CreateProgram);
-   SET_CreateShader(exec, _mesa_CreateShader);
-   SET_DeleteProgram(exec, _mesa_DeleteProgram);
-   SET_DeleteShader(exec, _mesa_DeleteShader);
-   SET_DetachShader(exec, _mesa_DetachShader);
-   SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
-   SET_GetProgramiv(exec, _mesa_GetProgramiv);
-   SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
-   SET_GetShaderiv(exec, _mesa_GetShaderiv);
-   SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
-   SET_IsProgram(exec, _mesa_IsProgram);
-   SET_IsShader(exec, _mesa_IsShader);
-
-#if FEATURE_ARB_vertex_shader
-   SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
-   SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
-   SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
-#endif
-
-   SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
-   SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
-   SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
-
-   /* GL_EXT_gpu_shader4 / GL 3.0 */
-   SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
-   SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
-
-   /* GL_ARB_ES2_compatibility */
-   SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
-   SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);
-
-#endif /* FEATURE_GL */
-}
-
+/*

+ * Mesa 3-D graphics library

+ *

+ * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009-2010  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file shaderapi.c

+ * \author Brian Paul

+ *

+ * Implementation of GLSL-related API functions.

+ * The glUniform* functions are in uniforms.c

+ *

+ *

+ * XXX things to do:

+ * 1. Check that the right error code is generated for all _mesa_error() calls.

+ * 2. Insert FLUSH_VERTICES calls in various places

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/dispatch.h"

+#include "main/enums.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/shaderapi.h"

+#include "main/shaderobj.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "program/prog_uniform.h"

+#include "ralloc.h"

+#include <stdbool.h>

+#include "../glsl/glsl_parser_extras.h"

+

+/** Define this to enable shader substitution (see below) */

+#define SHADER_SUBST 0

+

+

+/**

+ * Return mask of GLSL_x flags by examining the MESA_GLSL env var.

+ */

+static GLbitfield

+get_shader_flags(void)

+{

+   GLbitfield flags = 0x0;

+   const char *env = _mesa_getenv("MESA_GLSL");

+

+   if (env) {

+      if (strstr(env, "dump"))

+         flags |= GLSL_DUMP;

+      if (strstr(env, "log"))

+         flags |= GLSL_LOG;

+      if (strstr(env, "nopvert"))

+         flags |= GLSL_NOP_VERT;

+      if (strstr(env, "nopfrag"))

+         flags |= GLSL_NOP_FRAG;

+      if (strstr(env, "nopt"))

+         flags |= GLSL_NO_OPT;

+      else if (strstr(env, "opt"))

+         flags |= GLSL_OPT;

+      if (strstr(env, "uniform"))

+         flags |= GLSL_UNIFORMS;

+      if (strstr(env, "useprog"))

+         flags |= GLSL_USE_PROG;

+   }

+

+   return flags;

+}

+

+

+/**

+ * Initialize context's shader state.

+ */

+void

+_mesa_init_shader_state(struct gl_context *ctx)

+{

+   /* Device drivers may override these to control what kind of instructions

+    * are generated by the GLSL compiler.

+    */

+   struct gl_shader_compiler_options options;

+   gl_shader_type sh;

+

+   memset(&options, 0, sizeof(options));

+   options.MaxUnrollIterations = 32;

+

+   /* Default pragma settings */

+   options.DefaultPragmas.Optimize = GL_TRUE;

+

+   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)

+      memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));

+

+   ctx->Shader.Flags = get_shader_flags();

+}

+

+

+/**

+ * Free the per-context shader-related state.

+ */

+void

+_mesa_free_shader_state(struct gl_context *ctx)

+{

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,

+				  NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,

+				  NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);

+}

+

+

+/**

+ * Return the size of the given GLSL datatype, in floats (components).

+ */

+GLint

+_mesa_sizeof_glsl_type(GLenum type)

+{

+   switch (type) {

+   case GL_FLOAT:

+   case GL_INT:

+   case GL_BOOL:

+   case GL_SAMPLER_1D:

+   case GL_SAMPLER_2D:

+   case GL_SAMPLER_3D:

+   case GL_SAMPLER_CUBE:

+   case GL_SAMPLER_1D_SHADOW:

+   case GL_SAMPLER_2D_SHADOW:

+   case GL_SAMPLER_2D_RECT_ARB:

+   case GL_SAMPLER_2D_RECT_SHADOW_ARB:

+   case GL_SAMPLER_1D_ARRAY_EXT:

+   case GL_SAMPLER_2D_ARRAY_EXT:

+   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:

+   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:

+   case GL_SAMPLER_CUBE_SHADOW_EXT:

+      return 1;

+   case GL_FLOAT_VEC2:

+   case GL_INT_VEC2:

+   case GL_UNSIGNED_INT_VEC2:

+   case GL_BOOL_VEC2:

+      return 2;

+   case GL_FLOAT_VEC3:

+   case GL_INT_VEC3:

+   case GL_UNSIGNED_INT_VEC3:

+   case GL_BOOL_VEC3:

+      return 3;

+   case GL_FLOAT_VEC4:

+   case GL_INT_VEC4:

+   case GL_UNSIGNED_INT_VEC4:

+   case GL_BOOL_VEC4:

+      return 4;

+   case GL_FLOAT_MAT2:

+   case GL_FLOAT_MAT2x3:

+   case GL_FLOAT_MAT2x4:

+      return 8; /* two float[4] vectors */

+   case GL_FLOAT_MAT3:

+   case GL_FLOAT_MAT3x2:

+   case GL_FLOAT_MAT3x4:

+      return 12; /* three float[4] vectors */

+   case GL_FLOAT_MAT4:

+   case GL_FLOAT_MAT4x2:

+   case GL_FLOAT_MAT4x3:

+      return 16;  /* four float[4] vectors */

+   default:

+      _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");

+      return 1;

+   }

+}

+

+

+/**

+ * Copy string from <src> to <dst>, up to maxLength characters, returning

+ * length of <dst> in <length>.

+ * \param src  the strings source

+ * \param maxLength  max chars to copy

+ * \param length  returns number of chars copied

+ * \param dst  the string destination

+ */

+void

+_mesa_copy_string(GLchar *dst, GLsizei maxLength,

+                  GLsizei *length, const GLchar *src)

+{

+   GLsizei len;

+   for (len = 0; len < maxLength - 1 && src && src[len]; len++)

+      dst[len] = src[len];

+   if (maxLength > 0)

+      dst[len] = 0;

+   if (length)

+      *length = len;

+}

+

+

+

+/**

+ * Confirm that the a shader type is valid and supported by the implementation

+ *

+ * \param ctx   Current GL context

+ * \param type  Shader target

+ *

+ */

+static bool

+validate_shader_target(const struct gl_context *ctx, GLenum type)

+{

+   switch (type) {

+#if FEATURE_ARB_fragment_shader

+   case GL_FRAGMENT_SHADER:

+      return ctx->Extensions.ARB_fragment_shader;

+#endif

+#if FEATURE_ARB_vertex_shader

+   case GL_VERTEX_SHADER:

+      return ctx->Extensions.ARB_vertex_shader;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_SHADER_ARB:

+      return ctx->Extensions.ARB_geometry_shader4;

+#endif

+   default:

+      return false;

+   }

+}

+

+

+/**

+ * Find the length of the longest transform feedback varying name

+ * which was specified with glTransformFeedbackVaryings().

+ */

+static GLint

+longest_feedback_varying_name(const struct gl_shader_program *shProg)

+{

+   GLuint i;

+   GLint max = 0;

+   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {

+      GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);

+      if (len > max)

+         max = len;

+   }

+   return max;

+}

+

+

+

+static GLboolean

+is_program(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);

+   return shProg ? GL_TRUE : GL_FALSE;

+}

+

+

+static GLboolean

+is_shader(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);

+   return shader ? GL_TRUE : GL_FALSE;

+}

+

+

+/**

+ * Attach shader to a shader program.

+ */

+static void

+attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

+{

+   struct gl_shader_program *shProg;

+   struct gl_shader *sh;

+   GLuint i, n;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");

+   if (!shProg)

+      return;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");

+   if (!sh) {

+      return;

+   }

+

+   n = shProg->NumShaders;

+   for (i = 0; i < n; i++) {

+      if (shProg->Shaders[i] == sh) {

+         /* The shader is already attched to this program.  The

+          * GL_ARB_shader_objects spec says:

+          *

+          *     "The error INVALID_OPERATION is generated by AttachObjectARB

+          *     if <obj> is already attached to <containerObj>."

+          */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");

+         return;

+      }

+   }

+

+   /* grow list */

+   shProg->Shaders = (struct gl_shader **)

+      _mesa_realloc(shProg->Shaders,

+                    n * sizeof(struct gl_shader *),

+                    (n + 1) * sizeof(struct gl_shader *));

+   if (!shProg->Shaders) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");

+      return;

+   }

+

+   /* append */

+   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */

+   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);

+   shProg->NumShaders++;

+}

+

+

+static GLint

+get_attrib_location(struct gl_context *ctx, GLuint program, const GLchar *name)

+{

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");

+

+   if (!shProg) {

+      return -1;

+   }

+

+   if (!shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetAttribLocation(program not linked)");

+      return -1;

+   }

+

+   if (!name)

+      return -1;

+

+   if (shProg->VertexProgram) {

+      const struct gl_program_parameter_list *attribs =

+         shProg->VertexProgram->Base.Attributes;

+      if (attribs) {

+         GLint i = _mesa_lookup_parameter_index(attribs, -1, name);

+         if (i >= 0) {

+            return attribs->Parameters[i].StateIndexes[0];

+         }

+      }

+   }

+   return -1;

+}

+

+

+static void

+bind_attrib_location(struct gl_context *ctx, GLuint program, GLuint index,

+                     const GLchar *name)

+{

+   struct gl_shader_program *shProg;

+   const GLint size = -1; /* unknown size */

+   GLint i, oldIndex;

+   GLenum datatype = GL_FLOAT_VEC4;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program,

+                                            "glBindAttribLocation");

+   if (!shProg) {

+      return;

+   }

+

+   if (!name)

+      return;

+

+   if (strncmp(name, "gl_", 3) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glBindAttribLocation(illegal name)");

+      return;

+   }

+

+   if (index >= ctx->Const.VertexProgram.MaxAttribs) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");

+      return;

+   }

+

+   if (shProg->LinkStatus) {

+      /* get current index/location for the attribute */

+      oldIndex = get_attrib_location(ctx, program, name);

+   }

+   else {

+      oldIndex = -1;

+   }

+

+   /* this will replace the current value if it's already in the list */

+   i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);

+   if (i < 0) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");

+      return;

+   }

+

+   /*

+    * Note that this attribute binding won't go into effect until

+    * glLinkProgram is called again.

+    */

+}

+

+

+static void

+bind_frag_data_location(struct gl_context *ctx, GLuint program,

+                        GLuint colorNumber, const GLchar *name)

+{

+   _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");

+}

+

+

+static GLuint

+create_shader(struct gl_context *ctx, GLenum type)

+{

+   struct gl_shader *sh;

+   GLuint name;

+

+   if (!validate_shader_target(ctx, type)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");

+      return 0;

+   }

+

+   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

+   sh = ctx->Driver.NewShader(ctx, name, type);

+   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);

+

+   return name;

+}

+

+

+static GLuint 

+create_shader_program(struct gl_context *ctx)

+{

+   GLuint name;

+   struct gl_shader_program *shProg;

+

+   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

+

+   shProg = ctx->Driver.NewShaderProgram(ctx, name);

+

+   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);

+

+   assert(shProg->RefCount == 1);

+

+   return name;

+}

+

+

+/**

+ * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's

+ * DeleteProgramARB.

+ */

+static void

+delete_shader_program(struct gl_context *ctx, GLuint name)

+{

+   /*

+    * NOTE: deleting shaders/programs works a bit differently than

+    * texture objects (and buffer objects, etc).  Shader/program

+    * handles/IDs exist in the hash table until the object is really

+    * deleted (refcount==0).  With texture objects, the handle/ID is

+    * removed from the hash table in glDeleteTextures() while the tex

+    * object itself might linger until its refcount goes to zero.

+    */

+   struct gl_shader_program *shProg;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");

+   if (!shProg)

+      return;

+

+   shProg->DeletePending = GL_TRUE;

+

+   /* effectively, decr shProg's refcount */

+   _mesa_reference_shader_program(ctx, &shProg, NULL);

+}

+

+

+static void

+delete_shader(struct gl_context *ctx, GLuint shader)

+{

+   struct gl_shader *sh;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");

+   if (!sh)

+      return;

+

+   sh->DeletePending = GL_TRUE;

+

+   /* effectively, decr sh's refcount */

+   _mesa_reference_shader(ctx, &sh, NULL);

+}

+

+

+static void

+detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

+{

+   struct gl_shader_program *shProg;

+   GLuint n;

+   GLuint i, j;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");

+   if (!shProg)

+      return;

+

+   n = shProg->NumShaders;

+

+   for (i = 0; i < n; i++) {

+      if (shProg->Shaders[i]->Name == shader) {

+         /* found it */

+         struct gl_shader **newList;

+

+         /* release */

+         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);

+

+         /* alloc new, smaller array */

+         newList = (struct gl_shader **)

+            malloc((n - 1) * sizeof(struct gl_shader *));

+         if (!newList) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");

+            return;

+         }

+         for (j = 0; j < i; j++) {

+            newList[j] = shProg->Shaders[j];

+         }

+         while (++i < n)

+            newList[j++] = shProg->Shaders[i];

+         free(shProg->Shaders);

+

+         shProg->Shaders = newList;

+         shProg->NumShaders = n - 1;

+

+#ifdef DEBUG

+         /* sanity check */

+         {

+            for (j = 0; j < shProg->NumShaders; j++) {

+               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||

+                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);

+               assert(shProg->Shaders[j]->RefCount > 0);

+            }

+         }

+#endif

+

+         return;

+      }

+   }

+

+   /* not found */

+   {

+      GLenum err;

+      if (is_shader(ctx, shader))

+         err = GL_INVALID_OPERATION;

+      else if (is_program(ctx, shader))

+         err = GL_INVALID_OPERATION;

+      else

+         err = GL_INVALID_VALUE;

+      _mesa_error(ctx, err, "glDetachProgram(shader)");

+      return;

+   }

+}

+

+

+static void

+get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,

+                  GLsizei maxLength, GLsizei *length, GLint *size,

+                  GLenum *type, GLchar *nameOut)

+{

+   const struct gl_program_parameter_list *attribs = NULL;

+   struct gl_shader_program *shProg;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");

+   if (!shProg)

+      return;

+

+   if (shProg->VertexProgram)

+      attribs = shProg->VertexProgram->Base.Attributes;

+

+   if (!attribs || index >= attribs->NumParameters) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");

+      return;

+   }

+

+   _mesa_copy_string(nameOut, maxLength, length,

+                     attribs->Parameters[index].Name);

+

+   if (size)

+      *size = attribs->Parameters[index].Size

+         / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);

+

+   if (type)

+      *type = attribs->Parameters[index].DataType;

+}

+

+

+/**

+ * Return list of shaders attached to shader program.

+ */

+static void

+get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,

+                     GLsizei *count, GLuint *obj)

+{

+   struct gl_shader_program *shProg =

+      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");

+   if (shProg) {

+      GLuint i;

+      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {

+         obj[i] = shProg->Shaders[i]->Name;

+      }

+      if (count)

+         *count = i;

+   }

+}

+

+

+static GLint

+get_frag_data_location(struct gl_context *ctx, GLuint program,

+                       const GLchar *name)

+{

+   _mesa_problem(ctx, "get_frag_data_location() not implemented yet");

+   return -1;

+}

+

+

+

+/**

+ * glGetHandleARB() - return ID/name of currently bound shader program.

+ */

+static GLuint

+get_handle(struct gl_context *ctx, GLenum pname)

+{

+   if (pname == GL_PROGRAM_OBJECT_ARB) {

+      if (ctx->Shader.ActiveProgram)

+         return ctx->Shader.ActiveProgram->Name;

+      else

+         return 0;

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");

+      return 0;

+   }

+}

+

+

+/**

+ * glGetProgramiv() - get shader program state.

+ * Note that this is for GLSL shader programs, not ARB vertex/fragment

+ * programs (see glGetProgramivARB).

+ */

+static void

+get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)

+{

+   const struct gl_program_parameter_list *attribs;

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program(ctx, program);

+

+   if (!shProg) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");

+      return;

+   }

+

+   if (shProg->VertexProgram)

+      attribs = shProg->VertexProgram->Base.Attributes;

+   else

+      attribs = NULL;

+

+   switch (pname) {

+   case GL_DELETE_STATUS:

+      *params = shProg->DeletePending;

+      break; 

+   case GL_LINK_STATUS:

+      *params = shProg->LinkStatus;

+      break;

+   case GL_VALIDATE_STATUS:

+      *params = shProg->Validated;

+      break;

+   case GL_INFO_LOG_LENGTH:

+      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;

+      break;

+   case GL_ATTACHED_SHADERS:

+      *params = shProg->NumShaders;

+      break;

+   case GL_ACTIVE_ATTRIBUTES:

+      *params = attribs ? attribs->NumParameters : 0;

+      break;

+   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:

+      *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;

+      break;

+   case GL_ACTIVE_UNIFORMS:

+      *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;

+      break;

+   case GL_ACTIVE_UNIFORM_MAX_LENGTH:

+      *params = _mesa_longest_uniform_name(shProg->Uniforms);

+      if (*params > 0)

+         (*params)++;  /* add one for terminating zero */

+      break;

+   case GL_PROGRAM_BINARY_LENGTH_OES:

+      *params = 0;

+      break;

+#if FEATURE_EXT_transform_feedback

+   case GL_TRANSFORM_FEEDBACK_VARYINGS:

+      *params = shProg->TransformFeedback.NumVarying;

+      break;

+   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:

+      *params = longest_feedback_varying_name(shProg) + 1;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:

+      *params = shProg->TransformFeedback.BufferMode;

+      break;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_VERTICES_OUT_ARB:

+      *params = shProg->Geom.VerticesOut;

+      break;

+   case GL_GEOMETRY_INPUT_TYPE_ARB:

+      *params = shProg->Geom.InputType;

+      break;

+   case GL_GEOMETRY_OUTPUT_TYPE_ARB:

+      *params = shProg->Geom.OutputType;

+      break;

+#endif

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");

+      return;

+   }

+}

+

+

+/**

+ * glGetShaderiv() - get GLSL shader state

+ */

+static void

+get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)

+{

+   struct gl_shader *shader =

+      _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");

+

+   if (!shader) {

+      return;

+   }

+

+   switch (pname) {

+   case GL_SHADER_TYPE:

+      *params = shader->Type;

+      break;

+   case GL_DELETE_STATUS:

+      *params = shader->DeletePending;

+      break;

+   case GL_COMPILE_STATUS:

+      *params = shader->CompileStatus;

+      break;

+   case GL_INFO_LOG_LENGTH:

+      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;

+      break;

+   case GL_SHADER_SOURCE_LENGTH:

+      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");

+      return;

+   }

+}

+

+

+static void

+get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,

+                     GLsizei *length, GLchar *infoLog)

+{

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program(ctx, program);

+   if (!shProg) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");

+      return;

+   }

+   _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);

+}

+

+

+static void

+get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,

+                    GLsizei *length, GLchar *infoLog)

+{

+   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);

+   if (!sh) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");

+      return;

+   }

+   _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);

+}

+

+

+/**

+ * Return shader source code.

+ */

+static void

+get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,

+                  GLsizei *length, GLchar *sourceOut)

+{

+   struct gl_shader *sh;

+   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");

+   if (!sh) {

+      return;

+   }

+   _mesa_copy_string(sourceOut, maxLength, length, sh->Source);

+}

+

+

+/**

+ * Set/replace shader source code.

+ */

+static void

+shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)

+{

+   struct gl_shader *sh;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");

+   if (!sh)

+      return;

+

+   /* free old shader source string and install new one */

+   if (sh->Source) {

+      free((void *) sh->Source);

+   }

+   sh->Source = source;

+   sh->CompileStatus = GL_FALSE;

+#ifdef DEBUG

+   sh->SourceChecksum = _mesa_str_checksum(sh->Source);

+#endif

+}

+

+

+/**

+ * Compile a shader.

+ */

+static void

+compile_shader(struct gl_context *ctx, GLuint shaderObj)

+{

+   struct gl_shader *sh;

+   struct gl_shader_compiler_options *options;

+

+   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");

+   if (!sh)

+      return;

+

+   options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];

+

+   /* set default pragma state for shader */

+   sh->Pragmas = options->DefaultPragmas;

+

+   /* this call will set the sh->CompileStatus field to indicate if

+    * compilation was successful.

+    */

+   _mesa_glsl_compile_shader(ctx, sh);

+}

+

+

+/**

+ * Link a program's shaders.

+ */

+static void

+link_program(struct gl_context *ctx, GLuint program)

+{

+   struct gl_shader_program *shProg;

+   struct gl_transform_feedback_object *obj =

+      ctx->TransformFeedback.CurrentObject;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");

+   if (!shProg)

+      return;

+

+   if (obj->Active

+       && (shProg == ctx->Shader.CurrentVertexProgram

+	   || shProg == ctx->Shader.CurrentGeometryProgram

+	   || shProg == ctx->Shader.CurrentFragmentProgram)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glLinkProgram(transform feedback active");

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+

+   _mesa_glsl_link_shader(ctx, shProg);

+

+   /* debug code */

+   if (0) {

+      GLuint i;

+

+      printf("Link %u shaders in program %u: %s\n",

+                   shProg->NumShaders, shProg->Name,

+                   shProg->LinkStatus ? "Success" : "Failed");

+

+      for (i = 0; i < shProg->NumShaders; i++) {

+         printf(" shader %u, type 0x%x\n",

+                      shProg->Shaders[i]->Name,

+                      shProg->Shaders[i]->Type);

+      }

+   }

+}

+

+

+/**

+ * Print basic shader info (for debug).

+ */

+static void

+print_shader_info(const struct gl_shader_program *shProg)

+{

+   GLuint i;

+

+   printf("Mesa: glUseProgram(%u)\n", shProg->Name);

+   for (i = 0; i < shProg->NumShaders; i++) {

+      const char *s;

+      switch (shProg->Shaders[i]->Type) {

+      case GL_VERTEX_SHADER:

+         s = "vertex";

+         break;

+      case GL_FRAGMENT_SHADER:

+         s = "fragment";

+         break;

+      case GL_GEOMETRY_SHADER:

+         s = "geometry";

+         break;

+      default:

+         s = "";

+      }

+      printf("  %s shader %u, checksum %u\n", s, 

+	     shProg->Shaders[i]->Name,

+	     shProg->Shaders[i]->SourceChecksum);

+   }

+   if (shProg->VertexProgram)

+      printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);

+   if (shProg->FragmentProgram)

+      printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);

+}

+

+

+/**

+ * Use the named shader program for subsequent glUniform calls

+ */

+void

+_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,

+		     const char *caller)

+{

+   if ((shProg != NULL) && !shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+		  "%s(program %u not linked)", caller, shProg->Name);

+      return;

+   }

+

+   if (ctx->Shader.ActiveProgram != shProg) {

+      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);

+   }

+}

+

+/**

+ */

+static bool

+use_shader_program(struct gl_context *ctx, GLenum type,

+		   struct gl_shader_program *shProg)

+{

+   struct gl_shader_program **target;

+

+   switch (type) {

+#if FEATURE_ARB_vertex_shader

+   case GL_VERTEX_SHADER:

+      target = &ctx->Shader.CurrentVertexProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_SHADER_ARB:

+      target = &ctx->Shader.CurrentGeometryProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+#if FEATURE_ARB_fragment_shader

+   case GL_FRAGMENT_SHADER:

+      target = &ctx->Shader.CurrentFragmentProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+   default:

+      return false;

+   }

+

+   if (*target != shProg) {

+      FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);

+      _mesa_reference_shader_program(ctx, target, shProg);

+      return true;

+   }

+

+   return false;

+}

+

+/**

+ * Use the named shader program for subsequent rendering.

+ */

+void

+_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)

+{

+   use_shader_program(ctx, GL_VERTEX_SHADER, shProg);

+   use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);

+   use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);

+   _mesa_active_program(ctx, shProg, "glUseProgram");

+

+   if (ctx->Driver.UseProgram)

+      ctx->Driver.UseProgram(ctx, shProg);

+}

+

+

+/**

+ * Validate a program's samplers.

+ * Specifically, check that there aren't two samplers of different types

+ * pointing to the same texture unit.

+ * \return GL_TRUE if valid, GL_FALSE if invalid

+ */

+static GLboolean

+validate_samplers(const struct gl_program *prog, char *errMsg)

+{

+   static const char *targetName[] = {

+      "TEXTURE_2D_ARRAY",

+      "TEXTURE_1D_ARRAY",

+      "TEXTURE_CUBE",

+      "TEXTURE_3D",

+      "TEXTURE_RECT",

+      "TEXTURE_2D",

+      "TEXTURE_1D",

+   };

+   GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];

+   GLbitfield samplersUsed = prog->SamplersUsed;

+   GLuint i;

+

+   assert(Elements(targetName) == NUM_TEXTURE_TARGETS);

+

+   if (samplersUsed == 0x0)

+      return GL_TRUE;

+

+   for (i = 0; i < Elements(targetUsed); i++)

+      targetUsed[i] = -1;

+

+   /* walk over bits which are set in 'samplers' */

+   while (samplersUsed) {

+      GLuint unit;

+      gl_texture_index target;

+      GLint sampler = _mesa_ffs(samplersUsed) - 1;

+      assert(sampler >= 0);

+      assert(sampler < MAX_TEXTURE_IMAGE_UNITS);

+      unit = prog->SamplerUnits[sampler];

+      target = prog->SamplerTargets[sampler];

+      if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {

+         _mesa_snprintf(errMsg, 100,

+		  "Texture unit %d is accessed both as %s and %s",

+		  unit, targetName[targetUsed[unit]], targetName[target]);

+         return GL_FALSE;

+      }

+      targetUsed[unit] = target;

+      samplersUsed ^= (1 << sampler);

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do validation of the given shader program.

+ * \param errMsg  returns error message if validation fails.

+ * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)

+ */

+static GLboolean

+validate_shader_program(const struct gl_shader_program *shProg,

+                        char *errMsg)

+{

+   const struct gl_vertex_program *vp = shProg->VertexProgram;

+   const struct gl_fragment_program *fp = shProg->FragmentProgram;

+

+   if (!shProg->LinkStatus) {

+      return GL_FALSE;

+   }

+

+   /* From the GL spec, a program is invalid if any of these are true:

+

+     any two active samplers in the current program object are of

+     different types, but refer to the same texture image unit,

+

+     any active sampler in the current program object refers to a texture

+     image unit where fixed-function fragment processing accesses a

+     texture target that does not match the sampler type, or 

+

+     the sum of the number of active samplers in the program and the

+     number of texture image units enabled for fixed-function fragment

+     processing exceeds the combined limit on the total number of texture

+     image units allowed.

+   */

+

+

+   /*

+    * Check: any two active samplers in the current program object are of

+    * different types, but refer to the same texture image unit,

+    */

+   if (vp && !validate_samplers(&vp->Base, errMsg)) {

+      return GL_FALSE;

+   }

+   if (fp && !validate_samplers(&fp->Base, errMsg)) {

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Called via glValidateProgram()

+ */

+static void

+validate_program(struct gl_context *ctx, GLuint program)

+{

+   struct gl_shader_program *shProg;

+   char errMsg[100];

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");

+   if (!shProg) {

+      return;

+   }

+

+   shProg->Validated = validate_shader_program(shProg, errMsg);

+   if (!shProg->Validated) {

+      /* update info log */

+      if (shProg->InfoLog) {

+         ralloc_free(shProg->InfoLog);

+      }

+      shProg->InfoLog = ralloc_strdup(shProg, errMsg);

+   }

+}

+

+

+

+void GLAPIENTRY

+_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   attach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_AttachShader(GLuint program, GLuint shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   attach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,

+                            const GLcharARB *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   bind_attrib_location(ctx, program, index, name);

+}

+

+

+/* GL_EXT_gpu_shader4, GL3 */

+void GLAPIENTRY

+_mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,

+                           const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   bind_frag_data_location(ctx, program, colorNumber, name);

+}

+

+

+void GLAPIENTRY

+_mesa_CompileShaderARB(GLhandleARB shaderObj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);

+   compile_shader(ctx, shaderObj);

+}

+

+

+GLuint GLAPIENTRY

+_mesa_CreateShader(GLenum type)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));

+   return create_shader(ctx, type);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_CreateShaderObjectARB(GLenum type)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return create_shader(ctx, type);

+}

+

+

+GLuint GLAPIENTRY

+_mesa_CreateProgram(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCreateProgram\n");

+   return create_shader_program(ctx);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_CreateProgramObjectARB(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return create_shader_program(ctx);

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteObjectARB(GLhandleARB obj)

+{

+   if (MESA_VERBOSE & VERBOSE_API) {

+      GET_CURRENT_CONTEXT(ctx);

+      _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);

+   }

+

+   if (obj) {

+      GET_CURRENT_CONTEXT(ctx);

+      if (is_program(ctx, obj)) {

+         delete_shader_program(ctx, obj);

+      }

+      else if (is_shader(ctx, obj)) {

+         delete_shader(ctx, obj);

+      }

+      else {

+         /* error? */

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteProgram(GLuint name)

+{

+   if (name) {

+      GET_CURRENT_CONTEXT(ctx);

+      delete_shader_program(ctx, name);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteShader(GLuint name)

+{

+   if (name) {

+      GET_CURRENT_CONTEXT(ctx);

+      delete_shader(ctx, name);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   detach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_DetachShader(GLuint program, GLuint shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   detach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,

+                         GLsizei maxLength, GLsizei * length, GLint * size,

+                         GLenum * type, GLcharARB * name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_active_attrib(ctx, program, index, maxLength, length, size, type, name);

+}

+

+

+void GLAPIENTRY

+_mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,

+                            GLsizei * count, GLhandleARB * obj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_attached_shaders(ctx, container, maxCount, count, obj);

+}

+

+

+void GLAPIENTRY

+_mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,

+                         GLsizei *count, GLuint *obj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_attached_shaders(ctx, program, maxCount, count, obj);

+}

+

+

+GLint GLAPIENTRY

+_mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_attrib_location(ctx, program, name);

+}

+

+

+/* GL_EXT_gpu_shader4, GL3 */

+GLint GLAPIENTRY

+_mesa_GetFragDataLocation(GLuint program, const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_frag_data_location(ctx, program, name);

+}

+

+

+

+void GLAPIENTRY

+_mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,

+                    GLcharARB * infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (is_program(ctx, object)) {

+      get_program_info_log(ctx, object, maxLength, length, infoLog);

+   }

+   else if (is_shader(ctx, object)) {

+      get_shader_info_log(ctx, object, maxLength, length, infoLog);

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   /* Implement in terms of GetProgramiv, GetShaderiv */

+   if (is_program(ctx, object)) {

+      if (pname == GL_OBJECT_TYPE_ARB) {

+	 *params = GL_PROGRAM_OBJECT_ARB;

+      }

+      else {

+	 get_programiv(ctx, object, pname, params);

+      }

+   }

+   else if (is_shader(ctx, object)) {

+      if (pname == GL_OBJECT_TYPE_ARB) {

+	 *params = GL_SHADER_OBJECT_ARB;

+      }

+      else {

+	 get_shaderiv(ctx, object, pname, params);

+      }

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,

+                              GLfloat *params)

+{

+   GLint iparams[1];  /* XXX is one element enough? */

+   _mesa_GetObjectParameterivARB(object, pname, iparams);

+   params[0] = (GLfloat) iparams[0];

+}

+

+

+void GLAPIENTRY

+_mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_programiv(ctx, program, pname, params);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shaderiv(ctx, shader, pname, params);

+}

+

+

+void GLAPIENTRY

+_mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,

+                        GLsizei *length, GLchar *infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_program_info_log(ctx, program, bufSize, length, infoLog);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,

+                       GLsizei *length, GLchar *infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shader_info_log(ctx, shader, bufSize, length, infoLog);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,

+                         GLsizei *length, GLcharARB *sourceOut)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shader_source(ctx, shader, maxLength, length, sourceOut);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_GetHandleARB(GLenum pname)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_handle(ctx, pname);

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsProgram(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return is_program(ctx, name);

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsShader(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return is_shader(ctx, name);

+}

+

+

+void GLAPIENTRY

+_mesa_LinkProgramARB(GLhandleARB programObj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   link_program(ctx, programObj);

+}

+

+

+

+/**

+ * Read shader source code from a file.

+ * Useful for debugging to override an app's shader.

+ */

+static GLcharARB *

+read_shader(const char *fname)

+{

+   const int max = 50*1000;

+   FILE *f = fopen(fname, "r");

+   GLcharARB *buffer, *shader;

+   int len;

+

+   if (!f) {

+      return NULL;

+   }

+

+   buffer = (char *) malloc(max);

+   len = fread(buffer, 1, max, f);

+   buffer[len] = 0;

+

+   fclose(f);

+

+   shader = _mesa_strdup(buffer);

+   free(buffer);

+

+   return shader;

+}

+

+

+/**

+ * Called via glShaderSource() and glShaderSourceARB() API functions.

+ * Basically, concatenate the source code strings into one long string

+ * and pass it to _mesa_shader_source().

+ */

+void GLAPIENTRY

+_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,

+                      const GLcharARB ** string, const GLint * length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint *offsets;

+   GLsizei i, totalLength;

+   GLcharARB *source;

+   GLuint checksum;

+

+   if (!shaderObj || string == NULL) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");

+      return;

+   }

+

+   /*

+    * This array holds offsets of where the appropriate string ends, thus the

+    * last element will be set to the total length of the source code.

+    */

+   offsets = (GLint *) malloc(count * sizeof(GLint));

+   if (offsets == NULL) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");

+      return;

+   }

+

+   for (i = 0; i < count; i++) {

+      if (string[i] == NULL) {

+         free((GLvoid *) offsets);

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");

+         return;

+      }

+      if (length == NULL || length[i] < 0)

+         offsets[i] = strlen(string[i]);

+      else

+         offsets[i] = length[i];

+      /* accumulate string lengths */

+      if (i > 0)

+         offsets[i] += offsets[i - 1];

+   }

+

+   /* Total length of source string is sum off all strings plus two.

+    * One extra byte for terminating zero, another extra byte to silence

+    * valgrind warnings in the parser/grammer code.

+    */

+   totalLength = offsets[count - 1] + 2;

+   source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));

+   if (source == NULL) {

+      free((GLvoid *) offsets);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");

+      return;

+   }

+

+   for (i = 0; i < count; i++) {

+      GLint start = (i > 0) ? offsets[i - 1] : 0;

+      memcpy(source + start, string[i],

+             (offsets[i] - start) * sizeof(GLcharARB));

+   }

+   source[totalLength - 1] = '\0';

+   source[totalLength - 2] = '\0';

+

+   if (SHADER_SUBST) {

+      /* Compute the shader's source code checksum then try to open a file

+       * named newshader_<CHECKSUM>.  If it exists, use it in place of the

+       * original shader source code.  For debugging.

+       */

+      char filename[100];

+      GLcharARB *newSource;

+

+      checksum = _mesa_str_checksum(source);

+

+      _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);

+

+      newSource = read_shader(filename);

+      if (newSource) {

+         fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",

+                       shaderObj, checksum, filename);

+         free(source);

+         source = newSource;

+      }

+   }      

+

+   shader_source(ctx, shaderObj, source);

+

+   if (SHADER_SUBST) {

+      struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);

+      if (sh)

+         sh->SourceChecksum = checksum; /* save original checksum */

+   }

+

+   free(offsets);

+}

+

+

+void GLAPIENTRY

+_mesa_UseProgramObjectARB(GLhandleARB program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg;

+   struct gl_transform_feedback_object *obj =

+      ctx->TransformFeedback.CurrentObject;

+

+   if (obj->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glUseProgram(transform feedback active)");

+      return;

+   }

+

+   if (program) {

+      shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");

+      if (!shProg) {

+         return;

+      }

+      if (!shProg->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glUseProgram(program %u not linked)", program);

+         return;

+      }

+

+      /* debug code */

+      if (ctx->Shader.Flags & GLSL_USE_PROG) {

+         print_shader_info(shProg);

+      }

+   }

+   else {

+      shProg = NULL;

+   }

+

+   _mesa_use_program(ctx, shProg);

+}

+

+

+void GLAPIENTRY

+_mesa_ValidateProgramARB(GLhandleARB program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   validate_program(ctx, program);

+}

+

+#ifdef FEATURE_ES2

+

+void GLAPIENTRY

+_mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,

+                               GLint* range, GLint* precision)

+{

+   const struct gl_program_constants *limits;

+   const struct gl_precision *p;

+   GET_CURRENT_CONTEXT(ctx);

+

+   switch (shadertype) {

+   case GL_VERTEX_SHADER:

+      limits = &ctx->Const.VertexProgram;

+      break;

+   case GL_FRAGMENT_SHADER:

+      limits = &ctx->Const.FragmentProgram;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetShaderPrecisionFormat(shadertype)");

+      return;

+   }

+

+   switch (precisiontype) {

+   case GL_LOW_FLOAT:

+      p = &limits->LowFloat;

+      break;

+   case GL_MEDIUM_FLOAT:

+      p = &limits->MediumFloat;

+      break;

+   case GL_HIGH_FLOAT:

+      p = &limits->HighFloat;

+      break;

+   case GL_LOW_INT:

+      p = &limits->LowInt;

+      break;

+   case GL_MEDIUM_INT:

+      p = &limits->MediumInt;

+      break;

+   case GL_HIGH_INT:

+      p = &limits->HighInt;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetShaderPrecisionFormat(precisiontype)");

+      return;

+   }

+

+   range[0] = p->RangeMin;

+   range[1] = p->RangeMax;

+   precision[0] = p->Precision;

+}

+

+

+void GLAPIENTRY

+_mesa_ReleaseShaderCompiler(void)

+{

+   _mesa_destroy_shader_compiler_caches();

+}

+

+

+void GLAPIENTRY

+_mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,

+                   const void* binary, GLint length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) n;

+   (void) shaders;

+   (void) binaryformat;

+   (void) binary;

+   (void) length;

+   _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);

+}

+

+#endif /* FEATURE_ES2 */

+

+

+#if FEATURE_ARB_geometry_shader4

+

+void GLAPIENTRY

+_mesa_ProgramParameteriARB(GLuint program, GLenum pname,

+                           GLint value)

+{

+   struct gl_shader_program *shProg;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program,

+                                            "glProgramParameteri");

+   if (!shProg)

+      return;

+

+   switch (pname) {

+   case GL_GEOMETRY_VERTICES_OUT_ARB:

+      if (value < 1 ||

+          (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",

+                     value);

+         return;

+      }

+      shProg->Geom.VerticesOut = value;

+      break;

+   case GL_GEOMETRY_INPUT_TYPE_ARB:

+      switch (value) {

+      case GL_POINTS:

+      case GL_LINES:

+      case GL_LINES_ADJACENCY_ARB:

+      case GL_TRIANGLES:

+      case GL_TRIANGLES_ADJACENCY_ARB:

+         shProg->Geom.InputType = value;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(geometry input type = %s",

+                     _mesa_lookup_enum_by_nr(value));

+         return;

+      }

+      break;

+   case GL_GEOMETRY_OUTPUT_TYPE_ARB:

+      switch (value) {

+      case GL_POINTS:

+      case GL_LINE_STRIP:

+      case GL_TRIANGLE_STRIP:

+         shProg->Geom.OutputType = value;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(geometry output type = %s",

+                     _mesa_lookup_enum_by_nr(value));

+         return;

+      }

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",

+                  _mesa_lookup_enum_by_nr(pname));

+      break;

+   }

+}

+

+#endif

+

+void

+_mesa_use_shader_program(struct gl_context *ctx, GLenum type,

+			 struct gl_shader_program *shProg)

+{

+   use_shader_program(ctx, type, shProg);

+

+   if (ctx->Driver.UseProgram)

+      ctx->Driver.UseProgram(ctx, shProg);

+}

+

+void GLAPIENTRY

+_mesa_UseShaderProgramEXT(GLenum type, GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg = NULL;

+

+   if (!validate_shader_target(ctx, type)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");

+      return;

+   }

+

+   if (ctx->TransformFeedback.CurrentObject->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glUseShaderProgramEXT(transform feedback is active)");

+      return;

+   }

+

+   if (program) {

+      shProg = _mesa_lookup_shader_program_err(ctx, program,

+					       "glUseShaderProgramEXT");

+      if (shProg == NULL)

+	 return;

+

+      if (!shProg->LinkStatus) {

+	 _mesa_error(ctx, GL_INVALID_OPERATION,

+		     "glUseShaderProgramEXT(program not linked)");

+	 return;

+      }

+   }

+

+   _mesa_use_shader_program(ctx, type, shProg);

+}

+

+void GLAPIENTRY

+_mesa_ActiveProgramEXT(GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg = (program != 0)

+      ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")

+      : NULL;

+

+   _mesa_active_program(ctx, shProg, "glActiveProgramEXT");

+   return;

+}

+

+GLuint GLAPIENTRY

+_mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLuint shader = create_shader(ctx, type);

+   GLuint program = 0;

+

+   if (shader) {

+      shader_source(ctx, shader, _mesa_strdup(string));

+      compile_shader(ctx, shader);

+

+      program = create_shader_program(ctx);

+      if (program) {

+	 struct gl_shader_program *shProg;

+	 struct gl_shader *sh;

+	 GLint compiled = GL_FALSE;

+

+	 shProg = _mesa_lookup_shader_program(ctx, program);

+	 sh = _mesa_lookup_shader(ctx, shader);

+

+	 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);

+	 if (compiled) {

+	    attach_shader(ctx, program, shader);

+	    link_program(ctx, program);

+	    detach_shader(ctx, program, shader);

+

+#if 0

+	    /* Possibly... */

+	    if (active-user-defined-varyings-in-linked-program) {

+	       append-error-to-info-log;

+	       shProg->LinkStatus = GL_FALSE;

+	    }

+#endif

+	 }

+

+	 ralloc_strcat(&shProg->InfoLog, sh->InfoLog);

+      }

+

+      delete_shader(ctx, shader);

+   }

+

+   return program;

+}

+

+/**

+ * Plug in shader-related functions into API dispatch table.

+ */

+void

+_mesa_init_shader_dispatch(struct _glapi_table *exec)

+{

+#if FEATURE_GL

+   /* GL_ARB_vertex/fragment_shader */

+   SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);

+   SET_GetHandleARB(exec, _mesa_GetHandleARB);

+   SET_DetachObjectARB(exec, _mesa_DetachObjectARB);

+   SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);

+   SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);

+   SET_CompileShaderARB(exec, _mesa_CompileShaderARB);

+   SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);

+   SET_AttachObjectARB(exec, _mesa_AttachObjectARB);

+   SET_LinkProgramARB(exec, _mesa_LinkProgramARB);

+   SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);

+   SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);

+   SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);

+   SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);

+   SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);

+   SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);

+   SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);

+

+   /* OpenGL 2.0 */

+   SET_AttachShader(exec, _mesa_AttachShader);

+   SET_CreateProgram(exec, _mesa_CreateProgram);

+   SET_CreateShader(exec, _mesa_CreateShader);

+   SET_DeleteProgram(exec, _mesa_DeleteProgram);

+   SET_DeleteShader(exec, _mesa_DeleteShader);

+   SET_DetachShader(exec, _mesa_DetachShader);

+   SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);

+   SET_GetProgramiv(exec, _mesa_GetProgramiv);

+   SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);

+   SET_GetShaderiv(exec, _mesa_GetShaderiv);

+   SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);

+   SET_IsProgram(exec, _mesa_IsProgram);

+   SET_IsShader(exec, _mesa_IsShader);

+

+#if FEATURE_ARB_vertex_shader

+   SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);

+   SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);

+   SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);

+#endif

+

+   SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);

+   SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);

+   SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);

+

+   /* GL_EXT_gpu_shader4 / GL 3.0 */

+   SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);

+   SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);

+

+   /* GL_ARB_ES2_compatibility */

+   SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);

+   SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);

+

+#endif /* FEATURE_GL */

+}

+

diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index 502c42929..f11578faf 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -1,734 +1,734 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file state.c
- * State management.
- * 
- * This file manages recalculation of derived values in struct gl_context.
- */
-
-
-#include "glheader.h"
-#include "mtypes.h"
-#include "context.h"
-#include "debug.h"
-#include "macros.h"
-#include "ffvertex_prog.h"
-#include "framebuffer.h"
-#include "light.h"
-#include "matrix.h"
-#include "pixel.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "state.h"
-#include "stencil.h"
-#include "texenvprogram.h"
-#include "texobj.h"
-#include "texstate.h"
-
-
-static void
-update_separate_specular(struct gl_context *ctx)
-{
-   if (NEED_SECONDARY_COLOR(ctx))
-      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-   else
-      ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
-}
-
-
-/**
- * Compute the index of the last array element that can be safely accessed
- * in a vertex array.  We can really only do this when the array lives in
- * a VBO.
- * The array->_MaxElement field will be updated.
- * Later in glDrawArrays/Elements/etc we can do some bounds checking.
- */
-static void
-compute_max_element(struct gl_client_array *array)
-{
-   assert(array->Enabled);
-   if (array->BufferObj->Name) {
-      GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr;
-      GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size;
-
-      if (offset < obj_size) {
-	 array->_MaxElement = (obj_size - offset +
-			       array->StrideB -
-			       array->_ElementSize) / array->StrideB;
-      } else {
-	 array->_MaxElement = 0;
-      }
-   }
-   else {
-      /* user-space array, no idea how big it is */
-      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
-   }
-}
-
-
-/**
- * Helper for update_arrays().
- * \return  min(current min, array->_MaxElement).
- */
-static GLuint
-update_min(GLuint min, struct gl_client_array *array)
-{
-   compute_max_element(array);
-   return MIN2(min, array->_MaxElement);
-}
-
-
-/**
- * Update ctx->Array._MaxElement (the max legal index into all enabled arrays).
- * Need to do this upon new array state or new buffer object state.
- */
-static void
-update_arrays( struct gl_context *ctx )
-{
-   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-   GLuint i, min = ~0;
-
-   /* find min of _MaxElement values for all enabled arrays */
-
-   /* 0 */
-   if (ctx->VertexProgram._Current
-       && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);
-   }
-   else if (arrayObj->Vertex.Enabled) {
-      min = update_min(min, &arrayObj->Vertex);
-   }
-
-   /* 1 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]);
-   }
-   /* no conventional vertex weight array */
-
-   /* 2 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);
-   }
-   else if (arrayObj->Normal.Enabled) {
-      min = update_min(min, &arrayObj->Normal);
-   }
-
-   /* 3 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);
-   }
-   else if (arrayObj->Color.Enabled) {
-      min = update_min(min, &arrayObj->Color);
-   }
-
-   /* 4 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);
-   }
-   else if (arrayObj->SecondaryColor.Enabled) {
-      min = update_min(min, &arrayObj->SecondaryColor);
-   }
-
-   /* 5 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);
-   }
-   else if (arrayObj->FogCoord.Enabled) {
-      min = update_min(min, &arrayObj->FogCoord);
-   }
-
-   /* 6 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);
-   }
-   else if (arrayObj->Index.Enabled) {
-      min = update_min(min, &arrayObj->Index);
-   }
-
-   /* 7 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);
-   }
-
-   /* 8..15 */
-   for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {
-      if (ctx->VertexProgram._Enabled
-          && arrayObj->VertexAttrib[i].Enabled) {
-         min = update_min(min, &arrayObj->VertexAttrib[i]);
-      }
-      else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits
-               && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {
-         min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]);
-      }
-   }
-
-   /* 16..31 */
-   if (ctx->VertexProgram._Current) {
-      for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {
-         if (arrayObj->VertexAttrib[i].Enabled) {
-            min = update_min(min, &arrayObj->VertexAttrib[i]);
-         }
-      }
-   }
-
-   if (arrayObj->EdgeFlag.Enabled) {
-      min = update_min(min, &arrayObj->EdgeFlag);
-   }
-
-   /* _MaxElement is one past the last legal array element */
-   arrayObj->_MaxElement = min;
-}
-
-
-/**
- * Update the following fields:
- *   ctx->VertexProgram._Enabled
- *   ctx->FragmentProgram._Enabled
- *   ctx->ATIFragmentShader._Enabled
- * This needs to be done before texture state validation.
- */
-static void
-update_program_enables(struct gl_context *ctx)
-{
-   /* These _Enabled flags indicate if the program is enabled AND valid. */
-   ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled
-      && ctx->VertexProgram.Current->Base.Instructions;
-   ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled
-      && ctx->FragmentProgram.Current->Base.Instructions;
-   ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled
-      && ctx->ATIFragmentShader.Current->Instructions[0];
-}
-
-
-/**
- * Update vertex/fragment program state.  In particular, update these fields:
- *   ctx->VertexProgram._Current
- *   ctx->VertexProgram._TnlProgram,
- * These point to the highest priority enabled vertex/fragment program or are
- * NULL if fixed-function processing is to be done.
- *
- * This function needs to be called after texture state validation in case
- * we're generating a fragment program from fixed-function texture state.
- *
- * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex
- * or fragment program is being used.
- */
-static GLbitfield
-update_program(struct gl_context *ctx)
-{
-   const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram;
-   const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram;
-   const struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram;
-   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
-   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
-   const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;
-   GLbitfield new_state = 0x0;
-
-   /*
-    * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current
-    * pointers to the programs that should be used for rendering.  If either
-    * is NULL, use fixed-function code paths.
-    *
-    * These programs may come from several sources.  The priority is as
-    * follows:
-    *   1. OpenGL 2.0/ARB vertex/fragment shaders
-    *   2. ARB/NV vertex/fragment programs
-    *   3. Programs derived from fixed-function state.
-    *
-    * Note: it's possible for a vertex shader to get used with a fragment
-    * program (and vice versa) here, but in practice that shouldn't ever
-    * come up, or matter.
-    */
-
-   if (fsProg && fsProg->LinkStatus && fsProg->FragmentProgram) {
-      /* Use shader programs */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               fsProg->FragmentProgram);
-   }
-   else if (ctx->FragmentProgram._Enabled) {
-      /* use user-defined vertex program */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               ctx->FragmentProgram.Current);
-   }
-   else if (ctx->FragmentProgram._MaintainTexEnvProgram) {
-      /* Use fragment program generated from fixed-function state.
-       */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               _mesa_get_fixed_func_fragment_program(ctx));
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
-                               ctx->FragmentProgram._Current);
-   }
-   else {
-      /* no fragment program */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
-   }
-
-   if (gsProg && gsProg->LinkStatus && gsProg->GeometryProgram) {
-      /* Use shader programs */
-      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current,
-                               gsProg->GeometryProgram);
-   } else {
-      /* no fragment program */
-      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);
-   }
-
-   /* Examine vertex program after fragment program as
-    * _mesa_get_fixed_func_vertex_program() needs to know active
-    * fragprog inputs.
-    */
-   if (vsProg && vsProg->LinkStatus && vsProg->VertexProgram) {
-      /* Use shader programs */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                            vsProg->VertexProgram);
-   }
-   else if (ctx->VertexProgram._Enabled) {
-      /* use user-defined vertex program */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                               ctx->VertexProgram.Current);
-   }
-   else if (ctx->VertexProgram._MaintainTnlProgram) {
-      /* Use vertex program generated from fixed-function state.
-       */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                               _mesa_get_fixed_func_vertex_program(ctx));
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram,
-                               ctx->VertexProgram._Current);
-   }
-   else {
-      /* no vertex program */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
-   }
-
-   /* Let the driver know what's happening:
-    */
-   if (ctx->FragmentProgram._Current != prevFP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
-                          (struct gl_program *) ctx->FragmentProgram._Current);
-      }
-   }
-
-   if (ctx->GeometryProgram._Current != prevGP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM,
-                            (struct gl_program *) ctx->GeometryProgram._Current);
-      }
-   }
-
-   if (ctx->VertexProgram._Current != prevVP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
-                            (struct gl_program *) ctx->VertexProgram._Current);
-      }
-   }
-
-   return new_state;
-}
-
-
-/**
- * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0.
- */
-static GLbitfield
-update_program_constants(struct gl_context *ctx)
-{
-   GLbitfield new_state = 0x0;
-
-   if (ctx->FragmentProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->FragmentProgram._Current->Base.Parameters;
-      if (params && params->StateFlags & ctx->NewState) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   if (ctx->GeometryProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->GeometryProgram._Current->Base.Parameters;
-      /*FIXME: StateFlags is always 0 because we have unnamed constant
-       *       not state changes */
-      if (params /*&& params->StateFlags & ctx->NewState*/) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   if (ctx->VertexProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->VertexProgram._Current->Base.Parameters;
-      if (params && params->StateFlags & ctx->NewState) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   return new_state;
-}
-
-
-
-
-static void
-update_viewport_matrix(struct gl_context *ctx)
-{
-   const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
-
-   ASSERT(depthMax > 0);
-
-   /* Compute scale and bias values. This is really driver-specific
-    * and should be maintained elsewhere if at all.
-    * NOTE: RasterPos uses this.
-    */
-   _math_matrix_viewport(&ctx->Viewport._WindowMap,
-                         ctx->Viewport.X, ctx->Viewport.Y,
-                         ctx->Viewport.Width, ctx->Viewport.Height,
-                         ctx->Viewport.Near, ctx->Viewport.Far,
-                         depthMax);
-}
-
-
-/**
- * Update derived multisample state.
- */
-static void
-update_multisample(struct gl_context *ctx)
-{
-   ctx->Multisample._Enabled = GL_FALSE;
-   if (ctx->Multisample.Enabled &&
-       ctx->DrawBuffer &&
-       ctx->DrawBuffer->Visual.sampleBuffers)
-      ctx->Multisample._Enabled = GL_TRUE;
-}
-
-
-/**
- * Update derived color/blend/logicop state.
- */
-static void
-update_color(struct gl_context *ctx)
-{
-   /* This is needed to support 1.1's RGB logic ops AND
-    * 1.0's blending logicops.
-    */
-   ctx->Color._LogicOpEnabled = RGBA_LOGICOP_ENABLED(ctx);
-}
-
-
-/*
- * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET
- * in ctx->_TriangleCaps if needed.
- */
-static void
-update_polygon(struct gl_context *ctx)
-{
-   ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET);
-
-   if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
-      ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-
-   if (   ctx->Polygon.OffsetPoint
-       || ctx->Polygon.OffsetLine
-       || ctx->Polygon.OffsetFill)
-      ctx->_TriangleCaps |= DD_TRI_OFFSET;
-}
-
-
-/**
- * Update the ctx->_TriangleCaps bitfield.
- * XXX that bitfield should really go away someday!
- * This function must be called after other update_*() functions since
- * there are dependencies on some other derived values.
- */
-#if 0
-static void
-update_tricaps(struct gl_context *ctx, GLbitfield new_state)
-{
-   ctx->_TriangleCaps = 0;
-
-   /*
-    * Points
-    */
-   if (1/*new_state & _NEW_POINT*/) {
-      if (ctx->Point.SmoothFlag)
-         ctx->_TriangleCaps |= DD_POINT_SMOOTH;
-      if (ctx->Point._Attenuated)
-         ctx->_TriangleCaps |= DD_POINT_ATTEN;
-   }
-
-   /*
-    * Lines
-    */
-   if (1/*new_state & _NEW_LINE*/) {
-      if (ctx->Line.SmoothFlag)
-         ctx->_TriangleCaps |= DD_LINE_SMOOTH;
-      if (ctx->Line.StippleFlag)
-         ctx->_TriangleCaps |= DD_LINE_STIPPLE;
-   }
-
-   /*
-    * Polygons
-    */
-   if (1/*new_state & _NEW_POLYGON*/) {
-      if (ctx->Polygon.SmoothFlag)
-         ctx->_TriangleCaps |= DD_TRI_SMOOTH;
-      if (ctx->Polygon.StippleFlag)
-         ctx->_TriangleCaps |= DD_TRI_STIPPLE;
-      if (ctx->Polygon.FrontMode != GL_FILL
-          || ctx->Polygon.BackMode != GL_FILL)
-         ctx->_TriangleCaps |= DD_TRI_UNFILLED;
-      if (ctx->Polygon.CullFlag
-          && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
-         ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-      if (ctx->Polygon.OffsetPoint ||
-          ctx->Polygon.OffsetLine ||
-          ctx->Polygon.OffsetFill)
-         ctx->_TriangleCaps |= DD_TRI_OFFSET;
-   }
-
-   /*
-    * Lighting and shading
-    */
-   if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
-      ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
-   if (ctx->Light.ShadeModel == GL_FLAT)
-      ctx->_TriangleCaps |= DD_FLATSHADE;
-   if (NEED_SECONDARY_COLOR(ctx))
-      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-
-   /*
-    * Stencil
-    */
-   if (ctx->Stencil._TestTwoSide)
-      ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
-}
-#endif
-
-
-/**
- * Compute derived GL state.
- * If __struct gl_contextRec::NewState is non-zero then this function \b must
- * be called before rendering anything.
- *
- * Calls dd_function_table::UpdateState to perform any internal state
- * management necessary.
- * 
- * \sa _mesa_update_modelview_project(), _mesa_update_texture(),
- * _mesa_update_buffer_bounds(),
- * _mesa_update_lighting() and _mesa_update_tnl_spaces().
- */
-void
-_mesa_update_state_locked( struct gl_context *ctx )
-{
-   GLbitfield new_state = ctx->NewState;
-   GLbitfield prog_flags = _NEW_PROGRAM;
-   GLbitfield new_prog_state = 0x0;
-
-   if (new_state == _NEW_CURRENT_ATTRIB) 
-      goto out;
-
-   if (MESA_VERBOSE & VERBOSE_STATE)
-      _mesa_print_state("_mesa_update_state", new_state);
-
-   /* Determine which state flags effect vertex/fragment program state */
-   if (ctx->FragmentProgram._MaintainTexEnvProgram) {
-      prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |
-		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |
-		     _NEW_PROGRAM);
-   }
-   if (ctx->VertexProgram._MaintainTnlProgram) {
-      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
-                     _NEW_TRANSFORM | _NEW_POINT |
-                     _NEW_FOG | _NEW_LIGHT |
-                     _MESA_NEW_NEED_EYE_COORDS);
-   }
-
-   /*
-    * Now update derived state info
-    */
-
-   if (new_state & prog_flags)
-      update_program_enables( ctx );
-
-   if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
-      _mesa_update_modelview_project( ctx, new_state );
-
-   if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))
-      _mesa_update_texture( ctx, new_state );
-
-   if (new_state & _NEW_BUFFERS)
-      _mesa_update_framebuffer(ctx);
-
-   if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))
-      _mesa_update_draw_buffer_bounds( ctx );
-
-   if (new_state & _NEW_POLYGON)
-      update_polygon( ctx );
-
-   if (new_state & _NEW_LIGHT)
-      _mesa_update_lighting( ctx );
-
-   if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
-      _mesa_update_stencil( ctx );
-
-   if (new_state & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_pixel( ctx, new_state );
-
-   if (new_state & _DD_NEW_SEPARATE_SPECULAR)
-      update_separate_specular( ctx );
-
-   if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
-      update_viewport_matrix(ctx);
-
-   if (new_state & _NEW_MULTISAMPLE)
-      update_multisample( ctx );
-
-   if (new_state & _NEW_COLOR)
-      update_color( ctx );
-
-#if 0
-   if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT
-                    | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))
-      update_tricaps( ctx, new_state );
-#endif
-
-   /* ctx->_NeedEyeCoords is now up to date.
-    *
-    * If the truth value of this variable has changed, update for the
-    * new lighting space and recompute the positions of lights and the
-    * normal transform.
-    *
-    * If the lighting space hasn't changed, may still need to recompute
-    * light positions & normal transforms for other reasons.
-    */
-   if (new_state & _MESA_NEW_NEED_EYE_COORDS) 
-      _mesa_update_tnl_spaces( ctx, new_state );
-
-   if (new_state & prog_flags) {
-      /* When we generate programs from fixed-function vertex/fragment state
-       * this call may generate/bind a new program.  If so, we need to
-       * propogate the _NEW_PROGRAM flag to the driver.
-       */
-      new_prog_state |= update_program( ctx );
-   }
-
-   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
-      update_arrays( ctx );
-
- out:
-   new_prog_state |= update_program_constants(ctx);
-
-   /*
-    * Give the driver a chance to act upon the new_state flags.
-    * The driver might plug in different span functions, for example.
-    * Also, this is where the driver can invalidate the state of any
-    * active modules (such as swrast_setup, swrast, tnl, etc).
-    *
-    * Set ctx->NewState to zero to avoid recursion if
-    * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)
-    */
-   new_state = ctx->NewState | new_prog_state;
-   ctx->NewState = 0;
-   ctx->Driver.UpdateState(ctx, new_state);
-   ctx->Array.NewState = 0;
-   if (!ctx->Array.RebindArrays)
-      ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;
-}
-
-
-/* This is the usual entrypoint for state updates:
- */
-void
-_mesa_update_state( struct gl_context *ctx )
-{
-   _mesa_lock_context_textures(ctx);
-   _mesa_update_state_locked(ctx);
-   _mesa_unlock_context_textures(ctx);
-}
-
-
-
-
-/**
- * Want to figure out which fragment program inputs are actually
- * constant/current values from ctx->Current.  These should be
- * referenced as a tracked state variable rather than a fragment
- * program input, to save the overhead of putting a constant value in
- * every submitted vertex, transferring it to hardware, interpolating
- * it across the triangle, etc...
- *
- * When there is a VP bound, just use vp->outputs.  But when we're
- * generating vp from fixed function state, basically want to
- * calculate:
- *
- * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 
- *                 potential_vp_outputs )
- *
- * Where potential_vp_outputs is calculated by looking at enabled
- * texgen, etc.
- * 
- * The generated fragment program should then only declare inputs that
- * may vary or otherwise differ from the ctx->Current values.
- * Otherwise, the fp should track them as state values instead.
- */
-void
-_mesa_set_varying_vp_inputs( struct gl_context *ctx,
-                             GLbitfield varying_inputs )
-{
-   if (ctx->varying_vp_inputs != varying_inputs) {
-      ctx->varying_vp_inputs = varying_inputs;
-      ctx->NewState |= _NEW_ARRAY;
-      /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/
-   }
-}
-
-
-/**
- * Used by drivers to tell core Mesa that the driver is going to
- * install/ use its own vertex program.  In particular, this will
- * prevent generated fragment programs from using state vars instead
- * of ordinary varyings/inputs.
- */
-void
-_mesa_set_vp_override(struct gl_context *ctx, GLboolean flag)
-{
-   if (ctx->VertexProgram._Overriden != flag) {
-      ctx->VertexProgram._Overriden = flag;
-
-      /* Set one of the bits which will trigger fragment program
-       * regeneration:
-       */
-      ctx->NewState |= _NEW_PROGRAM;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file state.c

+ * State management.

+ * 

+ * This file manages recalculation of derived values in struct gl_context.

+ */

+

+

+#include "glheader.h"

+#include "mtypes.h"

+#include "context.h"

+#include "debug.h"

+#include "macros.h"

+#include "ffvertex_prog.h"

+#include "framebuffer.h"

+#include "light.h"

+#include "matrix.h"

+#include "pixel.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "state.h"

+#include "stencil.h"

+#include "texenvprogram.h"

+#include "texobj.h"

+#include "texstate.h"

+

+

+static void

+update_separate_specular(struct gl_context *ctx)

+{

+   if (NEED_SECONDARY_COLOR(ctx))

+      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;

+   else

+      ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;

+}

+

+

+/**

+ * Compute the index of the last array element that can be safely accessed

+ * in a vertex array.  We can really only do this when the array lives in

+ * a VBO.

+ * The array->_MaxElement field will be updated.

+ * Later in glDrawArrays/Elements/etc we can do some bounds checking.

+ */

+static void

+compute_max_element(struct gl_client_array *array)

+{

+   assert(array->Enabled);

+   if (array->BufferObj->Name) {

+      GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr;

+      GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size;

+

+      if (offset < obj_size) {

+	 array->_MaxElement = (obj_size - offset +

+			       array->StrideB -

+			       array->_ElementSize) / array->StrideB;

+      } else {

+	 array->_MaxElement = 0;

+      }

+   }

+   else {

+      /* user-space array, no idea how big it is */

+      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */

+   }

+}

+

+

+/**

+ * Helper for update_arrays().

+ * \return  min(current min, array->_MaxElement).

+ */

+static GLuint

+update_min(GLuint min, struct gl_client_array *array)

+{

+   compute_max_element(array);

+   return MIN2(min, array->_MaxElement);

+}

+

+

+/**

+ * Update ctx->Array._MaxElement (the max legal index into all enabled arrays).

+ * Need to do this upon new array state or new buffer object state.

+ */

+static void

+update_arrays( struct gl_context *ctx )

+{

+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+   GLuint i, min = ~0;

+

+   /* find min of _MaxElement values for all enabled arrays */

+

+   /* 0 */

+   if (ctx->VertexProgram._Current

+       && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);

+   }

+   else if (arrayObj->Vertex.Enabled) {

+      min = update_min(min, &arrayObj->Vertex);

+   }

+

+   /* 1 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]);

+   }

+   /* no conventional vertex weight array */

+

+   /* 2 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);

+   }

+   else if (arrayObj->Normal.Enabled) {

+      min = update_min(min, &arrayObj->Normal);

+   }

+

+   /* 3 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);

+   }

+   else if (arrayObj->Color.Enabled) {

+      min = update_min(min, &arrayObj->Color);

+   }

+

+   /* 4 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);

+   }

+   else if (arrayObj->SecondaryColor.Enabled) {

+      min = update_min(min, &arrayObj->SecondaryColor);

+   }

+

+   /* 5 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);

+   }

+   else if (arrayObj->FogCoord.Enabled) {

+      min = update_min(min, &arrayObj->FogCoord);

+   }

+

+   /* 6 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);

+   }

+   else if (arrayObj->Index.Enabled) {

+      min = update_min(min, &arrayObj->Index);

+   }

+

+   /* 7 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);

+   }

+

+   /* 8..15 */

+   for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {

+      if (ctx->VertexProgram._Enabled

+          && arrayObj->VertexAttrib[i].Enabled) {

+         min = update_min(min, &arrayObj->VertexAttrib[i]);

+      }

+      else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits

+               && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {

+         min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]);

+      }

+   }

+

+   /* 16..31 */

+   if (ctx->VertexProgram._Current) {

+      for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {

+         if (arrayObj->VertexAttrib[i].Enabled) {

+            min = update_min(min, &arrayObj->VertexAttrib[i]);

+         }

+      }

+   }

+

+   if (arrayObj->EdgeFlag.Enabled) {

+      min = update_min(min, &arrayObj->EdgeFlag);

+   }

+

+   /* _MaxElement is one past the last legal array element */

+   arrayObj->_MaxElement = min;

+}

+

+

+/**

+ * Update the following fields:

+ *   ctx->VertexProgram._Enabled

+ *   ctx->FragmentProgram._Enabled

+ *   ctx->ATIFragmentShader._Enabled

+ * This needs to be done before texture state validation.

+ */

+static void

+update_program_enables(struct gl_context *ctx)

+{

+   /* These _Enabled flags indicate if the program is enabled AND valid. */

+   ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled

+      && ctx->VertexProgram.Current->Base.Instructions;

+   ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled

+      && ctx->FragmentProgram.Current->Base.Instructions;

+   ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled

+      && ctx->ATIFragmentShader.Current->Instructions[0];

+}

+

+

+/**

+ * Update vertex/fragment program state.  In particular, update these fields:

+ *   ctx->VertexProgram._Current

+ *   ctx->VertexProgram._TnlProgram,

+ * These point to the highest priority enabled vertex/fragment program or are

+ * NULL if fixed-function processing is to be done.

+ *

+ * This function needs to be called after texture state validation in case

+ * we're generating a fragment program from fixed-function texture state.

+ *

+ * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex

+ * or fragment program is being used.

+ */

+static GLbitfield

+update_program(struct gl_context *ctx)

+{

+   const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram;

+   const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram;

+   const struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram;

+   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;

+   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;

+   const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;

+   GLbitfield new_state = 0x0;

+

+   /*

+    * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current

+    * pointers to the programs that should be used for rendering.  If either

+    * is NULL, use fixed-function code paths.

+    *

+    * These programs may come from several sources.  The priority is as

+    * follows:

+    *   1. OpenGL 2.0/ARB vertex/fragment shaders

+    *   2. ARB/NV vertex/fragment programs

+    *   3. Programs derived from fixed-function state.

+    *

+    * Note: it's possible for a vertex shader to get used with a fragment

+    * program (and vice versa) here, but in practice that shouldn't ever

+    * come up, or matter.

+    */

+

+   if (fsProg && fsProg->LinkStatus && fsProg->FragmentProgram) {

+      /* Use shader programs */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               fsProg->FragmentProgram);

+   }

+   else if (ctx->FragmentProgram._Enabled) {

+      /* use user-defined vertex program */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               ctx->FragmentProgram.Current);

+   }

+   else if (ctx->FragmentProgram._MaintainTexEnvProgram) {

+      /* Use fragment program generated from fixed-function state.

+       */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               _mesa_get_fixed_func_fragment_program(ctx));

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,

+                               ctx->FragmentProgram._Current);

+   }

+   else {

+      /* no fragment program */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);

+   }

+

+   if (gsProg && gsProg->LinkStatus && gsProg->GeometryProgram) {

+      /* Use shader programs */

+      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current,

+                               gsProg->GeometryProgram);

+   } else {

+      /* no fragment program */

+      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);

+   }

+

+   /* Examine vertex program after fragment program as

+    * _mesa_get_fixed_func_vertex_program() needs to know active

+    * fragprog inputs.

+    */

+   if (vsProg && vsProg->LinkStatus && vsProg->VertexProgram) {

+      /* Use shader programs */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                            vsProg->VertexProgram);

+   }

+   else if (ctx->VertexProgram._Enabled) {

+      /* use user-defined vertex program */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                               ctx->VertexProgram.Current);

+   }

+   else if (ctx->VertexProgram._MaintainTnlProgram) {

+      /* Use vertex program generated from fixed-function state.

+       */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                               _mesa_get_fixed_func_vertex_program(ctx));

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram,

+                               ctx->VertexProgram._Current);

+   }

+   else {

+      /* no vertex program */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);

+   }

+

+   /* Let the driver know what's happening:

+    */

+   if (ctx->FragmentProgram._Current != prevFP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,

+                          (struct gl_program *) ctx->FragmentProgram._Current);

+      }

+   }

+

+   if (ctx->GeometryProgram._Current != prevGP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM,

+                            (struct gl_program *) ctx->GeometryProgram._Current);

+      }

+   }

+

+   if (ctx->VertexProgram._Current != prevVP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,

+                            (struct gl_program *) ctx->VertexProgram._Current);

+      }

+   }

+

+   return new_state;

+}

+

+

+/**

+ * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0.

+ */

+static GLbitfield

+update_program_constants(struct gl_context *ctx)

+{

+   GLbitfield new_state = 0x0;

+

+   if (ctx->FragmentProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->FragmentProgram._Current->Base.Parameters;

+      if (params && params->StateFlags & ctx->NewState) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   if (ctx->GeometryProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->GeometryProgram._Current->Base.Parameters;

+      /*FIXME: StateFlags is always 0 because we have unnamed constant

+       *       not state changes */

+      if (params /*&& params->StateFlags & ctx->NewState*/) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   if (ctx->VertexProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->VertexProgram._Current->Base.Parameters;

+      if (params && params->StateFlags & ctx->NewState) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   return new_state;

+}

+

+

+

+

+static void

+update_viewport_matrix(struct gl_context *ctx)

+{

+   const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;

+

+   ASSERT(depthMax > 0);

+

+   /* Compute scale and bias values. This is really driver-specific

+    * and should be maintained elsewhere if at all.

+    * NOTE: RasterPos uses this.

+    */

+   _math_matrix_viewport(&ctx->Viewport._WindowMap,

+                         ctx->Viewport.X, ctx->Viewport.Y,

+                         ctx->Viewport.Width, ctx->Viewport.Height,

+                         ctx->Viewport.Near, ctx->Viewport.Far,

+                         depthMax);

+}

+

+

+/**

+ * Update derived multisample state.

+ */

+static void

+update_multisample(struct gl_context *ctx)

+{

+   ctx->Multisample._Enabled = GL_FALSE;

+   if (ctx->Multisample.Enabled &&

+       ctx->DrawBuffer &&

+       ctx->DrawBuffer->Visual.sampleBuffers)

+      ctx->Multisample._Enabled = GL_TRUE;

+}

+

+

+/**

+ * Update derived color/blend/logicop state.

+ */

+static void

+update_color(struct gl_context *ctx)

+{

+   /* This is needed to support 1.1's RGB logic ops AND

+    * 1.0's blending logicops.

+    */

+   ctx->Color._LogicOpEnabled = RGBA_LOGICOP_ENABLED(ctx);

+}

+

+

+/*

+ * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET

+ * in ctx->_TriangleCaps if needed.

+ */

+static void

+update_polygon(struct gl_context *ctx)

+{

+   ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET);

+

+   if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)

+      ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;

+

+   if (   ctx->Polygon.OffsetPoint

+       || ctx->Polygon.OffsetLine

+       || ctx->Polygon.OffsetFill)

+      ctx->_TriangleCaps |= DD_TRI_OFFSET;

+}

+

+

+/**

+ * Update the ctx->_TriangleCaps bitfield.

+ * XXX that bitfield should really go away someday!

+ * This function must be called after other update_*() functions since

+ * there are dependencies on some other derived values.

+ */

+#if 0

+static void

+update_tricaps(struct gl_context *ctx, GLbitfield new_state)

+{

+   ctx->_TriangleCaps = 0;

+

+   /*

+    * Points

+    */

+   if (1/*new_state & _NEW_POINT*/) {

+      if (ctx->Point.SmoothFlag)

+         ctx->_TriangleCaps |= DD_POINT_SMOOTH;

+      if (ctx->Point._Attenuated)

+         ctx->_TriangleCaps |= DD_POINT_ATTEN;

+   }

+

+   /*

+    * Lines

+    */

+   if (1/*new_state & _NEW_LINE*/) {

+      if (ctx->Line.SmoothFlag)

+         ctx->_TriangleCaps |= DD_LINE_SMOOTH;

+      if (ctx->Line.StippleFlag)

+         ctx->_TriangleCaps |= DD_LINE_STIPPLE;

+   }

+

+   /*

+    * Polygons

+    */

+   if (1/*new_state & _NEW_POLYGON*/) {

+      if (ctx->Polygon.SmoothFlag)

+         ctx->_TriangleCaps |= DD_TRI_SMOOTH;

+      if (ctx->Polygon.StippleFlag)

+         ctx->_TriangleCaps |= DD_TRI_STIPPLE;

+      if (ctx->Polygon.FrontMode != GL_FILL

+          || ctx->Polygon.BackMode != GL_FILL)

+         ctx->_TriangleCaps |= DD_TRI_UNFILLED;

+      if (ctx->Polygon.CullFlag

+          && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)

+         ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;

+      if (ctx->Polygon.OffsetPoint ||

+          ctx->Polygon.OffsetLine ||

+          ctx->Polygon.OffsetFill)

+         ctx->_TriangleCaps |= DD_TRI_OFFSET;

+   }

+

+   /*

+    * Lighting and shading

+    */

+   if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)

+      ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;

+   if (ctx->Light.ShadeModel == GL_FLAT)

+      ctx->_TriangleCaps |= DD_FLATSHADE;

+   if (NEED_SECONDARY_COLOR(ctx))

+      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;

+

+   /*

+    * Stencil

+    */

+   if (ctx->Stencil._TestTwoSide)

+      ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;

+}

+#endif

+

+

+/**

+ * Compute derived GL state.

+ * If __struct gl_contextRec::NewState is non-zero then this function \b must

+ * be called before rendering anything.

+ *

+ * Calls dd_function_table::UpdateState to perform any internal state

+ * management necessary.

+ * 

+ * \sa _mesa_update_modelview_project(), _mesa_update_texture(),

+ * _mesa_update_buffer_bounds(),

+ * _mesa_update_lighting() and _mesa_update_tnl_spaces().

+ */

+void

+_mesa_update_state_locked( struct gl_context *ctx )

+{

+   GLbitfield new_state = ctx->NewState;

+   GLbitfield prog_flags = _NEW_PROGRAM;

+   GLbitfield new_prog_state = 0x0;

+

+   if (new_state == _NEW_CURRENT_ATTRIB) 

+      goto out;

+

+   if (MESA_VERBOSE & VERBOSE_STATE)

+      _mesa_print_state("_mesa_update_state", new_state);

+

+   /* Determine which state flags effect vertex/fragment program state */

+   if (ctx->FragmentProgram._MaintainTexEnvProgram) {

+      prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |

+		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |

+		     _NEW_PROGRAM);

+   }

+   if (ctx->VertexProgram._MaintainTnlProgram) {

+      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |

+                     _NEW_TRANSFORM | _NEW_POINT |

+                     _NEW_FOG | _NEW_LIGHT |

+                     _MESA_NEW_NEED_EYE_COORDS);

+   }

+

+   /*

+    * Now update derived state info

+    */

+

+   if (new_state & prog_flags)

+      update_program_enables( ctx );

+

+   if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))

+      _mesa_update_modelview_project( ctx, new_state );

+

+   if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))

+      _mesa_update_texture( ctx, new_state );

+

+   if (new_state & _NEW_BUFFERS)

+      _mesa_update_framebuffer(ctx);

+

+   if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))

+      _mesa_update_draw_buffer_bounds( ctx );

+

+   if (new_state & _NEW_POLYGON)

+      update_polygon( ctx );

+

+   if (new_state & _NEW_LIGHT)

+      _mesa_update_lighting( ctx );

+

+   if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))

+      _mesa_update_stencil( ctx );

+

+   if (new_state & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_pixel( ctx, new_state );

+

+   if (new_state & _DD_NEW_SEPARATE_SPECULAR)

+      update_separate_specular( ctx );

+

+   if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))

+      update_viewport_matrix(ctx);

+

+   if (new_state & _NEW_MULTISAMPLE)

+      update_multisample( ctx );

+

+   if (new_state & _NEW_COLOR)

+      update_color( ctx );

+

+#if 0

+   if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT

+                    | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))

+      update_tricaps( ctx, new_state );

+#endif

+

+   /* ctx->_NeedEyeCoords is now up to date.

+    *

+    * If the truth value of this variable has changed, update for the

+    * new lighting space and recompute the positions of lights and the

+    * normal transform.

+    *

+    * If the lighting space hasn't changed, may still need to recompute

+    * light positions & normal transforms for other reasons.

+    */

+   if (new_state & _MESA_NEW_NEED_EYE_COORDS) 

+      _mesa_update_tnl_spaces( ctx, new_state );

+

+   if (new_state & prog_flags) {

+      /* When we generate programs from fixed-function vertex/fragment state

+       * this call may generate/bind a new program.  If so, we need to

+       * propogate the _NEW_PROGRAM flag to the driver.

+       */

+      new_prog_state |= update_program( ctx );

+   }

+

+   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))

+      update_arrays( ctx );

+

+ out:

+   new_prog_state |= update_program_constants(ctx);

+

+   /*

+    * Give the driver a chance to act upon the new_state flags.

+    * The driver might plug in different span functions, for example.

+    * Also, this is where the driver can invalidate the state of any

+    * active modules (such as swrast_setup, swrast, tnl, etc).

+    *

+    * Set ctx->NewState to zero to avoid recursion if

+    * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)

+    */

+   new_state = ctx->NewState | new_prog_state;

+   ctx->NewState = 0;

+   ctx->Driver.UpdateState(ctx, new_state);

+   ctx->Array.NewState = 0;

+   if (!ctx->Array.RebindArrays)

+      ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;

+}

+

+

+/* This is the usual entrypoint for state updates:

+ */

+void

+_mesa_update_state( struct gl_context *ctx )

+{

+   _mesa_lock_context_textures(ctx);

+   _mesa_update_state_locked(ctx);

+   _mesa_unlock_context_textures(ctx);

+}

+

+

+

+

+/**

+ * Want to figure out which fragment program inputs are actually

+ * constant/current values from ctx->Current.  These should be

+ * referenced as a tracked state variable rather than a fragment

+ * program input, to save the overhead of putting a constant value in

+ * every submitted vertex, transferring it to hardware, interpolating

+ * it across the triangle, etc...

+ *

+ * When there is a VP bound, just use vp->outputs.  But when we're

+ * generating vp from fixed function state, basically want to

+ * calculate:

+ *

+ * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 

+ *                 potential_vp_outputs )

+ *

+ * Where potential_vp_outputs is calculated by looking at enabled

+ * texgen, etc.

+ * 

+ * The generated fragment program should then only declare inputs that

+ * may vary or otherwise differ from the ctx->Current values.

+ * Otherwise, the fp should track them as state values instead.

+ */

+void

+_mesa_set_varying_vp_inputs( struct gl_context *ctx,

+                             GLbitfield varying_inputs )

+{

+   if (ctx->varying_vp_inputs != varying_inputs) {

+      ctx->varying_vp_inputs = varying_inputs;

+      ctx->NewState |= _NEW_ARRAY;

+      /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/

+   }

+}

+

+

+/**

+ * Used by drivers to tell core Mesa that the driver is going to

+ * install/ use its own vertex program.  In particular, this will

+ * prevent generated fragment programs from using state vars instead

+ * of ordinary varyings/inputs.

+ */

+void

+_mesa_set_vp_override(struct gl_context *ctx, GLboolean flag)

+{

+   if (ctx->VertexProgram._Overriden != flag) {

+      ctx->VertexProgram._Overriden = flag;

+

+      /* Set one of the bits which will trigger fragment program

+       * regeneration:

+       */

+      ctx->NewState |= _NEW_PROGRAM;

+   }

+}

diff --git a/mesalib/src/mesa/main/stencil.c b/mesalib/src/mesa/main/stencil.c
index d898bf1d7..b49ddbdbb 100644
--- a/mesalib/src/mesa/main/stencil.c
+++ b/mesalib/src/mesa/main/stencil.c
@@ -1,614 +1,614 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file stencil.c
- * Stencil operations.
- *
- * Note: There's some conflict between GL_EXT_stencil_two_side and
- * OpenGL 2.0's two-sided stencil feature.
- *
- * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the
- * front OR back face state (as set by glActiveStencilFaceEXT) is set.
- *
- * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the
- * front AND back state.
- *
- * Also, note that GL_ATI_separate_stencil is different as well:
- * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...)  vs.
- * glStencilFuncSeparate(GLenum face, GLenum func, ...).
- *
- * This problem is solved by keeping three sets of stencil state:
- *  state[0] = GL_FRONT state.
- *  state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state.
- *  state[2] = GL_EXT_stencil_two_side GL_BACK state.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "context.h"
-#include "macros.h"
-#include "stencil.h"
-#include "mtypes.h"
-
-
-static GLboolean
-validate_stencil_op(struct gl_context *ctx, GLenum op)
-{
-   switch (op) {
-   case GL_KEEP:
-   case GL_ZERO:
-   case GL_REPLACE:
-   case GL_INCR:
-   case GL_DECR:
-   case GL_INVERT:
-      return GL_TRUE;
-   case GL_INCR_WRAP_EXT:
-   case GL_DECR_WRAP_EXT:
-      if (ctx->Extensions.EXT_stencil_wrap) {
-         return GL_TRUE;
-      }
-      /* FALL-THROUGH */
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-static GLboolean
-validate_stencil_func(struct gl_context *ctx, GLenum func)
-{
-   switch (func) {
-   case GL_NEVER:
-   case GL_LESS:
-   case GL_LEQUAL:
-   case GL_GREATER:
-   case GL_GEQUAL:
-   case GL_EQUAL:
-   case GL_NOTEQUAL:
-   case GL_ALWAYS:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Set the clear value for the stencil buffer.
- *
- * \param s clear value.
- *
- * \sa glClearStencil().
- *
- * Updates gl_stencil_attrib::Clear. On change
- * flushes the vertices and notifies the driver via
- * the dd_function_table::ClearStencil callback.
- */
-void GLAPIENTRY
-_mesa_ClearStencil( GLint s )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (ctx->Stencil.Clear == (GLuint) s)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_STENCIL);
-   ctx->Stencil.Clear = (GLuint) s;
-
-   if (ctx->Driver.ClearStencil) {
-      ctx->Driver.ClearStencil( ctx, s );
-   }
-}
-
-
-/**
- * Set the function and reference value for stencil testing.
- *
- * \param frontfunc front test function.
- * \param backfunc back test function.
- * \param ref front and back reference value.
- * \param mask front and back bitmask.
- *
- * \sa glStencilFunc().
- *
- * Verifies the parameters and updates the respective values in
- * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the
- * driver via the dd_function_table::StencilFunc callback.
- */
-void GLAPIENTRY
-_mesa_StencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilFuncSeparateATI()\n");
-
-   if (!validate_stencil_func(ctx, frontfunc)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glStencilFuncSeparateATI(frontfunc)");
-      return;
-   }
-   if (!validate_stencil_func(ctx, backfunc)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glStencilFuncSeparateATI(backfunc)");
-      return;
-   }
-
-   ref = CLAMP( ref, 0, stencilMax );
-
-   /* set both front and back state */
-   if (ctx->Stencil.Function[0] == frontfunc &&
-       ctx->Stencil.Function[1] == backfunc &&
-       ctx->Stencil.ValueMask[0] == mask &&
-       ctx->Stencil.ValueMask[1] == mask &&
-       ctx->Stencil.Ref[0] == ref &&
-       ctx->Stencil.Ref[1] == ref)
-      return;
-   FLUSH_VERTICES(ctx, _NEW_STENCIL);
-   ctx->Stencil.Function[0]  = frontfunc;
-   ctx->Stencil.Function[1]  = backfunc;
-   ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;
-   ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;
-   if (ctx->Driver.StencilFuncSeparate) {
-      ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT,
-                                      frontfunc, ref, mask);
-      ctx->Driver.StencilFuncSeparate(ctx, GL_BACK,
-                                      backfunc, ref, mask);
-   }
-}
-
-
-/**
- * Set the function and reference value for stencil testing.
- *
- * \param func test function.
- * \param ref reference value.
- * \param mask bitmask.
- *
- * \sa glStencilFunc().
- *
- * Verifies the parameters and updates the respective values in
- * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the
- * driver via the dd_function_table::StencilFunc callback.
- */
-void GLAPIENTRY
-_mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
-   const GLint face = ctx->Stencil.ActiveFace;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilFunc()\n");
-
-   if (!validate_stencil_func(ctx, func)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFunc(func)");
-      return;
-   }
-
-   ref = CLAMP( ref, 0, stencilMax );
-
-   if (face != 0) {
-      if (ctx->Stencil.Function[face] == func &&
-          ctx->Stencil.ValueMask[face] == mask &&
-          ctx->Stencil.Ref[face] == ref)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.Function[face] = func;
-      ctx->Stencil.Ref[face] = ref;
-      ctx->Stencil.ValueMask[face] = mask;
-
-      /* Only propagate the change to the driver if EXT_stencil_two_side
-       * is enabled.
-       */
-      if (ctx->Driver.StencilFuncSeparate && ctx->Stencil.TestTwoSide) {
-         ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, func, ref, mask);
-      }
-   }
-   else {
-      /* set both front and back state */
-      if (ctx->Stencil.Function[0] == func &&
-          ctx->Stencil.Function[1] == func &&
-          ctx->Stencil.ValueMask[0] == mask &&
-          ctx->Stencil.ValueMask[1] == mask &&
-          ctx->Stencil.Ref[0] == ref &&
-          ctx->Stencil.Ref[1] == ref)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.Function[0]  = ctx->Stencil.Function[1]  = func;
-      ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;
-      ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;
-      if (ctx->Driver.StencilFuncSeparate) {
-         ctx->Driver.StencilFuncSeparate(ctx,
-					 ((ctx->Stencil.TestTwoSide)
-					  ? GL_FRONT : GL_FRONT_AND_BACK),
-                                         func, ref, mask);
-      }
-   }
-}
-
-
-/**
- * Set the stencil writing mask.
- *
- * \param mask bit-mask to enable/disable writing of individual bits in the
- * stencil planes.
- *
- * \sa glStencilMask().
- *
- * Updates gl_stencil_attrib::WriteMask. On change flushes the vertices and
- * notifies the driver via the dd_function_table::StencilMask callback.
- */
-void GLAPIENTRY
-_mesa_StencilMask( GLuint mask )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLint face = ctx->Stencil.ActiveFace;
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilMask()\n");
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (face != 0) {
-      /* Only modify the EXT_stencil_two_side back-face state.
-       */
-      if (ctx->Stencil.WriteMask[face] == mask)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.WriteMask[face] = mask;
-
-      /* Only propagate the change to the driver if EXT_stencil_two_side
-       * is enabled.
-       */
-      if (ctx->Driver.StencilMaskSeparate && ctx->Stencil.TestTwoSide) {
-         ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, mask);
-      }
-   }
-   else {
-      /* set both front and back state */
-      if (ctx->Stencil.WriteMask[0] == mask &&
-          ctx->Stencil.WriteMask[1] == mask)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.WriteMask[0] = ctx->Stencil.WriteMask[1] = mask;
-      if (ctx->Driver.StencilMaskSeparate) {
-         ctx->Driver.StencilMaskSeparate(ctx,
-					 ((ctx->Stencil.TestTwoSide)
-					  ? GL_FRONT : GL_FRONT_AND_BACK),
-					  mask);
-      }
-   }
-}
-
-
-/**
- * Set the stencil test actions.
- *
- * \param fail action to take when stencil test fails.
- * \param zfail action to take when stencil test passes, but depth test fails.
- * \param zpass action to take when stencil test passes and the depth test
- * passes (or depth testing is not enabled).
- * 
- * \sa glStencilOp().
- * 
- * Verifies the parameters and updates the respective fields in
- * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the
- * driver via the dd_function_table::StencilOp callback.
- */
-void GLAPIENTRY
-_mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLint face = ctx->Stencil.ActiveFace;
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilOp()\n");
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!validate_stencil_op(ctx, fail)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(sfail)");
-      return;
-   }
-   if (!validate_stencil_op(ctx, zfail)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zfail)");
-      return;
-   }
-   if (!validate_stencil_op(ctx, zpass)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zpass)");
-      return;
-   }
-
-   if (face != 0) {
-      /* only set active face state */
-      if (ctx->Stencil.ZFailFunc[face] == zfail &&
-          ctx->Stencil.ZPassFunc[face] == zpass &&
-          ctx->Stencil.FailFunc[face] == fail)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.ZFailFunc[face] = zfail;
-      ctx->Stencil.ZPassFunc[face] = zpass;
-      ctx->Stencil.FailFunc[face] = fail;
-
-      /* Only propagate the change to the driver if EXT_stencil_two_side
-       * is enabled.
-       */
-      if (ctx->Driver.StencilOpSeparate && ctx->Stencil.TestTwoSide) {
-         ctx->Driver.StencilOpSeparate(ctx, GL_BACK, fail, zfail, zpass);
-      }
-   }
-   else {
-      /* set both front and back state */
-      if (ctx->Stencil.ZFailFunc[0] == zfail &&
-          ctx->Stencil.ZFailFunc[1] == zfail &&
-          ctx->Stencil.ZPassFunc[0] == zpass &&
-          ctx->Stencil.ZPassFunc[1] == zpass &&
-          ctx->Stencil.FailFunc[0] == fail &&
-          ctx->Stencil.FailFunc[1] == fail)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.ZFailFunc[0] = ctx->Stencil.ZFailFunc[1] = zfail;
-      ctx->Stencil.ZPassFunc[0] = ctx->Stencil.ZPassFunc[1] = zpass;
-      ctx->Stencil.FailFunc[0]  = ctx->Stencil.FailFunc[1]  = fail;
-      if (ctx->Driver.StencilOpSeparate) {
-         ctx->Driver.StencilOpSeparate(ctx,
-				       ((ctx->Stencil.TestTwoSide)
-					? GL_FRONT : GL_FRONT_AND_BACK),
-                                       fail, zfail, zpass);
-      }
-   }
-}
-
-
-
-#if _HAVE_FULL_GL
-/* GL_EXT_stencil_two_side */
-void GLAPIENTRY
-_mesa_ActiveStencilFaceEXT(GLenum face)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glActiveStencilFaceEXT()\n");
-
-   if (!ctx->Extensions.EXT_stencil_two_side) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glActiveStencilFaceEXT");
-      return;
-   }
-
-   if (face == GL_FRONT || face == GL_BACK) {
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.ActiveFace = (face == GL_FRONT) ? 0 : 2;
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveStencilFaceEXT(face)");
-   }
-}
-#endif
-
-
-
-/**
- * OpenGL 2.0 function.
- * \todo Make StencilOp() call this function.  And eventually remove the
- * ctx->Driver.StencilOp function and use ctx->Driver.StencilOpSeparate
- * instead.
- */
-void GLAPIENTRY
-_mesa_StencilOpSeparate(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass)
-{
-   GLboolean set = GL_FALSE;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilOpSeparate()\n");
-
-   if (!validate_stencil_op(ctx, sfail)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(sfail)");
-      return;
-   }
-   if (!validate_stencil_op(ctx, zfail)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zfail)");
-      return;
-   }
-   if (!validate_stencil_op(ctx, zpass)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zpass)");
-      return;
-   }
-   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(face)");
-      return;
-   }
-
-   if (face != GL_BACK) {
-      /* set front */
-      if (ctx->Stencil.ZFailFunc[0] != zfail ||
-          ctx->Stencil.ZPassFunc[0] != zpass ||
-          ctx->Stencil.FailFunc[0] != sfail){
-         FLUSH_VERTICES(ctx, _NEW_STENCIL);
-         ctx->Stencil.ZFailFunc[0] = zfail;
-         ctx->Stencil.ZPassFunc[0] = zpass;
-         ctx->Stencil.FailFunc[0] = sfail;
-         set = GL_TRUE;
-      }
-   }
-   if (face != GL_FRONT) {
-      /* set back */
-      if (ctx->Stencil.ZFailFunc[1] != zfail ||
-          ctx->Stencil.ZPassFunc[1] != zpass ||
-          ctx->Stencil.FailFunc[1] != sfail) {
-         FLUSH_VERTICES(ctx, _NEW_STENCIL);
-         ctx->Stencil.ZFailFunc[1] = zfail;
-         ctx->Stencil.ZPassFunc[1] = zpass;
-         ctx->Stencil.FailFunc[1] = sfail;
-         set = GL_TRUE;
-      }
-   }
-   if (set && ctx->Driver.StencilOpSeparate) {
-      ctx->Driver.StencilOpSeparate(ctx, face, sfail, zfail, zpass);
-   }
-}
-
-
-/* OpenGL 2.0 */
-void GLAPIENTRY
-_mesa_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilFuncSeparate()\n");
-
-   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(face)");
-      return;
-   }
-   if (!validate_stencil_func(ctx, func)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(func)");
-      return;
-   }
-
-   ref = CLAMP(ref, 0, stencilMax);
-
-   FLUSH_VERTICES(ctx, _NEW_STENCIL);
-
-   if (face != GL_BACK) {
-      /* set front */
-      ctx->Stencil.Function[0] = func;
-      ctx->Stencil.Ref[0] = ref;
-      ctx->Stencil.ValueMask[0] = mask;
-   }
-   if (face != GL_FRONT) {
-      /* set back */
-      ctx->Stencil.Function[1] = func;
-      ctx->Stencil.Ref[1] = ref;
-      ctx->Stencil.ValueMask[1] = mask;
-   }
-   if (ctx->Driver.StencilFuncSeparate) {
-      ctx->Driver.StencilFuncSeparate(ctx, face, func, ref, mask);
-   }
-}
-
-
-/* OpenGL 2.0 */
-void GLAPIENTRY
-_mesa_StencilMaskSeparate(GLenum face, GLuint mask)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glStencilMaskSeparate()\n");
-
-   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilaMaskSeparate(face)");
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_STENCIL);
-
-   if (face != GL_BACK) {
-      ctx->Stencil.WriteMask[0] = mask;
-   }
-   if (face != GL_FRONT) {
-      ctx->Stencil.WriteMask[1] = mask;
-   }
-   if (ctx->Driver.StencilMaskSeparate) {
-      ctx->Driver.StencilMaskSeparate(ctx, face, mask);
-   }
-}
-
-
-/**
- * Update derived stencil state.
- */
-void
-_mesa_update_stencil(struct gl_context *ctx)
-{
-   const GLint face = ctx->Stencil._BackFace;
-
-   ctx->Stencil._Enabled = (ctx->Stencil.Enabled &&
-                            ctx->DrawBuffer->Visual.stencilBits > 0);
-
-    ctx->Stencil._TestTwoSide =
-       ctx->Stencil._Enabled &&
-       (ctx->Stencil.Function[0] != ctx->Stencil.Function[face] ||
-	ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[face] ||
-	ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[face] ||
-	ctx->Stencil.ZFailFunc[0] != ctx->Stencil.ZFailFunc[face] ||
-	ctx->Stencil.Ref[0] != ctx->Stencil.Ref[face] ||
-	ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[face] ||
-	ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[face]);
-}
-
-
-/**
- * Initialize the context stipple state.
- *
- * \param ctx GL context.
- *
- * Initializes __struct gl_contextRec::Stencil attribute group.
- */
-void
-_mesa_init_stencil(struct gl_context *ctx)
-{
-   ctx->Stencil.Enabled = GL_FALSE;
-   ctx->Stencil.TestTwoSide = GL_FALSE;
-   ctx->Stencil.ActiveFace = 0;  /* 0 = GL_FRONT, 2 = GL_BACK */
-   ctx->Stencil.Function[0] = GL_ALWAYS;
-   ctx->Stencil.Function[1] = GL_ALWAYS;
-   ctx->Stencil.Function[2] = GL_ALWAYS;
-   ctx->Stencil.FailFunc[0] = GL_KEEP;
-   ctx->Stencil.FailFunc[1] = GL_KEEP;
-   ctx->Stencil.FailFunc[2] = GL_KEEP;
-   ctx->Stencil.ZPassFunc[0] = GL_KEEP;
-   ctx->Stencil.ZPassFunc[1] = GL_KEEP;
-   ctx->Stencil.ZPassFunc[2] = GL_KEEP;
-   ctx->Stencil.ZFailFunc[0] = GL_KEEP;
-   ctx->Stencil.ZFailFunc[1] = GL_KEEP;
-   ctx->Stencil.ZFailFunc[2] = GL_KEEP;
-   ctx->Stencil.Ref[0] = 0;
-   ctx->Stencil.Ref[1] = 0;
-   ctx->Stencil.Ref[2] = 0;
-   ctx->Stencil.ValueMask[0] = ~0U;
-   ctx->Stencil.ValueMask[1] = ~0U;
-   ctx->Stencil.ValueMask[2] = ~0U;
-   ctx->Stencil.WriteMask[0] = ~0U;
-   ctx->Stencil.WriteMask[1] = ~0U;
-   ctx->Stencil.WriteMask[2] = ~0U;
-   ctx->Stencil.Clear = 0;
-   ctx->Stencil._BackFace = 1;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file stencil.c

+ * Stencil operations.

+ *

+ * Note: There's some conflict between GL_EXT_stencil_two_side and

+ * OpenGL 2.0's two-sided stencil feature.

+ *

+ * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the

+ * front OR back face state (as set by glActiveStencilFaceEXT) is set.

+ *

+ * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the

+ * front AND back state.

+ *

+ * Also, note that GL_ATI_separate_stencil is different as well:

+ * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...)  vs.

+ * glStencilFuncSeparate(GLenum face, GLenum func, ...).

+ *

+ * This problem is solved by keeping three sets of stencil state:

+ *  state[0] = GL_FRONT state.

+ *  state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state.

+ *  state[2] = GL_EXT_stencil_two_side GL_BACK state.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "context.h"

+#include "macros.h"

+#include "stencil.h"

+#include "mtypes.h"

+

+

+static GLboolean

+validate_stencil_op(struct gl_context *ctx, GLenum op)

+{

+   switch (op) {

+   case GL_KEEP:

+   case GL_ZERO:

+   case GL_REPLACE:

+   case GL_INCR:

+   case GL_DECR:

+   case GL_INVERT:

+      return GL_TRUE;

+   case GL_INCR_WRAP_EXT:

+   case GL_DECR_WRAP_EXT:

+      if (ctx->Extensions.EXT_stencil_wrap) {

+         return GL_TRUE;

+      }

+      /* FALL-THROUGH */

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+static GLboolean

+validate_stencil_func(struct gl_context *ctx, GLenum func)

+{

+   switch (func) {

+   case GL_NEVER:

+   case GL_LESS:

+   case GL_LEQUAL:

+   case GL_GREATER:

+   case GL_GEQUAL:

+   case GL_EQUAL:

+   case GL_NOTEQUAL:

+   case GL_ALWAYS:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Set the clear value for the stencil buffer.

+ *

+ * \param s clear value.

+ *

+ * \sa glClearStencil().

+ *

+ * Updates gl_stencil_attrib::Clear. On change

+ * flushes the vertices and notifies the driver via

+ * the dd_function_table::ClearStencil callback.

+ */

+void GLAPIENTRY

+_mesa_ClearStencil( GLint s )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (ctx->Stencil.Clear == (GLuint) s)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_STENCIL);

+   ctx->Stencil.Clear = (GLuint) s;

+

+   if (ctx->Driver.ClearStencil) {

+      ctx->Driver.ClearStencil( ctx, s );

+   }

+}

+

+

+/**

+ * Set the function and reference value for stencil testing.

+ *

+ * \param frontfunc front test function.

+ * \param backfunc back test function.

+ * \param ref front and back reference value.

+ * \param mask front and back bitmask.

+ *

+ * \sa glStencilFunc().

+ *

+ * Verifies the parameters and updates the respective values in

+ * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the

+ * driver via the dd_function_table::StencilFunc callback.

+ */

+void GLAPIENTRY

+_mesa_StencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilFuncSeparateATI()\n");

+

+   if (!validate_stencil_func(ctx, frontfunc)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glStencilFuncSeparateATI(frontfunc)");

+      return;

+   }

+   if (!validate_stencil_func(ctx, backfunc)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glStencilFuncSeparateATI(backfunc)");

+      return;

+   }

+

+   ref = CLAMP( ref, 0, stencilMax );

+

+   /* set both front and back state */

+   if (ctx->Stencil.Function[0] == frontfunc &&

+       ctx->Stencil.Function[1] == backfunc &&

+       ctx->Stencil.ValueMask[0] == mask &&

+       ctx->Stencil.ValueMask[1] == mask &&

+       ctx->Stencil.Ref[0] == ref &&

+       ctx->Stencil.Ref[1] == ref)

+      return;

+   FLUSH_VERTICES(ctx, _NEW_STENCIL);

+   ctx->Stencil.Function[0]  = frontfunc;

+   ctx->Stencil.Function[1]  = backfunc;

+   ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;

+   ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;

+   if (ctx->Driver.StencilFuncSeparate) {

+      ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT,

+                                      frontfunc, ref, mask);

+      ctx->Driver.StencilFuncSeparate(ctx, GL_BACK,

+                                      backfunc, ref, mask);

+   }

+}

+

+

+/**

+ * Set the function and reference value for stencil testing.

+ *

+ * \param func test function.

+ * \param ref reference value.

+ * \param mask bitmask.

+ *

+ * \sa glStencilFunc().

+ *

+ * Verifies the parameters and updates the respective values in

+ * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the

+ * driver via the dd_function_table::StencilFunc callback.

+ */

+void GLAPIENTRY

+_mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;

+   const GLint face = ctx->Stencil.ActiveFace;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilFunc()\n");

+

+   if (!validate_stencil_func(ctx, func)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFunc(func)");

+      return;

+   }

+

+   ref = CLAMP( ref, 0, stencilMax );

+

+   if (face != 0) {

+      if (ctx->Stencil.Function[face] == func &&

+          ctx->Stencil.ValueMask[face] == mask &&

+          ctx->Stencil.Ref[face] == ref)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.Function[face] = func;

+      ctx->Stencil.Ref[face] = ref;

+      ctx->Stencil.ValueMask[face] = mask;

+

+      /* Only propagate the change to the driver if EXT_stencil_two_side

+       * is enabled.

+       */

+      if (ctx->Driver.StencilFuncSeparate && ctx->Stencil.TestTwoSide) {

+         ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, func, ref, mask);

+      }

+   }

+   else {

+      /* set both front and back state */

+      if (ctx->Stencil.Function[0] == func &&

+          ctx->Stencil.Function[1] == func &&

+          ctx->Stencil.ValueMask[0] == mask &&

+          ctx->Stencil.ValueMask[1] == mask &&

+          ctx->Stencil.Ref[0] == ref &&

+          ctx->Stencil.Ref[1] == ref)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.Function[0]  = ctx->Stencil.Function[1]  = func;

+      ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;

+      ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;

+      if (ctx->Driver.StencilFuncSeparate) {

+         ctx->Driver.StencilFuncSeparate(ctx,

+					 ((ctx->Stencil.TestTwoSide)

+					  ? GL_FRONT : GL_FRONT_AND_BACK),

+                                         func, ref, mask);

+      }

+   }

+}

+

+

+/**

+ * Set the stencil writing mask.

+ *

+ * \param mask bit-mask to enable/disable writing of individual bits in the

+ * stencil planes.

+ *

+ * \sa glStencilMask().

+ *

+ * Updates gl_stencil_attrib::WriteMask. On change flushes the vertices and

+ * notifies the driver via the dd_function_table::StencilMask callback.

+ */

+void GLAPIENTRY

+_mesa_StencilMask( GLuint mask )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLint face = ctx->Stencil.ActiveFace;

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilMask()\n");

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (face != 0) {

+      /* Only modify the EXT_stencil_two_side back-face state.

+       */

+      if (ctx->Stencil.WriteMask[face] == mask)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.WriteMask[face] = mask;

+

+      /* Only propagate the change to the driver if EXT_stencil_two_side

+       * is enabled.

+       */

+      if (ctx->Driver.StencilMaskSeparate && ctx->Stencil.TestTwoSide) {

+         ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, mask);

+      }

+   }

+   else {

+      /* set both front and back state */

+      if (ctx->Stencil.WriteMask[0] == mask &&

+          ctx->Stencil.WriteMask[1] == mask)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.WriteMask[0] = ctx->Stencil.WriteMask[1] = mask;

+      if (ctx->Driver.StencilMaskSeparate) {

+         ctx->Driver.StencilMaskSeparate(ctx,

+					 ((ctx->Stencil.TestTwoSide)

+					  ? GL_FRONT : GL_FRONT_AND_BACK),

+					  mask);

+      }

+   }

+}

+

+

+/**

+ * Set the stencil test actions.

+ *

+ * \param fail action to take when stencil test fails.

+ * \param zfail action to take when stencil test passes, but depth test fails.

+ * \param zpass action to take when stencil test passes and the depth test

+ * passes (or depth testing is not enabled).

+ * 

+ * \sa glStencilOp().

+ * 

+ * Verifies the parameters and updates the respective fields in

+ * __struct gl_contextRec::Stencil. On change flushes the vertices and notifies the

+ * driver via the dd_function_table::StencilOp callback.

+ */

+void GLAPIENTRY

+_mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLint face = ctx->Stencil.ActiveFace;

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilOp()\n");

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!validate_stencil_op(ctx, fail)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(sfail)");

+      return;

+   }

+   if (!validate_stencil_op(ctx, zfail)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zfail)");

+      return;

+   }

+   if (!validate_stencil_op(ctx, zpass)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp(zpass)");

+      return;

+   }

+

+   if (face != 0) {

+      /* only set active face state */

+      if (ctx->Stencil.ZFailFunc[face] == zfail &&

+          ctx->Stencil.ZPassFunc[face] == zpass &&

+          ctx->Stencil.FailFunc[face] == fail)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.ZFailFunc[face] = zfail;

+      ctx->Stencil.ZPassFunc[face] = zpass;

+      ctx->Stencil.FailFunc[face] = fail;

+

+      /* Only propagate the change to the driver if EXT_stencil_two_side

+       * is enabled.

+       */

+      if (ctx->Driver.StencilOpSeparate && ctx->Stencil.TestTwoSide) {

+         ctx->Driver.StencilOpSeparate(ctx, GL_BACK, fail, zfail, zpass);

+      }

+   }

+   else {

+      /* set both front and back state */

+      if (ctx->Stencil.ZFailFunc[0] == zfail &&

+          ctx->Stencil.ZFailFunc[1] == zfail &&

+          ctx->Stencil.ZPassFunc[0] == zpass &&

+          ctx->Stencil.ZPassFunc[1] == zpass &&

+          ctx->Stencil.FailFunc[0] == fail &&

+          ctx->Stencil.FailFunc[1] == fail)

+         return;

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.ZFailFunc[0] = ctx->Stencil.ZFailFunc[1] = zfail;

+      ctx->Stencil.ZPassFunc[0] = ctx->Stencil.ZPassFunc[1] = zpass;

+      ctx->Stencil.FailFunc[0]  = ctx->Stencil.FailFunc[1]  = fail;

+      if (ctx->Driver.StencilOpSeparate) {

+         ctx->Driver.StencilOpSeparate(ctx,

+				       ((ctx->Stencil.TestTwoSide)

+					? GL_FRONT : GL_FRONT_AND_BACK),

+                                       fail, zfail, zpass);

+      }

+   }

+}

+

+

+

+#if _HAVE_FULL_GL

+/* GL_EXT_stencil_two_side */

+void GLAPIENTRY

+_mesa_ActiveStencilFaceEXT(GLenum face)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glActiveStencilFaceEXT()\n");

+

+   if (!ctx->Extensions.EXT_stencil_two_side) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glActiveStencilFaceEXT");

+      return;

+   }

+

+   if (face == GL_FRONT || face == GL_BACK) {

+      FLUSH_VERTICES(ctx, _NEW_STENCIL);

+      ctx->Stencil.ActiveFace = (face == GL_FRONT) ? 0 : 2;

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveStencilFaceEXT(face)");

+   }

+}

+#endif

+

+

+

+/**

+ * OpenGL 2.0 function.

+ * \todo Make StencilOp() call this function.  And eventually remove the

+ * ctx->Driver.StencilOp function and use ctx->Driver.StencilOpSeparate

+ * instead.

+ */

+void GLAPIENTRY

+_mesa_StencilOpSeparate(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass)

+{

+   GLboolean set = GL_FALSE;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilOpSeparate()\n");

+

+   if (!validate_stencil_op(ctx, sfail)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(sfail)");

+      return;

+   }

+   if (!validate_stencil_op(ctx, zfail)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zfail)");

+      return;

+   }

+   if (!validate_stencil_op(ctx, zpass)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(zpass)");

+      return;

+   }

+   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOpSeparate(face)");

+      return;

+   }

+

+   if (face != GL_BACK) {

+      /* set front */

+      if (ctx->Stencil.ZFailFunc[0] != zfail ||

+          ctx->Stencil.ZPassFunc[0] != zpass ||

+          ctx->Stencil.FailFunc[0] != sfail){

+         FLUSH_VERTICES(ctx, _NEW_STENCIL);

+         ctx->Stencil.ZFailFunc[0] = zfail;

+         ctx->Stencil.ZPassFunc[0] = zpass;

+         ctx->Stencil.FailFunc[0] = sfail;

+         set = GL_TRUE;

+      }

+   }

+   if (face != GL_FRONT) {

+      /* set back */

+      if (ctx->Stencil.ZFailFunc[1] != zfail ||

+          ctx->Stencil.ZPassFunc[1] != zpass ||

+          ctx->Stencil.FailFunc[1] != sfail) {

+         FLUSH_VERTICES(ctx, _NEW_STENCIL);

+         ctx->Stencil.ZFailFunc[1] = zfail;

+         ctx->Stencil.ZPassFunc[1] = zpass;

+         ctx->Stencil.FailFunc[1] = sfail;

+         set = GL_TRUE;

+      }

+   }

+   if (set && ctx->Driver.StencilOpSeparate) {

+      ctx->Driver.StencilOpSeparate(ctx, face, sfail, zfail, zpass);

+   }

+}

+

+

+/* OpenGL 2.0 */

+void GLAPIENTRY

+_mesa_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilFuncSeparate()\n");

+

+   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(face)");

+      return;

+   }

+   if (!validate_stencil_func(ctx, func)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilFuncSeparate(func)");

+      return;

+   }

+

+   ref = CLAMP(ref, 0, stencilMax);

+

+   FLUSH_VERTICES(ctx, _NEW_STENCIL);

+

+   if (face != GL_BACK) {

+      /* set front */

+      ctx->Stencil.Function[0] = func;

+      ctx->Stencil.Ref[0] = ref;

+      ctx->Stencil.ValueMask[0] = mask;

+   }

+   if (face != GL_FRONT) {

+      /* set back */

+      ctx->Stencil.Function[1] = func;

+      ctx->Stencil.Ref[1] = ref;

+      ctx->Stencil.ValueMask[1] = mask;

+   }

+   if (ctx->Driver.StencilFuncSeparate) {

+      ctx->Driver.StencilFuncSeparate(ctx, face, func, ref, mask);

+   }

+}

+

+

+/* OpenGL 2.0 */

+void GLAPIENTRY

+_mesa_StencilMaskSeparate(GLenum face, GLuint mask)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glStencilMaskSeparate()\n");

+

+   if (face != GL_FRONT && face != GL_BACK && face != GL_FRONT_AND_BACK) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glStencilaMaskSeparate(face)");

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_STENCIL);

+

+   if (face != GL_BACK) {

+      ctx->Stencil.WriteMask[0] = mask;

+   }

+   if (face != GL_FRONT) {

+      ctx->Stencil.WriteMask[1] = mask;

+   }

+   if (ctx->Driver.StencilMaskSeparate) {

+      ctx->Driver.StencilMaskSeparate(ctx, face, mask);

+   }

+}

+

+

+/**

+ * Update derived stencil state.

+ */

+void

+_mesa_update_stencil(struct gl_context *ctx)

+{

+   const GLint face = ctx->Stencil._BackFace;

+

+   ctx->Stencil._Enabled = (ctx->Stencil.Enabled &&

+                            ctx->DrawBuffer->Visual.stencilBits > 0);

+

+    ctx->Stencil._TestTwoSide =

+       ctx->Stencil._Enabled &&

+       (ctx->Stencil.Function[0] != ctx->Stencil.Function[face] ||

+	ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[face] ||

+	ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[face] ||

+	ctx->Stencil.ZFailFunc[0] != ctx->Stencil.ZFailFunc[face] ||

+	ctx->Stencil.Ref[0] != ctx->Stencil.Ref[face] ||

+	ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[face] ||

+	ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[face]);

+}

+

+

+/**

+ * Initialize the context stipple state.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes __struct gl_contextRec::Stencil attribute group.

+ */

+void

+_mesa_init_stencil(struct gl_context *ctx)

+{

+   ctx->Stencil.Enabled = GL_FALSE;

+   ctx->Stencil.TestTwoSide = GL_FALSE;

+   ctx->Stencil.ActiveFace = 0;  /* 0 = GL_FRONT, 2 = GL_BACK */

+   ctx->Stencil.Function[0] = GL_ALWAYS;

+   ctx->Stencil.Function[1] = GL_ALWAYS;

+   ctx->Stencil.Function[2] = GL_ALWAYS;

+   ctx->Stencil.FailFunc[0] = GL_KEEP;

+   ctx->Stencil.FailFunc[1] = GL_KEEP;

+   ctx->Stencil.FailFunc[2] = GL_KEEP;

+   ctx->Stencil.ZPassFunc[0] = GL_KEEP;

+   ctx->Stencil.ZPassFunc[1] = GL_KEEP;

+   ctx->Stencil.ZPassFunc[2] = GL_KEEP;

+   ctx->Stencil.ZFailFunc[0] = GL_KEEP;

+   ctx->Stencil.ZFailFunc[1] = GL_KEEP;

+   ctx->Stencil.ZFailFunc[2] = GL_KEEP;

+   ctx->Stencil.Ref[0] = 0;

+   ctx->Stencil.Ref[1] = 0;

+   ctx->Stencil.Ref[2] = 0;

+   ctx->Stencil.ValueMask[0] = ~0U;

+   ctx->Stencil.ValueMask[1] = ~0U;

+   ctx->Stencil.ValueMask[2] = ~0U;

+   ctx->Stencil.WriteMask[0] = ~0U;

+   ctx->Stencil.WriteMask[1] = ~0U;

+   ctx->Stencil.WriteMask[2] = ~0U;

+   ctx->Stencil.Clear = 0;

+   ctx->Stencil._BackFace = 1;

+}

diff --git a/mesalib/src/mesa/main/syncobj.c b/mesalib/src/mesa/main/syncobj.c
index 676038430..25307a17c 100644
--- a/mesalib/src/mesa/main/syncobj.c
+++ b/mesalib/src/mesa/main/syncobj.c
@@ -125,7 +125,7 @@ _mesa_wait_sync(struct gl_context *ctx, struct gl_sync_object *syncObj,
 }

 

 

-void

+void GLAPIENTRY

 _mesa_init_sync_object_functions(struct dd_function_table *driver)

 {

    driver->NewSyncObject = _mesa_new_sync_object;

@@ -140,7 +140,7 @@ _mesa_init_sync_object_functions(struct dd_function_table *driver)
 }

 

 

-void

+void GLAPIENTRY

 _mesa_init_sync_dispatch(struct _glapi_table *disp)

 {

    SET_IsSync(disp, _mesa_IsSync);

@@ -156,7 +156,7 @@ _mesa_init_sync_dispatch(struct _glapi_table *disp)
 /**

  * Allocate/init the context state related to sync objects.

  */

-void

+void GLAPIENTRY

 _mesa_init_sync(struct gl_context *ctx)

 {

    (void) ctx;

@@ -166,7 +166,7 @@ _mesa_init_sync(struct gl_context *ctx)
 /**

  * Free the context state related to sync objects.

  */

-void

+void GLAPIENTRY

 _mesa_free_sync_data(struct gl_context *ctx)

 {

    (void) ctx;

@@ -182,7 +182,7 @@ _mesa_validate_sync(struct gl_sync_object *syncObj)
 }

 

 

-void

+void GLAPIENTRY

 _mesa_ref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj)

 {

    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

@@ -191,7 +191,7 @@ _mesa_ref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj)
 }

 

 

-void

+void GLAPIENTRY

 _mesa_unref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj)

 {

    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

diff --git a/mesalib/src/mesa/main/syncobj.h b/mesalib/src/mesa/main/syncobj.h
index ac1384f61..e83ac8b0e 100644
--- a/mesalib/src/mesa/main/syncobj.h
+++ b/mesalib/src/mesa/main/syncobj.h
@@ -41,22 +41,22 @@ struct gl_sync_object;
 

 #if FEATURE_ARB_sync

 

-extern void

+extern void GLAPIENTRY

 _mesa_init_sync_object_functions(struct dd_function_table *driver);

 

-extern void

+extern void GLAPIENTRY

 _mesa_init_sync_dispatch(struct _glapi_table *disp);

 

-extern void

+extern void GLAPIENTRY

 _mesa_init_sync(struct gl_context *);

 

-extern void

+extern void GLAPIENTRY

 _mesa_free_sync_data(struct gl_context *);

 

-extern void

+extern void GLAPIENTRY

 _mesa_ref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj);

 

-extern void

+extern void GLAPIENTRY

 _mesa_unref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj);

 

 extern GLboolean GLAPIENTRY

diff --git a/mesalib/src/mesa/main/texcompress.c b/mesalib/src/mesa/main/texcompress.c
index d820ae927..59603e81e 100644
--- a/mesalib/src/mesa/main/texcompress.c
+++ b/mesalib/src/mesa/main/texcompress.c
@@ -1,288 +1,288 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008 VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file texcompress.c
- * Helper functions for texture compression.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "colormac.h"
-#include "formats.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "texcompress.h"
-
-
-/**
- * Return list of (and count of) all specific texture compression
- * formats that are supported.
- *
- * \param ctx  the GL context
- * \param formats  the resulting format list (may be NULL).
- * \param all  if true return all formats, even those with  some kind
- *             of restrictions/limitations (See GL_ARB_texture_compression
- *             spec for more info).
- *
- * \return number of formats.
- */
-GLuint
-_mesa_get_compressed_formats(struct gl_context *ctx, GLint *formats, GLboolean all)
-{
-   GLuint n = 0;
-   if (ctx->Extensions.TDFX_texture_compression_FXT1) {
-      if (formats) {
-         formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX;
-         formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX;
-      }
-      else {
-         n += 2;
-      }
-   }
-   /* don't return RGTC - ARB_texture_compression_rgtc query 19 */
-   if (ctx->Extensions.EXT_texture_compression_s3tc) {
-      if (formats) {
-         formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-         /* This format has some restrictions/limitations and so should
-          * not be returned via the GL_COMPRESSED_TEXTURE_FORMATS query.
-          * Specifically, all transparent pixels become black.  NVIDIA
-          * omits this format too.
-          */
-         if (all)
-             formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-      }
-      else {
-         n += 3;
-         if (all)
-             n += 1;
-      }
-   }
-   if (ctx->Extensions.S3_s3tc) {
-      if (formats) {
-         formats[n++] = GL_RGB_S3TC;
-         formats[n++] = GL_RGB4_S3TC;
-         formats[n++] = GL_RGBA_S3TC;
-         formats[n++] = GL_RGBA4_S3TC;
-      }
-      else {
-         n += 4;
-      }
-   }
-#if FEATURE_EXT_texture_sRGB
-   if (ctx->Extensions.EXT_texture_sRGB) {
-      if (formats) {
-         formats[n++] = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
-         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
-         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
-         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
-      }
-      else {
-         n += 4;
-      }
-   }
-#endif /* FEATURE_EXT_texture_sRGB */
-   return n;
-
-#if FEATURE_ES1 || FEATURE_ES2
-   if (formats) {
-      formats[n++] = GL_PALETTE4_RGB8_OES;
-      formats[n++] = GL_PALETTE4_RGBA8_OES;
-      formats[n++] = GL_PALETTE4_R5_G6_B5_OES;
-      formats[n++] = GL_PALETTE4_RGBA4_OES;
-      formats[n++] = GL_PALETTE4_RGB5_A1_OES;
-      formats[n++] = GL_PALETTE8_RGB8_OES;
-      formats[n++] = GL_PALETTE8_RGBA8_OES;
-      formats[n++] = GL_PALETTE8_R5_G6_B5_OES;
-      formats[n++] = GL_PALETTE8_RGBA4_OES;
-      formats[n++] = GL_PALETTE8_RGB5_A1_OES;
-   }
-   else {
-      n += 10;
-   }
-#endif
-}
-
-
-/**
- * Convert a compressed MESA_FORMAT_x to a GLenum.
- */
-gl_format
-_mesa_glenum_to_compressed_format(GLenum format)
-{
-   switch (format) {
-   case GL_COMPRESSED_RGB_FXT1_3DFX:
-      return MESA_FORMAT_RGB_FXT1;
-   case GL_COMPRESSED_RGBA_FXT1_3DFX:
-      return MESA_FORMAT_RGBA_FXT1;
-
-   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-   case GL_RGB_S3TC:
-      return MESA_FORMAT_RGB_DXT1;
-   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-   case GL_RGB4_S3TC:
-      return MESA_FORMAT_RGBA_DXT1;
-   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-   case GL_RGBA_S3TC:
-      return MESA_FORMAT_RGBA_DXT3;
-   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-   case GL_RGBA4_S3TC:
-      return MESA_FORMAT_RGBA_DXT5;
-
-   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-      return MESA_FORMAT_SRGB_DXT1;
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      return MESA_FORMAT_SRGBA_DXT1;
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      return MESA_FORMAT_SRGBA_DXT3;
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      return MESA_FORMAT_SRGBA_DXT5;
-
-   case GL_COMPRESSED_RED_RGTC1:
-      return MESA_FORMAT_RED_RGTC1;
-   case GL_COMPRESSED_SIGNED_RED_RGTC1:
-      return MESA_FORMAT_SIGNED_RED_RGTC1;
-   case GL_COMPRESSED_RG_RGTC2:
-      return MESA_FORMAT_RG_RGTC2;
-   case GL_COMPRESSED_SIGNED_RG_RGTC2:
-      return MESA_FORMAT_SIGNED_RG_RGTC2;
-
-   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-      return MESA_FORMAT_L_LATC1;
-   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-      return MESA_FORMAT_SIGNED_L_LATC1;
-   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      return MESA_FORMAT_LA_LATC2;
-   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-      return MESA_FORMAT_SIGNED_LA_LATC2;
-
-   default:
-      return MESA_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Given a compressed MESA_FORMAT_x value, return the corresponding
- * GLenum for that format.
- * This is needed for glGetTexLevelParameter(GL_TEXTURE_INTERNAL_FORMAT)
- * which must return the specific texture format used when the user might
- * have originally specified a generic compressed format in their
- * glTexImage2D() call.
- * For non-compressed textures, we always return the user-specified
- * internal format unchanged.
- */
-GLenum
-_mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat)
-{
-   switch (mesaFormat) {
-#if FEATURE_texture_fxt1
-   case MESA_FORMAT_RGB_FXT1:
-      return GL_COMPRESSED_RGB_FXT1_3DFX;
-   case MESA_FORMAT_RGBA_FXT1:
-      return GL_COMPRESSED_RGBA_FXT1_3DFX;
-#endif
-#if FEATURE_texture_s3tc
-   case MESA_FORMAT_RGB_DXT1:
-      return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-   case MESA_FORMAT_RGBA_DXT1:
-      return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-   case MESA_FORMAT_RGBA_DXT3:
-      return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-   case MESA_FORMAT_RGBA_DXT5:
-      return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB_DXT1:
-      return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
-   case MESA_FORMAT_SRGBA_DXT1:
-      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
-   case MESA_FORMAT_SRGBA_DXT3:
-      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
-   case MESA_FORMAT_SRGBA_DXT5:
-      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
-#endif
-#endif
-
-   case MESA_FORMAT_RED_RGTC1:
-      return GL_COMPRESSED_RED_RGTC1;
-   case MESA_FORMAT_SIGNED_RED_RGTC1:
-      return GL_COMPRESSED_SIGNED_RED_RGTC1;
-   case MESA_FORMAT_RG_RGTC2:
-      return GL_COMPRESSED_RG_RGTC2;
-   case MESA_FORMAT_SIGNED_RG_RGTC2:
-      return GL_COMPRESSED_SIGNED_RG_RGTC2;
-
-   case MESA_FORMAT_L_LATC1:
-      return GL_COMPRESSED_LUMINANCE_LATC1_EXT;
-   case MESA_FORMAT_SIGNED_L_LATC1:
-      return GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT;
-   case MESA_FORMAT_LA_LATC2:
-      return GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT;
-   case MESA_FORMAT_SIGNED_LA_LATC2:
-      return GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT;
-
-   default:
-      _mesa_problem(ctx, "Unexpected mesa texture format in"
-                    " _mesa_compressed_format_to_glenum()");
-      return 0;
-   }
-}
-
-
-/*
- * Return the address of the pixel at (col, row, img) in a
- * compressed texture image.
- * \param col, row, img - image position (3D), should be a multiple of the
- *                        format's block size.
- * \param format - compressed image format
- * \param width - image width (stride) in pixels
- * \param image - the image address
- * \return address of pixel at (row, col, img)
- */
-GLubyte *
-_mesa_compressed_image_address(GLint col, GLint row, GLint img,
-                               gl_format mesaFormat,
-                               GLsizei width, const GLubyte *image)
-{
-   /* XXX only 2D images implemented, not 3D */
-   const GLuint blockSize = _mesa_get_format_bytes(mesaFormat);
-   GLuint bw, bh;
-   GLint offset;
-
-   _mesa_get_format_block_size(mesaFormat, &bw, &bh);
-
-   ASSERT(col % bw == 0);
-   ASSERT(row % bh == 0);
-
-   offset = ((width + bw - 1) / bw) * (row / bh) + col / bw;
-   offset *= blockSize;
-
-   return (GLubyte *) image + offset;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008 VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file texcompress.c

+ * Helper functions for texture compression.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "colormac.h"

+#include "formats.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "texcompress.h"

+

+

+/**

+ * Return list of (and count of) all specific texture compression

+ * formats that are supported.

+ *

+ * \param ctx  the GL context

+ * \param formats  the resulting format list (may be NULL).

+ * \param all  if true return all formats, even those with  some kind

+ *             of restrictions/limitations (See GL_ARB_texture_compression

+ *             spec for more info).

+ *

+ * \return number of formats.

+ */

+GLuint

+_mesa_get_compressed_formats(struct gl_context *ctx, GLint *formats, GLboolean all)

+{

+   GLuint n = 0;

+   if (ctx->Extensions.TDFX_texture_compression_FXT1) {

+      if (formats) {

+         formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX;

+         formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX;

+      }

+      else {

+         n += 2;

+      }

+   }

+   /* don't return RGTC - ARB_texture_compression_rgtc query 19 */

+   if (ctx->Extensions.EXT_texture_compression_s3tc) {

+      if (formats) {

+         formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;

+         /* This format has some restrictions/limitations and so should

+          * not be returned via the GL_COMPRESSED_TEXTURE_FORMATS query.

+          * Specifically, all transparent pixels become black.  NVIDIA

+          * omits this format too.

+          */

+         if (all)

+             formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;

+         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;

+         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;

+      }

+      else {

+         n += 3;

+         if (all)

+             n += 1;

+      }

+   }

+   if (ctx->Extensions.S3_s3tc) {

+      if (formats) {

+         formats[n++] = GL_RGB_S3TC;

+         formats[n++] = GL_RGB4_S3TC;

+         formats[n++] = GL_RGBA_S3TC;

+         formats[n++] = GL_RGBA4_S3TC;

+      }

+      else {

+         n += 4;

+      }

+   }

+#if FEATURE_EXT_texture_sRGB

+   if (ctx->Extensions.EXT_texture_sRGB) {

+      if (formats) {

+         formats[n++] = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;

+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;

+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;

+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;

+      }

+      else {

+         n += 4;

+      }

+   }

+#endif /* FEATURE_EXT_texture_sRGB */

+   return n;

+

+#if FEATURE_ES1 || FEATURE_ES2

+   if (formats) {

+      formats[n++] = GL_PALETTE4_RGB8_OES;

+      formats[n++] = GL_PALETTE4_RGBA8_OES;

+      formats[n++] = GL_PALETTE4_R5_G6_B5_OES;

+      formats[n++] = GL_PALETTE4_RGBA4_OES;

+      formats[n++] = GL_PALETTE4_RGB5_A1_OES;

+      formats[n++] = GL_PALETTE8_RGB8_OES;

+      formats[n++] = GL_PALETTE8_RGBA8_OES;

+      formats[n++] = GL_PALETTE8_R5_G6_B5_OES;

+      formats[n++] = GL_PALETTE8_RGBA4_OES;

+      formats[n++] = GL_PALETTE8_RGB5_A1_OES;

+   }

+   else {

+      n += 10;

+   }

+#endif

+}

+

+

+/**

+ * Convert a compressed MESA_FORMAT_x to a GLenum.

+ */

+gl_format

+_mesa_glenum_to_compressed_format(GLenum format)

+{

+   switch (format) {

+   case GL_COMPRESSED_RGB_FXT1_3DFX:

+      return MESA_FORMAT_RGB_FXT1;

+   case GL_COMPRESSED_RGBA_FXT1_3DFX:

+      return MESA_FORMAT_RGBA_FXT1;

+

+   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+   case GL_RGB_S3TC:

+      return MESA_FORMAT_RGB_DXT1;

+   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+   case GL_RGB4_S3TC:

+      return MESA_FORMAT_RGBA_DXT1;

+   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+   case GL_RGBA_S3TC:

+      return MESA_FORMAT_RGBA_DXT3;

+   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+   case GL_RGBA4_S3TC:

+      return MESA_FORMAT_RGBA_DXT5;

+

+   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+      return MESA_FORMAT_SRGB_DXT1;

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      return MESA_FORMAT_SRGBA_DXT1;

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      return MESA_FORMAT_SRGBA_DXT3;

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+      return MESA_FORMAT_SRGBA_DXT5;

+

+   case GL_COMPRESSED_RED_RGTC1:

+      return MESA_FORMAT_RED_RGTC1;

+   case GL_COMPRESSED_SIGNED_RED_RGTC1:

+      return MESA_FORMAT_SIGNED_RED_RGTC1;

+   case GL_COMPRESSED_RG_RGTC2:

+      return MESA_FORMAT_RG_RGTC2;

+   case GL_COMPRESSED_SIGNED_RG_RGTC2:

+      return MESA_FORMAT_SIGNED_RG_RGTC2;

+

+   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+      return MESA_FORMAT_L_LATC1;

+   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+      return MESA_FORMAT_SIGNED_L_LATC1;

+   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+      return MESA_FORMAT_LA_LATC2;

+   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+      return MESA_FORMAT_SIGNED_LA_LATC2;

+

+   default:

+      return MESA_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Given a compressed MESA_FORMAT_x value, return the corresponding

+ * GLenum for that format.

+ * This is needed for glGetTexLevelParameter(GL_TEXTURE_INTERNAL_FORMAT)

+ * which must return the specific texture format used when the user might

+ * have originally specified a generic compressed format in their

+ * glTexImage2D() call.

+ * For non-compressed textures, we always return the user-specified

+ * internal format unchanged.

+ */

+GLenum

+_mesa_compressed_format_to_glenum(struct gl_context *ctx, GLuint mesaFormat)

+{

+   switch (mesaFormat) {

+#if FEATURE_texture_fxt1

+   case MESA_FORMAT_RGB_FXT1:

+      return GL_COMPRESSED_RGB_FXT1_3DFX;

+   case MESA_FORMAT_RGBA_FXT1:

+      return GL_COMPRESSED_RGBA_FXT1_3DFX;

+#endif

+#if FEATURE_texture_s3tc

+   case MESA_FORMAT_RGB_DXT1:

+      return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;

+   case MESA_FORMAT_RGBA_DXT1:

+      return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;

+   case MESA_FORMAT_RGBA_DXT3:

+      return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;

+   case MESA_FORMAT_RGBA_DXT5:

+      return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SRGB_DXT1:

+      return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;

+   case MESA_FORMAT_SRGBA_DXT1:

+      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;

+   case MESA_FORMAT_SRGBA_DXT3:

+      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;

+   case MESA_FORMAT_SRGBA_DXT5:

+      return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;

+#endif

+#endif

+

+   case MESA_FORMAT_RED_RGTC1:

+      return GL_COMPRESSED_RED_RGTC1;

+   case MESA_FORMAT_SIGNED_RED_RGTC1:

+      return GL_COMPRESSED_SIGNED_RED_RGTC1;

+   case MESA_FORMAT_RG_RGTC2:

+      return GL_COMPRESSED_RG_RGTC2;

+   case MESA_FORMAT_SIGNED_RG_RGTC2:

+      return GL_COMPRESSED_SIGNED_RG_RGTC2;

+

+   case MESA_FORMAT_L_LATC1:

+      return GL_COMPRESSED_LUMINANCE_LATC1_EXT;

+   case MESA_FORMAT_SIGNED_L_LATC1:

+      return GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT;

+   case MESA_FORMAT_LA_LATC2:

+      return GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT;

+   case MESA_FORMAT_SIGNED_LA_LATC2:

+      return GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT;

+

+   default:

+      _mesa_problem(ctx, "Unexpected mesa texture format in"

+                    " _mesa_compressed_format_to_glenum()");

+      return 0;

+   }

+}

+

+

+/*

+ * Return the address of the pixel at (col, row, img) in a

+ * compressed texture image.

+ * \param col, row, img - image position (3D), should be a multiple of the

+ *                        format's block size.

+ * \param format - compressed image format

+ * \param width - image width (stride) in pixels

+ * \param image - the image address

+ * \return address of pixel at (row, col, img)

+ */

+GLubyte *

+_mesa_compressed_image_address(GLint col, GLint row, GLint img,

+                               gl_format mesaFormat,

+                               GLsizei width, const GLubyte *image)

+{

+   /* XXX only 2D images implemented, not 3D */

+   const GLuint blockSize = _mesa_get_format_bytes(mesaFormat);

+   GLuint bw, bh;

+   GLint offset;

+

+   _mesa_get_format_block_size(mesaFormat, &bw, &bh);

+

+   ASSERT(col % bw == 0);

+   ASSERT(row % bh == 0);

+

+   offset = ((width + bw - 1) / bw) * (row / bh) + col / bw;

+   offset *= blockSize;

+

+   return (GLubyte *) image + offset;

+}

diff --git a/mesalib/src/mesa/main/texcompress_rgtc.c b/mesalib/src/mesa/main/texcompress_rgtc.c
index c50df19c5..60146d09b 100644
--- a/mesalib/src/mesa/main/texcompress_rgtc.c
+++ b/mesalib/src/mesa/main/texcompress_rgtc.c
@@ -1,460 +1,460 @@
-/*
- * Copyright (C) 2011 Red Hat Inc.
- * 
- * block compression parts are:
- * Copyright (C) 2004  Roland Scheidegger   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, sublicense,
- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Author:
- *    Dave Airlie
- */
-
-/**
- * \file texcompress_rgtc.c
- * GL_EXT_texture_compression_rgtc support.
- */
-
-
-#include "glheader.h"
-#include "imports.h"
-#include "colormac.h"
-#include "image.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mipmap.h"
-#include "texcompress.h"
-#include "texcompress_rgtc.h"
-#include "texstore.h"
-
-#define RGTC_DEBUG 0
-
-static void unsigned_encode_rgtc_chan(GLubyte *blkaddr, GLubyte srccolors[4][4],
-					GLint numxpixels, GLint numypixels);
-static void signed_encode_rgtc_chan(GLbyte *blkaddr, GLbyte srccolors[4][4],
-			     GLint numxpixels, GLint numypixels);
-
-static void unsigned_fetch_texel_rgtc(unsigned srcRowStride, const GLubyte *pixdata,
-				      unsigned i, unsigned j, GLubyte *value, unsigned comps);
-
-static void signed_fetch_texel_rgtc(unsigned srcRowStride, const GLbyte *pixdata,
-				      unsigned i, unsigned j, GLbyte *value, unsigned comps);
-
-static void extractsrc_u( GLubyte srcpixels[4][4], const GLchan *srcaddr,
-			  GLint srcRowStride, GLint numxpixels, GLint numypixels, GLint comps)
-{
-   GLubyte i, j;
-   const GLchan *curaddr;
-   for (j = 0; j < numypixels; j++) {
-      curaddr = srcaddr + j * srcRowStride * comps;
-      for (i = 0; i < numxpixels; i++) {
-	 srcpixels[j][i] = *curaddr / (CHAN_MAX / 255);
-	 curaddr += comps;
-      }
-   }
-}
-
-static void extractsrc_s( GLbyte srcpixels[4][4], const GLfloat *srcaddr,
-			  GLint srcRowStride, GLint numxpixels, GLint numypixels, GLint comps)
-{
-   GLubyte i, j;
-   const GLfloat *curaddr;
-   for (j = 0; j < numypixels; j++) {
-      curaddr = srcaddr + j * srcRowStride * comps;
-      for (i = 0; i < numxpixels; i++) {
-	 srcpixels[j][i] = FLOAT_TO_BYTE_TEX(*curaddr);
-	 curaddr += comps;
-      }
-   }
-}
-
-
-GLboolean
-_mesa_texstore_red_rgtc1(TEXSTORE_PARAMS)
-{
-   GLubyte *dst;
-   const GLint texWidth = dstRowStride * 4 / 8; /* a bit of a hack */
-   const GLchan *tempImage = NULL;
-   int i, j;
-   int numxpixels, numypixels;
-   const GLchan *srcaddr;
-   GLubyte srcpixels[4][4];
-   GLubyte *blkaddr;
-   GLint dstRowDiff;
-   ASSERT(dstFormat == MESA_FORMAT_RED_RGTC1 ||
-          dstFormat == MESA_FORMAT_L_LATC1);
-   ASSERT(dstXoffset % 4 == 0);
-   ASSERT(dstYoffset % 4 == 0);
-   ASSERT(dstZoffset % 4 == 0);
-   (void) dstZoffset;
-   (void) dstImageOffsets;
-
-
-   tempImage = _mesa_make_temp_chan_image(ctx, dims,
-					  baseInternalFormat,
-					  _mesa_get_format_base_format(dstFormat),
-					  srcWidth, srcHeight, srcDepth,
-					  srcFormat, srcType, srcAddr,
-					  srcPacking);
-   if (!tempImage)
-      return GL_FALSE; /* out of memory */
-
-   dst = _mesa_compressed_image_address(dstXoffset, dstYoffset, 0,
-                                        dstFormat,
-                                        texWidth, (GLubyte *) dstAddr);
-
-   blkaddr = dst;
-   dstRowDiff = dstRowStride >= (srcWidth * 4) ? dstRowStride - (((srcWidth + 3) & ~3) * 4) : 0;
-   for (j = 0; j < srcHeight; j+=4) {
-      if (srcHeight > j + 3) numypixels = 4;
-      else numypixels = srcHeight - j;
-      srcaddr = tempImage + j * srcWidth;
-      for (i = 0; i < srcWidth; i += 4) {
-	 if (srcWidth > i + 3) numxpixels = 4;
-	 else numxpixels = srcWidth - i;
-	 extractsrc_u(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 1);
-	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-	 srcaddr += numxpixels;
-	 blkaddr += 8;
-      }
-      blkaddr += dstRowDiff;
-   }
-   if (tempImage)
-      free((void *) tempImage);
-
-   return GL_TRUE;
-}
-
-GLboolean
-_mesa_texstore_signed_red_rgtc1(TEXSTORE_PARAMS)
-{
-   GLbyte *dst;
-   const GLint texWidth = dstRowStride * 4 / 8; /* a bit of a hack */
-   const GLfloat *tempImage = NULL;
-   int i, j;
-   int numxpixels, numypixels;
-   const GLfloat *srcaddr;
-   GLbyte srcpixels[4][4];
-   GLbyte *blkaddr;
-   GLint dstRowDiff;
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RED_RGTC1 ||
-          dstFormat == MESA_FORMAT_SIGNED_L_LATC1);
-   ASSERT(dstXoffset % 4 == 0);
-   ASSERT(dstYoffset % 4 == 0);
-   ASSERT(dstZoffset % 4 == 0);
-   (void) dstZoffset;
-   (void) dstImageOffsets;
-
-   tempImage = _mesa_make_temp_float_image(ctx, dims,
-					   baseInternalFormat,
-					   _mesa_get_format_base_format(dstFormat),
-					   srcWidth, srcHeight, srcDepth,
-					   srcFormat, srcType, srcAddr,
-					   srcPacking, 0x0);
-   if (!tempImage)
-      return GL_FALSE; /* out of memory */
-
-   dst = (GLbyte *)_mesa_compressed_image_address(dstXoffset, dstYoffset, 0,
-						  dstFormat,
-						  texWidth, (GLubyte *) dstAddr);
-
-   blkaddr = dst;
-   dstRowDiff = dstRowStride >= (srcWidth * 4) ? dstRowStride - (((srcWidth + 3) & ~3) * 4) : 0;
-   for (j = 0; j < srcHeight; j+=4) {
-      if (srcHeight > j + 3) numypixels = 4;
-      else numypixels = srcHeight - j;
-      srcaddr = tempImage + j * srcWidth;
-      for (i = 0; i < srcWidth; i += 4) {
-	 if (srcWidth > i + 3) numxpixels = 4;
-	 else numxpixels = srcWidth - i;
-	 extractsrc_s(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 1);
-	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-	 srcaddr += numxpixels;
-	 blkaddr += 8;
-      }
-      blkaddr += dstRowDiff;
-   }
-   if (tempImage)
-      free((void *) tempImage);
-
-   return GL_TRUE;
-}
-
-GLboolean
-_mesa_texstore_rg_rgtc2(TEXSTORE_PARAMS)
-{
-   GLubyte *dst;
-   const GLint texWidth = dstRowStride * 4 / 16; /* a bit of a hack */
-   const GLchan *tempImage = NULL;
-   int i, j;
-   int numxpixels, numypixels;
-   const GLchan *srcaddr;
-   GLubyte srcpixels[4][4];
-   GLubyte *blkaddr;
-   GLint dstRowDiff;
-
-   ASSERT(dstFormat == MESA_FORMAT_RG_RGTC2 ||
-          dstFormat == MESA_FORMAT_LA_LATC2);
-   ASSERT(dstXoffset % 4 == 0);
-   ASSERT(dstYoffset % 4 == 0);
-   ASSERT(dstZoffset % 4 == 0);
-   (void) dstZoffset;
-   (void) dstImageOffsets;
-
-   tempImage = _mesa_make_temp_chan_image(ctx, dims,
-					  baseInternalFormat,
-					  _mesa_get_format_base_format(dstFormat),
-					  srcWidth, srcHeight, srcDepth,
-					  srcFormat, srcType, srcAddr,
-					  srcPacking);
-   if (!tempImage)
-      return GL_FALSE; /* out of memory */
-
-   dst = _mesa_compressed_image_address(dstXoffset, dstYoffset, 0,
-                                        dstFormat,
-                                        texWidth, (GLubyte *) dstAddr);
-
-   blkaddr = dst;
-   dstRowDiff = dstRowStride >= (srcWidth * 8) ? dstRowStride - (((srcWidth + 7) & ~7) * 8) : 0;
-   for (j = 0; j < srcHeight; j+=4) {
-      if (srcHeight > j + 3) numypixels = 4;
-      else numypixels = srcHeight - j;
-      srcaddr = tempImage + j * srcWidth * 2;
-      for (i = 0; i < srcWidth; i += 4) {
-	 if (srcWidth > i + 3) numxpixels = 4;
-	 else numxpixels = srcWidth - i;
-	 extractsrc_u(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 2);
-	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-
-	 blkaddr += 8;
-	 extractsrc_u(srcpixels, (GLchan *)srcaddr + 1, srcWidth, numxpixels, numypixels, 2);
-	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-
-	 blkaddr += 8;
-
-	 srcaddr += numxpixels * 2;
-      }
-      blkaddr += dstRowDiff;
-   }
-   if (tempImage)
-      free((void *) tempImage);
-
-   return GL_TRUE;
-}
-
-GLboolean
-_mesa_texstore_signed_rg_rgtc2(TEXSTORE_PARAMS)
-{
-   GLbyte *dst;
-   const GLint texWidth = dstRowStride * 4 / 16; /* a bit of a hack */
-   const GLfloat *tempImage = NULL;
-   int i, j;
-   int numxpixels, numypixels;
-   const GLfloat *srcaddr;
-   GLbyte srcpixels[4][4];
-   GLbyte *blkaddr;
-   GLint dstRowDiff;
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RG_RGTC2 ||
-          dstFormat == MESA_FORMAT_SIGNED_LA_LATC2);
-   ASSERT(dstXoffset % 4 == 0);
-   ASSERT(dstYoffset % 4 == 0);
-   ASSERT(dstZoffset % 4 == 0);
-   (void) dstZoffset;
-   (void) dstImageOffsets;
-
-   tempImage = _mesa_make_temp_float_image(ctx, dims,
-					   baseInternalFormat,
-					   _mesa_get_format_base_format(dstFormat),
-					   srcWidth, srcHeight, srcDepth,
-					   srcFormat, srcType, srcAddr,
-					   srcPacking, 0x0);
-   if (!tempImage)
-      return GL_FALSE; /* out of memory */
-
-   dst = (GLbyte *)_mesa_compressed_image_address(dstXoffset, dstYoffset, 0,
-						  dstFormat,
-						  texWidth, (GLubyte *) dstAddr);
-
-   blkaddr = dst;
-   dstRowDiff = dstRowStride >= (srcWidth * 8) ? dstRowStride - (((srcWidth + 7) & ~7) * 8) : 0;
-   for (j = 0; j < srcHeight; j += 4) {
-      if (srcHeight > j + 3) numypixels = 4;
-      else numypixels = srcHeight - j;
-      srcaddr = tempImage + j * srcWidth * 2;
-      for (i = 0; i < srcWidth; i += 4) {
-	 if (srcWidth > i + 3) numxpixels = 4;
-	 else numxpixels = srcWidth - i;
-
-	 extractsrc_s(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 2);
-	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-	 blkaddr += 8;
-
-	 extractsrc_s(srcpixels, srcaddr + 1, srcWidth, numxpixels, numypixels, 2);
-	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);
-	 blkaddr += 8;
-
-	 srcaddr += numxpixels * 2;
-
-      }
-      blkaddr += dstRowDiff;
-   }
-   if (tempImage)
-      free((void *) tempImage);
-
-   return GL_TRUE;
-}
-
-void
-_mesa_fetch_texel_2d_f_red_rgtc1(const struct gl_texture_image *texImage,
-				 GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLubyte red;
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),
-		       i, j, &red, 1);
-   texel[RCOMP] = UBYTE_TO_FLOAT(red);
-   texel[GCOMP] = 0.0;
-   texel[BCOMP] = 0.0;
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_signed_red_rgtc1(const struct gl_texture_image *texImage,
-					GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLbyte red;
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),
-		       i, j, &red, 1);
-   texel[RCOMP] = BYTE_TO_FLOAT_TEX(red);
-   texel[GCOMP] = 0.0;
-   texel[BCOMP] = 0.0;
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_rg_rgtc2(const struct gl_texture_image *texImage,
-				 GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLubyte red, green;
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),
-		     i, j, &red, 2);
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data) + 8,
-		     i, j, &green, 2);
-   texel[RCOMP] = UBYTE_TO_FLOAT(red);
-   texel[GCOMP] = UBYTE_TO_FLOAT(green);
-   texel[BCOMP] = 0.0;
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_signed_rg_rgtc2(const struct gl_texture_image *texImage,
-				       GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLbyte red, green;
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),
-		     i, j, &red, 2);
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data) + 8,
-		     i, j, &green, 2);
-   texel[RCOMP] = BYTE_TO_FLOAT_TEX(red);
-   texel[GCOMP] = BYTE_TO_FLOAT_TEX(green);
-   texel[BCOMP] = 0.0;
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_l_latc1(const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLubyte red;
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),
-                       i, j, &red, 1);
-   texel[RCOMP] =
-   texel[GCOMP] =
-   texel[BCOMP] = UBYTE_TO_FLOAT(red);
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_signed_l_latc1(const struct gl_texture_image *texImage,
-                                        GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLbyte red;
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),
-                       i, j, &red, 1);
-   texel[RCOMP] =
-   texel[GCOMP] =
-   texel[BCOMP] = BYTE_TO_FLOAT_TEX(red);
-   texel[ACOMP] = 1.0;
-}
-
-void
-_mesa_fetch_texel_2d_f_la_latc2(const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLubyte red, green;
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),
-                     i, j, &red, 2);
-   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data) + 8,
-                     i, j, &green, 2);
-   texel[RCOMP] =
-   texel[GCOMP] =
-   texel[BCOMP] = UBYTE_TO_FLOAT(red);
-   texel[ACOMP] = UBYTE_TO_FLOAT(green);
-}
-
-void
-_mesa_fetch_texel_2d_f_signed_la_latc2(const struct gl_texture_image *texImage,
-                                       GLint i, GLint j, GLint k, GLfloat *texel)
-{
-   GLbyte red, green;
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),
-                     i, j, &red, 2);
-   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data) + 8,
-                     i, j, &green, 2);
-   texel[RCOMP] =
-   texel[GCOMP] =
-   texel[BCOMP] = BYTE_TO_FLOAT_TEX(red);
-   texel[ACOMP] = BYTE_TO_FLOAT_TEX(green);
-}
-
-#define TAG(x) unsigned_##x
-
-#define TYPE GLubyte
-#define T_MIN 0
-#define T_MAX 0xff
-
-#include "texcompress_rgtc_tmp.h"
-
-#undef TAG
-#undef TYPE
-#undef T_MIN
-#undef T_MAX
-
-#define TAG(x) signed_##x
-#define TYPE GLbyte
-#define T_MIN (GLbyte)-128
-#define T_MAX (GLbyte)127
-
-#include "texcompress_rgtc_tmp.h"
-
-#undef TAG
-#undef TYPE
-#undef T_MIN
-#undef T_MAX
+/*

+ * Copyright (C) 2011 Red Hat Inc.

+ * 

+ * block compression parts are:

+ * Copyright (C) 2004  Roland Scheidegger   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, sublicense,

+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Author:

+ *    Dave Airlie

+ */

+

+/**

+ * \file texcompress_rgtc.c

+ * GL_EXT_texture_compression_rgtc support.

+ */

+

+

+#include "glheader.h"

+#include "imports.h"

+#include "colormac.h"

+#include "image.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mipmap.h"

+#include "texcompress.h"

+#include "texcompress_rgtc.h"

+#include "texstore.h"

+

+#define RGTC_DEBUG 0

+

+static void unsigned_encode_rgtc_chan(GLubyte *blkaddr, GLubyte srccolors[4][4],

+					GLint numxpixels, GLint numypixels);

+static void signed_encode_rgtc_chan(GLbyte *blkaddr, GLbyte srccolors[4][4],

+			     GLint numxpixels, GLint numypixels);

+

+static void unsigned_fetch_texel_rgtc(unsigned srcRowStride, const GLubyte *pixdata,

+				      unsigned i, unsigned j, GLubyte *value, unsigned comps);

+

+static void signed_fetch_texel_rgtc(unsigned srcRowStride, const GLbyte *pixdata,

+				      unsigned i, unsigned j, GLbyte *value, unsigned comps);

+

+static void extractsrc_u( GLubyte srcpixels[4][4], const GLchan *srcaddr,

+			  GLint srcRowStride, GLint numxpixels, GLint numypixels, GLint comps)

+{

+   GLubyte i, j;

+   const GLchan *curaddr;

+   for (j = 0; j < numypixels; j++) {

+      curaddr = srcaddr + j * srcRowStride * comps;

+      for (i = 0; i < numxpixels; i++) {

+	 srcpixels[j][i] = *curaddr / (CHAN_MAX / 255);

+	 curaddr += comps;

+      }

+   }

+}

+

+static void extractsrc_s( GLbyte srcpixels[4][4], const GLfloat *srcaddr,

+			  GLint srcRowStride, GLint numxpixels, GLint numypixels, GLint comps)

+{

+   GLubyte i, j;

+   const GLfloat *curaddr;

+   for (j = 0; j < numypixels; j++) {

+      curaddr = srcaddr + j * srcRowStride * comps;

+      for (i = 0; i < numxpixels; i++) {

+	 srcpixels[j][i] = FLOAT_TO_BYTE_TEX(*curaddr);

+	 curaddr += comps;

+      }

+   }

+}

+

+

+GLboolean

+_mesa_texstore_red_rgtc1(TEXSTORE_PARAMS)

+{

+   GLubyte *dst;

+   const GLint texWidth = dstRowStride * 4 / 8; /* a bit of a hack */

+   const GLchan *tempImage = NULL;

+   int i, j;

+   int numxpixels, numypixels;

+   const GLchan *srcaddr;

+   GLubyte srcpixels[4][4];

+   GLubyte *blkaddr;

+   GLint dstRowDiff;

+   ASSERT(dstFormat == MESA_FORMAT_RED_RGTC1 ||

+          dstFormat == MESA_FORMAT_L_LATC1);

+   ASSERT(dstXoffset % 4 == 0);

+   ASSERT(dstYoffset % 4 == 0);

+   ASSERT(dstZoffset % 4 == 0);

+   (void) dstZoffset;

+   (void) dstImageOffsets;

+

+

+   tempImage = _mesa_make_temp_chan_image(ctx, dims,

+					  baseInternalFormat,

+					  _mesa_get_format_base_format(dstFormat),

+					  srcWidth, srcHeight, srcDepth,

+					  srcFormat, srcType, srcAddr,

+					  srcPacking);

+   if (!tempImage)

+      return GL_FALSE; /* out of memory */

+

+   dst = _mesa_compressed_image_address(dstXoffset, dstYoffset, 0,

+                                        dstFormat,

+                                        texWidth, (GLubyte *) dstAddr);

+

+   blkaddr = dst;

+   dstRowDiff = dstRowStride >= (srcWidth * 4) ? dstRowStride - (((srcWidth + 3) & ~3) * 4) : 0;

+   for (j = 0; j < srcHeight; j+=4) {

+      if (srcHeight > j + 3) numypixels = 4;

+      else numypixels = srcHeight - j;

+      srcaddr = tempImage + j * srcWidth;

+      for (i = 0; i < srcWidth; i += 4) {

+	 if (srcWidth > i + 3) numxpixels = 4;

+	 else numxpixels = srcWidth - i;

+	 extractsrc_u(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 1);

+	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+	 srcaddr += numxpixels;

+	 blkaddr += 8;

+      }

+      blkaddr += dstRowDiff;

+   }

+   if (tempImage)

+      free((void *) tempImage);

+

+   return GL_TRUE;

+}

+

+GLboolean

+_mesa_texstore_signed_red_rgtc1(TEXSTORE_PARAMS)

+{

+   GLbyte *dst;

+   const GLint texWidth = dstRowStride * 4 / 8; /* a bit of a hack */

+   const GLfloat *tempImage = NULL;

+   int i, j;

+   int numxpixels, numypixels;

+   const GLfloat *srcaddr;

+   GLbyte srcpixels[4][4];

+   GLbyte *blkaddr;

+   GLint dstRowDiff;

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RED_RGTC1 ||

+          dstFormat == MESA_FORMAT_SIGNED_L_LATC1);

+   ASSERT(dstXoffset % 4 == 0);

+   ASSERT(dstYoffset % 4 == 0);

+   ASSERT(dstZoffset % 4 == 0);

+   (void) dstZoffset;

+   (void) dstImageOffsets;

+

+   tempImage = _mesa_make_temp_float_image(ctx, dims,

+					   baseInternalFormat,

+					   _mesa_get_format_base_format(dstFormat),

+					   srcWidth, srcHeight, srcDepth,

+					   srcFormat, srcType, srcAddr,

+					   srcPacking, 0x0);

+   if (!tempImage)

+      return GL_FALSE; /* out of memory */

+

+   dst = (GLbyte *)_mesa_compressed_image_address(dstXoffset, dstYoffset, 0,

+						  dstFormat,

+						  texWidth, (GLubyte *) dstAddr);

+

+   blkaddr = dst;

+   dstRowDiff = dstRowStride >= (srcWidth * 4) ? dstRowStride - (((srcWidth + 3) & ~3) * 4) : 0;

+   for (j = 0; j < srcHeight; j+=4) {

+      if (srcHeight > j + 3) numypixels = 4;

+      else numypixels = srcHeight - j;

+      srcaddr = tempImage + j * srcWidth;

+      for (i = 0; i < srcWidth; i += 4) {

+	 if (srcWidth > i + 3) numxpixels = 4;

+	 else numxpixels = srcWidth - i;

+	 extractsrc_s(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 1);

+	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+	 srcaddr += numxpixels;

+	 blkaddr += 8;

+      }

+      blkaddr += dstRowDiff;

+   }

+   if (tempImage)

+      free((void *) tempImage);

+

+   return GL_TRUE;

+}

+

+GLboolean

+_mesa_texstore_rg_rgtc2(TEXSTORE_PARAMS)

+{

+   GLubyte *dst;

+   const GLint texWidth = dstRowStride * 4 / 16; /* a bit of a hack */

+   const GLchan *tempImage = NULL;

+   int i, j;

+   int numxpixels, numypixels;

+   const GLchan *srcaddr;

+   GLubyte srcpixels[4][4];

+   GLubyte *blkaddr;

+   GLint dstRowDiff;

+

+   ASSERT(dstFormat == MESA_FORMAT_RG_RGTC2 ||

+          dstFormat == MESA_FORMAT_LA_LATC2);

+   ASSERT(dstXoffset % 4 == 0);

+   ASSERT(dstYoffset % 4 == 0);

+   ASSERT(dstZoffset % 4 == 0);

+   (void) dstZoffset;

+   (void) dstImageOffsets;

+

+   tempImage = _mesa_make_temp_chan_image(ctx, dims,

+					  baseInternalFormat,

+					  _mesa_get_format_base_format(dstFormat),

+					  srcWidth, srcHeight, srcDepth,

+					  srcFormat, srcType, srcAddr,

+					  srcPacking);

+   if (!tempImage)

+      return GL_FALSE; /* out of memory */

+

+   dst = _mesa_compressed_image_address(dstXoffset, dstYoffset, 0,

+                                        dstFormat,

+                                        texWidth, (GLubyte *) dstAddr);

+

+   blkaddr = dst;

+   dstRowDiff = dstRowStride >= (srcWidth * 8) ? dstRowStride - (((srcWidth + 7) & ~7) * 8) : 0;

+   for (j = 0; j < srcHeight; j+=4) {

+      if (srcHeight > j + 3) numypixels = 4;

+      else numypixels = srcHeight - j;

+      srcaddr = tempImage + j * srcWidth * 2;

+      for (i = 0; i < srcWidth; i += 4) {

+	 if (srcWidth > i + 3) numxpixels = 4;

+	 else numxpixels = srcWidth - i;

+	 extractsrc_u(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 2);

+	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+

+	 blkaddr += 8;

+	 extractsrc_u(srcpixels, (GLchan *)srcaddr + 1, srcWidth, numxpixels, numypixels, 2);

+	 unsigned_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+

+	 blkaddr += 8;

+

+	 srcaddr += numxpixels * 2;

+      }

+      blkaddr += dstRowDiff;

+   }

+   if (tempImage)

+      free((void *) tempImage);

+

+   return GL_TRUE;

+}

+

+GLboolean

+_mesa_texstore_signed_rg_rgtc2(TEXSTORE_PARAMS)

+{

+   GLbyte *dst;

+   const GLint texWidth = dstRowStride * 4 / 16; /* a bit of a hack */

+   const GLfloat *tempImage = NULL;

+   int i, j;

+   int numxpixels, numypixels;

+   const GLfloat *srcaddr;

+   GLbyte srcpixels[4][4];

+   GLbyte *blkaddr;

+   GLint dstRowDiff;

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RG_RGTC2 ||

+          dstFormat == MESA_FORMAT_SIGNED_LA_LATC2);

+   ASSERT(dstXoffset % 4 == 0);

+   ASSERT(dstYoffset % 4 == 0);

+   ASSERT(dstZoffset % 4 == 0);

+   (void) dstZoffset;

+   (void) dstImageOffsets;

+

+   tempImage = _mesa_make_temp_float_image(ctx, dims,

+					   baseInternalFormat,

+					   _mesa_get_format_base_format(dstFormat),

+					   srcWidth, srcHeight, srcDepth,

+					   srcFormat, srcType, srcAddr,

+					   srcPacking, 0x0);

+   if (!tempImage)

+      return GL_FALSE; /* out of memory */

+

+   dst = (GLbyte *)_mesa_compressed_image_address(dstXoffset, dstYoffset, 0,

+						  dstFormat,

+						  texWidth, (GLubyte *) dstAddr);

+

+   blkaddr = dst;

+   dstRowDiff = dstRowStride >= (srcWidth * 8) ? dstRowStride - (((srcWidth + 7) & ~7) * 8) : 0;

+   for (j = 0; j < srcHeight; j += 4) {

+      if (srcHeight > j + 3) numypixels = 4;

+      else numypixels = srcHeight - j;

+      srcaddr = tempImage + j * srcWidth * 2;

+      for (i = 0; i < srcWidth; i += 4) {

+	 if (srcWidth > i + 3) numxpixels = 4;

+	 else numxpixels = srcWidth - i;

+

+	 extractsrc_s(srcpixels, srcaddr, srcWidth, numxpixels, numypixels, 2);

+	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+	 blkaddr += 8;

+

+	 extractsrc_s(srcpixels, srcaddr + 1, srcWidth, numxpixels, numypixels, 2);

+	 signed_encode_rgtc_chan(blkaddr, srcpixels, numxpixels, numypixels);

+	 blkaddr += 8;

+

+	 srcaddr += numxpixels * 2;

+

+      }

+      blkaddr += dstRowDiff;

+   }

+   if (tempImage)

+      free((void *) tempImage);

+

+   return GL_TRUE;

+}

+

+void

+_mesa_fetch_texel_2d_f_red_rgtc1(const struct gl_texture_image *texImage,

+				 GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLubyte red;

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),

+		       i, j, &red, 1);

+   texel[RCOMP] = UBYTE_TO_FLOAT(red);

+   texel[GCOMP] = 0.0;

+   texel[BCOMP] = 0.0;

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_signed_red_rgtc1(const struct gl_texture_image *texImage,

+					GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLbyte red;

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),

+		       i, j, &red, 1);

+   texel[RCOMP] = BYTE_TO_FLOAT_TEX(red);

+   texel[GCOMP] = 0.0;

+   texel[BCOMP] = 0.0;

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_rg_rgtc2(const struct gl_texture_image *texImage,

+				 GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLubyte red, green;

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),

+		     i, j, &red, 2);

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data) + 8,

+		     i, j, &green, 2);

+   texel[RCOMP] = UBYTE_TO_FLOAT(red);

+   texel[GCOMP] = UBYTE_TO_FLOAT(green);

+   texel[BCOMP] = 0.0;

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_signed_rg_rgtc2(const struct gl_texture_image *texImage,

+				       GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLbyte red, green;

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),

+		     i, j, &red, 2);

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data) + 8,

+		     i, j, &green, 2);

+   texel[RCOMP] = BYTE_TO_FLOAT_TEX(red);

+   texel[GCOMP] = BYTE_TO_FLOAT_TEX(green);

+   texel[BCOMP] = 0.0;

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_l_latc1(const struct gl_texture_image *texImage,

+                                 GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLubyte red;

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),

+                       i, j, &red, 1);

+   texel[RCOMP] =

+   texel[GCOMP] =

+   texel[BCOMP] = UBYTE_TO_FLOAT(red);

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_signed_l_latc1(const struct gl_texture_image *texImage,

+                                        GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLbyte red;

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),

+                       i, j, &red, 1);

+   texel[RCOMP] =

+   texel[GCOMP] =

+   texel[BCOMP] = BYTE_TO_FLOAT_TEX(red);

+   texel[ACOMP] = 1.0;

+}

+

+void

+_mesa_fetch_texel_2d_f_la_latc2(const struct gl_texture_image *texImage,

+                                 GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLubyte red, green;

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data),

+                     i, j, &red, 2);

+   unsigned_fetch_texel_rgtc(texImage->RowStride, (GLubyte *)(texImage->Data) + 8,

+                     i, j, &green, 2);

+   texel[RCOMP] =

+   texel[GCOMP] =

+   texel[BCOMP] = UBYTE_TO_FLOAT(red);

+   texel[ACOMP] = UBYTE_TO_FLOAT(green);

+}

+

+void

+_mesa_fetch_texel_2d_f_signed_la_latc2(const struct gl_texture_image *texImage,

+                                       GLint i, GLint j, GLint k, GLfloat *texel)

+{

+   GLbyte red, green;

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data),

+                     i, j, &red, 2);

+   signed_fetch_texel_rgtc(texImage->RowStride, (GLbyte *)(texImage->Data) + 8,

+                     i, j, &green, 2);

+   texel[RCOMP] =

+   texel[GCOMP] =

+   texel[BCOMP] = BYTE_TO_FLOAT_TEX(red);

+   texel[ACOMP] = BYTE_TO_FLOAT_TEX(green);

+}

+

+#define TAG(x) unsigned_##x

+

+#define TYPE GLubyte

+#define T_MIN 0

+#define T_MAX 0xff

+

+#include "texcompress_rgtc_tmp.h"

+

+#undef TAG

+#undef TYPE

+#undef T_MIN

+#undef T_MAX

+

+#define TAG(x) signed_##x

+#define TYPE GLbyte

+#define T_MIN (GLbyte)-128

+#define T_MAX (GLbyte)127

+

+#include "texcompress_rgtc_tmp.h"

+

+#undef TAG

+#undef TYPE

+#undef T_MIN

+#undef T_MAX

diff --git a/mesalib/src/mesa/main/texcompress_rgtc.h b/mesalib/src/mesa/main/texcompress_rgtc.h
index 18766770d..a64ef9968 100644
--- a/mesalib/src/mesa/main/texcompress_rgtc.h
+++ b/mesalib/src/mesa/main/texcompress_rgtc.h
@@ -1,77 +1,77 @@
-/*
- * Copyright (C) 2011 Red Hat Inc.
- *
- * 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, sublicense,
- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- */
-
-#ifndef TEXCOMPRESS_RGTC_H
-#define TEXCOMPRESS_RGTC_H
-
-#include "glheader.h"
-#include "mfeatures.h"
-#include "texstore.h"
-
-struct gl_texture_image;
-
-extern GLboolean
-_mesa_texstore_red_rgtc1(TEXSTORE_PARAMS);
-
-extern GLboolean
-_mesa_texstore_signed_red_rgtc1(TEXSTORE_PARAMS);
-
-extern GLboolean
-_mesa_texstore_rg_rgtc2(TEXSTORE_PARAMS);
-
-extern GLboolean
-_mesa_texstore_signed_rg_rgtc2(TEXSTORE_PARAMS);
-
-extern void
-_mesa_fetch_texel_2d_f_red_rgtc1(const struct gl_texture_image *texImage,
-				 GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_signed_red_rgtc1(const struct gl_texture_image *texImage,
-					GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_rg_rgtc2(const struct gl_texture_image *texImage,
-				 GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_signed_rg_rgtc2(const struct gl_texture_image *texImage,
-				       GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_l_latc1(const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_signed_l_latc1(const struct gl_texture_image *texImage,
-                                        GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_la_latc2(const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLfloat *texel);
-
-extern void
-_mesa_fetch_texel_2d_f_signed_la_latc2(const struct gl_texture_image *texImage,
-                                       GLint i, GLint j, GLint k, GLfloat *texel);
-
-#endif
+/*

+ * Copyright (C) 2011 Red Hat Inc.

+ *

+ * 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, sublicense,

+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+

+#ifndef TEXCOMPRESS_RGTC_H

+#define TEXCOMPRESS_RGTC_H

+

+#include "glheader.h"

+#include "mfeatures.h"

+#include "texstore.h"

+

+struct gl_texture_image;

+

+extern GLboolean

+_mesa_texstore_red_rgtc1(TEXSTORE_PARAMS);

+

+extern GLboolean

+_mesa_texstore_signed_red_rgtc1(TEXSTORE_PARAMS);

+

+extern GLboolean

+_mesa_texstore_rg_rgtc2(TEXSTORE_PARAMS);

+

+extern GLboolean

+_mesa_texstore_signed_rg_rgtc2(TEXSTORE_PARAMS);

+

+extern void

+_mesa_fetch_texel_2d_f_red_rgtc1(const struct gl_texture_image *texImage,

+				 GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_signed_red_rgtc1(const struct gl_texture_image *texImage,

+					GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_rg_rgtc2(const struct gl_texture_image *texImage,

+				 GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_signed_rg_rgtc2(const struct gl_texture_image *texImage,

+				       GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_l_latc1(const struct gl_texture_image *texImage,

+                                 GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_signed_l_latc1(const struct gl_texture_image *texImage,

+                                        GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_la_latc2(const struct gl_texture_image *texImage,

+                                 GLint i, GLint j, GLint k, GLfloat *texel);

+

+extern void

+_mesa_fetch_texel_2d_f_signed_la_latc2(const struct gl_texture_image *texImage,

+                                       GLint i, GLint j, GLint k, GLfloat *texel);

+

+#endif

diff --git a/mesalib/src/mesa/main/texcompress_rgtc_tmp.h b/mesalib/src/mesa/main/texcompress_rgtc_tmp.h
index c8bf082a1..335e1f4a1 100644
--- a/mesalib/src/mesa/main/texcompress_rgtc_tmp.h
+++ b/mesalib/src/mesa/main/texcompress_rgtc_tmp.h
@@ -1,418 +1,418 @@
-/*
- * Copyright (C) 2011 Red Hat Inc.
- * 
- * block compression parts are:
- * Copyright (C) 2004  Roland Scheidegger   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, sublicense,
- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Author:
- *    Dave Airlie
- */
-
-/* included by texcompress_rgtc to define byte/ubyte compressors */
-
-static void TAG(fetch_texel_rgtc)(unsigned srcRowStride, const TYPE *pixdata,
-				  unsigned i, unsigned j, TYPE *value, unsigned comps)
-{
-   TYPE decode;
-   const TYPE *blksrc = (pixdata + ((srcRowStride + 3) / 4 * (j / 4) + (i / 4)) * 8 * comps);
-   const TYPE alpha0 = blksrc[0];
-   const TYPE alpha1 = blksrc[1];
-   const char bit_pos = ((j&3) * 4 + (i&3)) * 3;
-   const TYPE acodelow = blksrc[2 + bit_pos / 8];
-   const TYPE acodehigh = (3 + bit_pos / 8) < 8 ? blksrc[3 + bit_pos / 8] : 0;
-   const TYPE code = (acodelow >> (bit_pos & 0x7) |
-      (acodehigh  << (8 - (bit_pos & 0x7)))) & 0x7;
-
-   if (code == 0)
-      decode = alpha0;
-   else if (code == 1)
-      decode = alpha1;
-   else if (alpha0 > alpha1)
-      decode = ((alpha0 * (8 - code) + (alpha1 * (code - 1))) / 7);
-   else if (code < 6)
-      decode = ((alpha0 * (6 - code) + (alpha1 * (code - 1))) / 5);
-   else if (code == 6)
-      decode = T_MIN;
-   else
-      decode = T_MAX;
-
-   *value = decode;
-}
-
-static void TAG(write_rgtc_encoded_channel)(TYPE *blkaddr,
-					    TYPE alphabase1,
-					    TYPE alphabase2,
-					    TYPE alphaenc[16])
-{
-   *blkaddr++ = alphabase1;
-   *blkaddr++ = alphabase2;
-   *blkaddr++ = alphaenc[0] | (alphaenc[1] << 3) | ((alphaenc[2] & 3) << 6);
-   *blkaddr++ = (alphaenc[2] >> 2) | (alphaenc[3] << 1) | (alphaenc[4] << 4) | ((alphaenc[5] & 1) << 7);
-   *blkaddr++ = (alphaenc[5] >> 1) | (alphaenc[6] << 2) | (alphaenc[7] << 5);
-   *blkaddr++ = alphaenc[8] | (alphaenc[9] << 3) | ((alphaenc[10] & 3) << 6);
-   *blkaddr++ = (alphaenc[10] >> 2) | (alphaenc[11] << 1) | (alphaenc[12] << 4) | ((alphaenc[13] & 1) << 7);
-   *blkaddr++ = (alphaenc[13] >> 1) | (alphaenc[14] << 2) | (alphaenc[15] << 5);
-}
-
-static void TAG(encode_rgtc_chan)(TYPE *blkaddr, TYPE srccolors[4][4],
-			     int numxpixels, int numypixels)
-{
-   TYPE alphabase[2], alphause[2];
-   short alphatest[2] = { 0 };
-   unsigned int alphablockerror1, alphablockerror2, alphablockerror3;
-   TYPE i, j, aindex, acutValues[7];
-   TYPE alphaenc1[16], alphaenc2[16], alphaenc3[16];
-   int alphaabsmin = 0, alphaabsmax = 0;
-   short alphadist;
-
-   /* find lowest and highest alpha value in block, alphabase[0] lowest, alphabase[1] highest */
-   alphabase[0] = T_MAX; alphabase[1] = T_MIN;
-   for (j = 0; j < numypixels; j++) {
-      for (i = 0; i < numxpixels; i++) {
-	 if (srccolors[j][i] == T_MIN)
-            alphaabsmin = 1;
-         else if (srccolors[j][i] == T_MAX)
-            alphaabsmax = 1;
-         else {
-            if (srccolors[j][i] > alphabase[1])
-               alphabase[1] = srccolors[j][i];
-            if (srccolors[j][i] < alphabase[0])
-               alphabase[0] = srccolors[j][i];
-         }
-      }
-   }
-
-
-   if (((alphabase[0] > alphabase[1]) && !(alphaabsmin && alphaabsmax))
-       || (alphabase[0] == alphabase[1] && !alphaabsmin && !alphaabsmax)) { /* one color, either max or min */
-      /* shortcut here since it is a very common case (and also avoids later problems) */
-      /* could also thest for alpha0 == alpha1 (and not min/max), but probably not common, so don't bother */
-
-      *blkaddr++ = srccolors[0][0];
-      blkaddr++;
-      *blkaddr++ = 0;
-      *blkaddr++ = 0;
-      *blkaddr++ = 0;
-      *blkaddr++ = 0;
-      *blkaddr++ = 0;
-      *blkaddr++ = 0;
-#if RGTC_DEBUG
-      fprintf(stderr, "enc0 used\n");
-#endif
-      return;
-   }
-
-   /* find best encoding for alpha0 > alpha1 */
-   /* it's possible this encoding is better even if both alphaabsmin and alphaabsmax are true */
-   alphablockerror1 = 0x0;
-   alphablockerror2 = 0xffffffff;
-   alphablockerror3 = 0xffffffff;
-   if (alphaabsmin) alphause[0] = T_MIN;
-   else alphause[0] = alphabase[0];
-   if (alphaabsmax) alphause[1] = T_MAX;
-   else alphause[1] = alphabase[1];
-   /* calculate the 7 cut values, just the middle between 2 of the computed alpha values */
-   for (aindex = 0; aindex < 7; aindex++) {
-      /* don't forget here is always rounded down */
-      acutValues[aindex] = (alphause[0] * (2*aindex + 1) + alphause[1] * (14 - (2*aindex + 1))) / 14;
-   }
-
-   for (j = 0; j < numypixels; j++) {
-      for (i = 0; i < numxpixels; i++) {
-         /* maybe it's overkill to have the most complicated calculation just for the error
-            calculation which we only need to figure out if encoding1 or encoding2 is better... */
-         if (srccolors[j][i] > acutValues[0]) {
-            alphaenc1[4*j + i] = 0;
-            alphadist = srccolors[j][i] - alphause[1];
-         }
-         else if (srccolors[j][i] > acutValues[1]) {
-            alphaenc1[4*j + i] = 2;
-            alphadist = srccolors[j][i] - (alphause[1] * 6 + alphause[0] * 1) / 7;
-         }
-         else if (srccolors[j][i] > acutValues[2]) {
-            alphaenc1[4*j + i] = 3;
-            alphadist = srccolors[j][i] - (alphause[1] * 5 + alphause[0] * 2) / 7;
-         }
-         else if (srccolors[j][i] > acutValues[3]) {
-            alphaenc1[4*j + i] = 4;
-            alphadist = srccolors[j][i] - (alphause[1] * 4 + alphause[0] * 3) / 7;
-         }
-         else if (srccolors[j][i] > acutValues[4]) {
-            alphaenc1[4*j + i] = 5;
-            alphadist = srccolors[j][i] - (alphause[1] * 3 + alphause[0] * 4) / 7;
-         }
-         else if (srccolors[j][i] > acutValues[5]) {
-            alphaenc1[4*j + i] = 6;
-            alphadist = srccolors[j][i] - (alphause[1] * 2 + alphause[0] * 5) / 7;
-         }
-         else if (srccolors[j][i] > acutValues[6]) {
-            alphaenc1[4*j + i] = 7;
-            alphadist = srccolors[j][i] - (alphause[1] * 1 + alphause[0] * 6) / 7;
-         }
-         else {
-            alphaenc1[4*j + i] = 1;
-            alphadist = srccolors[j][i] - alphause[0];
-         }
-         alphablockerror1 += alphadist * alphadist;
-      }
-   }
-
-#if RGTC_DEBUG
-   for (i = 0; i < 16; i++) {
-      fprintf(stderr, "%d ", alphaenc1[i]);
-   }
-   fprintf(stderr, "cutVals ");
-   for (i = 0; i < 8; i++) {
-      fprintf(stderr, "%d ", acutValues[i]);
-   }
-   fprintf(stderr, "srcVals ");
-   for (j = 0; j < numypixels; j++) {
-      for (i = 0; i < numxpixels; i++) {
-	 fprintf(stderr, "%d ", srccolors[j][i]);
-      }
-   }
-   fprintf(stderr, "\n");
-#endif
-
-   /* it's not very likely this encoding is better if both alphaabsmin and alphaabsmax
-      are false but try it anyway */
-   if (alphablockerror1 >= 32) {
-
-      /* don't bother if encoding is already very good, this condition should also imply
-      we have valid alphabase colors which we absolutely need (alphabase[0] <= alphabase[1]) */
-      alphablockerror2 = 0;
-      for (aindex = 0; aindex < 5; aindex++) {
-         /* don't forget here is always rounded down */
-         acutValues[aindex] = (alphabase[0] * (10 - (2*aindex + 1)) + alphabase[1] * (2*aindex + 1)) / 10;
-      }
-      for (j = 0; j < numypixels; j++) {
-         for (i = 0; i < numxpixels; i++) {
-             /* maybe it's overkill to have the most complicated calculation just for the error
-               calculation which we only need to figure out if encoding1 or encoding2 is better... */
-            if (srccolors[j][i] == T_MIN) {
-               alphaenc2[4*j + i] = 6;
-               alphadist = 0;
-            }
-            else if (srccolors[j][i] == T_MAX) {
-               alphaenc2[4*j + i] = 7;
-               alphadist = 0;
-            }
-            else if (srccolors[j][i] <= acutValues[0]) {
-               alphaenc2[4*j + i] = 0;
-               alphadist = srccolors[j][i] - alphabase[0];
-            }
-            else if (srccolors[j][i] <= acutValues[1]) {
-               alphaenc2[4*j + i] = 2;
-               alphadist = srccolors[j][i] - (alphabase[0] * 4 + alphabase[1] * 1) / 5;
-            }
-            else if (srccolors[j][i] <= acutValues[2]) {
-               alphaenc2[4*j + i] = 3;
-               alphadist = srccolors[j][i] - (alphabase[0] * 3 + alphabase[1] * 2) / 5;
-            }
-            else if (srccolors[j][i] <= acutValues[3]) {
-               alphaenc2[4*j + i] = 4;
-               alphadist = srccolors[j][i] - (alphabase[0] * 2 + alphabase[1] * 3) / 5;
-            }
-            else if (srccolors[j][i] <= acutValues[4]) {
-               alphaenc2[4*j + i] = 5;
-               alphadist = srccolors[j][i] - (alphabase[0] * 1 + alphabase[1] * 4) / 5;
-            }
-            else {
-               alphaenc2[4*j + i] = 1;
-               alphadist = srccolors[j][i] - alphabase[1];
-            }
-            alphablockerror2 += alphadist * alphadist;
-         }
-      }
-
-
-      /* skip this if the error is already very small
-         this encoding is MUCH better on average than #2 though, but expensive! */
-      if ((alphablockerror2 > 96) && (alphablockerror1 > 96)) {
-         short blockerrlin1 = 0;
-         short blockerrlin2 = 0;
-         TYPE nralphainrangelow = 0;
-         TYPE nralphainrangehigh = 0;
-         alphatest[0] = T_MAX;
-         alphatest[1] = T_MIN;
-         /* if we have large range it's likely there are values close to 0/255, try to map them to 0/255 */
-         for (j = 0; j < numypixels; j++) {
-            for (i = 0; i < numxpixels; i++) {
-               if ((srccolors[j][i] > alphatest[1]) && (srccolors[j][i] < (T_MAX -(alphabase[1] - alphabase[0]) / 28)))
-                  alphatest[1] = srccolors[j][i];
-               if ((srccolors[j][i] < alphatest[0]) && (srccolors[j][i] > (alphabase[1] - alphabase[0]) / 28))
-                  alphatest[0] = srccolors[j][i];
-            }
-         }
-          /* shouldn't happen too often, don't really care about those degenerated cases */
-          if (alphatest[1] <= alphatest[0]) {
-             alphatest[0] = T_MIN+1;
-             alphatest[1] = T_MAX-1;
-         }
-         for (aindex = 0; aindex < 5; aindex++) {
-         /* don't forget here is always rounded down */
-            acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;
-         }
-
-         /* find the "average" difference between the alpha values and the next encoded value.
-            This is then used to calculate new base values.
-            Should there be some weighting, i.e. those values closer to alphatest[x] have more weight,
-            since they will see more improvement, and also because the values in the middle are somewhat
-            likely to get no improvement at all (because the base values might move in different directions)?
-            OTOH it would mean the values in the middle are even less likely to get an improvement
-         */
-         for (j = 0; j < numypixels; j++) {
-            for (i = 0; i < numxpixels; i++) {
-               if (srccolors[j][i] <= alphatest[0] / 2) {
-               }
-               else if (srccolors[j][i] > ((T_MAX + alphatest[1]) / 2)) {
-               }
-               else if (srccolors[j][i] <= acutValues[0]) {
-                  blockerrlin1 += (srccolors[j][i] - alphatest[0]);
-                  nralphainrangelow += 1;
-               }
-               else if (srccolors[j][i] <= acutValues[1]) {
-                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
-                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
-                  nralphainrangelow += 1;
-                  nralphainrangehigh += 1;
-               }
-               else if (srccolors[j][i] <= acutValues[2]) {
-                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
-                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
-                  nralphainrangelow += 1;
-                  nralphainrangehigh += 1;
-               }
-               else if (srccolors[j][i] <= acutValues[3]) {
-                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
-                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
-                  nralphainrangelow += 1;
-                  nralphainrangehigh += 1;
-               }
-               else if (srccolors[j][i] <= acutValues[4]) {
-                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
-                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
-                  nralphainrangelow += 1;
-                  nralphainrangehigh += 1;
-                  }
-               else {
-                  blockerrlin2 += (srccolors[j][i] - alphatest[1]);
-                  nralphainrangehigh += 1;
-               }
-            }
-         }
-         /* shouldn't happen often, needed to avoid div by zero */
-         if (nralphainrangelow == 0) nralphainrangelow = 1;
-         if (nralphainrangehigh == 0) nralphainrangehigh = 1;
-         alphatest[0] = alphatest[0] + (blockerrlin1 / nralphainrangelow);
-#if RGTC_DEBUG
-         fprintf(stderr, "block err lin low %d, nr %d\n", blockerrlin1, nralphainrangelow);
-         fprintf(stderr, "block err lin high %d, nr %d\n", blockerrlin2, nralphainrangehigh);
-#endif
-         /* again shouldn't really happen often... */
-         if (alphatest[0] < T_MIN) {
-            alphatest[0] = T_MIN;
-         }
-         alphatest[1] = alphatest[1] + (blockerrlin2 / nralphainrangehigh);
-         if (alphatest[1] > T_MAX) {
-            alphatest[1] = T_MAX;
-         }
-
-         alphablockerror3 = 0;
-         for (aindex = 0; aindex < 5; aindex++) {
-         /* don't forget here is always rounded down */
-            acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;
-         }
-         for (j = 0; j < numypixels; j++) {
-            for (i = 0; i < numxpixels; i++) {
-                /* maybe it's overkill to have the most complicated calculation just for the error
-                  calculation which we only need to figure out if encoding1 or encoding2 is better... */
-               if (srccolors[j][i] <= alphatest[0] / 2) {
-                  alphaenc3[4*j + i] = 6;
-                  alphadist = srccolors[j][i];
-               }
-               else if (srccolors[j][i] > ((T_MAX + alphatest[1]) / 2)) {
-                  alphaenc3[4*j + i] = 7;
-                  alphadist = T_MAX - srccolors[j][i];
-               }
-               else if (srccolors[j][i] <= acutValues[0]) {
-                  alphaenc3[4*j + i] = 0;
-                  alphadist = srccolors[j][i] - alphatest[0];
-               }
-               else if (srccolors[j][i] <= acutValues[1]) {
-                 alphaenc3[4*j + i] = 2;
-                 alphadist = srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5;
-               }
-               else if (srccolors[j][i] <= acutValues[2]) {
-                  alphaenc3[4*j + i] = 3;
-                  alphadist = srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5;
-               }
-               else if (srccolors[j][i] <= acutValues[3]) {
-                  alphaenc3[4*j + i] = 4;
-                  alphadist = srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5;
-               }
-               else if (srccolors[j][i] <= acutValues[4]) {
-                  alphaenc3[4*j + i] = 5;
-                  alphadist = srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5;
-               }
-               else {
-                  alphaenc3[4*j + i] = 1;
-                  alphadist = srccolors[j][i] - alphatest[1];
-               }
-               alphablockerror3 += alphadist * alphadist;
-            }
-         }
-      }
-   }
-
-  /* write the alpha values and encoding back. */
-   if ((alphablockerror1 <= alphablockerror2) && (alphablockerror1 <= alphablockerror3)) {
-#if RGTC_DEBUG
-      if (alphablockerror1 > 96) fprintf(stderr, "enc1 used, error %d\n", alphablockerror1);
-      fprintf(stderr,"w1: min %d max %d au0 %d au1 %d\n",
-	      T_MIN, T_MAX,
-	      alphause[1], alphause[0]);
-#endif
-
-      TAG(write_rgtc_encoded_channel)( blkaddr, alphause[1], alphause[0], alphaenc1 );
-   }
-   else if (alphablockerror2 <= alphablockerror3) {
-#if RGTC_DEBUG
-      if (alphablockerror2 > 96) fprintf(stderr, "enc2 used, error %d\n", alphablockerror2);
-      fprintf(stderr,"w2: min %d max %d au0 %d au1 %d\n",
-	      T_MIN, T_MAX,
-	      alphabase[0], alphabase[1]);
-#endif
-
-      TAG(write_rgtc_encoded_channel)( blkaddr, alphabase[0], alphabase[1], alphaenc2 );
-   }
-   else {
-#if RGTC_DEBUG
-      fprintf(stderr, "enc3 used, error %d\n", alphablockerror3);
-      fprintf(stderr,"w3: min %d max %d au0 %d au1 %d\n",
-	      T_MIN, T_MAX,
-	      alphatest[0], alphatest[1]);
-#endif
-
-      TAG(write_rgtc_encoded_channel)( blkaddr, (TYPE)alphatest[0], (TYPE)alphatest[1], alphaenc3 );
-   }
-}
+/*

+ * Copyright (C) 2011 Red Hat Inc.

+ * 

+ * block compression parts are:

+ * Copyright (C) 2004  Roland Scheidegger   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, sublicense,

+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Author:

+ *    Dave Airlie

+ */

+

+/* included by texcompress_rgtc to define byte/ubyte compressors */

+

+static void TAG(fetch_texel_rgtc)(unsigned srcRowStride, const TYPE *pixdata,

+				  unsigned i, unsigned j, TYPE *value, unsigned comps)

+{

+   TYPE decode;

+   const TYPE *blksrc = (pixdata + ((srcRowStride + 3) / 4 * (j / 4) + (i / 4)) * 8 * comps);

+   const TYPE alpha0 = blksrc[0];

+   const TYPE alpha1 = blksrc[1];

+   const char bit_pos = ((j&3) * 4 + (i&3)) * 3;

+   const TYPE acodelow = blksrc[2 + bit_pos / 8];

+   const TYPE acodehigh = (3 + bit_pos / 8) < 8 ? blksrc[3 + bit_pos / 8] : 0;

+   const TYPE code = (acodelow >> (bit_pos & 0x7) |

+      (acodehigh  << (8 - (bit_pos & 0x7)))) & 0x7;

+

+   if (code == 0)

+      decode = alpha0;

+   else if (code == 1)

+      decode = alpha1;

+   else if (alpha0 > alpha1)

+      decode = ((alpha0 * (8 - code) + (alpha1 * (code - 1))) / 7);

+   else if (code < 6)

+      decode = ((alpha0 * (6 - code) + (alpha1 * (code - 1))) / 5);

+   else if (code == 6)

+      decode = T_MIN;

+   else

+      decode = T_MAX;

+

+   *value = decode;

+}

+

+static void TAG(write_rgtc_encoded_channel)(TYPE *blkaddr,

+					    TYPE alphabase1,

+					    TYPE alphabase2,

+					    TYPE alphaenc[16])

+{

+   *blkaddr++ = alphabase1;

+   *blkaddr++ = alphabase2;

+   *blkaddr++ = alphaenc[0] | (alphaenc[1] << 3) | ((alphaenc[2] & 3) << 6);

+   *blkaddr++ = (alphaenc[2] >> 2) | (alphaenc[3] << 1) | (alphaenc[4] << 4) | ((alphaenc[5] & 1) << 7);

+   *blkaddr++ = (alphaenc[5] >> 1) | (alphaenc[6] << 2) | (alphaenc[7] << 5);

+   *blkaddr++ = alphaenc[8] | (alphaenc[9] << 3) | ((alphaenc[10] & 3) << 6);

+   *blkaddr++ = (alphaenc[10] >> 2) | (alphaenc[11] << 1) | (alphaenc[12] << 4) | ((alphaenc[13] & 1) << 7);

+   *blkaddr++ = (alphaenc[13] >> 1) | (alphaenc[14] << 2) | (alphaenc[15] << 5);

+}

+

+static void TAG(encode_rgtc_chan)(TYPE *blkaddr, TYPE srccolors[4][4],

+			     int numxpixels, int numypixels)

+{

+   TYPE alphabase[2], alphause[2];

+   short alphatest[2] = { 0 };

+   unsigned int alphablockerror1, alphablockerror2, alphablockerror3;

+   TYPE i, j, aindex, acutValues[7];

+   TYPE alphaenc1[16], alphaenc2[16], alphaenc3[16];

+   int alphaabsmin = 0, alphaabsmax = 0;

+   short alphadist;

+

+   /* find lowest and highest alpha value in block, alphabase[0] lowest, alphabase[1] highest */

+   alphabase[0] = T_MAX; alphabase[1] = T_MIN;

+   for (j = 0; j < numypixels; j++) {

+      for (i = 0; i < numxpixels; i++) {

+	 if (srccolors[j][i] == T_MIN)

+            alphaabsmin = 1;

+         else if (srccolors[j][i] == T_MAX)

+            alphaabsmax = 1;

+         else {

+            if (srccolors[j][i] > alphabase[1])

+               alphabase[1] = srccolors[j][i];

+            if (srccolors[j][i] < alphabase[0])

+               alphabase[0] = srccolors[j][i];

+         }

+      }

+   }

+

+

+   if (((alphabase[0] > alphabase[1]) && !(alphaabsmin && alphaabsmax))

+       || (alphabase[0] == alphabase[1] && !alphaabsmin && !alphaabsmax)) { /* one color, either max or min */

+      /* shortcut here since it is a very common case (and also avoids later problems) */

+      /* could also thest for alpha0 == alpha1 (and not min/max), but probably not common, so don't bother */

+

+      *blkaddr++ = srccolors[0][0];

+      blkaddr++;

+      *blkaddr++ = 0;

+      *blkaddr++ = 0;

+      *blkaddr++ = 0;

+      *blkaddr++ = 0;

+      *blkaddr++ = 0;

+      *blkaddr++ = 0;

+#if RGTC_DEBUG

+      fprintf(stderr, "enc0 used\n");

+#endif

+      return;

+   }

+

+   /* find best encoding for alpha0 > alpha1 */

+   /* it's possible this encoding is better even if both alphaabsmin and alphaabsmax are true */

+   alphablockerror1 = 0x0;

+   alphablockerror2 = 0xffffffff;

+   alphablockerror3 = 0xffffffff;

+   if (alphaabsmin) alphause[0] = T_MIN;

+   else alphause[0] = alphabase[0];

+   if (alphaabsmax) alphause[1] = T_MAX;

+   else alphause[1] = alphabase[1];

+   /* calculate the 7 cut values, just the middle between 2 of the computed alpha values */

+   for (aindex = 0; aindex < 7; aindex++) {

+      /* don't forget here is always rounded down */

+      acutValues[aindex] = (alphause[0] * (2*aindex + 1) + alphause[1] * (14 - (2*aindex + 1))) / 14;

+   }

+

+   for (j = 0; j < numypixels; j++) {

+      for (i = 0; i < numxpixels; i++) {

+         /* maybe it's overkill to have the most complicated calculation just for the error

+            calculation which we only need to figure out if encoding1 or encoding2 is better... */

+         if (srccolors[j][i] > acutValues[0]) {

+            alphaenc1[4*j + i] = 0;

+            alphadist = srccolors[j][i] - alphause[1];

+         }

+         else if (srccolors[j][i] > acutValues[1]) {

+            alphaenc1[4*j + i] = 2;

+            alphadist = srccolors[j][i] - (alphause[1] * 6 + alphause[0] * 1) / 7;

+         }

+         else if (srccolors[j][i] > acutValues[2]) {

+            alphaenc1[4*j + i] = 3;

+            alphadist = srccolors[j][i] - (alphause[1] * 5 + alphause[0] * 2) / 7;

+         }

+         else if (srccolors[j][i] > acutValues[3]) {

+            alphaenc1[4*j + i] = 4;

+            alphadist = srccolors[j][i] - (alphause[1] * 4 + alphause[0] * 3) / 7;

+         }

+         else if (srccolors[j][i] > acutValues[4]) {

+            alphaenc1[4*j + i] = 5;

+            alphadist = srccolors[j][i] - (alphause[1] * 3 + alphause[0] * 4) / 7;

+         }

+         else if (srccolors[j][i] > acutValues[5]) {

+            alphaenc1[4*j + i] = 6;

+            alphadist = srccolors[j][i] - (alphause[1] * 2 + alphause[0] * 5) / 7;

+         }

+         else if (srccolors[j][i] > acutValues[6]) {

+            alphaenc1[4*j + i] = 7;

+            alphadist = srccolors[j][i] - (alphause[1] * 1 + alphause[0] * 6) / 7;

+         }

+         else {

+            alphaenc1[4*j + i] = 1;

+            alphadist = srccolors[j][i] - alphause[0];

+         }

+         alphablockerror1 += alphadist * alphadist;

+      }

+   }

+

+#if RGTC_DEBUG

+   for (i = 0; i < 16; i++) {

+      fprintf(stderr, "%d ", alphaenc1[i]);

+   }

+   fprintf(stderr, "cutVals ");

+   for (i = 0; i < 8; i++) {

+      fprintf(stderr, "%d ", acutValues[i]);

+   }

+   fprintf(stderr, "srcVals ");

+   for (j = 0; j < numypixels; j++) {

+      for (i = 0; i < numxpixels; i++) {

+	 fprintf(stderr, "%d ", srccolors[j][i]);

+      }

+   }

+   fprintf(stderr, "\n");

+#endif

+

+   /* it's not very likely this encoding is better if both alphaabsmin and alphaabsmax

+      are false but try it anyway */

+   if (alphablockerror1 >= 32) {

+

+      /* don't bother if encoding is already very good, this condition should also imply

+      we have valid alphabase colors which we absolutely need (alphabase[0] <= alphabase[1]) */

+      alphablockerror2 = 0;

+      for (aindex = 0; aindex < 5; aindex++) {

+         /* don't forget here is always rounded down */

+         acutValues[aindex] = (alphabase[0] * (10 - (2*aindex + 1)) + alphabase[1] * (2*aindex + 1)) / 10;

+      }

+      for (j = 0; j < numypixels; j++) {

+         for (i = 0; i < numxpixels; i++) {

+             /* maybe it's overkill to have the most complicated calculation just for the error

+               calculation which we only need to figure out if encoding1 or encoding2 is better... */

+            if (srccolors[j][i] == T_MIN) {

+               alphaenc2[4*j + i] = 6;

+               alphadist = 0;

+            }

+            else if (srccolors[j][i] == T_MAX) {

+               alphaenc2[4*j + i] = 7;

+               alphadist = 0;

+            }

+            else if (srccolors[j][i] <= acutValues[0]) {

+               alphaenc2[4*j + i] = 0;

+               alphadist = srccolors[j][i] - alphabase[0];

+            }

+            else if (srccolors[j][i] <= acutValues[1]) {

+               alphaenc2[4*j + i] = 2;

+               alphadist = srccolors[j][i] - (alphabase[0] * 4 + alphabase[1] * 1) / 5;

+            }

+            else if (srccolors[j][i] <= acutValues[2]) {

+               alphaenc2[4*j + i] = 3;

+               alphadist = srccolors[j][i] - (alphabase[0] * 3 + alphabase[1] * 2) / 5;

+            }

+            else if (srccolors[j][i] <= acutValues[3]) {

+               alphaenc2[4*j + i] = 4;

+               alphadist = srccolors[j][i] - (alphabase[0] * 2 + alphabase[1] * 3) / 5;

+            }

+            else if (srccolors[j][i] <= acutValues[4]) {

+               alphaenc2[4*j + i] = 5;

+               alphadist = srccolors[j][i] - (alphabase[0] * 1 + alphabase[1] * 4) / 5;

+            }

+            else {

+               alphaenc2[4*j + i] = 1;

+               alphadist = srccolors[j][i] - alphabase[1];

+            }

+            alphablockerror2 += alphadist * alphadist;

+         }

+      }

+

+

+      /* skip this if the error is already very small

+         this encoding is MUCH better on average than #2 though, but expensive! */

+      if ((alphablockerror2 > 96) && (alphablockerror1 > 96)) {

+         short blockerrlin1 = 0;

+         short blockerrlin2 = 0;

+         TYPE nralphainrangelow = 0;

+         TYPE nralphainrangehigh = 0;

+         alphatest[0] = T_MAX;

+         alphatest[1] = T_MIN;

+         /* if we have large range it's likely there are values close to 0/255, try to map them to 0/255 */

+         for (j = 0; j < numypixels; j++) {

+            for (i = 0; i < numxpixels; i++) {

+               if ((srccolors[j][i] > alphatest[1]) && (srccolors[j][i] < (T_MAX -(alphabase[1] - alphabase[0]) / 28)))

+                  alphatest[1] = srccolors[j][i];

+               if ((srccolors[j][i] < alphatest[0]) && (srccolors[j][i] > (alphabase[1] - alphabase[0]) / 28))

+                  alphatest[0] = srccolors[j][i];

+            }

+         }

+          /* shouldn't happen too often, don't really care about those degenerated cases */

+          if (alphatest[1] <= alphatest[0]) {

+             alphatest[0] = T_MIN+1;

+             alphatest[1] = T_MAX-1;

+         }

+         for (aindex = 0; aindex < 5; aindex++) {

+         /* don't forget here is always rounded down */

+            acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;

+         }

+

+         /* find the "average" difference between the alpha values and the next encoded value.

+            This is then used to calculate new base values.

+            Should there be some weighting, i.e. those values closer to alphatest[x] have more weight,

+            since they will see more improvement, and also because the values in the middle are somewhat

+            likely to get no improvement at all (because the base values might move in different directions)?

+            OTOH it would mean the values in the middle are even less likely to get an improvement

+         */

+         for (j = 0; j < numypixels; j++) {

+            for (i = 0; i < numxpixels; i++) {

+               if (srccolors[j][i] <= alphatest[0] / 2) {

+               }

+               else if (srccolors[j][i] > ((T_MAX + alphatest[1]) / 2)) {

+               }

+               else if (srccolors[j][i] <= acutValues[0]) {

+                  blockerrlin1 += (srccolors[j][i] - alphatest[0]);

+                  nralphainrangelow += 1;

+               }

+               else if (srccolors[j][i] <= acutValues[1]) {

+                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);

+                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);

+                  nralphainrangelow += 1;

+                  nralphainrangehigh += 1;

+               }

+               else if (srccolors[j][i] <= acutValues[2]) {

+                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);

+                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);

+                  nralphainrangelow += 1;

+                  nralphainrangehigh += 1;

+               }

+               else if (srccolors[j][i] <= acutValues[3]) {

+                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);

+                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);

+                  nralphainrangelow += 1;

+                  nralphainrangehigh += 1;

+               }

+               else if (srccolors[j][i] <= acutValues[4]) {

+                  blockerrlin1 += (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);

+                  blockerrlin2 += (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);

+                  nralphainrangelow += 1;

+                  nralphainrangehigh += 1;

+                  }

+               else {

+                  blockerrlin2 += (srccolors[j][i] - alphatest[1]);

+                  nralphainrangehigh += 1;

+               }

+            }

+         }

+         /* shouldn't happen often, needed to avoid div by zero */

+         if (nralphainrangelow == 0) nralphainrangelow = 1;

+         if (nralphainrangehigh == 0) nralphainrangehigh = 1;

+         alphatest[0] = alphatest[0] + (blockerrlin1 / nralphainrangelow);

+#if RGTC_DEBUG

+         fprintf(stderr, "block err lin low %d, nr %d\n", blockerrlin1, nralphainrangelow);

+         fprintf(stderr, "block err lin high %d, nr %d\n", blockerrlin2, nralphainrangehigh);

+#endif

+         /* again shouldn't really happen often... */

+         if (alphatest[0] < T_MIN) {

+            alphatest[0] = T_MIN;

+         }

+         alphatest[1] = alphatest[1] + (blockerrlin2 / nralphainrangehigh);

+         if (alphatest[1] > T_MAX) {

+            alphatest[1] = T_MAX;

+         }

+

+         alphablockerror3 = 0;

+         for (aindex = 0; aindex < 5; aindex++) {

+         /* don't forget here is always rounded down */

+            acutValues[aindex] = (alphatest[0] * (10 - (2*aindex + 1)) + alphatest[1] * (2*aindex + 1)) / 10;

+         }

+         for (j = 0; j < numypixels; j++) {

+            for (i = 0; i < numxpixels; i++) {

+                /* maybe it's overkill to have the most complicated calculation just for the error

+                  calculation which we only need to figure out if encoding1 or encoding2 is better... */

+               if (srccolors[j][i] <= alphatest[0] / 2) {

+                  alphaenc3[4*j + i] = 6;

+                  alphadist = srccolors[j][i];

+               }

+               else if (srccolors[j][i] > ((T_MAX + alphatest[1]) / 2)) {

+                  alphaenc3[4*j + i] = 7;

+                  alphadist = T_MAX - srccolors[j][i];

+               }

+               else if (srccolors[j][i] <= acutValues[0]) {

+                  alphaenc3[4*j + i] = 0;

+                  alphadist = srccolors[j][i] - alphatest[0];

+               }

+               else if (srccolors[j][i] <= acutValues[1]) {

+                 alphaenc3[4*j + i] = 2;

+                 alphadist = srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5;

+               }

+               else if (srccolors[j][i] <= acutValues[2]) {

+                  alphaenc3[4*j + i] = 3;

+                  alphadist = srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5;

+               }

+               else if (srccolors[j][i] <= acutValues[3]) {

+                  alphaenc3[4*j + i] = 4;

+                  alphadist = srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5;

+               }

+               else if (srccolors[j][i] <= acutValues[4]) {

+                  alphaenc3[4*j + i] = 5;

+                  alphadist = srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5;

+               }

+               else {

+                  alphaenc3[4*j + i] = 1;

+                  alphadist = srccolors[j][i] - alphatest[1];

+               }

+               alphablockerror3 += alphadist * alphadist;

+            }

+         }

+      }

+   }

+

+  /* write the alpha values and encoding back. */

+   if ((alphablockerror1 <= alphablockerror2) && (alphablockerror1 <= alphablockerror3)) {

+#if RGTC_DEBUG

+      if (alphablockerror1 > 96) fprintf(stderr, "enc1 used, error %d\n", alphablockerror1);

+      fprintf(stderr,"w1: min %d max %d au0 %d au1 %d\n",

+	      T_MIN, T_MAX,

+	      alphause[1], alphause[0]);

+#endif

+

+      TAG(write_rgtc_encoded_channel)( blkaddr, alphause[1], alphause[0], alphaenc1 );

+   }

+   else if (alphablockerror2 <= alphablockerror3) {

+#if RGTC_DEBUG

+      if (alphablockerror2 > 96) fprintf(stderr, "enc2 used, error %d\n", alphablockerror2);

+      fprintf(stderr,"w2: min %d max %d au0 %d au1 %d\n",

+	      T_MIN, T_MAX,

+	      alphabase[0], alphabase[1]);

+#endif

+

+      TAG(write_rgtc_encoded_channel)( blkaddr, alphabase[0], alphabase[1], alphaenc2 );

+   }

+   else {

+#if RGTC_DEBUG

+      fprintf(stderr, "enc3 used, error %d\n", alphablockerror3);

+      fprintf(stderr,"w3: min %d max %d au0 %d au1 %d\n",

+	      T_MIN, T_MAX,

+	      alphatest[0], alphatest[1]);

+#endif

+

+      TAG(write_rgtc_encoded_channel)( blkaddr, (TYPE)alphatest[0], (TYPE)alphatest[1], alphaenc3 );

+   }

+}

diff --git a/mesalib/src/mesa/main/texcompress_s3tc.c b/mesalib/src/mesa/main/texcompress_s3tc.c
index 90be6c0a8..479806eca 100644
--- a/mesalib/src/mesa/main/texcompress_s3tc.c
+++ b/mesalib/src/mesa/main/texcompress_s3tc.c
@@ -50,7 +50,11 @@
 

 

 #if defined(_WIN32) || defined(WIN32)

+#ifdef _DEBUG

+#define DXTN_LIBNAME "dxtn_dbg.dll"

+#else

 #define DXTN_LIBNAME "dxtn.dll"

+#endif

 #define RTLD_LAZY 0

 #define RTLD_GLOBAL 0

 #elif defined(__DJGPP__)

diff --git a/mesalib/src/mesa/main/texfetch.c b/mesalib/src/mesa/main/texfetch.c
index 988a7e054..33f8dbba2 100644
--- a/mesalib/src/mesa/main/texfetch.c
+++ b/mesalib/src/mesa/main/texfetch.c
@@ -1,950 +1,950 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2009  VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file texfetch.c
- *
- * Texel fetch/store functions
- *
- * \author Gareth Hughes
- */
-
-
-#include "colormac.h"
-#include "macros.h"
-#include "texcompress.h"
-#include "texcompress_fxt1.h"
-#include "texcompress_s3tc.h"
-#include "texcompress_rgtc.h"
-#include "texfetch.h"
-#include "teximage.h"
-
-
-/**
- * Convert an 8-bit sRGB value from non-linear space to a
- * linear RGB value in [0, 1].
- * Implemented with a 256-entry lookup table.
- */
-static INLINE GLfloat
-nonlinear_to_linear(GLubyte cs8)
-{
-   static GLfloat table[256];
-   static GLboolean tableReady = GL_FALSE;
-   if (!tableReady) {
-      /* compute lookup table now */
-      GLuint i;
-      for (i = 0; i < 256; i++) {
-         const GLfloat cs = UBYTE_TO_FLOAT(i);
-         if (cs <= 0.04045) {
-            table[i] = cs / 12.92f;
-         }
-         else {
-            table[i] = (GLfloat) pow((cs + 0.055) / 1.055, 2.4);
-         }
-      }
-      tableReady = GL_TRUE;
-   }
-   return table[cs8];
-}
-
-
-
-/* Texel fetch routines for all supported formats
- */
-#define DIM 1
-#include "texfetch_tmp.h"
-
-#define DIM 2
-#include "texfetch_tmp.h"
-
-#define DIM 3
-#include "texfetch_tmp.h"
-
-/**
- * Null texel fetch function.
- *
- * Have to have this so the FetchTexel function pointer is never NULL.
- */
-static void fetch_null_texelf( const struct gl_texture_image *texImage,
-                               GLint i, GLint j, GLint k, GLfloat *texel )
-{
-   (void) texImage; (void) i; (void) j; (void) k;
-   texel[RCOMP] = 0.0;
-   texel[GCOMP] = 0.0;
-   texel[BCOMP] = 0.0;
-   texel[ACOMP] = 0.0;
-   _mesa_warning(NULL, "fetch_null_texelf() called!");
-}
-
-static void store_null_texel(struct gl_texture_image *texImage,
-                             GLint i, GLint j, GLint k, const void *texel)
-{
-   (void) texImage;
-   (void) i;
-   (void) j;
-   (void) k;
-   (void) texel;
-   /* no-op */
-}
-
-
-
-/**
- * Table to map MESA_FORMAT_ to texel fetch/store funcs.
- * XXX this is somewhat temporary.
- */
-static struct {
-   gl_format Name;
-   FetchTexelFuncF Fetch1D;
-   FetchTexelFuncF Fetch2D;
-   FetchTexelFuncF Fetch3D;
-   StoreTexelFunc StoreTexel;
-}
-texfetch_funcs[MESA_FORMAT_COUNT] =
-{
-   {
-      MESA_FORMAT_NONE,
-      fetch_null_texelf,
-      fetch_null_texelf,
-      fetch_null_texelf,
-      store_null_texel
-   },
-
-   {
-      MESA_FORMAT_RGBA8888,
-      fetch_texel_1d_f_rgba8888,
-      fetch_texel_2d_f_rgba8888,
-      fetch_texel_3d_f_rgba8888,
-      store_texel_rgba8888
-   },
-   {
-      MESA_FORMAT_RGBA8888_REV,
-      fetch_texel_1d_f_rgba8888_rev,
-      fetch_texel_2d_f_rgba8888_rev,
-      fetch_texel_3d_f_rgba8888_rev,
-      store_texel_rgba8888_rev
-   },
-   {
-      MESA_FORMAT_ARGB8888,
-      fetch_texel_1d_f_argb8888,
-      fetch_texel_2d_f_argb8888,
-      fetch_texel_3d_f_argb8888,
-      store_texel_argb8888
-   },
-   {
-      MESA_FORMAT_ARGB8888_REV,
-      fetch_texel_1d_f_argb8888_rev,
-      fetch_texel_2d_f_argb8888_rev,
-      fetch_texel_3d_f_argb8888_rev,
-      store_texel_argb8888_rev
-   },
-   {
-      MESA_FORMAT_XRGB8888,
-      fetch_texel_1d_f_xrgb8888,
-      fetch_texel_2d_f_xrgb8888,
-      fetch_texel_3d_f_xrgb8888,
-      store_texel_xrgb8888
-   },
-   {
-      MESA_FORMAT_XRGB8888_REV,
-      fetch_texel_1d_f_xrgb8888_rev,
-      fetch_texel_2d_f_xrgb8888_rev,
-      fetch_texel_3d_f_xrgb8888_rev,
-      store_texel_xrgb8888_rev,
-   },
-   {
-      MESA_FORMAT_RGB888,
-      fetch_texel_1d_f_rgb888,
-      fetch_texel_2d_f_rgb888,
-      fetch_texel_3d_f_rgb888,
-      store_texel_rgb888
-   },
-   {
-      MESA_FORMAT_BGR888,
-      fetch_texel_1d_f_bgr888,
-      fetch_texel_2d_f_bgr888,
-      fetch_texel_3d_f_bgr888,
-      store_texel_bgr888
-   },
-   {
-      MESA_FORMAT_RGB565,
-      fetch_texel_1d_f_rgb565,
-      fetch_texel_2d_f_rgb565,
-      fetch_texel_3d_f_rgb565,
-      store_texel_rgb565
-   },
-   {
-      MESA_FORMAT_RGB565_REV,
-      fetch_texel_1d_f_rgb565_rev,
-      fetch_texel_2d_f_rgb565_rev,
-      fetch_texel_3d_f_rgb565_rev,
-      store_texel_rgb565_rev
-   },
-   {
-      MESA_FORMAT_ARGB4444,
-      fetch_texel_1d_f_argb4444,
-      fetch_texel_2d_f_argb4444,
-      fetch_texel_3d_f_argb4444,
-      store_texel_argb4444
-   },
-   {
-      MESA_FORMAT_ARGB4444_REV,
-      fetch_texel_1d_f_argb4444_rev,
-      fetch_texel_2d_f_argb4444_rev,
-      fetch_texel_3d_f_argb4444_rev,
-      store_texel_argb4444_rev
-   },
-   {
-      MESA_FORMAT_RGBA5551,
-      fetch_texel_1d_f_rgba5551,
-      fetch_texel_2d_f_rgba5551,
-      fetch_texel_3d_f_rgba5551,
-      store_texel_rgba5551
-   },
-   {
-      MESA_FORMAT_ARGB1555,
-      fetch_texel_1d_f_argb1555,
-      fetch_texel_2d_f_argb1555,
-      fetch_texel_3d_f_argb1555,
-      store_texel_argb1555
-   },
-   {
-      MESA_FORMAT_ARGB1555_REV,
-      fetch_texel_1d_f_argb1555_rev,
-      fetch_texel_2d_f_argb1555_rev,
-      fetch_texel_3d_f_argb1555_rev,
-      store_texel_argb1555_rev
-   },
-   {
-      MESA_FORMAT_AL44,
-      fetch_texel_1d_f_al44,
-      fetch_texel_2d_f_al44,
-      fetch_texel_3d_f_al44,
-      store_texel_al44
-   },
-   {
-      MESA_FORMAT_AL88,
-      fetch_texel_1d_f_al88,
-      fetch_texel_2d_f_al88,
-      fetch_texel_3d_f_al88,
-      store_texel_al88
-   },
-   {
-      MESA_FORMAT_AL88_REV,
-      fetch_texel_1d_f_al88_rev,
-      fetch_texel_2d_f_al88_rev,
-      fetch_texel_3d_f_al88_rev,
-      store_texel_al88_rev
-   },
-   {
-      MESA_FORMAT_AL1616,
-      fetch_texel_1d_f_al1616,
-      fetch_texel_2d_f_al1616,
-      fetch_texel_3d_f_al1616,
-      store_texel_al1616
-   },
-   {
-      MESA_FORMAT_AL1616_REV,
-      fetch_texel_1d_f_al1616_rev,
-      fetch_texel_2d_f_al1616_rev,
-      fetch_texel_3d_f_al1616_rev,
-      store_texel_al1616_rev
-   },
-   {
-      MESA_FORMAT_RGB332,
-      fetch_texel_1d_f_rgb332,
-      fetch_texel_2d_f_rgb332,
-      fetch_texel_3d_f_rgb332,
-      store_texel_rgb332
-   },
-   {
-      MESA_FORMAT_A8,
-      fetch_texel_1d_f_a8,
-      fetch_texel_2d_f_a8,
-      fetch_texel_3d_f_a8,
-      store_texel_a8
-   },
-   {
-      MESA_FORMAT_A16,
-      fetch_texel_1d_f_a16,
-      fetch_texel_2d_f_a16,
-      fetch_texel_3d_f_a16,
-      store_texel_a16
-   },
-   {
-      MESA_FORMAT_L8,
-      fetch_texel_1d_f_l8,
-      fetch_texel_2d_f_l8,
-      fetch_texel_3d_f_l8,
-      store_texel_l8
-   },
-   {
-      MESA_FORMAT_L16,
-      fetch_texel_1d_f_l16,
-      fetch_texel_2d_f_l16,
-      fetch_texel_3d_f_l16,
-      store_texel_l16
-   },
-   {
-      MESA_FORMAT_I8,
-      fetch_texel_1d_f_i8,
-      fetch_texel_2d_f_i8,
-      fetch_texel_3d_f_i8,
-      store_texel_i8
-   },
-   {
-      MESA_FORMAT_I16,
-      fetch_texel_1d_f_i16,
-      fetch_texel_2d_f_i16,
-      fetch_texel_3d_f_i16,
-      store_texel_i16
-   },
-   {
-      MESA_FORMAT_CI8,
-      fetch_texel_1d_f_ci8,
-      fetch_texel_2d_f_ci8,
-      fetch_texel_3d_f_ci8,
-      store_texel_ci8
-   },
-   {
-      MESA_FORMAT_YCBCR,
-      fetch_texel_1d_f_ycbcr,
-      fetch_texel_2d_f_ycbcr,
-      fetch_texel_3d_f_ycbcr,
-      store_texel_ycbcr
-   },
-   {
-      MESA_FORMAT_YCBCR_REV,
-      fetch_texel_1d_f_ycbcr_rev,
-      fetch_texel_2d_f_ycbcr_rev,
-      fetch_texel_3d_f_ycbcr_rev,
-      store_texel_ycbcr_rev
-   },
-   {
-      MESA_FORMAT_R8,
-      fetch_texel_1d_f_r8,
-      fetch_texel_2d_f_r8,
-      fetch_texel_3d_f_r8,
-      store_texel_r8,
-   },
-   {
-      MESA_FORMAT_RG88,
-      fetch_texel_1d_f_rg88,
-      fetch_texel_2d_f_rg88,
-      fetch_texel_3d_f_rg88,
-      store_texel_rg88,
-   },
-   {
-      MESA_FORMAT_RG88_REV,
-      fetch_texel_1d_f_rg88_rev,
-      fetch_texel_2d_f_rg88_rev,
-      fetch_texel_3d_f_rg88_rev,
-      store_texel_rg88_rev,
-   },
-   {
-      MESA_FORMAT_R16,
-      fetch_texel_1d_f_r16,
-      fetch_texel_2d_f_r16,
-      fetch_texel_3d_f_r16,
-      store_texel_r16,
-   },
-   {
-      MESA_FORMAT_RG1616,
-      fetch_texel_1d_f_rg1616,
-      fetch_texel_2d_f_rg1616,
-      fetch_texel_3d_f_rg1616,
-      store_texel_rg1616,
-   },
-   {
-      MESA_FORMAT_RG1616_REV,
-      fetch_texel_1d_f_rg1616_rev,
-      fetch_texel_2d_f_rg1616_rev,
-      fetch_texel_3d_f_rg1616_rev,
-      store_texel_rg1616_rev,
-   },
-   {
-      MESA_FORMAT_ARGB2101010,
-      fetch_texel_1d_f_argb2101010,
-      fetch_texel_2d_f_argb2101010,
-      fetch_texel_3d_f_argb2101010,
-      store_texel_argb2101010
-   },
-   {
-      MESA_FORMAT_Z24_S8,
-      fetch_texel_1d_f_z24_s8,
-      fetch_texel_2d_f_z24_s8,
-      fetch_texel_3d_f_z24_s8,
-      store_texel_z24_s8
-   },
-   {
-      MESA_FORMAT_S8_Z24,
-      fetch_texel_1d_f_s8_z24,
-      fetch_texel_2d_f_s8_z24,
-      fetch_texel_3d_f_s8_z24,
-      store_texel_s8_z24
-   },
-   {
-      MESA_FORMAT_Z16,
-      fetch_texel_1d_f_z16,
-      fetch_texel_2d_f_z16,
-      fetch_texel_3d_f_z16,
-      store_texel_z16
-   },
-   {
-      MESA_FORMAT_X8_Z24,
-      fetch_texel_1d_f_s8_z24,
-      fetch_texel_2d_f_s8_z24,
-      fetch_texel_3d_f_s8_z24,
-      store_texel_s8_z24
-   },
-   {
-      MESA_FORMAT_Z24_X8,
-      fetch_texel_1d_f_z24_s8,
-      fetch_texel_2d_f_z24_s8,
-      fetch_texel_3d_f_z24_s8,
-      store_texel_z24_s8
-   },
-   {
-      MESA_FORMAT_Z32,
-      fetch_texel_1d_f_z32,
-      fetch_texel_2d_f_z32,
-      fetch_texel_3d_f_z32,
-      store_texel_z32
-   },
-   {
-      MESA_FORMAT_S8,
-      NULL,
-      NULL,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SRGB8,
-      fetch_texel_1d_srgb8,
-      fetch_texel_2d_srgb8,
-      fetch_texel_3d_srgb8,
-      store_texel_srgb8
-   },
-   {
-      MESA_FORMAT_SRGBA8,
-      fetch_texel_1d_srgba8,
-      fetch_texel_2d_srgba8,
-      fetch_texel_3d_srgba8,
-      store_texel_srgba8
-   },
-   {
-      MESA_FORMAT_SARGB8,
-      fetch_texel_1d_sargb8,
-      fetch_texel_2d_sargb8,
-      fetch_texel_3d_sargb8,
-      store_texel_sargb8
-   },
-   {
-      MESA_FORMAT_SL8,
-      fetch_texel_1d_sl8,
-      fetch_texel_2d_sl8,
-      fetch_texel_3d_sl8,
-      store_texel_sl8
-   },
-   {
-      MESA_FORMAT_SLA8,
-      fetch_texel_1d_sla8,
-      fetch_texel_2d_sla8,
-      fetch_texel_3d_sla8,
-      store_texel_sla8
-   },
-   {
-      MESA_FORMAT_SRGB_DXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_srgb_dxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_srgba_dxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT3,
-      NULL,
-      _mesa_fetch_texel_2d_f_srgba_dxt3,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SRGBA_DXT5,
-      NULL,
-      _mesa_fetch_texel_2d_f_srgba_dxt5,
-      NULL,
-      NULL
-   },
-
-   {
-      MESA_FORMAT_RGB_FXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgb_fxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGBA_FXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgba_fxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGB_DXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgb_dxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGBA_DXT1,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgba_dxt1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGBA_DXT3,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgba_dxt3,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGBA_DXT5,
-      NULL,
-      _mesa_fetch_texel_2d_f_rgba_dxt5,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RGBA_FLOAT32,
-      fetch_texel_1d_f_rgba_f32,
-      fetch_texel_2d_f_rgba_f32,
-      fetch_texel_3d_f_rgba_f32,
-      store_texel_rgba_f32
-   },
-   {
-      MESA_FORMAT_RGBA_FLOAT16,
-      fetch_texel_1d_f_rgba_f16,
-      fetch_texel_2d_f_rgba_f16,
-      fetch_texel_3d_f_rgba_f16,
-      store_texel_rgba_f16
-   },
-   {
-      MESA_FORMAT_RGB_FLOAT32,
-      fetch_texel_1d_f_rgb_f32,
-      fetch_texel_2d_f_rgb_f32,
-      fetch_texel_3d_f_rgb_f32,
-      store_texel_rgb_f32
-   },
-   {
-      MESA_FORMAT_RGB_FLOAT16,
-      fetch_texel_1d_f_rgb_f16,
-      fetch_texel_2d_f_rgb_f16,
-      fetch_texel_3d_f_rgb_f16,
-      store_texel_rgb_f16
-   },
-   {
-      MESA_FORMAT_ALPHA_FLOAT32,
-      fetch_texel_1d_f_alpha_f32,
-      fetch_texel_2d_f_alpha_f32,
-      fetch_texel_3d_f_alpha_f32,
-      store_texel_alpha_f32
-   },
-   {
-      MESA_FORMAT_ALPHA_FLOAT16,
-      fetch_texel_1d_f_alpha_f16,
-      fetch_texel_2d_f_alpha_f16,
-      fetch_texel_3d_f_alpha_f16,
-      store_texel_alpha_f16
-   },
-   {
-      MESA_FORMAT_LUMINANCE_FLOAT32,
-      fetch_texel_1d_f_luminance_f32,
-      fetch_texel_2d_f_luminance_f32,
-      fetch_texel_3d_f_luminance_f32,
-      store_texel_luminance_f32
-   },
-   {
-      MESA_FORMAT_LUMINANCE_FLOAT16,
-      fetch_texel_1d_f_luminance_f16,
-      fetch_texel_2d_f_luminance_f16,
-      fetch_texel_3d_f_luminance_f16,
-      store_texel_luminance_f16
-   },
-   {
-      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,
-      fetch_texel_1d_f_luminance_alpha_f32,
-      fetch_texel_2d_f_luminance_alpha_f32,
-      fetch_texel_3d_f_luminance_alpha_f32,
-      store_texel_luminance_alpha_f32
-   },
-   {
-      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,
-      fetch_texel_1d_f_luminance_alpha_f16,
-      fetch_texel_2d_f_luminance_alpha_f16,
-      fetch_texel_3d_f_luminance_alpha_f16,
-      store_texel_luminance_alpha_f16
-   },
-   {
-      MESA_FORMAT_INTENSITY_FLOAT32,
-      fetch_texel_1d_f_intensity_f32,
-      fetch_texel_2d_f_intensity_f32,
-      fetch_texel_3d_f_intensity_f32,
-      store_texel_intensity_f32
-   },
-   {
-      MESA_FORMAT_INTENSITY_FLOAT16,
-      fetch_texel_1d_f_intensity_f16,
-      fetch_texel_2d_f_intensity_f16,
-      fetch_texel_3d_f_intensity_f16,
-      store_texel_intensity_f16
-   },
-
-   /* non-normalized, signed int */
-   {
-      MESA_FORMAT_RGBA_INT8,
-      fetch_texel_1d_rgba_int8,
-      fetch_texel_2d_rgba_int8,
-      fetch_texel_3d_rgba_int8,
-      store_texel_rgba_int8
-   },
-   {
-      MESA_FORMAT_RGBA_INT16,
-      fetch_texel_1d_rgba_int16,
-      fetch_texel_2d_rgba_int16,
-      fetch_texel_3d_rgba_int16,
-      store_texel_rgba_int16
-   },
-   {
-      MESA_FORMAT_RGBA_INT32,
-      fetch_texel_1d_rgba_int32,
-      fetch_texel_2d_rgba_int32,
-      fetch_texel_3d_rgba_int32,
-      store_texel_rgba_int32
-   },
-
-   /* non-normalized, unsigned int */
-   {
-      MESA_FORMAT_RGBA_UINT8,
-      fetch_texel_1d_rgba_uint8,
-      fetch_texel_2d_rgba_uint8,
-      fetch_texel_3d_rgba_uint8,
-      store_texel_rgba_uint8
-   },
-   {
-      MESA_FORMAT_RGBA_UINT16,
-      fetch_texel_1d_rgba_uint16,
-      fetch_texel_2d_rgba_uint16,
-      fetch_texel_3d_rgba_uint16,
-      store_texel_rgba_uint16
-   },
-   {
-      MESA_FORMAT_RGBA_UINT32,
-      fetch_texel_1d_rgba_uint32,
-      fetch_texel_2d_rgba_uint32,
-      fetch_texel_3d_rgba_uint32,
-      store_texel_rgba_uint32
-   },
-
-   /* dudv */
-   {
-      MESA_FORMAT_DUDV8,
-      fetch_texel_1d_dudv8,
-      fetch_texel_2d_dudv8,
-      fetch_texel_3d_dudv8,
-      NULL
-   },
-
-   /* signed, normalized */
-   {
-      MESA_FORMAT_SIGNED_R8,
-      fetch_texel_1d_signed_r8,
-      fetch_texel_2d_signed_r8,
-      fetch_texel_3d_signed_r8,
-      store_texel_signed_r8
-   },
-   {
-      MESA_FORMAT_SIGNED_RG88,
-      fetch_texel_1d_signed_rg88,
-      fetch_texel_2d_signed_rg88,
-      fetch_texel_3d_signed_rg88,
-      store_texel_signed_rg88
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBX8888,
-      fetch_texel_1d_signed_rgbx8888,
-      fetch_texel_2d_signed_rgbx8888,
-      fetch_texel_3d_signed_rgbx8888,
-      store_texel_signed_rgbx8888
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA8888,
-      fetch_texel_1d_signed_rgba8888,
-      fetch_texel_2d_signed_rgba8888,
-      fetch_texel_3d_signed_rgba8888,
-      store_texel_signed_rgba8888
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA8888_REV,
-      fetch_texel_1d_signed_rgba8888_rev,
-      fetch_texel_2d_signed_rgba8888_rev,
-      fetch_texel_3d_signed_rgba8888_rev,
-      store_texel_signed_rgba8888_rev
-   },
-   {
-      MESA_FORMAT_SIGNED_R_16,
-      fetch_texel_1d_signed_r_16,
-      fetch_texel_2d_signed_r_16,
-      fetch_texel_3d_signed_r_16,
-      store_texel_signed_r_16
-   },
-   {
-      MESA_FORMAT_SIGNED_RG_16,
-      fetch_texel_1d_signed_rg_16,
-      fetch_texel_2d_signed_rg_16,
-      fetch_texel_3d_signed_rg_16,
-      store_texel_signed_rg_16
-   },
-   {
-      MESA_FORMAT_SIGNED_RGB_16,
-      fetch_texel_1d_signed_rgb_16,
-      fetch_texel_2d_signed_rgb_16,
-      fetch_texel_3d_signed_rgb_16,
-      store_texel_signed_rgb_16
-   },
-   {
-      MESA_FORMAT_SIGNED_RGBA_16,
-      fetch_texel_1d_signed_rgba_16,
-      fetch_texel_2d_signed_rgba_16,
-      fetch_texel_3d_signed_rgba_16,
-      store_texel_signed_rgba_16
-   },
-   {
-      MESA_FORMAT_RGBA_16,
-      fetch_texel_1d_rgba_16,
-      fetch_texel_2d_rgba_16,
-      fetch_texel_3d_rgba_16,
-      store_texel_rgba_16
-   },
-   {
-      MESA_FORMAT_RED_RGTC1,
-      NULL,
-      _mesa_fetch_texel_2d_f_red_rgtc1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SIGNED_RED_RGTC1,
-      NULL,
-      _mesa_fetch_texel_2d_f_signed_red_rgtc1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_RG_RGTC2,
-      NULL,
-      _mesa_fetch_texel_2d_f_rg_rgtc2,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SIGNED_RG_RGTC2,
-      NULL,
-      _mesa_fetch_texel_2d_f_signed_rg_rgtc2,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_L_LATC1,
-      NULL,
-      _mesa_fetch_texel_2d_f_l_latc1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SIGNED_L_LATC1,
-      NULL,
-      _mesa_fetch_texel_2d_f_signed_l_latc1,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_LA_LATC2,
-      NULL,
-      _mesa_fetch_texel_2d_f_la_latc2,
-      NULL,
-      NULL
-   },
-   {
-      MESA_FORMAT_SIGNED_LA_LATC2,
-      NULL,
-      _mesa_fetch_texel_2d_f_signed_la_latc2,
-      NULL,
-      NULL
-   },
-};
-
-
-FetchTexelFuncF
-_mesa_get_texel_fetch_func(gl_format format, GLuint dims)
-{
-#ifdef DEBUG
-   /* check that the table entries are sorted by format name */
-   gl_format fmt;
-   for (fmt = 0; fmt < MESA_FORMAT_COUNT; fmt++) {
-      assert(texfetch_funcs[fmt].Name == fmt);
-   }
-#endif
-
-   assert(Elements(texfetch_funcs) == MESA_FORMAT_COUNT);
-   assert(format < MESA_FORMAT_COUNT);
-
-   switch (dims) {
-   case 1:
-      return texfetch_funcs[format].Fetch1D;
-   case 2:
-      return texfetch_funcs[format].Fetch2D;
-   case 3:
-      return texfetch_funcs[format].Fetch3D;
-   default:
-      assert(0 && "bad dims in _mesa_get_texel_fetch_func");
-      return NULL;
-   }
-}
-
-
-StoreTexelFunc
-_mesa_get_texel_store_func(gl_format format)
-{
-   assert(format < MESA_FORMAT_COUNT);
-   return texfetch_funcs[format].StoreTexel;
-}
-
-
-/**
- * Adaptor for fetching a GLchan texel from a float-valued texture.
- */
-static void
-fetch_texel_float_to_chan(const struct gl_texture_image *texImage,
-                          GLint i, GLint j, GLint k, GLchan *texelOut)
-{
-   GLfloat temp[4];
-   GLenum baseFormat = _mesa_get_format_base_format(texImage->TexFormat);
-
-   ASSERT(texImage->FetchTexelf);
-   texImage->FetchTexelf(texImage, i, j, k, temp);
-   if (baseFormat == GL_DEPTH_COMPONENT ||
-       baseFormat == GL_DEPTH_STENCIL_EXT) {
-      /* just one channel */
-      UNCLAMPED_FLOAT_TO_CHAN(texelOut[0], temp[0]);
-   }
-   else {
-      /* four channels */
-      UNCLAMPED_FLOAT_TO_CHAN(texelOut[0], temp[0]);
-      UNCLAMPED_FLOAT_TO_CHAN(texelOut[1], temp[1]);
-      UNCLAMPED_FLOAT_TO_CHAN(texelOut[2], temp[2]);
-      UNCLAMPED_FLOAT_TO_CHAN(texelOut[3], temp[3]);
-   }
-}
-
-
-#if 0
-/**
- * Adaptor for fetching a float texel from a GLchan-valued texture.
- */
-static void
-fetch_texel_chan_to_float(const struct gl_texture_image *texImage,
-                          GLint i, GLint j, GLint k, GLfloat *texelOut)
-{
-   GLchan temp[4];
-   GLenum baseFormat = _mesa_get_format_base_format(texImage->TexFormat);
-
-   ASSERT(texImage->FetchTexelc);
-   texImage->FetchTexelc(texImage, i, j, k, temp);
-   if (baseFormat == GL_DEPTH_COMPONENT ||
-       baseFormat == GL_DEPTH_STENCIL_EXT) {
-      /* just one channel */
-      texelOut[0] = CHAN_TO_FLOAT(temp[0]);
-   }
-   else {
-      /* four channels */
-      texelOut[0] = CHAN_TO_FLOAT(temp[0]);
-      texelOut[1] = CHAN_TO_FLOAT(temp[1]);
-      texelOut[2] = CHAN_TO_FLOAT(temp[2]);
-      texelOut[3] = CHAN_TO_FLOAT(temp[3]);
-   }
-}
-#endif
-
-
-/**
- * Initialize the texture image's FetchTexelc and FetchTexelf methods.
- */
-void
-_mesa_set_fetch_functions(struct gl_texture_image *texImage, GLuint dims)
-{
-   gl_format format = texImage->TexFormat;
-
-   ASSERT(dims == 1 || dims == 2 || dims == 3);
-
-   if (texImage->TexObject->sRGBDecode == GL_SKIP_DECODE_EXT &&
-       _mesa_get_format_color_encoding(format) == GL_SRGB) {
-      format = _mesa_get_srgb_format_linear(format);
-   }
-
-   texImage->FetchTexelf = _mesa_get_texel_fetch_func(format, dims);
-
-   texImage->FetchTexelc = fetch_texel_float_to_chan;
-
-   ASSERT(texImage->FetchTexelc);
-   ASSERT(texImage->FetchTexelf);
-}
-
-void
-_mesa_update_fetch_functions(struct gl_texture_object *texObj)
-{
-   GLuint face, i;
-   GLuint dims;
-
-   dims = _mesa_get_texture_dimensions(texObj->Target);
-
-   for (face = 0; face < 6; face++) {
-      for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
-         if (texObj->Image[face][i]) {
-	    _mesa_set_fetch_functions(texObj->Image[face][i], dims);
-         }
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2009  VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file texfetch.c

+ *

+ * Texel fetch/store functions

+ *

+ * \author Gareth Hughes

+ */

+

+

+#include "colormac.h"

+#include "macros.h"

+#include "texcompress.h"

+#include "texcompress_fxt1.h"

+#include "texcompress_s3tc.h"

+#include "texcompress_rgtc.h"

+#include "texfetch.h"

+#include "teximage.h"

+

+

+/**

+ * Convert an 8-bit sRGB value from non-linear space to a

+ * linear RGB value in [0, 1].

+ * Implemented with a 256-entry lookup table.

+ */

+static INLINE GLfloat

+nonlinear_to_linear(GLubyte cs8)

+{

+   static GLfloat table[256];

+   static GLboolean tableReady = GL_FALSE;

+   if (!tableReady) {

+      /* compute lookup table now */

+      GLuint i;

+      for (i = 0; i < 256; i++) {

+         const GLfloat cs = UBYTE_TO_FLOAT(i);

+         if (cs <= 0.04045) {

+            table[i] = cs / 12.92f;

+         }

+         else {

+            table[i] = (GLfloat) pow((cs + 0.055) / 1.055, 2.4);

+         }

+      }

+      tableReady = GL_TRUE;

+   }

+   return table[cs8];

+}

+

+

+

+/* Texel fetch routines for all supported formats

+ */

+#define DIM 1

+#include "texfetch_tmp.h"

+

+#define DIM 2

+#include "texfetch_tmp.h"

+

+#define DIM 3

+#include "texfetch_tmp.h"

+

+/**

+ * Null texel fetch function.

+ *

+ * Have to have this so the FetchTexel function pointer is never NULL.

+ */

+static void fetch_null_texelf( const struct gl_texture_image *texImage,

+                               GLint i, GLint j, GLint k, GLfloat *texel )

+{

+   (void) texImage; (void) i; (void) j; (void) k;

+   texel[RCOMP] = 0.0;

+   texel[GCOMP] = 0.0;

+   texel[BCOMP] = 0.0;

+   texel[ACOMP] = 0.0;

+   _mesa_warning(NULL, "fetch_null_texelf() called!");

+}

+

+static void store_null_texel(struct gl_texture_image *texImage,

+                             GLint i, GLint j, GLint k, const void *texel)

+{

+   (void) texImage;

+   (void) i;

+   (void) j;

+   (void) k;

+   (void) texel;

+   /* no-op */

+}

+

+

+

+/**

+ * Table to map MESA_FORMAT_ to texel fetch/store funcs.

+ * XXX this is somewhat temporary.

+ */

+static struct {

+   gl_format Name;

+   FetchTexelFuncF Fetch1D;

+   FetchTexelFuncF Fetch2D;

+   FetchTexelFuncF Fetch3D;

+   StoreTexelFunc StoreTexel;

+}

+texfetch_funcs[MESA_FORMAT_COUNT] =

+{

+   {

+      MESA_FORMAT_NONE,

+      fetch_null_texelf,

+      fetch_null_texelf,

+      fetch_null_texelf,

+      store_null_texel

+   },

+

+   {

+      MESA_FORMAT_RGBA8888,

+      fetch_texel_1d_f_rgba8888,

+      fetch_texel_2d_f_rgba8888,

+      fetch_texel_3d_f_rgba8888,

+      store_texel_rgba8888

+   },

+   {

+      MESA_FORMAT_RGBA8888_REV,

+      fetch_texel_1d_f_rgba8888_rev,

+      fetch_texel_2d_f_rgba8888_rev,

+      fetch_texel_3d_f_rgba8888_rev,

+      store_texel_rgba8888_rev

+   },

+   {

+      MESA_FORMAT_ARGB8888,

+      fetch_texel_1d_f_argb8888,

+      fetch_texel_2d_f_argb8888,

+      fetch_texel_3d_f_argb8888,

+      store_texel_argb8888

+   },

+   {

+      MESA_FORMAT_ARGB8888_REV,

+      fetch_texel_1d_f_argb8888_rev,

+      fetch_texel_2d_f_argb8888_rev,

+      fetch_texel_3d_f_argb8888_rev,

+      store_texel_argb8888_rev

+   },

+   {

+      MESA_FORMAT_XRGB8888,

+      fetch_texel_1d_f_xrgb8888,

+      fetch_texel_2d_f_xrgb8888,

+      fetch_texel_3d_f_xrgb8888,

+      store_texel_xrgb8888

+   },

+   {

+      MESA_FORMAT_XRGB8888_REV,

+      fetch_texel_1d_f_xrgb8888_rev,

+      fetch_texel_2d_f_xrgb8888_rev,

+      fetch_texel_3d_f_xrgb8888_rev,

+      store_texel_xrgb8888_rev,

+   },

+   {

+      MESA_FORMAT_RGB888,

+      fetch_texel_1d_f_rgb888,

+      fetch_texel_2d_f_rgb888,

+      fetch_texel_3d_f_rgb888,

+      store_texel_rgb888

+   },

+   {

+      MESA_FORMAT_BGR888,

+      fetch_texel_1d_f_bgr888,

+      fetch_texel_2d_f_bgr888,

+      fetch_texel_3d_f_bgr888,

+      store_texel_bgr888

+   },

+   {

+      MESA_FORMAT_RGB565,

+      fetch_texel_1d_f_rgb565,

+      fetch_texel_2d_f_rgb565,

+      fetch_texel_3d_f_rgb565,

+      store_texel_rgb565

+   },

+   {

+      MESA_FORMAT_RGB565_REV,

+      fetch_texel_1d_f_rgb565_rev,

+      fetch_texel_2d_f_rgb565_rev,

+      fetch_texel_3d_f_rgb565_rev,

+      store_texel_rgb565_rev

+   },

+   {

+      MESA_FORMAT_ARGB4444,

+      fetch_texel_1d_f_argb4444,

+      fetch_texel_2d_f_argb4444,

+      fetch_texel_3d_f_argb4444,

+      store_texel_argb4444

+   },

+   {

+      MESA_FORMAT_ARGB4444_REV,

+      fetch_texel_1d_f_argb4444_rev,

+      fetch_texel_2d_f_argb4444_rev,

+      fetch_texel_3d_f_argb4444_rev,

+      store_texel_argb4444_rev

+   },

+   {

+      MESA_FORMAT_RGBA5551,

+      fetch_texel_1d_f_rgba5551,

+      fetch_texel_2d_f_rgba5551,

+      fetch_texel_3d_f_rgba5551,

+      store_texel_rgba5551

+   },

+   {

+      MESA_FORMAT_ARGB1555,

+      fetch_texel_1d_f_argb1555,

+      fetch_texel_2d_f_argb1555,

+      fetch_texel_3d_f_argb1555,

+      store_texel_argb1555

+   },

+   {

+      MESA_FORMAT_ARGB1555_REV,

+      fetch_texel_1d_f_argb1555_rev,

+      fetch_texel_2d_f_argb1555_rev,

+      fetch_texel_3d_f_argb1555_rev,

+      store_texel_argb1555_rev

+   },

+   {

+      MESA_FORMAT_AL44,

+      fetch_texel_1d_f_al44,

+      fetch_texel_2d_f_al44,

+      fetch_texel_3d_f_al44,

+      store_texel_al44

+   },

+   {

+      MESA_FORMAT_AL88,

+      fetch_texel_1d_f_al88,

+      fetch_texel_2d_f_al88,

+      fetch_texel_3d_f_al88,

+      store_texel_al88

+   },

+   {

+      MESA_FORMAT_AL88_REV,

+      fetch_texel_1d_f_al88_rev,

+      fetch_texel_2d_f_al88_rev,

+      fetch_texel_3d_f_al88_rev,

+      store_texel_al88_rev

+   },

+   {

+      MESA_FORMAT_AL1616,

+      fetch_texel_1d_f_al1616,

+      fetch_texel_2d_f_al1616,

+      fetch_texel_3d_f_al1616,

+      store_texel_al1616

+   },

+   {

+      MESA_FORMAT_AL1616_REV,

+      fetch_texel_1d_f_al1616_rev,

+      fetch_texel_2d_f_al1616_rev,

+      fetch_texel_3d_f_al1616_rev,

+      store_texel_al1616_rev

+   },

+   {

+      MESA_FORMAT_RGB332,

+      fetch_texel_1d_f_rgb332,

+      fetch_texel_2d_f_rgb332,

+      fetch_texel_3d_f_rgb332,

+      store_texel_rgb332

+   },

+   {

+      MESA_FORMAT_A8,

+      fetch_texel_1d_f_a8,

+      fetch_texel_2d_f_a8,

+      fetch_texel_3d_f_a8,

+      store_texel_a8

+   },

+   {

+      MESA_FORMAT_A16,

+      fetch_texel_1d_f_a16,

+      fetch_texel_2d_f_a16,

+      fetch_texel_3d_f_a16,

+      store_texel_a16

+   },

+   {

+      MESA_FORMAT_L8,

+      fetch_texel_1d_f_l8,

+      fetch_texel_2d_f_l8,

+      fetch_texel_3d_f_l8,

+      store_texel_l8

+   },

+   {

+      MESA_FORMAT_L16,

+      fetch_texel_1d_f_l16,

+      fetch_texel_2d_f_l16,

+      fetch_texel_3d_f_l16,

+      store_texel_l16

+   },

+   {

+      MESA_FORMAT_I8,

+      fetch_texel_1d_f_i8,

+      fetch_texel_2d_f_i8,

+      fetch_texel_3d_f_i8,

+      store_texel_i8

+   },

+   {

+      MESA_FORMAT_I16,

+      fetch_texel_1d_f_i16,

+      fetch_texel_2d_f_i16,

+      fetch_texel_3d_f_i16,

+      store_texel_i16

+   },

+   {

+      MESA_FORMAT_CI8,

+      fetch_texel_1d_f_ci8,

+      fetch_texel_2d_f_ci8,

+      fetch_texel_3d_f_ci8,

+      store_texel_ci8

+   },

+   {

+      MESA_FORMAT_YCBCR,

+      fetch_texel_1d_f_ycbcr,

+      fetch_texel_2d_f_ycbcr,

+      fetch_texel_3d_f_ycbcr,

+      store_texel_ycbcr

+   },

+   {

+      MESA_FORMAT_YCBCR_REV,

+      fetch_texel_1d_f_ycbcr_rev,

+      fetch_texel_2d_f_ycbcr_rev,

+      fetch_texel_3d_f_ycbcr_rev,

+      store_texel_ycbcr_rev

+   },

+   {

+      MESA_FORMAT_R8,

+      fetch_texel_1d_f_r8,

+      fetch_texel_2d_f_r8,

+      fetch_texel_3d_f_r8,

+      store_texel_r8,

+   },

+   {

+      MESA_FORMAT_RG88,

+      fetch_texel_1d_f_rg88,

+      fetch_texel_2d_f_rg88,

+      fetch_texel_3d_f_rg88,

+      store_texel_rg88,

+   },

+   {

+      MESA_FORMAT_RG88_REV,

+      fetch_texel_1d_f_rg88_rev,

+      fetch_texel_2d_f_rg88_rev,

+      fetch_texel_3d_f_rg88_rev,

+      store_texel_rg88_rev,

+   },

+   {

+      MESA_FORMAT_R16,

+      fetch_texel_1d_f_r16,

+      fetch_texel_2d_f_r16,

+      fetch_texel_3d_f_r16,

+      store_texel_r16,

+   },

+   {

+      MESA_FORMAT_RG1616,

+      fetch_texel_1d_f_rg1616,

+      fetch_texel_2d_f_rg1616,

+      fetch_texel_3d_f_rg1616,

+      store_texel_rg1616,

+   },

+   {

+      MESA_FORMAT_RG1616_REV,

+      fetch_texel_1d_f_rg1616_rev,

+      fetch_texel_2d_f_rg1616_rev,

+      fetch_texel_3d_f_rg1616_rev,

+      store_texel_rg1616_rev,

+   },

+   {

+      MESA_FORMAT_ARGB2101010,

+      fetch_texel_1d_f_argb2101010,

+      fetch_texel_2d_f_argb2101010,

+      fetch_texel_3d_f_argb2101010,

+      store_texel_argb2101010

+   },

+   {

+      MESA_FORMAT_Z24_S8,

+      fetch_texel_1d_f_z24_s8,

+      fetch_texel_2d_f_z24_s8,

+      fetch_texel_3d_f_z24_s8,

+      store_texel_z24_s8

+   },

+   {

+      MESA_FORMAT_S8_Z24,

+      fetch_texel_1d_f_s8_z24,

+      fetch_texel_2d_f_s8_z24,

+      fetch_texel_3d_f_s8_z24,

+      store_texel_s8_z24

+   },

+   {

+      MESA_FORMAT_Z16,

+      fetch_texel_1d_f_z16,

+      fetch_texel_2d_f_z16,

+      fetch_texel_3d_f_z16,

+      store_texel_z16

+   },

+   {

+      MESA_FORMAT_X8_Z24,

+      fetch_texel_1d_f_s8_z24,

+      fetch_texel_2d_f_s8_z24,

+      fetch_texel_3d_f_s8_z24,

+      store_texel_s8_z24

+   },

+   {

+      MESA_FORMAT_Z24_X8,

+      fetch_texel_1d_f_z24_s8,

+      fetch_texel_2d_f_z24_s8,

+      fetch_texel_3d_f_z24_s8,

+      store_texel_z24_s8

+   },

+   {

+      MESA_FORMAT_Z32,

+      fetch_texel_1d_f_z32,

+      fetch_texel_2d_f_z32,

+      fetch_texel_3d_f_z32,

+      store_texel_z32

+   },

+   {

+      MESA_FORMAT_S8,

+      NULL,

+      NULL,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SRGB8,

+      fetch_texel_1d_srgb8,

+      fetch_texel_2d_srgb8,

+      fetch_texel_3d_srgb8,

+      store_texel_srgb8

+   },

+   {

+      MESA_FORMAT_SRGBA8,

+      fetch_texel_1d_srgba8,

+      fetch_texel_2d_srgba8,

+      fetch_texel_3d_srgba8,

+      store_texel_srgba8

+   },

+   {

+      MESA_FORMAT_SARGB8,

+      fetch_texel_1d_sargb8,

+      fetch_texel_2d_sargb8,

+      fetch_texel_3d_sargb8,

+      store_texel_sargb8

+   },

+   {

+      MESA_FORMAT_SL8,

+      fetch_texel_1d_sl8,

+      fetch_texel_2d_sl8,

+      fetch_texel_3d_sl8,

+      store_texel_sl8

+   },

+   {

+      MESA_FORMAT_SLA8,

+      fetch_texel_1d_sla8,

+      fetch_texel_2d_sla8,

+      fetch_texel_3d_sla8,

+      store_texel_sla8

+   },

+   {

+      MESA_FORMAT_SRGB_DXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_srgb_dxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_srgba_dxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT3,

+      NULL,

+      _mesa_fetch_texel_2d_f_srgba_dxt3,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SRGBA_DXT5,

+      NULL,

+      _mesa_fetch_texel_2d_f_srgba_dxt5,

+      NULL,

+      NULL

+   },

+

+   {

+      MESA_FORMAT_RGB_FXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgb_fxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGBA_FXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgba_fxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGB_DXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgb_dxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGBA_DXT1,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgba_dxt1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGBA_DXT3,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgba_dxt3,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGBA_DXT5,

+      NULL,

+      _mesa_fetch_texel_2d_f_rgba_dxt5,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RGBA_FLOAT32,

+      fetch_texel_1d_f_rgba_f32,

+      fetch_texel_2d_f_rgba_f32,

+      fetch_texel_3d_f_rgba_f32,

+      store_texel_rgba_f32

+   },

+   {

+      MESA_FORMAT_RGBA_FLOAT16,

+      fetch_texel_1d_f_rgba_f16,

+      fetch_texel_2d_f_rgba_f16,

+      fetch_texel_3d_f_rgba_f16,

+      store_texel_rgba_f16

+   },

+   {

+      MESA_FORMAT_RGB_FLOAT32,

+      fetch_texel_1d_f_rgb_f32,

+      fetch_texel_2d_f_rgb_f32,

+      fetch_texel_3d_f_rgb_f32,

+      store_texel_rgb_f32

+   },

+   {

+      MESA_FORMAT_RGB_FLOAT16,

+      fetch_texel_1d_f_rgb_f16,

+      fetch_texel_2d_f_rgb_f16,

+      fetch_texel_3d_f_rgb_f16,

+      store_texel_rgb_f16

+   },

+   {

+      MESA_FORMAT_ALPHA_FLOAT32,

+      fetch_texel_1d_f_alpha_f32,

+      fetch_texel_2d_f_alpha_f32,

+      fetch_texel_3d_f_alpha_f32,

+      store_texel_alpha_f32

+   },

+   {

+      MESA_FORMAT_ALPHA_FLOAT16,

+      fetch_texel_1d_f_alpha_f16,

+      fetch_texel_2d_f_alpha_f16,

+      fetch_texel_3d_f_alpha_f16,

+      store_texel_alpha_f16

+   },

+   {

+      MESA_FORMAT_LUMINANCE_FLOAT32,

+      fetch_texel_1d_f_luminance_f32,

+      fetch_texel_2d_f_luminance_f32,

+      fetch_texel_3d_f_luminance_f32,

+      store_texel_luminance_f32

+   },

+   {

+      MESA_FORMAT_LUMINANCE_FLOAT16,

+      fetch_texel_1d_f_luminance_f16,

+      fetch_texel_2d_f_luminance_f16,

+      fetch_texel_3d_f_luminance_f16,

+      store_texel_luminance_f16

+   },

+   {

+      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,

+      fetch_texel_1d_f_luminance_alpha_f32,

+      fetch_texel_2d_f_luminance_alpha_f32,

+      fetch_texel_3d_f_luminance_alpha_f32,

+      store_texel_luminance_alpha_f32

+   },

+   {

+      MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,

+      fetch_texel_1d_f_luminance_alpha_f16,

+      fetch_texel_2d_f_luminance_alpha_f16,

+      fetch_texel_3d_f_luminance_alpha_f16,

+      store_texel_luminance_alpha_f16

+   },

+   {

+      MESA_FORMAT_INTENSITY_FLOAT32,

+      fetch_texel_1d_f_intensity_f32,

+      fetch_texel_2d_f_intensity_f32,

+      fetch_texel_3d_f_intensity_f32,

+      store_texel_intensity_f32

+   },

+   {

+      MESA_FORMAT_INTENSITY_FLOAT16,

+      fetch_texel_1d_f_intensity_f16,

+      fetch_texel_2d_f_intensity_f16,

+      fetch_texel_3d_f_intensity_f16,

+      store_texel_intensity_f16

+   },

+

+   /* non-normalized, signed int */

+   {

+      MESA_FORMAT_RGBA_INT8,

+      fetch_texel_1d_rgba_int8,

+      fetch_texel_2d_rgba_int8,

+      fetch_texel_3d_rgba_int8,

+      store_texel_rgba_int8

+   },

+   {

+      MESA_FORMAT_RGBA_INT16,

+      fetch_texel_1d_rgba_int16,

+      fetch_texel_2d_rgba_int16,

+      fetch_texel_3d_rgba_int16,

+      store_texel_rgba_int16

+   },

+   {

+      MESA_FORMAT_RGBA_INT32,

+      fetch_texel_1d_rgba_int32,

+      fetch_texel_2d_rgba_int32,

+      fetch_texel_3d_rgba_int32,

+      store_texel_rgba_int32

+   },

+

+   /* non-normalized, unsigned int */

+   {

+      MESA_FORMAT_RGBA_UINT8,

+      fetch_texel_1d_rgba_uint8,

+      fetch_texel_2d_rgba_uint8,

+      fetch_texel_3d_rgba_uint8,

+      store_texel_rgba_uint8

+   },

+   {

+      MESA_FORMAT_RGBA_UINT16,

+      fetch_texel_1d_rgba_uint16,

+      fetch_texel_2d_rgba_uint16,

+      fetch_texel_3d_rgba_uint16,

+      store_texel_rgba_uint16

+   },

+   {

+      MESA_FORMAT_RGBA_UINT32,

+      fetch_texel_1d_rgba_uint32,

+      fetch_texel_2d_rgba_uint32,

+      fetch_texel_3d_rgba_uint32,

+      store_texel_rgba_uint32

+   },

+

+   /* dudv */

+   {

+      MESA_FORMAT_DUDV8,

+      fetch_texel_1d_dudv8,

+      fetch_texel_2d_dudv8,

+      fetch_texel_3d_dudv8,

+      NULL

+   },

+

+   /* signed, normalized */

+   {

+      MESA_FORMAT_SIGNED_R8,

+      fetch_texel_1d_signed_r8,

+      fetch_texel_2d_signed_r8,

+      fetch_texel_3d_signed_r8,

+      store_texel_signed_r8

+   },

+   {

+      MESA_FORMAT_SIGNED_RG88,

+      fetch_texel_1d_signed_rg88,

+      fetch_texel_2d_signed_rg88,

+      fetch_texel_3d_signed_rg88,

+      store_texel_signed_rg88

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBX8888,

+      fetch_texel_1d_signed_rgbx8888,

+      fetch_texel_2d_signed_rgbx8888,

+      fetch_texel_3d_signed_rgbx8888,

+      store_texel_signed_rgbx8888

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA8888,

+      fetch_texel_1d_signed_rgba8888,

+      fetch_texel_2d_signed_rgba8888,

+      fetch_texel_3d_signed_rgba8888,

+      store_texel_signed_rgba8888

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA8888_REV,

+      fetch_texel_1d_signed_rgba8888_rev,

+      fetch_texel_2d_signed_rgba8888_rev,

+      fetch_texel_3d_signed_rgba8888_rev,

+      store_texel_signed_rgba8888_rev

+   },

+   {

+      MESA_FORMAT_SIGNED_R_16,

+      fetch_texel_1d_signed_r_16,

+      fetch_texel_2d_signed_r_16,

+      fetch_texel_3d_signed_r_16,

+      store_texel_signed_r_16

+   },

+   {

+      MESA_FORMAT_SIGNED_RG_16,

+      fetch_texel_1d_signed_rg_16,

+      fetch_texel_2d_signed_rg_16,

+      fetch_texel_3d_signed_rg_16,

+      store_texel_signed_rg_16

+   },

+   {

+      MESA_FORMAT_SIGNED_RGB_16,

+      fetch_texel_1d_signed_rgb_16,

+      fetch_texel_2d_signed_rgb_16,

+      fetch_texel_3d_signed_rgb_16,

+      store_texel_signed_rgb_16

+   },

+   {

+      MESA_FORMAT_SIGNED_RGBA_16,

+      fetch_texel_1d_signed_rgba_16,

+      fetch_texel_2d_signed_rgba_16,

+      fetch_texel_3d_signed_rgba_16,

+      store_texel_signed_rgba_16

+   },

+   {

+      MESA_FORMAT_RGBA_16,

+      fetch_texel_1d_rgba_16,

+      fetch_texel_2d_rgba_16,

+      fetch_texel_3d_rgba_16,

+      store_texel_rgba_16

+   },

+   {

+      MESA_FORMAT_RED_RGTC1,

+      NULL,

+      _mesa_fetch_texel_2d_f_red_rgtc1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SIGNED_RED_RGTC1,

+      NULL,

+      _mesa_fetch_texel_2d_f_signed_red_rgtc1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_RG_RGTC2,

+      NULL,

+      _mesa_fetch_texel_2d_f_rg_rgtc2,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SIGNED_RG_RGTC2,

+      NULL,

+      _mesa_fetch_texel_2d_f_signed_rg_rgtc2,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_L_LATC1,

+      NULL,

+      _mesa_fetch_texel_2d_f_l_latc1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SIGNED_L_LATC1,

+      NULL,

+      _mesa_fetch_texel_2d_f_signed_l_latc1,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_LA_LATC2,

+      NULL,

+      _mesa_fetch_texel_2d_f_la_latc2,

+      NULL,

+      NULL

+   },

+   {

+      MESA_FORMAT_SIGNED_LA_LATC2,

+      NULL,

+      _mesa_fetch_texel_2d_f_signed_la_latc2,

+      NULL,

+      NULL

+   },

+};

+

+

+FetchTexelFuncF

+_mesa_get_texel_fetch_func(gl_format format, GLuint dims)

+{

+#ifdef DEBUG

+   /* check that the table entries are sorted by format name */

+   gl_format fmt;

+   for (fmt = 0; fmt < MESA_FORMAT_COUNT; fmt++) {

+      assert(texfetch_funcs[fmt].Name == fmt);

+   }

+#endif

+

+   assert(Elements(texfetch_funcs) == MESA_FORMAT_COUNT);

+   assert(format < MESA_FORMAT_COUNT);

+

+   switch (dims) {

+   case 1:

+      return texfetch_funcs[format].Fetch1D;

+   case 2:

+      return texfetch_funcs[format].Fetch2D;

+   case 3:

+      return texfetch_funcs[format].Fetch3D;

+   default:

+      assert(0 && "bad dims in _mesa_get_texel_fetch_func");

+      return NULL;

+   }

+}

+

+

+StoreTexelFunc

+_mesa_get_texel_store_func(gl_format format)

+{

+   assert(format < MESA_FORMAT_COUNT);

+   return texfetch_funcs[format].StoreTexel;

+}

+

+

+/**

+ * Adaptor for fetching a GLchan texel from a float-valued texture.

+ */

+static void

+fetch_texel_float_to_chan(const struct gl_texture_image *texImage,

+                          GLint i, GLint j, GLint k, GLchan *texelOut)

+{

+   GLfloat temp[4];

+   GLenum baseFormat = _mesa_get_format_base_format(texImage->TexFormat);

+

+   ASSERT(texImage->FetchTexelf);

+   texImage->FetchTexelf(texImage, i, j, k, temp);

+   if (baseFormat == GL_DEPTH_COMPONENT ||

+       baseFormat == GL_DEPTH_STENCIL_EXT) {

+      /* just one channel */

+      UNCLAMPED_FLOAT_TO_CHAN(texelOut[0], temp[0]);

+   }

+   else {

+      /* four channels */

+      UNCLAMPED_FLOAT_TO_CHAN(texelOut[0], temp[0]);

+      UNCLAMPED_FLOAT_TO_CHAN(texelOut[1], temp[1]);

+      UNCLAMPED_FLOAT_TO_CHAN(texelOut[2], temp[2]);

+      UNCLAMPED_FLOAT_TO_CHAN(texelOut[3], temp[3]);

+   }

+}

+

+

+#if 0

+/**

+ * Adaptor for fetching a float texel from a GLchan-valued texture.

+ */

+static void

+fetch_texel_chan_to_float(const struct gl_texture_image *texImage,

+                          GLint i, GLint j, GLint k, GLfloat *texelOut)

+{

+   GLchan temp[4];

+   GLenum baseFormat = _mesa_get_format_base_format(texImage->TexFormat);

+

+   ASSERT(texImage->FetchTexelc);

+   texImage->FetchTexelc(texImage, i, j, k, temp);

+   if (baseFormat == GL_DEPTH_COMPONENT ||

+       baseFormat == GL_DEPTH_STENCIL_EXT) {

+      /* just one channel */

+      texelOut[0] = CHAN_TO_FLOAT(temp[0]);

+   }

+   else {

+      /* four channels */

+      texelOut[0] = CHAN_TO_FLOAT(temp[0]);

+      texelOut[1] = CHAN_TO_FLOAT(temp[1]);

+      texelOut[2] = CHAN_TO_FLOAT(temp[2]);

+      texelOut[3] = CHAN_TO_FLOAT(temp[3]);

+   }

+}

+#endif

+

+

+/**

+ * Initialize the texture image's FetchTexelc and FetchTexelf methods.

+ */

+void

+_mesa_set_fetch_functions(struct gl_texture_image *texImage, GLuint dims)

+{

+   gl_format format = texImage->TexFormat;

+

+   ASSERT(dims == 1 || dims == 2 || dims == 3);

+

+   if (texImage->TexObject->sRGBDecode == GL_SKIP_DECODE_EXT &&

+       _mesa_get_format_color_encoding(format) == GL_SRGB) {

+      format = _mesa_get_srgb_format_linear(format);

+   }

+

+   texImage->FetchTexelf = _mesa_get_texel_fetch_func(format, dims);

+

+   texImage->FetchTexelc = fetch_texel_float_to_chan;

+

+   ASSERT(texImage->FetchTexelc);

+   ASSERT(texImage->FetchTexelf);

+}

+

+void

+_mesa_update_fetch_functions(struct gl_texture_object *texObj)

+{

+   GLuint face, i;

+   GLuint dims;

+

+   dims = _mesa_get_texture_dimensions(texObj->Target);

+

+   for (face = 0; face < 6; face++) {

+      for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {

+         if (texObj->Image[face][i]) {

+	    _mesa_set_fetch_functions(texObj->Image[face][i], dims);

+         }

+      }

+   }

+}

diff --git a/mesalib/src/mesa/main/texformat.c b/mesalib/src/mesa/main/texformat.c
index 5eabf2aa5..80518200b 100644
--- a/mesalib/src/mesa/main/texformat.c
+++ b/mesalib/src/mesa/main/texformat.c
@@ -1,656 +1,656 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008-2009 VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file texformat.c
- * Texture formats.
- *
- * \author Gareth Hughes
- * \author Brian Paul
- */
-
-
-#include "context.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "texcompress.h"
-#include "texformat.h"
-
-#define RETURN_IF_SUPPORTED(f) do {		\
-   if (ctx->TextureFormatSupported[f])		\
-      return f;					\
-} while (0)
-
-/**
- * Choose an appropriate texture format given the format, type and
- * internalFormat parameters passed to glTexImage().
- *
- * \param ctx  the GL context.
- * \param internalFormat  user's prefered internal texture format.
- * \param format  incoming image pixel format.
- * \param type  incoming image data type.
- *
- * \return a pointer to a gl_texture_format object which describes the
- * choosen texture format, or NULL on failure.
- * 
- * This is called via dd_function_table::ChooseTextureFormat.  Hardware drivers
- * will typically override this function with a specialized version.
- */
-gl_format
-_mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,
-                         GLenum format, GLenum type )
-{
-   (void) format;
-   (void) type;
-
-   switch (internalFormat) {
-      /* shallow RGBA formats */
-      case 4:
-      case GL_RGBA:
-	 if (type == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);
-	 } else if (type == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB1555);
-	 }
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-
-      case GL_RGBA8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      case GL_RGB5_A1:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB1555);
-	 break;
-      case GL_RGBA2:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444_REV); /* just to test another format*/
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);
-	 break;
-      case GL_RGBA4:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);
-	 break;
-
-      /* deep RGBA formats */
-      case GL_RGB10_A2:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB2101010);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      case GL_RGBA12:
-      case GL_RGBA16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-
-      /* shallow RGB formats */
-      case 3:
-      case GL_RGB:
-      case GL_RGB8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      case GL_R3_G3_B2:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB332);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      case GL_RGB4:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565_REV); /* just to test another format */
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565);
-	 break;
-      case GL_RGB5:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565);
-	 break;
-
-      /* deep RGB formats */
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-
-      /* Alpha formats */
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);
-	 break;
-
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_A16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);
-	 break;
-
-      /* Luminance formats */
-      case 1:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);
-	 break;
-
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_L16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);
-	 break;
-
-      /* Luminance/Alpha formats */
-      case GL_LUMINANCE4_ALPHA4:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL44);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);
-	 break;
-
-      case 2:
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);
-	 break;
-
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL1616);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);
-	 break;
-
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);
-	 break;
-
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_I16);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);
-	 break;
-
-      case GL_COLOR_INDEX:
-      case GL_COLOR_INDEX1_EXT:
-      case GL_COLOR_INDEX2_EXT:
-      case GL_COLOR_INDEX4_EXT:
-      case GL_COLOR_INDEX12_EXT:
-      case GL_COLOR_INDEX16_EXT:
-      case GL_COLOR_INDEX8_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_CI8);
-	 break;
-
-      default:
-         ; /* fallthrough */
-   }
-
-   if (ctx->Extensions.ARB_depth_texture) {
-      switch (internalFormat) {
-         case GL_DEPTH_COMPONENT:
-         case GL_DEPTH_COMPONENT24:
-         case GL_DEPTH_COMPONENT32:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z32);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);
-	    break;
-         case GL_DEPTH_COMPONENT16:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z16);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   switch (internalFormat) {
-      case GL_COMPRESSED_ALPHA_ARB:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);
-	 break;
-      case GL_COMPRESSED_LUMINANCE_ARB:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);
-	 break;
-      case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);
-	 break;
-      case GL_COMPRESSED_INTENSITY_ARB:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);
-	 break;
-      case GL_COMPRESSED_RGB_ARB:
-         if (ctx->Extensions.EXT_texture_compression_s3tc ||
-             ctx->Extensions.S3_s3tc)
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);
-         if (ctx->Extensions.TDFX_texture_compression_FXT1)
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FXT1);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      case GL_COMPRESSED_RGBA_ARB:
-         if (ctx->Extensions.EXT_texture_compression_s3tc ||
-             ctx->Extensions.S3_s3tc)
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3); /* Not rgba_dxt1, see spec */
-         if (ctx->Extensions.TDFX_texture_compression_FXT1)
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FXT1);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-      default:
-         ; /* fallthrough */
-   }
-
-   if (ctx->Extensions.MESA_ycbcr_texture) {
-      if (internalFormat == GL_YCBCR_MESA) {
-         if (type == GL_UNSIGNED_SHORT_8_8_MESA)
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_YCBCR);
-         else
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_YCBCR_REV);
-      }
-   }
-
-#if FEATURE_texture_fxt1
-   if (ctx->Extensions.TDFX_texture_compression_FXT1) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_FXT1_3DFX:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FXT1);
-	 break;
-         case GL_COMPRESSED_RGBA_FXT1_3DFX:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FXT1);
-	 break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-#endif
-
-#if FEATURE_texture_s3tc
-   if (ctx->Extensions.EXT_texture_compression_s3tc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);
-	    break;
-         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT1);
-	    break;
-         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3);
-	    break;
-         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT5);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.S3_s3tc) {
-      switch (internalFormat) {
-         case GL_RGB_S3TC:
-         case GL_RGB4_S3TC:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);
-	    break;
-         case GL_RGBA_S3TC:
-         case GL_RGBA4_S3TC:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-#endif
-
-   if (ctx->Extensions.ARB_texture_float) {
-      switch (internalFormat) {
-         case GL_ALPHA16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_ALPHA_FLOAT16);
-	    break;
-         case GL_ALPHA32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_ALPHA_FLOAT32);
-	    break;
-         case GL_LUMINANCE16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_FLOAT16);
-	    break;
-         case GL_LUMINANCE32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_FLOAT32);
-	    break;
-         case GL_LUMINANCE_ALPHA16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16);
-	    break;
-         case GL_LUMINANCE_ALPHA32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32);
-	    break;
-         case GL_INTENSITY16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_INTENSITY_FLOAT16);
-	    break;
-         case GL_INTENSITY32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_INTENSITY_FLOAT32);
-	    break;
-         case GL_RGB16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FLOAT16);
-	    break;
-         case GL_RGB32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FLOAT32);
-	    break;
-         case GL_RGBA16F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FLOAT16);
-	    break;
-         case GL_RGBA32F_ARB:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FLOAT32);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_packed_depth_stencil) {
-      switch (internalFormat) {
-         case GL_DEPTH_STENCIL_EXT:
-         case GL_DEPTH24_STENCIL8_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z24_S8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ATI_envmap_bumpmap) {
-      switch (internalFormat) {
-         case GL_DUDV_ATI:
-         case GL_DU8DV8_ATI:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_DUDV8);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.MESA_texture_signed_rgba) {
-      switch (internalFormat) {
-         case GL_RGBA_SNORM:
-         case GL_RGBA8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888_REV);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->VersionMajor * 10 + ctx->VersionMinor >= 31) {
-      switch (internalFormat) {
-         case GL_RED_SNORM:
-         case GL_R8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R8);
-	    break;
-         case GL_RG_SNORM:
-         case GL_RG8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG88);
-	    break;
-         case GL_RGB_SNORM:
-         case GL_RGB8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBX8888);
-	    break;
-         case GL_RGBA_SNORM:
-         case GL_RGBA8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);
-	    break;
-         case GL_R16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R_16);
-	    break;
-         case GL_RG16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG_16);
-	    break;
-         case GL_RGB16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGB_16);
-	    break;
-         case GL_RGBA16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA_16);
-	    break;
-         default:
-            ; /* fall-through */
-      }
-   }
-
-#if FEATURE_EXT_texture_sRGB
-   if (ctx->Extensions.EXT_texture_sRGB) {
-      switch (internalFormat) {
-         case GL_SRGB_EXT:
-         case GL_SRGB8_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_SRGB_ALPHA_EXT:
-         case GL_SRGB8_ALPHA8_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_SLUMINANCE_EXT:
-         case GL_SLUMINANCE8_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SL8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_SLUMINANCE_ALPHA_EXT:
-         case GL_SLUMINANCE8_ALPHA8_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SLA8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_COMPRESSED_SLUMINANCE_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SL8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SLA8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_COMPRESSED_SRGB_EXT:
-#if FEATURE_texture_s3tc
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB_DXT1);
-#endif
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-         case GL_COMPRESSED_SRGB_ALPHA_EXT:
-#if FEATURE_texture_s3tc
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT3); /* Not srgba_dxt1, see spec */
-#endif
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA8);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-	    break;
-#if FEATURE_texture_s3tc
-         case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB_DXT1);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-            break;
-         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT1);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-            break;
-         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT3);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-            break;
-         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-            if (ctx->Extensions.EXT_texture_compression_s3tc)
-	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT5);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);
-            break;
-#endif
-         default:
-            ; /* fallthrough */
-      }
-   }
-#endif /* FEATURE_EXT_texture_sRGB */
-
-   if (ctx->Extensions.EXT_texture_integer) {
-      switch (internalFormat) {
-      case GL_RGBA32UI_EXT:
-      case GL_RGB32UI_EXT:
-      case GL_ALPHA32UI_EXT:
-      case GL_INTENSITY32UI_EXT:
-      case GL_LUMINANCE32UI_EXT:
-      case GL_LUMINANCE_ALPHA32UI_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT32);
-	 break;
-      case GL_RGBA16UI_EXT:
-      case GL_RGB16UI_EXT:
-      case GL_ALPHA16UI_EXT:
-      case GL_INTENSITY16UI_EXT:
-      case GL_LUMINANCE16UI_EXT:
-      case GL_LUMINANCE_ALPHA16UI_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT16);
-	 break;
-      case GL_RGBA8UI_EXT:
-      case GL_RGB8UI_EXT:
-      case GL_ALPHA8UI_EXT:
-      case GL_INTENSITY8UI_EXT:
-      case GL_LUMINANCE8UI_EXT:
-      case GL_LUMINANCE_ALPHA8UI_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT8);
-	 break;
-      case GL_RGBA32I_EXT:
-      case GL_RGB32I_EXT:
-      case GL_ALPHA32I_EXT:
-      case GL_INTENSITY32I_EXT:
-      case GL_LUMINANCE32I_EXT:
-      case GL_LUMINANCE_ALPHA32I_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT32);
-	 break;
-      case GL_RGBA16I_EXT:
-      case GL_RGB16I_EXT:
-      case GL_ALPHA16I_EXT:
-      case GL_INTENSITY16I_EXT:
-      case GL_LUMINANCE16I_EXT:
-      case GL_LUMINANCE_ALPHA16I_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT16);
-	 break;
-      case GL_RGBA8I_EXT:
-      case GL_RGB8I_EXT:
-      case GL_ALPHA8I_EXT:
-      case GL_INTENSITY8I_EXT:
-      case GL_LUMINANCE8I_EXT:
-      case GL_LUMINANCE_ALPHA8I_EXT:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT8);
-	 break;
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_rg) {
-      switch (internalFormat) {
-      case GL_R8:
-      case GL_RED:
-      case GL_COMPRESSED_RED:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_R8);
-	 break;
-
-      case GL_R16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_R16);
-	 break;
-
-      case GL_RG:
-      case GL_RG8:
-      case GL_COMPRESSED_RG:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RG88);
-	 break;
-
-      case GL_RG16:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_RG1616);
-	 break;
-
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_format_BGRA8888) {
-      switch (internalFormat) {
-      case GL_BGRA:
-	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);
-	 break;
-
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_compression_rgtc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RED_RGTC1:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RED_RGTC1);
-	    break;
-         case GL_COMPRESSED_SIGNED_RED_RGTC1:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RED_RGTC1);
-	    break;
-         case GL_COMPRESSED_RG_RGTC2:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_RG_RGTC2);
-	    break;
-         case GL_COMPRESSED_SIGNED_RG_RGTC2:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG_RGTC2);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_compression_latc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-            RETURN_IF_SUPPORTED(MESA_FORMAT_L_LATC1);
-            break;
-         case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_L_LATC1);
-            break;
-         case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-            RETURN_IF_SUPPORTED(MESA_FORMAT_LA_LATC2);
-            break;
-         case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_LA_LATC2);
-            break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ATI_texture_compression_3dc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-            RETURN_IF_SUPPORTED(MESA_FORMAT_LA_LATC2);
-            break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   _mesa_problem(ctx, "unexpected format in _mesa_choose_tex_format()");
-   return MESA_FORMAT_NONE;
-}
-
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008-2009 VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file texformat.c

+ * Texture formats.

+ *

+ * \author Gareth Hughes

+ * \author Brian Paul

+ */

+

+

+#include "context.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "texcompress.h"

+#include "texformat.h"

+

+#define RETURN_IF_SUPPORTED(f) do {		\

+   if (ctx->TextureFormatSupported[f])		\

+      return f;					\

+} while (0)

+

+/**

+ * Choose an appropriate texture format given the format, type and

+ * internalFormat parameters passed to glTexImage().

+ *

+ * \param ctx  the GL context.

+ * \param internalFormat  user's prefered internal texture format.

+ * \param format  incoming image pixel format.

+ * \param type  incoming image data type.

+ *

+ * \return a pointer to a gl_texture_format object which describes the

+ * choosen texture format, or NULL on failure.

+ * 

+ * This is called via dd_function_table::ChooseTextureFormat.  Hardware drivers

+ * will typically override this function with a specialized version.

+ */

+gl_format

+_mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,

+                         GLenum format, GLenum type )

+{

+   (void) format;

+   (void) type;

+

+   switch (internalFormat) {

+      /* shallow RGBA formats */

+      case 4:

+      case GL_RGBA:

+	 if (type == GL_UNSIGNED_SHORT_4_4_4_4_REV) {

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);

+	 } else if (type == GL_UNSIGNED_SHORT_1_5_5_5_REV) {

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB1555);

+	 }

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+

+      case GL_RGBA8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      case GL_RGB5_A1:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB1555);

+	 break;

+      case GL_RGBA2:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444_REV); /* just to test another format*/

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);

+	 break;

+      case GL_RGBA4:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB4444);

+	 break;

+

+      /* deep RGBA formats */

+      case GL_RGB10_A2:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB2101010);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      case GL_RGBA12:

+      case GL_RGBA16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+

+      /* shallow RGB formats */

+      case 3:

+      case GL_RGB:

+      case GL_RGB8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      case GL_R3_G3_B2:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB332);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      case GL_RGB4:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565_REV); /* just to test another format */

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565);

+	 break;

+      case GL_RGB5:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB565);

+	 break;

+

+      /* deep RGB formats */

+      case GL_RGB10:

+      case GL_RGB12:

+      case GL_RGB16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+

+      /* Alpha formats */

+      case GL_ALPHA:

+      case GL_ALPHA4:

+      case GL_ALPHA8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);

+	 break;

+

+      case GL_ALPHA12:

+      case GL_ALPHA16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_A16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);

+	 break;

+

+      /* Luminance formats */

+      case 1:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE4:

+      case GL_LUMINANCE8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);

+	 break;

+

+      case GL_LUMINANCE12:

+      case GL_LUMINANCE16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_L16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);

+	 break;

+

+      /* Luminance/Alpha formats */

+      case GL_LUMINANCE4_ALPHA4:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL44);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);

+	 break;

+

+      case 2:

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE6_ALPHA2:

+      case GL_LUMINANCE8_ALPHA8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);

+	 break;

+

+      case GL_LUMINANCE12_ALPHA4:

+      case GL_LUMINANCE12_ALPHA12:

+      case GL_LUMINANCE16_ALPHA16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL1616);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);

+	 break;

+

+      case GL_INTENSITY:

+      case GL_INTENSITY4:

+      case GL_INTENSITY8:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);

+	 break;

+

+      case GL_INTENSITY12:

+      case GL_INTENSITY16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_I16);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);

+	 break;

+

+      case GL_COLOR_INDEX:

+      case GL_COLOR_INDEX1_EXT:

+      case GL_COLOR_INDEX2_EXT:

+      case GL_COLOR_INDEX4_EXT:

+      case GL_COLOR_INDEX12_EXT:

+      case GL_COLOR_INDEX16_EXT:

+      case GL_COLOR_INDEX8_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_CI8);

+	 break;

+

+      default:

+         ; /* fallthrough */

+   }

+

+   if (ctx->Extensions.ARB_depth_texture) {

+      switch (internalFormat) {

+         case GL_DEPTH_COMPONENT:

+         case GL_DEPTH_COMPONENT24:

+         case GL_DEPTH_COMPONENT32:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z32);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);

+	    break;

+         case GL_DEPTH_COMPONENT16:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z16);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   switch (internalFormat) {

+      case GL_COMPRESSED_ALPHA_ARB:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_A8);

+	 break;

+      case GL_COMPRESSED_LUMINANCE_ARB:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_L8);

+	 break;

+      case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_AL88);

+	 break;

+      case GL_COMPRESSED_INTENSITY_ARB:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_I8);

+	 break;

+      case GL_COMPRESSED_RGB_ARB:

+         if (ctx->Extensions.EXT_texture_compression_s3tc ||

+             ctx->Extensions.S3_s3tc)

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);

+         if (ctx->Extensions.TDFX_texture_compression_FXT1)

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FXT1);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGB888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_XRGB8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      case GL_COMPRESSED_RGBA_ARB:

+         if (ctx->Extensions.EXT_texture_compression_s3tc ||

+             ctx->Extensions.S3_s3tc)

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3); /* Not rgba_dxt1, see spec */

+         if (ctx->Extensions.TDFX_texture_compression_FXT1)

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FXT1);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA8888);

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+      default:

+         ; /* fallthrough */

+   }

+

+   if (ctx->Extensions.MESA_ycbcr_texture) {

+      if (internalFormat == GL_YCBCR_MESA) {

+         if (type == GL_UNSIGNED_SHORT_8_8_MESA)

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_YCBCR);

+         else

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_YCBCR_REV);

+      }

+   }

+

+#if FEATURE_texture_fxt1

+   if (ctx->Extensions.TDFX_texture_compression_FXT1) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_FXT1_3DFX:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FXT1);

+	 break;

+         case GL_COMPRESSED_RGBA_FXT1_3DFX:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FXT1);

+	 break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+#endif

+

+#if FEATURE_texture_s3tc

+   if (ctx->Extensions.EXT_texture_compression_s3tc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);

+	    break;

+         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT1);

+	    break;

+         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3);

+	    break;

+         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT5);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.S3_s3tc) {

+      switch (internalFormat) {

+         case GL_RGB_S3TC:

+         case GL_RGB4_S3TC:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_DXT1);

+	    break;

+         case GL_RGBA_S3TC:

+         case GL_RGBA4_S3TC:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_DXT3);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+#endif

+

+   if (ctx->Extensions.ARB_texture_float) {

+      switch (internalFormat) {

+         case GL_ALPHA16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_ALPHA_FLOAT16);

+	    break;

+         case GL_ALPHA32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_ALPHA_FLOAT32);

+	    break;

+         case GL_LUMINANCE16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_FLOAT16);

+	    break;

+         case GL_LUMINANCE32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_FLOAT32);

+	    break;

+         case GL_LUMINANCE_ALPHA16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16);

+	    break;

+         case GL_LUMINANCE_ALPHA32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32);

+	    break;

+         case GL_INTENSITY16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_INTENSITY_FLOAT16);

+	    break;

+         case GL_INTENSITY32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_INTENSITY_FLOAT32);

+	    break;

+         case GL_RGB16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FLOAT16);

+	    break;

+         case GL_RGB32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGB_FLOAT32);

+	    break;

+         case GL_RGBA16F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FLOAT16);

+	    break;

+         case GL_RGBA32F_ARB:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_FLOAT32);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_packed_depth_stencil) {

+      switch (internalFormat) {

+         case GL_DEPTH_STENCIL_EXT:

+         case GL_DEPTH24_STENCIL8_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_Z24_S8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_S8_Z24);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ATI_envmap_bumpmap) {

+      switch (internalFormat) {

+         case GL_DUDV_ATI:

+         case GL_DU8DV8_ATI:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_DUDV8);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.MESA_texture_signed_rgba) {

+      switch (internalFormat) {

+         case GL_RGBA_SNORM:

+         case GL_RGBA8_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888_REV);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->VersionMajor * 10 + ctx->VersionMinor >= 31) {

+      switch (internalFormat) {

+         case GL_RED_SNORM:

+         case GL_R8_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R8);

+	    break;

+         case GL_RG_SNORM:

+         case GL_RG8_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG88);

+	    break;

+         case GL_RGB_SNORM:

+         case GL_RGB8_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBX8888);

+	    break;

+         case GL_RGBA_SNORM:

+         case GL_RGBA8_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);

+	    break;

+         case GL_R16_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R_16);

+	    break;

+         case GL_RG16_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG_16);

+	    break;

+         case GL_RGB16_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGB_16);

+	    break;

+         case GL_RGBA16_SNORM:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA_16);

+	    break;

+         default:

+            ; /* fall-through */

+      }

+   }

+

+#if FEATURE_EXT_texture_sRGB

+   if (ctx->Extensions.EXT_texture_sRGB) {

+      switch (internalFormat) {

+         case GL_SRGB_EXT:

+         case GL_SRGB8_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_SRGB_ALPHA_EXT:

+         case GL_SRGB8_ALPHA8_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_SLUMINANCE_EXT:

+         case GL_SLUMINANCE8_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SL8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_SLUMINANCE_ALPHA_EXT:

+         case GL_SLUMINANCE8_ALPHA8_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SLA8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_COMPRESSED_SLUMINANCE_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SL8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SLA8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_COMPRESSED_SRGB_EXT:

+#if FEATURE_texture_s3tc

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB_DXT1);

+#endif

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+         case GL_COMPRESSED_SRGB_ALPHA_EXT:

+#if FEATURE_texture_s3tc

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT3); /* Not srgba_dxt1, see spec */

+#endif

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA8);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+	    break;

+#if FEATURE_texture_s3tc

+         case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGB_DXT1);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+            break;

+         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT1);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+            break;

+         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT3);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+            break;

+         case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+            if (ctx->Extensions.EXT_texture_compression_s3tc)

+	       RETURN_IF_SUPPORTED(MESA_FORMAT_SRGBA_DXT5);

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SARGB8);

+            break;

+#endif

+         default:

+            ; /* fallthrough */

+      }

+   }

+#endif /* FEATURE_EXT_texture_sRGB */

+

+   if (ctx->Extensions.EXT_texture_integer) {

+      switch (internalFormat) {

+      case GL_RGBA32UI_EXT:

+      case GL_RGB32UI_EXT:

+      case GL_ALPHA32UI_EXT:

+      case GL_INTENSITY32UI_EXT:

+      case GL_LUMINANCE32UI_EXT:

+      case GL_LUMINANCE_ALPHA32UI_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT32);

+	 break;

+      case GL_RGBA16UI_EXT:

+      case GL_RGB16UI_EXT:

+      case GL_ALPHA16UI_EXT:

+      case GL_INTENSITY16UI_EXT:

+      case GL_LUMINANCE16UI_EXT:

+      case GL_LUMINANCE_ALPHA16UI_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT16);

+	 break;

+      case GL_RGBA8UI_EXT:

+      case GL_RGB8UI_EXT:

+      case GL_ALPHA8UI_EXT:

+      case GL_INTENSITY8UI_EXT:

+      case GL_LUMINANCE8UI_EXT:

+      case GL_LUMINANCE_ALPHA8UI_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_UINT8);

+	 break;

+      case GL_RGBA32I_EXT:

+      case GL_RGB32I_EXT:

+      case GL_ALPHA32I_EXT:

+      case GL_INTENSITY32I_EXT:

+      case GL_LUMINANCE32I_EXT:

+      case GL_LUMINANCE_ALPHA32I_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT32);

+	 break;

+      case GL_RGBA16I_EXT:

+      case GL_RGB16I_EXT:

+      case GL_ALPHA16I_EXT:

+      case GL_INTENSITY16I_EXT:

+      case GL_LUMINANCE16I_EXT:

+      case GL_LUMINANCE_ALPHA16I_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT16);

+	 break;

+      case GL_RGBA8I_EXT:

+      case GL_RGB8I_EXT:

+      case GL_ALPHA8I_EXT:

+      case GL_INTENSITY8I_EXT:

+      case GL_LUMINANCE8I_EXT:

+      case GL_LUMINANCE_ALPHA8I_EXT:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RGBA_INT8);

+	 break;

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_rg) {

+      switch (internalFormat) {

+      case GL_R8:

+      case GL_RED:

+      case GL_COMPRESSED_RED:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_R8);

+	 break;

+

+      case GL_R16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_R16);

+	 break;

+

+      case GL_RG:

+      case GL_RG8:

+      case GL_COMPRESSED_RG:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RG88);

+	 break;

+

+      case GL_RG16:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_RG1616);

+	 break;

+

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_format_BGRA8888) {

+      switch (internalFormat) {

+      case GL_BGRA:

+	 RETURN_IF_SUPPORTED(MESA_FORMAT_ARGB8888);

+	 break;

+

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_compression_rgtc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RED_RGTC1:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RED_RGTC1);

+	    break;

+         case GL_COMPRESSED_SIGNED_RED_RGTC1:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RED_RGTC1);

+	    break;

+         case GL_COMPRESSED_RG_RGTC2:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_RG_RGTC2);

+	    break;

+         case GL_COMPRESSED_SIGNED_RG_RGTC2:

+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG_RGTC2);

+	    break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_compression_latc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+            RETURN_IF_SUPPORTED(MESA_FORMAT_L_LATC1);

+            break;

+         case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_L_LATC1);

+            break;

+         case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+            RETURN_IF_SUPPORTED(MESA_FORMAT_LA_LATC2);

+            break;

+         case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_LA_LATC2);

+            break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ATI_texture_compression_3dc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+            RETURN_IF_SUPPORTED(MESA_FORMAT_LA_LATC2);

+            break;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   _mesa_problem(ctx, "unexpected format in _mesa_choose_tex_format()");

+   return MESA_FORMAT_NONE;

+}

+

diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c
index 21d9140c5..fe5ac0a89 100644
--- a/mesalib/src/mesa/main/texgetimage.c
+++ b/mesalib/src/mesa/main/texgetimage.c
@@ -1,918 +1,918 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2009 VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * Code for glGetTexImage() and glGetCompressedTexImage().
- */
-
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "enums.h"
-#include "context.h"
-#include "formats.h"
-#include "image.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "pack.h"
-#include "pbo.h"
-#include "texgetimage.h"
-#include "teximage.h"
-
-
-
-/**
- * Can the given type represent negative values?
- */
-static INLINE GLboolean
-type_with_negative_values(GLenum type)
-{
-   switch (type) {
-   case GL_BYTE:
-   case GL_SHORT:
-   case GL_INT:
-   case GL_FLOAT:
-   case GL_HALF_FLOAT_ARB:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * glGetTexImage for color index pixels.
- */
-static void
-get_tex_color_index(struct gl_context *ctx, GLuint dimensions,
-                    GLenum format, GLenum type, GLvoid *pixels,
-                    const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   const GLuint indexBits =
-      _mesa_get_format_bits(texImage->TexFormat, GL_TEXTURE_INDEX_SIZE_EXT);
-   const GLbitfield transferOps = 0x0;
-   GLint img, row, col;
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         GLuint indexRow[MAX_WIDTH] = { 0 };
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-         assert(dest);
-
-         if (indexBits == 8) {
-            const GLubyte *src = (const GLubyte *) texImage->Data;
-            src += width * (img * texImage->Height + row);
-            for (col = 0; col < width; col++) {
-               indexRow[col] = src[col];
-            }
-         }
-         else if (indexBits == 16) {
-            const GLushort *src = (const GLushort *) texImage->Data;
-            src += width * (img * texImage->Height + row);
-            for (col = 0; col < width; col++) {
-               indexRow[col] = src[col];
-            }
-         }
-         else {
-            _mesa_problem(ctx, "Color index problem in _mesa_GetTexImage");
-         }
-         _mesa_pack_index_span(ctx, width, type, dest,
-                               indexRow, &ctx->Pack, transferOps);
-      }
-   }
-}
-
-
-/**
- * glGetTexImage for depth/Z pixels.
- */
-static void
-get_tex_depth(struct gl_context *ctx, GLuint dimensions,
-              GLenum format, GLenum type, GLvoid *pixels,
-              const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   GLint img, row, col;
-   GLfloat *depthRow = (GLfloat *) malloc(width * sizeof(GLfloat));
-
-   if (!depthRow) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
-      return;
-   }
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-         assert(dest);
-
-         for (col = 0; col < width; col++) {
-            texImage->FetchTexelf(texImage, col, row, img, depthRow + col);
-         }
-         _mesa_pack_depth_span(ctx, width, dest, type, depthRow, &ctx->Pack);
-      }
-   }
-
-   free(depthRow);
-}
-
-
-/**
- * glGetTexImage for depth/stencil pixels.
- */
-static void
-get_tex_depth_stencil(struct gl_context *ctx, GLuint dimensions,
-                      GLenum format, GLenum type, GLvoid *pixels,
-                      const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   const GLuint *src = (const GLuint *) texImage->Data;
-   GLint img, row;
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-         memcpy(dest, src, width * sizeof(GLuint));
-         if (ctx->Pack.SwapBytes) {
-            _mesa_swap4((GLuint *) dest, width);
-         }
-
-         src += width * row + width * height * img;
-      }
-   }
-}
-
-
-/**
- * glGetTexImage for YCbCr pixels.
- */
-static void
-get_tex_ycbcr(struct gl_context *ctx, GLuint dimensions,
-              GLenum format, GLenum type, GLvoid *pixels,
-              const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   const GLint rowstride = texImage->RowStride;
-   const GLushort *src = (const GLushort *) texImage->Data;
-   GLint img, row;
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-         memcpy(dest, src, width * sizeof(GLushort));
-
-         /* check for byte swapping */
-         if ((texImage->TexFormat == MESA_FORMAT_YCBCR
-              && type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||
-             (texImage->TexFormat == MESA_FORMAT_YCBCR_REV
-              && type == GL_UNSIGNED_SHORT_8_8_MESA)) {
-            if (!ctx->Pack.SwapBytes)
-               _mesa_swap2((GLushort *) dest, width);
-         }
-         else if (ctx->Pack.SwapBytes) {
-            _mesa_swap2((GLushort *) dest, width);
-         }
-
-         src += rowstride;
-      }
-   }
-}
-
-
-#if FEATURE_EXT_texture_sRGB
-
-
-/**
- * Convert a float value from linear space to a
- * non-linear sRGB value in [0, 255].
- * Not terribly efficient.
- */
-static INLINE GLfloat
-linear_to_nonlinear(GLfloat cl)
-{
-   /* can't have values outside [0, 1] */
-   GLfloat cs;
-   if (cl < 0.0031308f) {
-      cs = 12.92f * cl;
-   }
-   else {
-      cs = (GLfloat)(1.055 * pow(cl, 0.41666) - 0.055);
-   }
-   return cs;
-}
-
-
-/**
- * glGetTexImagefor sRGB pixels;
- */
-static void
-get_tex_srgb(struct gl_context *ctx, GLuint dimensions,
-             GLenum format, GLenum type, GLvoid *pixels,
-             const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   const GLbitfield transferOps = 0x0;
-   GLint img, row;
-   GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));
-
-   if (!rgba) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
-      return;
-   }
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-
-         GLint col;
-
-         /* convert row to RGBA format */
-         for (col = 0; col < width; col++) {
-            texImage->FetchTexelf(texImage, col, row, img, rgba[col]);
-            if (texImage->_BaseFormat == GL_LUMINANCE) {
-               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
-               rgba[col][GCOMP] = 0.0;
-               rgba[col][BCOMP] = 0.0;
-            }
-            else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
-               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
-               rgba[col][GCOMP] = 0.0;
-               rgba[col][BCOMP] = 0.0;
-            }
-            else if (texImage->_BaseFormat == GL_RGB ||
-                     texImage->_BaseFormat == GL_RGBA) {
-               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
-               rgba[col][GCOMP] = linear_to_nonlinear(rgba[col][GCOMP]);
-               rgba[col][BCOMP] = linear_to_nonlinear(rgba[col][BCOMP]);
-            }
-         }
-         _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
-                                    format, type, dest,
-                                    &ctx->Pack, transferOps);
-      }
-   }
-
-   free(rgba);
-}
-
-
-#else /* FEATURE_EXT_texture_sRGB */
-
-
-static INLINE void
-get_tex_srgb(struct gl_context *ctx, GLuint dimensions,
-             GLenum format, GLenum type, GLvoid *pixels,
-             const struct gl_texture_image *texImage)
-{
-   ASSERT_NO_FEATURE();
-}
-
-
-#endif /* FEATURE_EXT_texture_sRGB */
-
-
-/**
- * glGetTexImagefor RGBA, Luminance, etc. pixels.
- * This is the slow way since we use texture sampling.
- */
-static void
-get_tex_rgba(struct gl_context *ctx, GLuint dimensions,
-             GLenum format, GLenum type, GLvoid *pixels,
-             const struct gl_texture_image *texImage)
-{
-   const GLint width = texImage->Width;
-   const GLint height = texImage->Height;
-   const GLint depth = texImage->Depth;
-   /* Normally, no pixel transfer ops are performed during glGetTexImage.
-    * The only possible exception is component clamping to [0,1].
-    */
-   GLbitfield transferOps = 0x0;
-   GLint img, row;
-   GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));
-
-   if (!rgba) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
-      return;
-   }
-
-   for (img = 0; img < depth; img++) {
-      for (row = 0; row < height; row++) {
-         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,
-                                          width, height, format, type,
-                                          img, row, 0);
-         GLint col;
-         GLenum dataType = _mesa_get_format_datatype(texImage->TexFormat);
-
-         /* clamp does not apply to GetTexImage (final conversion)?
-          * Looks like we need clamp though when going from format
-          * containing negative values to unsigned format.
-          */
-         if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {
-            transferOps |= IMAGE_CLAMP_BIT;
-         }
-         else if (!type_with_negative_values(type) &&
-                  (dataType == GL_FLOAT ||
-                   dataType == GL_SIGNED_NORMALIZED)) {
-            transferOps |= IMAGE_CLAMP_BIT;
-         }
-
-         for (col = 0; col < width; col++) {
-            texImage->FetchTexelf(texImage, col, row, img, rgba[col]);
-            if (texImage->_BaseFormat == GL_ALPHA) {
-               rgba[col][RCOMP] = 0.0F;
-               rgba[col][GCOMP] = 0.0F;
-               rgba[col][BCOMP] = 0.0F;
-            }
-            else if (texImage->_BaseFormat == GL_LUMINANCE) {
-               rgba[col][GCOMP] = 0.0F;
-               rgba[col][BCOMP] = 0.0F;
-               rgba[col][ACOMP] = 1.0F;
-            }
-            else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
-               rgba[col][GCOMP] = 0.0F;
-               rgba[col][BCOMP] = 0.0F;
-            }
-            else if (texImage->_BaseFormat == GL_INTENSITY) {
-               rgba[col][GCOMP] = 0.0F;
-               rgba[col][BCOMP] = 0.0F;
-               rgba[col][ACOMP] = 1.0F;
-            }
-         }
-         _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
-                                    format, type, dest,
-                                    &ctx->Pack, transferOps);
-      }
-   }
-
-   free(rgba);
-}
-
-
-/**
- * Try to do glGetTexImage() with simple memcpy().
- * \return GL_TRUE if done, GL_FALSE otherwise
- */
-static GLboolean
-get_tex_memcpy(struct gl_context *ctx, GLenum format, GLenum type, GLvoid *pixels,
-               const struct gl_texture_object *texObj,
-               const struct gl_texture_image *texImage)
-{
-   GLboolean memCopy = GL_FALSE;
-
-   /* Texture image should have been mapped already */
-   assert(texImage->Data);
-
-   /*
-    * Check if the src/dst formats are compatible.
-    * Also note that GL's pixel transfer ops don't apply to glGetTexImage()
-    * so we don't have to worry about those.
-    * XXX more format combinations could be supported here.
-    */
-   if ((texObj->Target == GL_TEXTURE_1D ||
-        texObj->Target == GL_TEXTURE_2D ||
-        texObj->Target == GL_TEXTURE_RECTANGLE ||
-        (texObj->Target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
-         texObj->Target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) {
-      if (texImage->TexFormat == MESA_FORMAT_ARGB8888 &&
-          format == GL_BGRA &&
-          type == GL_UNSIGNED_BYTE &&
-          !ctx->Pack.SwapBytes &&
-          _mesa_little_endian()) {
-         memCopy = GL_TRUE;
-      }
-      else if (texImage->TexFormat == MESA_FORMAT_AL88 &&
-               format == GL_LUMINANCE_ALPHA &&
-               type == GL_UNSIGNED_BYTE &&
-               !ctx->Pack.SwapBytes &&
-               _mesa_little_endian()) {
-         memCopy = GL_TRUE;
-      }
-      else if (texImage->TexFormat == MESA_FORMAT_L8 &&
-               format == GL_LUMINANCE &&
-               type == GL_UNSIGNED_BYTE) {
-         memCopy = GL_TRUE;
-      }
-      else if (texImage->TexFormat == MESA_FORMAT_L16 &&
-               format == GL_LUMINANCE &&
-               type == GL_UNSIGNED_SHORT) {
-         memCopy = GL_TRUE;
-      }
-      else if (texImage->TexFormat == MESA_FORMAT_A8 &&
-               format == GL_ALPHA &&
-               type == GL_UNSIGNED_BYTE) {
-         memCopy = GL_TRUE;
-      }
-      else if (texImage->TexFormat == MESA_FORMAT_A16 &&
-               format == GL_ALPHA &&
-               type == GL_UNSIGNED_SHORT) {
-         memCopy = GL_TRUE;
-      }
-   }
-
-   if (memCopy) {
-      const GLuint bpp = _mesa_get_format_bytes(texImage->TexFormat);
-      const GLuint bytesPerRow = texImage->Width * bpp;
-      GLubyte *dst =
-         _mesa_image_address2d(&ctx->Pack, pixels, texImage->Width,
-                               texImage->Height, format, type, 0, 0);
-      const GLint dstRowStride =
-         _mesa_image_row_stride(&ctx->Pack, texImage->Width, format, type);
-      const GLubyte *src = texImage->Data;
-      const GLint srcRowStride = texImage->RowStride * bpp;
-      GLuint row;
-
-      if (bytesPerRow == dstRowStride && bytesPerRow == srcRowStride) {
-         memcpy(dst, src, bytesPerRow * texImage->Height);
-      }
-      else {
-         for (row = 0; row < texImage->Height; row++) {
-            memcpy(dst, src, bytesPerRow);
-            dst += dstRowStride;
-            src += srcRowStride;
-         }
-      }
-   }
-
-   return memCopy;
-}
-
-
-/**
- * This is the software fallback for Driver.GetTexImage().
- * All error checking will have been done before this routine is called.
- * The texture image must be mapped.
- */
-void
-_mesa_get_teximage(struct gl_context *ctx, GLenum target, GLint level,
-                   GLenum format, GLenum type, GLvoid *pixels,
-                   struct gl_texture_object *texObj,
-                   struct gl_texture_image *texImage)
-{
-   GLuint dimensions;
-
-   /* If we get here, the texture image should be mapped */
-   assert(texImage->Data);
-
-   switch (target) {
-   case GL_TEXTURE_1D:
-      dimensions = 1;
-      break;
-   case GL_TEXTURE_3D:
-      dimensions = 3;
-      break;
-   default:
-      dimensions = 2;
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      /* Packing texture image into a PBO.
-       * Map the (potentially) VRAM-based buffer into our process space so
-       * we can write into it with the code below.
-       * A hardware driver might use a sophisticated blit to move the
-       * texture data to the PBO if the PBO is in VRAM along with the texture.
-       */
-      GLubyte *buf = (GLubyte *)
-         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);
-      if (!buf) {
-         /* out of memory or other unexpected error */
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage(map PBO failed)");
-         return;
-      }
-      /* <pixels> was an offset into the PBO.
-       * Now make it a real, client-side pointer inside the mapped region.
-       */
-      pixels = ADD_POINTERS(buf, pixels);
-   }
-
-   if (get_tex_memcpy(ctx, format, type, pixels, texObj, texImage)) {
-      /* all done */
-   }
-   else if (format == GL_COLOR_INDEX) {
-      get_tex_color_index(ctx, dimensions, format, type, pixels, texImage);
-   }
-   else if (format == GL_DEPTH_COMPONENT) {
-      get_tex_depth(ctx, dimensions, format, type, pixels, texImage);
-   }
-   else if (format == GL_DEPTH_STENCIL_EXT) {
-      get_tex_depth_stencil(ctx, dimensions, format, type, pixels, texImage);
-   }
-   else if (format == GL_YCBCR_MESA) {
-      get_tex_ycbcr(ctx, dimensions, format, type, pixels, texImage);
-   }
-   else if (_mesa_get_format_color_encoding(texImage->TexFormat) == GL_SRGB) {
-      get_tex_srgb(ctx, dimensions, format, type, pixels, texImage);
-   }
-   else {
-      get_tex_rgba(ctx, dimensions, format, type, pixels, texImage);
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
-}
-
-
-
-/**
- * This is the software fallback for Driver.GetCompressedTexImage().
- * All error checking will have been done before this routine is called.
- */
-void
-_mesa_get_compressed_teximage(struct gl_context *ctx, GLenum target, GLint level,
-                              GLvoid *img,
-                              struct gl_texture_object *texObj,
-                              struct gl_texture_image *texImage)
-{
-   const GLuint row_stride = _mesa_format_row_stride(texImage->TexFormat,
-                                                     texImage->Width);
-   const GLuint row_stride_stored = _mesa_format_row_stride(texImage->TexFormat,
-                                                            texImage->RowStride);
-   GLuint i;
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      /* pack texture image into a PBO */
-      GLubyte *buf = (GLubyte *)
-         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);
-      if (!buf) {
-         /* out of memory or other unexpected error */
-         _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                     "glGetCompresssedTexImage(map PBO failed)");
-         return;
-      }
-      img = ADD_POINTERS(buf, img);
-   }
-
-   /* no pixelstore or pixel transfer, but respect stride */
-
-   if (row_stride == row_stride_stored) {
-      const GLuint size = _mesa_format_image_size(texImage->TexFormat,
-                                                  texImage->Width,
-                                                  texImage->Height,
-                                                  texImage->Depth);
-      memcpy(img, texImage->Data, size);
-   }
-   else {
-      GLuint bw, bh;
-      _mesa_get_format_block_size(texImage->TexFormat, &bw, &bh);
-      for (i = 0; i < (texImage->Height + bh - 1) / bh; i++) {
-         memcpy((GLubyte *)img + i * row_stride,
-                (GLubyte *)texImage->Data + i * row_stride_stored,
-                row_stride);
-      }
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
-}
-
-
-
-/**
- * Do error checking for a glGetTexImage() call.
- * \return GL_TRUE if any error, GL_FALSE if no errors.
- */
-static GLboolean
-getteximage_error_check(struct gl_context *ctx, GLenum target, GLint level,
-                        GLenum format, GLenum type, GLvoid *pixels )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);
-   GLenum baseFormat;
-
-   if (maxLevels == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target=0x%x)", target);
-      return GL_TRUE;
-   }
-
-   if (level < 0 || level >= maxLevels) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
-      return GL_TRUE;
-   }
-
-   if (_mesa_sizeof_packed_type(type) <= 0) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
-      return GL_TRUE;
-   }
-
-   if (_mesa_components_in_format(format) <= 0 ||
-       format == GL_STENCIL_INDEX) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
-      return GL_TRUE;
-   }
-
-   if (!ctx->Extensions.EXT_paletted_texture && _mesa_is_index_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return GL_TRUE;
-   }
-
-   if (!ctx->Extensions.ARB_depth_texture && _mesa_is_depth_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return GL_TRUE;
-   }
-
-   if (!ctx->Extensions.MESA_ycbcr_texture && _mesa_is_ycbcr_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return GL_TRUE;
-   }
-
-   if (!ctx->Extensions.EXT_packed_depth_stencil
-       && _mesa_is_depthstencil_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return GL_TRUE;
-   }
-
-   if (!ctx->Extensions.ATI_envmap_bumpmap
-       && _mesa_is_dudv_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return GL_TRUE;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   if (!texObj || _mesa_is_proxy_texture(target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
-      return GL_TRUE;
-   }
-
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   if (!texImage) {
-      /* out of memory */
-      return GL_TRUE;
-   }
-
-   baseFormat = _mesa_get_format_base_format(texImage->TexFormat);
-      
-   /* Make sure the requested image format is compatible with the
-    * texture's format.  Note that a color index texture can be converted
-    * to RGBA so that combo is allowed.
-    */
-   if (_mesa_is_color_format(format)
-       && !_mesa_is_color_format(baseFormat)
-       && !_mesa_is_index_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-   else if (_mesa_is_index_format(format)
-            && !_mesa_is_index_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-   else if (_mesa_is_depth_format(format)
-            && !_mesa_is_depth_format(baseFormat)
-            && !_mesa_is_depthstencil_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-   else if (_mesa_is_ycbcr_format(format)
-            && !_mesa_is_ycbcr_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-   else if (_mesa_is_depthstencil_format(format)
-            && !_mesa_is_depthstencil_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-   else if (_mesa_is_dudv_format(format)
-            && !_mesa_is_dudv_format(baseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return GL_TRUE;
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      /* packing texture image into a PBO */
-      const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
-      if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,
-                                     texImage->Height, texImage->Depth,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetTexImage(out of bounds PBO write)");
-         return GL_TRUE;
-      }
-
-      /* PBO should not be mapped */
-      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetTexImage(PBO is mapped)");
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-
-/**
- * Get texture image.  Called by glGetTexImage.
- *
- * \param target texture target.
- * \param level image level.
- * \param format pixel data format for returned image.
- * \param type pixel data type for returned image.
- * \param pixels returned pixel data.
- */
-void GLAPIENTRY
-_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
-                   GLenum type, GLvoid *pixels )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (getteximage_error_check(ctx, target, level, format, type, pixels)) {
-      return;
-   }
-
-   if (!_mesa_is_bufferobj(ctx->Pack.BufferObj) && !pixels) {
-      /* not an error, do nothing */
-      return;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE)) {
-      _mesa_debug(ctx, "glGetTexImage(tex %u) format = %s, w=%d, h=%d,"
-                  " dstFmt=0x%x, dstType=0x%x\n",
-                  texObj->Name,
-                  _mesa_get_format_name(texImage->TexFormat),
-                  texImage->Width, texImage->Height,
-                  format, type);
-   }
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,
-                              texObj, texImage);
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-
-/**
- * Do error checking for a glGetCompressedTexImage() call.
- * \return GL_TRUE if any error, GL_FALSE if no errors.
- */
-static GLboolean
-getcompressedteximage_error_check(struct gl_context *ctx, GLenum target,
-                                  GLint level, GLvoid *img)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);
-
-   if (maxLevels == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImage(target=0x%x)",
-                  target);
-      return GL_TRUE;
-   }
-
-   if (level < 0 || level >= maxLevels) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetCompressedTexImageARB(bad level = %d)", level);
-      return GL_TRUE;
-   }
-
-   if (_mesa_is_proxy_texture(target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetCompressedTexImageARB(bad target = %s)",
-                  _mesa_lookup_enum_by_nr(target));
-      return GL_TRUE;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   if (!texObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
-      return GL_TRUE;
-   }
-
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-   if (!texImage) {
-      /* probably invalid mipmap level */
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetCompressedTexImageARB(level)");
-      return GL_TRUE;
-   }
-
-   if (!_mesa_is_format_compressed(texImage->TexFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetCompressedTexImageARB(texture is not compressed)");
-      return GL_TRUE;
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
-      GLuint compressedSize;
-
-      /* make sure PBO is not mapped */
-      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetCompressedTexImage(PBO is mapped)");
-         return GL_TRUE;
-      }
-
-      compressedSize = _mesa_format_image_size(texImage->TexFormat,
-                                               texImage->Width,
-                                               texImage->Height,
-                                               texImage->Depth);
-
-      /* do bounds checking on PBO write */
-      if ((const GLubyte *) img + compressedSize >
-          (const GLubyte *) ctx->Pack.BufferObj->Size) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetCompressedTexImage(out of bounds PBO write)");
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-void GLAPIENTRY
-_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (getcompressedteximage_error_check(ctx, target, level, img)) {
-      return;
-   }
-
-   if (_mesa_is_bufferobj(ctx->Pack.BufferObj) && !img) {
-      /* not an error, do nothing */
-      return;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE)) {
-      _mesa_debug(ctx,
-                  "glGetCompressedTexImage(tex %u) format = %s, w=%d, h=%d\n",
-                  texObj->Name,
-                  _mesa_get_format_name(texImage->TexFormat),
-                  texImage->Width, texImage->Height);
-   }
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      ctx->Driver.GetCompressedTexImage(ctx, target, level, img,
-                                        texObj, texImage);
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2009 VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * Code for glGetTexImage() and glGetCompressedTexImage().

+ */

+

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "enums.h"

+#include "context.h"

+#include "formats.h"

+#include "image.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "pack.h"

+#include "pbo.h"

+#include "texgetimage.h"

+#include "teximage.h"

+

+

+

+/**

+ * Can the given type represent negative values?

+ */

+static INLINE GLboolean

+type_with_negative_values(GLenum type)

+{

+   switch (type) {

+   case GL_BYTE:

+   case GL_SHORT:

+   case GL_INT:

+   case GL_FLOAT:

+   case GL_HALF_FLOAT_ARB:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * glGetTexImage for color index pixels.

+ */

+static void

+get_tex_color_index(struct gl_context *ctx, GLuint dimensions,

+                    GLenum format, GLenum type, GLvoid *pixels,

+                    const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   const GLuint indexBits =

+      _mesa_get_format_bits(texImage->TexFormat, GL_TEXTURE_INDEX_SIZE_EXT);

+   const GLbitfield transferOps = 0x0;

+   GLint img, row, col;

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         GLuint indexRow[MAX_WIDTH] = { 0 };

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+         assert(dest);

+

+         if (indexBits == 8) {

+            const GLubyte *src = (const GLubyte *) texImage->Data;

+            src += width * (img * texImage->Height + row);

+            for (col = 0; col < width; col++) {

+               indexRow[col] = src[col];

+            }

+         }

+         else if (indexBits == 16) {

+            const GLushort *src = (const GLushort *) texImage->Data;

+            src += width * (img * texImage->Height + row);

+            for (col = 0; col < width; col++) {

+               indexRow[col] = src[col];

+            }

+         }

+         else {

+            _mesa_problem(ctx, "Color index problem in _mesa_GetTexImage");

+         }

+         _mesa_pack_index_span(ctx, width, type, dest,

+                               indexRow, &ctx->Pack, transferOps);

+      }

+   }

+}

+

+

+/**

+ * glGetTexImage for depth/Z pixels.

+ */

+static void

+get_tex_depth(struct gl_context *ctx, GLuint dimensions,

+              GLenum format, GLenum type, GLvoid *pixels,

+              const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   GLint img, row, col;

+   GLfloat *depthRow = (GLfloat *) malloc(width * sizeof(GLfloat));

+

+   if (!depthRow) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");

+      return;

+   }

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+         assert(dest);

+

+         for (col = 0; col < width; col++) {

+            texImage->FetchTexelf(texImage, col, row, img, depthRow + col);

+         }

+         _mesa_pack_depth_span(ctx, width, dest, type, depthRow, &ctx->Pack);

+      }

+   }

+

+   free(depthRow);

+}

+

+

+/**

+ * glGetTexImage for depth/stencil pixels.

+ */

+static void

+get_tex_depth_stencil(struct gl_context *ctx, GLuint dimensions,

+                      GLenum format, GLenum type, GLvoid *pixels,

+                      const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   const GLuint *src = (const GLuint *) texImage->Data;

+   GLint img, row;

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+         memcpy(dest, src, width * sizeof(GLuint));

+         if (ctx->Pack.SwapBytes) {

+            _mesa_swap4((GLuint *) dest, width);

+         }

+

+         src += width * row + width * height * img;

+      }

+   }

+}

+

+

+/**

+ * glGetTexImage for YCbCr pixels.

+ */

+static void

+get_tex_ycbcr(struct gl_context *ctx, GLuint dimensions,

+              GLenum format, GLenum type, GLvoid *pixels,

+              const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   const GLint rowstride = texImage->RowStride;

+   const GLushort *src = (const GLushort *) texImage->Data;

+   GLint img, row;

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+         memcpy(dest, src, width * sizeof(GLushort));

+

+         /* check for byte swapping */

+         if ((texImage->TexFormat == MESA_FORMAT_YCBCR

+              && type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||

+             (texImage->TexFormat == MESA_FORMAT_YCBCR_REV

+              && type == GL_UNSIGNED_SHORT_8_8_MESA)) {

+            if (!ctx->Pack.SwapBytes)

+               _mesa_swap2((GLushort *) dest, width);

+         }

+         else if (ctx->Pack.SwapBytes) {

+            _mesa_swap2((GLushort *) dest, width);

+         }

+

+         src += rowstride;

+      }

+   }

+}

+

+

+#if FEATURE_EXT_texture_sRGB

+

+

+/**

+ * Convert a float value from linear space to a

+ * non-linear sRGB value in [0, 255].

+ * Not terribly efficient.

+ */

+static INLINE GLfloat

+linear_to_nonlinear(GLfloat cl)

+{

+   /* can't have values outside [0, 1] */

+   GLfloat cs;

+   if (cl < 0.0031308f) {

+      cs = 12.92f * cl;

+   }

+   else {

+      cs = (GLfloat)(1.055 * pow(cl, 0.41666) - 0.055);

+   }

+   return cs;

+}

+

+

+/**

+ * glGetTexImagefor sRGB pixels;

+ */

+static void

+get_tex_srgb(struct gl_context *ctx, GLuint dimensions,

+             GLenum format, GLenum type, GLvoid *pixels,

+             const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   const GLbitfield transferOps = 0x0;

+   GLint img, row;

+   GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));

+

+   if (!rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");

+      return;

+   }

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+

+         GLint col;

+

+         /* convert row to RGBA format */

+         for (col = 0; col < width; col++) {

+            texImage->FetchTexelf(texImage, col, row, img, rgba[col]);

+            if (texImage->_BaseFormat == GL_LUMINANCE) {

+               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);

+               rgba[col][GCOMP] = 0.0;

+               rgba[col][BCOMP] = 0.0;

+            }

+            else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {

+               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);

+               rgba[col][GCOMP] = 0.0;

+               rgba[col][BCOMP] = 0.0;

+            }

+            else if (texImage->_BaseFormat == GL_RGB ||

+                     texImage->_BaseFormat == GL_RGBA) {

+               rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);

+               rgba[col][GCOMP] = linear_to_nonlinear(rgba[col][GCOMP]);

+               rgba[col][BCOMP] = linear_to_nonlinear(rgba[col][BCOMP]);

+            }

+         }

+         _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,

+                                    format, type, dest,

+                                    &ctx->Pack, transferOps);

+      }

+   }

+

+   free(rgba);

+}

+

+

+#else /* FEATURE_EXT_texture_sRGB */

+

+

+static INLINE void

+get_tex_srgb(struct gl_context *ctx, GLuint dimensions,

+             GLenum format, GLenum type, GLvoid *pixels,

+             const struct gl_texture_image *texImage)

+{

+   ASSERT_NO_FEATURE();

+}

+

+

+#endif /* FEATURE_EXT_texture_sRGB */

+

+

+/**

+ * glGetTexImagefor RGBA, Luminance, etc. pixels.

+ * This is the slow way since we use texture sampling.

+ */

+static void

+get_tex_rgba(struct gl_context *ctx, GLuint dimensions,

+             GLenum format, GLenum type, GLvoid *pixels,

+             const struct gl_texture_image *texImage)

+{

+   const GLint width = texImage->Width;

+   const GLint height = texImage->Height;

+   const GLint depth = texImage->Depth;

+   /* Normally, no pixel transfer ops are performed during glGetTexImage.

+    * The only possible exception is component clamping to [0,1].

+    */

+   GLbitfield transferOps = 0x0;

+   GLint img, row;

+   GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));

+

+   if (!rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");

+      return;

+   }

+

+   for (img = 0; img < depth; img++) {

+      for (row = 0; row < height; row++) {

+         void *dest = _mesa_image_address(dimensions, &ctx->Pack, pixels,

+                                          width, height, format, type,

+                                          img, row, 0);

+         GLint col;

+         GLenum dataType = _mesa_get_format_datatype(texImage->TexFormat);

+

+         /* clamp does not apply to GetTexImage (final conversion)?

+          * Looks like we need clamp though when going from format

+          * containing negative values to unsigned format.

+          */

+         if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {

+            transferOps |= IMAGE_CLAMP_BIT;

+         }

+         else if (!type_with_negative_values(type) &&

+                  (dataType == GL_FLOAT ||

+                   dataType == GL_SIGNED_NORMALIZED)) {

+            transferOps |= IMAGE_CLAMP_BIT;

+         }

+

+         for (col = 0; col < width; col++) {

+            texImage->FetchTexelf(texImage, col, row, img, rgba[col]);

+            if (texImage->_BaseFormat == GL_ALPHA) {

+               rgba[col][RCOMP] = 0.0F;

+               rgba[col][GCOMP] = 0.0F;

+               rgba[col][BCOMP] = 0.0F;

+            }

+            else if (texImage->_BaseFormat == GL_LUMINANCE) {

+               rgba[col][GCOMP] = 0.0F;

+               rgba[col][BCOMP] = 0.0F;

+               rgba[col][ACOMP] = 1.0F;

+            }

+            else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {

+               rgba[col][GCOMP] = 0.0F;

+               rgba[col][BCOMP] = 0.0F;

+            }

+            else if (texImage->_BaseFormat == GL_INTENSITY) {

+               rgba[col][GCOMP] = 0.0F;

+               rgba[col][BCOMP] = 0.0F;

+               rgba[col][ACOMP] = 1.0F;

+            }

+         }

+         _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,

+                                    format, type, dest,

+                                    &ctx->Pack, transferOps);

+      }

+   }

+

+   free(rgba);

+}

+

+

+/**

+ * Try to do glGetTexImage() with simple memcpy().

+ * \return GL_TRUE if done, GL_FALSE otherwise

+ */

+static GLboolean

+get_tex_memcpy(struct gl_context *ctx, GLenum format, GLenum type, GLvoid *pixels,

+               const struct gl_texture_object *texObj,

+               const struct gl_texture_image *texImage)

+{

+   GLboolean memCopy = GL_FALSE;

+

+   /* Texture image should have been mapped already */

+   assert(texImage->Data);

+

+   /*

+    * Check if the src/dst formats are compatible.

+    * Also note that GL's pixel transfer ops don't apply to glGetTexImage()

+    * so we don't have to worry about those.

+    * XXX more format combinations could be supported here.

+    */

+   if ((texObj->Target == GL_TEXTURE_1D ||

+        texObj->Target == GL_TEXTURE_2D ||

+        texObj->Target == GL_TEXTURE_RECTANGLE ||

+        (texObj->Target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&

+         texObj->Target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) {

+      if (texImage->TexFormat == MESA_FORMAT_ARGB8888 &&

+          format == GL_BGRA &&

+          type == GL_UNSIGNED_BYTE &&

+          !ctx->Pack.SwapBytes &&

+          _mesa_little_endian()) {

+         memCopy = GL_TRUE;

+      }

+      else if (texImage->TexFormat == MESA_FORMAT_AL88 &&

+               format == GL_LUMINANCE_ALPHA &&

+               type == GL_UNSIGNED_BYTE &&

+               !ctx->Pack.SwapBytes &&

+               _mesa_little_endian()) {

+         memCopy = GL_TRUE;

+      }

+      else if (texImage->TexFormat == MESA_FORMAT_L8 &&

+               format == GL_LUMINANCE &&

+               type == GL_UNSIGNED_BYTE) {

+         memCopy = GL_TRUE;

+      }

+      else if (texImage->TexFormat == MESA_FORMAT_L16 &&

+               format == GL_LUMINANCE &&

+               type == GL_UNSIGNED_SHORT) {

+         memCopy = GL_TRUE;

+      }

+      else if (texImage->TexFormat == MESA_FORMAT_A8 &&

+               format == GL_ALPHA &&

+               type == GL_UNSIGNED_BYTE) {

+         memCopy = GL_TRUE;

+      }

+      else if (texImage->TexFormat == MESA_FORMAT_A16 &&

+               format == GL_ALPHA &&

+               type == GL_UNSIGNED_SHORT) {

+         memCopy = GL_TRUE;

+      }

+   }

+

+   if (memCopy) {

+      const GLuint bpp = _mesa_get_format_bytes(texImage->TexFormat);

+      const GLuint bytesPerRow = texImage->Width * bpp;

+      GLubyte *dst =

+         _mesa_image_address2d(&ctx->Pack, pixels, texImage->Width,

+                               texImage->Height, format, type, 0, 0);

+      const GLint dstRowStride =

+         _mesa_image_row_stride(&ctx->Pack, texImage->Width, format, type);

+      const GLubyte *src = texImage->Data;

+      const GLint srcRowStride = texImage->RowStride * bpp;

+      GLuint row;

+

+      if (bytesPerRow == dstRowStride && bytesPerRow == srcRowStride) {

+         memcpy(dst, src, bytesPerRow * texImage->Height);

+      }

+      else {

+         for (row = 0; row < texImage->Height; row++) {

+            memcpy(dst, src, bytesPerRow);

+            dst += dstRowStride;

+            src += srcRowStride;

+         }

+      }

+   }

+

+   return memCopy;

+}

+

+

+/**

+ * This is the software fallback for Driver.GetTexImage().

+ * All error checking will have been done before this routine is called.

+ * The texture image must be mapped.

+ */

+void

+_mesa_get_teximage(struct gl_context *ctx, GLenum target, GLint level,

+                   GLenum format, GLenum type, GLvoid *pixels,

+                   struct gl_texture_object *texObj,

+                   struct gl_texture_image *texImage)

+{

+   GLuint dimensions;

+

+   /* If we get here, the texture image should be mapped */

+   assert(texImage->Data);

+

+   switch (target) {

+   case GL_TEXTURE_1D:

+      dimensions = 1;

+      break;

+   case GL_TEXTURE_3D:

+      dimensions = 3;

+      break;

+   default:

+      dimensions = 2;

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      /* Packing texture image into a PBO.

+       * Map the (potentially) VRAM-based buffer into our process space so

+       * we can write into it with the code below.

+       * A hardware driver might use a sophisticated blit to move the

+       * texture data to the PBO if the PBO is in VRAM along with the texture.

+       */

+      GLubyte *buf = (GLubyte *)

+         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,

+                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);

+      if (!buf) {

+         /* out of memory or other unexpected error */

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage(map PBO failed)");

+         return;

+      }

+      /* <pixels> was an offset into the PBO.

+       * Now make it a real, client-side pointer inside the mapped region.

+       */

+      pixels = ADD_POINTERS(buf, pixels);

+   }

+

+   if (get_tex_memcpy(ctx, format, type, pixels, texObj, texImage)) {

+      /* all done */

+   }

+   else if (format == GL_COLOR_INDEX) {

+      get_tex_color_index(ctx, dimensions, format, type, pixels, texImage);

+   }

+   else if (format == GL_DEPTH_COMPONENT) {

+      get_tex_depth(ctx, dimensions, format, type, pixels, texImage);

+   }

+   else if (format == GL_DEPTH_STENCIL_EXT) {

+      get_tex_depth_stencil(ctx, dimensions, format, type, pixels, texImage);

+   }

+   else if (format == GL_YCBCR_MESA) {

+      get_tex_ycbcr(ctx, dimensions, format, type, pixels, texImage);

+   }

+   else if (_mesa_get_format_color_encoding(texImage->TexFormat) == GL_SRGB) {

+      get_tex_srgb(ctx, dimensions, format, type, pixels, texImage);

+   }

+   else {

+      get_tex_rgba(ctx, dimensions, format, type, pixels, texImage);

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,

+                              ctx->Pack.BufferObj);

+   }

+}

+

+

+

+/**

+ * This is the software fallback for Driver.GetCompressedTexImage().

+ * All error checking will have been done before this routine is called.

+ */

+void

+_mesa_get_compressed_teximage(struct gl_context *ctx, GLenum target, GLint level,

+                              GLvoid *img,

+                              struct gl_texture_object *texObj,

+                              struct gl_texture_image *texImage)

+{

+   const GLuint row_stride = _mesa_format_row_stride(texImage->TexFormat,

+                                                     texImage->Width);

+   const GLuint row_stride_stored = _mesa_format_row_stride(texImage->TexFormat,

+                                                            texImage->RowStride);

+   GLuint i;

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      /* pack texture image into a PBO */

+      GLubyte *buf = (GLubyte *)

+         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,

+                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);

+      if (!buf) {

+         /* out of memory or other unexpected error */

+         _mesa_error(ctx, GL_OUT_OF_MEMORY,

+                     "glGetCompresssedTexImage(map PBO failed)");

+         return;

+      }

+      img = ADD_POINTERS(buf, img);

+   }

+

+   /* no pixelstore or pixel transfer, but respect stride */

+

+   if (row_stride == row_stride_stored) {

+      const GLuint size = _mesa_format_image_size(texImage->TexFormat,

+                                                  texImage->Width,

+                                                  texImage->Height,

+                                                  texImage->Depth);

+      memcpy(img, texImage->Data, size);

+   }

+   else {

+      GLuint bw, bh;

+      _mesa_get_format_block_size(texImage->TexFormat, &bw, &bh);

+      for (i = 0; i < (texImage->Height + bh - 1) / bh; i++) {

+         memcpy((GLubyte *)img + i * row_stride,

+                (GLubyte *)texImage->Data + i * row_stride_stored,

+                row_stride);

+      }

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,

+                              ctx->Pack.BufferObj);

+   }

+}

+

+

+

+/**

+ * Do error checking for a glGetTexImage() call.

+ * \return GL_TRUE if any error, GL_FALSE if no errors.

+ */

+static GLboolean

+getteximage_error_check(struct gl_context *ctx, GLenum target, GLint level,

+                        GLenum format, GLenum type, GLvoid *pixels )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);

+   GLenum baseFormat;

+

+   if (maxLevels == 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target=0x%x)", target);

+      return GL_TRUE;

+   }

+

+   if (level < 0 || level >= maxLevels) {

+      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );

+      return GL_TRUE;

+   }

+

+   if (_mesa_sizeof_packed_type(type) <= 0) {

+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );

+      return GL_TRUE;

+   }

+

+   if (_mesa_components_in_format(format) <= 0 ||

+       format == GL_STENCIL_INDEX) {

+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );

+      return GL_TRUE;

+   }

+

+   if (!ctx->Extensions.EXT_paletted_texture && _mesa_is_index_format(format)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");

+      return GL_TRUE;

+   }

+

+   if (!ctx->Extensions.ARB_depth_texture && _mesa_is_depth_format(format)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");

+      return GL_TRUE;

+   }

+

+   if (!ctx->Extensions.MESA_ycbcr_texture && _mesa_is_ycbcr_format(format)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");

+      return GL_TRUE;

+   }

+

+   if (!ctx->Extensions.EXT_packed_depth_stencil

+       && _mesa_is_depthstencil_format(format)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");

+      return GL_TRUE;

+   }

+

+   if (!ctx->Extensions.ATI_envmap_bumpmap

+       && _mesa_is_dudv_format(format)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");

+      return GL_TRUE;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   if (!texObj || _mesa_is_proxy_texture(target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");

+      return GL_TRUE;

+   }

+

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+   if (!texImage) {

+      /* out of memory */

+      return GL_TRUE;

+   }

+

+   baseFormat = _mesa_get_format_base_format(texImage->TexFormat);

+      

+   /* Make sure the requested image format is compatible with the

+    * texture's format.  Note that a color index texture can be converted

+    * to RGBA so that combo is allowed.

+    */

+   if (_mesa_is_color_format(format)

+       && !_mesa_is_color_format(baseFormat)

+       && !_mesa_is_index_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+   else if (_mesa_is_index_format(format)

+            && !_mesa_is_index_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+   else if (_mesa_is_depth_format(format)

+            && !_mesa_is_depth_format(baseFormat)

+            && !_mesa_is_depthstencil_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+   else if (_mesa_is_ycbcr_format(format)

+            && !_mesa_is_ycbcr_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+   else if (_mesa_is_depthstencil_format(format)

+            && !_mesa_is_depthstencil_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+   else if (_mesa_is_dudv_format(format)

+            && !_mesa_is_dudv_format(baseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");

+      return GL_TRUE;

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      /* packing texture image into a PBO */

+      const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;

+      if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,

+                                     texImage->Height, texImage->Depth,

+                                     format, type, pixels)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetTexImage(out of bounds PBO write)");

+         return GL_TRUE;

+      }

+

+      /* PBO should not be mapped */

+      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetTexImage(PBO is mapped)");

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+

+/**

+ * Get texture image.  Called by glGetTexImage.

+ *

+ * \param target texture target.

+ * \param level image level.

+ * \param format pixel data format for returned image.

+ * \param type pixel data type for returned image.

+ * \param pixels returned pixel data.

+ */

+void GLAPIENTRY

+_mesa_GetTexImage( GLenum target, GLint level, GLenum format,

+                   GLenum type, GLvoid *pixels )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (getteximage_error_check(ctx, target, level, format, type, pixels)) {

+      return;

+   }

+

+   if (!_mesa_is_bufferobj(ctx->Pack.BufferObj) && !pixels) {

+      /* not an error, do nothing */

+      return;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE)) {

+      _mesa_debug(ctx, "glGetTexImage(tex %u) format = %s, w=%d, h=%d,"

+                  " dstFmt=0x%x, dstType=0x%x\n",

+                  texObj->Name,

+                  _mesa_get_format_name(texImage->TexFormat),

+                  texImage->Width, texImage->Height,

+                  format, type);

+   }

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,

+                              texObj, texImage);

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+

+/**

+ * Do error checking for a glGetCompressedTexImage() call.

+ * \return GL_TRUE if any error, GL_FALSE if no errors.

+ */

+static GLboolean

+getcompressedteximage_error_check(struct gl_context *ctx, GLenum target,

+                                  GLint level, GLvoid *img)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);

+

+   if (maxLevels == 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImage(target=0x%x)",

+                  target);

+      return GL_TRUE;

+   }

+

+   if (level < 0 || level >= maxLevels) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetCompressedTexImageARB(bad level = %d)", level);

+      return GL_TRUE;

+   }

+

+   if (_mesa_is_proxy_texture(target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetCompressedTexImageARB(bad target = %s)",

+                  _mesa_lookup_enum_by_nr(target));

+      return GL_TRUE;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   if (!texObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");

+      return GL_TRUE;

+   }

+

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+   if (!texImage) {

+      /* probably invalid mipmap level */

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetCompressedTexImageARB(level)");

+      return GL_TRUE;

+   }

+

+   if (!_mesa_is_format_compressed(texImage->TexFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetCompressedTexImageARB(texture is not compressed)");

+      return GL_TRUE;

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {

+      GLuint compressedSize;

+

+      /* make sure PBO is not mapped */

+      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetCompressedTexImage(PBO is mapped)");

+         return GL_TRUE;

+      }

+

+      compressedSize = _mesa_format_image_size(texImage->TexFormat,

+                                               texImage->Width,

+                                               texImage->Height,

+                                               texImage->Depth);

+

+      /* do bounds checking on PBO write */

+      if ((const GLubyte *) img + compressedSize >

+          (const GLubyte *) ctx->Pack.BufferObj->Size) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glGetCompressedTexImage(out of bounds PBO write)");

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+void GLAPIENTRY

+_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (getcompressedteximage_error_check(ctx, target, level, img)) {

+      return;

+   }

+

+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj) && !img) {

+      /* not an error, do nothing */

+      return;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE)) {

+      _mesa_debug(ctx,

+                  "glGetCompressedTexImage(tex %u) format = %s, w=%d, h=%d\n",

+                  texObj->Name,

+                  _mesa_get_format_name(texImage->TexFormat),

+                  texImage->Width, texImage->Height);

+   }

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      ctx->Driver.GetCompressedTexImage(ctx, target, level, img,

+                                        texObj, texImage);

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 2a3037f61..f4d7a4212 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -1,3526 +1,3526 @@
-/*
- * mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file teximage.c
- * Texture image-related functions.
- */
-
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "enums.h"
-#include "fbobject.h"
-#include "framebuffer.h"
-#include "hash.h"
-#include "image.h"
-#include "imports.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "state.h"
-#include "texcompress.h"
-#include "texfetch.h"
-#include "teximage.h"
-#include "texstate.h"
-#include "texpal.h"
-#include "mtypes.h"
-
-
-/**
- * State changes which we care about for glCopyTex[Sub]Image() calls.
- * In particular, we care about pixel transfer state and buffer state
- * (such as glReadBuffer to make sure we read from the right renderbuffer).
- */
-#define NEW_COPY_TEX_STATE (_MESA_NEW_TRANSFER_STATE | \
-                            _NEW_BUFFERS | \
-                            _NEW_PIXEL)
-
-
-
-/**
- * We allocate texture memory on 512-byte boundaries so we can use MMX/SSE
- * elsewhere.
- */
-void *
-_mesa_alloc_texmemory(GLsizei bytes)
-{
-   return _mesa_align_malloc(bytes, 512);
-}
-
-
-/**
- * Free texture memory allocated with _mesa_alloc_texmemory()
- */
-void
-_mesa_free_texmemory(void *m)
-{
-   _mesa_align_free(m);
-}
-
-
-/*
- * Compute floor(log_base_2(n)).
- * If n < 0 return -1.
- */
-static int
-logbase2( int n )
-{
-   GLint i = 1;
-   GLint log2 = 0;
-
-   if (n < 0)
-      return -1;
-
-   if (n == 0)
-      return 0;
-
-   while ( n > i ) {
-      i *= 2;
-      log2++;
-   }
-   if (i != n) {
-      return log2 - 1;
-   }
-   else {
-      return log2;
-   }
-}
-
-
-
-/**
- * Return the simple base format for a given internal texture format.
- * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.
- *
- * \param ctx GL context.
- * \param internalFormat the internal texture format token or 1, 2, 3, or 4.
- *
- * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,
- * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.
- *
- * This is the format which is used during texture application (i.e. the
- * texture format and env mode determine the arithmetic used.
- *
- * XXX this could be static
- */
-GLint
-_mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )
-{
-   switch (internalFormat) {
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-         return GL_ALPHA;
-      case 1:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-         return GL_LUMINANCE;
-      case 2:
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-         return GL_LUMINANCE_ALPHA;
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-         return GL_INTENSITY;
-      case 3:
-      case GL_RGB:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-         return GL_RGB;
-      case 4:
-      case GL_RGBA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-         return GL_RGBA;
-      default:
-         ; /* fallthrough */
-   }
-
-   if (ctx->Extensions.EXT_texture_format_BGRA8888) {
-      switch (internalFormat) {
-         case GL_BGRA_EXT:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_paletted_texture) {
-      switch (internalFormat) {
-         case GL_COLOR_INDEX:
-         case GL_COLOR_INDEX1_EXT:
-         case GL_COLOR_INDEX2_EXT:
-         case GL_COLOR_INDEX4_EXT:
-         case GL_COLOR_INDEX8_EXT:
-         case GL_COLOR_INDEX12_EXT:
-         case GL_COLOR_INDEX16_EXT:
-            return GL_COLOR_INDEX;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_depth_texture) {
-      switch (internalFormat) {
-         case GL_DEPTH_COMPONENT:
-         case GL_DEPTH_COMPONENT16:
-         case GL_DEPTH_COMPONENT24:
-         case GL_DEPTH_COMPONENT32:
-            return GL_DEPTH_COMPONENT;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   switch (internalFormat) {
-   case GL_COMPRESSED_ALPHA:
-      return GL_ALPHA;
-   case GL_COMPRESSED_LUMINANCE:
-      return GL_LUMINANCE;
-   case GL_COMPRESSED_LUMINANCE_ALPHA:
-      return GL_LUMINANCE_ALPHA;
-   case GL_COMPRESSED_INTENSITY:
-      return GL_INTENSITY;
-   case GL_COMPRESSED_RGB:
-      return GL_RGB;
-   case GL_COMPRESSED_RGBA:
-      return GL_RGBA;
-   default:
-      ; /* fallthrough */
-   }
-         
-   if (ctx->Extensions.TDFX_texture_compression_FXT1) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_FXT1_3DFX:
-            return GL_RGB;
-         case GL_COMPRESSED_RGBA_FXT1_3DFX:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_compression_s3tc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-            return GL_RGB;
-         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.S3_s3tc) {
-      switch (internalFormat) {
-         case GL_RGB_S3TC:
-         case GL_RGB4_S3TC:
-            return GL_RGB;
-         case GL_RGBA_S3TC:
-         case GL_RGBA4_S3TC:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.MESA_ycbcr_texture) {
-      if (internalFormat == GL_YCBCR_MESA)
-         return GL_YCBCR_MESA;
-   }
-
-   if (ctx->Extensions.ARB_texture_float) {
-      switch (internalFormat) {
-         case GL_ALPHA16F_ARB:
-         case GL_ALPHA32F_ARB:
-            return GL_ALPHA;
-         case GL_RGBA16F_ARB:
-         case GL_RGBA32F_ARB:
-            return GL_RGBA;
-         case GL_RGB16F_ARB:
-         case GL_RGB32F_ARB:
-            return GL_RGB;
-         case GL_INTENSITY16F_ARB:
-         case GL_INTENSITY32F_ARB:
-            return GL_INTENSITY;
-         case GL_LUMINANCE16F_ARB:
-         case GL_LUMINANCE32F_ARB:
-            return GL_LUMINANCE;
-         case GL_LUMINANCE_ALPHA16F_ARB:
-         case GL_LUMINANCE_ALPHA32F_ARB:
-            return GL_LUMINANCE_ALPHA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ATI_envmap_bumpmap) {
-      switch (internalFormat) {
-         case GL_DUDV_ATI:
-         case GL_DU8DV8_ATI:
-            return GL_DUDV_ATI;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.MESA_texture_signed_rgba) {
-      switch (internalFormat) {
-         case GL_RGBA_SNORM:
-         case GL_RGBA8_SNORM:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_packed_depth_stencil) {
-      switch (internalFormat) {
-         case GL_DEPTH_STENCIL_EXT:
-         case GL_DEPTH24_STENCIL8_EXT:
-            return GL_DEPTH_STENCIL_EXT;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-#if FEATURE_EXT_texture_sRGB
-   if (ctx->Extensions.EXT_texture_sRGB) {
-      switch (internalFormat) {
-      case GL_SRGB_EXT:
-      case GL_SRGB8_EXT:
-      case GL_COMPRESSED_SRGB_EXT:
-      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-         return GL_RGB;
-      case GL_SRGB_ALPHA_EXT:
-      case GL_SRGB8_ALPHA8_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-         return GL_RGBA;
-      case GL_SLUMINANCE_ALPHA_EXT:
-      case GL_SLUMINANCE8_ALPHA8_EXT:
-      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-         return GL_LUMINANCE_ALPHA;
-      case GL_SLUMINANCE_EXT:
-      case GL_SLUMINANCE8_EXT:
-      case GL_COMPRESSED_SLUMINANCE_EXT:
-         return GL_LUMINANCE;
-      default:
-         ; /* fallthrough */
-      }
-   }
-#endif /* FEATURE_EXT_texture_sRGB */
-
-   if (ctx->Extensions.EXT_texture_integer) {
-      switch (internalFormat) {
-      case GL_RGBA8UI_EXT:
-      case GL_RGBA16UI_EXT:
-      case GL_RGBA32UI_EXT:
-      case GL_RGBA8I_EXT:
-      case GL_RGBA16I_EXT:
-      case GL_RGBA32I_EXT:
-         return GL_RGBA;
-      case GL_RGB8UI_EXT:
-      case GL_RGB16UI_EXT:
-      case GL_RGB32UI_EXT:
-      case GL_RGB8I_EXT:
-      case GL_RGB16I_EXT:
-      case GL_RGB32I_EXT:
-         return GL_RGB;
-      case GL_ALPHA8UI_EXT:
-      case GL_ALPHA16UI_EXT:
-      case GL_ALPHA32UI_EXT:
-      case GL_ALPHA8I_EXT:
-      case GL_ALPHA16I_EXT:
-      case GL_ALPHA32I_EXT:
-         return GL_ALPHA;
-      case GL_INTENSITY8UI_EXT:
-      case GL_INTENSITY16UI_EXT:
-      case GL_INTENSITY32UI_EXT:
-      case GL_INTENSITY8I_EXT:
-      case GL_INTENSITY16I_EXT:
-      case GL_INTENSITY32I_EXT:
-         return GL_INTENSITY;
-      case GL_LUMINANCE8UI_EXT:
-      case GL_LUMINANCE16UI_EXT:
-      case GL_LUMINANCE32UI_EXT:
-      case GL_LUMINANCE8I_EXT:
-      case GL_LUMINANCE16I_EXT:
-      case GL_LUMINANCE32I_EXT:
-         return GL_LUMINANCE;
-      case GL_LUMINANCE_ALPHA8UI_EXT:
-      case GL_LUMINANCE_ALPHA16UI_EXT:
-      case GL_LUMINANCE_ALPHA32UI_EXT:
-      case GL_LUMINANCE_ALPHA8I_EXT:
-      case GL_LUMINANCE_ALPHA16I_EXT:
-      case GL_LUMINANCE_ALPHA32I_EXT:
-         return GL_LUMINANCE_ALPHA;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_rg) {
-      switch (internalFormat) {
-      case GL_R16F:
-	 /* R16F depends on both ARB_half_float_pixel and ARB_texture_float.
-	  */
-	 if (!ctx->Extensions.ARB_half_float_pixel)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_R32F:
-	 if (!ctx->Extensions.ARB_texture_float)
-	    break;
-         return GL_RED;
-      case GL_R8I:
-      case GL_R8UI:
-      case GL_R16I:
-      case GL_R16UI:
-      case GL_R32I:
-      case GL_R32UI:
-	 if (!ctx->Extensions.EXT_texture_integer)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_R8:
-      case GL_R16:
-      case GL_RED:
-      case GL_COMPRESSED_RED:
-         return GL_RED;
-
-      case GL_RG16F:
-	 /* RG16F depends on both ARB_half_float_pixel and ARB_texture_float.
-	  */
-	 if (!ctx->Extensions.ARB_half_float_pixel)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_RG32F:
-	 if (!ctx->Extensions.ARB_texture_float)
-	    break;
-         return GL_RG;
-      case GL_RG8I:
-      case GL_RG8UI:
-      case GL_RG16I:
-      case GL_RG16UI:
-      case GL_RG32I:
-      case GL_RG32UI:
-	 if (!ctx->Extensions.EXT_texture_integer)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_RG:
-      case GL_RG8:
-      case GL_RG16:
-      case GL_COMPRESSED_RG:
-         return GL_RG;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_shared_exponent) {
-      switch (internalFormat) {
-      case GL_RGB9_E5_EXT:
-         return GL_RGB;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_packed_float) {
-      switch (internalFormat) {
-      case GL_R11F_G11F_B10F_EXT:
-         return GL_RGB;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_depth_buffer_float) {
-      switch (internalFormat) {
-      case GL_DEPTH_COMPONENT32F:
-         return GL_DEPTH_COMPONENT;
-      case GL_DEPTH32F_STENCIL8:
-         return GL_DEPTH_STENCIL;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_compression_rgtc) {
-      switch (internalFormat) {
-      case GL_COMPRESSED_RED_RGTC1:
-      case GL_COMPRESSED_SIGNED_RED_RGTC1:
-         return GL_RED;
-      case GL_COMPRESSED_RG_RGTC2:
-      case GL_COMPRESSED_SIGNED_RG_RGTC2:
-         return GL_RG;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_compression_latc) {
-      switch (internalFormat) {
-      case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-      case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-         return GL_LUMINANCE;
-      case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-      case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-         return GL_LUMINANCE_ALPHA;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ATI_texture_compression_3dc) {
-      switch (internalFormat) {
-      case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-         return GL_LUMINANCE_ALPHA;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   return -1; /* error */
-}
-
-
-/**
- * For cube map faces, return a face index in [0,5].
- * For other targets return 0;
- */
-GLuint
-_mesa_tex_target_to_face(GLenum target)
-{
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)
-      return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
-   else
-      return 0;
-}
-
-
-
-/**
- * Store a gl_texture_image pointer in a gl_texture_object structure
- * according to the target and level parameters.
- * 
- * \param tObj texture object.
- * \param target texture target.
- * \param level image level.
- * \param texImage texture image.
- * 
- * This was basically prompted by the introduction of cube maps.
- */
-void
-_mesa_set_tex_image(struct gl_texture_object *tObj,
-                    GLenum target, GLint level,
-                    struct gl_texture_image *texImage)
-{
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT(tObj);
-   ASSERT(texImage);
-   ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0);
-
-   tObj->Image[face][level] = texImage;
-
-   /* Set the 'back' pointer */
-   texImage->TexObject = tObj;
-}
-
-
-/**
- * Allocate a texture image structure.
- * 
- * Called via ctx->Driver.NewTextureImage() unless overriden by a device
- * driver.
- *
- * \return a pointer to gl_texture_image struct with all fields initialized to
- * zero.
- */
-struct gl_texture_image *
-_mesa_new_texture_image( struct gl_context *ctx )
-{
-   (void) ctx;
-   return CALLOC_STRUCT(gl_texture_image);
-}
-
-
-/**
- * Free texture image data.
- * This function is a fallback called via ctx->Driver.FreeTexImageData().
- *
- * \param texImage texture image.
- *
- * Free the texture image data if it's not marked as client data.
- */
-void
-_mesa_free_texture_image_data(struct gl_context *ctx,
-                              struct gl_texture_image *texImage)
-{
-   (void) ctx;
-
-   if (texImage->Data && !texImage->IsClientData) {
-      /* free the old texture data */
-      _mesa_free_texmemory(texImage->Data);
-   }
-
-   texImage->Data = NULL;
-}
-
-
-/**
- * Free texture image.
- *
- * \param texImage texture image.
- *
- * Free the texture image structure and the associated image data.
- */
-void
-_mesa_delete_texture_image(struct gl_context *ctx,
-                           struct gl_texture_image *texImage)
-{
-   /* Free texImage->Data and/or any other driver-specific texture
-    * image storage.
-    */
-   ASSERT(ctx->Driver.FreeTexImageData);
-   ctx->Driver.FreeTexImageData( ctx, texImage );
-
-   ASSERT(texImage->Data == NULL);
-   if (texImage->ImageOffsets)
-      free(texImage->ImageOffsets);
-   free(texImage);
-}
-
-
-/**
- * Test if a target is a proxy target.
- *
- * \param target texture target.
- *
- * \return GL_TRUE if the target is a proxy target, GL_FALSE otherwise.
- */
-GLboolean
-_mesa_is_proxy_texture(GLenum target)
-{
-   /* NUM_TEXTURE_TARGETS should match number of terms below */
-   assert(NUM_TEXTURE_TARGETS == 7);
-
-   return (target == GL_PROXY_TEXTURE_1D ||
-           target == GL_PROXY_TEXTURE_2D ||
-           target == GL_PROXY_TEXTURE_3D ||
-           target == GL_PROXY_TEXTURE_CUBE_MAP_ARB ||
-           target == GL_PROXY_TEXTURE_RECTANGLE_NV ||
-           target == GL_PROXY_TEXTURE_1D_ARRAY_EXT ||
-           target == GL_PROXY_TEXTURE_2D_ARRAY_EXT);
-}
-
-
-/**
- * Return the proxy target which corresponds to the given texture target
- */
-static GLenum
-get_proxy_target(GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-      return GL_PROXY_TEXTURE_1D;
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return GL_PROXY_TEXTURE_2D;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-      return GL_PROXY_TEXTURE_3D;
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      return GL_PROXY_TEXTURE_CUBE_MAP_ARB;
-   case GL_TEXTURE_RECTANGLE_NV:
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      return GL_PROXY_TEXTURE_RECTANGLE_NV;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      return GL_PROXY_TEXTURE_1D_ARRAY_EXT;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      return GL_PROXY_TEXTURE_2D_ARRAY_EXT;
-   default:
-      _mesa_problem(NULL, "unexpected target in get_proxy_target()");
-      return 0;
-   }
-}
-
-
-/**
- * Get the texture object that corresponds to the target of the given
- * texture unit.
- *
- * \param ctx GL context.
- * \param texUnit texture unit.
- * \param target texture target.
- *
- * \return pointer to the texture object on success, or NULL on failure.
- * 
- * \sa gl_texture_unit.
- */
-struct gl_texture_object *
-_mesa_select_tex_object(struct gl_context *ctx,
-                        const struct gl_texture_unit *texUnit,
-                        GLenum target)
-{
-   const GLboolean arrayTex = (ctx->Extensions.MESA_texture_array ||
-                               ctx->Extensions.EXT_texture_array);
-
-   switch (target) {
-      case GL_TEXTURE_1D:
-         return texUnit->CurrentTex[TEXTURE_1D_INDEX];
-      case GL_PROXY_TEXTURE_1D:
-         return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];
-      case GL_TEXTURE_2D:
-         return texUnit->CurrentTex[TEXTURE_2D_INDEX];
-      case GL_PROXY_TEXTURE_2D:
-         return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];
-      case GL_TEXTURE_3D:
-         return texUnit->CurrentTex[TEXTURE_3D_INDEX];
-      case GL_PROXY_TEXTURE_3D:
-         return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.ARB_texture_cube_map
-                ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.ARB_texture_cube_map
-                ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL;
-      case GL_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle
-                ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle
-                ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         return arrayTex ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         return arrayTex ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
-      default:
-         _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");
-         return NULL;
-   }
-}
-
-
-/**
- * Return pointer to texture object for given target on current texture unit.
- */
-struct gl_texture_object *
-_mesa_get_current_tex_object(struct gl_context *ctx, GLenum target)
-{
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   return _mesa_select_tex_object(ctx, texUnit, target);
-}
-
-
-/**
- * Get a texture image pointer from a texture object, given a texture
- * target and mipmap level.  The target and level parameters should
- * have already been error-checked.
- *
- * \param ctx GL context.
- * \param texObj texture unit.
- * \param target texture target.
- * \param level image level.
- *
- * \return pointer to the texture image structure, or NULL on failure.
- */
-struct gl_texture_image *
-_mesa_select_tex_image(struct gl_context *ctx,
-                       const struct gl_texture_object *texObj,
-		       GLenum target, GLint level)
-{
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT(texObj);
-   ASSERT(level >= 0);
-   ASSERT(level < MAX_TEXTURE_LEVELS);
-
-   return texObj->Image[face][level];
-}
-
-
-/**
- * Like _mesa_select_tex_image() but if the image doesn't exist, allocate
- * it and install it.  Only return NULL if passed a bad parameter or run
- * out of memory.
- */
-struct gl_texture_image *
-_mesa_get_tex_image(struct gl_context *ctx, struct gl_texture_object *texObj,
-                    GLenum target, GLint level)
-{
-   struct gl_texture_image *texImage;
-
-   if (!texObj)
-      return NULL;
-   
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   if (!texImage) {
-      texImage = ctx->Driver.NewTextureImage(ctx);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture image allocation");
-         return NULL;
-      }
-
-      _mesa_set_tex_image(texObj, target, level, texImage);
-   }
-
-   return texImage;
-}
-
-
-/**
- * Return pointer to the specified proxy texture image.
- * Note that proxy textures are per-context, not per-texture unit.
- * \return pointer to texture image or NULL if invalid target, invalid
- *         level, or out of memory.
- */
-struct gl_texture_image *
-_mesa_get_proxy_tex_image(struct gl_context *ctx, GLenum target, GLint level)
-{
-   struct gl_texture_image *texImage;
-   GLuint texIndex;
-
-   if (level < 0 )
-      return NULL;
-
-   switch (target) {
-   case GL_PROXY_TEXTURE_1D:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_1D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_2D:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_2D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_3D:
-      if (level >= ctx->Const.Max3DTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_3D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-      if (level >= ctx->Const.MaxCubeTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_CUBE_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      if (level > 0)
-         return NULL;
-      texIndex = TEXTURE_RECT_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_1D_ARRAY_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_2D_ARRAY_INDEX;
-      break;
-   default:
-      return NULL;
-   }
-
-   texImage = ctx->Texture.ProxyTex[texIndex]->Image[0][level];
-   if (!texImage) {
-      texImage = ctx->Driver.NewTextureImage(ctx);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-         return NULL;
-      }
-      ctx->Texture.ProxyTex[texIndex]->Image[0][level] = texImage;
-      /* Set the 'back' pointer */
-      texImage->TexObject = ctx->Texture.ProxyTex[texIndex];
-   }
-   return texImage;
-}
-
-
-/**
- * Get the maximum number of allowed mipmap levels.
- *
- * \param ctx GL context.
- * \param target texture target.
- * 
- * \return the maximum number of allowed mipmap levels for the given
- * texture target, or zero if passed a bad target.
- *
- * \sa gl_constants.
- */
-GLint
-_mesa_max_texture_levels(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return ctx->Const.MaxTextureLevels;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-      return ctx->Const.Max3DTextureLevels;
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      return ctx->Extensions.ARB_texture_cube_map
-         ? ctx->Const.MaxCubeTextureLevels : 0;
-   case GL_TEXTURE_RECTANGLE_NV:
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      return ctx->Extensions.NV_texture_rectangle ? 1 : 0;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      return (ctx->Extensions.MESA_texture_array ||
-              ctx->Extensions.EXT_texture_array)
-         ? ctx->Const.MaxTextureLevels : 0;
-   default:
-      return 0; /* bad target */
-   }
-}
-
-
-/**
- * Return number of dimensions per mipmap level for the given texture target.
- */
-GLint
-_mesa_get_texture_dimensions(GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-      return 1;
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_RECTANGLE:
-   case GL_TEXTURE_CUBE_MAP:
-   case GL_PROXY_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_RECTANGLE:
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-   case GL_TEXTURE_1D_ARRAY:
-   case GL_PROXY_TEXTURE_1D_ARRAY:
-      return 2;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-   case GL_TEXTURE_2D_ARRAY:
-   case GL_PROXY_TEXTURE_2D_ARRAY:
-      return 3;
-   default:
-      _mesa_problem(NULL, "invalid target 0x%x in get_texture_dimensions()",
-                    target);
-      return 2;
-   }
-}
-
-
-
-
-#if 000 /* not used anymore */
-/*
- * glTexImage[123]D can accept a NULL image pointer.  In this case we
- * create a texture image with unspecified image contents per the OpenGL
- * spec.
- */
-static GLubyte *
-make_null_texture(GLint width, GLint height, GLint depth, GLenum format)
-{
-   const GLint components = _mesa_components_in_format(format);
-   const GLint numPixels = width * height * depth;
-   GLubyte *data = (GLubyte *) MALLOC(numPixels * components * sizeof(GLubyte));
-
-#ifdef DEBUG
-   /*
-    * Let's see if anyone finds this.  If glTexImage2D() is called with
-    * a NULL image pointer then load the texture image with something
-    * interesting instead of leaving it indeterminate.
-    */
-   if (data) {
-      static const char message[8][32] = {
-         "   X   X  XXXXX   XXX     X    ",
-         "   XX XX  X      X   X   X X   ",
-         "   X X X  X      X      X   X  ",
-         "   X   X  XXXX    XXX   XXXXX  ",
-         "   X   X  X          X  X   X  ",
-         "   X   X  X      X   X  X   X  ",
-         "   X   X  XXXXX   XXX   X   X  ",
-         "                               "
-      };
-
-      GLubyte *imgPtr = data;
-      GLint h, i, j, k;
-      for (h = 0; h < depth; h++) {
-         for (i = 0; i < height; i++) {
-            GLint srcRow = 7 - (i % 8);
-            for (j = 0; j < width; j++) {
-               GLint srcCol = j % 32;
-               GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;
-               for (k = 0; k < components; k++) {
-                  *imgPtr++ = texel;
-               }
-            }
-         }
-      }
-   }
-#endif
-
-   return data;
-}
-#endif
-
-
-
-/**
- * Reset the fields of a gl_texture_image struct to zero.
- * 
- * \param img texture image structure.
- *
- * This is called when a proxy texture test fails, we set all the
- * image members (except DriverData) to zero.
- * It's also used in glTexImage[123]D as a safeguard to be sure all
- * required fields get initialized properly by the Driver.TexImage[123]D
- * functions.
- */
-static void
-clear_teximage_fields(struct gl_texture_image *img)
-{
-   ASSERT(img);
-   img->_BaseFormat = 0;
-   img->InternalFormat = 0;
-   img->Border = 0;
-   img->Width = 0;
-   img->Height = 0;
-   img->Depth = 0;
-   img->RowStride = 0;
-   if (img->ImageOffsets) {
-      free(img->ImageOffsets);
-      img->ImageOffsets = NULL;
-   }
-   img->Width2 = 0;
-   img->Height2 = 0;
-   img->Depth2 = 0;
-   img->WidthLog2 = 0;
-   img->HeightLog2 = 0;
-   img->DepthLog2 = 0;
-   img->Data = NULL;
-   img->TexFormat = MESA_FORMAT_NONE;
-   img->FetchTexelc = NULL;
-   img->FetchTexelf = NULL;
-}
-
-
-/**
- * Initialize basic fields of the gl_texture_image struct.
- *
- * \param ctx GL context.
- * \param target texture target (GL_TEXTURE_1D, GL_TEXTURE_RECTANGLE, etc).
- * \param img texture image structure to be initialized.
- * \param width image width.
- * \param height image height.
- * \param depth image depth.
- * \param border image border.
- * \param internalFormat internal format.
- * \param format  the actual hardware format (one of MESA_FORMAT_*)
- *
- * Fills in the fields of \p img with the given information.
- * Note: width, height and depth include the border.
- */
-void
-_mesa_init_teximage_fields(struct gl_context *ctx, GLenum target,
-                           struct gl_texture_image *img,
-                           GLsizei width, GLsizei height, GLsizei depth,
-                           GLint border, GLenum internalFormat,
-                           gl_format format)
-{
-   GLint i, dims;
-
-   ASSERT(img);
-   ASSERT(width >= 0);
-   ASSERT(height >= 0);
-   ASSERT(depth >= 0);
-
-   img->_BaseFormat = _mesa_base_tex_format( ctx, internalFormat );
-   ASSERT(img->_BaseFormat > 0);
-   img->InternalFormat = internalFormat;
-   img->Border = border;
-   img->Width = width;
-   img->Height = height;
-   img->Depth = depth;
-
-   img->Width2 = width - 2 * border;   /* == 1 << img->WidthLog2; */
-   img->WidthLog2 = logbase2(img->Width2);
-
-   if (height == 1) { /* 1-D texture */
-      img->Height2 = 1;
-      img->HeightLog2 = 0;
-   }
-   else {
-      img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */
-      img->HeightLog2 = logbase2(img->Height2);
-   }
-
-   if (depth == 1) {  /* 2-D texture */
-      img->Depth2 = 1;
-      img->DepthLog2 = 0;
-   }
-   else {
-      img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */
-      img->DepthLog2 = logbase2(img->Depth2);
-   }
-
-   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
-
-   if ((width == 1 || _mesa_is_pow_two(img->Width2)) &&
-       (height == 1 || _mesa_is_pow_two(img->Height2)) &&
-       (depth == 1 || _mesa_is_pow_two(img->Depth2)))
-      img->_IsPowerOfTwo = GL_TRUE;
-   else
-      img->_IsPowerOfTwo = GL_FALSE;
-
-   /* RowStride and ImageOffsets[] describe how to address texels in 'Data' */
-   img->RowStride = width;
-   /* Allocate the ImageOffsets array and initialize to typical values.
-    * We allocate the array for 1D/2D textures too in order to avoid special-
-    * case code in the texstore routines.
-    */
-   if (img->ImageOffsets)
-      free(img->ImageOffsets);
-   img->ImageOffsets = (GLuint *) malloc(depth * sizeof(GLuint));
-   for (i = 0; i < depth; i++) {
-      img->ImageOffsets[i] = i * width * height;
-   }
-
-   /* Compute Width/Height/DepthScale for mipmap lod computation */
-   if (target == GL_TEXTURE_RECTANGLE_NV) {
-      /* scale = 1.0 since texture coords directly map to texels */
-      img->WidthScale = 1.0;
-      img->HeightScale = 1.0;
-      img->DepthScale = 1.0;
-   }
-   else {
-      img->WidthScale = (GLfloat) img->Width;
-      img->HeightScale = (GLfloat) img->Height;
-      img->DepthScale = (GLfloat) img->Depth;
-   }
-
-   img->TexFormat = format;
-
-   dims = _mesa_get_texture_dimensions(target);
-
-   _mesa_set_fetch_functions(img, dims);
-}
-
-
-/**
- * Free and clear fields of the gl_texture_image struct.
- *
- * \param ctx GL context.
- * \param texImage texture image structure to be cleared.
- *
- * After the call, \p texImage will have no data associated with it.  Its
- * fields are cleared so that its parent object will test incomplete.
- */
-void
-_mesa_clear_texture_image(struct gl_context *ctx,
-                          struct gl_texture_image *texImage)
-{
-   ctx->Driver.FreeTexImageData(ctx, texImage);
-   clear_teximage_fields(texImage);
-}
-
-
-/**
- * This is the fallback for Driver.TestProxyTexImage().  Test the texture
- * level, width, height and depth against the ctx->Const limits for textures.
- *
- * A hardware driver might override this function if, for example, the
- * max 3D texture size is 512x512x64 (i.e. not a cube).
- *
- * Note that width, height, depth == 0 is not an error.  However, a
- * texture with zero width/height/depth will be considered "incomplete"
- * and texturing will effectively be disabled.
- *
- * \param target  one of GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D,
- *                GL_PROXY_TEXTURE_3D, GL_PROXY_TEXTURE_RECTANGLE_NV,
- *                GL_PROXY_TEXTURE_CUBE_MAP_ARB.
- * \param level  as passed to glTexImage
- * \param internalFormat  as passed to glTexImage
- * \param format  as passed to glTexImage
- * \param type  as passed to glTexImage
- * \param width  as passed to glTexImage
- * \param height  as passed to glTexImage
- * \param depth  as passed to glTexImage
- * \param border  as passed to glTexImage
- * \return GL_TRUE if the image is acceptable, GL_FALSE if not acceptable.
- */
-GLboolean
-_mesa_test_proxy_teximage(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint internalFormat, GLenum format, GLenum type,
-                          GLint width, GLint height, GLint depth, GLint border)
-{
-   GLint maxSize;
-
-   (void) internalFormat;
-   (void) format;
-   (void) type;
-
-   switch (target) {
-   case GL_PROXY_TEXTURE_1D:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_2D:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_3D:
-      maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (depth < 2 * border || depth > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.Max3DTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-         if (depth > 0 && !_mesa_is_pow_two(depth - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      maxSize = ctx->Const.MaxTextureRectSize;
-      if (width < 0 || width > maxSize)
-         return GL_FALSE;
-      if (height < 0 || height > maxSize)
-         return GL_FALSE;
-      if (level != 0)
-         return GL_FALSE;
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      maxSize = 1 << (ctx->Const.MaxCubeTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxCubeTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 1 || height > ctx->Const.MaxArrayTextureLayers)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (depth < 1 || depth > ctx->Const.MaxArrayTextureLayers)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   default:
-      _mesa_problem(ctx, "Invalid target in _mesa_test_proxy_teximage");
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if the memory used by the texture would exceed the driver's limit.
- * This lets us support a max 3D texture size of 8K (for example) but
- * prevents allocating a full 8K x 8K x 8K texture.
- * XXX this could be rolled into the proxy texture size test (above) but
- * we don't have the actual texture internal format at that point.
- */
-static GLboolean
-legal_texture_size(struct gl_context *ctx, gl_format format,
-                   GLint width, GLint height, GLint depth)
-{
-   uint64_t bytes = _mesa_format_image_size64(format, width, height, depth);
-   uint64_t mbytes = bytes / (1024 * 1024); /* convert to MB */
-   return mbytes <= (uint64_t) ctx->Const.MaxTextureMbytes;
-}
-
-
-
-/**
- * Helper function to determine whether a target and specific compression
- * format are supported.
- */
-static GLboolean
-target_can_be_compressed(const struct gl_context *ctx, GLenum target,
-                         GLenum intFormat)
-{
-   (void) intFormat;  /* not used yet */
-
-   switch (target) {
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return GL_TRUE; /* true for any compressed format so far */
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-      return ctx->Extensions.ARB_texture_cube_map;
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      return (ctx->Extensions.MESA_texture_array ||
-              ctx->Extensions.EXT_texture_array);
-   default:
-      return GL_FALSE;
-   }      
-}
-
-
-/**
- * Check if the given texture target value is legal for a
- * glTexImage1/2/3D call.
- */
-static GLboolean
-legal_teximage_target(struct gl_context *ctx, GLuint dims, GLenum target)
-{
-   switch (dims) {
-   case 1:
-      switch (target) {
-      case GL_TEXTURE_1D:
-      case GL_PROXY_TEXTURE_1D:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-      }
-   case 2:
-      switch (target) {
-      case GL_TEXTURE_2D:
-      case GL_PROXY_TEXTURE_2D:
-         return GL_TRUE;
-      case GL_PROXY_TEXTURE_CUBE_MAP:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-         return ctx->Extensions.ARB_texture_cube_map;
-      case GL_TEXTURE_RECTANGLE_NV:
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   case 3:
-      switch (target) {
-      case GL_TEXTURE_3D:
-      case GL_PROXY_TEXTURE_3D:
-         return GL_TRUE;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   default:
-      _mesa_problem(ctx, "invalid dims=%u in legal_teximage_target()", dims);
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if the given texture target value is legal for a
- * glTexSubImage, glCopyTexSubImage or glCopyTexImage call.
- * The difference compared to legal_teximage_target() above is that
- * proxy targets are not supported.
- */
-static GLboolean
-legal_texsubimage_target(struct gl_context *ctx, GLuint dims, GLenum target)
-{
-   switch (dims) {
-   case 1:
-      return target == GL_TEXTURE_1D;
-   case 2:
-      switch (target) {
-      case GL_TEXTURE_2D:
-         return GL_TRUE;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-         return ctx->Extensions.ARB_texture_cube_map;
-      case GL_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   case 3:
-      switch (target) {
-      case GL_TEXTURE_3D:
-         return GL_TRUE;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   default:
-      _mesa_problem(ctx, "invalid dims=%u in legal_texsubimage_target()",
-                    dims);
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Test the glTexImage[123]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param internalFormat internal format given by the user.
- * \param format pixel data format given by the user.
- * \param type pixel data type given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param depth image depth given by the user.
- * \param border image border given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- *
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-texture_error_check( struct gl_context *ctx,
-                     GLuint dimensions, GLenum target,
-                     GLint level, GLint internalFormat,
-                     GLenum format, GLenum type,
-                     GLint width, GLint height,
-                     GLint depth, GLint border )
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLboolean isProxy = target == proxyTarget;
-   GLboolean sizeOK = GL_TRUE;
-   GLboolean colorFormat, indexFormat;
-
-   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(level=%d)", dimensions, level);
-      }
-      return GL_TRUE;
-   }
-
-   /* Check border */
-   if (border < 0 || border > 1 ||
-       ((target == GL_TEXTURE_RECTANGLE_NV ||
-         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(border=%d)", dimensions, border);
-      }
-      return GL_TRUE;
-   }
-
-   if (width < 0 || height < 0 || depth < 0) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(width, height or depth < 0)", dimensions);
-      }
-      return GL_TRUE;
-   }
-
-   /* Do this simple check before calling the TestProxyTexImage() function */
-   if (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
-      sizeOK = (width == height);
-   }
-
-   /*
-    * Use the proxy texture driver hook to see if the size/level/etc are
-    * legal.
-    */
-   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                                    internalFormat, format,
-                                                    type, width, height,
-                                                    depth, border);
-   if (!sizeOK) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(level=%d, width=%d, height=%d, depth=%d)",
-                     dimensions, level, width, height, depth);
-      }
-      return GL_TRUE;
-   }
-
-   /* Check internalFormat */
-   if (_mesa_base_tex_format(ctx, internalFormat) < 0) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(internalFormat=%s)",
-                     dimensions, _mesa_lookup_enum_by_nr(internalFormat));
-      }
-      return GL_TRUE;
-   }
-
-   /* Check incoming image format and type */
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      /* Normally, GL_INVALID_OPERATION is generated by a format/type
-       * mismatch (see the 1.2 spec page 94, sec 3.6.4.).  But with the
-       * GL_EXT_texture_integer extension, some combinations should generate
-       * GL_INVALID_ENUM instead (grr!).
-       */
-      if (!isProxy) {
-         GLenum error = _mesa_is_integer_format(format)
-            ? GL_INVALID_ENUM : GL_INVALID_OPERATION;
-         _mesa_error(ctx, error,
-                     "glTexImage%dD(incompatible format 0x%x, type 0x%x)",
-                     dimensions, format, type);
-      }
-      return GL_TRUE;
-   }
-
-   /* make sure internal format and format basically agree */
-   colorFormat = _mesa_is_color_format(format);
-   indexFormat = _mesa_is_index_format(format);
-   if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) ||
-       (_mesa_is_index_format(internalFormat) && !indexFormat) ||
-       (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) ||
-       (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) ||
-       (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) ||
-       (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) {
-      if (!isProxy)
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)",
-                     dimensions, internalFormat, format);
-      return GL_TRUE;
-   }
-
-   /* additional checks for ycbcr textures */
-   if (internalFormat == GL_YCBCR_MESA) {
-      ASSERT(ctx->Extensions.MESA_ycbcr_texture);
-      if (type != GL_UNSIGNED_SHORT_8_8_MESA &&
-          type != GL_UNSIGNED_SHORT_8_8_REV_MESA) {
-         char message[100];
-         _mesa_snprintf(message, sizeof(message),
-                        "glTexImage%dD(format/type YCBCR mismatch", dimensions);
-         _mesa_error(ctx, GL_INVALID_ENUM, "%s", message);
-         return GL_TRUE; /* error */
-      }
-      if (target != GL_TEXTURE_2D &&
-          target != GL_PROXY_TEXTURE_2D &&
-          target != GL_TEXTURE_RECTANGLE_NV &&
-          target != GL_PROXY_TEXTURE_RECTANGLE_NV) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         if (!isProxy) {
-            char message[100];
-            _mesa_snprintf(message, sizeof(message),
-                           "glTexImage%dD(format=GL_YCBCR_MESA and border=%d)",
-                           dimensions, border);
-            _mesa_error(ctx, GL_INVALID_VALUE, "%s", message);
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for depth textures */
-   if (_mesa_base_tex_format(ctx, internalFormat) == GL_DEPTH_COMPONENT) {
-      /* Only 1D, 2D and rectangular textures supported, not 3D or cubes */
-      if (target != GL_TEXTURE_1D &&
-          target != GL_PROXY_TEXTURE_1D &&
-          target != GL_TEXTURE_2D &&
-          target != GL_PROXY_TEXTURE_2D &&
-          target != GL_TEXTURE_RECTANGLE_ARB &&
-          target != GL_PROXY_TEXTURE_RECTANGLE_ARB) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexImage(target/internalFormat)");
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for compressed textures */
-   if (_mesa_is_compressed_format(ctx, internalFormat)) {
-      if (!target_can_be_compressed(ctx, target, internalFormat)) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexImage%dD(target)", dimensions);
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         if (!isProxy) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glTexImage%dD(border!=0)", dimensions);
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for integer textures */
-   if (ctx->Extensions.EXT_texture_integer &&
-       (_mesa_is_integer_format(format) !=
-        _mesa_is_integer_format(internalFormat))) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage%dD(integer/non-integer format mismatch)",
-                     dimensions);
-      }
-      return GL_TRUE;
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/**
- * Test glTexSubImage[123]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param xoffset sub-image x offset given by the user.
- * \param yoffset sub-image y offset given by the user.
- * \param zoffset sub-image z offset given by the user.
- * \param format pixel data format given by the user.
- * \param type pixel data type given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param depth image depth given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- *
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-subtexture_error_check( struct gl_context *ctx, GLuint dimensions,
-                        GLenum target, GLint level,
-                        GLint xoffset, GLint yoffset, GLint zoffset,
-                        GLint width, GLint height, GLint depth,
-                        GLenum format, GLenum type )
-{
-   /* Basic level check */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level=%d)", level);
-      return GL_TRUE;
-   }
-
-   /* Check for negative sizes */
-   if (width < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(width=%d)", dimensions, width);
-      return GL_TRUE;
-   }
-   if (height < 0 && dimensions > 1) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(height=%d)", dimensions, height);
-      return GL_TRUE;
-   }
-   if (depth < 0 && dimensions > 2) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(depth=%d)", dimensions, depth);
-      return GL_TRUE;
-   }
-
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      /* As with the glTexImage2D check above, the error code here
-       * depends on texture integer.
-       */
-      GLenum error = _mesa_is_integer_format(format)
-         ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
-      _mesa_error(ctx, error,
-                  "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)",
-                  dimensions, format, type);
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Do second part of glTexSubImage which depends on the destination texture.
- * \return GL_TRUE if error recorded, GL_FALSE otherwise
- */
-static GLboolean
-subtexture_error_check2( struct gl_context *ctx, GLuint dimensions,
-			 GLenum target, GLint level,
-			 GLint xoffset, GLint yoffset, GLint zoffset,
-			 GLint width, GLint height, GLint depth,
-			 GLenum format, GLenum type,
-			 const struct gl_texture_image *destTex )
-{
-   if (!destTex) {
-      /* undefined image level */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage%dD", dimensions);
-      return GL_TRUE;
-   }
-
-   if (xoffset < -((GLint)destTex->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset)",
-                  dimensions);
-      return GL_TRUE;
-   }
-   if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset+width)",
-                  dimensions);
-      return GL_TRUE;
-   }
-   if (dimensions > 1) {
-      if (yoffset < -((GLint)destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset)",
-                     dimensions);
-         return GL_TRUE;
-      }
-      if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset+height)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-   if (dimensions > 2) {
-      if (zoffset < -((GLint)destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
-         return GL_TRUE;
-      }
-      if (zoffset + depth  > (GLint) (destTex->Depth + destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
-         return GL_TRUE;
-      }
-   }
-
-   if (_mesa_is_format_compressed(destTex->TexFormat)) {
-      GLuint bw, bh;
-
-      /* do tests which depend on compression block size */
-      _mesa_get_format_block_size(destTex->TexFormat, &bw, &bh);
-
-      /* offset must be multiple of block size */
-      if ((xoffset % bw != 0) || (yoffset % bh != 0)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(xoffset = %d, yoffset = %d)",
-                     dimensions, xoffset, yoffset);
-         return GL_TRUE;
-      }
-      /* size must be multiple of bw by bh or equal to whole texture size */
-      if ((width % bw != 0) && (GLuint) width != destTex->Width) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(width = %d)", dimensions, width);
-         return GL_TRUE;
-      }         
-      if ((height % bh != 0) && (GLuint) height != destTex->Height) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(height = %d)", dimensions, height);
-         return GL_TRUE;
-      }         
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Test glCopyTexImage[12]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param internalFormat internal format given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param border texture border.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- * 
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
-                         GLenum target, GLint level, GLint internalFormat,
-                         GLint width, GLint height, GLint border )
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLenum type = GL_FLOAT;
-   GLboolean sizeOK;
-   GLint format;
-
-   /* check target */
-   if (!legal_texsubimage_target(ctx, dimensions, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexImage%uD(target=%s)",
-                  dimensions, _mesa_lookup_enum_by_nr(target));
-      return GL_TRUE;
-   }       
-
-   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexImage%dD(level=%d)", dimensions, level);
-      return GL_TRUE;
-   }
-
-   /* Check that the source buffer is complete */
-   if (ctx->ReadBuffer->Name) {
-      if (ctx->ReadBuffer->_Status == 0) {
-         _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
-      }
-      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* Check border */
-   if (border < 0 || border > 1 ||
-       ((target == GL_TEXTURE_RECTANGLE_NV ||
-         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {
-      return GL_TRUE;
-   }
-
-   format = _mesa_base_tex_format(ctx, internalFormat);
-   if (format < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexImage%dD(internalFormat)", dimensions);
-      return GL_TRUE;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, format)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexImage%dD(missing readbuffer)", dimensions);
-      return GL_TRUE;
-   }
-
-   /* Do size, level checking */
-   sizeOK = (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB)
-      ? (width == height) : 1;
-
-   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                                    internalFormat, format,
-                                                    type, width, height,
-                                                    1, border);
-
-   if (!sizeOK) {
-      if (dimensions == 1) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexImage1D(width=%d)", width);
-      }
-      else {
-         ASSERT(dimensions == 2);
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexImage2D(width=%d, height=%d)", width, height);
-      }
-      return GL_TRUE;
-   }
-
-   if (_mesa_is_compressed_format(ctx, internalFormat)) {
-      if (!target_can_be_compressed(ctx, target, internalFormat)) {
-         _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glCopyTexImage%dD(target)", dimensions);
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(border!=0)", dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depth_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth)", dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depthstencil_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth/stencil buffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/**
- * Test glCopyTexSubImage[12]D() parameters for errors.
- * Note that this is the first part of error checking.
- * See also copytexsubimage_error_check2() below for the second part.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- */
-static GLboolean
-copytexsubimage_error_check1( struct gl_context *ctx, GLuint dimensions,
-                              GLenum target, GLint level)
-{
-   /* Check that the source buffer is complete */
-   if (ctx->ReadBuffer->Name) {
-      if (ctx->ReadBuffer->_Status == 0) {
-         _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
-      }
-      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* check target (proxies not allowed) */
-   if (!legal_texsubimage_target(ctx, dimensions, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexSubImage%uD(target=%s)",
-                  dimensions, _mesa_lookup_enum_by_nr(target));
-      return GL_TRUE;
-   }
-
-   /* Check level */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(level=%d)", dimensions, level);
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Second part of error checking for glCopyTexSubImage[12]D().
- * \param xoffset sub-image x offset given by the user.
- * \param yoffset sub-image y offset given by the user.
- * \param zoffset sub-image z offset given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- */
-static GLboolean
-copytexsubimage_error_check2( struct gl_context *ctx, GLuint dimensions,
-			      GLenum target, GLint level,
-			      GLint xoffset, GLint yoffset, GLint zoffset,
-			      GLsizei width, GLsizei height,
-			      const struct gl_texture_image *teximage )
-{
-   /* check that dest tex image exists */
-   if (!teximage) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(undefined texture level: %d)",
-                  dimensions, level);
-      return GL_TRUE;
-   }
-
-   /* Check size */
-   if (width < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(width=%d)", dimensions, width);
-      return GL_TRUE;
-   }
-   if (dimensions > 1 && height < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(height=%d)", dimensions, height);
-      return GL_TRUE;
-   }
-
-   /* check x/y offsets */
-   if (xoffset < -((GLint)teximage->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);
-      return GL_TRUE;
-   }
-   if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(xoffset+width)", dimensions);
-      return GL_TRUE;
-   }
-   if (dimensions > 1) {
-      if (yoffset < -((GLint)teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);
-         return GL_TRUE;
-      }
-      /* NOTE: we're adding the border here, not subtracting! */
-      if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(yoffset+height)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* check z offset */
-   if (dimensions > 2) {
-      if (zoffset < -((GLint)teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(zoffset)", dimensions);
-         return GL_TRUE;
-      }
-      if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(zoffset+depth)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   if (_mesa_is_format_compressed(teximage->TexFormat)) {
-      /* offset must be multiple of 4 */
-      if ((xoffset & 3) || (yoffset & 3)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(xoffset or yoffset)", dimensions);
-         return GL_TRUE;
-      }
-      /* size must be multiple of 4 */
-      if ((width & 3) != 0 && (GLuint) width != teximage->Width) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(width)", dimensions);
-         return GL_TRUE;
-      }         
-      if ((height & 3) != 0 && (GLuint) height != teximage->Height) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(height)", dimensions);
-         return GL_TRUE;
-      }         
-   }
-
-   if (teximage->InternalFormat == GL_YCBCR_MESA) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");
-      return GL_TRUE;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, teximage->_BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(missing readbuffer, format=0x%x)",
-                  dimensions, teximage->_BaseFormat);
-      return GL_TRUE;
-   }
-
-   if (teximage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (teximage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth/stencil buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* If copying into an integer texture, the source buffer must also be
-    * integer-valued.
-    */
-   if (_mesa_is_format_integer_color(teximage->TexFormat)) {
-      struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-      if (!_mesa_is_format_integer_color(rb->Format)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(source buffer is not integer format)",
-                  dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/** Callback info for walking over FBO hash table */
-struct cb_info
-{
-   struct gl_context *ctx;
-   struct gl_texture_object *texObj;
-   GLuint level, face;
-};
-
-
-/**
- * Check render to texture callback.  Called from _mesa_HashWalk().
- */
-static void
-check_rtt_cb(GLuint key, void *data, void *userData)
-{
-   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
-   const struct cb_info *info = (struct cb_info *) userData;
-   struct gl_context *ctx = info->ctx;
-   const struct gl_texture_object *texObj = info->texObj;
-   const GLuint level = info->level, face = info->face;
-
-   /* If this is a user-created FBO */
-   if (fb->Name) {
-      GLuint i;
-      /* check if any of the FBO's attachments point to 'texObj' */
-      for (i = 0; i < BUFFER_COUNT; i++) {
-         struct gl_renderbuffer_attachment *att = fb->Attachment + i;
-         if (att->Type == GL_TEXTURE &&
-             att->Texture == texObj &&
-             att->TextureLevel == level &&
-             att->CubeMapFace == face) {
-            ASSERT(att->Texture->Image[att->CubeMapFace][att->TextureLevel]);
-            /* Tell driver about the new renderbuffer texture */
-            ctx->Driver.RenderTexture(ctx, ctx->DrawBuffer, att);
-            /* Mark fb status as indeterminate to force re-validation */
-            fb->_Status = 0;
-         }
-      }
-   }
-}
-
-
-/**
- * When a texture image is specified we have to check if it's bound to
- * any framebuffer objects (render to texture) in order to detect changes
- * in size or format since that effects FBO completeness.
- * Any FBOs rendering into the texture must be re-validated.
- */
-static void
-update_fbo_texture(struct gl_context *ctx, struct gl_texture_object *texObj,
-                   GLuint face, GLuint level)
-{
-   /* Only check this texture if it's been marked as RenderToTexture */
-   if (texObj->_RenderToTexture) {
-      struct cb_info info;
-      info.ctx = ctx;
-      info.texObj = texObj;
-      info.level = level;
-      info.face = face;
-      _mesa_HashWalk(ctx->Shared->FrameBuffers, check_rtt_cb, &info);
-   }
-}
-
-
-/**
- * If the texture object's GenerateMipmap flag is set and we've
- * changed the texture base level image, regenerate the rest of the
- * mipmap levels now.
- */
-static INLINE void
-check_gen_mipmap(struct gl_context *ctx, GLenum target,
-                 struct gl_texture_object *texObj, GLint level)
-{
-   ASSERT(target != GL_TEXTURE_CUBE_MAP);
-   if (texObj->GenerateMipmap &&
-       level == texObj->BaseLevel &&
-       level < texObj->MaxLevel) {
-      ASSERT(ctx->Driver.GenerateMipmap);
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/** Debug helper: override the user-requested internal format */
-static GLenum
-override_internal_format(GLenum internalFormat, GLint width, GLint height)
-{
-#if 0
-   if (internalFormat == GL_RGBA16F_ARB ||
-       internalFormat == GL_RGBA32F_ARB) {
-      printf("Convert rgba float tex to int %d x %d\n", width, height);
-      return GL_RGBA;
-   }
-   else if (internalFormat == GL_RGB16F_ARB ||
-            internalFormat == GL_RGB32F_ARB) {
-      printf("Convert rgb float tex to int %d x %d\n", width, height);
-      return GL_RGB;
-   }
-   else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB ||
-            internalFormat == GL_LUMINANCE_ALPHA32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_LUMINANCE_ALPHA;
-   }
-   else if (internalFormat == GL_LUMINANCE16F_ARB ||
-            internalFormat == GL_LUMINANCE32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_LUMINANCE;
-   }
-   else if (internalFormat == GL_ALPHA16F_ARB ||
-            internalFormat == GL_ALPHA32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_ALPHA;
-   }
-   /*
-   else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {
-      internalFormat = GL_RGBA;
-   }
-   */
-   else {
-      return internalFormat;
-   }
-#else
-   return internalFormat;
-#endif
-}
-
-
-/**
- * Choose the actual hardware format for a texture image.
- * Try to use the same format as the previous image level when possible.
- * Otherwise, ask the driver for the best format.
- * It's important to try to choose a consistant format for all levels
- * for efficient texture memory layout/allocation.  In particular, this
- * comes up during automatic mipmap generation.
- */
-gl_format
-_mesa_choose_texture_format(struct gl_context *ctx,
-                            struct gl_texture_object *texObj,
-                            GLenum target, GLint level,
-                            GLenum internalFormat, GLenum format, GLenum type)
-{
-   gl_format f;
-
-   /* see if we've already chosen a format for the previous level */
-   if (level > 0) {
-      struct gl_texture_image *prevImage =
-	 _mesa_select_tex_image(ctx, texObj, target, level - 1);
-      /* See if the prev level is defined and has an internal format which
-       * matches the new internal format.
-       */
-      if (prevImage &&
-          prevImage->Width > 0 &&
-          prevImage->InternalFormat == internalFormat) {
-         /* use the same format */
-         ASSERT(prevImage->TexFormat != MESA_FORMAT_NONE);
-         return prevImage->TexFormat;
-      }
-   }
-
-   /* choose format from scratch */
-   f = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
-   ASSERT(f != MESA_FORMAT_NONE);
-   return f;
-}
-
-
-/**
- * Common code to implement all the glTexImage1D/2D/3D functions.
- */
-static void
-teximage(struct gl_context *ctx, GLuint dims,
-         GLenum target, GLint level, GLint internalFormat,
-         GLsizei width, GLsizei height, GLsizei depth,
-         GLint border, GLenum format, GLenum type,
-         const GLvoid *pixels)
-{
-   GLboolean error;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glTexImage%uD %s %d %s %d %d %d %d %s %s %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  width, height, depth, border,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type), pixels);
-
-   internalFormat = override_internal_format(internalFormat, width, height);
-
-   /* target error checking */
-   if (!legal_teximage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }
-
-   /* general error checking */
-   error = texture_error_check(ctx, dims, target, level, internalFormat,
-                               format, type, width, height, depth, border);
-
-   if (_mesa_is_proxy_texture(target)) {
-      /* Proxy texture: just clear or set state depending on error checking */
-      struct gl_texture_image *texImage =
-         _mesa_get_proxy_tex_image(ctx, target, level);
-
-      if (error) {
-         /* when error, clear all proxy texture image parameters */
-         if (texImage)
-            clear_teximage_fields(texImage);
-      }
-      else {
-         /* no error, set the tex image parameters */
-         struct gl_texture_object *texObj =
-            _mesa_get_current_tex_object(ctx, target);
-         gl_format texFormat = _mesa_choose_texture_format(ctx, texObj,
-                                                           target, level,
-                                                           internalFormat,
-                                                           format, type);
-
-         if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height,
-                                       depth, border, internalFormat,
-                                       texFormat);
-         }
-         else if (texImage) {
-            clear_teximage_fields(texImage);
-         }
-      }
-   }
-   else {
-      /* non-proxy target */
-      const GLuint face = _mesa_tex_target_to_face(target);
-      struct gl_texture_object *texObj;
-      struct gl_texture_image *texImage;
-
-      if (error) {
-         return;   /* error was recorded */
-      }
-
-      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-	 _mesa_update_state(ctx);
-
-      texObj = _mesa_get_current_tex_object(ctx, target);
-
-      _mesa_lock_texture(ctx, texObj);
-      {
-	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-
-	 if (!texImage) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
-	 }
-         else {
-            gl_format texFormat;
-
-            if (texImage->Data) {
-               ctx->Driver.FreeTexImageData( ctx, texImage );
-            }
-
-            ASSERT(texImage->Data == NULL);
-            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                    internalFormat, format,
-                                                    type);
-
-            if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-               _mesa_init_teximage_fields(ctx, target, texImage,
-                                          width, height, depth,
-                                          border, internalFormat, texFormat);
-
-               /* Give the texture to the driver.  <pixels> may be null. */
-               ASSERT(ctx->Driver.TexImage3D);
-               switch (dims) {
-               case 1:
-                  ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                                         width, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               case 2:
-                  ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                                         width, height, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               case 3:
-                  ctx->Driver.TexImage3D(ctx, target, level, internalFormat,
-                                         width, height, depth, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               default:
-                  _mesa_problem(ctx, "invalid dims=%u in teximage()", dims);
-               }
-
-               check_gen_mipmap(ctx, target, texObj, level);
-
-               update_fbo_texture(ctx, texObj, face, level);
-
-               /* state update */
-               texObj->_Complete = GL_FALSE;
-               ctx->NewState |= _NEW_TEXTURE;
-            }
-            else {
-               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
-            }
-         }
-      }
-      _mesa_unlock_texture(ctx, texObj);
-   }
-}
-
-
-/*
- * Called from the API.  Note that width includes the border.
- */
-void GLAPIENTRY
-_mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLint border, GLenum format,
-                  GLenum type, const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 1, target, level, internalFormat, width, 1, 1,
-            border, format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLsizei height, GLint border,
-                  GLenum format, GLenum type,
-                  const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 2, target, level, internalFormat, width, height, 1,
-            border, format, type, pixels);
-}
-
-
-/*
- * Called by the API or display list executor.
- * Note that width and height include the border.
- */
-void GLAPIENTRY
-_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLsizei height, GLsizei depth,
-                  GLint border, GLenum format, GLenum type,
-                  const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 3, target, level, internalFormat, width, height, depth,
-            border, format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalFormat,
-                     GLsizei width, GLsizei height, GLsizei depth,
-                     GLint border, GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,
-                    depth, border, format, type, pixels);
-}
-
-
-#if FEATURE_OES_EGL_image
-void GLAPIENTRY
-_mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (!ctx->Extensions.OES_EGL_image) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glEGLImageTargetTexture2DOES(unsupported)");
-      return;
-   }
-
-   if (target != GL_TEXTURE_2D) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-		  "glEGLImageTargetTexture2D(target=%d)", target);
-      return;
-   }
-
-   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_state(ctx);
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   _mesa_lock_texture(ctx, texObj);
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, 0);
-   if (!texImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEGLImageTargetTexture2D");
-   } else {
-      if (texImage->Data)
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-
-      ASSERT(texImage->Data == NULL);
-      ctx->Driver.EGLImageTargetTexture2D(ctx, target,
-					  texObj, texImage, image);
-
-      /* state update */
-      texObj->_Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
-   }
-   _mesa_unlock_texture(ctx, texObj);
-
-}
-#endif
-
-
-
-/**
- * Implement all the glTexSubImage1/2/3D() functions.
- */
-static void
-texsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,
-            GLint xoffset, GLint yoffset, GLint zoffset,
-            GLsizei width, GLsizei height, GLsizei depth,
-            GLenum format, GLenum type, const GLvoid *pixels )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glTexSubImage%uD %s %d %d %d %d %d %d %d %s %s %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  xoffset, yoffset, zoffset, width, height, depth,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type), pixels);
-
-   /* check target (proxies not allowed) */
-   if (!legal_texsubimage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }       
-
-   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_state(ctx);
-
-   if (subtexture_error_check(ctx, dims, target, level, xoffset, yoffset, zoffset,
-                              width, height, depth, format, type)) {
-      return;   /* error was detected */
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-      if (subtexture_error_check2(ctx, dims, target, level,
-                                  xoffset, yoffset, zoffset,
-				  width, height, depth,
-                                  format, type, texImage)) {
-         /* error was recorded */
-      }
-      else if (width > 0 && height > 0 && height > 0) {
-         /* If we have a border, offset=-1 is legal.  Bias by border width. */
-         switch (dims) {
-         case 3:
-            zoffset += texImage->Border;
-            /* fall-through */
-         case 2:
-            yoffset += texImage->Border;
-            /* fall-through */
-         case 1:
-            xoffset += texImage->Border;
-         }
-
-         switch (dims) {
-         case 1:
-            ctx->Driver.TexSubImage1D(ctx, target, level,
-                                      xoffset, width,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         case 2:
-            ctx->Driver.TexSubImage2D(ctx, target, level,
-                                      xoffset, yoffset, width, height,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         case 3:
-            ctx->Driver.TexSubImage3D(ctx, target, level,
-                                      xoffset, yoffset, zoffset,
-                                      width, height, depth,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         default:
-            _mesa_problem(ctx, "unexpected dims in subteximage()");
-         }
-
-         check_gen_mipmap(ctx, target, texObj, level);
-
-         ctx->NewState |= _NEW_TEXTURE;
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_TexSubImage1D( GLenum target, GLint level,
-                     GLint xoffset, GLsizei width,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 1, target, level,
-               xoffset, 0, 0,
-               width, 1, 1,
-               format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexSubImage2D( GLenum target, GLint level,
-                     GLint xoffset, GLint yoffset,
-                     GLsizei width, GLsizei height,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 2, target, level,
-               xoffset, yoffset, 0,
-               width, height, 1,
-               format, type, pixels);
-}
-
-
-
-void GLAPIENTRY
-_mesa_TexSubImage3D( GLenum target, GLint level,
-                     GLint xoffset, GLint yoffset, GLint zoffset,
-                     GLsizei width, GLsizei height, GLsizei depth,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 3, target, level,
-               xoffset, yoffset, zoffset,
-               width, height, depth,
-               format, type, pixels);
-}
-
-
-
-/**
- * Implement the glCopyTexImage1/2D() functions.
- */
-static void
-copyteximage(struct gl_context *ctx, GLuint dims,
-             GLenum target, GLint level, GLenum internalFormat,
-             GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glCopyTexImage%uD %s %d %s %d %d %d %d %d\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  x, y, width, height, border);
-
-   if (ctx->NewState & NEW_COPY_TEX_STATE)
-      _mesa_update_state(ctx);
-
-   if (copytexture_error_check(ctx, dims, target, level, internalFormat,
-                               width, height, border))
-      return;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-
-      if (!texImage) {
-	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
-      }
-      else {
-         gl_format texFormat;
-
-         if (texImage->Data) {
-            ctx->Driver.FreeTexImageData( ctx, texImage );
-         }
-
-         ASSERT(texImage->Data == NULL);
-
-         texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                 internalFormat, GL_NONE,
-                                                 GL_NONE);
-
-         if (legal_texture_size(ctx, texFormat, width, height, 1)) {
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
-                                       border, internalFormat, texFormat);
-
-            ASSERT(ctx->Driver.CopyTexImage2D);
-            if (dims == 1)
-               ctx->Driver.CopyTexImage1D(ctx, target, level, internalFormat,
-                                          x, y, width, border);
-            else
-               ctx->Driver.CopyTexImage2D(ctx, target, level, internalFormat,
-                                          x, y, width, height, border);
-
-            check_gen_mipmap(ctx, target, texObj, level);
-
-            update_fbo_texture(ctx, texObj, face, level);
-
-            /* state update */
-            texObj->_Complete = GL_FALSE;
-            ctx->NewState |= _NEW_TEXTURE;
-         }
-         else {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
-         }
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexImage1D( GLenum target, GLint level,
-                      GLenum internalFormat,
-                      GLint x, GLint y,
-                      GLsizei width, GLint border )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copyteximage(ctx, 1, target, level, internalFormat, x, y, width, 1, border);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
-                      GLint x, GLint y, GLsizei width, GLsizei height,
-                      GLint border )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copyteximage(ctx, 2, target, level, internalFormat,
-                x, y, width, height, border);
-}
-
-
-
-/**
- * Implementation for glCopyTexSubImage1/2/3D() functions.
- */
-static void
-copytexsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,
-                GLint xoffset, GLint yoffset, GLint zoffset,
-                GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glCopyTexSubImage%uD %s %d %d %d %d %d %d %d %d\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target),
-                  level, xoffset, yoffset, zoffset, x, y, width, height);
-
-   if (ctx->NewState & NEW_COPY_TEX_STATE)
-      _mesa_update_state(ctx);
-
-   if (copytexsubimage_error_check1(ctx, dims, target, level))
-      return;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-      if (copytexsubimage_error_check2(ctx, dims, target, level, xoffset, yoffset,
-				       zoffset, width, height, texImage)) {
-         /* error was recored */
-      }
-      else {
-         /* If we have a border, offset=-1 is legal.  Bias by border width. */
-         switch (dims) {
-         case 3:
-            zoffset += texImage->Border;
-            /* fall-through */
-         case 2:
-            yoffset += texImage->Border;
-            /* fall-through */
-         case 1:
-            xoffset += texImage->Border;
-         }
-
-         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
-                                        &width, &height)) {
-            switch (dims) {
-            case 1:
-               ctx->Driver.CopyTexSubImage1D(ctx, target, level,
-                                             xoffset, x, y, width);
-               break;
-            case 2:
-               ctx->Driver.CopyTexSubImage2D(ctx, target, level,
-                                             xoffset, yoffset,
-                                             x, y, width, height);
-               break;
-            case 3:
-               ctx->Driver.CopyTexSubImage3D(ctx, target, level,
-                                             xoffset, yoffset, zoffset,
-                                             x, y, width, height);
-               break;
-            default:
-               _mesa_problem(ctx, "bad dims in copytexsubimage()");
-            }
-
-            check_gen_mipmap(ctx, target, texObj, level);
-
-            ctx->NewState |= _NEW_TEXTURE;
-         }
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage1D( GLenum target, GLint level,
-                         GLint xoffset, GLint x, GLint y, GLsizei width )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 1, target, level, xoffset, 0, 0, x, y, width, 1);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage2D( GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset,
-                         GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 2, target, level, xoffset, yoffset, 0, x, y,
-                   width, height);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage3D( GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset, GLint zoffset,
-                         GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 3, target, level, xoffset, yoffset, zoffset,
-                   x, y, width, height);
-}
-
-
-
-
-/**********************************************************************/
-/******                   Compressed Textures                    ******/
-/**********************************************************************/
-
-
-/**
- * Return expected size of a compressed texture.
- */
-static GLuint
-compressed_tex_size(GLsizei width, GLsizei height, GLsizei depth,
-                    GLenum glformat)
-{
-   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);
-   return _mesa_format_image_size(mesaFormat, width, height, depth);
-}
-
-
-/*
- * Return compressed texture block size, in pixels.
- */
-static void
-get_compressed_block_size(GLenum glformat, GLuint *bw, GLuint *bh)
-{
-   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);
-   _mesa_get_format_block_size(mesaFormat, bw, bh);
-}
-
-
-/**
- * Error checking for glCompressedTexImage[123]D().
- * \return error code or GL_NO_ERROR.
- */
-static GLenum
-compressed_texture_error_check(struct gl_context *ctx, GLint dimensions,
-                               GLenum target, GLint level,
-                               GLenum internalFormat, GLsizei width,
-                               GLsizei height, GLsizei depth, GLint border,
-                               GLsizei imageSize)
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);
-   GLint expectedSize;
-
-   /* check level */
-   if (level < 0 || level >= maxLevels)
-      return GL_INVALID_VALUE;
-
-   if (!target_can_be_compressed(ctx, target, internalFormat)) {
-      return GL_INVALID_ENUM;
-   }
-
-   /* This will detect any invalid internalFormat value */
-   if (!_mesa_is_compressed_format(ctx, internalFormat))
-      return GL_INVALID_ENUM;
-
-   /* This should really never fail */
-   if (_mesa_base_tex_format(ctx, internalFormat) < 0)
-      return GL_INVALID_ENUM;
-
-   /* No compressed formats support borders at this time */
-   if (border != 0)
-      return GL_INVALID_VALUE;
-
-   /* For cube map, width must equal height */
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height)
-      return GL_INVALID_VALUE;
-
-   /* check image size against compression block size */
-   {
-      gl_format texFormat =
-         ctx->Driver.ChooseTextureFormat(ctx, internalFormat,
-                                         GL_NONE, GL_NONE);
-      GLuint bw, bh;
-
-      _mesa_get_format_block_size(texFormat, &bw, &bh);
-      if ((width > bw && width % bw > 0) ||
-          (height > bh && height % bh > 0)) {
-         /*
-          * Per GL_ARB_texture_compression:  GL_INVALID_OPERATION is
-          * generated [...] if any parameter combinations are not
-          * supported by the specific compressed internal format. 
-          */
-         return GL_INVALID_OPERATION;
-      }
-   }
-
-   /* check image sizes */
-   if (!ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                      internalFormat, GL_NONE, GL_NONE,
-                                      width, height, depth, border)) {
-      /* See error comment above */
-      return GL_INVALID_OPERATION;
-   }
-
-   /* check image size in bytes */
-   expectedSize = compressed_tex_size(width, height, depth, internalFormat);
-   if (expectedSize != imageSize) {
-      /* Per GL_ARB_texture_compression:  GL_INVALID_VALUE is generated [...]
-       * if <imageSize> is not consistent with the format, dimensions, and
-       * contents of the specified image.
-       */
-      return GL_INVALID_VALUE;
-   }
-
-   return GL_NO_ERROR;
-}
-
-
-/**
- * Error checking for glCompressedTexSubImage[123]D().
- * \warning  There are some bad assumptions here about the size of compressed
- *           texture tiles (multiple of 4) used to test the validity of the
- *           offset and size parameters.
- * \return error code or GL_NO_ERROR.
- */
-static GLenum
-compressed_subtexture_error_check(struct gl_context *ctx, GLint dimensions,
-                                  GLenum target, GLint level,
-                                  GLint xoffset, GLint yoffset, GLint zoffset,
-                                  GLsizei width, GLsizei height, GLsizei depth,
-                                  GLenum format, GLsizei imageSize)
-{
-   GLint expectedSize, maxLevels = 0, maxTextureSize;
-   GLuint bw, bh;
-   (void) zoffset;
-
-   if (dimensions == 1) {
-      /* 1D compressed textures not allowed */
-      return GL_INVALID_ENUM;
-   }
-   else if (dimensions == 2) {
-      if (target == GL_PROXY_TEXTURE_2D) {
-         maxLevels = ctx->Const.MaxTextureLevels;
-      }
-      else if (target == GL_TEXTURE_2D) {
-         maxLevels = ctx->Const.MaxTextureLevels;
-      }
-      else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
-         if (!ctx->Extensions.ARB_texture_cube_map)
-            return GL_INVALID_ENUM; /*target*/
-         maxLevels = ctx->Const.MaxCubeTextureLevels;
-      }
-      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
-         if (!ctx->Extensions.ARB_texture_cube_map)
-            return GL_INVALID_ENUM; /*target*/
-         maxLevels = ctx->Const.MaxCubeTextureLevels;
-      }
-      else {
-         return GL_INVALID_ENUM; /*target*/
-      }
-   }
-   else if (dimensions == 3) {
-      /* 3D compressed textures not allowed */
-      return GL_INVALID_ENUM;
-   }
-
-   maxTextureSize = 1 << (maxLevels - 1);
-
-   /* this will catch any invalid compressed format token */
-   if (!_mesa_is_compressed_format(ctx, format))
-      return GL_INVALID_ENUM;
-
-   if (width < 1 || width > maxTextureSize)
-      return GL_INVALID_VALUE;
-
-   if ((height < 1 || height > maxTextureSize)
-       && dimensions > 1)
-      return GL_INVALID_VALUE;
-
-   if (level < 0 || level >= maxLevels)
-      return GL_INVALID_VALUE;
-
-   /*
-    * do checks which depend on compression block size
-    */
-   get_compressed_block_size(format, &bw, &bh);
-
-   if ((xoffset % bw != 0) || (yoffset % bh != 0))
-      return GL_INVALID_VALUE;
-
-   if ((width % bw != 0) && width != 2 && width != 1)
-      return GL_INVALID_VALUE;
-
-   if ((height % bh != 0) && height != 2 && height != 1)
-      return GL_INVALID_VALUE;
-
-   expectedSize = compressed_tex_size(width, height, depth, format);
-   if (expectedSize != imageSize)
-      return GL_INVALID_VALUE;
-
-   return GL_NO_ERROR;
-}
-
-
-/**
- * Do second part of glCompressedTexSubImage error checking.
- * \return GL_TRUE if error found, GL_FALSE otherwise.
- */
-static GLboolean
-compressed_subtexture_error_check2(struct gl_context *ctx, GLuint dims,
-                                   GLsizei width, GLsizei height,
-                                   GLsizei depth, GLenum format,
-                                   struct gl_texture_image *texImage)
-{
-
-   if ((GLint) format != texImage->InternalFormat) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCompressedTexSubImage%uD(format=0x%x)", dims, format);
-      return GL_TRUE;
-   }
-
-   if (((width == 1 || width == 2) &&
-        width != (GLsizei) texImage->Width) ||
-       (width > (GLsizei) texImage->Width)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCompressedTexSubImage%uD(width=%d)", dims, width);
-      return GL_TRUE;
-   }
-
-   if (dims >= 2) {
-      if (((height == 1 || height == 2) &&
-           height != (GLsizei) texImage->Height) ||
-          (height > (GLsizei) texImage->Height)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCompressedTexSubImage%uD(height=%d)", dims, height);
-         return GL_TRUE;
-      }
-   }
-
-   if (dims >= 3) {
-      if (((depth == 1 || depth == 2) &&
-           depth != (GLsizei) texImage->Depth) ||
-          (depth > (GLsizei) texImage->Depth)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCompressedTexSubImage%uD(depth=%d)", dims, depth);
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Implementation of the glCompressedTexImage1/2/3D() functions.
- */
-static void
-compressedteximage(struct gl_context *ctx, GLuint dims,
-                   GLenum target, GLint level,
-                   GLenum internalFormat, GLsizei width,
-                   GLsizei height, GLsizei depth, GLint border,
-                   GLsizei imageSize, const GLvoid *data)
-{
-   GLenum error;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx,
-                  "glCompressedTexImage%uDARB %s %d %s %d %d %d %d %d %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  width, height, depth, border, imageSize, data);
-
-   /* check target */
-   if (!legal_teximage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }
-
-   error = compressed_texture_error_check(ctx, dims, target, level,
-                                          internalFormat, width, height, depth,
-                                          border, imageSize);
-
-#if FEATURE_ES
-   /* XXX this is kind of a hack */
-   if (error) {
-      _mesa_error(ctx, error, "glTexImage2D");
-      return;
-   }
-
-   if (dims == 2) {
-      switch (internalFormat) {
-      case GL_PALETTE4_RGB8_OES:
-      case GL_PALETTE4_RGBA8_OES:
-      case GL_PALETTE4_R5_G6_B5_OES:
-      case GL_PALETTE4_RGBA4_OES:
-      case GL_PALETTE4_RGB5_A1_OES:
-      case GL_PALETTE8_RGB8_OES:
-      case GL_PALETTE8_RGBA8_OES:
-      case GL_PALETTE8_R5_G6_B5_OES:
-      case GL_PALETTE8_RGBA4_OES:
-      case GL_PALETTE8_RGB5_A1_OES:
-         _mesa_cpal_compressed_teximage2d(target, level, internalFormat,
-                                          width, height, imageSize, data);
-         return;
-      }
-   }
-#endif
-
-   if (_mesa_is_proxy_texture(target)) {
-      /* Proxy texture: just check for errors and update proxy state */
-      struct gl_texture_image *texImage;
-
-      if (!error) {
-         struct gl_texture_object *texObj =
-            _mesa_get_current_tex_object(ctx, target);
-         gl_format texFormat =
-            _mesa_choose_texture_format(ctx, texObj, target, level,
-                                        internalFormat, GL_NONE, GL_NONE);
-         if (!legal_texture_size(ctx, texFormat, width, height, depth)) {
-            error = GL_OUT_OF_MEMORY;
-         }
-      }
-
-      texImage = _mesa_get_proxy_tex_image(ctx, target, level);
-      if (texImage) {
-         if (error) {
-            /* if error, clear all proxy texture image parameters */
-            clear_teximage_fields(texImage);
-         }
-         else {
-            /* no error: store the teximage parameters */
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height,
-                                       depth, border, internalFormat,
-                                       MESA_FORMAT_NONE);
-         }
-      }
-   }
-   else {
-      /* non-proxy target */
-      struct gl_texture_object *texObj;
-      struct gl_texture_image *texImage;
-
-      if (error) {
-         _mesa_error(ctx, error, "glCompressedTexImage%uD", dims);
-         return;
-      }
-
-      texObj = _mesa_get_current_tex_object(ctx, target);
-
-      _mesa_lock_texture(ctx, texObj);
-      {
-	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-	 if (!texImage) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                        "glCompressedTexImage%uD", dims);
-	 }
-         else {
-            gl_format texFormat;
-
-            if (texImage->Data) {
-               ctx->Driver.FreeTexImageData( ctx, texImage );
-            }
-            ASSERT(texImage->Data == NULL);
-
-            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                    internalFormat, GL_NONE,
-                                                    GL_NONE);
-
-            if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-               _mesa_init_teximage_fields(ctx, target, texImage,
-                                          width, height, depth,
-                                          border, internalFormat, texFormat);
-
-               switch (dims) {
-               case 1:
-                  ASSERT(ctx->Driver.CompressedTexImage1D);
-                  ctx->Driver.CompressedTexImage1D(ctx, target, level,
-                                                   internalFormat,
-                                                   width,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               case 2:
-                  ASSERT(ctx->Driver.CompressedTexImage2D);
-                  ctx->Driver.CompressedTexImage2D(ctx, target, level,
-                                                   internalFormat,
-                                                   width, height,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               case 3:
-                  ASSERT(ctx->Driver.CompressedTexImage3D);
-                  ctx->Driver.CompressedTexImage3D(ctx, target, level,
-                                                   internalFormat,
-                                                   width, height, depth,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               default:
-                  _mesa_problem(ctx, "bad dims in compressedteximage");
-               }
-
-               check_gen_mipmap(ctx, target, texObj, level);
-
-               /* state update */
-               texObj->_Complete = GL_FALSE;
-               ctx->NewState |= _NEW_TEXTURE;
-            }
-            else {
-               _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                           "glCompressedTexImage%uD", dims);
-            }
-         }
-      }
-      _mesa_unlock_texture(ctx, texObj);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage1DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLint border, GLsizei imageSize,
-                              const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 1, target, level, internalFormat,
-                      width, 1, 1, border, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage2DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLsizei height, GLint border, GLsizei imageSize,
-                              const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 2, target, level, internalFormat,
-                      width, height, 1, border, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage3DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLsizei height, GLsizei depth, GLint border,
-                              GLsizei imageSize, const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 3, target, level, internalFormat,
-                      width, height, depth, border, imageSize, data);
-}
-
-
-/**
- * Common helper for glCompressedTexSubImage1/2/3D().
- */
-static void
-compressed_tex_sub_image(GLuint dims, GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset, GLint zoffset,
-                         GLsizei width, GLsizei height, GLsizei depth,
-                         GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLenum error;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   error = compressed_subtexture_error_check(ctx, dims, target, level,
-                                             xoffset, 0, 0, /* pos */
-                                             width, height, depth,   /* size */
-                                             format, imageSize);
-   if (error) {
-      _mesa_error(ctx, error, "glCompressedTexSubImage%uD", dims);
-      return;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-      assert(texImage);
-
-      if (compressed_subtexture_error_check2(ctx, dims, width, height, depth,
-                                             format, texImage)) {
-         /* error was recorded */
-      }
-      else if (width > 0 && height > 0 && depth > 0) {
-         switch (dims) {
-         case 1:
-            if (ctx->Driver.CompressedTexSubImage1D) {
-               ctx->Driver.CompressedTexSubImage1D(ctx, target, level,
-                                                   xoffset, width,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         case 2:
-            if (ctx->Driver.CompressedTexSubImage2D) {
-               ctx->Driver.CompressedTexSubImage2D(ctx, target, level,
-                                                   xoffset, yoffset,
-                                                   width, height,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         case 3:
-            if (ctx->Driver.CompressedTexSubImage3D) {
-               ctx->Driver.CompressedTexSubImage3D(ctx, target, level,
-                                                   xoffset, yoffset, zoffset,
-                                                   width, height, depth,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         default:
-            ;
-         }
-
-         check_gen_mipmap(ctx, target, texObj, level);
-
-         ctx->NewState |= _NEW_TEXTURE;
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLsizei width, GLenum format,
-                                 GLsizei imageSize, const GLvoid *data)
-{
-   compressed_tex_sub_image(1, target, level, xoffset, 0, 0, width, 1, 1,
-                            format, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLint yoffset, GLsizei width, GLsizei height,
-                                 GLenum format, GLsizei imageSize,
-                                 const GLvoid *data)
-{
-   compressed_tex_sub_image(2, target, level, xoffset, yoffset, 0,
-                            width, height, 1, format, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLint yoffset, GLint zoffset, GLsizei width,
-                                 GLsizei height, GLsizei depth, GLenum format,
-                                 GLsizei imageSize, const GLvoid *data)
-{
-   compressed_tex_sub_image(3, target, level, xoffset, yoffset, zoffset,
-                            width, height, depth, format, imageSize, data);
-}
+/*

+ * mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file teximage.c

+ * Texture image-related functions.

+ */

+

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "enums.h"

+#include "fbobject.h"

+#include "framebuffer.h"

+#include "hash.h"

+#include "image.h"

+#include "imports.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "state.h"

+#include "texcompress.h"

+#include "texfetch.h"

+#include "teximage.h"

+#include "texstate.h"

+#include "texpal.h"

+#include "mtypes.h"

+

+

+/**

+ * State changes which we care about for glCopyTex[Sub]Image() calls.

+ * In particular, we care about pixel transfer state and buffer state

+ * (such as glReadBuffer to make sure we read from the right renderbuffer).

+ */

+#define NEW_COPY_TEX_STATE (_MESA_NEW_TRANSFER_STATE | \

+                            _NEW_BUFFERS | \

+                            _NEW_PIXEL)

+

+

+

+/**

+ * We allocate texture memory on 512-byte boundaries so we can use MMX/SSE

+ * elsewhere.

+ */

+void *

+_mesa_alloc_texmemory(GLsizei bytes)

+{

+   return _mesa_align_malloc(bytes, 512);

+}

+

+

+/**

+ * Free texture memory allocated with _mesa_alloc_texmemory()

+ */

+void

+_mesa_free_texmemory(void *m)

+{

+   _mesa_align_free(m);

+}

+

+

+/*

+ * Compute floor(log_base_2(n)).

+ * If n < 0 return -1.

+ */

+static int

+logbase2( int n )

+{

+   GLint i = 1;

+   GLint log2 = 0;

+

+   if (n < 0)

+      return -1;

+

+   if (n == 0)

+      return 0;

+

+   while ( n > i ) {

+      i *= 2;

+      log2++;

+   }

+   if (i != n) {

+      return log2 - 1;

+   }

+   else {

+      return log2;

+   }

+}

+

+

+

+/**

+ * Return the simple base format for a given internal texture format.

+ * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.

+ *

+ * \param ctx GL context.

+ * \param internalFormat the internal texture format token or 1, 2, 3, or 4.

+ *

+ * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,

+ * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.

+ *

+ * This is the format which is used during texture application (i.e. the

+ * texture format and env mode determine the arithmetic used.

+ *

+ * XXX this could be static

+ */

+GLint

+_mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )

+{

+   switch (internalFormat) {

+      case GL_ALPHA:

+      case GL_ALPHA4:

+      case GL_ALPHA8:

+      case GL_ALPHA12:

+      case GL_ALPHA16:

+         return GL_ALPHA;

+      case 1:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE4:

+      case GL_LUMINANCE8:

+      case GL_LUMINANCE12:

+      case GL_LUMINANCE16:

+         return GL_LUMINANCE;

+      case 2:

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE4_ALPHA4:

+      case GL_LUMINANCE6_ALPHA2:

+      case GL_LUMINANCE8_ALPHA8:

+      case GL_LUMINANCE12_ALPHA4:

+      case GL_LUMINANCE12_ALPHA12:

+      case GL_LUMINANCE16_ALPHA16:

+         return GL_LUMINANCE_ALPHA;

+      case GL_INTENSITY:

+      case GL_INTENSITY4:

+      case GL_INTENSITY8:

+      case GL_INTENSITY12:

+      case GL_INTENSITY16:

+         return GL_INTENSITY;

+      case 3:

+      case GL_RGB:

+      case GL_R3_G3_B2:

+      case GL_RGB4:

+      case GL_RGB5:

+      case GL_RGB8:

+      case GL_RGB10:

+      case GL_RGB12:

+      case GL_RGB16:

+         return GL_RGB;

+      case 4:

+      case GL_RGBA:

+      case GL_RGBA2:

+      case GL_RGBA4:

+      case GL_RGB5_A1:

+      case GL_RGBA8:

+      case GL_RGB10_A2:

+      case GL_RGBA12:

+      case GL_RGBA16:

+         return GL_RGBA;

+      default:

+         ; /* fallthrough */

+   }

+

+   if (ctx->Extensions.EXT_texture_format_BGRA8888) {

+      switch (internalFormat) {

+         case GL_BGRA_EXT:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_paletted_texture) {

+      switch (internalFormat) {

+         case GL_COLOR_INDEX:

+         case GL_COLOR_INDEX1_EXT:

+         case GL_COLOR_INDEX2_EXT:

+         case GL_COLOR_INDEX4_EXT:

+         case GL_COLOR_INDEX8_EXT:

+         case GL_COLOR_INDEX12_EXT:

+         case GL_COLOR_INDEX16_EXT:

+            return GL_COLOR_INDEX;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_depth_texture) {

+      switch (internalFormat) {

+         case GL_DEPTH_COMPONENT:

+         case GL_DEPTH_COMPONENT16:

+         case GL_DEPTH_COMPONENT24:

+         case GL_DEPTH_COMPONENT32:

+            return GL_DEPTH_COMPONENT;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   switch (internalFormat) {

+   case GL_COMPRESSED_ALPHA:

+      return GL_ALPHA;

+   case GL_COMPRESSED_LUMINANCE:

+      return GL_LUMINANCE;

+   case GL_COMPRESSED_LUMINANCE_ALPHA:

+      return GL_LUMINANCE_ALPHA;

+   case GL_COMPRESSED_INTENSITY:

+      return GL_INTENSITY;

+   case GL_COMPRESSED_RGB:

+      return GL_RGB;

+   case GL_COMPRESSED_RGBA:

+      return GL_RGBA;

+   default:

+      ; /* fallthrough */

+   }

+         

+   if (ctx->Extensions.TDFX_texture_compression_FXT1) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_FXT1_3DFX:

+            return GL_RGB;

+         case GL_COMPRESSED_RGBA_FXT1_3DFX:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_compression_s3tc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+            return GL_RGB;

+         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.S3_s3tc) {

+      switch (internalFormat) {

+         case GL_RGB_S3TC:

+         case GL_RGB4_S3TC:

+            return GL_RGB;

+         case GL_RGBA_S3TC:

+         case GL_RGBA4_S3TC:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.MESA_ycbcr_texture) {

+      if (internalFormat == GL_YCBCR_MESA)

+         return GL_YCBCR_MESA;

+   }

+

+   if (ctx->Extensions.ARB_texture_float) {

+      switch (internalFormat) {

+         case GL_ALPHA16F_ARB:

+         case GL_ALPHA32F_ARB:

+            return GL_ALPHA;

+         case GL_RGBA16F_ARB:

+         case GL_RGBA32F_ARB:

+            return GL_RGBA;

+         case GL_RGB16F_ARB:

+         case GL_RGB32F_ARB:

+            return GL_RGB;

+         case GL_INTENSITY16F_ARB:

+         case GL_INTENSITY32F_ARB:

+            return GL_INTENSITY;

+         case GL_LUMINANCE16F_ARB:

+         case GL_LUMINANCE32F_ARB:

+            return GL_LUMINANCE;

+         case GL_LUMINANCE_ALPHA16F_ARB:

+         case GL_LUMINANCE_ALPHA32F_ARB:

+            return GL_LUMINANCE_ALPHA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ATI_envmap_bumpmap) {

+      switch (internalFormat) {

+         case GL_DUDV_ATI:

+         case GL_DU8DV8_ATI:

+            return GL_DUDV_ATI;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.MESA_texture_signed_rgba) {

+      switch (internalFormat) {

+         case GL_RGBA_SNORM:

+         case GL_RGBA8_SNORM:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_packed_depth_stencil) {

+      switch (internalFormat) {

+         case GL_DEPTH_STENCIL_EXT:

+         case GL_DEPTH24_STENCIL8_EXT:

+            return GL_DEPTH_STENCIL_EXT;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+#if FEATURE_EXT_texture_sRGB

+   if (ctx->Extensions.EXT_texture_sRGB) {

+      switch (internalFormat) {

+      case GL_SRGB_EXT:

+      case GL_SRGB8_EXT:

+      case GL_COMPRESSED_SRGB_EXT:

+      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+         return GL_RGB;

+      case GL_SRGB_ALPHA_EXT:

+      case GL_SRGB8_ALPHA8_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+         return GL_RGBA;

+      case GL_SLUMINANCE_ALPHA_EXT:

+      case GL_SLUMINANCE8_ALPHA8_EXT:

+      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+         return GL_LUMINANCE_ALPHA;

+      case GL_SLUMINANCE_EXT:

+      case GL_SLUMINANCE8_EXT:

+      case GL_COMPRESSED_SLUMINANCE_EXT:

+         return GL_LUMINANCE;

+      default:

+         ; /* fallthrough */

+      }

+   }

+#endif /* FEATURE_EXT_texture_sRGB */

+

+   if (ctx->Extensions.EXT_texture_integer) {

+      switch (internalFormat) {

+      case GL_RGBA8UI_EXT:

+      case GL_RGBA16UI_EXT:

+      case GL_RGBA32UI_EXT:

+      case GL_RGBA8I_EXT:

+      case GL_RGBA16I_EXT:

+      case GL_RGBA32I_EXT:

+         return GL_RGBA;

+      case GL_RGB8UI_EXT:

+      case GL_RGB16UI_EXT:

+      case GL_RGB32UI_EXT:

+      case GL_RGB8I_EXT:

+      case GL_RGB16I_EXT:

+      case GL_RGB32I_EXT:

+         return GL_RGB;

+      case GL_ALPHA8UI_EXT:

+      case GL_ALPHA16UI_EXT:

+      case GL_ALPHA32UI_EXT:

+      case GL_ALPHA8I_EXT:

+      case GL_ALPHA16I_EXT:

+      case GL_ALPHA32I_EXT:

+         return GL_ALPHA;

+      case GL_INTENSITY8UI_EXT:

+      case GL_INTENSITY16UI_EXT:

+      case GL_INTENSITY32UI_EXT:

+      case GL_INTENSITY8I_EXT:

+      case GL_INTENSITY16I_EXT:

+      case GL_INTENSITY32I_EXT:

+         return GL_INTENSITY;

+      case GL_LUMINANCE8UI_EXT:

+      case GL_LUMINANCE16UI_EXT:

+      case GL_LUMINANCE32UI_EXT:

+      case GL_LUMINANCE8I_EXT:

+      case GL_LUMINANCE16I_EXT:

+      case GL_LUMINANCE32I_EXT:

+         return GL_LUMINANCE;

+      case GL_LUMINANCE_ALPHA8UI_EXT:

+      case GL_LUMINANCE_ALPHA16UI_EXT:

+      case GL_LUMINANCE_ALPHA32UI_EXT:

+      case GL_LUMINANCE_ALPHA8I_EXT:

+      case GL_LUMINANCE_ALPHA16I_EXT:

+      case GL_LUMINANCE_ALPHA32I_EXT:

+         return GL_LUMINANCE_ALPHA;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_rg) {

+      switch (internalFormat) {

+      case GL_R16F:

+	 /* R16F depends on both ARB_half_float_pixel and ARB_texture_float.

+	  */

+	 if (!ctx->Extensions.ARB_half_float_pixel)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_R32F:

+	 if (!ctx->Extensions.ARB_texture_float)

+	    break;

+         return GL_RED;

+      case GL_R8I:

+      case GL_R8UI:

+      case GL_R16I:

+      case GL_R16UI:

+      case GL_R32I:

+      case GL_R32UI:

+	 if (!ctx->Extensions.EXT_texture_integer)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_R8:

+      case GL_R16:

+      case GL_RED:

+      case GL_COMPRESSED_RED:

+         return GL_RED;

+

+      case GL_RG16F:

+	 /* RG16F depends on both ARB_half_float_pixel and ARB_texture_float.

+	  */

+	 if (!ctx->Extensions.ARB_half_float_pixel)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_RG32F:

+	 if (!ctx->Extensions.ARB_texture_float)

+	    break;

+         return GL_RG;

+      case GL_RG8I:

+      case GL_RG8UI:

+      case GL_RG16I:

+      case GL_RG16UI:

+      case GL_RG32I:

+      case GL_RG32UI:

+	 if (!ctx->Extensions.EXT_texture_integer)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_RG:

+      case GL_RG8:

+      case GL_RG16:

+      case GL_COMPRESSED_RG:

+         return GL_RG;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_shared_exponent) {

+      switch (internalFormat) {

+      case GL_RGB9_E5_EXT:

+         return GL_RGB;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_packed_float) {

+      switch (internalFormat) {

+      case GL_R11F_G11F_B10F_EXT:

+         return GL_RGB;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_depth_buffer_float) {

+      switch (internalFormat) {

+      case GL_DEPTH_COMPONENT32F:

+         return GL_DEPTH_COMPONENT;

+      case GL_DEPTH32F_STENCIL8:

+         return GL_DEPTH_STENCIL;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_compression_rgtc) {

+      switch (internalFormat) {

+      case GL_COMPRESSED_RED_RGTC1:

+      case GL_COMPRESSED_SIGNED_RED_RGTC1:

+         return GL_RED;

+      case GL_COMPRESSED_RG_RGTC2:

+      case GL_COMPRESSED_SIGNED_RG_RGTC2:

+         return GL_RG;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_compression_latc) {

+      switch (internalFormat) {

+      case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+      case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+         return GL_LUMINANCE;

+      case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+      case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+         return GL_LUMINANCE_ALPHA;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ATI_texture_compression_3dc) {

+      switch (internalFormat) {

+      case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+         return GL_LUMINANCE_ALPHA;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   return -1; /* error */

+}

+

+

+/**

+ * For cube map faces, return a face index in [0,5].

+ * For other targets return 0;

+ */

+GLuint

+_mesa_tex_target_to_face(GLenum target)

+{

+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)

+      return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;

+   else

+      return 0;

+}

+

+

+

+/**

+ * Store a gl_texture_image pointer in a gl_texture_object structure

+ * according to the target and level parameters.

+ * 

+ * \param tObj texture object.

+ * \param target texture target.

+ * \param level image level.

+ * \param texImage texture image.

+ * 

+ * This was basically prompted by the introduction of cube maps.

+ */

+void

+_mesa_set_tex_image(struct gl_texture_object *tObj,

+                    GLenum target, GLint level,

+                    struct gl_texture_image *texImage)

+{

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT(tObj);

+   ASSERT(texImage);

+   ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0);

+

+   tObj->Image[face][level] = texImage;

+

+   /* Set the 'back' pointer */

+   texImage->TexObject = tObj;

+}

+

+

+/**

+ * Allocate a texture image structure.

+ * 

+ * Called via ctx->Driver.NewTextureImage() unless overriden by a device

+ * driver.

+ *

+ * \return a pointer to gl_texture_image struct with all fields initialized to

+ * zero.

+ */

+struct gl_texture_image *

+_mesa_new_texture_image( struct gl_context *ctx )

+{

+   (void) ctx;

+   return CALLOC_STRUCT(gl_texture_image);

+}

+

+

+/**

+ * Free texture image data.

+ * This function is a fallback called via ctx->Driver.FreeTexImageData().

+ *

+ * \param texImage texture image.

+ *

+ * Free the texture image data if it's not marked as client data.

+ */

+void

+_mesa_free_texture_image_data(struct gl_context *ctx,

+                              struct gl_texture_image *texImage)

+{

+   (void) ctx;

+

+   if (texImage->Data && !texImage->IsClientData) {

+      /* free the old texture data */

+      _mesa_free_texmemory(texImage->Data);

+   }

+

+   texImage->Data = NULL;

+}

+

+

+/**

+ * Free texture image.

+ *

+ * \param texImage texture image.

+ *

+ * Free the texture image structure and the associated image data.

+ */

+void

+_mesa_delete_texture_image(struct gl_context *ctx,

+                           struct gl_texture_image *texImage)

+{

+   /* Free texImage->Data and/or any other driver-specific texture

+    * image storage.

+    */

+   ASSERT(ctx->Driver.FreeTexImageData);

+   ctx->Driver.FreeTexImageData( ctx, texImage );

+

+   ASSERT(texImage->Data == NULL);

+   if (texImage->ImageOffsets)

+      free(texImage->ImageOffsets);

+   free(texImage);

+}

+

+

+/**

+ * Test if a target is a proxy target.

+ *

+ * \param target texture target.

+ *

+ * \return GL_TRUE if the target is a proxy target, GL_FALSE otherwise.

+ */

+GLboolean

+_mesa_is_proxy_texture(GLenum target)

+{

+   /* NUM_TEXTURE_TARGETS should match number of terms below */

+   assert(NUM_TEXTURE_TARGETS == 7);

+

+   return (target == GL_PROXY_TEXTURE_1D ||

+           target == GL_PROXY_TEXTURE_2D ||

+           target == GL_PROXY_TEXTURE_3D ||

+           target == GL_PROXY_TEXTURE_CUBE_MAP_ARB ||

+           target == GL_PROXY_TEXTURE_RECTANGLE_NV ||

+           target == GL_PROXY_TEXTURE_1D_ARRAY_EXT ||

+           target == GL_PROXY_TEXTURE_2D_ARRAY_EXT);

+}

+

+

+/**

+ * Return the proxy target which corresponds to the given texture target

+ */

+static GLenum

+get_proxy_target(GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+      return GL_PROXY_TEXTURE_1D;

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return GL_PROXY_TEXTURE_2D;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+      return GL_PROXY_TEXTURE_3D;

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      return GL_PROXY_TEXTURE_CUBE_MAP_ARB;

+   case GL_TEXTURE_RECTANGLE_NV:

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      return GL_PROXY_TEXTURE_RECTANGLE_NV;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      return GL_PROXY_TEXTURE_1D_ARRAY_EXT;

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      return GL_PROXY_TEXTURE_2D_ARRAY_EXT;

+   default:

+      _mesa_problem(NULL, "unexpected target in get_proxy_target()");

+      return 0;

+   }

+}

+

+

+/**

+ * Get the texture object that corresponds to the target of the given

+ * texture unit.

+ *

+ * \param ctx GL context.

+ * \param texUnit texture unit.

+ * \param target texture target.

+ *

+ * \return pointer to the texture object on success, or NULL on failure.

+ * 

+ * \sa gl_texture_unit.

+ */

+struct gl_texture_object *

+_mesa_select_tex_object(struct gl_context *ctx,

+                        const struct gl_texture_unit *texUnit,

+                        GLenum target)

+{

+   const GLboolean arrayTex = (ctx->Extensions.MESA_texture_array ||

+                               ctx->Extensions.EXT_texture_array);

+

+   switch (target) {

+      case GL_TEXTURE_1D:

+         return texUnit->CurrentTex[TEXTURE_1D_INDEX];

+      case GL_PROXY_TEXTURE_1D:

+         return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];

+      case GL_TEXTURE_2D:

+         return texUnit->CurrentTex[TEXTURE_2D_INDEX];

+      case GL_PROXY_TEXTURE_2D:

+         return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];

+      case GL_TEXTURE_3D:

+         return texUnit->CurrentTex[TEXTURE_3D_INDEX];

+      case GL_PROXY_TEXTURE_3D:

+         return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+      case GL_TEXTURE_CUBE_MAP_ARB:

+         return ctx->Extensions.ARB_texture_cube_map

+                ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+         return ctx->Extensions.ARB_texture_cube_map

+                ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL;

+      case GL_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle

+                ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle

+                ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         return arrayTex ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         return arrayTex ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL;

+      default:

+         _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");

+         return NULL;

+   }

+}

+

+

+/**

+ * Return pointer to texture object for given target on current texture unit.

+ */

+struct gl_texture_object *

+_mesa_get_current_tex_object(struct gl_context *ctx, GLenum target)

+{

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   return _mesa_select_tex_object(ctx, texUnit, target);

+}

+

+

+/**

+ * Get a texture image pointer from a texture object, given a texture

+ * target and mipmap level.  The target and level parameters should

+ * have already been error-checked.

+ *

+ * \param ctx GL context.

+ * \param texObj texture unit.

+ * \param target texture target.

+ * \param level image level.

+ *

+ * \return pointer to the texture image structure, or NULL on failure.

+ */

+struct gl_texture_image *

+_mesa_select_tex_image(struct gl_context *ctx,

+                       const struct gl_texture_object *texObj,

+		       GLenum target, GLint level)

+{

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT(texObj);

+   ASSERT(level >= 0);

+   ASSERT(level < MAX_TEXTURE_LEVELS);

+

+   return texObj->Image[face][level];

+}

+

+

+/**

+ * Like _mesa_select_tex_image() but if the image doesn't exist, allocate

+ * it and install it.  Only return NULL if passed a bad parameter or run

+ * out of memory.

+ */

+struct gl_texture_image *

+_mesa_get_tex_image(struct gl_context *ctx, struct gl_texture_object *texObj,

+                    GLenum target, GLint level)

+{

+   struct gl_texture_image *texImage;

+

+   if (!texObj)

+      return NULL;

+   

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+   if (!texImage) {

+      texImage = ctx->Driver.NewTextureImage(ctx);

+      if (!texImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture image allocation");

+         return NULL;

+      }

+

+      _mesa_set_tex_image(texObj, target, level, texImage);

+   }

+

+   return texImage;

+}

+

+

+/**

+ * Return pointer to the specified proxy texture image.

+ * Note that proxy textures are per-context, not per-texture unit.

+ * \return pointer to texture image or NULL if invalid target, invalid

+ *         level, or out of memory.

+ */

+struct gl_texture_image *

+_mesa_get_proxy_tex_image(struct gl_context *ctx, GLenum target, GLint level)

+{

+   struct gl_texture_image *texImage;

+   GLuint texIndex;

+

+   if (level < 0 )

+      return NULL;

+

+   switch (target) {

+   case GL_PROXY_TEXTURE_1D:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_1D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_2D:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_2D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_3D:

+      if (level >= ctx->Const.Max3DTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_3D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+      if (level >= ctx->Const.MaxCubeTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_CUBE_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      if (level > 0)

+         return NULL;

+      texIndex = TEXTURE_RECT_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_1D_ARRAY_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_2D_ARRAY_INDEX;

+      break;

+   default:

+      return NULL;

+   }

+

+   texImage = ctx->Texture.ProxyTex[texIndex]->Image[0][level];

+   if (!texImage) {

+      texImage = ctx->Driver.NewTextureImage(ctx);

+      if (!texImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");

+         return NULL;

+      }

+      ctx->Texture.ProxyTex[texIndex]->Image[0][level] = texImage;

+      /* Set the 'back' pointer */

+      texImage->TexObject = ctx->Texture.ProxyTex[texIndex];

+   }

+   return texImage;

+}

+

+

+/**

+ * Get the maximum number of allowed mipmap levels.

+ *

+ * \param ctx GL context.

+ * \param target texture target.

+ * 

+ * \return the maximum number of allowed mipmap levels for the given

+ * texture target, or zero if passed a bad target.

+ *

+ * \sa gl_constants.

+ */

+GLint

+_mesa_max_texture_levels(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return ctx->Const.MaxTextureLevels;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+      return ctx->Const.Max3DTextureLevels;

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      return ctx->Extensions.ARB_texture_cube_map

+         ? ctx->Const.MaxCubeTextureLevels : 0;

+   case GL_TEXTURE_RECTANGLE_NV:

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      return ctx->Extensions.NV_texture_rectangle ? 1 : 0;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      return (ctx->Extensions.MESA_texture_array ||

+              ctx->Extensions.EXT_texture_array)

+         ? ctx->Const.MaxTextureLevels : 0;

+   default:

+      return 0; /* bad target */

+   }

+}

+

+

+/**

+ * Return number of dimensions per mipmap level for the given texture target.

+ */

+GLint

+_mesa_get_texture_dimensions(GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+      return 1;

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_RECTANGLE:

+   case GL_TEXTURE_CUBE_MAP:

+   case GL_PROXY_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_RECTANGLE:

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+   case GL_TEXTURE_1D_ARRAY:

+   case GL_PROXY_TEXTURE_1D_ARRAY:

+      return 2;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+   case GL_TEXTURE_2D_ARRAY:

+   case GL_PROXY_TEXTURE_2D_ARRAY:

+      return 3;

+   default:

+      _mesa_problem(NULL, "invalid target 0x%x in get_texture_dimensions()",

+                    target);

+      return 2;

+   }

+}

+

+

+

+

+#if 000 /* not used anymore */

+/*

+ * glTexImage[123]D can accept a NULL image pointer.  In this case we

+ * create a texture image with unspecified image contents per the OpenGL

+ * spec.

+ */

+static GLubyte *

+make_null_texture(GLint width, GLint height, GLint depth, GLenum format)

+{

+   const GLint components = _mesa_components_in_format(format);

+   const GLint numPixels = width * height * depth;

+   GLubyte *data = (GLubyte *) MALLOC(numPixels * components * sizeof(GLubyte));

+

+#ifdef DEBUG

+   /*

+    * Let's see if anyone finds this.  If glTexImage2D() is called with

+    * a NULL image pointer then load the texture image with something

+    * interesting instead of leaving it indeterminate.

+    */

+   if (data) {

+      static const char message[8][32] = {

+         "   X   X  XXXXX   XXX     X    ",

+         "   XX XX  X      X   X   X X   ",

+         "   X X X  X      X      X   X  ",

+         "   X   X  XXXX    XXX   XXXXX  ",

+         "   X   X  X          X  X   X  ",

+         "   X   X  X      X   X  X   X  ",

+         "   X   X  XXXXX   XXX   X   X  ",

+         "                               "

+      };

+

+      GLubyte *imgPtr = data;

+      GLint h, i, j, k;

+      for (h = 0; h < depth; h++) {

+         for (i = 0; i < height; i++) {

+            GLint srcRow = 7 - (i % 8);

+            for (j = 0; j < width; j++) {

+               GLint srcCol = j % 32;

+               GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;

+               for (k = 0; k < components; k++) {

+                  *imgPtr++ = texel;

+               }

+            }

+         }

+      }

+   }

+#endif

+

+   return data;

+}

+#endif

+

+

+

+/**

+ * Reset the fields of a gl_texture_image struct to zero.

+ * 

+ * \param img texture image structure.

+ *

+ * This is called when a proxy texture test fails, we set all the

+ * image members (except DriverData) to zero.

+ * It's also used in glTexImage[123]D as a safeguard to be sure all

+ * required fields get initialized properly by the Driver.TexImage[123]D

+ * functions.

+ */

+static void

+clear_teximage_fields(struct gl_texture_image *img)

+{

+   ASSERT(img);

+   img->_BaseFormat = 0;

+   img->InternalFormat = 0;

+   img->Border = 0;

+   img->Width = 0;

+   img->Height = 0;

+   img->Depth = 0;

+   img->RowStride = 0;

+   if (img->ImageOffsets) {

+      free(img->ImageOffsets);

+      img->ImageOffsets = NULL;

+   }

+   img->Width2 = 0;

+   img->Height2 = 0;

+   img->Depth2 = 0;

+   img->WidthLog2 = 0;

+   img->HeightLog2 = 0;

+   img->DepthLog2 = 0;

+   img->Data = NULL;

+   img->TexFormat = MESA_FORMAT_NONE;

+   img->FetchTexelc = NULL;

+   img->FetchTexelf = NULL;

+}

+

+

+/**

+ * Initialize basic fields of the gl_texture_image struct.

+ *

+ * \param ctx GL context.

+ * \param target texture target (GL_TEXTURE_1D, GL_TEXTURE_RECTANGLE, etc).

+ * \param img texture image structure to be initialized.

+ * \param width image width.

+ * \param height image height.

+ * \param depth image depth.

+ * \param border image border.

+ * \param internalFormat internal format.

+ * \param format  the actual hardware format (one of MESA_FORMAT_*)

+ *

+ * Fills in the fields of \p img with the given information.

+ * Note: width, height and depth include the border.

+ */

+void

+_mesa_init_teximage_fields(struct gl_context *ctx, GLenum target,

+                           struct gl_texture_image *img,

+                           GLsizei width, GLsizei height, GLsizei depth,

+                           GLint border, GLenum internalFormat,

+                           gl_format format)

+{

+   GLint i, dims;

+

+   ASSERT(img);

+   ASSERT(width >= 0);

+   ASSERT(height >= 0);

+   ASSERT(depth >= 0);

+

+   img->_BaseFormat = _mesa_base_tex_format( ctx, internalFormat );

+   ASSERT(img->_BaseFormat > 0);

+   img->InternalFormat = internalFormat;

+   img->Border = border;

+   img->Width = width;

+   img->Height = height;

+   img->Depth = depth;

+

+   img->Width2 = width - 2 * border;   /* == 1 << img->WidthLog2; */

+   img->WidthLog2 = logbase2(img->Width2);

+

+   if (height == 1) { /* 1-D texture */

+      img->Height2 = 1;

+      img->HeightLog2 = 0;

+   }

+   else {

+      img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */

+      img->HeightLog2 = logbase2(img->Height2);

+   }

+

+   if (depth == 1) {  /* 2-D texture */

+      img->Depth2 = 1;

+      img->DepthLog2 = 0;

+   }

+   else {

+      img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */

+      img->DepthLog2 = logbase2(img->Depth2);

+   }

+

+   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);

+

+   if ((width == 1 || _mesa_is_pow_two(img->Width2)) &&

+       (height == 1 || _mesa_is_pow_two(img->Height2)) &&

+       (depth == 1 || _mesa_is_pow_two(img->Depth2)))

+      img->_IsPowerOfTwo = GL_TRUE;

+   else

+      img->_IsPowerOfTwo = GL_FALSE;

+

+   /* RowStride and ImageOffsets[] describe how to address texels in 'Data' */

+   img->RowStride = width;

+   /* Allocate the ImageOffsets array and initialize to typical values.

+    * We allocate the array for 1D/2D textures too in order to avoid special-

+    * case code in the texstore routines.

+    */

+   if (img->ImageOffsets)

+      free(img->ImageOffsets);

+   img->ImageOffsets = (GLuint *) malloc(depth * sizeof(GLuint));

+   for (i = 0; i < depth; i++) {

+      img->ImageOffsets[i] = i * width * height;

+   }

+

+   /* Compute Width/Height/DepthScale for mipmap lod computation */

+   if (target == GL_TEXTURE_RECTANGLE_NV) {

+      /* scale = 1.0 since texture coords directly map to texels */

+      img->WidthScale = 1.0;

+      img->HeightScale = 1.0;

+      img->DepthScale = 1.0;

+   }

+   else {

+      img->WidthScale = (GLfloat) img->Width;

+      img->HeightScale = (GLfloat) img->Height;

+      img->DepthScale = (GLfloat) img->Depth;

+   }

+

+   img->TexFormat = format;

+

+   dims = _mesa_get_texture_dimensions(target);

+

+   _mesa_set_fetch_functions(img, dims);

+}

+

+

+/**

+ * Free and clear fields of the gl_texture_image struct.

+ *

+ * \param ctx GL context.

+ * \param texImage texture image structure to be cleared.

+ *

+ * After the call, \p texImage will have no data associated with it.  Its

+ * fields are cleared so that its parent object will test incomplete.

+ */

+void

+_mesa_clear_texture_image(struct gl_context *ctx,

+                          struct gl_texture_image *texImage)

+{

+   ctx->Driver.FreeTexImageData(ctx, texImage);

+   clear_teximage_fields(texImage);

+}

+

+

+/**

+ * This is the fallback for Driver.TestProxyTexImage().  Test the texture

+ * level, width, height and depth against the ctx->Const limits for textures.

+ *

+ * A hardware driver might override this function if, for example, the

+ * max 3D texture size is 512x512x64 (i.e. not a cube).

+ *

+ * Note that width, height, depth == 0 is not an error.  However, a

+ * texture with zero width/height/depth will be considered "incomplete"

+ * and texturing will effectively be disabled.

+ *

+ * \param target  one of GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D,

+ *                GL_PROXY_TEXTURE_3D, GL_PROXY_TEXTURE_RECTANGLE_NV,

+ *                GL_PROXY_TEXTURE_CUBE_MAP_ARB.

+ * \param level  as passed to glTexImage

+ * \param internalFormat  as passed to glTexImage

+ * \param format  as passed to glTexImage

+ * \param type  as passed to glTexImage

+ * \param width  as passed to glTexImage

+ * \param height  as passed to glTexImage

+ * \param depth  as passed to glTexImage

+ * \param border  as passed to glTexImage

+ * \return GL_TRUE if the image is acceptable, GL_FALSE if not acceptable.

+ */

+GLboolean

+_mesa_test_proxy_teximage(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint internalFormat, GLenum format, GLenum type,

+                          GLint width, GLint height, GLint depth, GLint border)

+{

+   GLint maxSize;

+

+   (void) internalFormat;

+   (void) format;

+   (void) type;

+

+   switch (target) {

+   case GL_PROXY_TEXTURE_1D:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_2D:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_3D:

+      maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (depth < 2 * border || depth > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.Max3DTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+         if (depth > 0 && !_mesa_is_pow_two(depth - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      maxSize = ctx->Const.MaxTextureRectSize;

+      if (width < 0 || width > maxSize)

+         return GL_FALSE;

+      if (height < 0 || height > maxSize)

+         return GL_FALSE;

+      if (level != 0)

+         return GL_FALSE;

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      maxSize = 1 << (ctx->Const.MaxCubeTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxCubeTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 1 || height > ctx->Const.MaxArrayTextureLayers)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (depth < 1 || depth > ctx->Const.MaxArrayTextureLayers)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   default:

+      _mesa_problem(ctx, "Invalid target in _mesa_test_proxy_teximage");

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if the memory used by the texture would exceed the driver's limit.

+ * This lets us support a max 3D texture size of 8K (for example) but

+ * prevents allocating a full 8K x 8K x 8K texture.

+ * XXX this could be rolled into the proxy texture size test (above) but

+ * we don't have the actual texture internal format at that point.

+ */

+static GLboolean

+legal_texture_size(struct gl_context *ctx, gl_format format,

+                   GLint width, GLint height, GLint depth)

+{

+   uint64_t bytes = _mesa_format_image_size64(format, width, height, depth);

+   uint64_t mbytes = bytes / (1024 * 1024); /* convert to MB */

+   return mbytes <= (uint64_t) ctx->Const.MaxTextureMbytes;

+}

+

+

+

+/**

+ * Helper function to determine whether a target and specific compression

+ * format are supported.

+ */

+static GLboolean

+target_can_be_compressed(const struct gl_context *ctx, GLenum target,

+                         GLenum intFormat)

+{

+   (void) intFormat;  /* not used yet */

+

+   switch (target) {

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return GL_TRUE; /* true for any compressed format so far */

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+      return ctx->Extensions.ARB_texture_cube_map;

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      return (ctx->Extensions.MESA_texture_array ||

+              ctx->Extensions.EXT_texture_array);

+   default:

+      return GL_FALSE;

+   }      

+}

+

+

+/**

+ * Check if the given texture target value is legal for a

+ * glTexImage1/2/3D call.

+ */

+static GLboolean

+legal_teximage_target(struct gl_context *ctx, GLuint dims, GLenum target)

+{

+   switch (dims) {

+   case 1:

+      switch (target) {

+      case GL_TEXTURE_1D:

+      case GL_PROXY_TEXTURE_1D:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+      }

+   case 2:

+      switch (target) {

+      case GL_TEXTURE_2D:

+      case GL_PROXY_TEXTURE_2D:

+         return GL_TRUE;

+      case GL_PROXY_TEXTURE_CUBE_MAP:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+         return ctx->Extensions.ARB_texture_cube_map;

+      case GL_TEXTURE_RECTANGLE_NV:

+      case GL_PROXY_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   case 3:

+      switch (target) {

+      case GL_TEXTURE_3D:

+      case GL_PROXY_TEXTURE_3D:

+         return GL_TRUE;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   default:

+      _mesa_problem(ctx, "invalid dims=%u in legal_teximage_target()", dims);

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if the given texture target value is legal for a

+ * glTexSubImage, glCopyTexSubImage or glCopyTexImage call.

+ * The difference compared to legal_teximage_target() above is that

+ * proxy targets are not supported.

+ */

+static GLboolean

+legal_texsubimage_target(struct gl_context *ctx, GLuint dims, GLenum target)

+{

+   switch (dims) {

+   case 1:

+      return target == GL_TEXTURE_1D;

+   case 2:

+      switch (target) {

+      case GL_TEXTURE_2D:

+         return GL_TRUE;

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+         return ctx->Extensions.ARB_texture_cube_map;

+      case GL_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   case 3:

+      switch (target) {

+      case GL_TEXTURE_3D:

+         return GL_TRUE;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   default:

+      _mesa_problem(ctx, "invalid dims=%u in legal_texsubimage_target()",

+                    dims);

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test the glTexImage[123]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param internalFormat internal format given by the user.

+ * \param format pixel data format given by the user.

+ * \param type pixel data type given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param depth image depth given by the user.

+ * \param border image border given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ *

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+texture_error_check( struct gl_context *ctx,

+                     GLuint dimensions, GLenum target,

+                     GLint level, GLint internalFormat,

+                     GLenum format, GLenum type,

+                     GLint width, GLint height,

+                     GLint depth, GLint border )

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLboolean isProxy = target == proxyTarget;

+   GLboolean sizeOK = GL_TRUE;

+   GLboolean colorFormat, indexFormat;

+

+   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(level=%d)", dimensions, level);

+      }

+      return GL_TRUE;

+   }

+

+   /* Check border */

+   if (border < 0 || border > 1 ||

+       ((target == GL_TEXTURE_RECTANGLE_NV ||

+         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(border=%d)", dimensions, border);

+      }

+      return GL_TRUE;

+   }

+

+   if (width < 0 || height < 0 || depth < 0) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(width, height or depth < 0)", dimensions);

+      }

+      return GL_TRUE;

+   }

+

+   /* Do this simple check before calling the TestProxyTexImage() function */

+   if (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {

+      sizeOK = (width == height);

+   }

+

+   /*

+    * Use the proxy texture driver hook to see if the size/level/etc are

+    * legal.

+    */

+   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                                    internalFormat, format,

+                                                    type, width, height,

+                                                    depth, border);

+   if (!sizeOK) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(level=%d, width=%d, height=%d, depth=%d)",

+                     dimensions, level, width, height, depth);

+      }

+      return GL_TRUE;

+   }

+

+   /* Check internalFormat */

+   if (_mesa_base_tex_format(ctx, internalFormat) < 0) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(internalFormat=%s)",

+                     dimensions, _mesa_lookup_enum_by_nr(internalFormat));

+      }

+      return GL_TRUE;

+   }

+

+   /* Check incoming image format and type */

+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {

+      /* Normally, GL_INVALID_OPERATION is generated by a format/type

+       * mismatch (see the 1.2 spec page 94, sec 3.6.4.).  But with the

+       * GL_EXT_texture_integer extension, some combinations should generate

+       * GL_INVALID_ENUM instead (grr!).

+       */

+      if (!isProxy) {

+         GLenum error = _mesa_is_integer_format(format)

+            ? GL_INVALID_ENUM : GL_INVALID_OPERATION;

+         _mesa_error(ctx, error,

+                     "glTexImage%dD(incompatible format 0x%x, type 0x%x)",

+                     dimensions, format, type);

+      }

+      return GL_TRUE;

+   }

+

+   /* make sure internal format and format basically agree */

+   colorFormat = _mesa_is_color_format(format);

+   indexFormat = _mesa_is_index_format(format);

+   if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) ||

+       (_mesa_is_index_format(internalFormat) && !indexFormat) ||

+       (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) ||

+       (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) ||

+       (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) ||

+       (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) {

+      if (!isProxy)

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)",

+                     dimensions, internalFormat, format);

+      return GL_TRUE;

+   }

+

+   /* additional checks for ycbcr textures */

+   if (internalFormat == GL_YCBCR_MESA) {

+      ASSERT(ctx->Extensions.MESA_ycbcr_texture);

+      if (type != GL_UNSIGNED_SHORT_8_8_MESA &&

+          type != GL_UNSIGNED_SHORT_8_8_REV_MESA) {

+         char message[100];

+         _mesa_snprintf(message, sizeof(message),

+                        "glTexImage%dD(format/type YCBCR mismatch", dimensions);

+         _mesa_error(ctx, GL_INVALID_ENUM, "%s", message);

+         return GL_TRUE; /* error */

+      }

+      if (target != GL_TEXTURE_2D &&

+          target != GL_PROXY_TEXTURE_2D &&

+          target != GL_TEXTURE_RECTANGLE_NV &&

+          target != GL_PROXY_TEXTURE_RECTANGLE_NV) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         if (!isProxy) {

+            char message[100];

+            _mesa_snprintf(message, sizeof(message),

+                           "glTexImage%dD(format=GL_YCBCR_MESA and border=%d)",

+                           dimensions, border);

+            _mesa_error(ctx, GL_INVALID_VALUE, "%s", message);

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for depth textures */

+   if (_mesa_base_tex_format(ctx, internalFormat) == GL_DEPTH_COMPONENT) {

+      /* Only 1D, 2D and rectangular textures supported, not 3D or cubes */

+      if (target != GL_TEXTURE_1D &&

+          target != GL_PROXY_TEXTURE_1D &&

+          target != GL_TEXTURE_2D &&

+          target != GL_PROXY_TEXTURE_2D &&

+          target != GL_TEXTURE_RECTANGLE_ARB &&

+          target != GL_PROXY_TEXTURE_RECTANGLE_ARB) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM,

+                        "glTexImage(target/internalFormat)");

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for compressed textures */

+   if (_mesa_is_compressed_format(ctx, internalFormat)) {

+      if (!target_can_be_compressed(ctx, target, internalFormat)) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM,

+                        "glTexImage%dD(target)", dimensions);

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         if (!isProxy) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                        "glTexImage%dD(border!=0)", dimensions);

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for integer textures */

+   if (ctx->Extensions.EXT_texture_integer &&

+       (_mesa_is_integer_format(format) !=

+        _mesa_is_integer_format(internalFormat))) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexImage%dD(integer/non-integer format mismatch)",

+                     dimensions);

+      }

+      return GL_TRUE;

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glTexSubImage[123]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param xoffset sub-image x offset given by the user.

+ * \param yoffset sub-image y offset given by the user.

+ * \param zoffset sub-image z offset given by the user.

+ * \param format pixel data format given by the user.

+ * \param type pixel data type given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param depth image depth given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ *

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+subtexture_error_check( struct gl_context *ctx, GLuint dimensions,

+                        GLenum target, GLint level,

+                        GLint xoffset, GLint yoffset, GLint zoffset,

+                        GLint width, GLint height, GLint depth,

+                        GLenum format, GLenum type )

+{

+   /* Basic level check */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level=%d)", level);

+      return GL_TRUE;

+   }

+

+   /* Check for negative sizes */

+   if (width < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(width=%d)", dimensions, width);

+      return GL_TRUE;

+   }

+   if (height < 0 && dimensions > 1) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(height=%d)", dimensions, height);

+      return GL_TRUE;

+   }

+   if (depth < 0 && dimensions > 2) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(depth=%d)", dimensions, depth);

+      return GL_TRUE;

+   }

+

+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {

+      /* As with the glTexImage2D check above, the error code here

+       * depends on texture integer.

+       */

+      GLenum error = _mesa_is_integer_format(format)

+         ? GL_INVALID_OPERATION : GL_INVALID_ENUM;

+      _mesa_error(ctx, error,

+                  "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)",

+                  dimensions, format, type);

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Do second part of glTexSubImage which depends on the destination texture.

+ * \return GL_TRUE if error recorded, GL_FALSE otherwise

+ */

+static GLboolean

+subtexture_error_check2( struct gl_context *ctx, GLuint dimensions,

+			 GLenum target, GLint level,

+			 GLint xoffset, GLint yoffset, GLint zoffset,

+			 GLint width, GLint height, GLint depth,

+			 GLenum format, GLenum type,

+			 const struct gl_texture_image *destTex )

+{

+   if (!destTex) {

+      /* undefined image level */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage%dD", dimensions);

+      return GL_TRUE;

+   }

+

+   if (xoffset < -((GLint)destTex->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset)",

+                  dimensions);

+      return GL_TRUE;

+   }

+   if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset+width)",

+                  dimensions);

+      return GL_TRUE;

+   }

+   if (dimensions > 1) {

+      if (yoffset < -((GLint)destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset)",

+                     dimensions);

+         return GL_TRUE;

+      }

+      if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset+height)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+   if (dimensions > 2) {

+      if (zoffset < -((GLint)destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");

+         return GL_TRUE;

+      }

+      if (zoffset + depth  > (GLint) (destTex->Depth + destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");

+         return GL_TRUE;

+      }

+   }

+

+   if (_mesa_is_format_compressed(destTex->TexFormat)) {

+      GLuint bw, bh;

+

+      /* do tests which depend on compression block size */

+      _mesa_get_format_block_size(destTex->TexFormat, &bw, &bh);

+

+      /* offset must be multiple of block size */

+      if ((xoffset % bw != 0) || (yoffset % bh != 0)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(xoffset = %d, yoffset = %d)",

+                     dimensions, xoffset, yoffset);

+         return GL_TRUE;

+      }

+      /* size must be multiple of bw by bh or equal to whole texture size */

+      if ((width % bw != 0) && (GLuint) width != destTex->Width) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(width = %d)", dimensions, width);

+         return GL_TRUE;

+      }         

+      if ((height % bh != 0) && (GLuint) height != destTex->Height) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(height = %d)", dimensions, height);

+         return GL_TRUE;

+      }         

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glCopyTexImage[12]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param internalFormat internal format given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param border texture border.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ * 

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+copytexture_error_check( struct gl_context *ctx, GLuint dimensions,

+                         GLenum target, GLint level, GLint internalFormat,

+                         GLint width, GLint height, GLint border )

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLenum type = GL_FLOAT;

+   GLboolean sizeOK;

+   GLint format;

+

+   /* check target */

+   if (!legal_texsubimage_target(ctx, dimensions, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexImage%uD(target=%s)",

+                  dimensions, _mesa_lookup_enum_by_nr(target));

+      return GL_TRUE;

+   }       

+

+   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexImage%dD(level=%d)", dimensions, level);

+      return GL_TRUE;

+   }

+

+   /* Check that the source buffer is complete */

+   if (ctx->ReadBuffer->Name) {

+      if (ctx->ReadBuffer->_Status == 0) {

+         _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);

+      }

+      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* Check border */

+   if (border < 0 || border > 1 ||

+       ((target == GL_TEXTURE_RECTANGLE_NV ||

+         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {

+      return GL_TRUE;

+   }

+

+   format = _mesa_base_tex_format(ctx, internalFormat);

+   if (format < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexImage%dD(internalFormat)", dimensions);

+      return GL_TRUE;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, format)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexImage%dD(missing readbuffer)", dimensions);

+      return GL_TRUE;

+   }

+

+   /* Do size, level checking */

+   sizeOK = (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB)

+      ? (width == height) : 1;

+

+   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                                    internalFormat, format,

+                                                    type, width, height,

+                                                    1, border);

+

+   if (!sizeOK) {

+      if (dimensions == 1) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexImage1D(width=%d)", width);

+      }

+      else {

+         ASSERT(dimensions == 2);

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexImage2D(width=%d, height=%d)", width, height);

+      }

+      return GL_TRUE;

+   }

+

+   if (_mesa_is_compressed_format(ctx, internalFormat)) {

+      if (!target_can_be_compressed(ctx, target, internalFormat)) {

+         _mesa_error(ctx, GL_INVALID_ENUM,

+                     "glCopyTexImage%dD(target)", dimensions);

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(border!=0)", dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (_mesa_is_depth_format(internalFormat)) {

+      /* make sure we have depth/stencil buffers */

+      if (!ctx->ReadBuffer->_DepthBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(no depth)", dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (_mesa_is_depthstencil_format(internalFormat)) {

+      /* make sure we have depth/stencil buffers */

+      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(no depth/stencil buffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glCopyTexSubImage[12]D() parameters for errors.

+ * Note that this is the first part of error checking.

+ * See also copytexsubimage_error_check2() below for the second part.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ */

+static GLboolean

+copytexsubimage_error_check1( struct gl_context *ctx, GLuint dimensions,

+                              GLenum target, GLint level)

+{

+   /* Check that the source buffer is complete */

+   if (ctx->ReadBuffer->Name) {

+      if (ctx->ReadBuffer->_Status == 0) {

+         _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);

+      }

+      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* check target (proxies not allowed) */

+   if (!legal_texsubimage_target(ctx, dimensions, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexSubImage%uD(target=%s)",

+                  dimensions, _mesa_lookup_enum_by_nr(target));

+      return GL_TRUE;

+   }

+

+   /* Check level */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(level=%d)", dimensions, level);

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Second part of error checking for glCopyTexSubImage[12]D().

+ * \param xoffset sub-image x offset given by the user.

+ * \param yoffset sub-image y offset given by the user.

+ * \param zoffset sub-image z offset given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ */

+static GLboolean

+copytexsubimage_error_check2( struct gl_context *ctx, GLuint dimensions,

+			      GLenum target, GLint level,

+			      GLint xoffset, GLint yoffset, GLint zoffset,

+			      GLsizei width, GLsizei height,

+			      const struct gl_texture_image *teximage )

+{

+   /* check that dest tex image exists */

+   if (!teximage) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(undefined texture level: %d)",

+                  dimensions, level);

+      return GL_TRUE;

+   }

+

+   /* Check size */

+   if (width < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(width=%d)", dimensions, width);

+      return GL_TRUE;

+   }

+   if (dimensions > 1 && height < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(height=%d)", dimensions, height);

+      return GL_TRUE;

+   }

+

+   /* check x/y offsets */

+   if (xoffset < -((GLint)teximage->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);

+      return GL_TRUE;

+   }

+   if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(xoffset+width)", dimensions);

+      return GL_TRUE;

+   }

+   if (dimensions > 1) {

+      if (yoffset < -((GLint)teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);

+         return GL_TRUE;

+      }

+      /* NOTE: we're adding the border here, not subtracting! */

+      if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(yoffset+height)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* check z offset */

+   if (dimensions > 2) {

+      if (zoffset < -((GLint)teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(zoffset)", dimensions);

+         return GL_TRUE;

+      }

+      if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(zoffset+depth)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   if (_mesa_is_format_compressed(teximage->TexFormat)) {

+      /* offset must be multiple of 4 */

+      if ((xoffset & 3) || (yoffset & 3)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(xoffset or yoffset)", dimensions);

+         return GL_TRUE;

+      }

+      /* size must be multiple of 4 */

+      if ((width & 3) != 0 && (GLuint) width != teximage->Width) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(width)", dimensions);

+         return GL_TRUE;

+      }         

+      if ((height & 3) != 0 && (GLuint) height != teximage->Height) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(height)", dimensions);

+         return GL_TRUE;

+      }         

+   }

+

+   if (teximage->InternalFormat == GL_YCBCR_MESA) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");

+      return GL_TRUE;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, teximage->_BaseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(missing readbuffer, format=0x%x)",

+                  dimensions, teximage->_BaseFormat);

+      return GL_TRUE;

+   }

+

+   if (teximage->_BaseFormat == GL_DEPTH_COMPONENT) {

+      if (!ctx->ReadBuffer->_DepthBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexSubImage%dD(no depth buffer)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (teximage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {

+      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexSubImage%dD(no depth/stencil buffer)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* If copying into an integer texture, the source buffer must also be

+    * integer-valued.

+    */

+   if (_mesa_is_format_integer_color(teximage->TexFormat)) {

+      struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;

+      if (!_mesa_is_format_integer_color(rb->Format)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(source buffer is not integer format)",

+                  dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/** Callback info for walking over FBO hash table */

+struct cb_info

+{

+   struct gl_context *ctx;

+   struct gl_texture_object *texObj;

+   GLuint level, face;

+};

+

+

+/**

+ * Check render to texture callback.  Called from _mesa_HashWalk().

+ */

+static void

+check_rtt_cb(GLuint key, void *data, void *userData)

+{

+   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;

+   const struct cb_info *info = (struct cb_info *) userData;

+   struct gl_context *ctx = info->ctx;

+   const struct gl_texture_object *texObj = info->texObj;

+   const GLuint level = info->level, face = info->face;

+

+   /* If this is a user-created FBO */

+   if (fb->Name) {

+      GLuint i;

+      /* check if any of the FBO's attachments point to 'texObj' */

+      for (i = 0; i < BUFFER_COUNT; i++) {

+         struct gl_renderbuffer_attachment *att = fb->Attachment + i;

+         if (att->Type == GL_TEXTURE &&

+             att->Texture == texObj &&

+             att->TextureLevel == level &&

+             att->CubeMapFace == face) {

+            ASSERT(att->Texture->Image[att->CubeMapFace][att->TextureLevel]);

+            /* Tell driver about the new renderbuffer texture */

+            ctx->Driver.RenderTexture(ctx, ctx->DrawBuffer, att);

+            /* Mark fb status as indeterminate to force re-validation */

+            fb->_Status = 0;

+         }

+      }

+   }

+}

+

+

+/**

+ * When a texture image is specified we have to check if it's bound to

+ * any framebuffer objects (render to texture) in order to detect changes

+ * in size or format since that effects FBO completeness.

+ * Any FBOs rendering into the texture must be re-validated.

+ */

+static void

+update_fbo_texture(struct gl_context *ctx, struct gl_texture_object *texObj,

+                   GLuint face, GLuint level)

+{

+   /* Only check this texture if it's been marked as RenderToTexture */

+   if (texObj->_RenderToTexture) {

+      struct cb_info info;

+      info.ctx = ctx;

+      info.texObj = texObj;

+      info.level = level;

+      info.face = face;

+      _mesa_HashWalk(ctx->Shared->FrameBuffers, check_rtt_cb, &info);

+   }

+}

+

+

+/**

+ * If the texture object's GenerateMipmap flag is set and we've

+ * changed the texture base level image, regenerate the rest of the

+ * mipmap levels now.

+ */

+static INLINE void

+check_gen_mipmap(struct gl_context *ctx, GLenum target,

+                 struct gl_texture_object *texObj, GLint level)

+{

+   ASSERT(target != GL_TEXTURE_CUBE_MAP);

+   if (texObj->GenerateMipmap &&

+       level == texObj->BaseLevel &&

+       level < texObj->MaxLevel) {

+      ASSERT(ctx->Driver.GenerateMipmap);

+      ctx->Driver.GenerateMipmap(ctx, target, texObj);

+   }

+}

+

+

+/** Debug helper: override the user-requested internal format */

+static GLenum

+override_internal_format(GLenum internalFormat, GLint width, GLint height)

+{

+#if 0

+   if (internalFormat == GL_RGBA16F_ARB ||

+       internalFormat == GL_RGBA32F_ARB) {

+      printf("Convert rgba float tex to int %d x %d\n", width, height);

+      return GL_RGBA;

+   }

+   else if (internalFormat == GL_RGB16F_ARB ||

+            internalFormat == GL_RGB32F_ARB) {

+      printf("Convert rgb float tex to int %d x %d\n", width, height);

+      return GL_RGB;

+   }

+   else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB ||

+            internalFormat == GL_LUMINANCE_ALPHA32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_LUMINANCE_ALPHA;

+   }

+   else if (internalFormat == GL_LUMINANCE16F_ARB ||

+            internalFormat == GL_LUMINANCE32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_LUMINANCE;

+   }

+   else if (internalFormat == GL_ALPHA16F_ARB ||

+            internalFormat == GL_ALPHA32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_ALPHA;

+   }

+   /*

+   else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {

+      internalFormat = GL_RGBA;

+   }

+   */

+   else {

+      return internalFormat;

+   }

+#else

+   return internalFormat;

+#endif

+}

+

+

+/**

+ * Choose the actual hardware format for a texture image.

+ * Try to use the same format as the previous image level when possible.

+ * Otherwise, ask the driver for the best format.

+ * It's important to try to choose a consistant format for all levels

+ * for efficient texture memory layout/allocation.  In particular, this

+ * comes up during automatic mipmap generation.

+ */

+gl_format

+_mesa_choose_texture_format(struct gl_context *ctx,

+                            struct gl_texture_object *texObj,

+                            GLenum target, GLint level,

+                            GLenum internalFormat, GLenum format, GLenum type)

+{

+   gl_format f;

+

+   /* see if we've already chosen a format for the previous level */

+   if (level > 0) {

+      struct gl_texture_image *prevImage =

+	 _mesa_select_tex_image(ctx, texObj, target, level - 1);

+      /* See if the prev level is defined and has an internal format which

+       * matches the new internal format.

+       */

+      if (prevImage &&

+          prevImage->Width > 0 &&

+          prevImage->InternalFormat == internalFormat) {

+         /* use the same format */

+         ASSERT(prevImage->TexFormat != MESA_FORMAT_NONE);

+         return prevImage->TexFormat;

+      }

+   }

+

+   /* choose format from scratch */

+   f = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);

+   ASSERT(f != MESA_FORMAT_NONE);

+   return f;

+}

+

+

+/**

+ * Common code to implement all the glTexImage1D/2D/3D functions.

+ */

+static void

+teximage(struct gl_context *ctx, GLuint dims,

+         GLenum target, GLint level, GLint internalFormat,

+         GLsizei width, GLsizei height, GLsizei depth,

+         GLint border, GLenum format, GLenum type,

+         const GLvoid *pixels)

+{

+   GLboolean error;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glTexImage%uD %s %d %s %d %d %d %d %s %s %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  width, height, depth, border,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type), pixels);

+

+   internalFormat = override_internal_format(internalFormat, width, height);

+

+   /* target error checking */

+   if (!legal_teximage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }

+

+   /* general error checking */

+   error = texture_error_check(ctx, dims, target, level, internalFormat,

+                               format, type, width, height, depth, border);

+

+   if (_mesa_is_proxy_texture(target)) {

+      /* Proxy texture: just clear or set state depending on error checking */

+      struct gl_texture_image *texImage =

+         _mesa_get_proxy_tex_image(ctx, target, level);

+

+      if (error) {

+         /* when error, clear all proxy texture image parameters */

+         if (texImage)

+            clear_teximage_fields(texImage);

+      }

+      else {

+         /* no error, set the tex image parameters */

+         struct gl_texture_object *texObj =

+            _mesa_get_current_tex_object(ctx, target);

+         gl_format texFormat = _mesa_choose_texture_format(ctx, texObj,

+                                                           target, level,

+                                                           internalFormat,

+                                                           format, type);

+

+         if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height,

+                                       depth, border, internalFormat,

+                                       texFormat);

+         }

+         else if (texImage) {

+            clear_teximage_fields(texImage);

+         }

+      }

+   }

+   else {

+      /* non-proxy target */

+      const GLuint face = _mesa_tex_target_to_face(target);

+      struct gl_texture_object *texObj;

+      struct gl_texture_image *texImage;

+

+      if (error) {

+         return;   /* error was recorded */

+      }

+

+      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+	 _mesa_update_state(ctx);

+

+      texObj = _mesa_get_current_tex_object(ctx, target);

+

+      _mesa_lock_texture(ctx, texObj);

+      {

+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+

+	 if (!texImage) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);

+	 }

+         else {

+            gl_format texFormat;

+

+            if (texImage->Data) {

+               ctx->Driver.FreeTexImageData( ctx, texImage );

+            }

+

+            ASSERT(texImage->Data == NULL);

+            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                    internalFormat, format,

+                                                    type);

+

+            if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+               _mesa_init_teximage_fields(ctx, target, texImage,

+                                          width, height, depth,

+                                          border, internalFormat, texFormat);

+

+               /* Give the texture to the driver.  <pixels> may be null. */

+               ASSERT(ctx->Driver.TexImage3D);

+               switch (dims) {

+               case 1:

+                  ctx->Driver.TexImage1D(ctx, target, level, internalFormat,

+                                         width, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               case 2:

+                  ctx->Driver.TexImage2D(ctx, target, level, internalFormat,

+                                         width, height, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               case 3:

+                  ctx->Driver.TexImage3D(ctx, target, level, internalFormat,

+                                         width, height, depth, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               default:

+                  _mesa_problem(ctx, "invalid dims=%u in teximage()", dims);

+               }

+

+               check_gen_mipmap(ctx, target, texObj, level);

+

+               update_fbo_texture(ctx, texObj, face, level);

+

+               /* state update */

+               texObj->_Complete = GL_FALSE;

+               ctx->NewState |= _NEW_TEXTURE;

+            }

+            else {

+               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);

+            }

+         }

+      }

+      _mesa_unlock_texture(ctx, texObj);

+   }

+}

+

+

+/*

+ * Called from the API.  Note that width includes the border.

+ */

+void GLAPIENTRY

+_mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLint border, GLenum format,

+                  GLenum type, const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 1, target, level, internalFormat, width, 1, 1,

+            border, format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLsizei height, GLint border,

+                  GLenum format, GLenum type,

+                  const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 2, target, level, internalFormat, width, height, 1,

+            border, format, type, pixels);

+}

+

+

+/*

+ * Called by the API or display list executor.

+ * Note that width and height include the border.

+ */

+void GLAPIENTRY

+_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLsizei height, GLsizei depth,

+                  GLint border, GLenum format, GLenum type,

+                  const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 3, target, level, internalFormat, width, height, depth,

+            border, format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalFormat,

+                     GLsizei width, GLsizei height, GLsizei depth,

+                     GLint border, GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,

+                    depth, border, format, type, pixels);

+}

+

+

+#if FEATURE_OES_EGL_image

+void GLAPIENTRY

+_mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (!ctx->Extensions.OES_EGL_image) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glEGLImageTargetTexture2DOES(unsupported)");

+      return;

+   }

+

+   if (target != GL_TEXTURE_2D) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+		  "glEGLImageTargetTexture2D(target=%d)", target);

+      return;

+   }

+

+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_state(ctx);

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   _mesa_lock_texture(ctx, texObj);

+

+   texImage = _mesa_get_tex_image(ctx, texObj, target, 0);

+   if (!texImage) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEGLImageTargetTexture2D");

+   } else {

+      if (texImage->Data)

+	 ctx->Driver.FreeTexImageData( ctx, texImage );

+

+      ASSERT(texImage->Data == NULL);

+      ctx->Driver.EGLImageTargetTexture2D(ctx, target,

+					  texObj, texImage, image);

+

+      /* state update */

+      texObj->_Complete = GL_FALSE;

+      ctx->NewState |= _NEW_TEXTURE;

+   }

+   _mesa_unlock_texture(ctx, texObj);

+

+}

+#endif

+

+

+

+/**

+ * Implement all the glTexSubImage1/2/3D() functions.

+ */

+static void

+texsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,

+            GLint xoffset, GLint yoffset, GLint zoffset,

+            GLsizei width, GLsizei height, GLsizei depth,

+            GLenum format, GLenum type, const GLvoid *pixels )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glTexSubImage%uD %s %d %d %d %d %d %d %d %s %s %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  xoffset, yoffset, zoffset, width, height, depth,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type), pixels);

+

+   /* check target (proxies not allowed) */

+   if (!legal_texsubimage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }       

+

+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_state(ctx);

+

+   if (subtexture_error_check(ctx, dims, target, level, xoffset, yoffset, zoffset,

+                              width, height, depth, format, type)) {

+      return;   /* error was detected */

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+      if (subtexture_error_check2(ctx, dims, target, level,

+                                  xoffset, yoffset, zoffset,

+				  width, height, depth,

+                                  format, type, texImage)) {

+         /* error was recorded */

+      }

+      else if (width > 0 && height > 0 && height > 0) {

+         /* If we have a border, offset=-1 is legal.  Bias by border width. */

+         switch (dims) {

+         case 3:

+            zoffset += texImage->Border;

+            /* fall-through */

+         case 2:

+            yoffset += texImage->Border;

+            /* fall-through */

+         case 1:

+            xoffset += texImage->Border;

+         }

+

+         switch (dims) {

+         case 1:

+            ctx->Driver.TexSubImage1D(ctx, target, level,

+                                      xoffset, width,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         case 2:

+            ctx->Driver.TexSubImage2D(ctx, target, level,

+                                      xoffset, yoffset, width, height,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         case 3:

+            ctx->Driver.TexSubImage3D(ctx, target, level,

+                                      xoffset, yoffset, zoffset,

+                                      width, height, depth,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         default:

+            _mesa_problem(ctx, "unexpected dims in subteximage()");

+         }

+

+         check_gen_mipmap(ctx, target, texObj, level);

+

+         ctx->NewState |= _NEW_TEXTURE;

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_TexSubImage1D( GLenum target, GLint level,

+                     GLint xoffset, GLsizei width,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 1, target, level,

+               xoffset, 0, 0,

+               width, 1, 1,

+               format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexSubImage2D( GLenum target, GLint level,

+                     GLint xoffset, GLint yoffset,

+                     GLsizei width, GLsizei height,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 2, target, level,

+               xoffset, yoffset, 0,

+               width, height, 1,

+               format, type, pixels);

+}

+

+

+

+void GLAPIENTRY

+_mesa_TexSubImage3D( GLenum target, GLint level,

+                     GLint xoffset, GLint yoffset, GLint zoffset,

+                     GLsizei width, GLsizei height, GLsizei depth,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 3, target, level,

+               xoffset, yoffset, zoffset,

+               width, height, depth,

+               format, type, pixels);

+}

+

+

+

+/**

+ * Implement the glCopyTexImage1/2D() functions.

+ */

+static void

+copyteximage(struct gl_context *ctx, GLuint dims,

+             GLenum target, GLint level, GLenum internalFormat,

+             GLint x, GLint y, GLsizei width, GLsizei height, GLint border )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glCopyTexImage%uD %s %d %s %d %d %d %d %d\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  x, y, width, height, border);

+

+   if (ctx->NewState & NEW_COPY_TEX_STATE)

+      _mesa_update_state(ctx);

+

+   if (copytexture_error_check(ctx, dims, target, level, internalFormat,

+                               width, height, border))

+      return;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+

+      if (!texImage) {

+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);

+      }

+      else {

+         gl_format texFormat;

+

+         if (texImage->Data) {

+            ctx->Driver.FreeTexImageData( ctx, texImage );

+         }

+

+         ASSERT(texImage->Data == NULL);

+

+         texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                 internalFormat, GL_NONE,

+                                                 GL_NONE);

+

+         if (legal_texture_size(ctx, texFormat, width, height, 1)) {

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,

+                                       border, internalFormat, texFormat);

+

+            ASSERT(ctx->Driver.CopyTexImage2D);

+            if (dims == 1)

+               ctx->Driver.CopyTexImage1D(ctx, target, level, internalFormat,

+                                          x, y, width, border);

+            else

+               ctx->Driver.CopyTexImage2D(ctx, target, level, internalFormat,

+                                          x, y, width, height, border);

+

+            check_gen_mipmap(ctx, target, texObj, level);

+

+            update_fbo_texture(ctx, texObj, face, level);

+

+            /* state update */

+            texObj->_Complete = GL_FALSE;

+            ctx->NewState |= _NEW_TEXTURE;

+         }

+         else {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);

+         }

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexImage1D( GLenum target, GLint level,

+                      GLenum internalFormat,

+                      GLint x, GLint y,

+                      GLsizei width, GLint border )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copyteximage(ctx, 1, target, level, internalFormat, x, y, width, 1, border);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,

+                      GLint x, GLint y, GLsizei width, GLsizei height,

+                      GLint border )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copyteximage(ctx, 2, target, level, internalFormat,

+                x, y, width, height, border);

+}

+

+

+

+/**

+ * Implementation for glCopyTexSubImage1/2/3D() functions.

+ */

+static void

+copytexsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,

+                GLint xoffset, GLint yoffset, GLint zoffset,

+                GLint x, GLint y, GLsizei width, GLsizei height)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glCopyTexSubImage%uD %s %d %d %d %d %d %d %d %d\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target),

+                  level, xoffset, yoffset, zoffset, x, y, width, height);

+

+   if (ctx->NewState & NEW_COPY_TEX_STATE)

+      _mesa_update_state(ctx);

+

+   if (copytexsubimage_error_check1(ctx, dims, target, level))

+      return;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+      if (copytexsubimage_error_check2(ctx, dims, target, level, xoffset, yoffset,

+				       zoffset, width, height, texImage)) {

+         /* error was recored */

+      }

+      else {

+         /* If we have a border, offset=-1 is legal.  Bias by border width. */

+         switch (dims) {

+         case 3:

+            zoffset += texImage->Border;

+            /* fall-through */

+         case 2:

+            yoffset += texImage->Border;

+            /* fall-through */

+         case 1:

+            xoffset += texImage->Border;

+         }

+

+         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,

+                                        &width, &height)) {

+            switch (dims) {

+            case 1:

+               ctx->Driver.CopyTexSubImage1D(ctx, target, level,

+                                             xoffset, x, y, width);

+               break;

+            case 2:

+               ctx->Driver.CopyTexSubImage2D(ctx, target, level,

+                                             xoffset, yoffset,

+                                             x, y, width, height);

+               break;

+            case 3:

+               ctx->Driver.CopyTexSubImage3D(ctx, target, level,

+                                             xoffset, yoffset, zoffset,

+                                             x, y, width, height);

+               break;

+            default:

+               _mesa_problem(ctx, "bad dims in copytexsubimage()");

+            }

+

+            check_gen_mipmap(ctx, target, texObj, level);

+

+            ctx->NewState |= _NEW_TEXTURE;

+         }

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage1D( GLenum target, GLint level,

+                         GLint xoffset, GLint x, GLint y, GLsizei width )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 1, target, level, xoffset, 0, 0, x, y, width, 1);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage2D( GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset,

+                         GLint x, GLint y, GLsizei width, GLsizei height )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 2, target, level, xoffset, yoffset, 0, x, y,

+                   width, height);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage3D( GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset, GLint zoffset,

+                         GLint x, GLint y, GLsizei width, GLsizei height )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 3, target, level, xoffset, yoffset, zoffset,

+                   x, y, width, height);

+}

+

+

+

+

+/**********************************************************************/

+/******                   Compressed Textures                    ******/

+/**********************************************************************/

+

+

+/**

+ * Return expected size of a compressed texture.

+ */

+static GLuint

+compressed_tex_size(GLsizei width, GLsizei height, GLsizei depth,

+                    GLenum glformat)

+{

+   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);

+   return _mesa_format_image_size(mesaFormat, width, height, depth);

+}

+

+

+/*

+ * Return compressed texture block size, in pixels.

+ */

+static void

+get_compressed_block_size(GLenum glformat, GLuint *bw, GLuint *bh)

+{

+   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);

+   _mesa_get_format_block_size(mesaFormat, bw, bh);

+}

+

+

+/**

+ * Error checking for glCompressedTexImage[123]D().

+ * \return error code or GL_NO_ERROR.

+ */

+static GLenum

+compressed_texture_error_check(struct gl_context *ctx, GLint dimensions,

+                               GLenum target, GLint level,

+                               GLenum internalFormat, GLsizei width,

+                               GLsizei height, GLsizei depth, GLint border,

+                               GLsizei imageSize)

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);

+   GLint expectedSize;

+

+   /* check level */

+   if (level < 0 || level >= maxLevels)

+      return GL_INVALID_VALUE;

+

+   if (!target_can_be_compressed(ctx, target, internalFormat)) {

+      return GL_INVALID_ENUM;

+   }

+

+   /* This will detect any invalid internalFormat value */

+   if (!_mesa_is_compressed_format(ctx, internalFormat))

+      return GL_INVALID_ENUM;

+

+   /* This should really never fail */

+   if (_mesa_base_tex_format(ctx, internalFormat) < 0)

+      return GL_INVALID_ENUM;

+

+   /* No compressed formats support borders at this time */

+   if (border != 0)

+      return GL_INVALID_VALUE;

+

+   /* For cube map, width must equal height */

+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height)

+      return GL_INVALID_VALUE;

+

+   /* check image size against compression block size */

+   {

+      gl_format texFormat =

+         ctx->Driver.ChooseTextureFormat(ctx, internalFormat,

+                                         GL_NONE, GL_NONE);

+      GLuint bw, bh;

+

+      _mesa_get_format_block_size(texFormat, &bw, &bh);

+      if ((width > bw && width % bw > 0) ||

+          (height > bh && height % bh > 0)) {

+         /*

+          * Per GL_ARB_texture_compression:  GL_INVALID_OPERATION is

+          * generated [...] if any parameter combinations are not

+          * supported by the specific compressed internal format. 

+          */

+         return GL_INVALID_OPERATION;

+      }

+   }

+

+   /* check image sizes */

+   if (!ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                      internalFormat, GL_NONE, GL_NONE,

+                                      width, height, depth, border)) {

+      /* See error comment above */

+      return GL_INVALID_OPERATION;

+   }

+

+   /* check image size in bytes */

+   expectedSize = compressed_tex_size(width, height, depth, internalFormat);

+   if (expectedSize != imageSize) {

+      /* Per GL_ARB_texture_compression:  GL_INVALID_VALUE is generated [...]

+       * if <imageSize> is not consistent with the format, dimensions, and

+       * contents of the specified image.

+       */

+      return GL_INVALID_VALUE;

+   }

+

+   return GL_NO_ERROR;

+}

+

+

+/**

+ * Error checking for glCompressedTexSubImage[123]D().

+ * \warning  There are some bad assumptions here about the size of compressed

+ *           texture tiles (multiple of 4) used to test the validity of the

+ *           offset and size parameters.

+ * \return error code or GL_NO_ERROR.

+ */

+static GLenum

+compressed_subtexture_error_check(struct gl_context *ctx, GLint dimensions,

+                                  GLenum target, GLint level,

+                                  GLint xoffset, GLint yoffset, GLint zoffset,

+                                  GLsizei width, GLsizei height, GLsizei depth,

+                                  GLenum format, GLsizei imageSize)

+{

+   GLint expectedSize, maxLevels = 0, maxTextureSize;

+   GLuint bw, bh;

+   (void) zoffset;

+

+   if (dimensions == 1) {

+      /* 1D compressed textures not allowed */

+      return GL_INVALID_ENUM;

+   }

+   else if (dimensions == 2) {

+      if (target == GL_PROXY_TEXTURE_2D) {

+         maxLevels = ctx->Const.MaxTextureLevels;

+      }

+      else if (target == GL_TEXTURE_2D) {

+         maxLevels = ctx->Const.MaxTextureLevels;

+      }

+      else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {

+         if (!ctx->Extensions.ARB_texture_cube_map)

+            return GL_INVALID_ENUM; /*target*/

+         maxLevels = ctx->Const.MaxCubeTextureLevels;

+      }

+      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {

+         if (!ctx->Extensions.ARB_texture_cube_map)

+            return GL_INVALID_ENUM; /*target*/

+         maxLevels = ctx->Const.MaxCubeTextureLevels;

+      }

+      else {

+         return GL_INVALID_ENUM; /*target*/

+      }

+   }

+   else if (dimensions == 3) {

+      /* 3D compressed textures not allowed */

+      return GL_INVALID_ENUM;

+   }

+

+   maxTextureSize = 1 << (maxLevels - 1);

+

+   /* this will catch any invalid compressed format token */

+   if (!_mesa_is_compressed_format(ctx, format))

+      return GL_INVALID_ENUM;

+

+   if (width < 1 || width > maxTextureSize)

+      return GL_INVALID_VALUE;

+

+   if ((height < 1 || height > maxTextureSize)

+       && dimensions > 1)

+      return GL_INVALID_VALUE;

+

+   if (level < 0 || level >= maxLevels)

+      return GL_INVALID_VALUE;

+

+   /*

+    * do checks which depend on compression block size

+    */

+   get_compressed_block_size(format, &bw, &bh);

+

+   if ((xoffset % bw != 0) || (yoffset % bh != 0))

+      return GL_INVALID_VALUE;

+

+   if ((width % bw != 0) && width != 2 && width != 1)

+      return GL_INVALID_VALUE;

+

+   if ((height % bh != 0) && height != 2 && height != 1)

+      return GL_INVALID_VALUE;

+

+   expectedSize = compressed_tex_size(width, height, depth, format);

+   if (expectedSize != imageSize)

+      return GL_INVALID_VALUE;

+

+   return GL_NO_ERROR;

+}

+

+

+/**

+ * Do second part of glCompressedTexSubImage error checking.

+ * \return GL_TRUE if error found, GL_FALSE otherwise.

+ */

+static GLboolean

+compressed_subtexture_error_check2(struct gl_context *ctx, GLuint dims,

+                                   GLsizei width, GLsizei height,

+                                   GLsizei depth, GLenum format,

+                                   struct gl_texture_image *texImage)

+{

+

+   if ((GLint) format != texImage->InternalFormat) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCompressedTexSubImage%uD(format=0x%x)", dims, format);

+      return GL_TRUE;

+   }

+

+   if (((width == 1 || width == 2) &&

+        width != (GLsizei) texImage->Width) ||

+       (width > (GLsizei) texImage->Width)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCompressedTexSubImage%uD(width=%d)", dims, width);

+      return GL_TRUE;

+   }

+

+   if (dims >= 2) {

+      if (((height == 1 || height == 2) &&

+           height != (GLsizei) texImage->Height) ||

+          (height > (GLsizei) texImage->Height)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCompressedTexSubImage%uD(height=%d)", dims, height);

+         return GL_TRUE;

+      }

+   }

+

+   if (dims >= 3) {

+      if (((depth == 1 || depth == 2) &&

+           depth != (GLsizei) texImage->Depth) ||

+          (depth > (GLsizei) texImage->Depth)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCompressedTexSubImage%uD(depth=%d)", dims, depth);

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Implementation of the glCompressedTexImage1/2/3D() functions.

+ */

+static void

+compressedteximage(struct gl_context *ctx, GLuint dims,

+                   GLenum target, GLint level,

+                   GLenum internalFormat, GLsizei width,

+                   GLsizei height, GLsizei depth, GLint border,

+                   GLsizei imageSize, const GLvoid *data)

+{

+   GLenum error;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx,

+                  "glCompressedTexImage%uDARB %s %d %s %d %d %d %d %d %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  width, height, depth, border, imageSize, data);

+

+   /* check target */

+   if (!legal_teximage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }

+

+   error = compressed_texture_error_check(ctx, dims, target, level,

+                                          internalFormat, width, height, depth,

+                                          border, imageSize);

+

+#if FEATURE_ES

+   /* XXX this is kind of a hack */

+   if (error) {

+      _mesa_error(ctx, error, "glTexImage2D");

+      return;

+   }

+

+   if (dims == 2) {

+      switch (internalFormat) {

+      case GL_PALETTE4_RGB8_OES:

+      case GL_PALETTE4_RGBA8_OES:

+      case GL_PALETTE4_R5_G6_B5_OES:

+      case GL_PALETTE4_RGBA4_OES:

+      case GL_PALETTE4_RGB5_A1_OES:

+      case GL_PALETTE8_RGB8_OES:

+      case GL_PALETTE8_RGBA8_OES:

+      case GL_PALETTE8_R5_G6_B5_OES:

+      case GL_PALETTE8_RGBA4_OES:

+      case GL_PALETTE8_RGB5_A1_OES:

+         _mesa_cpal_compressed_teximage2d(target, level, internalFormat,

+                                          width, height, imageSize, data);

+         return;

+      }

+   }

+#endif

+

+   if (_mesa_is_proxy_texture(target)) {

+      /* Proxy texture: just check for errors and update proxy state */

+      struct gl_texture_image *texImage;

+

+      if (!error) {

+         struct gl_texture_object *texObj =

+            _mesa_get_current_tex_object(ctx, target);

+         gl_format texFormat =

+            _mesa_choose_texture_format(ctx, texObj, target, level,

+                                        internalFormat, GL_NONE, GL_NONE);

+         if (!legal_texture_size(ctx, texFormat, width, height, depth)) {

+            error = GL_OUT_OF_MEMORY;

+         }

+      }

+

+      texImage = _mesa_get_proxy_tex_image(ctx, target, level);

+      if (texImage) {

+         if (error) {

+            /* if error, clear all proxy texture image parameters */

+            clear_teximage_fields(texImage);

+         }

+         else {

+            /* no error: store the teximage parameters */

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height,

+                                       depth, border, internalFormat,

+                                       MESA_FORMAT_NONE);

+         }

+      }

+   }

+   else {

+      /* non-proxy target */

+      struct gl_texture_object *texObj;

+      struct gl_texture_image *texImage;

+

+      if (error) {

+         _mesa_error(ctx, error, "glCompressedTexImage%uD", dims);

+         return;

+      }

+

+      texObj = _mesa_get_current_tex_object(ctx, target);

+

+      _mesa_lock_texture(ctx, texObj);

+      {

+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+	 if (!texImage) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY,

+                        "glCompressedTexImage%uD", dims);

+	 }

+         else {

+            gl_format texFormat;

+

+            if (texImage->Data) {

+               ctx->Driver.FreeTexImageData( ctx, texImage );

+            }

+            ASSERT(texImage->Data == NULL);

+

+            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                    internalFormat, GL_NONE,

+                                                    GL_NONE);

+

+            if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+               _mesa_init_teximage_fields(ctx, target, texImage,

+                                          width, height, depth,

+                                          border, internalFormat, texFormat);

+

+               switch (dims) {

+               case 1:

+                  ASSERT(ctx->Driver.CompressedTexImage1D);

+                  ctx->Driver.CompressedTexImage1D(ctx, target, level,

+                                                   internalFormat,

+                                                   width,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               case 2:

+                  ASSERT(ctx->Driver.CompressedTexImage2D);

+                  ctx->Driver.CompressedTexImage2D(ctx, target, level,

+                                                   internalFormat,

+                                                   width, height,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               case 3:

+                  ASSERT(ctx->Driver.CompressedTexImage3D);

+                  ctx->Driver.CompressedTexImage3D(ctx, target, level,

+                                                   internalFormat,

+                                                   width, height, depth,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               default:

+                  _mesa_problem(ctx, "bad dims in compressedteximage");

+               }

+

+               check_gen_mipmap(ctx, target, texObj, level);

+

+               /* state update */

+               texObj->_Complete = GL_FALSE;

+               ctx->NewState |= _NEW_TEXTURE;

+            }

+            else {

+               _mesa_error(ctx, GL_OUT_OF_MEMORY,

+                           "glCompressedTexImage%uD", dims);

+            }

+         }

+      }

+      _mesa_unlock_texture(ctx, texObj);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage1DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLint border, GLsizei imageSize,

+                              const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 1, target, level, internalFormat,

+                      width, 1, 1, border, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage2DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLsizei height, GLint border, GLsizei imageSize,

+                              const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 2, target, level, internalFormat,

+                      width, height, 1, border, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage3DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLsizei height, GLsizei depth, GLint border,

+                              GLsizei imageSize, const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 3, target, level, internalFormat,

+                      width, height, depth, border, imageSize, data);

+}

+

+

+/**

+ * Common helper for glCompressedTexSubImage1/2/3D().

+ */

+static void

+compressed_tex_sub_image(GLuint dims, GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset, GLint zoffset,

+                         GLsizei width, GLsizei height, GLsizei depth,

+                         GLenum format, GLsizei imageSize, const GLvoid *data)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GLenum error;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   error = compressed_subtexture_error_check(ctx, dims, target, level,

+                                             xoffset, 0, 0, /* pos */

+                                             width, height, depth,   /* size */

+                                             format, imageSize);

+   if (error) {

+      _mesa_error(ctx, error, "glCompressedTexSubImage%uD", dims);

+      return;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+      assert(texImage);

+

+      if (compressed_subtexture_error_check2(ctx, dims, width, height, depth,

+                                             format, texImage)) {

+         /* error was recorded */

+      }

+      else if (width > 0 && height > 0 && depth > 0) {

+         switch (dims) {

+         case 1:

+            if (ctx->Driver.CompressedTexSubImage1D) {

+               ctx->Driver.CompressedTexSubImage1D(ctx, target, level,

+                                                   xoffset, width,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         case 2:

+            if (ctx->Driver.CompressedTexSubImage2D) {

+               ctx->Driver.CompressedTexSubImage2D(ctx, target, level,

+                                                   xoffset, yoffset,

+                                                   width, height,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         case 3:

+            if (ctx->Driver.CompressedTexSubImage3D) {

+               ctx->Driver.CompressedTexSubImage3D(ctx, target, level,

+                                                   xoffset, yoffset, zoffset,

+                                                   width, height, depth,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         default:

+            ;

+         }

+

+         check_gen_mipmap(ctx, target, texObj, level);

+

+         ctx->NewState |= _NEW_TEXTURE;

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLsizei width, GLenum format,

+                                 GLsizei imageSize, const GLvoid *data)

+{

+   compressed_tex_sub_image(1, target, level, xoffset, 0, 0, width, 1, 1,

+                            format, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLint yoffset, GLsizei width, GLsizei height,

+                                 GLenum format, GLsizei imageSize,

+                                 const GLvoid *data)

+{

+   compressed_tex_sub_image(2, target, level, xoffset, yoffset, 0,

+                            width, height, 1, format, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLint yoffset, GLint zoffset, GLsizei width,

+                                 GLsizei height, GLsizei depth, GLenum format,

+                                 GLsizei imageSize, const GLvoid *data)

+{

+   compressed_tex_sub_image(3, target, level, xoffset, yoffset, zoffset,

+                            width, height, depth, format, imageSize, data);

+}

diff --git a/mesalib/src/mesa/main/texstate.c b/mesalib/src/mesa/main/texstate.c
index 41d531f59..40282eabf 100644
--- a/mesalib/src/mesa/main/texstate.c
+++ b/mesalib/src/mesa/main/texstate.c
@@ -1,841 +1,841 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/** 
- * \file texstate.c
- *
- * Texture state handling.
- */
-
-#include "glheader.h"
-#include "mfeatures.h"
-#include "colormac.h"
-#include "colortab.h"
-#include "context.h"
-#include "enums.h"
-#include "macros.h"
-#include "texobj.h"
-#include "teximage.h"
-#include "texstate.h"
-#include "mtypes.h"
-
-
-
-/**
- * Default texture combine environment state.  This is used to initialize
- * a context's texture units and as the basis for converting "classic"
- * texture environmnets to ARB_texture_env_combine style values.
- */
-static const struct gl_tex_env_combine_state default_combine_state = {
-   GL_MODULATE, GL_MODULATE,
-   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
-   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
-   { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA },
-   { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },
-   0, 0,
-   2, 2
-};
-
-
-
-/**
- * Used by glXCopyContext to copy texture state from one context to another.
- */
-void
-_mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst )
-{
-   GLuint u, tex;
-
-   ASSERT(src);
-   ASSERT(dst);
-
-   dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
-   dst->Texture._GenFlags = src->Texture._GenFlags;
-   dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
-   dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
-   dst->Texture.SharedPalette = src->Texture.SharedPalette;
-
-   /* per-unit state */
-   for (u = 0; u < src->Const.MaxCombinedTextureImageUnits; u++) {
-      dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled;
-      dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode;
-      COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor);
-      dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled;
-      dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS;
-      dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT;
-      dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR;
-      dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ;
-      dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias;
-
-      /* GL_EXT_texture_env_combine */
-      dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine;
-
-      /* GL_ATI_envmap_bumpmap - need this? */
-      dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget;
-      COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix);
-
-      /*
-       * XXX strictly speaking, we should compare texture names/ids and
-       * bind textures in the dest context according to id.  For now, only
-       * copy bindings if the contexts share the same pool of textures to
-       * avoid refcounting bugs.
-       */
-      if (dst->Shared == src->Shared) {
-         /* copy texture object bindings, not contents of texture objects */
-         _mesa_lock_context_textures(dst);
-
-         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
-            _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],
-                                   src->Texture.Unit[u].CurrentTex[tex]);
-         }
-         _mesa_unlock_context_textures(dst);
-      }
-   }
-}
-
-
-/*
- * For debugging
- */
-void
-_mesa_print_texunit_state( struct gl_context *ctx, GLuint unit )
-{
-   const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit;
-   printf("Texture Unit %d\n", unit);
-   printf("  GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));
-   printf("  GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));
-   printf("  GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));
-   printf("  GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));
-   printf("  GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));
-   printf("  GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));
-   printf("  GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));
-   printf("  GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));
-   printf("  GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));
-   printf("  GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));
-   printf("  GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));
-   printf("  GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));
-   printf("  GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));
-   printf("  GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));
-   printf("  GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));
-   printf("  GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
-   printf("  GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
-   printf("  GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
-}
-
-
-
-/**********************************************************************/
-/*                       Texture Environment                          */
-/**********************************************************************/
-
-/**
- * Convert "classic" texture environment to ARB_texture_env_combine style
- * environments.
- * 
- * \param state  texture_env_combine state vector to be filled-in.
- * \param mode   Classic texture environment mode (i.e., \c GL_REPLACE,
- *               \c GL_BLEND, \c GL_DECAL, etc.).
- * \param texBaseFormat  Base format of the texture associated with the
- *               texture unit.
- */
-static void
-calculate_derived_texenv( struct gl_tex_env_combine_state *state,
-			  GLenum mode, GLenum texBaseFormat )
-{
-   GLenum mode_rgb;
-   GLenum mode_a;
-
-   *state = default_combine_state;
-
-   switch (texBaseFormat) {
-   case GL_ALPHA:
-      state->SourceRGB[0] = GL_PREVIOUS;
-      break;
-
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_RGBA:
-      break;
-
-   case GL_LUMINANCE:
-   case GL_RED:
-   case GL_RG:
-   case GL_RGB:
-   case GL_YCBCR_MESA:
-   case GL_DUDV_ATI:
-      state->SourceA[0] = GL_PREVIOUS;
-      break;
-      
-   default:
-      _mesa_problem(NULL,
-                    "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
-                    texBaseFormat);
-      return;
-   }
-
-   if (mode == GL_REPLACE_EXT)
-      mode = GL_REPLACE;
-
-   switch (mode) {
-   case GL_REPLACE:
-   case GL_MODULATE:
-      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode;
-      mode_a   = mode;
-      break;
-   
-   case GL_DECAL:
-      mode_rgb = GL_INTERPOLATE;
-      mode_a   = GL_REPLACE;
-
-      state->SourceA[0] = GL_PREVIOUS;
-
-      /* Having alpha / luminance / intensity textures replace using the
-       * incoming fragment color matches the definition in NV_texture_shader.
-       * The 1.5 spec simply marks these as "undefined".
-       */
-      switch (texBaseFormat) {
-      case GL_ALPHA:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_ALPHA:
-      case GL_INTENSITY:
-	 state->SourceRGB[0] = GL_PREVIOUS;
-	 break;
-      case GL_RED:
-      case GL_RG:
-      case GL_RGB:
-      case GL_YCBCR_MESA:
-      case GL_DUDV_ATI:
-	 mode_rgb = GL_REPLACE;
-	 break;
-      case GL_RGBA:
-	 state->SourceRGB[2] = GL_TEXTURE;
-	 break;
-      }
-      break;
-
-   case GL_BLEND:
-      mode_rgb = GL_INTERPOLATE;
-      mode_a   = GL_MODULATE;
-
-      switch (texBaseFormat) {
-      case GL_ALPHA:
-	 mode_rgb = GL_REPLACE;
-	 break;
-      case GL_INTENSITY:
-	 mode_a = GL_INTERPOLATE;
-	 state->SourceA[0] = GL_CONSTANT;
-	 state->OperandA[2] = GL_SRC_ALPHA;
-	 /* FALLTHROUGH */
-      case GL_LUMINANCE:
-      case GL_RED:
-      case GL_RG:
-      case GL_RGB:
-      case GL_LUMINANCE_ALPHA:
-      case GL_RGBA:
-      case GL_YCBCR_MESA:
-      case GL_DUDV_ATI:
-	 state->SourceRGB[2] = GL_TEXTURE;
-	 state->SourceA[2]   = GL_TEXTURE;
-	 state->SourceRGB[0] = GL_CONSTANT;
-	 state->OperandRGB[2] = GL_SRC_COLOR;
-	 break;
-      }
-      break;
-
-   case GL_ADD:
-      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : GL_ADD;
-      mode_a   = (texBaseFormat == GL_INTENSITY) ? GL_ADD : GL_MODULATE;
-      break;
-
-   default:
-      _mesa_problem(NULL,
-                    "Invalid texture env mode 0x%x in calculate_derived_texenv",
-                    mode);
-      return;
-   }
-   
-   state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS)
-       ? mode_rgb : GL_REPLACE;
-   state->ModeA   = (state->SourceA[0]   != GL_PREVIOUS)
-       ? mode_a   : GL_REPLACE;
-}
-
-
-
-
-/* GL_ARB_multitexture */
-void GLAPIENTRY
-_mesa_ActiveTextureARB(GLenum texture)
-{
-   const GLuint texUnit = texture - GL_TEXTURE0;
-   GLuint k;
-   GET_CURRENT_CONTEXT(ctx);
-
-   /* See OpenGL spec for glActiveTexture: */
-   k = MAX2(ctx->Const.MaxCombinedTextureImageUnits,
-            ctx->Const.MaxTextureCoordUnits);
-
-   ASSERT(k <= Elements(ctx->Texture.Unit));
-   
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glActiveTexture %s\n",
-                  _mesa_lookup_enum_by_nr(texture));
-
-   if (texUnit >= k) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)",
-                  _mesa_lookup_enum_by_nr(texture));
-      return;
-   }
-
-   if (ctx->Texture.CurrentUnit == texUnit)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-
-   ctx->Texture.CurrentUnit = texUnit;
-   if (ctx->Transform.MatrixMode == GL_TEXTURE) {
-      /* update current stack pointer */
-      ctx->CurrentStack = &ctx->TextureMatrixStack[texUnit];
-   }
-}
-
-
-/* GL_ARB_multitexture */
-void GLAPIENTRY
-_mesa_ClientActiveTextureARB(GLenum texture)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint texUnit = texture - GL_TEXTURE0;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glClientActiveTexture %s\n",
-                  _mesa_lookup_enum_by_nr(texture));
-
-   if (texUnit >= ctx->Const.MaxTextureCoordUnits) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture)");
-      return;
-   }
-
-   if (ctx->Array.ActiveTexture == texUnit)
-      return;
-
-   FLUSH_VERTICES(ctx, _NEW_ARRAY);
-   ctx->Array.ActiveTexture = texUnit;
-}
-
-
-
-/**********************************************************************/
-/*****                    State management                        *****/
-/**********************************************************************/
-
-
-/**
- * \note This routine refers to derived texture attribute values to
- * compute the ENABLE_TEXMAT flags, but is only called on
- * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
- * flags are updated by _mesa_update_textures(), below.
- *
- * \param ctx GL context.
- */
-static void
-update_texture_matrices( struct gl_context *ctx )
-{
-   GLuint u;
-
-   ctx->Texture._TexMatEnabled = 0x0;
-
-   for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {
-      ASSERT(u < Elements(ctx->TextureMatrixStack));
-      if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {
-	 _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );
-
-	 if (ctx->Texture.Unit[u]._ReallyEnabled &&
-	     ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)
-	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);
-      }
-   }
-}
-
-
-/**
- * Examine texture unit's combine/env state to update derived state.
- */
-static void
-update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit)
-{
-   struct gl_tex_env_combine_state *combine;
-
-   /* Set the texUnit->_CurrentCombine field to point to the user's combiner
-    * state, or the combiner state which is derived from traditional texenv
-    * mode.
-    */
-   if (texUnit->EnvMode == GL_COMBINE ||
-       texUnit->EnvMode == GL_COMBINE4_NV) {
-      texUnit->_CurrentCombine = & texUnit->Combine;
-   }
-   else {
-      const struct gl_texture_object *texObj = texUnit->_Current;
-      GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
-      if (format == GL_COLOR_INDEX) {
-         format = GL_RGBA;  /* a bit of a hack */
-      }
-      else if (format == GL_DEPTH_COMPONENT ||
-               format == GL_DEPTH_STENCIL_EXT) {
-         format = texObj->DepthMode;
-      }
-      calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
-      texUnit->_CurrentCombine = & texUnit->_EnvMode;
-   }
-
-   combine = texUnit->_CurrentCombine;
-
-   /* Determine number of source RGB terms in the combiner function */
-   switch (combine->ModeRGB) {
-   case GL_REPLACE:
-      combine->_NumArgsRGB = 1;
-      break;
-   case GL_ADD:
-   case GL_ADD_SIGNED:
-      if (texUnit->EnvMode == GL_COMBINE4_NV)
-         combine->_NumArgsRGB = 4;
-      else
-         combine->_NumArgsRGB = 2;
-      break;
-   case GL_MODULATE:
-   case GL_SUBTRACT:
-   case GL_DOT3_RGB:
-   case GL_DOT3_RGBA:
-   case GL_DOT3_RGB_EXT:
-   case GL_DOT3_RGBA_EXT:
-      combine->_NumArgsRGB = 2;
-      break;
-   case GL_INTERPOLATE:
-   case GL_MODULATE_ADD_ATI:
-   case GL_MODULATE_SIGNED_ADD_ATI:
-   case GL_MODULATE_SUBTRACT_ATI:
-      combine->_NumArgsRGB = 3;
-      break;
-   case GL_BUMP_ENVMAP_ATI:
-      /* no real arguments for this case */
-      combine->_NumArgsRGB = 0;
-      break;
-   default:
-      combine->_NumArgsRGB = 0;
-      _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
-      return;
-   }
-
-   /* Determine number of source Alpha terms in the combiner function */
-   switch (combine->ModeA) {
-   case GL_REPLACE:
-      combine->_NumArgsA = 1;
-      break;
-   case GL_ADD:
-   case GL_ADD_SIGNED:
-      if (texUnit->EnvMode == GL_COMBINE4_NV)
-         combine->_NumArgsA = 4;
-      else
-         combine->_NumArgsA = 2;
-      break;
-   case GL_MODULATE:
-   case GL_SUBTRACT:
-      combine->_NumArgsA = 2;
-      break;
-   case GL_INTERPOLATE:
-   case GL_MODULATE_ADD_ATI:
-   case GL_MODULATE_SIGNED_ADD_ATI:
-   case GL_MODULATE_SUBTRACT_ATI:
-      combine->_NumArgsA = 3;
-      break;
-   default:
-      combine->_NumArgsA = 0;
-      _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
-      break;
-   }
-}
-
-
-/**
- * \note This routine refers to derived texture matrix values to
- * compute the ENABLE_TEXMAT flags, but is only called on
- * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
- * flags are updated by _mesa_update_texture_matrices, above.
- *
- * \param ctx GL context.
- */
-static void
-update_texture_state( struct gl_context *ctx )
-{
-   GLuint unit;
-   struct gl_fragment_program *fprog = NULL;
-   struct gl_vertex_program *vprog = NULL;
-   GLbitfield enabledFragUnits = 0x0;
-
-   if (ctx->Shader.CurrentVertexProgram &&
-       ctx->Shader.CurrentVertexProgram->LinkStatus) {
-      vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;
-   } else if (ctx->VertexProgram._Enabled) {
-      /* XXX enable this if/when non-shader vertex programs get
-       * texture fetches:
-       vprog = ctx->VertexProgram.Current;
-       */
-   }
-
-   if (ctx->Shader.CurrentFragmentProgram &&
-       ctx->Shader.CurrentFragmentProgram->LinkStatus) {
-      fprog = ctx->Shader.CurrentFragmentProgram->FragmentProgram;
-   }
-   else if (ctx->FragmentProgram._Enabled) {
-      fprog = ctx->FragmentProgram.Current;
-   }
-
-   /* FINISHME: Geometry shader texture accesses should also be considered
-    * FINISHME: here.
-    */
-
-   /* TODO: only set this if there are actual changes */
-   ctx->NewState |= _NEW_TEXTURE;
-
-   ctx->Texture._EnabledUnits = 0x0;
-   ctx->Texture._GenFlags = 0x0;
-   ctx->Texture._TexMatEnabled = 0x0;
-   ctx->Texture._TexGenEnabled = 0x0;
-
-   /*
-    * Update texture unit state.
-    */
-   for (unit = 0; unit < ctx->Const.MaxCombinedTextureImageUnits; unit++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLbitfield enabledVertTargets = 0x0;
-      GLbitfield enabledFragTargets = 0x0;
-      GLbitfield enabledTargets = 0x0;
-      GLuint texIndex;
-
-      /* Get the bitmask of texture target enables.
-       * enableBits will be a mask of the TEXTURE_*_BIT flags indicating
-       * which texture targets are enabled (fixed function) or referenced
-       * by a fragment program/program.  When multiple flags are set, we'll
-       * settle on the one with highest priority (see below).
-       */
-      if (vprog) {
-         enabledVertTargets |= vprog->Base.TexturesUsed[unit];
-      }
-
-      if (fprog) {
-         enabledFragTargets |= fprog->Base.TexturesUsed[unit];
-      }
-      else {
-         /* fixed-function fragment program */
-         enabledFragTargets |= texUnit->Enabled;
-      }
-
-      enabledTargets = enabledVertTargets | enabledFragTargets;
-
-      texUnit->_ReallyEnabled = 0x0;
-
-      if (enabledTargets == 0x0) {
-         /* neither vertex nor fragment processing uses this unit */
-         continue;
-      }
-
-      /* Look for the highest priority texture target that's enabled (or used
-       * by the vert/frag shaders) and "complete".  That's the one we'll use
-       * for texturing.  If we're using vert/frag program we're guaranteed
-       * that bitcount(enabledBits) <= 1.
-       * Note that the TEXTURE_x_INDEX values are in high to low priority.
-       */
-      for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) {
-         if (enabledTargets & (1 << texIndex)) {
-            struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
-            if (!texObj->_Complete) {
-               _mesa_test_texobj_completeness(ctx, texObj);
-            }
-            if (texObj->_Complete) {
-               texUnit->_ReallyEnabled = 1 << texIndex;
-               _mesa_reference_texobj(&texUnit->_Current, texObj);
-               break;
-            }
-         }
-      }
-
-      if (!texUnit->_ReallyEnabled) {
-         if (fprog) {
-            /* If we get here it means the shader is expecting a texture
-             * object, but there isn't one (or it's incomplete).  Use the
-             * fallback texture.
-             */
-            struct gl_texture_object *texObj = _mesa_get_fallback_texture(ctx);
-            texUnit->_ReallyEnabled = 1 << TEXTURE_2D_INDEX;
-            _mesa_reference_texobj(&texUnit->_Current, texObj);
-         }
-         else {
-            /* fixed-function: texture unit is really disabled */
-            continue;
-         }
-      }
-
-      /* if we get here, we know this texture unit is enabled */
-
-      ctx->Texture._EnabledUnits |= (1 << unit);
-
-      if (enabledFragTargets)
-         enabledFragUnits |= (1 << unit);
-
-      update_tex_combine(ctx, texUnit);
-   }
-
-
-   /* Determine which texture coordinate sets are actually needed */
-   if (fprog) {
-      const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
-      ctx->Texture._EnabledCoordUnits
-         = (fprog->Base.InputsRead >> FRAG_ATTRIB_TEX0) & coordMask;
-   }
-   else {
-      ctx->Texture._EnabledCoordUnits = enabledFragUnits;
-   }
-
-   /* Setup texgen for those texture coordinate sets that are in use */
-   for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-
-      texUnit->_GenFlags = 0x0;
-
-      if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))
-	 continue;
-
-      if (texUnit->TexGenEnabled) {
-	 if (texUnit->TexGenEnabled & S_BIT) {
-	    texUnit->_GenFlags |= texUnit->GenS._ModeBit;
-	 }
-	 if (texUnit->TexGenEnabled & T_BIT) {
-	    texUnit->_GenFlags |= texUnit->GenT._ModeBit;
-	 }
-	 if (texUnit->TexGenEnabled & R_BIT) {
-	    texUnit->_GenFlags |= texUnit->GenR._ModeBit;
-	 }
-	 if (texUnit->TexGenEnabled & Q_BIT) {
-	    texUnit->_GenFlags |= texUnit->GenQ._ModeBit;
-	 }
-
-	 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);
-	 ctx->Texture._GenFlags |= texUnit->_GenFlags;
-      }
-
-      ASSERT(unit < Elements(ctx->TextureMatrixStack));
-      if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY)
-	 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit);
-   }
-}
-
-
-/**
- * Update texture-related derived state.
- */
-void
-_mesa_update_texture( struct gl_context *ctx, GLuint new_state )
-{
-   if (new_state & _NEW_TEXTURE_MATRIX)
-      update_texture_matrices( ctx );
-
-   if (new_state & (_NEW_TEXTURE | _NEW_PROGRAM))
-      update_texture_state( ctx );
-}
-
-
-/**********************************************************************/
-/*****                      Initialization                        *****/
-/**********************************************************************/
-
-/**
- * Allocate the proxy textures for the given context.
- * 
- * \param ctx the context to allocate proxies for.
- * 
- * \return GL_TRUE on success, or GL_FALSE on failure
- * 
- * If run out of memory part way through the allocations, clean up and return
- * GL_FALSE.
- */
-static GLboolean
-alloc_proxy_textures( struct gl_context *ctx )
-{
-   static const GLenum targets[] = {
-      GL_TEXTURE_1D,
-      GL_TEXTURE_2D,
-      GL_TEXTURE_3D,
-      GL_TEXTURE_CUBE_MAP_ARB,
-      GL_TEXTURE_RECTANGLE_NV,
-      GL_TEXTURE_1D_ARRAY_EXT,
-      GL_TEXTURE_2D_ARRAY_EXT
-   };
-   GLint tgt;
-
-   ASSERT(Elements(targets) == NUM_TEXTURE_TARGETS);
-
-   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-      if (!(ctx->Texture.ProxyTex[tgt]
-            = ctx->Driver.NewTextureObject(ctx, 0, targets[tgt]))) {
-         /* out of memory, free what we did allocate */
-         while (--tgt >= 0) {
-            ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
-         }
-         return GL_FALSE;
-      }
-   }
-
-   assert(ctx->Texture.ProxyTex[0]->RefCount == 1); /* sanity check */
-   return GL_TRUE;
-}
-
-
-/**
- * Initialize a texture unit.
- *
- * \param ctx GL context.
- * \param unit texture unit number to be initialized.
- */
-static void
-init_texture_unit( struct gl_context *ctx, GLuint unit )
-{
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   GLuint tex;
-
-   texUnit->EnvMode = GL_MODULATE;
-   ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
-
-   texUnit->Combine = default_combine_state;
-   texUnit->_EnvMode = default_combine_state;
-   texUnit->_CurrentCombine = & texUnit->_EnvMode;
-   texUnit->BumpTarget = GL_TEXTURE0;
-
-   texUnit->TexGenEnabled = 0x0;
-   texUnit->GenS.Mode = GL_EYE_LINEAR;
-   texUnit->GenT.Mode = GL_EYE_LINEAR;
-   texUnit->GenR.Mode = GL_EYE_LINEAR;
-   texUnit->GenQ.Mode = GL_EYE_LINEAR;
-   texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;
-   texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;
-   texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;
-   texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;
-
-   /* Yes, these plane coefficients are correct! */
-   ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );
-
-   /* no mention of this in spec, but maybe id matrix expected? */
-   ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 );
-
-   /* initialize current texture object ptrs to the shared default objects */
-   for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
-      _mesa_reference_texobj(&texUnit->CurrentTex[tex],
-                             ctx->Shared->DefaultTex[tex]);
-   }
-}
-
-
-/**
- * Initialize texture state for the given context.
- */
-GLboolean
-_mesa_init_texture(struct gl_context *ctx)
-{
-   GLuint u;
-
-   /* Texture group */
-   ctx->Texture.CurrentUnit = 0;      /* multitexture */
-   ctx->Texture._EnabledUnits = 0x0;
-   ctx->Texture.SharedPalette = GL_FALSE;
-   _mesa_init_colortable(&ctx->Texture.Palette);
-
-   for (u = 0; u < Elements(ctx->Texture.Unit); u++)
-      init_texture_unit(ctx, u);
-
-   /* After we're done initializing the context's texture state the default
-    * texture objects' refcounts should be at least
-    * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
-    */
-   assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount
-          >= MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1);
-
-   /* Allocate proxy textures */
-   if (!alloc_proxy_textures( ctx ))
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Free dynamically-allocted texture data attached to the given context.
- */
-void
-_mesa_free_texture_data(struct gl_context *ctx)
-{
-   GLuint u, tgt;
-
-   /* unreference current textures */
-   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
-      /* The _Current texture could account for another reference */
-      _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);
-
-      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
-         _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);
-      }
-   }
-
-   /* Free proxy texture objects */
-   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)
-      ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
-}
-
-
-/**
- * Update the default texture objects in the given context to reference those
- * specified in the shared state and release those referencing the old 
- * shared state.
- */
-void
-_mesa_update_default_objects_texture(struct gl_context *ctx)
-{
-   GLuint u, tex;
-
-   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
-      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
-         _mesa_reference_texobj(&texUnit->CurrentTex[tex],
-                                ctx->Shared->DefaultTex[tex]);
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/** 

+ * \file texstate.c

+ *

+ * Texture state handling.

+ */

+

+#include "glheader.h"

+#include "mfeatures.h"

+#include "colormac.h"

+#include "colortab.h"

+#include "context.h"

+#include "enums.h"

+#include "macros.h"

+#include "texobj.h"

+#include "teximage.h"

+#include "texstate.h"

+#include "mtypes.h"

+

+

+

+/**

+ * Default texture combine environment state.  This is used to initialize

+ * a context's texture units and as the basis for converting "classic"

+ * texture environmnets to ARB_texture_env_combine style values.

+ */

+static const struct gl_tex_env_combine_state default_combine_state = {

+   GL_MODULATE, GL_MODULATE,

+   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },

+   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },

+   { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA },

+   { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },

+   0, 0,

+   2, 2

+};

+

+

+

+/**

+ * Used by glXCopyContext to copy texture state from one context to another.

+ */

+void

+_mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst )

+{

+   GLuint u, tex;

+

+   ASSERT(src);

+   ASSERT(dst);

+

+   dst->Texture.CurrentUnit = src->Texture.CurrentUnit;

+   dst->Texture._GenFlags = src->Texture._GenFlags;

+   dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;

+   dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;

+   dst->Texture.SharedPalette = src->Texture.SharedPalette;

+

+   /* per-unit state */

+   for (u = 0; u < src->Const.MaxCombinedTextureImageUnits; u++) {

+      dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled;

+      dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode;

+      COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor);

+      dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled;

+      dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS;

+      dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT;

+      dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR;

+      dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ;

+      dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias;

+

+      /* GL_EXT_texture_env_combine */

+      dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine;

+

+      /* GL_ATI_envmap_bumpmap - need this? */

+      dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget;

+      COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix);

+

+      /*

+       * XXX strictly speaking, we should compare texture names/ids and

+       * bind textures in the dest context according to id.  For now, only

+       * copy bindings if the contexts share the same pool of textures to

+       * avoid refcounting bugs.

+       */

+      if (dst->Shared == src->Shared) {

+         /* copy texture object bindings, not contents of texture objects */

+         _mesa_lock_context_textures(dst);

+

+         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {

+            _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],

+                                   src->Texture.Unit[u].CurrentTex[tex]);

+         }

+         _mesa_unlock_context_textures(dst);

+      }

+   }

+}

+

+

+/*

+ * For debugging

+ */

+void

+_mesa_print_texunit_state( struct gl_context *ctx, GLuint unit )

+{

+   const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit;

+   printf("Texture Unit %d\n", unit);

+   printf("  GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));

+   printf("  GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));

+   printf("  GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));

+   printf("  GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));

+   printf("  GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));

+   printf("  GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));

+   printf("  GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));

+   printf("  GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));

+   printf("  GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));

+   printf("  GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));

+   printf("  GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));

+   printf("  GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));

+   printf("  GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));

+   printf("  GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));

+   printf("  GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));

+   printf("  GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);

+   printf("  GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);

+   printf("  GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);

+}

+

+

+

+/**********************************************************************/

+/*                       Texture Environment                          */

+/**********************************************************************/

+

+/**

+ * Convert "classic" texture environment to ARB_texture_env_combine style

+ * environments.

+ * 

+ * \param state  texture_env_combine state vector to be filled-in.

+ * \param mode   Classic texture environment mode (i.e., \c GL_REPLACE,

+ *               \c GL_BLEND, \c GL_DECAL, etc.).

+ * \param texBaseFormat  Base format of the texture associated with the

+ *               texture unit.

+ */

+static void

+calculate_derived_texenv( struct gl_tex_env_combine_state *state,

+			  GLenum mode, GLenum texBaseFormat )

+{

+   GLenum mode_rgb;

+   GLenum mode_a;

+

+   *state = default_combine_state;

+

+   switch (texBaseFormat) {

+   case GL_ALPHA:

+      state->SourceRGB[0] = GL_PREVIOUS;

+      break;

+

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+   case GL_RGBA:

+      break;

+

+   case GL_LUMINANCE:

+   case GL_RED:

+   case GL_RG:

+   case GL_RGB:

+   case GL_YCBCR_MESA:

+   case GL_DUDV_ATI:

+      state->SourceA[0] = GL_PREVIOUS;

+      break;

+      

+   default:

+      _mesa_problem(NULL,

+                    "Invalid texBaseFormat 0x%x in calculate_derived_texenv",

+                    texBaseFormat);

+      return;

+   }

+

+   if (mode == GL_REPLACE_EXT)

+      mode = GL_REPLACE;

+

+   switch (mode) {

+   case GL_REPLACE:

+   case GL_MODULATE:

+      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode;

+      mode_a   = mode;

+      break;

+   

+   case GL_DECAL:

+      mode_rgb = GL_INTERPOLATE;

+      mode_a   = GL_REPLACE;

+

+      state->SourceA[0] = GL_PREVIOUS;

+

+      /* Having alpha / luminance / intensity textures replace using the

+       * incoming fragment color matches the definition in NV_texture_shader.

+       * The 1.5 spec simply marks these as "undefined".

+       */

+      switch (texBaseFormat) {

+      case GL_ALPHA:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE_ALPHA:

+      case GL_INTENSITY:

+	 state->SourceRGB[0] = GL_PREVIOUS;

+	 break;

+      case GL_RED:

+      case GL_RG:

+      case GL_RGB:

+      case GL_YCBCR_MESA:

+      case GL_DUDV_ATI:

+	 mode_rgb = GL_REPLACE;

+	 break;

+      case GL_RGBA:

+	 state->SourceRGB[2] = GL_TEXTURE;

+	 break;

+      }

+      break;

+

+   case GL_BLEND:

+      mode_rgb = GL_INTERPOLATE;

+      mode_a   = GL_MODULATE;

+

+      switch (texBaseFormat) {

+      case GL_ALPHA:

+	 mode_rgb = GL_REPLACE;

+	 break;

+      case GL_INTENSITY:

+	 mode_a = GL_INTERPOLATE;

+	 state->SourceA[0] = GL_CONSTANT;

+	 state->OperandA[2] = GL_SRC_ALPHA;

+	 /* FALLTHROUGH */

+      case GL_LUMINANCE:

+      case GL_RED:

+      case GL_RG:

+      case GL_RGB:

+      case GL_LUMINANCE_ALPHA:

+      case GL_RGBA:

+      case GL_YCBCR_MESA:

+      case GL_DUDV_ATI:

+	 state->SourceRGB[2] = GL_TEXTURE;

+	 state->SourceA[2]   = GL_TEXTURE;

+	 state->SourceRGB[0] = GL_CONSTANT;

+	 state->OperandRGB[2] = GL_SRC_COLOR;

+	 break;

+      }

+      break;

+

+   case GL_ADD:

+      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : GL_ADD;

+      mode_a   = (texBaseFormat == GL_INTENSITY) ? GL_ADD : GL_MODULATE;

+      break;

+

+   default:

+      _mesa_problem(NULL,

+                    "Invalid texture env mode 0x%x in calculate_derived_texenv",

+                    mode);

+      return;

+   }

+   

+   state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS)

+       ? mode_rgb : GL_REPLACE;

+   state->ModeA   = (state->SourceA[0]   != GL_PREVIOUS)

+       ? mode_a   : GL_REPLACE;

+}

+

+

+

+

+/* GL_ARB_multitexture */

+void GLAPIENTRY

+_mesa_ActiveTextureARB(GLenum texture)

+{

+   const GLuint texUnit = texture - GL_TEXTURE0;

+   GLuint k;

+   GET_CURRENT_CONTEXT(ctx);

+

+   /* See OpenGL spec for glActiveTexture: */

+   k = MAX2(ctx->Const.MaxCombinedTextureImageUnits,

+            ctx->Const.MaxTextureCoordUnits);

+

+   ASSERT(k <= Elements(ctx->Texture.Unit));

+   

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glActiveTexture %s\n",

+                  _mesa_lookup_enum_by_nr(texture));

+

+   if (texUnit >= k) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)",

+                  _mesa_lookup_enum_by_nr(texture));

+      return;

+   }

+

+   if (ctx->Texture.CurrentUnit == texUnit)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);

+

+   ctx->Texture.CurrentUnit = texUnit;

+   if (ctx->Transform.MatrixMode == GL_TEXTURE) {

+      /* update current stack pointer */

+      ctx->CurrentStack = &ctx->TextureMatrixStack[texUnit];

+   }

+}

+

+

+/* GL_ARB_multitexture */

+void GLAPIENTRY

+_mesa_ClientActiveTextureARB(GLenum texture)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint texUnit = texture - GL_TEXTURE0;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glClientActiveTexture %s\n",

+                  _mesa_lookup_enum_by_nr(texture));

+

+   if (texUnit >= ctx->Const.MaxTextureCoordUnits) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture)");

+      return;

+   }

+

+   if (ctx->Array.ActiveTexture == texUnit)

+      return;

+

+   FLUSH_VERTICES(ctx, _NEW_ARRAY);

+   ctx->Array.ActiveTexture = texUnit;

+}

+

+

+

+/**********************************************************************/

+/*****                    State management                        *****/

+/**********************************************************************/

+

+

+/**

+ * \note This routine refers to derived texture attribute values to

+ * compute the ENABLE_TEXMAT flags, but is only called on

+ * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT

+ * flags are updated by _mesa_update_textures(), below.

+ *

+ * \param ctx GL context.

+ */

+static void

+update_texture_matrices( struct gl_context *ctx )

+{

+   GLuint u;

+

+   ctx->Texture._TexMatEnabled = 0x0;

+

+   for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {

+      ASSERT(u < Elements(ctx->TextureMatrixStack));

+      if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {

+	 _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );

+

+	 if (ctx->Texture.Unit[u]._ReallyEnabled &&

+	     ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)

+	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);

+      }

+   }

+}

+

+

+/**

+ * Examine texture unit's combine/env state to update derived state.

+ */

+static void

+update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit)

+{

+   struct gl_tex_env_combine_state *combine;

+

+   /* Set the texUnit->_CurrentCombine field to point to the user's combiner

+    * state, or the combiner state which is derived from traditional texenv

+    * mode.

+    */

+   if (texUnit->EnvMode == GL_COMBINE ||

+       texUnit->EnvMode == GL_COMBINE4_NV) {

+      texUnit->_CurrentCombine = & texUnit->Combine;

+   }

+   else {

+      const struct gl_texture_object *texObj = texUnit->_Current;

+      GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;

+      if (format == GL_COLOR_INDEX) {

+         format = GL_RGBA;  /* a bit of a hack */

+      }

+      else if (format == GL_DEPTH_COMPONENT ||

+               format == GL_DEPTH_STENCIL_EXT) {

+         format = texObj->DepthMode;

+      }

+      calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);

+      texUnit->_CurrentCombine = & texUnit->_EnvMode;

+   }

+

+   combine = texUnit->_CurrentCombine;

+

+   /* Determine number of source RGB terms in the combiner function */

+   switch (combine->ModeRGB) {

+   case GL_REPLACE:

+      combine->_NumArgsRGB = 1;

+      break;

+   case GL_ADD:

+   case GL_ADD_SIGNED:

+      if (texUnit->EnvMode == GL_COMBINE4_NV)

+         combine->_NumArgsRGB = 4;

+      else

+         combine->_NumArgsRGB = 2;

+      break;

+   case GL_MODULATE:

+   case GL_SUBTRACT:

+   case GL_DOT3_RGB:

+   case GL_DOT3_RGBA:

+   case GL_DOT3_RGB_EXT:

+   case GL_DOT3_RGBA_EXT:

+      combine->_NumArgsRGB = 2;

+      break;

+   case GL_INTERPOLATE:

+   case GL_MODULATE_ADD_ATI:

+   case GL_MODULATE_SIGNED_ADD_ATI:

+   case GL_MODULATE_SUBTRACT_ATI:

+      combine->_NumArgsRGB = 3;

+      break;

+   case GL_BUMP_ENVMAP_ATI:

+      /* no real arguments for this case */

+      combine->_NumArgsRGB = 0;

+      break;

+   default:

+      combine->_NumArgsRGB = 0;

+      _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");

+      return;

+   }

+

+   /* Determine number of source Alpha terms in the combiner function */

+   switch (combine->ModeA) {

+   case GL_REPLACE:

+      combine->_NumArgsA = 1;

+      break;

+   case GL_ADD:

+   case GL_ADD_SIGNED:

+      if (texUnit->EnvMode == GL_COMBINE4_NV)

+         combine->_NumArgsA = 4;

+      else

+         combine->_NumArgsA = 2;

+      break;

+   case GL_MODULATE:

+   case GL_SUBTRACT:

+      combine->_NumArgsA = 2;

+      break;

+   case GL_INTERPOLATE:

+   case GL_MODULATE_ADD_ATI:

+   case GL_MODULATE_SIGNED_ADD_ATI:

+   case GL_MODULATE_SUBTRACT_ATI:

+      combine->_NumArgsA = 3;

+      break;

+   default:

+      combine->_NumArgsA = 0;

+      _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");

+      break;

+   }

+}

+

+

+/**

+ * \note This routine refers to derived texture matrix values to

+ * compute the ENABLE_TEXMAT flags, but is only called on

+ * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT

+ * flags are updated by _mesa_update_texture_matrices, above.

+ *

+ * \param ctx GL context.

+ */

+static void

+update_texture_state( struct gl_context *ctx )

+{

+   GLuint unit;

+   struct gl_fragment_program *fprog = NULL;

+   struct gl_vertex_program *vprog = NULL;

+   GLbitfield enabledFragUnits = 0x0;

+

+   if (ctx->Shader.CurrentVertexProgram &&

+       ctx->Shader.CurrentVertexProgram->LinkStatus) {

+      vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;

+   } else if (ctx->VertexProgram._Enabled) {

+      /* XXX enable this if/when non-shader vertex programs get

+       * texture fetches:

+       vprog = ctx->VertexProgram.Current;

+       */

+   }

+

+   if (ctx->Shader.CurrentFragmentProgram &&

+       ctx->Shader.CurrentFragmentProgram->LinkStatus) {

+      fprog = ctx->Shader.CurrentFragmentProgram->FragmentProgram;

+   }

+   else if (ctx->FragmentProgram._Enabled) {

+      fprog = ctx->FragmentProgram.Current;

+   }

+

+   /* FINISHME: Geometry shader texture accesses should also be considered

+    * FINISHME: here.

+    */

+

+   /* TODO: only set this if there are actual changes */

+   ctx->NewState |= _NEW_TEXTURE;

+

+   ctx->Texture._EnabledUnits = 0x0;

+   ctx->Texture._GenFlags = 0x0;

+   ctx->Texture._TexMatEnabled = 0x0;

+   ctx->Texture._TexGenEnabled = 0x0;

+

+   /*

+    * Update texture unit state.

+    */

+   for (unit = 0; unit < ctx->Const.MaxCombinedTextureImageUnits; unit++) {

+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+      GLbitfield enabledVertTargets = 0x0;

+      GLbitfield enabledFragTargets = 0x0;

+      GLbitfield enabledTargets = 0x0;

+      GLuint texIndex;

+

+      /* Get the bitmask of texture target enables.

+       * enableBits will be a mask of the TEXTURE_*_BIT flags indicating

+       * which texture targets are enabled (fixed function) or referenced

+       * by a fragment program/program.  When multiple flags are set, we'll

+       * settle on the one with highest priority (see below).

+       */

+      if (vprog) {

+         enabledVertTargets |= vprog->Base.TexturesUsed[unit];

+      }

+

+      if (fprog) {

+         enabledFragTargets |= fprog->Base.TexturesUsed[unit];

+      }

+      else {

+         /* fixed-function fragment program */

+         enabledFragTargets |= texUnit->Enabled;

+      }

+

+      enabledTargets = enabledVertTargets | enabledFragTargets;

+

+      texUnit->_ReallyEnabled = 0x0;

+

+      if (enabledTargets == 0x0) {

+         /* neither vertex nor fragment processing uses this unit */

+         continue;

+      }

+

+      /* Look for the highest priority texture target that's enabled (or used

+       * by the vert/frag shaders) and "complete".  That's the one we'll use

+       * for texturing.  If we're using vert/frag program we're guaranteed

+       * that bitcount(enabledBits) <= 1.

+       * Note that the TEXTURE_x_INDEX values are in high to low priority.

+       */

+      for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) {

+         if (enabledTargets & (1 << texIndex)) {

+            struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];

+            if (!texObj->_Complete) {

+               _mesa_test_texobj_completeness(ctx, texObj);

+            }

+            if (texObj->_Complete) {

+               texUnit->_ReallyEnabled = 1 << texIndex;

+               _mesa_reference_texobj(&texUnit->_Current, texObj);

+               break;

+            }

+         }

+      }

+

+      if (!texUnit->_ReallyEnabled) {

+         if (fprog) {

+            /* If we get here it means the shader is expecting a texture

+             * object, but there isn't one (or it's incomplete).  Use the

+             * fallback texture.

+             */

+            struct gl_texture_object *texObj = _mesa_get_fallback_texture(ctx);

+            texUnit->_ReallyEnabled = 1 << TEXTURE_2D_INDEX;

+            _mesa_reference_texobj(&texUnit->_Current, texObj);

+         }

+         else {

+            /* fixed-function: texture unit is really disabled */

+            continue;

+         }

+      }

+

+      /* if we get here, we know this texture unit is enabled */

+

+      ctx->Texture._EnabledUnits |= (1 << unit);

+

+      if (enabledFragTargets)

+         enabledFragUnits |= (1 << unit);

+

+      update_tex_combine(ctx, texUnit);

+   }

+

+

+   /* Determine which texture coordinate sets are actually needed */

+   if (fprog) {

+      const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;

+      ctx->Texture._EnabledCoordUnits

+         = (fprog->Base.InputsRead >> FRAG_ATTRIB_TEX0) & coordMask;

+   }

+   else {

+      ctx->Texture._EnabledCoordUnits = enabledFragUnits;

+   }

+

+   /* Setup texgen for those texture coordinate sets that are in use */

+   for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {

+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+

+      texUnit->_GenFlags = 0x0;

+

+      if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))

+	 continue;

+

+      if (texUnit->TexGenEnabled) {

+	 if (texUnit->TexGenEnabled & S_BIT) {

+	    texUnit->_GenFlags |= texUnit->GenS._ModeBit;

+	 }

+	 if (texUnit->TexGenEnabled & T_BIT) {

+	    texUnit->_GenFlags |= texUnit->GenT._ModeBit;

+	 }

+	 if (texUnit->TexGenEnabled & R_BIT) {

+	    texUnit->_GenFlags |= texUnit->GenR._ModeBit;

+	 }

+	 if (texUnit->TexGenEnabled & Q_BIT) {

+	    texUnit->_GenFlags |= texUnit->GenQ._ModeBit;

+	 }

+

+	 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);

+	 ctx->Texture._GenFlags |= texUnit->_GenFlags;

+      }

+

+      ASSERT(unit < Elements(ctx->TextureMatrixStack));

+      if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY)

+	 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit);

+   }

+}

+

+

+/**

+ * Update texture-related derived state.

+ */

+void

+_mesa_update_texture( struct gl_context *ctx, GLuint new_state )

+{

+   if (new_state & _NEW_TEXTURE_MATRIX)

+      update_texture_matrices( ctx );

+

+   if (new_state & (_NEW_TEXTURE | _NEW_PROGRAM))

+      update_texture_state( ctx );

+}

+

+

+/**********************************************************************/

+/*****                      Initialization                        *****/

+/**********************************************************************/

+

+/**

+ * Allocate the proxy textures for the given context.

+ * 

+ * \param ctx the context to allocate proxies for.

+ * 

+ * \return GL_TRUE on success, or GL_FALSE on failure

+ * 

+ * If run out of memory part way through the allocations, clean up and return

+ * GL_FALSE.

+ */

+static GLboolean

+alloc_proxy_textures( struct gl_context *ctx )

+{

+   static const GLenum targets[] = {

+      GL_TEXTURE_1D,

+      GL_TEXTURE_2D,

+      GL_TEXTURE_3D,

+      GL_TEXTURE_CUBE_MAP_ARB,

+      GL_TEXTURE_RECTANGLE_NV,

+      GL_TEXTURE_1D_ARRAY_EXT,

+      GL_TEXTURE_2D_ARRAY_EXT

+   };

+   GLint tgt;

+

+   ASSERT(Elements(targets) == NUM_TEXTURE_TARGETS);

+

+   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+      if (!(ctx->Texture.ProxyTex[tgt]

+            = ctx->Driver.NewTextureObject(ctx, 0, targets[tgt]))) {

+         /* out of memory, free what we did allocate */

+         while (--tgt >= 0) {

+            ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);

+         }

+         return GL_FALSE;

+      }

+   }

+

+   assert(ctx->Texture.ProxyTex[0]->RefCount == 1); /* sanity check */

+   return GL_TRUE;

+}

+

+

+/**

+ * Initialize a texture unit.

+ *

+ * \param ctx GL context.

+ * \param unit texture unit number to be initialized.

+ */

+static void

+init_texture_unit( struct gl_context *ctx, GLuint unit )

+{

+   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+   GLuint tex;

+

+   texUnit->EnvMode = GL_MODULATE;

+   ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );

+

+   texUnit->Combine = default_combine_state;

+   texUnit->_EnvMode = default_combine_state;

+   texUnit->_CurrentCombine = & texUnit->_EnvMode;

+   texUnit->BumpTarget = GL_TEXTURE0;

+

+   texUnit->TexGenEnabled = 0x0;

+   texUnit->GenS.Mode = GL_EYE_LINEAR;

+   texUnit->GenT.Mode = GL_EYE_LINEAR;

+   texUnit->GenR.Mode = GL_EYE_LINEAR;

+   texUnit->GenQ.Mode = GL_EYE_LINEAR;

+   texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;

+   texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;

+   texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;

+   texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;

+

+   /* Yes, these plane coefficients are correct! */

+   ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );

+

+   /* no mention of this in spec, but maybe id matrix expected? */

+   ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 );

+

+   /* initialize current texture object ptrs to the shared default objects */

+   for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {

+      _mesa_reference_texobj(&texUnit->CurrentTex[tex],

+                             ctx->Shared->DefaultTex[tex]);

+   }

+}

+

+

+/**

+ * Initialize texture state for the given context.

+ */

+GLboolean

+_mesa_init_texture(struct gl_context *ctx)

+{

+   GLuint u;

+

+   /* Texture group */

+   ctx->Texture.CurrentUnit = 0;      /* multitexture */

+   ctx->Texture._EnabledUnits = 0x0;

+   ctx->Texture.SharedPalette = GL_FALSE;

+   _mesa_init_colortable(&ctx->Texture.Palette);

+

+   for (u = 0; u < Elements(ctx->Texture.Unit); u++)

+      init_texture_unit(ctx, u);

+

+   /* After we're done initializing the context's texture state the default

+    * texture objects' refcounts should be at least

+    * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.

+    */

+   assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount

+          >= MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1);

+

+   /* Allocate proxy textures */

+   if (!alloc_proxy_textures( ctx ))

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Free dynamically-allocted texture data attached to the given context.

+ */

+void

+_mesa_free_texture_data(struct gl_context *ctx)

+{

+   GLuint u, tgt;

+

+   /* unreference current textures */

+   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {

+      /* The _Current texture could account for another reference */

+      _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);

+

+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {

+         _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);

+      }

+   }

+

+   /* Free proxy texture objects */

+   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)

+      ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);

+}

+

+

+/**

+ * Update the default texture objects in the given context to reference those

+ * specified in the shared state and release those referencing the old 

+ * shared state.

+ */

+void

+_mesa_update_default_objects_texture(struct gl_context *ctx)

+{

+   GLuint u, tex;

+

+   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {

+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];

+      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {

+         _mesa_reference_texobj(&texUnit->CurrentTex[tex],

+                                ctx->Shared->DefaultTex[tex]);

+      }

+   }

+}

diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c
index 760cdfa85..749956a1f 100644
--- a/mesalib/src/mesa/main/texstore.c
+++ b/mesalib/src/mesa/main/texstore.c
@@ -1,4709 +1,4709 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008-2009  VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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:
- *   Brian Paul
- */
-
-/**
- * The GL texture image functions in teximage.c basically just do
- * error checking and data structure allocation.  They in turn call
- * device driver functions which actually copy/convert/store the user's
- * texture image data.
- *
- * However, most device drivers will be able to use the fallback functions
- * in this file.  That is, most drivers will have the following bit of
- * code:
- *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
- *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
- *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
- *   etc...
- *
- * Texture image processing is actually kind of complicated.  We have to do:
- *    Format/type conversions
- *    pixel unpacking
- *    pixel transfer (scale, bais, lookup, etc)
- *
- * These functions can handle most everything, including processing full
- * images and sub-images.
- */
-
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "colormac.h"
-#include "image.h"
-#include "macros.h"
-#include "mipmap.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "pack.h"
-#include "pbo.h"
-#include "imports.h"
-#include "pack.h"
-#include "texcompress.h"
-#include "texcompress_fxt1.h"
-#include "texcompress_rgtc.h"
-#include "texcompress_s3tc.h"
-#include "teximage.h"
-#include "texstore.h"
-#include "enums.h"
-
-
-enum {
-   ZERO = 4, 
-   ONE = 5
-};
-
-
-/**
- * Texture image storage function.
- */
-typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
-
-
-/**
- * Return GL_TRUE if the given image format is one that be converted
- * to another format by swizzling.
- */
-static GLboolean
-can_swizzle(GLenum logicalBaseFormat)
-{
-   switch (logicalBaseFormat) {
-   case GL_RGBA:
-   case GL_RGB:
-   case GL_LUMINANCE_ALPHA:
-   case GL_INTENSITY:
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_RED:
-   case GL_GREEN:
-   case GL_BLUE:
-   case GL_BGR:
-   case GL_BGRA:
-   case GL_ABGR_EXT:
-   case GL_RG:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-
-enum {
-   IDX_LUMINANCE = 0,
-   IDX_ALPHA,
-   IDX_INTENSITY,
-   IDX_LUMINANCE_ALPHA,
-   IDX_RGB,
-   IDX_RGBA,
-   IDX_RED,
-   IDX_GREEN,
-   IDX_BLUE,
-   IDX_BGR,
-   IDX_BGRA,
-   IDX_ABGR,
-   IDX_RG,
-   MAX_IDX
-};
-
-#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
-#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
-#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
-#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
-
-
-static const struct {
-   GLubyte format_idx;
-   GLubyte to_rgba[6];
-   GLubyte from_rgba[6];
-} mappings[MAX_IDX] = 
-{
-   {
-      IDX_LUMINANCE,
-      MAP4(0,0,0,ONE),
-      MAP1(0)
-   },
-
-   {
-      IDX_ALPHA,
-      MAP4(ZERO, ZERO, ZERO, 0),
-      MAP1(3)
-   },
-
-   {
-      IDX_INTENSITY,
-      MAP4(0, 0, 0, 0),
-      MAP1(0),
-   },
-
-   {
-      IDX_LUMINANCE_ALPHA,
-      MAP4(0,0,0,1),
-      MAP2(0,3)
-   },
-
-   {
-      IDX_RGB,
-      MAP4(0,1,2,ONE),
-      MAP3(0,1,2)
-   },
-
-   {
-      IDX_RGBA,
-      MAP4(0,1,2,3),
-      MAP4(0,1,2,3),
-   },
-
-   {
-      IDX_RED,
-      MAP4(0, ZERO, ZERO, ONE),
-      MAP1(0),
-   },
-
-   {
-      IDX_GREEN,
-      MAP4(ZERO, 0, ZERO, ONE),
-      MAP1(1),
-   },
-
-   {
-      IDX_BLUE,
-      MAP4(ZERO, ZERO, 0, ONE),
-      MAP1(2),
-   },
-
-   {
-      IDX_BGR,
-      MAP4(2,1,0,ONE),
-      MAP3(2,1,0)
-   },
-
-   {
-      IDX_BGRA,
-      MAP4(2,1,0,3),
-      MAP4(2,1,0,3)
-   },
-
-   {
-      IDX_ABGR,
-      MAP4(3,2,1,0),
-      MAP4(3,2,1,0)
-   },
-
-   {
-      IDX_RG,
-      MAP4(0, 1, ZERO, ONE),
-      MAP2(0, 1)
-   },
-};
-
-
-
-/**
- * Convert a GL image format enum to an IDX_* value (see above).
- */
-static int
-get_map_idx(GLenum value)
-{
-   switch (value) {
-   case GL_LUMINANCE: return IDX_LUMINANCE;
-   case GL_ALPHA: return IDX_ALPHA;
-   case GL_INTENSITY: return IDX_INTENSITY;
-   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;
-   case GL_RGB: return IDX_RGB;
-   case GL_RGBA: return IDX_RGBA;
-   case GL_RED: return IDX_RED;
-   case GL_GREEN: return IDX_GREEN;
-   case GL_BLUE: return IDX_BLUE;
-   case GL_BGR: return IDX_BGR;
-   case GL_BGRA: return IDX_BGRA;
-   case GL_ABGR_EXT: return IDX_ABGR;
-   case GL_RG: return IDX_RG;
-   default:
-      _mesa_problem(NULL, "Unexpected inFormat");
-      return 0;
-   }
-}   
-
-
-/**
- * When promoting texture formats (see below) we need to compute the
- * mapping of dest components back to source components.
- * This function does that.
- * \param inFormat  the incoming format of the texture
- * \param outFormat  the final texture format
- * \return map[6]  a full 6-component map
- */
-static void
-compute_component_mapping(GLenum inFormat, GLenum outFormat, 
-			  GLubyte *map)
-{
-   const int inFmt = get_map_idx(inFormat);
-   const int outFmt = get_map_idx(outFormat);
-   const GLubyte *in2rgba = mappings[inFmt].to_rgba;
-   const GLubyte *rgba2out = mappings[outFmt].from_rgba;
-   int i;
-   
-   for (i = 0; i < 4; i++)
-      map[i] = in2rgba[rgba2out[i]];
-
-   map[ZERO] = ZERO;
-   map[ONE] = ONE;   
-
-#if 0
-   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
-	  inFormat, _mesa_lookup_enum_by_nr(inFormat),
-	  outFormat, _mesa_lookup_enum_by_nr(outFormat),
-	  map[0], 
-	  map[1], 
-	  map[2], 
-	  map[3], 
-	  map[4], 
-	  map[5]); 
-#endif
-}
-
-
-/**
- * Make a temporary (color) texture image with GLfloat components.
- * Apply all needed pixel unpacking and pixel transfer operations.
- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
- * Suppose the user specifies GL_LUMINANCE as the internal texture format
- * but the graphics hardware doesn't support luminance textures.  So, we might
- * use an RGB hardware format instead.
- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
- *
- * \param ctx  the rendering context
- * \param dims  image dimensions: 1, 2 or 3
- * \param logicalBaseFormat  basic texture derived from the user's
- *    internal texture format value
- * \param textureBaseFormat  the actual basic format of the texture
- * \param srcWidth  source image width
- * \param srcHeight  source image height
- * \param srcDepth  source image depth
- * \param srcFormat  source image format
- * \param srcType  source image type
- * \param srcAddr  source image address
- * \param srcPacking  source image pixel packing
- * \return resulting image with format = textureBaseFormat and type = GLfloat.
- */
-GLfloat *
-_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
-			    GLenum logicalBaseFormat,
-			    GLenum textureBaseFormat,
-			    GLint srcWidth, GLint srcHeight, GLint srcDepth,
-			    GLenum srcFormat, GLenum srcType,
-			    const GLvoid *srcAddr,
-			    const struct gl_pixelstore_attrib *srcPacking,
-			    GLbitfield transferOps)
-{
-   GLfloat *tempImage;
-   const GLint components = _mesa_components_in_format(logicalBaseFormat);
-   const GLint srcStride =
-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-   GLfloat *dst;
-   GLint img, row;
-
-   ASSERT(dims >= 1 && dims <= 3);
-
-   ASSERT(logicalBaseFormat == GL_RGBA ||
-          logicalBaseFormat == GL_RGB ||
-          logicalBaseFormat == GL_RG ||
-          logicalBaseFormat == GL_RED ||
-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
-          logicalBaseFormat == GL_LUMINANCE ||
-          logicalBaseFormat == GL_ALPHA ||
-          logicalBaseFormat == GL_INTENSITY ||
-          logicalBaseFormat == GL_COLOR_INDEX ||
-          logicalBaseFormat == GL_DEPTH_COMPONENT);
-
-   ASSERT(textureBaseFormat == GL_RGBA ||
-          textureBaseFormat == GL_RGB ||
-          textureBaseFormat == GL_RG ||
-          textureBaseFormat == GL_RED ||
-          textureBaseFormat == GL_LUMINANCE_ALPHA ||
-          textureBaseFormat == GL_LUMINANCE ||
-          textureBaseFormat == GL_ALPHA ||
-          textureBaseFormat == GL_INTENSITY ||
-          textureBaseFormat == GL_COLOR_INDEX ||
-          textureBaseFormat == GL_DEPTH_COMPONENT);
-
-   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
-				  * components * sizeof(GLfloat));
-   if (!tempImage)
-      return NULL;
-
-   dst = tempImage;
-   for (img = 0; img < srcDepth; img++) {
-      const GLubyte *src
-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
-						 srcWidth, srcHeight,
-						 srcFormat, srcType,
-						 img, 0, 0);
-      for (row = 0; row < srcHeight; row++) {
-	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,
-				       dst, srcFormat, srcType, src,
-				       srcPacking, transferOps);
-	 dst += srcWidth * components;
-	 src += srcStride;
-      }
-   }
-
-   if (logicalBaseFormat != textureBaseFormat) {
-      /* more work */
-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
-      GLfloat *newImage;
-      GLint i, n;
-      GLubyte map[6];
-
-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
-             textureBaseFormat == GL_LUMINANCE_ALPHA);
-
-      /* The actual texture format should have at least as many components
-       * as the logical texture format.
-       */
-      ASSERT(texComponents >= logComponents);
-
-      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
-                                          * texComponents * sizeof(GLfloat));
-      if (!newImage) {
-         free(tempImage);
-         return NULL;
-      }
-
-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
-
-      n = srcWidth * srcHeight * srcDepth;
-      for (i = 0; i < n; i++) {
-         GLint k;
-         for (k = 0; k < texComponents; k++) {
-            GLint j = map[k];
-            if (j == ZERO)
-               newImage[i * texComponents + k] = 0.0F;
-            else if (j == ONE)
-               newImage[i * texComponents + k] = 1.0F;
-            else
-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
-         }
-      }
-
-      free(tempImage);
-      tempImage = newImage;
-   }
-
-   return tempImage;
-}
-
-
-/**
- * Make temporary image with uint pixel values.  Used for unsigned
- * integer-valued textures.
- */
-static GLuint *
-make_temp_uint_image(struct gl_context *ctx, GLuint dims,
-                     GLenum logicalBaseFormat,
-                     GLenum textureBaseFormat,
-                     GLint srcWidth, GLint srcHeight, GLint srcDepth,
-                     GLenum srcFormat, GLenum srcType,
-                     const GLvoid *srcAddr,
-                     const struct gl_pixelstore_attrib *srcPacking)
-{
-   GLuint *tempImage;
-   const GLint components = _mesa_components_in_format(logicalBaseFormat);
-   const GLint srcStride =
-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-   GLuint *dst;
-   GLint img, row;
-
-   ASSERT(dims >= 1 && dims <= 3);
-
-   ASSERT(logicalBaseFormat == GL_RGBA ||
-          logicalBaseFormat == GL_RGB ||
-          logicalBaseFormat == GL_RG ||
-          logicalBaseFormat == GL_RED ||
-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
-          logicalBaseFormat == GL_LUMINANCE ||
-          logicalBaseFormat == GL_INTENSITY ||
-          logicalBaseFormat == GL_ALPHA);
-
-   ASSERT(textureBaseFormat == GL_RGBA ||
-          textureBaseFormat == GL_RGB ||
-          textureBaseFormat == GL_RG ||
-          textureBaseFormat == GL_RED ||
-          textureBaseFormat == GL_LUMINANCE_ALPHA ||
-          textureBaseFormat == GL_LUMINANCE ||
-          textureBaseFormat == GL_ALPHA);
-
-   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
-                                 * components * sizeof(GLuint));
-   if (!tempImage)
-      return NULL;
-
-   dst = tempImage;
-   for (img = 0; img < srcDepth; img++) {
-      const GLubyte *src
-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
-						 srcWidth, srcHeight,
-						 srcFormat, srcType,
-						 img, 0, 0);
-      for (row = 0; row < srcHeight; row++) {
-	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,
-                                      dst, srcFormat, srcType, src,
-                                      srcPacking);
-	 dst += srcWidth * components;
-	 src += srcStride;
-      }
-   }
-
-   if (logicalBaseFormat != textureBaseFormat) {
-      /* more work */
-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
-      GLuint *newImage;
-      GLint i, n;
-      GLubyte map[6];
-
-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
-             textureBaseFormat == GL_LUMINANCE_ALPHA);
-
-      /* The actual texture format should have at least as many components
-       * as the logical texture format.
-       */
-      ASSERT(texComponents >= logComponents);
-
-      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
-                                   * texComponents * sizeof(GLuint));
-      if (!newImage) {
-         free(tempImage);
-         return NULL;
-      }
-
-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
-
-      n = srcWidth * srcHeight * srcDepth;
-      for (i = 0; i < n; i++) {
-         GLint k;
-         for (k = 0; k < texComponents; k++) {
-            GLint j = map[k];
-            if (j == ZERO)
-               newImage[i * texComponents + k] = 0.0F;
-            else if (j == ONE)
-               newImage[i * texComponents + k] = 1.0F;
-            else
-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
-         }
-      }
-
-      free(tempImage);
-      tempImage = newImage;
-   }
-
-   return tempImage;
-}
-
-
-
-/**
- * Make a temporary (color) texture image with GLchan components.
- * Apply all needed pixel unpacking and pixel transfer operations.
- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
- * Suppose the user specifies GL_LUMINANCE as the internal texture format
- * but the graphics hardware doesn't support luminance textures.  So, we might
- * use an RGB hardware format instead.
- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
- *
- * \param ctx  the rendering context
- * \param dims  image dimensions: 1, 2 or 3
- * \param logicalBaseFormat  basic texture derived from the user's
- *    internal texture format value
- * \param textureBaseFormat  the actual basic format of the texture
- * \param srcWidth  source image width
- * \param srcHeight  source image height
- * \param srcDepth  source image depth
- * \param srcFormat  source image format
- * \param srcType  source image type
- * \param srcAddr  source image address
- * \param srcPacking  source image pixel packing
- * \return resulting image with format = textureBaseFormat and type = GLchan.
- */
-GLchan *
-_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,
-                           GLenum logicalBaseFormat,
-                           GLenum textureBaseFormat,
-                           GLint srcWidth, GLint srcHeight, GLint srcDepth,
-                           GLenum srcFormat, GLenum srcType,
-                           const GLvoid *srcAddr,
-                           const struct gl_pixelstore_attrib *srcPacking)
-{
-   GLuint transferOps = ctx->_ImageTransferState;
-   const GLint components = _mesa_components_in_format(logicalBaseFormat);
-   GLint img, row;
-   GLchan *tempImage, *dst;
-
-   ASSERT(dims >= 1 && dims <= 3);
-
-   ASSERT(logicalBaseFormat == GL_RGBA ||
-          logicalBaseFormat == GL_RGB ||
-          logicalBaseFormat == GL_RG ||
-          logicalBaseFormat == GL_RED ||
-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
-          logicalBaseFormat == GL_LUMINANCE ||
-          logicalBaseFormat == GL_ALPHA ||
-          logicalBaseFormat == GL_INTENSITY);
-
-   ASSERT(textureBaseFormat == GL_RGBA ||
-          textureBaseFormat == GL_RGB ||
-          textureBaseFormat == GL_RG ||
-          textureBaseFormat == GL_RED ||
-          textureBaseFormat == GL_LUMINANCE_ALPHA ||
-          textureBaseFormat == GL_LUMINANCE ||
-          textureBaseFormat == GL_ALPHA ||
-          textureBaseFormat == GL_INTENSITY);
-
-   /* unpack and transfer the source image */
-   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
-                                       * components * sizeof(GLchan));
-   if (!tempImage) {
-      return NULL;
-   }
-
-   dst = tempImage;
-   for (img = 0; img < srcDepth; img++) {
-      const GLint srcStride =
-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-      const GLubyte *src =
-         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
-                                               srcWidth, srcHeight,
-                                               srcFormat, srcType,
-                                               img, 0, 0);
-      for (row = 0; row < srcHeight; row++) {
-         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,
-                                      srcFormat, srcType, src, srcPacking,
-                                      transferOps);
-         dst += srcWidth * components;
-         src += srcStride;
-      }
-   }
-
-   if (logicalBaseFormat != textureBaseFormat) {
-      /* one more conversion step */
-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
-      GLchan *newImage;
-      GLint i, n;
-      GLubyte map[6];
-
-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
-             textureBaseFormat == GL_LUMINANCE_ALPHA);
-
-      /* The actual texture format should have at least as many components
-       * as the logical texture format.
-       */
-      ASSERT(texComponents >= logComponents);
-
-      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
-                                         * texComponents * sizeof(GLchan));
-      if (!newImage) {
-         free(tempImage);
-         return NULL;
-      }
-
-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
-
-      n = srcWidth * srcHeight * srcDepth;
-      for (i = 0; i < n; i++) {
-         GLint k;
-         for (k = 0; k < texComponents; k++) {
-            GLint j = map[k];
-            if (j == ZERO)
-               newImage[i * texComponents + k] = 0;
-            else if (j == ONE)
-               newImage[i * texComponents + k] = CHAN_MAX;
-            else
-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
-         }
-      }
-
-      free(tempImage);
-      tempImage = newImage;
-   }
-
-   return tempImage;
-}
-
-
-/**
- * Copy GLubyte pixels from <src> to <dst> with swizzling.
- * \param dst  destination pixels
- * \param dstComponents  number of color components in destination pixels
- * \param src  source pixels
- * \param srcComponents  number of color components in source pixels
- * \param map  the swizzle mapping.  map[X] says where to find the X component
- *             in the source image's pixels.  For example, if the source image
- *             is GL_BGRA and X = red, map[0] yields 2.
- * \param count  number of pixels to copy/swizzle.
- */
-static void
-swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 
-             GLuint srcComponents, const GLubyte *map, GLuint count)
-{
-#define SWZ_CPY(dst, src, count, dstComps, srcComps) \
-   do {                                              \
-      GLuint i;                                      \
-      for (i = 0; i < count; i++) {                  \
-         GLuint j;                                   \
-         if (srcComps == 4) {                        \
-            COPY_4UBV(tmp, src);                     \
-         }                                           \
-         else {                                      \
-            for (j = 0; j < srcComps; j++) {         \
-               tmp[j] = src[j];                      \
-            }                                        \
-         }                                           \
-         src += srcComps;                            \
-         for (j = 0; j < dstComps; j++) {            \
-            dst[j] = tmp[map[j]];                    \
-         }                                           \
-         dst += dstComps;                            \
-      }                                              \
-   } while (0)
-
-   GLubyte tmp[6];
-
-   tmp[ZERO] = 0x0;
-   tmp[ONE] = 0xff;
-
-   ASSERT(srcComponents <= 4);
-   ASSERT(dstComponents <= 4);
-
-   switch (dstComponents) {
-   case 4:
-      switch (srcComponents) {
-      case 4:
-         SWZ_CPY(dst, src, count, 4, 4);
-         break;
-      case 3:
-         SWZ_CPY(dst, src, count, 4, 3);
-         break;
-      case 2:
-         SWZ_CPY(dst, src, count, 4, 2);
-         break;
-      case 1:
-         SWZ_CPY(dst, src, count, 4, 1);
-         break;
-      default:
-         ;
-      }
-      break;
-   case 3:
-      switch (srcComponents) {
-      case 4:
-         SWZ_CPY(dst, src, count, 3, 4);
-         break;
-      case 3:
-         SWZ_CPY(dst, src, count, 3, 3);
-         break;
-      case 2:
-         SWZ_CPY(dst, src, count, 3, 2);
-         break;
-      case 1:
-         SWZ_CPY(dst, src, count, 3, 1);
-         break;
-      default:
-         ;
-      }
-      break;
-   case 2:
-      switch (srcComponents) {
-      case 4:
-         SWZ_CPY(dst, src, count, 2, 4);
-         break;
-      case 3:
-         SWZ_CPY(dst, src, count, 2, 3);
-         break;
-      case 2:
-         SWZ_CPY(dst, src, count, 2, 2);
-         break;
-      case 1:
-         SWZ_CPY(dst, src, count, 2, 1);
-         break;
-      default:
-         ;
-      }
-      break;
-   case 1:
-      switch (srcComponents) {
-      case 4:
-         SWZ_CPY(dst, src, count, 1, 4);
-         break;
-      case 3:
-         SWZ_CPY(dst, src, count, 1, 3);
-         break;
-      case 2:
-         SWZ_CPY(dst, src, count, 1, 2);
-         break;
-      case 1:
-         SWZ_CPY(dst, src, count, 1, 1);
-         break;
-      default:
-         ;
-      }
-      break;
-   default:
-      ;
-   }
-#undef SWZ_CPY
-}
-
-
-
-static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };
-static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };
-
-
-/**
- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
- * mapping array depending on endianness.
- */
-static const GLubyte *
-type_mapping( GLenum srcType )
-{
-   switch (srcType) {
-   case GL_BYTE:
-   case GL_UNSIGNED_BYTE:
-      return map_identity;
-   case GL_UNSIGNED_INT_8_8_8_8:
-      return _mesa_little_endian() ? map_3210 : map_identity;
-   case GL_UNSIGNED_INT_8_8_8_8_REV:
-      return _mesa_little_endian() ? map_identity : map_3210;
-   default:
-      return NULL;
-   }
-}
-
-
-/**
- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
- * mapping array depending on pixelstore byte swapping state.
- */
-static const GLubyte *
-byteswap_mapping( GLboolean swapBytes,
-		  GLenum srcType )
-{
-   if (!swapBytes) 
-      return map_identity;
-
-   switch (srcType) {
-   case GL_BYTE:
-   case GL_UNSIGNED_BYTE:
-      return map_identity;
-   case GL_UNSIGNED_INT_8_8_8_8:
-   case GL_UNSIGNED_INT_8_8_8_8_REV:
-      return map_3210;
-   default:
-      return NULL;
-   }
-}
-
-
-
-/**
- * Transfer a GLubyte texture image with component swizzling.
- */
-static void
-_mesa_swizzle_ubyte_image(struct gl_context *ctx, 
-			  GLuint dimensions,
-			  GLenum srcFormat,
-			  GLenum srcType,
-
-			  GLenum baseInternalFormat,
-
-			  const GLubyte *rgba2dst,
-			  GLuint dstComponents,
-
-			  GLvoid *dstAddr,
-			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
-			  GLint dstRowStride,
-                          const GLuint *dstImageOffsets,
-
-			  GLint srcWidth, GLint srcHeight, GLint srcDepth,
-			  const GLvoid *srcAddr,
-			  const struct gl_pixelstore_attrib *srcPacking )
-{
-   GLint srcComponents = _mesa_components_in_format(srcFormat);
-   const GLubyte *srctype2ubyte, *swap;
-   GLubyte map[4], src2base[6], base2rgba[6];
-   GLint i;
-   const GLint srcRowStride =
-      _mesa_image_row_stride(srcPacking, srcWidth,
-                             srcFormat, GL_UNSIGNED_BYTE);
-   const GLint srcImageStride
-      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,
-                                 GL_UNSIGNED_BYTE);
-   const GLubyte *srcImage
-      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,
-                                              srcWidth, srcHeight, srcFormat,
-                                              GL_UNSIGNED_BYTE, 0, 0, 0);
-
-   (void) ctx;
-
-   /* Translate from src->baseInternal->GL_RGBA->dst.  This will
-    * correctly deal with RGBA->RGB->RGBA conversions where the final
-    * A value must be 0xff regardless of the incoming alpha values.
-    */
-   compute_component_mapping(srcFormat, baseInternalFormat, src2base);
-   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);
-   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);
-   srctype2ubyte = type_mapping(srcType);
-
-
-   for (i = 0; i < 4; i++)
-      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
-
-/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */
-
-   if (srcComponents == dstComponents &&
-       srcRowStride == dstRowStride &&
-       srcRowStride == srcWidth * srcComponents &&
-       dimensions < 3) {
-      /* 1 and 2D images only */
-      GLubyte *dstImage = (GLubyte *) dstAddr
-         + dstYoffset * dstRowStride
-         + dstXoffset * dstComponents;
-      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 
-		   srcWidth * srcHeight);
-   }
-   else {
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         const GLubyte *srcRow = srcImage;
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * dstComponents
-            + dstYoffset * dstRowStride
-            + dstXoffset * dstComponents;
-         for (row = 0; row < srcHeight; row++) {
-	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-         srcImage += srcImageStride;
-      }
-   }
-}
-
-
-/**
- * Teximage storage routine for when a simple memcpy will do.
- * No pixel transfer operations or special texel encodings allowed.
- * 1D, 2D and 3D images supported.
- */
-static void
-memcpy_texture(struct gl_context *ctx,
-	       GLuint dimensions,
-               gl_format dstFormat,
-               GLvoid *dstAddr,
-               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
-               GLint dstRowStride,
-               const GLuint *dstImageOffsets,
-               GLint srcWidth, GLint srcHeight, GLint srcDepth,
-               GLenum srcFormat, GLenum srcType,
-               const GLvoid *srcAddr,
-               const struct gl_pixelstore_attrib *srcPacking)
-{
-   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
-                                                     srcFormat, srcType);
-   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
-                                      srcWidth, srcHeight, srcFormat, srcType);
-   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,
-        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLint bytesPerRow = srcWidth * texelBytes;
-
-#if 0
-   /* XXX update/re-enable for dstImageOffsets array */
-   const GLint bytesPerImage = srcHeight * bytesPerRow;
-   const GLint bytesPerTexture = srcDepth * bytesPerImage;
-   GLubyte *dstImage = (GLubyte *) dstAddr
-                     + dstZoffset * dstImageStride
-                     + dstYoffset * dstRowStride
-                     + dstXoffset * texelBytes;
-
-   if (dstRowStride == srcRowStride &&
-       dstRowStride == bytesPerRow &&
-       ((dstImageStride == srcImageStride &&
-         dstImageStride == bytesPerImage) ||
-        (srcDepth == 1))) {
-      /* one big memcpy */
-      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);
-   }
-   else
-   {
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         const GLubyte *srcRow = srcImage;
-         GLubyte *dstRow = dstImage;
-         for (row = 0; row < srcHeight; row++) {
-            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-         srcImage += srcImageStride;
-         dstImage += dstImageStride;
-      }
-   }
-#endif
-
-   GLint img, row;
-   for (img = 0; img < srcDepth; img++) {
-      const GLubyte *srcRow = srcImage;
-      GLubyte *dstRow = (GLubyte *) dstAddr
-         + dstImageOffsets[dstZoffset + img] * texelBytes
-         + dstYoffset * dstRowStride
-         + dstXoffset * texelBytes;
-      for (row = 0; row < srcHeight; row++) {
-         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
-         dstRow += dstRowStride;
-         srcRow += srcRowStride;
-      }
-      srcImage += srcImageStride;
-   }
-}
-
-
-
-/**
- * Store a 32-bit integer depth component texture image.
- */
-static GLboolean
-_mesa_texstore_z32(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffffffff;
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   (void) dims;
-   ASSERT(dstFormat == MESA_FORMAT_Z32);
-   ASSERT(texelBytes == sizeof(GLuint));
-
-   if (ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_DEPTH_COMPONENT &&
-       srcFormat == GL_DEPTH_COMPONENT &&
-       srcType == GL_UNSIGNED_INT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            const GLvoid *src = _mesa_image_address(dims, srcPacking,
-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
-            _mesa_unpack_depth_span(ctx, srcWidth,
-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
-                                    depthScale, srcType, src, srcPacking);
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a 24-bit integer depth component texture image.
- */
-static GLboolean
-_mesa_texstore_x8_z24(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffffff;
-   const GLuint texelBytes = 4;
-
-   (void) dims;
-   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);
-
-   {
-      /* general path */
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            const GLvoid *src = _mesa_image_address(dims, srcPacking,
-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
-            _mesa_unpack_depth_span(ctx, srcWidth,
-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
-                                    depthScale, srcType, src, srcPacking);
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a 24-bit integer depth component texture image.
- */
-static GLboolean
-_mesa_texstore_z24_x8(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffffff;
-   const GLuint texelBytes = 4;
-
-   (void) dims;
-   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);
-
-   {
-      /* general path */
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            const GLvoid *src = _mesa_image_address(dims, srcPacking,
-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
-            GLuint *dst = (GLuint *) dstRow;
-            GLint i;
-            _mesa_unpack_depth_span(ctx, srcWidth,
-                                    GL_UNSIGNED_INT, dst,
-                                    depthScale, srcType, src, srcPacking);
-            for (i = 0; i < srcWidth; i++)
-               dst[i] <<= 8;
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a 16-bit integer depth component texture image.
- */
-static GLboolean
-_mesa_texstore_z16(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffff;
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   (void) dims;
-   ASSERT(dstFormat == MESA_FORMAT_Z16);
-   ASSERT(texelBytes == sizeof(GLushort));
-
-   if (ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_DEPTH_COMPONENT &&
-       srcFormat == GL_DEPTH_COMPONENT &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            const GLvoid *src = _mesa_image_address(dims, srcPacking,
-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
-            GLushort *dst16 = (GLushort *) dstRow;
-            _mesa_unpack_depth_span(ctx, srcWidth,
-                                    GL_UNSIGNED_SHORT, dst16, depthScale,
-                                    srcType, src, srcPacking);
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store an rgb565 or rgb565_rev texture image.
- */
-static GLboolean
-_mesa_texstore_rgb565(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||
-          dstFormat == MESA_FORMAT_RGB565_REV);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_RGB565 &&
-       baseInternalFormat == GL_RGB &&
-       srcFormat == GL_RGB &&
-       srcType == GL_UNSIGNED_SHORT_5_6_5) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            baseInternalFormat == GL_RGB &&
-            srcFormat == GL_RGB &&
-            srcType == GL_UNSIGNED_BYTE &&
-            dims == 2) {
-      /* do optimized tex store */
-      const GLint srcRowStride =
-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-      const GLubyte *src = (const GLubyte *)
-         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
-                             srcFormat, srcType, 0, 0, 0);
-      GLubyte *dst = (GLubyte *) dstAddr
-                   + dstYoffset * dstRowStride
-                   + dstXoffset * texelBytes;
-      GLint row, col;
-      for (row = 0; row < srcHeight; row++) {
-         const GLubyte *srcUB = (const GLubyte *) src;
-         GLushort *dstUS = (GLushort *) dst;
-         /* check for byteswapped format */
-         if (dstFormat == MESA_FORMAT_RGB565) {
-            for (col = 0; col < srcWidth; col++) {
-               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );
-               srcUB += 3;
-            }
-         }
-         else {
-            for (col = 0; col < srcWidth; col++) {
-               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );
-               srcUB += 3;
-            }
-         }
-         dst += dstRowStride;
-         src += srcRowStride;
-      }
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            /* check for byteswapped format */
-            if (dstFormat == MESA_FORMAT_RGB565) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),
-                                               CHAN_TO_UBYTE(src[GCOMP]),
-                                               CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 3;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),
-                                                   CHAN_TO_UBYTE(src[GCOMP]),
-                                                   CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 3;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.
- */
-static GLboolean
-_mesa_texstore_rgba8888(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||
-          dstFormat == MESA_FORMAT_RGBA8888_REV);
-   ASSERT(texelBytes == 4);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_RGBA8888 &&
-       baseInternalFormat == GL_RGBA &&
-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {
-       /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_RGBA8888_REV &&
-       baseInternalFormat == GL_RGBA &&
-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    (srcType == GL_UNSIGNED_BYTE ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||
-	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {
-	 dstmap[3] = 0;
-	 dstmap[2] = 1;
-	 dstmap[1] = 2;
-	 dstmap[0] = 3;
-      }
-      else {
-	 dstmap[3] = 3;
-	 dstmap[2] = 2;
-	 dstmap[1] = 1;
-	 dstmap[0] = 0;
-      }
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 4,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstUI = (GLuint *) dstRow;
-            if (dstFormat == MESA_FORMAT_RGBA8888) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),
-                                                CHAN_TO_UBYTE(src[GCOMP]),
-                                                CHAN_TO_UBYTE(src[BCOMP]),
-                                                CHAN_TO_UBYTE(src[ACOMP]) );
-                  src += 4;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),
-                                                    CHAN_TO_UBYTE(src[GCOMP]),
-                                                    CHAN_TO_UBYTE(src[BCOMP]),
-                                                    CHAN_TO_UBYTE(src[ACOMP]) );
-                  src += 4;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_argb8888(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = GL_RGBA;
-
-   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||
-          dstFormat == MESA_FORMAT_ARGB8888_REV ||
-          dstFormat == MESA_FORMAT_XRGB8888 ||
-          dstFormat == MESA_FORMAT_XRGB8888_REV );
-   ASSERT(texelBytes == 4);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       (dstFormat == MESA_FORMAT_ARGB8888 ||
-        dstFormat == MESA_FORMAT_XRGB8888) &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_BGRA &&
-       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||
-        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {
-      /* simple memcpy path (little endian) */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       (dstFormat == MESA_FORMAT_ARGB8888_REV ||
-        dstFormat == MESA_FORMAT_XRGB8888_REV) &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_BGRA &&
-       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
-        srcType == GL_UNSIGNED_INT_8_8_8_8)) {
-      /* simple memcpy path (big endian) */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-	    (dstFormat == MESA_FORMAT_ARGB8888 ||
-             dstFormat == MESA_FORMAT_XRGB8888) &&
-            srcFormat == GL_RGB &&
-	    (baseInternalFormat == GL_RGBA ||
-	     baseInternalFormat == GL_RGB) &&
-            srcType == GL_UNSIGNED_BYTE) {
-      int img, row, col;
-      for (img = 0; img < srcDepth; img++) {
-         const GLint srcRowStride =
-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *d4 = (GLuint *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               d4[col] = PACK_COLOR_8888(0xff,
-                                         srcRow[col * 3 + RCOMP],
-                                         srcRow[col * 3 + GCOMP],
-                                         srcRow[col * 3 + BCOMP]);
-            }
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-      }
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-	    dstFormat == MESA_FORMAT_ARGB8888 &&
-            srcFormat == GL_RGBA &&
-	    baseInternalFormat == GL_RGBA &&
-            srcType == GL_UNSIGNED_BYTE) {
-      /* same as above case, but src data has alpha too */
-      GLint img, row, col;
-      /* For some reason, streaming copies to write-combined regions
-       * are extremely sensitive to the characteristics of how the
-       * source data is retrieved.  By reordering the source reads to
-       * be in-order, the speed of this operation increases by half.
-       * Strangely the same isn't required for the RGB path, above.
-       */
-      for (img = 0; img < srcDepth; img++) {
-         const GLint srcRowStride =
-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *d4 = (GLuint *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],
-                                         srcRow[col * 4 + RCOMP],
-                                         srcRow[col * 4 + GCOMP],
-                                         srcRow[col * 4 + BCOMP]);
-            }
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-      }
-   }
-   else if (!ctx->_ImageTransferState &&
-	    (srcType == GL_UNSIGNED_BYTE ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
-	    can_swizzle(baseInternalFormat) &&	   
-	    can_swizzle(srcFormat)) {
-
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
-          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||
-	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
-	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {
-	 dstmap[3] = 3;		/* alpha */
-	 dstmap[2] = 0;		/* red */
-	 dstmap[1] = 1;		/* green */
-	 dstmap[0] = 2;		/* blue */
-      }
-      else {
-	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
-		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
-		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||
-		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));
-	 dstmap[3] = 2;
-	 dstmap[2] = 1;
-	 dstmap[1] = 0;
-	 dstmap[0] = 3;
-      }
- 
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 4,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride,
-                                dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstUI = (GLuint *) dstRow;
-            if (dstFormat == MESA_FORMAT_ARGB8888) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),
-                                                CHAN_TO_UBYTE(src[RCOMP]),
-                                                CHAN_TO_UBYTE(src[GCOMP]),
-                                                CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            else if (dstFormat == MESA_FORMAT_XRGB8888) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888( 0xff,
-                                                CHAN_TO_UBYTE(src[RCOMP]),
-                                                CHAN_TO_UBYTE(src[GCOMP]),
-                                                CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),
-                                                    CHAN_TO_UBYTE(src[RCOMP]),
-                                                    CHAN_TO_UBYTE(src[GCOMP]),
-                                                    CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_rgb888(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGB888);
-   ASSERT(texelBytes == 3);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGB &&
-       srcFormat == GL_BGR &&
-       srcType == GL_UNSIGNED_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            srcFormat == GL_RGBA &&
-            srcType == GL_UNSIGNED_BYTE) {
-      /* extract RGB from RGBA */
-      GLint img, row, col;
-      for (img = 0; img < srcDepth; img++) {
-         const GLint srcRowStride =
-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];
-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
-               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];
-            }
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-      }
-   }
-   else if (!ctx->_ImageTransferState &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      dstmap[0] = 2;
-      dstmap[1] = 1;
-      dstmap[2] = 0;
-      dstmap[3] = ONE;		/* ? */
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 3,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = (const GLchan *) tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-#if 0
-            if (littleEndian) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
-                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
-                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
-                  srcUB += 3;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstRow[col * 3 + 0] = srcUB[BCOMP];
-                  dstRow[col * 3 + 1] = srcUB[GCOMP];
-                  dstRow[col * 3 + 2] = srcUB[RCOMP];
-                  srcUB += 3;
-               }
-            }
-#else
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);
-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);
-               src += 3;
-            }
-#endif
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_bgr888(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_BGR888);
-   ASSERT(texelBytes == 3);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGB &&
-       srcFormat == GL_RGB &&
-       srcType == GL_UNSIGNED_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            srcFormat == GL_RGBA &&
-            srcType == GL_UNSIGNED_BYTE) {
-      /* extract BGR from RGBA */
-      int img, row, col;
-      for (img = 0; img < srcDepth; img++) {
-         const GLint srcRowStride =
-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];
-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
-               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];
-            }
-            dstRow += dstRowStride;
-            srcRow += srcRowStride;
-         }
-      }
-   }
-   else if (!ctx->_ImageTransferState &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      dstmap[0] = 0;
-      dstmap[1] = 1;
-      dstmap[2] = 2;
-      dstmap[3] = ONE;		/* ? */
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 3,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }   
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = (const GLchan *) tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
-               src += 3;
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_argb4444(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||
-          dstFormat == MESA_FORMAT_ARGB4444_REV);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_ARGB4444 &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_BGRA &&
-       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            if (dstFormat == MESA_FORMAT_ARGB4444) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),
-                                                CHAN_TO_UBYTE(src[RCOMP]),
-                                                CHAN_TO_UBYTE(src[GCOMP]),
-                                                CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),
-                                                    CHAN_TO_UBYTE(src[RCOMP]),
-                                                    CHAN_TO_UBYTE(src[GCOMP]),
-                                                    CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_rgba5551(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_RGBA5551 &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_RGBA &&
-       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src =tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-	    for (col = 0; col < srcWidth; col++) {
-	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),
-					     CHAN_TO_UBYTE(src[GCOMP]),
-					     CHAN_TO_UBYTE(src[BCOMP]),
-					     CHAN_TO_UBYTE(src[ACOMP]) );
-	      src += 4;
-	    }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_argb1555(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||
-          dstFormat == MESA_FORMAT_ARGB1555_REV);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_ARGB1555 &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_BGRA &&
-       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src =tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            if (dstFormat == MESA_FORMAT_ARGB1555) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),
-                                                CHAN_TO_UBYTE(src[RCOMP]),
-                                                CHAN_TO_UBYTE(src[GCOMP]),
-                                                CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),
-                                                    CHAN_TO_UBYTE(src[RCOMP]),
-                                                    CHAN_TO_UBYTE(src[GCOMP]),
-                                                    CHAN_TO_UBYTE(src[BCOMP]) );
-                  src += 4;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_argb2101010(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);
-   ASSERT(texelBytes == 4);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_ARGB2101010 &&
-       srcFormat == GL_BGRA &&
-       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&
-       baseInternalFormat == GL_RGBA) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         if (baseInternalFormat == GL_RGBA) {
-            for (row = 0; row < srcHeight; row++) {
-               GLuint *dstUI = (GLuint *) dstRow;
-               for (col = 0; col < srcWidth; col++) {
-                  GLushort a,r,g,b;
-
-                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
-                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);
-                  src += 4;
-               }
-               dstRow += dstRowStride;
-            }
-         } else if (baseInternalFormat == GL_RGB) {
-            for (row = 0; row < srcHeight; row++) {
-               GLuint *dstUI = (GLuint *) dstRow;
-               for (col = 0; col < srcWidth; col++) {
-                  GLushort r,g,b;
-
-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
-                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);
-                  src += 4;
-               }
-               dstRow += dstRowStride;
-            }
-         } else {
-            ASSERT(0);
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.
- */
-static GLboolean
-_mesa_texstore_unorm44(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_AL44);
-   ASSERT(texelBytes == 1);
-
-   {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLubyte *dstUS = (GLubyte *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               /* src[0] is luminance, src[1] is alpha */
-               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),
-                                           CHAN_TO_UBYTE(src[0]) );
-               src += 2;
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.
- */
-static GLboolean
-_mesa_texstore_unorm88(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_AL88 ||
-          dstFormat == MESA_FORMAT_AL88_REV ||
-          dstFormat == MESA_FORMAT_RG88 ||
-          dstFormat == MESA_FORMAT_RG88_REV);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_RG88) &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    littleEndian &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {
-	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||
-	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {
-	    dstmap[0] = 0;
-	    dstmap[1] = 3;
-	 }
-	 else {
-	    dstmap[0] = 3;
-	    dstmap[1] = 0;
-	 }
-      }
-      else {
-	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||
-	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {
-	    dstmap[0] = 0;
-	    dstmap[1] = 1;
-	 }
-	 else {
-	    dstmap[0] = 1;
-	    dstmap[1] = 0;
-	 }
-      }
-      dstmap[2] = ZERO;		/* ? */
-      dstmap[3] = ONE;		/* ? */
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 2,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }   
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            if (dstFormat == MESA_FORMAT_AL88 ||
-		dstFormat == MESA_FORMAT_RG88) {
-               for (col = 0; col < srcWidth; col++) {
-                  /* src[0] is luminance, src[1] is alpha */
-                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),
-                                             CHAN_TO_UBYTE(src[0]) );
-                 src += 2;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  /* src[0] is luminance, src[1] is alpha */
-                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),
-                                                 CHAN_TO_UBYTE(src[0]) );
-                 src += 2;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.
- */
-static GLboolean
-_mesa_texstore_unorm1616(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
-          dstFormat == MESA_FORMAT_AL1616_REV ||
-	  dstFormat == MESA_FORMAT_RG1616 ||
-          dstFormat == MESA_FORMAT_RG1616_REV);
-   ASSERT(texelBytes == 4);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       (dstFormat == MESA_FORMAT_AL1616 || dstFormat == MESA_FORMAT_RG1616) &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstUI = (GLuint *) dstRow;
-            if (dstFormat == MESA_FORMAT_AL1616 ||
-		dstFormat == MESA_FORMAT_RG1616) {
-               for (col = 0; col < srcWidth; col++) {
-		  GLushort l, a;
-
-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
-		  dstUI[col] = PACK_COLOR_1616(a, l);
-		  src += 2;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-		  GLushort l, a;
-
-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
-		  dstUI[col] = PACK_COLOR_1616_REV(a, l);
-		  src += 2;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* Texstore for R16, A16, L16, I16. */
-static GLboolean
-_mesa_texstore_unorm16(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_R16 ||
-          dstFormat == MESA_FORMAT_A16 ||
-          dstFormat == MESA_FORMAT_L16 ||
-          dstFormat == MESA_FORMAT_I16);
-   ASSERT(texelBytes == 2);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-	    for (col = 0; col < srcWidth; col++) {
-	       GLushort r;
-
-	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
-	       dstUS[col] = r;
-	       src += 1;
-	    }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_rgba_16(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);
-   ASSERT(texelBytes == 8);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_RGBA &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               GLushort r, g, b, a;
-
-               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
-               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);
-               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);
-               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);
-               dstUS[col*4+0] = r;
-               dstUS[col*4+1] = g;
-               dstUS[col*4+2] = b;
-               dstUS[col*4+3] = a;
-               src += 4;
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R_16 ||
-          dstFormat == MESA_FORMAT_SIGNED_RG_16 ||
-          dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||
-          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGBA &&
-       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&
-       srcFormat == GL_RGBA &&
-       srcType == GL_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;
-      GLint img, row, col;
-
-      if (!tempImage)
-         return GL_FALSE;
-
-      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,
-       * 3 or 4 components/pixel here.
-       */
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLshort *dstRowS = (GLshort *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               GLuint c;
-               for (c = 0; c < comps; c++) {
-                  GLshort p;
-                  UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);
-                  dstRowS[col * comps + c] = p;
-               }
-            }
-            dstRow += dstRowStride;
-            src += 4 * srcWidth;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
-_mesa_texstore_rgb332(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGB332);
-   ASSERT(texelBytes == 1);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGB &&
-       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),
-                                             CHAN_TO_UBYTE(src[GCOMP]),
-                                             CHAN_TO_UBYTE(src[BCOMP]) );
-               src += 3;
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.
- */
-static GLboolean
-_mesa_texstore_a8(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_A8 ||
-          dstFormat == MESA_FORMAT_L8 ||
-          dstFormat == MESA_FORMAT_I8 ||
-          dstFormat == MESA_FORMAT_R8);
-   ASSERT(texelBytes == 1);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if (dstFormat == MESA_FORMAT_A8) {
-	 dstmap[0] = 3;
-      }
-      else {
-	 dstmap[0] = 0;
-      }
-      dstmap[1] = ZERO;		/* ? */
-      dstmap[2] = ZERO;		/* ? */
-      dstmap[3] = ONE;		/* ? */
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 1,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }   
-   else {
-      /* general path */
-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking);
-      const GLchan *src = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            for (col = 0; col < srcWidth; col++) {
-               dstRow[col] = CHAN_TO_UBYTE(src[col]);
-            }
-            dstRow += dstRowStride;
-            src += srcWidth;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-
-static GLboolean
-_mesa_texstore_ci8(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-
-   (void) dims; (void) baseInternalFormat;
-   ASSERT(dstFormat == MESA_FORMAT_CI8);
-   ASSERT(texelBytes == 1);
-   ASSERT(baseInternalFormat == GL_COLOR_INDEX);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       srcFormat == GL_COLOR_INDEX &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            const GLvoid *src = _mesa_image_address(dims, srcPacking,
-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
-            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,
-                                    srcType, src, srcPacking,
-                                    ctx->_ImageTransferState);
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
- */
-static GLboolean
-_mesa_texstore_ycbcr(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-
-   (void) ctx; (void) dims; (void) baseInternalFormat;
-
-   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||
-          (dstFormat == MESA_FORMAT_YCBCR_REV));
-   ASSERT(texelBytes == 2);
-   ASSERT(ctx->Extensions.MESA_ycbcr_texture);
-   ASSERT(srcFormat == GL_YCBCR_MESA);
-   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||
-          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
-   ASSERT(baseInternalFormat == GL_YCBCR_MESA);
-
-   /* always just memcpy since no pixel transfer ops apply */
-   memcpy_texture(ctx, dims,
-                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                  dstRowStride,
-                  dstImageOffsets,
-                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                  srcAddr, srcPacking);
-
-   /* Check if we need byte swapping */
-   /* XXX the logic here _might_ be wrong */
-   if (srcPacking->SwapBytes ^
-       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
-       (dstFormat == MESA_FORMAT_YCBCR_REV) ^
-       !littleEndian) {
-      GLint img, row;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            _mesa_swap2((GLushort *) dstRow, srcWidth);
-            dstRow += dstRowStride;
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_dudv8(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_DUDV8);
-   ASSERT(texelBytes == 2);
-   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);
-   ASSERT((srcFormat == GL_DU8DV8_ATI) ||
-	  (srcFormat == GL_DUDV_ATI));
-   ASSERT(baseInternalFormat == GL_DUDV_ATI);
-
-   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (srcType == GL_BYTE) {
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if (littleEndian) {
-	 dstmap[0] = 0;
-	 dstmap[1] = 3;
-      }
-      else {
-	 dstmap[0] = 3;
-	 dstmap[1] = 0;
-      }
-      dstmap[2] = ZERO;		/* ? */
-      dstmap[3] = ONE;		/* ? */
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				GL_LUMINANCE_ALPHA, /* hack */
-				GL_UNSIGNED_BYTE, /* hack */
-				GL_LUMINANCE_ALPHA, /* hack */
-				dstmap, 2,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }   
-   else {
-      /* general path - note this is defined for 2d textures only */
-      const GLint components = _mesa_components_in_format(baseInternalFormat);
-      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,
-                                                     srcFormat, srcType);
-      GLbyte *tempImage, *dst, *src;
-      GLint row;
-
-      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth
-                                          * components * sizeof(GLbyte));
-      if (!tempImage)
-         return GL_FALSE;
-
-      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,
-                                           srcWidth, srcHeight,
-                                           srcFormat, srcType,
-                                           0, 0, 0);
-
-      dst = tempImage;
-      for (row = 0; row < srcHeight; row++) {
-         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,
-                                     dst, srcFormat, srcType, src,
-                                     srcPacking, 0);
-         dst += srcWidth * components;
-         src += srcStride;
-      }
- 
-      src = tempImage;
-      dst = (GLbyte *) dstAddr
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-      for (row = 0; row < srcHeight; row++) {
-         memcpy(dst, src, srcWidth * texelBytes);
-         dst += dstRowStride;
-         src += srcWidth * texelBytes;
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a texture in MESA_FORMAT_SIGNED_R8 format.
- */
-static GLboolean
-_mesa_texstore_signed_r8(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R8);
-   ASSERT(texelBytes == 1);
-
-   /* XXX look at adding optimized paths */
-   {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *srcRow = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLubyte *dstB = (GLubyte *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               dstB[col] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a texture in MESA_FORMAT_SIGNED_RG88 format.
- */
-static GLboolean
-_mesa_texstore_signed_rg88(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RG88);
-   ASSERT(texelBytes == 1);
-
-   /* XXX look at adding optimized paths */
-   {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *srcRow = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstUS = (GLushort *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               dstUS[col] = PACK_COLOR_88(FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
-                                          FLOAT_TO_BYTE_TEX(srcRow[GCOMP]));
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.
- */
-static GLboolean
-_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);
-   ASSERT(texelBytes == 4);
-
-   {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *srcRow = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstUI = (GLuint *) dstRow;
-            for (col = 0; col < srcWidth; col++) {
-               dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
-                                             FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),
-                                             FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),
-                                             0xff );
-               srcRow += 4;
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-
-/**
- * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or
- * MESA_FORMAT_SIGNED_RGBA8888_REV
- */
-static GLboolean
-_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
-{
-   const GLboolean littleEndian = _mesa_little_endian();
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||
-          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);
-   ASSERT(texelBytes == 4);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&
-       baseInternalFormat == GL_RGBA &&
-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {
-       /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&
-       baseInternalFormat == GL_RGBA &&
-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||
-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    (srcType == GL_BYTE) &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
-
-      GLubyte dstmap[4];
-
-      /* dstmap - how to swizzle from RGBA to dst format:
-       */
-      if ((littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888) ||
-	  (!littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV)) {
-	 dstmap[3] = 0;
-	 dstmap[2] = 1;
-	 dstmap[1] = 2;
-	 dstmap[0] = 3;
-      }
-      else {
-	 dstmap[3] = 3;
-	 dstmap[2] = 2;
-	 dstmap[1] = 1;
-	 dstmap[0] = 0;
-      }
-      
-      _mesa_swizzle_ubyte_image(ctx, dims,
-				srcFormat,
-				srcType,
-				baseInternalFormat,
-				dstmap, 4,
-				dstAddr, dstXoffset, dstYoffset, dstZoffset,
-				dstRowStride, dstImageOffsets,
-				srcWidth, srcHeight, srcDepth, srcAddr,
-				srcPacking);      
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *srcRow = tempImage;
-      GLint img, row, col;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstUI = (GLuint *) dstRow;
-            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
-                                                FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),
-                                                FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),
-                                                FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );
-                  srcRow += 4;
-               }
-            }
-            else {
-               for (col = 0; col < srcWidth; col++) {
-                  dstUI[col] = PACK_COLOR_8888_REV( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
-                                                    FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),
-                                                    FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),
-                                                    FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );
-                  srcRow += 4;
-               }
-            }
-            dstRow += dstRowStride;
-         }
-      }
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a combined depth/stencil texture image.
- */
-static GLboolean
-_mesa_texstore_z24_s8(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffffff;
-   const GLint srcRowStride
-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
-      / sizeof(GLuint);
-   GLint img, row;
-
-   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);
-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);
-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
-
-   if (srcFormat != GL_DEPTH_COMPONENT && ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes) {
-      /* simple path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (srcFormat == GL_DEPTH_COMPONENT) {
-      /* In case we only upload depth we need to preserve the stencil */
-      for (img = 0; img < srcDepth; img++) {
-	 GLuint *dstRow = (GLuint *) dstAddr
-            + dstImageOffsets[dstZoffset + img]
-            + dstYoffset * dstRowStride / sizeof(GLuint)
-            + dstXoffset;
-         const GLuint *src
-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
-                  srcWidth, srcHeight,
-                  srcFormat, srcType,
-                  img, 0, 0);
-         for (row = 0; row < srcHeight; row++) {
-            GLuint depth[MAX_WIDTH];
-	    GLubyte stencil[MAX_WIDTH];
-            GLint i;
-	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
-
-	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
-	       keepstencil = GL_TRUE;
-	    }
-            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
-	       keepdepth = GL_TRUE;
-	    }
-
-	    if (keepdepth == GL_FALSE)
-	       /* the 24 depth bits will be in the low position: */
-	       _mesa_unpack_depth_span(ctx, srcWidth,
-				       GL_UNSIGNED_INT, /* dst type */
-				       keepstencil ? depth : dstRow, /* dst addr */
-				       depthScale,
-				       srcType, src, srcPacking);
-
-	    if (keepstencil == GL_FALSE)
-	       /* get the 8-bit stencil values */
-	       _mesa_unpack_stencil_span(ctx, srcWidth,
-					 GL_UNSIGNED_BYTE, /* dst type */
-					 stencil, /* dst addr */
-					 srcType, src, srcPacking,
-					 ctx->_ImageTransferState);
-
-	    for (i = 0; i < srcWidth; i++) {
-	       if (keepstencil)
-		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
-	       else
-		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);
-	    }
-
-            src += srcRowStride;
-            dstRow += dstRowStride / sizeof(GLuint);
-         }
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store a combined depth/stencil texture image.
- */
-static GLboolean
-_mesa_texstore_s8_z24(TEXSTORE_PARAMS)
-{
-   const GLuint depthScale = 0xffffff;
-   const GLint srcRowStride
-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
-      / sizeof(GLuint);
-   GLint img, row;
-
-   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);
-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
-          srcFormat == GL_DEPTH_COMPONENT ||
-          srcFormat == GL_STENCIL_INDEX);
-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||
-          srcType == GL_UNSIGNED_INT_24_8_EXT);
-
-   for (img = 0; img < srcDepth; img++) {
-      GLuint *dstRow = (GLuint *) dstAddr
-	 + dstImageOffsets[dstZoffset + img]
-	 + dstYoffset * dstRowStride / sizeof(GLuint)
-	 + dstXoffset;
-      const GLuint *src
-	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
-						srcWidth, srcHeight,
-						srcFormat, srcType,
-						img, 0, 0);
-      for (row = 0; row < srcHeight; row++) {
-	 GLuint depth[MAX_WIDTH];
-	 GLubyte stencil[MAX_WIDTH];
-	 GLint i;
-	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
-	 
-	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
-	    keepstencil = GL_TRUE;
-	 }
-         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
-	    keepdepth = GL_TRUE;
-	 }
-
-	 if (keepdepth == GL_FALSE)
-	    /* the 24 depth bits will be in the low position: */
-	    _mesa_unpack_depth_span(ctx, srcWidth,
-				    GL_UNSIGNED_INT, /* dst type */
-				    keepstencil ? depth : dstRow, /* dst addr */
-				    depthScale,
-				    srcType, src, srcPacking);	 
-
-	 if (keepstencil == GL_FALSE)
-	    /* get the 8-bit stencil values */
-	    _mesa_unpack_stencil_span(ctx, srcWidth,
-				      GL_UNSIGNED_BYTE, /* dst type */
-				      stencil, /* dst addr */
-				      srcType, src, srcPacking,
-				      ctx->_ImageTransferState);
-
-	 /* merge stencil values into depth values */
-	 for (i = 0; i < srcWidth; i++) {
-	    if (keepstencil)
-	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);
-	    else
-	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);
-
-	 }
-	 src += srcRowStride;
-	 dstRow += dstRowStride / sizeof(GLuint);
-      }
-   }
-   return GL_TRUE;
-}
-
-
-/**
- * Store simple 8-bit/value stencil texture data.
- */
-static GLboolean
-_mesa_texstore_s8(TEXSTORE_PARAMS)
-{
-   ASSERT(dstFormat == MESA_FORMAT_S8);
-   ASSERT(srcFormat == GL_STENCIL_INDEX);
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      const GLint srcRowStride
-	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
-	 / sizeof(GLuint);
-      GLint img, row;
-      
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img]
-            + dstYoffset * dstRowStride / sizeof(GLuint)
-            + dstXoffset;
-         const GLuint *src
-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
-                                                   srcWidth, srcHeight,
-                                                   srcFormat, srcType,
-                                                   img, 0, 0);
-         for (row = 0; row < srcHeight; row++) {
-            GLubyte stencil[MAX_WIDTH];
-            GLint i;
-
-            /* get the 8-bit stencil values */
-            _mesa_unpack_stencil_span(ctx, srcWidth,
-                                      GL_UNSIGNED_BYTE, /* dst type */
-                                      stencil, /* dst addr */
-                                      srcType, src, srcPacking,
-                                      ctx->_ImageTransferState);
-            /* merge stencil values into depth values */
-            for (i = 0; i < srcWidth; i++)
-               dstRow[i] = stencil[i];
-
-            src += srcRowStride;
-            dstRow += dstRowStride / sizeof(GLubyte);
-         }
-      }
-
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Store an image in any of the formats:
- *   _mesa_texformat_rgba_float32
- *   _mesa_texformat_rgb_float32
- *   _mesa_texformat_alpha_float32
- *   _mesa_texformat_luminance_float32
- *   _mesa_texformat_luminance_alpha_float32
- *   _mesa_texformat_intensity_float32
- */
-static GLboolean
-_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||
-          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||
-          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||
-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||
-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||
-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLfloat));
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_FLOAT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *srcRow = tempImage;
-      GLint bytesPerRow;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      bytesPerRow = srcWidth * components * sizeof(GLfloat);
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            memcpy(dstRow, srcRow, bytesPerRow);
-            dstRow += dstRowStride;
-            srcRow += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-
-/**
- * As above, but store 16-bit floats.
- */
-static GLboolean
-_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||
-          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||
-          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||
-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||
-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||
-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLhalfARB));
-
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_HALF_FLOAT_ARB) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking,
-                                                 ctx->_ImageTransferState);
-      const GLfloat *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = _mesa_float_to_half(src[i]);
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, signed int8 */
-static GLboolean
-_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLbyte));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking, 0x0);
-      const GLfloat *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLbyte *dstTexel = (GLbyte *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = (GLbyte) src[i];
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, signed int16 */
-static GLboolean
-_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLshort));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking, 0x0);
-      const GLfloat *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLshort *dstTexel = (GLshort *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = (GLint) src[i];
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, signed int32 */
-static GLboolean
-_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLint));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_INT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
-                                                 baseInternalFormat,
-                                                 baseFormat,
-                                                 srcWidth, srcHeight, srcDepth,
-                                                 srcFormat, srcType, srcAddr,
-                                                 srcPacking, 0x0);
-      const GLfloat *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLint *dstTexel = (GLint *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = (GLint) src[i];
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, unsigned int8 */
-static GLboolean
-_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLubyte));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLuint *tempImage =
-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
-                              srcWidth, srcHeight, srcDepth,
-                              srcFormat, srcType, srcAddr, srcPacking);
-      const GLuint *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLubyte *dstTexel = (GLubyte *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, unsigned int16 */
-static GLboolean
-_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLushort));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLuint *tempImage =
-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
-                              srcWidth, srcHeight, srcDepth,
-                              srcFormat, srcType, srcAddr, srcPacking);
-      const GLuint *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLushort *dstTexel = (GLushort *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-/* non-normalized, unsigned int32 */
-static GLboolean
-_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)
-{
-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
-   const GLint components = _mesa_components_in_format(baseFormat);
-
-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);
-   ASSERT(baseInternalFormat == GL_RGBA ||
-          baseInternalFormat == GL_RGB ||
-          baseInternalFormat == GL_ALPHA ||
-          baseInternalFormat == GL_LUMINANCE ||
-          baseInternalFormat == GL_LUMINANCE_ALPHA ||
-          baseInternalFormat == GL_INTENSITY);
-   ASSERT(texelBytes == components * sizeof(GLuint));
-
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_INT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                     dstRowStride,
-                     dstImageOffsets,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      /* general path */
-      const GLuint *tempImage =
-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
-                              srcWidth, srcHeight, srcDepth,
-                              srcFormat, srcType, srcAddr, srcPacking);
-      const GLuint *src = tempImage;
-      GLint img, row;
-      if (!tempImage)
-         return GL_FALSE;
-      for (img = 0; img < srcDepth; img++) {
-         GLubyte *dstRow = (GLubyte *) dstAddr
-            + dstImageOffsets[dstZoffset + img] * texelBytes
-            + dstYoffset * dstRowStride
-            + dstXoffset * texelBytes;
-         for (row = 0; row < srcHeight; row++) {
-            GLuint *dstTexel = (GLuint *) dstRow;
-            GLint i;
-            for (i = 0; i < srcWidth * components; i++) {
-               dstTexel[i] = src[i];
-            }
-            dstRow += dstRowStride;
-            src += srcWidth * components;
-         }
-      }
-
-      free((void *) tempImage);
-   }
-   return GL_TRUE;
-}
-
-
-
-
-#if FEATURE_EXT_texture_sRGB
-static GLboolean
-_mesa_texstore_srgb8(TEXSTORE_PARAMS)
-{
-   gl_format newDstFormat;
-   GLboolean k;
-
-   ASSERT(dstFormat == MESA_FORMAT_SRGB8);
-
-   /* reuse normal rgb texstore code */
-   newDstFormat = MESA_FORMAT_RGB888;
-
-   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,
-                             newDstFormat, dstAddr,
-                             dstXoffset, dstYoffset, dstZoffset,
-                             dstRowStride, dstImageOffsets,
-                             srcWidth, srcHeight, srcDepth,
-                             srcFormat, srcType,
-                             srcAddr, srcPacking);
-   return k;
-}
-
-
-static GLboolean
-_mesa_texstore_srgba8(TEXSTORE_PARAMS)
-{
-   gl_format newDstFormat;
-   GLboolean k;
-
-   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);
-
-   /* reuse normal rgba texstore code */
-   newDstFormat = MESA_FORMAT_RGBA8888;
-   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,
-                               newDstFormat, dstAddr,
-                               dstXoffset, dstYoffset, dstZoffset,
-                               dstRowStride, dstImageOffsets,
-                               srcWidth, srcHeight, srcDepth,
-                               srcFormat, srcType,
-                               srcAddr, srcPacking);
-   return k;
-}
-
-
-static GLboolean
-_mesa_texstore_sargb8(TEXSTORE_PARAMS)
-{
-   gl_format newDstFormat;
-   GLboolean k;
-
-   ASSERT(dstFormat == MESA_FORMAT_SARGB8);
-
-   /* reuse normal rgba texstore code */
-   newDstFormat = MESA_FORMAT_ARGB8888;
-
-   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,
-                               newDstFormat, dstAddr,
-                               dstXoffset, dstYoffset, dstZoffset,
-                               dstRowStride, dstImageOffsets,
-                               srcWidth, srcHeight, srcDepth,
-                               srcFormat, srcType,
-                               srcAddr, srcPacking);
-   return k;
-}
-
-
-static GLboolean
-_mesa_texstore_sl8(TEXSTORE_PARAMS)
-{
-   gl_format newDstFormat;
-   GLboolean k;
-
-   ASSERT(dstFormat == MESA_FORMAT_SL8);
-
-   newDstFormat = MESA_FORMAT_L8;
-
-   /* _mesa_textore_a8 handles luminance8 too */
-   k = _mesa_texstore_a8(ctx, dims, baseInternalFormat,
-                         newDstFormat, dstAddr,
-                         dstXoffset, dstYoffset, dstZoffset,
-                         dstRowStride, dstImageOffsets,
-                         srcWidth, srcHeight, srcDepth,
-                         srcFormat, srcType,
-                         srcAddr, srcPacking);
-   return k;
-}
-
-
-static GLboolean
-_mesa_texstore_sla8(TEXSTORE_PARAMS)
-{
-   gl_format newDstFormat;
-   GLboolean k;
-
-   ASSERT(dstFormat == MESA_FORMAT_SLA8);
-
-   /* reuse normal luminance/alpha texstore code */
-   newDstFormat = MESA_FORMAT_AL88;
-
-   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,
-			      newDstFormat, dstAddr,
-			      dstXoffset, dstYoffset, dstZoffset,
-			      dstRowStride, dstImageOffsets,
-			      srcWidth, srcHeight, srcDepth,
-			      srcFormat, srcType,
-			      srcAddr, srcPacking);
-   return k;
-}
-
-#else
-
-/* these are used only in texstore_funcs[] below */
-#define _mesa_texstore_srgb8 NULL
-#define _mesa_texstore_srgba8 NULL
-#define _mesa_texstore_sargb8 NULL
-#define _mesa_texstore_sl8 NULL
-#define _mesa_texstore_sla8 NULL
-
-#endif /* FEATURE_EXT_texture_sRGB */
-
-
-
-
-/**
- * Table mapping MESA_FORMAT_* to _mesa_texstore_*()
- * XXX this is somewhat temporary.
- */
-static const struct {
-   gl_format Name;
-   StoreTexImageFunc Store;
-}
-texstore_funcs[MESA_FORMAT_COUNT] =
-{
-   { MESA_FORMAT_NONE, NULL },
-   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },
-   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },
-   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },
-   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },
-   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },
-   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },
-   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },
-   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },
-   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },
-   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },
-   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },
-   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },
-   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },
-   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },
-   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },
-   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },
-   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },
-   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },
-   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },
-   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },
-   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },
-   { MESA_FORMAT_A8, _mesa_texstore_a8 },
-   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },
-   { MESA_FORMAT_L8, _mesa_texstore_a8 },
-   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },
-   { MESA_FORMAT_I8, _mesa_texstore_a8 },
-   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },
-   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },
-   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },
-   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },
-   { MESA_FORMAT_R8, _mesa_texstore_a8 },
-   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },
-   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },
-   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },
-   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },
-   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },
-   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },
-   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },
-   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },
-   { MESA_FORMAT_Z16, _mesa_texstore_z16 },
-   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },
-   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },
-   { MESA_FORMAT_Z32, _mesa_texstore_z32 },
-   { MESA_FORMAT_S8, _mesa_texstore_s8 },
-   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },
-   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },
-   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },
-   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },
-   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },
-   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },
-   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },
-   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },
-   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },
-   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },
-   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },
-   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },
-   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },
-   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },
-   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },
-   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },
-   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },
-   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
-   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },
-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
-   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },
-   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },
-
-   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },
-   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },
-   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },
-   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },
-   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },
-   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },
-
-   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },
-
-   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_signed_r8 },
-   { MESA_FORMAT_SIGNED_RG88, _mesa_texstore_signed_rg88 },
-   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },
-
-   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },
-   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },
-
-   { MESA_FORMAT_SIGNED_R_16, _mesa_texstore_signed_rgba_16 },
-   { MESA_FORMAT_SIGNED_RG_16, _mesa_texstore_signed_rgba_16 },
-   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },
-   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },
-   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },
-
-   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },
-   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },
-   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },
-   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },
-
-   /* Re-use the R/RG texstore functions.
-    * The code is generic enough to handle LATC too. */
-   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },
-   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },
-   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },
-   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 }
-};
-
-
-static GLboolean
-_mesa_texstore_null(TEXSTORE_PARAMS)
-{
-   (void) ctx; (void) dims;
-   (void) baseInternalFormat;
-   (void) dstFormat;
-   (void) dstAddr;
-   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;
-   (void) dstRowStride; (void) dstImageOffsets;
-   (void) srcWidth; (void) srcHeight; (void) srcDepth;
-   (void) srcFormat; (void) srcType;
-   (void) srcAddr;
-   (void) srcPacking;
-
-   /* should never happen */
-   _mesa_problem(NULL, "_mesa_texstore_null() is called");
-   return GL_FALSE;
-}
-
-
-/**
- * Return the StoreTexImageFunc pointer to store an image in the given format.
- */
-static StoreTexImageFunc
-_mesa_get_texstore_func(gl_format format)
-{
-#ifdef DEBUG
-   GLuint i;
-   for (i = 0; i < MESA_FORMAT_COUNT; i++) {
-      ASSERT(texstore_funcs[i].Name == i);
-   }
-#endif
-   ASSERT(texstore_funcs[format].Name == format);
-
-   if (texstore_funcs[format].Store)
-      return texstore_funcs[format].Store;
-   else
-      return _mesa_texstore_null;
-}
-
-
-/**
- * Store user data into texture memory.
- * Called via glTex[Sub]Image1/2/3D()
- */
-GLboolean
-_mesa_texstore(TEXSTORE_PARAMS)
-{
-   StoreTexImageFunc storeImage;
-   GLboolean success;
-
-   storeImage = _mesa_get_texstore_func(dstFormat);
-
-   success = storeImage(ctx, dims, baseInternalFormat,
-                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
-                        dstRowStride, dstImageOffsets,
-                        srcWidth, srcHeight, srcDepth,
-                        srcFormat, srcType, srcAddr, srcPacking);
-   return success;
-}
-
-
-/** Return texture size in bytes */
-static GLuint
-texture_size(const struct gl_texture_image *texImage)
-{
-   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,
-                                       texImage->Height, texImage->Depth);
-   return sz;
-}
-
-
-/** Return row stride in bytes */
-static GLuint
-texture_row_stride(const struct gl_texture_image *texImage)
-{
-   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,
-                                           texImage->Width);
-   return stride;
-}
-
-
-
-/**
- * This is the software fallback for Driver.TexImage1D()
- * and Driver.CopyTexImage1D().
- * \sa _mesa_store_teximage2d()
- */
-void
-_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint border,
-                       GLenum format, GLenum type, const GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage)
-{
-   GLuint sizeInBytes;
-   (void) border;
-
-   /* allocate memory */
-   sizeInBytes = texture_size(texImage);
-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
-   if (!texImage->Data) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
-      return;
-   }
-
-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
-                                        pixels, packing, "glTexImage1D");
-   if (!pixels) {
-      /* Note: we check for a NULL image pointer here, _after_ we allocated
-       * memory for the texture.  That's what the GL spec calls for.
-       */
-      return;
-   }
-   else {
-      const GLint dstRowStride = 0;
-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         0, 0, 0,  /* dstX/Y/Zoffset */
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, 1, 1,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-/**
- * This is the software fallback for Driver.TexImage2D()
- * and Driver.CopyTexImage2D().
- *
- * This function is oriented toward storing images in main memory, rather
- * than VRAM.  Device driver's can easily plug in their own replacement.
- */
-void
-_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint height, GLint border,
-                       GLenum format, GLenum type, const void *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage)
-{
-   GLuint sizeInBytes;
-   (void) border;
-
-   /* allocate memory */
-   sizeInBytes = texture_size(texImage);
-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
-   if (!texImage->Data) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
-      return;
-   }
-
-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
-                                        pixels, packing, "glTexImage2D");
-   if (!pixels) {
-      /* Note: we check for a NULL image pointer here, _after_ we allocated
-       * memory for the texture.  That's what the GL spec calls for.
-       */
-      return;
-   }
-   else {
-      GLint dstRowStride = texture_row_stride(texImage);
-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         0, 0, 0,  /* dstX/Y/Zoffset */
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, height, 1,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-
-/**
- * This is the software fallback for Driver.TexImage3D()
- * and Driver.CopyTexImage3D().
- * \sa _mesa_store_teximage2d()
- */
-void
-_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint height, GLint depth, GLint border,
-                       GLenum format, GLenum type, const void *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage)
-{
-   GLuint sizeInBytes;
-   (void) border;
-
-   /* allocate memory */
-   sizeInBytes = texture_size(texImage);
-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
-   if (!texImage->Data) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
-      return;
-   }
-
-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
-                                        type, pixels, packing, "glTexImage3D");
-   if (!pixels) {
-      /* Note: we check for a NULL image pointer here, _after_ we allocated
-       * memory for the texture.  That's what the GL spec calls for.
-       */
-      return;
-   }
-   else {
-      GLint dstRowStride = texture_row_stride(texImage);
-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         0, 0, 0,  /* dstX/Y/Zoffset */
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, height, depth,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-
-
-/*
- * This is the software fallback for Driver.TexSubImage1D()
- * and Driver.CopyTexSubImage1D().
- */
-void
-_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint width,
-                          GLenum format, GLenum type, const void *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage)
-{
-   /* get pointer to src pixels (may be in a pbo which we'll map here) */
-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
-                                        pixels, packing, "glTexSubImage1D");
-   if (!pixels)
-      return;
-
-   {
-      const GLint dstRowStride = 0;
-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         xoffset, 0, 0,  /* offsets */
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, 1, 1,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-
-/**
- * This is the software fallback for Driver.TexSubImage2D()
- * and Driver.CopyTexSubImage2D().
- */
-void
-_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint yoffset,
-                          GLint width, GLint height,
-                          GLenum format, GLenum type, const void *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage)
-{
-   /* get pointer to src pixels (may be in a pbo which we'll map here) */
-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
-                                        pixels, packing, "glTexSubImage2D");
-   if (!pixels)
-      return;
-
-   {
-      GLint dstRowStride = texture_row_stride(texImage);
-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         xoffset, yoffset, 0,
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, height, 1,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-/*
- * This is the software fallback for Driver.TexSubImage3D().
- * and Driver.CopyTexSubImage3D().
- */
-void
-_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint yoffset, GLint zoffset,
-                          GLint width, GLint height, GLint depth,
-                          GLenum format, GLenum type, const void *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage)
-{
-   /* get pointer to src pixels (may be in a pbo which we'll map here) */
-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
-                                        type, pixels, packing,
-                                        "glTexSubImage3D");
-   if (!pixels)
-      return;
-
-   {
-      GLint dstRowStride = texture_row_stride(texImage);
-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
-                                         texImage->TexFormat,
-                                         texImage->Data,
-                                         xoffset, yoffset, zoffset,
-                                         dstRowStride,
-                                         texImage->ImageOffsets,
-                                         width, height, depth,
-                                         format, type, pixels, packing);
-      if (!success) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");
-      }
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, packing);
-}
-
-
-/*
- * Fallback for Driver.CompressedTexImage1D()
- */
-void
-_mesa_store_compressed_teximage1d(struct gl_context *ctx,
-                                  GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage)
-{
-   /* this space intentionally left blank */
-   (void) ctx;
-   (void) target; (void) level;
-   (void) internalFormat;
-   (void) width; (void) border;
-   (void) imageSize; (void) data;
-   (void) texObj;
-   (void) texImage;
-}
-
-
-
-/**
- * Fallback for Driver.CompressedTexImage2D()
- */
-void
-_mesa_store_compressed_teximage2d(struct gl_context *ctx,
-                                  GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint height, GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage)
-{
-   (void) width; (void) height; (void) border;
-
-   /* This is pretty simple, basically just do a memcpy without worrying
-    * about the usual image unpacking or image transfer operations.
-    */
-   ASSERT(texObj);
-   ASSERT(texImage);
-   ASSERT(texImage->Width > 0);
-   ASSERT(texImage->Height > 0);
-   ASSERT(texImage->Depth == 1);
-   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */
-
-   /* allocate storage */
-   texImage->Data = _mesa_alloc_texmemory(imageSize);
-   if (!texImage->Data) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
-      return;
-   }
-
-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
-                                                 &ctx->Unpack,
-                                                 "glCompressedTexImage2D");
-   if (!data)
-      return;
-
-   /* copy the data */
-   memcpy(texImage->Data, data, imageSize);
-
-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
-}
-
-
-
-/*
- * Fallback for Driver.CompressedTexImage3D()
- */
-void
-_mesa_store_compressed_teximage3d(struct gl_context *ctx,
-                                  GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint height, GLint depth,
-                                  GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage)
-{
-   /* this space intentionally left blank */
-   (void) ctx;
-   (void) target; (void) level;
-   (void) internalFormat;
-   (void) width; (void) height; (void) depth;
-   (void) border;
-   (void) imageSize; (void) data;
-   (void) texObj;
-   (void) texImage;
-}
-
-
-
-/**
- * Fallback for Driver.CompressedTexSubImage1D()
- */
-void
-_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,
-                                     GLint level,
-                                     GLint xoffset, GLsizei width,
-                                     GLenum format,
-                                     GLsizei imageSize, const GLvoid *data,
-                                     struct gl_texture_object *texObj,
-                                     struct gl_texture_image *texImage)
-{
-   /* there are no compressed 1D texture formats yet */
-   (void) ctx;
-   (void) target; (void) level;
-   (void) xoffset; (void) width;
-   (void) format;
-   (void) imageSize; (void) data;
-   (void) texObj;
-   (void) texImage;
-}
-
-
-/**
- * Fallback for Driver.CompressedTexSubImage2D()
- */
-void
-_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,
-                                     GLint level,
-                                     GLint xoffset, GLint yoffset,
-                                     GLsizei width, GLsizei height,
-                                     GLenum format,
-                                     GLsizei imageSize, const GLvoid *data,
-                                     struct gl_texture_object *texObj,
-                                     struct gl_texture_image *texImage)
-{
-   GLint bytesPerRow, destRowStride, srcRowStride;
-   GLint i, rows;
-   GLubyte *dest;
-   const GLubyte *src;
-   const gl_format texFormat = texImage->TexFormat;
-   const GLint destWidth = texImage->Width;
-   GLuint bw, bh;
-
-   _mesa_get_format_block_size(texFormat, &bw, &bh);
-
-   (void) level;
-   (void) format;
-
-   /* these should have been caught sooner */
-   ASSERT((width % bw) == 0 || width == 2 || width == 1);
-   ASSERT((height % bh) == 0 || height == 2 || height == 1);
-   ASSERT((xoffset % bw) == 0);
-   ASSERT((yoffset % bh) == 0);
-
-   /* get pointer to src pixels (may be in a pbo which we'll map here) */
-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
-                                                 &ctx->Unpack,
-                                                 "glCompressedTexSubImage2D");
-   if (!data)
-      return;
-
-   srcRowStride = _mesa_format_row_stride(texFormat, width);
-   src = (const GLubyte *) data;
-
-   destRowStride = _mesa_format_row_stride(texFormat, destWidth);
-   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,
-                                         texFormat, destWidth,
-                                         (GLubyte *) texImage->Data);
-
-   bytesPerRow = srcRowStride;  /* bytes per row of blocks */
-   rows = height / bh;  /* rows in blocks */
-
-   /* copy rows of blocks */
-   for (i = 0; i < rows; i++) {
-      memcpy(dest, src, bytesPerRow);
-      dest += destRowStride;
-      src += srcRowStride;
-   }
-
-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
-}
-
-
-/**
- * Fallback for Driver.CompressedTexSubImage3D()
- */
-void
-_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,
-                                GLint level,
-                                GLint xoffset, GLint yoffset, GLint zoffset,
-                                GLsizei width, GLsizei height, GLsizei depth,
-                                GLenum format,
-                                GLsizei imageSize, const GLvoid *data,
-                                struct gl_texture_object *texObj,
-                                struct gl_texture_image *texImage)
-{
-   /* there are no compressed 3D texture formats yet */
-   (void) ctx;
-   (void) target; (void) level;
-   (void) xoffset; (void) yoffset; (void) zoffset;
-   (void) width; (void) height; (void) depth;
-   (void) format;
-   (void) imageSize; (void) data;
-   (void) texObj;
-   (void) texImage;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008-2009  VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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:

+ *   Brian Paul

+ */

+

+/**

+ * The GL texture image functions in teximage.c basically just do

+ * error checking and data structure allocation.  They in turn call

+ * device driver functions which actually copy/convert/store the user's

+ * texture image data.

+ *

+ * However, most device drivers will be able to use the fallback functions

+ * in this file.  That is, most drivers will have the following bit of

+ * code:

+ *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;

+ *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;

+ *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;

+ *   etc...

+ *

+ * Texture image processing is actually kind of complicated.  We have to do:

+ *    Format/type conversions

+ *    pixel unpacking

+ *    pixel transfer (scale, bais, lookup, etc)

+ *

+ * These functions can handle most everything, including processing full

+ * images and sub-images.

+ */

+

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "colormac.h"

+#include "image.h"

+#include "macros.h"

+#include "mipmap.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "pack.h"

+#include "pbo.h"

+#include "imports.h"

+#include "pack.h"

+#include "texcompress.h"

+#include "texcompress_fxt1.h"

+#include "texcompress_rgtc.h"

+#include "texcompress_s3tc.h"

+#include "teximage.h"

+#include "texstore.h"

+#include "enums.h"

+

+

+enum {

+   ZERO = 4, 

+   ONE = 5

+};

+

+

+/**

+ * Texture image storage function.

+ */

+typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);

+

+

+/**

+ * Return GL_TRUE if the given image format is one that be converted

+ * to another format by swizzling.

+ */

+static GLboolean

+can_swizzle(GLenum logicalBaseFormat)

+{

+   switch (logicalBaseFormat) {

+   case GL_RGBA:

+   case GL_RGB:

+   case GL_LUMINANCE_ALPHA:

+   case GL_INTENSITY:

+   case GL_ALPHA:

+   case GL_LUMINANCE:

+   case GL_RED:

+   case GL_GREEN:

+   case GL_BLUE:

+   case GL_BGR:

+   case GL_BGRA:

+   case GL_ABGR_EXT:

+   case GL_RG:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+

+enum {

+   IDX_LUMINANCE = 0,

+   IDX_ALPHA,

+   IDX_INTENSITY,

+   IDX_LUMINANCE_ALPHA,

+   IDX_RGB,

+   IDX_RGBA,

+   IDX_RED,

+   IDX_GREEN,

+   IDX_BLUE,

+   IDX_BGR,

+   IDX_BGRA,

+   IDX_ABGR,

+   IDX_RG,

+   MAX_IDX

+};

+

+#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)

+#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)

+#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)

+#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }

+

+

+static const struct {

+   GLubyte format_idx;

+   GLubyte to_rgba[6];

+   GLubyte from_rgba[6];

+} mappings[MAX_IDX] = 

+{

+   {

+      IDX_LUMINANCE,

+      MAP4(0,0,0,ONE),

+      MAP1(0)

+   },

+

+   {

+      IDX_ALPHA,

+      MAP4(ZERO, ZERO, ZERO, 0),

+      MAP1(3)

+   },

+

+   {

+      IDX_INTENSITY,

+      MAP4(0, 0, 0, 0),

+      MAP1(0),

+   },

+

+   {

+      IDX_LUMINANCE_ALPHA,

+      MAP4(0,0,0,1),

+      MAP2(0,3)

+   },

+

+   {

+      IDX_RGB,

+      MAP4(0,1,2,ONE),

+      MAP3(0,1,2)

+   },

+

+   {

+      IDX_RGBA,

+      MAP4(0,1,2,3),

+      MAP4(0,1,2,3),

+   },

+

+   {

+      IDX_RED,

+      MAP4(0, ZERO, ZERO, ONE),

+      MAP1(0),

+   },

+

+   {

+      IDX_GREEN,

+      MAP4(ZERO, 0, ZERO, ONE),

+      MAP1(1),

+   },

+

+   {

+      IDX_BLUE,

+      MAP4(ZERO, ZERO, 0, ONE),

+      MAP1(2),

+   },

+

+   {

+      IDX_BGR,

+      MAP4(2,1,0,ONE),

+      MAP3(2,1,0)

+   },

+

+   {

+      IDX_BGRA,

+      MAP4(2,1,0,3),

+      MAP4(2,1,0,3)

+   },

+

+   {

+      IDX_ABGR,

+      MAP4(3,2,1,0),

+      MAP4(3,2,1,0)

+   },

+

+   {

+      IDX_RG,

+      MAP4(0, 1, ZERO, ONE),

+      MAP2(0, 1)

+   },

+};

+

+

+

+/**

+ * Convert a GL image format enum to an IDX_* value (see above).

+ */

+static int

+get_map_idx(GLenum value)

+{

+   switch (value) {

+   case GL_LUMINANCE: return IDX_LUMINANCE;

+   case GL_ALPHA: return IDX_ALPHA;

+   case GL_INTENSITY: return IDX_INTENSITY;

+   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;

+   case GL_RGB: return IDX_RGB;

+   case GL_RGBA: return IDX_RGBA;

+   case GL_RED: return IDX_RED;

+   case GL_GREEN: return IDX_GREEN;

+   case GL_BLUE: return IDX_BLUE;

+   case GL_BGR: return IDX_BGR;

+   case GL_BGRA: return IDX_BGRA;

+   case GL_ABGR_EXT: return IDX_ABGR;

+   case GL_RG: return IDX_RG;

+   default:

+      _mesa_problem(NULL, "Unexpected inFormat");

+      return 0;

+   }

+}   

+

+

+/**

+ * When promoting texture formats (see below) we need to compute the

+ * mapping of dest components back to source components.

+ * This function does that.

+ * \param inFormat  the incoming format of the texture

+ * \param outFormat  the final texture format

+ * \return map[6]  a full 6-component map

+ */

+static void

+compute_component_mapping(GLenum inFormat, GLenum outFormat, 

+			  GLubyte *map)

+{

+   const int inFmt = get_map_idx(inFormat);

+   const int outFmt = get_map_idx(outFormat);

+   const GLubyte *in2rgba = mappings[inFmt].to_rgba;

+   const GLubyte *rgba2out = mappings[outFmt].from_rgba;

+   int i;

+   

+   for (i = 0; i < 4; i++)

+      map[i] = in2rgba[rgba2out[i]];

+

+   map[ZERO] = ZERO;

+   map[ONE] = ONE;   

+

+#if 0

+   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",

+	  inFormat, _mesa_lookup_enum_by_nr(inFormat),

+	  outFormat, _mesa_lookup_enum_by_nr(outFormat),

+	  map[0], 

+	  map[1], 

+	  map[2], 

+	  map[3], 

+	  map[4], 

+	  map[5]); 

+#endif

+}

+

+

+/**

+ * Make a temporary (color) texture image with GLfloat components.

+ * Apply all needed pixel unpacking and pixel transfer operations.

+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

+ * Suppose the user specifies GL_LUMINANCE as the internal texture format

+ * but the graphics hardware doesn't support luminance textures.  So, we might

+ * use an RGB hardware format instead.

+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

+ *

+ * \param ctx  the rendering context

+ * \param dims  image dimensions: 1, 2 or 3

+ * \param logicalBaseFormat  basic texture derived from the user's

+ *    internal texture format value

+ * \param textureBaseFormat  the actual basic format of the texture

+ * \param srcWidth  source image width

+ * \param srcHeight  source image height

+ * \param srcDepth  source image depth

+ * \param srcFormat  source image format

+ * \param srcType  source image type

+ * \param srcAddr  source image address

+ * \param srcPacking  source image pixel packing

+ * \return resulting image with format = textureBaseFormat and type = GLfloat.

+ */

+GLfloat *

+_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,

+			    GLenum logicalBaseFormat,

+			    GLenum textureBaseFormat,

+			    GLint srcWidth, GLint srcHeight, GLint srcDepth,

+			    GLenum srcFormat, GLenum srcType,

+			    const GLvoid *srcAddr,

+			    const struct gl_pixelstore_attrib *srcPacking,

+			    GLbitfield transferOps)

+{

+   GLfloat *tempImage;

+   const GLint components = _mesa_components_in_format(logicalBaseFormat);

+   const GLint srcStride =

+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+   GLfloat *dst;

+   GLint img, row;

+

+   ASSERT(dims >= 1 && dims <= 3);

+

+   ASSERT(logicalBaseFormat == GL_RGBA ||

+          logicalBaseFormat == GL_RGB ||

+          logicalBaseFormat == GL_RG ||

+          logicalBaseFormat == GL_RED ||

+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

+          logicalBaseFormat == GL_LUMINANCE ||

+          logicalBaseFormat == GL_ALPHA ||

+          logicalBaseFormat == GL_INTENSITY ||

+          logicalBaseFormat == GL_COLOR_INDEX ||

+          logicalBaseFormat == GL_DEPTH_COMPONENT);

+

+   ASSERT(textureBaseFormat == GL_RGBA ||

+          textureBaseFormat == GL_RGB ||

+          textureBaseFormat == GL_RG ||

+          textureBaseFormat == GL_RED ||

+          textureBaseFormat == GL_LUMINANCE_ALPHA ||

+          textureBaseFormat == GL_LUMINANCE ||

+          textureBaseFormat == GL_ALPHA ||

+          textureBaseFormat == GL_INTENSITY ||

+          textureBaseFormat == GL_COLOR_INDEX ||

+          textureBaseFormat == GL_DEPTH_COMPONENT);

+

+   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

+				  * components * sizeof(GLfloat));

+   if (!tempImage)

+      return NULL;

+

+   dst = tempImage;

+   for (img = 0; img < srcDepth; img++) {

+      const GLubyte *src

+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

+						 srcWidth, srcHeight,

+						 srcFormat, srcType,

+						 img, 0, 0);

+      for (row = 0; row < srcHeight; row++) {

+	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,

+				       dst, srcFormat, srcType, src,

+				       srcPacking, transferOps);

+	 dst += srcWidth * components;

+	 src += srcStride;

+      }

+   }

+

+   if (logicalBaseFormat != textureBaseFormat) {

+      /* more work */

+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

+      GLfloat *newImage;

+      GLint i, n;

+      GLubyte map[6];

+

+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

+             textureBaseFormat == GL_LUMINANCE_ALPHA);

+

+      /* The actual texture format should have at least as many components

+       * as the logical texture format.

+       */

+      ASSERT(texComponents >= logComponents);

+

+      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

+                                          * texComponents * sizeof(GLfloat));

+      if (!newImage) {

+         free(tempImage);

+         return NULL;

+      }

+

+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

+

+      n = srcWidth * srcHeight * srcDepth;

+      for (i = 0; i < n; i++) {

+         GLint k;

+         for (k = 0; k < texComponents; k++) {

+            GLint j = map[k];

+            if (j == ZERO)

+               newImage[i * texComponents + k] = 0.0F;

+            else if (j == ONE)

+               newImage[i * texComponents + k] = 1.0F;

+            else

+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

+         }

+      }

+

+      free(tempImage);

+      tempImage = newImage;

+   }

+

+   return tempImage;

+}

+

+

+/**

+ * Make temporary image with uint pixel values.  Used for unsigned

+ * integer-valued textures.

+ */

+static GLuint *

+make_temp_uint_image(struct gl_context *ctx, GLuint dims,

+                     GLenum logicalBaseFormat,

+                     GLenum textureBaseFormat,

+                     GLint srcWidth, GLint srcHeight, GLint srcDepth,

+                     GLenum srcFormat, GLenum srcType,

+                     const GLvoid *srcAddr,

+                     const struct gl_pixelstore_attrib *srcPacking)

+{

+   GLuint *tempImage;

+   const GLint components = _mesa_components_in_format(logicalBaseFormat);

+   const GLint srcStride =

+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+   GLuint *dst;

+   GLint img, row;

+

+   ASSERT(dims >= 1 && dims <= 3);

+

+   ASSERT(logicalBaseFormat == GL_RGBA ||

+          logicalBaseFormat == GL_RGB ||

+          logicalBaseFormat == GL_RG ||

+          logicalBaseFormat == GL_RED ||

+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

+          logicalBaseFormat == GL_LUMINANCE ||

+          logicalBaseFormat == GL_INTENSITY ||

+          logicalBaseFormat == GL_ALPHA);

+

+   ASSERT(textureBaseFormat == GL_RGBA ||

+          textureBaseFormat == GL_RGB ||

+          textureBaseFormat == GL_RG ||

+          textureBaseFormat == GL_RED ||

+          textureBaseFormat == GL_LUMINANCE_ALPHA ||

+          textureBaseFormat == GL_LUMINANCE ||

+          textureBaseFormat == GL_ALPHA);

+

+   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

+                                 * components * sizeof(GLuint));

+   if (!tempImage)

+      return NULL;

+

+   dst = tempImage;

+   for (img = 0; img < srcDepth; img++) {

+      const GLubyte *src

+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

+						 srcWidth, srcHeight,

+						 srcFormat, srcType,

+						 img, 0, 0);

+      for (row = 0; row < srcHeight; row++) {

+	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,

+                                      dst, srcFormat, srcType, src,

+                                      srcPacking);

+	 dst += srcWidth * components;

+	 src += srcStride;

+      }

+   }

+

+   if (logicalBaseFormat != textureBaseFormat) {

+      /* more work */

+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

+      GLuint *newImage;

+      GLint i, n;

+      GLubyte map[6];

+

+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

+             textureBaseFormat == GL_LUMINANCE_ALPHA);

+

+      /* The actual texture format should have at least as many components

+       * as the logical texture format.

+       */

+      ASSERT(texComponents >= logComponents);

+

+      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

+                                   * texComponents * sizeof(GLuint));

+      if (!newImage) {

+         free(tempImage);

+         return NULL;

+      }

+

+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

+

+      n = srcWidth * srcHeight * srcDepth;

+      for (i = 0; i < n; i++) {

+         GLint k;

+         for (k = 0; k < texComponents; k++) {

+            GLint j = map[k];

+            if (j == ZERO)

+               newImage[i * texComponents + k] = 0.0F;

+            else if (j == ONE)

+               newImage[i * texComponents + k] = 1.0F;

+            else

+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

+         }

+      }

+

+      free(tempImage);

+      tempImage = newImage;

+   }

+

+   return tempImage;

+}

+

+

+

+/**

+ * Make a temporary (color) texture image with GLchan components.

+ * Apply all needed pixel unpacking and pixel transfer operations.

+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

+ * Suppose the user specifies GL_LUMINANCE as the internal texture format

+ * but the graphics hardware doesn't support luminance textures.  So, we might

+ * use an RGB hardware format instead.

+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

+ *

+ * \param ctx  the rendering context

+ * \param dims  image dimensions: 1, 2 or 3

+ * \param logicalBaseFormat  basic texture derived from the user's

+ *    internal texture format value

+ * \param textureBaseFormat  the actual basic format of the texture

+ * \param srcWidth  source image width

+ * \param srcHeight  source image height

+ * \param srcDepth  source image depth

+ * \param srcFormat  source image format

+ * \param srcType  source image type

+ * \param srcAddr  source image address

+ * \param srcPacking  source image pixel packing

+ * \return resulting image with format = textureBaseFormat and type = GLchan.

+ */

+GLchan *

+_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,

+                           GLenum logicalBaseFormat,

+                           GLenum textureBaseFormat,

+                           GLint srcWidth, GLint srcHeight, GLint srcDepth,

+                           GLenum srcFormat, GLenum srcType,

+                           const GLvoid *srcAddr,

+                           const struct gl_pixelstore_attrib *srcPacking)

+{

+   GLuint transferOps = ctx->_ImageTransferState;

+   const GLint components = _mesa_components_in_format(logicalBaseFormat);

+   GLint img, row;

+   GLchan *tempImage, *dst;

+

+   ASSERT(dims >= 1 && dims <= 3);

+

+   ASSERT(logicalBaseFormat == GL_RGBA ||

+          logicalBaseFormat == GL_RGB ||

+          logicalBaseFormat == GL_RG ||

+          logicalBaseFormat == GL_RED ||

+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

+          logicalBaseFormat == GL_LUMINANCE ||

+          logicalBaseFormat == GL_ALPHA ||

+          logicalBaseFormat == GL_INTENSITY);

+

+   ASSERT(textureBaseFormat == GL_RGBA ||

+          textureBaseFormat == GL_RGB ||

+          textureBaseFormat == GL_RG ||

+          textureBaseFormat == GL_RED ||

+          textureBaseFormat == GL_LUMINANCE_ALPHA ||

+          textureBaseFormat == GL_LUMINANCE ||

+          textureBaseFormat == GL_ALPHA ||

+          textureBaseFormat == GL_INTENSITY);

+

+   /* unpack and transfer the source image */

+   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

+                                       * components * sizeof(GLchan));

+   if (!tempImage) {

+      return NULL;

+   }

+

+   dst = tempImage;

+   for (img = 0; img < srcDepth; img++) {

+      const GLint srcStride =

+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+      const GLubyte *src =

+         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

+                                               srcWidth, srcHeight,

+                                               srcFormat, srcType,

+                                               img, 0, 0);

+      for (row = 0; row < srcHeight; row++) {

+         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,

+                                      srcFormat, srcType, src, srcPacking,

+                                      transferOps);

+         dst += srcWidth * components;

+         src += srcStride;

+      }

+   }

+

+   if (logicalBaseFormat != textureBaseFormat) {

+      /* one more conversion step */

+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

+      GLchan *newImage;

+      GLint i, n;

+      GLubyte map[6];

+

+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

+             textureBaseFormat == GL_LUMINANCE_ALPHA);

+

+      /* The actual texture format should have at least as many components

+       * as the logical texture format.

+       */

+      ASSERT(texComponents >= logComponents);

+

+      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

+                                         * texComponents * sizeof(GLchan));

+      if (!newImage) {

+         free(tempImage);

+         return NULL;

+      }

+

+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

+

+      n = srcWidth * srcHeight * srcDepth;

+      for (i = 0; i < n; i++) {

+         GLint k;

+         for (k = 0; k < texComponents; k++) {

+            GLint j = map[k];

+            if (j == ZERO)

+               newImage[i * texComponents + k] = 0;

+            else if (j == ONE)

+               newImage[i * texComponents + k] = CHAN_MAX;

+            else

+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

+         }

+      }

+

+      free(tempImage);

+      tempImage = newImage;

+   }

+

+   return tempImage;

+}

+

+

+/**

+ * Copy GLubyte pixels from <src> to <dst> with swizzling.

+ * \param dst  destination pixels

+ * \param dstComponents  number of color components in destination pixels

+ * \param src  source pixels

+ * \param srcComponents  number of color components in source pixels

+ * \param map  the swizzle mapping.  map[X] says where to find the X component

+ *             in the source image's pixels.  For example, if the source image

+ *             is GL_BGRA and X = red, map[0] yields 2.

+ * \param count  number of pixels to copy/swizzle.

+ */

+static void

+swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 

+             GLuint srcComponents, const GLubyte *map, GLuint count)

+{

+#define SWZ_CPY(dst, src, count, dstComps, srcComps) \

+   do {                                              \

+      GLuint i;                                      \

+      for (i = 0; i < count; i++) {                  \

+         GLuint j;                                   \

+         if (srcComps == 4) {                        \

+            COPY_4UBV(tmp, src);                     \

+         }                                           \

+         else {                                      \

+            for (j = 0; j < srcComps; j++) {         \

+               tmp[j] = src[j];                      \

+            }                                        \

+         }                                           \

+         src += srcComps;                            \

+         for (j = 0; j < dstComps; j++) {            \

+            dst[j] = tmp[map[j]];                    \

+         }                                           \

+         dst += dstComps;                            \

+      }                                              \

+   } while (0)

+

+   GLubyte tmp[6];

+

+   tmp[ZERO] = 0x0;

+   tmp[ONE] = 0xff;

+

+   ASSERT(srcComponents <= 4);

+   ASSERT(dstComponents <= 4);

+

+   switch (dstComponents) {

+   case 4:

+      switch (srcComponents) {

+      case 4:

+         SWZ_CPY(dst, src, count, 4, 4);

+         break;

+      case 3:

+         SWZ_CPY(dst, src, count, 4, 3);

+         break;

+      case 2:

+         SWZ_CPY(dst, src, count, 4, 2);

+         break;

+      case 1:

+         SWZ_CPY(dst, src, count, 4, 1);

+         break;

+      default:

+         ;

+      }

+      break;

+   case 3:

+      switch (srcComponents) {

+      case 4:

+         SWZ_CPY(dst, src, count, 3, 4);

+         break;

+      case 3:

+         SWZ_CPY(dst, src, count, 3, 3);

+         break;

+      case 2:

+         SWZ_CPY(dst, src, count, 3, 2);

+         break;

+      case 1:

+         SWZ_CPY(dst, src, count, 3, 1);

+         break;

+      default:

+         ;

+      }

+      break;

+   case 2:

+      switch (srcComponents) {

+      case 4:

+         SWZ_CPY(dst, src, count, 2, 4);

+         break;

+      case 3:

+         SWZ_CPY(dst, src, count, 2, 3);

+         break;

+      case 2:

+         SWZ_CPY(dst, src, count, 2, 2);

+         break;

+      case 1:

+         SWZ_CPY(dst, src, count, 2, 1);

+         break;

+      default:

+         ;

+      }

+      break;

+   case 1:

+      switch (srcComponents) {

+      case 4:

+         SWZ_CPY(dst, src, count, 1, 4);

+         break;

+      case 3:

+         SWZ_CPY(dst, src, count, 1, 3);

+         break;

+      case 2:

+         SWZ_CPY(dst, src, count, 1, 2);

+         break;

+      case 1:

+         SWZ_CPY(dst, src, count, 1, 1);

+         break;

+      default:

+         ;

+      }

+      break;

+   default:

+      ;

+   }

+#undef SWZ_CPY

+}

+

+

+

+static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };

+static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };

+

+

+/**

+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

+ * mapping array depending on endianness.

+ */

+static const GLubyte *

+type_mapping( GLenum srcType )

+{

+   switch (srcType) {

+   case GL_BYTE:

+   case GL_UNSIGNED_BYTE:

+      return map_identity;

+   case GL_UNSIGNED_INT_8_8_8_8:

+      return _mesa_little_endian() ? map_3210 : map_identity;

+   case GL_UNSIGNED_INT_8_8_8_8_REV:

+      return _mesa_little_endian() ? map_identity : map_3210;

+   default:

+      return NULL;

+   }

+}

+

+

+/**

+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

+ * mapping array depending on pixelstore byte swapping state.

+ */

+static const GLubyte *

+byteswap_mapping( GLboolean swapBytes,

+		  GLenum srcType )

+{

+   if (!swapBytes) 

+      return map_identity;

+

+   switch (srcType) {

+   case GL_BYTE:

+   case GL_UNSIGNED_BYTE:

+      return map_identity;

+   case GL_UNSIGNED_INT_8_8_8_8:

+   case GL_UNSIGNED_INT_8_8_8_8_REV:

+      return map_3210;

+   default:

+      return NULL;

+   }

+}

+

+

+

+/**

+ * Transfer a GLubyte texture image with component swizzling.

+ */

+static void

+_mesa_swizzle_ubyte_image(struct gl_context *ctx, 

+			  GLuint dimensions,

+			  GLenum srcFormat,

+			  GLenum srcType,

+

+			  GLenum baseInternalFormat,

+

+			  const GLubyte *rgba2dst,

+			  GLuint dstComponents,

+

+			  GLvoid *dstAddr,

+			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

+			  GLint dstRowStride,

+                          const GLuint *dstImageOffsets,

+

+			  GLint srcWidth, GLint srcHeight, GLint srcDepth,

+			  const GLvoid *srcAddr,

+			  const struct gl_pixelstore_attrib *srcPacking )

+{

+   GLint srcComponents = _mesa_components_in_format(srcFormat);

+   const GLubyte *srctype2ubyte, *swap;

+   GLubyte map[4], src2base[6], base2rgba[6];

+   GLint i;

+   const GLint srcRowStride =

+      _mesa_image_row_stride(srcPacking, srcWidth,

+                             srcFormat, GL_UNSIGNED_BYTE);

+   const GLint srcImageStride

+      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,

+                                 GL_UNSIGNED_BYTE);

+   const GLubyte *srcImage

+      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,

+                                              srcWidth, srcHeight, srcFormat,

+                                              GL_UNSIGNED_BYTE, 0, 0, 0);

+

+   (void) ctx;

+

+   /* Translate from src->baseInternal->GL_RGBA->dst.  This will

+    * correctly deal with RGBA->RGB->RGBA conversions where the final

+    * A value must be 0xff regardless of the incoming alpha values.

+    */

+   compute_component_mapping(srcFormat, baseInternalFormat, src2base);

+   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);

+   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);

+   srctype2ubyte = type_mapping(srcType);

+

+

+   for (i = 0; i < 4; i++)

+      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];

+

+/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */

+

+   if (srcComponents == dstComponents &&

+       srcRowStride == dstRowStride &&

+       srcRowStride == srcWidth * srcComponents &&

+       dimensions < 3) {

+      /* 1 and 2D images only */

+      GLubyte *dstImage = (GLubyte *) dstAddr

+         + dstYoffset * dstRowStride

+         + dstXoffset * dstComponents;

+      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 

+		   srcWidth * srcHeight);

+   }

+   else {

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         const GLubyte *srcRow = srcImage;

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * dstComponents

+            + dstYoffset * dstRowStride

+            + dstXoffset * dstComponents;

+         for (row = 0; row < srcHeight; row++) {

+	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+         srcImage += srcImageStride;

+      }

+   }

+}

+

+

+/**

+ * Teximage storage routine for when a simple memcpy will do.

+ * No pixel transfer operations or special texel encodings allowed.

+ * 1D, 2D and 3D images supported.

+ */

+static void

+memcpy_texture(struct gl_context *ctx,

+	       GLuint dimensions,

+               gl_format dstFormat,

+               GLvoid *dstAddr,

+               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

+               GLint dstRowStride,

+               const GLuint *dstImageOffsets,

+               GLint srcWidth, GLint srcHeight, GLint srcDepth,

+               GLenum srcFormat, GLenum srcType,

+               const GLvoid *srcAddr,

+               const struct gl_pixelstore_attrib *srcPacking)

+{

+   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,

+                                                     srcFormat, srcType);

+   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,

+                                      srcWidth, srcHeight, srcFormat, srcType);

+   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,

+        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLint bytesPerRow = srcWidth * texelBytes;

+

+#if 0

+   /* XXX update/re-enable for dstImageOffsets array */

+   const GLint bytesPerImage = srcHeight * bytesPerRow;

+   const GLint bytesPerTexture = srcDepth * bytesPerImage;

+   GLubyte *dstImage = (GLubyte *) dstAddr

+                     + dstZoffset * dstImageStride

+                     + dstYoffset * dstRowStride

+                     + dstXoffset * texelBytes;

+

+   if (dstRowStride == srcRowStride &&

+       dstRowStride == bytesPerRow &&

+       ((dstImageStride == srcImageStride &&

+         dstImageStride == bytesPerImage) ||

+        (srcDepth == 1))) {

+      /* one big memcpy */

+      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);

+   }

+   else

+   {

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         const GLubyte *srcRow = srcImage;

+         GLubyte *dstRow = dstImage;

+         for (row = 0; row < srcHeight; row++) {

+            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+         srcImage += srcImageStride;

+         dstImage += dstImageStride;

+      }

+   }

+#endif

+

+   GLint img, row;

+   for (img = 0; img < srcDepth; img++) {

+      const GLubyte *srcRow = srcImage;

+      GLubyte *dstRow = (GLubyte *) dstAddr

+         + dstImageOffsets[dstZoffset + img] * texelBytes

+         + dstYoffset * dstRowStride

+         + dstXoffset * texelBytes;

+      for (row = 0; row < srcHeight; row++) {

+         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

+         dstRow += dstRowStride;

+         srcRow += srcRowStride;

+      }

+      srcImage += srcImageStride;

+   }

+}

+

+

+

+/**

+ * Store a 32-bit integer depth component texture image.

+ */

+static GLboolean

+_mesa_texstore_z32(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffffffff;

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   (void) dims;

+   ASSERT(dstFormat == MESA_FORMAT_Z32);

+   ASSERT(texelBytes == sizeof(GLuint));

+

+   if (ctx->Pixel.DepthScale == 1.0f &&

+       ctx->Pixel.DepthBias == 0.0f &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_DEPTH_COMPONENT &&

+       srcFormat == GL_DEPTH_COMPONENT &&

+       srcType == GL_UNSIGNED_INT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            const GLvoid *src = _mesa_image_address(dims, srcPacking,

+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

+            _mesa_unpack_depth_span(ctx, srcWidth,

+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

+                                    depthScale, srcType, src, srcPacking);

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a 24-bit integer depth component texture image.

+ */

+static GLboolean

+_mesa_texstore_x8_z24(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffffff;

+   const GLuint texelBytes = 4;

+

+   (void) dims;

+   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);

+

+   {

+      /* general path */

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            const GLvoid *src = _mesa_image_address(dims, srcPacking,

+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

+            _mesa_unpack_depth_span(ctx, srcWidth,

+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

+                                    depthScale, srcType, src, srcPacking);

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a 24-bit integer depth component texture image.

+ */

+static GLboolean

+_mesa_texstore_z24_x8(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffffff;

+   const GLuint texelBytes = 4;

+

+   (void) dims;

+   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);

+

+   {

+      /* general path */

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            const GLvoid *src = _mesa_image_address(dims, srcPacking,

+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

+            GLuint *dst = (GLuint *) dstRow;

+            GLint i;

+            _mesa_unpack_depth_span(ctx, srcWidth,

+                                    GL_UNSIGNED_INT, dst,

+                                    depthScale, srcType, src, srcPacking);

+            for (i = 0; i < srcWidth; i++)

+               dst[i] <<= 8;

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a 16-bit integer depth component texture image.

+ */

+static GLboolean

+_mesa_texstore_z16(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffff;

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   (void) dims;

+   ASSERT(dstFormat == MESA_FORMAT_Z16);

+   ASSERT(texelBytes == sizeof(GLushort));

+

+   if (ctx->Pixel.DepthScale == 1.0f &&

+       ctx->Pixel.DepthBias == 0.0f &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_DEPTH_COMPONENT &&

+       srcFormat == GL_DEPTH_COMPONENT &&

+       srcType == GL_UNSIGNED_SHORT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            const GLvoid *src = _mesa_image_address(dims, srcPacking,

+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

+            GLushort *dst16 = (GLushort *) dstRow;

+            _mesa_unpack_depth_span(ctx, srcWidth,

+                                    GL_UNSIGNED_SHORT, dst16, depthScale,

+                                    srcType, src, srcPacking);

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store an rgb565 or rgb565_rev texture image.

+ */

+static GLboolean

+_mesa_texstore_rgb565(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||

+          dstFormat == MESA_FORMAT_RGB565_REV);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_RGB565 &&

+       baseInternalFormat == GL_RGB &&

+       srcFormat == GL_RGB &&

+       srcType == GL_UNSIGNED_SHORT_5_6_5) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+            !srcPacking->SwapBytes &&

+            baseInternalFormat == GL_RGB &&

+            srcFormat == GL_RGB &&

+            srcType == GL_UNSIGNED_BYTE &&

+            dims == 2) {

+      /* do optimized tex store */

+      const GLint srcRowStride =

+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+      const GLubyte *src = (const GLubyte *)

+         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,

+                             srcFormat, srcType, 0, 0, 0);

+      GLubyte *dst = (GLubyte *) dstAddr

+                   + dstYoffset * dstRowStride

+                   + dstXoffset * texelBytes;

+      GLint row, col;

+      for (row = 0; row < srcHeight; row++) {

+         const GLubyte *srcUB = (const GLubyte *) src;

+         GLushort *dstUS = (GLushort *) dst;

+         /* check for byteswapped format */

+         if (dstFormat == MESA_FORMAT_RGB565) {

+            for (col = 0; col < srcWidth; col++) {

+               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );

+               srcUB += 3;

+            }

+         }

+         else {

+            for (col = 0; col < srcWidth; col++) {

+               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );

+               srcUB += 3;

+            }

+         }

+         dst += dstRowStride;

+         src += srcRowStride;

+      }

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            /* check for byteswapped format */

+            if (dstFormat == MESA_FORMAT_RGB565) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),

+                                               CHAN_TO_UBYTE(src[GCOMP]),

+                                               CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 3;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),

+                                                   CHAN_TO_UBYTE(src[GCOMP]),

+                                                   CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 3;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.

+ */

+static GLboolean

+_mesa_texstore_rgba8888(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||

+          dstFormat == MESA_FORMAT_RGBA8888_REV);

+   ASSERT(texelBytes == 4);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_RGBA8888 &&

+       baseInternalFormat == GL_RGBA &&

+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {

+       /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_RGBA8888_REV &&

+       baseInternalFormat == GL_RGBA &&

+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+	    (srcType == GL_UNSIGNED_BYTE ||

+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||

+	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {

+	 dstmap[3] = 0;

+	 dstmap[2] = 1;

+	 dstmap[1] = 2;

+	 dstmap[0] = 3;

+      }

+      else {

+	 dstmap[3] = 3;

+	 dstmap[2] = 2;

+	 dstmap[1] = 1;

+	 dstmap[0] = 0;

+      }

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 4,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstUI = (GLuint *) dstRow;

+            if (dstFormat == MESA_FORMAT_RGBA8888) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),

+                                                CHAN_TO_UBYTE(src[GCOMP]),

+                                                CHAN_TO_UBYTE(src[BCOMP]),

+                                                CHAN_TO_UBYTE(src[ACOMP]) );

+                  src += 4;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),

+                                                    CHAN_TO_UBYTE(src[GCOMP]),

+                                                    CHAN_TO_UBYTE(src[BCOMP]),

+                                                    CHAN_TO_UBYTE(src[ACOMP]) );

+                  src += 4;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_argb8888(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = GL_RGBA;

+

+   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||

+          dstFormat == MESA_FORMAT_ARGB8888_REV ||

+          dstFormat == MESA_FORMAT_XRGB8888 ||

+          dstFormat == MESA_FORMAT_XRGB8888_REV );

+   ASSERT(texelBytes == 4);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       (dstFormat == MESA_FORMAT_ARGB8888 ||

+        dstFormat == MESA_FORMAT_XRGB8888) &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_BGRA &&

+       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||

+        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {

+      /* simple memcpy path (little endian) */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       (dstFormat == MESA_FORMAT_ARGB8888_REV ||

+        dstFormat == MESA_FORMAT_XRGB8888_REV) &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_BGRA &&

+       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

+        srcType == GL_UNSIGNED_INT_8_8_8_8)) {

+      /* simple memcpy path (big endian) */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+            !srcPacking->SwapBytes &&

+	    (dstFormat == MESA_FORMAT_ARGB8888 ||

+             dstFormat == MESA_FORMAT_XRGB8888) &&

+            srcFormat == GL_RGB &&

+	    (baseInternalFormat == GL_RGBA ||

+	     baseInternalFormat == GL_RGB) &&

+            srcType == GL_UNSIGNED_BYTE) {

+      int img, row, col;

+      for (img = 0; img < srcDepth; img++) {

+         const GLint srcRowStride =

+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *d4 = (GLuint *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               d4[col] = PACK_COLOR_8888(0xff,

+                                         srcRow[col * 3 + RCOMP],

+                                         srcRow[col * 3 + GCOMP],

+                                         srcRow[col * 3 + BCOMP]);

+            }

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+      }

+   }

+   else if (!ctx->_ImageTransferState &&

+            !srcPacking->SwapBytes &&

+	    dstFormat == MESA_FORMAT_ARGB8888 &&

+            srcFormat == GL_RGBA &&

+	    baseInternalFormat == GL_RGBA &&

+            srcType == GL_UNSIGNED_BYTE) {

+      /* same as above case, but src data has alpha too */

+      GLint img, row, col;

+      /* For some reason, streaming copies to write-combined regions

+       * are extremely sensitive to the characteristics of how the

+       * source data is retrieved.  By reordering the source reads to

+       * be in-order, the speed of this operation increases by half.

+       * Strangely the same isn't required for the RGB path, above.

+       */

+      for (img = 0; img < srcDepth; img++) {

+         const GLint srcRowStride =

+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *d4 = (GLuint *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],

+                                         srcRow[col * 4 + RCOMP],

+                                         srcRow[col * 4 + GCOMP],

+                                         srcRow[col * 4 + BCOMP]);

+            }

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+      }

+   }

+   else if (!ctx->_ImageTransferState &&

+	    (srcType == GL_UNSIGNED_BYTE ||

+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

+	    can_swizzle(baseInternalFormat) &&	   

+	    can_swizzle(srcFormat)) {

+

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

+          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||

+	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

+	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {

+	 dstmap[3] = 3;		/* alpha */

+	 dstmap[2] = 0;		/* red */

+	 dstmap[1] = 1;		/* green */

+	 dstmap[0] = 2;		/* blue */

+      }

+      else {

+	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

+		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

+		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||

+		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));

+	 dstmap[3] = 2;

+	 dstmap[2] = 1;

+	 dstmap[1] = 0;

+	 dstmap[0] = 3;

+      }

+ 

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 4,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride,

+                                dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstUI = (GLuint *) dstRow;

+            if (dstFormat == MESA_FORMAT_ARGB8888) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),

+                                                CHAN_TO_UBYTE(src[RCOMP]),

+                                                CHAN_TO_UBYTE(src[GCOMP]),

+                                                CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            else if (dstFormat == MESA_FORMAT_XRGB8888) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888( 0xff,

+                                                CHAN_TO_UBYTE(src[RCOMP]),

+                                                CHAN_TO_UBYTE(src[GCOMP]),

+                                                CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),

+                                                    CHAN_TO_UBYTE(src[RCOMP]),

+                                                    CHAN_TO_UBYTE(src[GCOMP]),

+                                                    CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_rgb888(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGB888);

+   ASSERT(texelBytes == 3);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_RGB &&

+       srcFormat == GL_BGR &&

+       srcType == GL_UNSIGNED_BYTE &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+            !srcPacking->SwapBytes &&

+            srcFormat == GL_RGBA &&

+            srcType == GL_UNSIGNED_BYTE) {

+      /* extract RGB from RGBA */

+      GLint img, row, col;

+      for (img = 0; img < srcDepth; img++) {

+         const GLint srcRowStride =

+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];

+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

+               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];

+            }

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+      }

+   }

+   else if (!ctx->_ImageTransferState &&

+	    srcType == GL_UNSIGNED_BYTE &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      dstmap[0] = 2;

+      dstmap[1] = 1;

+      dstmap[2] = 0;

+      dstmap[3] = ONE;		/* ? */

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 3,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = (const GLchan *) tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+#if 0

+            if (littleEndian) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

+                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

+                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

+                  srcUB += 3;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstRow[col * 3 + 0] = srcUB[BCOMP];

+                  dstRow[col * 3 + 1] = srcUB[GCOMP];

+                  dstRow[col * 3 + 2] = srcUB[RCOMP];

+                  srcUB += 3;

+               }

+            }

+#else

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);

+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);

+               src += 3;

+            }

+#endif

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_bgr888(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_BGR888);

+   ASSERT(texelBytes == 3);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_RGB &&

+       srcFormat == GL_RGB &&

+       srcType == GL_UNSIGNED_BYTE &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+            !srcPacking->SwapBytes &&

+            srcFormat == GL_RGBA &&

+            srcType == GL_UNSIGNED_BYTE) {

+      /* extract BGR from RGBA */

+      int img, row, col;

+      for (img = 0; img < srcDepth; img++) {

+         const GLint srcRowStride =

+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];

+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

+               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];

+            }

+            dstRow += dstRowStride;

+            srcRow += srcRowStride;

+         }

+      }

+   }

+   else if (!ctx->_ImageTransferState &&

+	    srcType == GL_UNSIGNED_BYTE &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      dstmap[0] = 0;

+      dstmap[1] = 1;

+      dstmap[2] = 2;

+      dstmap[3] = ONE;		/* ? */

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 3,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }   

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = (const GLchan *) tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

+               src += 3;

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_argb4444(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||

+          dstFormat == MESA_FORMAT_ARGB4444_REV);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_ARGB4444 &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_BGRA &&

+       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            if (dstFormat == MESA_FORMAT_ARGB4444) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),

+                                                CHAN_TO_UBYTE(src[RCOMP]),

+                                                CHAN_TO_UBYTE(src[GCOMP]),

+                                                CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),

+                                                    CHAN_TO_UBYTE(src[RCOMP]),

+                                                    CHAN_TO_UBYTE(src[GCOMP]),

+                                                    CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+static GLboolean

+_mesa_texstore_rgba5551(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_RGBA5551 &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_RGBA &&

+       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src =tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+	    for (col = 0; col < srcWidth; col++) {

+	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),

+					     CHAN_TO_UBYTE(src[GCOMP]),

+					     CHAN_TO_UBYTE(src[BCOMP]),

+					     CHAN_TO_UBYTE(src[ACOMP]) );

+	      src += 4;

+	    }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+static GLboolean

+_mesa_texstore_argb1555(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||

+          dstFormat == MESA_FORMAT_ARGB1555_REV);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_ARGB1555 &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_BGRA &&

+       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src =tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            if (dstFormat == MESA_FORMAT_ARGB1555) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),

+                                                CHAN_TO_UBYTE(src[RCOMP]),

+                                                CHAN_TO_UBYTE(src[GCOMP]),

+                                                CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),

+                                                    CHAN_TO_UBYTE(src[RCOMP]),

+                                                    CHAN_TO_UBYTE(src[GCOMP]),

+                                                    CHAN_TO_UBYTE(src[BCOMP]) );

+                  src += 4;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_argb2101010(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);

+   ASSERT(texelBytes == 4);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_ARGB2101010 &&

+       srcFormat == GL_BGRA &&

+       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&

+       baseInternalFormat == GL_RGBA) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         if (baseInternalFormat == GL_RGBA) {

+            for (row = 0; row < srcHeight; row++) {

+               GLuint *dstUI = (GLuint *) dstRow;

+               for (col = 0; col < srcWidth; col++) {

+                  GLushort a,r,g,b;

+

+                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);

+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

+                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);

+                  src += 4;

+               }

+               dstRow += dstRowStride;

+            }

+         } else if (baseInternalFormat == GL_RGB) {

+            for (row = 0; row < srcHeight; row++) {

+               GLuint *dstUI = (GLuint *) dstRow;

+               for (col = 0; col < srcWidth; col++) {

+                  GLushort r,g,b;

+

+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

+                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);

+                  src += 4;

+               }

+               dstRow += dstRowStride;

+            }

+         } else {

+            ASSERT(0);

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.

+ */

+static GLboolean

+_mesa_texstore_unorm44(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_AL44);

+   ASSERT(texelBytes == 1);

+

+   {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLubyte *dstUS = (GLubyte *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               /* src[0] is luminance, src[1] is alpha */

+               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),

+                                           CHAN_TO_UBYTE(src[0]) );

+               src += 2;

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.

+ */

+static GLboolean

+_mesa_texstore_unorm88(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_AL88 ||

+          dstFormat == MESA_FORMAT_AL88_REV ||

+          dstFormat == MESA_FORMAT_RG88 ||

+          dstFormat == MESA_FORMAT_RG88_REV);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_RG88) &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_BYTE &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+	    littleEndian &&

+	    srcType == GL_UNSIGNED_BYTE &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {

+	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||

+	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {

+	    dstmap[0] = 0;

+	    dstmap[1] = 3;

+	 }

+	 else {

+	    dstmap[0] = 3;

+	    dstmap[1] = 0;

+	 }

+      }

+      else {

+	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||

+	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {

+	    dstmap[0] = 0;

+	    dstmap[1] = 1;

+	 }

+	 else {

+	    dstmap[0] = 1;

+	    dstmap[1] = 0;

+	 }

+      }

+      dstmap[2] = ZERO;		/* ? */

+      dstmap[3] = ONE;		/* ? */

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 2,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }   

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            if (dstFormat == MESA_FORMAT_AL88 ||

+		dstFormat == MESA_FORMAT_RG88) {

+               for (col = 0; col < srcWidth; col++) {

+                  /* src[0] is luminance, src[1] is alpha */

+                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),

+                                             CHAN_TO_UBYTE(src[0]) );

+                 src += 2;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  /* src[0] is luminance, src[1] is alpha */

+                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),

+                                                 CHAN_TO_UBYTE(src[0]) );

+                 src += 2;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.

+ */

+static GLboolean

+_mesa_texstore_unorm1616(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||

+          dstFormat == MESA_FORMAT_AL1616_REV ||

+	  dstFormat == MESA_FORMAT_RG1616 ||

+          dstFormat == MESA_FORMAT_RG1616_REV);

+   ASSERT(texelBytes == 4);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       (dstFormat == MESA_FORMAT_AL1616 || dstFormat == MESA_FORMAT_RG1616) &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_SHORT &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstUI = (GLuint *) dstRow;

+            if (dstFormat == MESA_FORMAT_AL1616 ||

+		dstFormat == MESA_FORMAT_RG1616) {

+               for (col = 0; col < srcWidth; col++) {

+		  GLushort l, a;

+

+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

+		  dstUI[col] = PACK_COLOR_1616(a, l);

+		  src += 2;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+		  GLushort l, a;

+

+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

+		  dstUI[col] = PACK_COLOR_1616_REV(a, l);

+		  src += 2;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* Texstore for R16, A16, L16, I16. */

+static GLboolean

+_mesa_texstore_unorm16(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_R16 ||

+          dstFormat == MESA_FORMAT_A16 ||

+          dstFormat == MESA_FORMAT_L16 ||

+          dstFormat == MESA_FORMAT_I16);

+   ASSERT(texelBytes == 2);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_SHORT &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+	    for (col = 0; col < srcWidth; col++) {

+	       GLushort r;

+

+	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

+	       dstUS[col] = r;

+	       src += 1;

+	    }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_rgba_16(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);

+   ASSERT(texelBytes == 8);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_RGBA &&

+       srcFormat == GL_RGBA &&

+       srcType == GL_UNSIGNED_SHORT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               GLushort r, g, b, a;

+

+               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

+               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);

+               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);

+               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);

+               dstUS[col*4+0] = r;

+               dstUS[col*4+1] = g;

+               dstUS[col*4+2] = b;

+               dstUS[col*4+3] = a;

+               src += 4;

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R_16 ||

+          dstFormat == MESA_FORMAT_SIGNED_RG_16 ||

+          dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||

+          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_RGBA &&

+       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&

+       srcFormat == GL_RGBA &&

+       srcType == GL_SHORT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;

+      GLint img, row, col;

+

+      if (!tempImage)

+         return GL_FALSE;

+

+      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,

+       * 3 or 4 components/pixel here.

+       */

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLshort *dstRowS = (GLshort *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               GLuint c;

+               for (c = 0; c < comps; c++) {

+                  GLshort p;

+                  UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);

+                  dstRowS[col * comps + c] = p;

+               }

+            }

+            dstRow += dstRowStride;

+            src += 4 * srcWidth;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+static GLboolean

+_mesa_texstore_rgb332(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGB332);

+   ASSERT(texelBytes == 1);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == GL_RGB &&

+       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),

+                                             CHAN_TO_UBYTE(src[GCOMP]),

+                                             CHAN_TO_UBYTE(src[BCOMP]) );

+               src += 3;

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.

+ */

+static GLboolean

+_mesa_texstore_a8(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_A8 ||

+          dstFormat == MESA_FORMAT_L8 ||

+          dstFormat == MESA_FORMAT_I8 ||

+          dstFormat == MESA_FORMAT_R8);

+   ASSERT(texelBytes == 1);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_BYTE) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+	    srcType == GL_UNSIGNED_BYTE &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if (dstFormat == MESA_FORMAT_A8) {

+	 dstmap[0] = 3;

+      }

+      else {

+	 dstmap[0] = 0;

+      }

+      dstmap[1] = ZERO;		/* ? */

+      dstmap[2] = ZERO;		/* ? */

+      dstmap[3] = ONE;		/* ? */

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 1,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }   

+   else {

+      /* general path */

+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking);

+      const GLchan *src = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            for (col = 0; col < srcWidth; col++) {

+               dstRow[col] = CHAN_TO_UBYTE(src[col]);

+            }

+            dstRow += dstRowStride;

+            src += srcWidth;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+

+static GLboolean

+_mesa_texstore_ci8(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+

+   (void) dims; (void) baseInternalFormat;

+   ASSERT(dstFormat == MESA_FORMAT_CI8);

+   ASSERT(texelBytes == 1);

+   ASSERT(baseInternalFormat == GL_COLOR_INDEX);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       srcFormat == GL_COLOR_INDEX &&

+       srcType == GL_UNSIGNED_BYTE) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            const GLvoid *src = _mesa_image_address(dims, srcPacking,

+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

+            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,

+                                    srcType, src, srcPacking,

+                                    ctx->_ImageTransferState);

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.

+ */

+static GLboolean

+_mesa_texstore_ycbcr(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+

+   (void) ctx; (void) dims; (void) baseInternalFormat;

+

+   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||

+          (dstFormat == MESA_FORMAT_YCBCR_REV));

+   ASSERT(texelBytes == 2);

+   ASSERT(ctx->Extensions.MESA_ycbcr_texture);

+   ASSERT(srcFormat == GL_YCBCR_MESA);

+   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||

+          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));

+   ASSERT(baseInternalFormat == GL_YCBCR_MESA);

+

+   /* always just memcpy since no pixel transfer ops apply */

+   memcpy_texture(ctx, dims,

+                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                  dstRowStride,

+                  dstImageOffsets,

+                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                  srcAddr, srcPacking);

+

+   /* Check if we need byte swapping */

+   /* XXX the logic here _might_ be wrong */

+   if (srcPacking->SwapBytes ^

+       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^

+       (dstFormat == MESA_FORMAT_YCBCR_REV) ^

+       !littleEndian) {

+      GLint img, row;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            _mesa_swap2((GLushort *) dstRow, srcWidth);

+            dstRow += dstRowStride;

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+static GLboolean

+_mesa_texstore_dudv8(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_DUDV8);

+   ASSERT(texelBytes == 2);

+   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);

+   ASSERT((srcFormat == GL_DU8DV8_ATI) ||

+	  (srcFormat == GL_DUDV_ATI));

+   ASSERT(baseInternalFormat == GL_DUDV_ATI);

+

+   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&

+       littleEndian) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (srcType == GL_BYTE) {

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if (littleEndian) {

+	 dstmap[0] = 0;

+	 dstmap[1] = 3;

+      }

+      else {

+	 dstmap[0] = 3;

+	 dstmap[1] = 0;

+      }

+      dstmap[2] = ZERO;		/* ? */

+      dstmap[3] = ONE;		/* ? */

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				GL_LUMINANCE_ALPHA, /* hack */

+				GL_UNSIGNED_BYTE, /* hack */

+				GL_LUMINANCE_ALPHA, /* hack */

+				dstmap, 2,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }   

+   else {

+      /* general path - note this is defined for 2d textures only */

+      const GLint components = _mesa_components_in_format(baseInternalFormat);

+      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,

+                                                     srcFormat, srcType);

+      GLbyte *tempImage, *dst, *src;

+      GLint row;

+

+      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth

+                                          * components * sizeof(GLbyte));

+      if (!tempImage)

+         return GL_FALSE;

+

+      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,

+                                           srcWidth, srcHeight,

+                                           srcFormat, srcType,

+                                           0, 0, 0);

+

+      dst = tempImage;

+      for (row = 0; row < srcHeight; row++) {

+         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,

+                                     dst, srcFormat, srcType, src,

+                                     srcPacking, 0);

+         dst += srcWidth * components;

+         src += srcStride;

+      }

+ 

+      src = tempImage;

+      dst = (GLbyte *) dstAddr

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+      for (row = 0; row < srcHeight; row++) {

+         memcpy(dst, src, srcWidth * texelBytes);

+         dst += dstRowStride;

+         src += srcWidth * texelBytes;

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a texture in MESA_FORMAT_SIGNED_R8 format.

+ */

+static GLboolean

+_mesa_texstore_signed_r8(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R8);

+   ASSERT(texelBytes == 1);

+

+   /* XXX look at adding optimized paths */

+   {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *srcRow = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLubyte *dstB = (GLubyte *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               dstB[col] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a texture in MESA_FORMAT_SIGNED_RG88 format.

+ */

+static GLboolean

+_mesa_texstore_signed_rg88(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RG88);

+   ASSERT(texelBytes == 1);

+

+   /* XXX look at adding optimized paths */

+   {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *srcRow = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstUS = (GLushort *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               dstUS[col] = PACK_COLOR_88(FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

+                                          FLOAT_TO_BYTE_TEX(srcRow[GCOMP]));

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.

+ */

+static GLboolean

+_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);

+   ASSERT(texelBytes == 4);

+

+   {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *srcRow = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstUI = (GLuint *) dstRow;

+            for (col = 0; col < srcWidth; col++) {

+               dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

+                                             FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

+                                             FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

+                                             0xff );

+               srcRow += 4;

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+

+/**

+ * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or

+ * MESA_FORMAT_SIGNED_RGBA8888_REV

+ */

+static GLboolean

+_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)

+{

+   const GLboolean littleEndian = _mesa_little_endian();

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||

+          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);

+   ASSERT(texelBytes == 4);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&

+       baseInternalFormat == GL_RGBA &&

+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {

+       /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&

+       baseInternalFormat == GL_RGBA &&

+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||

+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (!ctx->_ImageTransferState &&

+	    (srcType == GL_BYTE) &&

+	    can_swizzle(baseInternalFormat) &&

+	    can_swizzle(srcFormat)) {

+

+      GLubyte dstmap[4];

+

+      /* dstmap - how to swizzle from RGBA to dst format:

+       */

+      if ((littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888) ||

+	  (!littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV)) {

+	 dstmap[3] = 0;

+	 dstmap[2] = 1;

+	 dstmap[1] = 2;

+	 dstmap[0] = 3;

+      }

+      else {

+	 dstmap[3] = 3;

+	 dstmap[2] = 2;

+	 dstmap[1] = 1;

+	 dstmap[0] = 0;

+      }

+      

+      _mesa_swizzle_ubyte_image(ctx, dims,

+				srcFormat,

+				srcType,

+				baseInternalFormat,

+				dstmap, 4,

+				dstAddr, dstXoffset, dstYoffset, dstZoffset,

+				dstRowStride, dstImageOffsets,

+				srcWidth, srcHeight, srcDepth, srcAddr,

+				srcPacking);      

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *srcRow = tempImage;

+      GLint img, row, col;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstUI = (GLuint *) dstRow;

+            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

+                                                FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

+                                                FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

+                                                FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );

+                  srcRow += 4;

+               }

+            }

+            else {

+               for (col = 0; col < srcWidth; col++) {

+                  dstUI[col] = PACK_COLOR_8888_REV( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

+                                                    FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

+                                                    FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

+                                                    FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );

+                  srcRow += 4;

+               }

+            }

+            dstRow += dstRowStride;

+         }

+      }

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a combined depth/stencil texture image.

+ */

+static GLboolean

+_mesa_texstore_z24_s8(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffffff;

+   const GLint srcRowStride

+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

+      / sizeof(GLuint);

+   GLint img, row;

+

+   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);

+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);

+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);

+

+   if (srcFormat != GL_DEPTH_COMPONENT && ctx->Pixel.DepthScale == 1.0f &&

+       ctx->Pixel.DepthBias == 0.0f &&

+       !srcPacking->SwapBytes) {

+      /* simple path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else if (srcFormat == GL_DEPTH_COMPONENT) {

+      /* In case we only upload depth we need to preserve the stencil */

+      for (img = 0; img < srcDepth; img++) {

+	 GLuint *dstRow = (GLuint *) dstAddr

+            + dstImageOffsets[dstZoffset + img]

+            + dstYoffset * dstRowStride / sizeof(GLuint)

+            + dstXoffset;

+         const GLuint *src

+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

+                  srcWidth, srcHeight,

+                  srcFormat, srcType,

+                  img, 0, 0);

+         for (row = 0; row < srcHeight; row++) {

+            GLuint depth[MAX_WIDTH];

+	    GLubyte stencil[MAX_WIDTH];

+            GLint i;

+	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

+

+	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

+	       keepstencil = GL_TRUE;

+	    }

+            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

+	       keepdepth = GL_TRUE;

+	    }

+

+	    if (keepdepth == GL_FALSE)

+	       /* the 24 depth bits will be in the low position: */

+	       _mesa_unpack_depth_span(ctx, srcWidth,

+				       GL_UNSIGNED_INT, /* dst type */

+				       keepstencil ? depth : dstRow, /* dst addr */

+				       depthScale,

+				       srcType, src, srcPacking);

+

+	    if (keepstencil == GL_FALSE)

+	       /* get the 8-bit stencil values */

+	       _mesa_unpack_stencil_span(ctx, srcWidth,

+					 GL_UNSIGNED_BYTE, /* dst type */

+					 stencil, /* dst addr */

+					 srcType, src, srcPacking,

+					 ctx->_ImageTransferState);

+

+	    for (i = 0; i < srcWidth; i++) {

+	       if (keepstencil)

+		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);

+	       else

+		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);

+	    }

+

+            src += srcRowStride;

+            dstRow += dstRowStride / sizeof(GLuint);

+         }

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store a combined depth/stencil texture image.

+ */

+static GLboolean

+_mesa_texstore_s8_z24(TEXSTORE_PARAMS)

+{

+   const GLuint depthScale = 0xffffff;

+   const GLint srcRowStride

+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

+      / sizeof(GLuint);

+   GLint img, row;

+

+   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);

+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||

+          srcFormat == GL_DEPTH_COMPONENT ||

+          srcFormat == GL_STENCIL_INDEX);

+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||

+          srcType == GL_UNSIGNED_INT_24_8_EXT);

+

+   for (img = 0; img < srcDepth; img++) {

+      GLuint *dstRow = (GLuint *) dstAddr

+	 + dstImageOffsets[dstZoffset + img]

+	 + dstYoffset * dstRowStride / sizeof(GLuint)

+	 + dstXoffset;

+      const GLuint *src

+	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

+						srcWidth, srcHeight,

+						srcFormat, srcType,

+						img, 0, 0);

+      for (row = 0; row < srcHeight; row++) {

+	 GLuint depth[MAX_WIDTH];

+	 GLubyte stencil[MAX_WIDTH];

+	 GLint i;

+	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

+	 

+	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

+	    keepstencil = GL_TRUE;

+	 }

+         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

+	    keepdepth = GL_TRUE;

+	 }

+

+	 if (keepdepth == GL_FALSE)

+	    /* the 24 depth bits will be in the low position: */

+	    _mesa_unpack_depth_span(ctx, srcWidth,

+				    GL_UNSIGNED_INT, /* dst type */

+				    keepstencil ? depth : dstRow, /* dst addr */

+				    depthScale,

+				    srcType, src, srcPacking);	 

+

+	 if (keepstencil == GL_FALSE)

+	    /* get the 8-bit stencil values */

+	    _mesa_unpack_stencil_span(ctx, srcWidth,

+				      GL_UNSIGNED_BYTE, /* dst type */

+				      stencil, /* dst addr */

+				      srcType, src, srcPacking,

+				      ctx->_ImageTransferState);

+

+	 /* merge stencil values into depth values */

+	 for (i = 0; i < srcWidth; i++) {

+	    if (keepstencil)

+	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);

+	    else

+	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);

+

+	 }

+	 src += srcRowStride;

+	 dstRow += dstRowStride / sizeof(GLuint);

+      }

+   }

+   return GL_TRUE;

+}

+

+

+/**

+ * Store simple 8-bit/value stencil texture data.

+ */

+static GLboolean

+_mesa_texstore_s8(TEXSTORE_PARAMS)

+{

+   ASSERT(dstFormat == MESA_FORMAT_S8);

+   ASSERT(srcFormat == GL_STENCIL_INDEX);

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_BYTE) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      const GLint srcRowStride

+	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

+	 / sizeof(GLuint);

+      GLint img, row;

+      

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img]

+            + dstYoffset * dstRowStride / sizeof(GLuint)

+            + dstXoffset;

+         const GLuint *src

+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

+                                                   srcWidth, srcHeight,

+                                                   srcFormat, srcType,

+                                                   img, 0, 0);

+         for (row = 0; row < srcHeight; row++) {

+            GLubyte stencil[MAX_WIDTH];

+            GLint i;

+

+            /* get the 8-bit stencil values */

+            _mesa_unpack_stencil_span(ctx, srcWidth,

+                                      GL_UNSIGNED_BYTE, /* dst type */

+                                      stencil, /* dst addr */

+                                      srcType, src, srcPacking,

+                                      ctx->_ImageTransferState);

+            /* merge stencil values into depth values */

+            for (i = 0; i < srcWidth; i++)

+               dstRow[i] = stencil[i];

+

+            src += srcRowStride;

+            dstRow += dstRowStride / sizeof(GLubyte);

+         }

+      }

+

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Store an image in any of the formats:

+ *   _mesa_texformat_rgba_float32

+ *   _mesa_texformat_rgb_float32

+ *   _mesa_texformat_alpha_float32

+ *   _mesa_texformat_luminance_float32

+ *   _mesa_texformat_luminance_alpha_float32

+ *   _mesa_texformat_intensity_float32

+ */

+static GLboolean

+_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||

+          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||

+          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||

+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||

+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||

+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLfloat));

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_FLOAT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *srcRow = tempImage;

+      GLint bytesPerRow;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      bytesPerRow = srcWidth * components * sizeof(GLfloat);

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            memcpy(dstRow, srcRow, bytesPerRow);

+            dstRow += dstRowStride;

+            srcRow += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+

+/**

+ * As above, but store 16-bit floats.

+ */

+static GLboolean

+_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||

+          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||

+          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||

+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||

+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||

+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLhalfARB));

+

+   if (!ctx->_ImageTransferState &&

+       !srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_HALF_FLOAT_ARB) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking,

+                                                 ctx->_ImageTransferState);

+      const GLfloat *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = _mesa_float_to_half(src[i]);

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, signed int8 */

+static GLboolean

+_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLbyte));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_BYTE) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking, 0x0);

+      const GLfloat *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLbyte *dstTexel = (GLbyte *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = (GLbyte) src[i];

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, signed int16 */

+static GLboolean

+_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLshort));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_SHORT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking, 0x0);

+      const GLfloat *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLshort *dstTexel = (GLshort *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = (GLint) src[i];

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, signed int32 */

+static GLboolean

+_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLint));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_INT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

+                                                 baseInternalFormat,

+                                                 baseFormat,

+                                                 srcWidth, srcHeight, srcDepth,

+                                                 srcFormat, srcType, srcAddr,

+                                                 srcPacking, 0x0);

+      const GLfloat *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLint *dstTexel = (GLint *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = (GLint) src[i];

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, unsigned int8 */

+static GLboolean

+_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLubyte));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_BYTE) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLuint *tempImage =

+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

+                              srcWidth, srcHeight, srcDepth,

+                              srcFormat, srcType, srcAddr, srcPacking);

+      const GLuint *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLubyte *dstTexel = (GLubyte *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, unsigned int16 */

+static GLboolean

+_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLushort));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_SHORT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLuint *tempImage =

+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

+                              srcWidth, srcHeight, srcDepth,

+                              srcFormat, srcType, srcAddr, srcPacking);

+      const GLuint *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLushort *dstTexel = (GLushort *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+/* non-normalized, unsigned int32 */

+static GLboolean

+_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)

+{

+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

+   const GLint components = _mesa_components_in_format(baseFormat);

+

+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);

+   ASSERT(baseInternalFormat == GL_RGBA ||

+          baseInternalFormat == GL_RGB ||

+          baseInternalFormat == GL_ALPHA ||

+          baseInternalFormat == GL_LUMINANCE ||

+          baseInternalFormat == GL_LUMINANCE_ALPHA ||

+          baseInternalFormat == GL_INTENSITY);

+   ASSERT(texelBytes == components * sizeof(GLuint));

+

+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

+    * to integer formats.

+    */

+   if (!srcPacking->SwapBytes &&

+       baseInternalFormat == srcFormat &&

+       srcType == GL_UNSIGNED_INT) {

+      /* simple memcpy path */

+      memcpy_texture(ctx, dims,

+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                     dstRowStride,

+                     dstImageOffsets,

+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

+                     srcAddr, srcPacking);

+   }

+   else {

+      /* general path */

+      const GLuint *tempImage =

+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

+                              srcWidth, srcHeight, srcDepth,

+                              srcFormat, srcType, srcAddr, srcPacking);

+      const GLuint *src = tempImage;

+      GLint img, row;

+      if (!tempImage)

+         return GL_FALSE;

+      for (img = 0; img < srcDepth; img++) {

+         GLubyte *dstRow = (GLubyte *) dstAddr

+            + dstImageOffsets[dstZoffset + img] * texelBytes

+            + dstYoffset * dstRowStride

+            + dstXoffset * texelBytes;

+         for (row = 0; row < srcHeight; row++) {

+            GLuint *dstTexel = (GLuint *) dstRow;

+            GLint i;

+            for (i = 0; i < srcWidth * components; i++) {

+               dstTexel[i] = src[i];

+            }

+            dstRow += dstRowStride;

+            src += srcWidth * components;

+         }

+      }

+

+      free((void *) tempImage);

+   }

+   return GL_TRUE;

+}

+

+

+

+

+#if FEATURE_EXT_texture_sRGB

+static GLboolean

+_mesa_texstore_srgb8(TEXSTORE_PARAMS)

+{

+   gl_format newDstFormat;

+   GLboolean k;

+

+   ASSERT(dstFormat == MESA_FORMAT_SRGB8);

+

+   /* reuse normal rgb texstore code */

+   newDstFormat = MESA_FORMAT_RGB888;

+

+   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,

+                             newDstFormat, dstAddr,

+                             dstXoffset, dstYoffset, dstZoffset,

+                             dstRowStride, dstImageOffsets,

+                             srcWidth, srcHeight, srcDepth,

+                             srcFormat, srcType,

+                             srcAddr, srcPacking);

+   return k;

+}

+

+

+static GLboolean

+_mesa_texstore_srgba8(TEXSTORE_PARAMS)

+{

+   gl_format newDstFormat;

+   GLboolean k;

+

+   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);

+

+   /* reuse normal rgba texstore code */

+   newDstFormat = MESA_FORMAT_RGBA8888;

+   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,

+                               newDstFormat, dstAddr,

+                               dstXoffset, dstYoffset, dstZoffset,

+                               dstRowStride, dstImageOffsets,

+                               srcWidth, srcHeight, srcDepth,

+                               srcFormat, srcType,

+                               srcAddr, srcPacking);

+   return k;

+}

+

+

+static GLboolean

+_mesa_texstore_sargb8(TEXSTORE_PARAMS)

+{

+   gl_format newDstFormat;

+   GLboolean k;

+

+   ASSERT(dstFormat == MESA_FORMAT_SARGB8);

+

+   /* reuse normal rgba texstore code */

+   newDstFormat = MESA_FORMAT_ARGB8888;

+

+   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,

+                               newDstFormat, dstAddr,

+                               dstXoffset, dstYoffset, dstZoffset,

+                               dstRowStride, dstImageOffsets,

+                               srcWidth, srcHeight, srcDepth,

+                               srcFormat, srcType,

+                               srcAddr, srcPacking);

+   return k;

+}

+

+

+static GLboolean

+_mesa_texstore_sl8(TEXSTORE_PARAMS)

+{

+   gl_format newDstFormat;

+   GLboolean k;

+

+   ASSERT(dstFormat == MESA_FORMAT_SL8);

+

+   newDstFormat = MESA_FORMAT_L8;

+

+   /* _mesa_textore_a8 handles luminance8 too */

+   k = _mesa_texstore_a8(ctx, dims, baseInternalFormat,

+                         newDstFormat, dstAddr,

+                         dstXoffset, dstYoffset, dstZoffset,

+                         dstRowStride, dstImageOffsets,

+                         srcWidth, srcHeight, srcDepth,

+                         srcFormat, srcType,

+                         srcAddr, srcPacking);

+   return k;

+}

+

+

+static GLboolean

+_mesa_texstore_sla8(TEXSTORE_PARAMS)

+{

+   gl_format newDstFormat;

+   GLboolean k;

+

+   ASSERT(dstFormat == MESA_FORMAT_SLA8);

+

+   /* reuse normal luminance/alpha texstore code */

+   newDstFormat = MESA_FORMAT_AL88;

+

+   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,

+			      newDstFormat, dstAddr,

+			      dstXoffset, dstYoffset, dstZoffset,

+			      dstRowStride, dstImageOffsets,

+			      srcWidth, srcHeight, srcDepth,

+			      srcFormat, srcType,

+			      srcAddr, srcPacking);

+   return k;

+}

+

+#else

+

+/* these are used only in texstore_funcs[] below */

+#define _mesa_texstore_srgb8 NULL

+#define _mesa_texstore_srgba8 NULL

+#define _mesa_texstore_sargb8 NULL

+#define _mesa_texstore_sl8 NULL

+#define _mesa_texstore_sla8 NULL

+

+#endif /* FEATURE_EXT_texture_sRGB */

+

+

+

+

+/**

+ * Table mapping MESA_FORMAT_* to _mesa_texstore_*()

+ * XXX this is somewhat temporary.

+ */

+static const struct {

+   gl_format Name;

+   StoreTexImageFunc Store;

+}

+texstore_funcs[MESA_FORMAT_COUNT] =

+{

+   { MESA_FORMAT_NONE, NULL },

+   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },

+   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },

+   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },

+   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },

+   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },

+   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },

+   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },

+   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },

+   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },

+   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },

+   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },

+   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },

+   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },

+   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },

+   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },

+   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },

+   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },

+   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },

+   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },

+   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },

+   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },

+   { MESA_FORMAT_A8, _mesa_texstore_a8 },

+   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },

+   { MESA_FORMAT_L8, _mesa_texstore_a8 },

+   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },

+   { MESA_FORMAT_I8, _mesa_texstore_a8 },

+   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },

+   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },

+   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },

+   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },

+   { MESA_FORMAT_R8, _mesa_texstore_a8 },

+   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },

+   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },

+   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },

+   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },

+   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },

+   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },

+   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },

+   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },

+   { MESA_FORMAT_Z16, _mesa_texstore_z16 },

+   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },

+   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },

+   { MESA_FORMAT_Z32, _mesa_texstore_z32 },

+   { MESA_FORMAT_S8, _mesa_texstore_s8 },

+   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },

+   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },

+   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },

+   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },

+   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },

+   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },

+   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },

+   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },

+   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },

+   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },

+   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },

+   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },

+   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },

+   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },

+   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },

+   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },

+   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },

+   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

+   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },

+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

+   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },

+   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },

+

+   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },

+   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },

+   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },

+   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },

+   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },

+   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },

+

+   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },

+

+   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_signed_r8 },

+   { MESA_FORMAT_SIGNED_RG88, _mesa_texstore_signed_rg88 },

+   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },

+

+   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },

+   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },

+

+   { MESA_FORMAT_SIGNED_R_16, _mesa_texstore_signed_rgba_16 },

+   { MESA_FORMAT_SIGNED_RG_16, _mesa_texstore_signed_rgba_16 },

+   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },

+   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },

+   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },

+

+   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },

+   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },

+   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },

+   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },

+

+   /* Re-use the R/RG texstore functions.

+    * The code is generic enough to handle LATC too. */

+   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },

+   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },

+   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },

+   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 }

+};

+

+

+static GLboolean

+_mesa_texstore_null(TEXSTORE_PARAMS)

+{

+   (void) ctx; (void) dims;

+   (void) baseInternalFormat;

+   (void) dstFormat;

+   (void) dstAddr;

+   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;

+   (void) dstRowStride; (void) dstImageOffsets;

+   (void) srcWidth; (void) srcHeight; (void) srcDepth;

+   (void) srcFormat; (void) srcType;

+   (void) srcAddr;

+   (void) srcPacking;

+

+   /* should never happen */

+   _mesa_problem(NULL, "_mesa_texstore_null() is called");

+   return GL_FALSE;

+}

+

+

+/**

+ * Return the StoreTexImageFunc pointer to store an image in the given format.

+ */

+static StoreTexImageFunc

+_mesa_get_texstore_func(gl_format format)

+{

+#ifdef DEBUG

+   GLuint i;

+   for (i = 0; i < MESA_FORMAT_COUNT; i++) {

+      ASSERT(texstore_funcs[i].Name == i);

+   }

+#endif

+   ASSERT(texstore_funcs[format].Name == format);

+

+   if (texstore_funcs[format].Store)

+      return texstore_funcs[format].Store;

+   else

+      return _mesa_texstore_null;

+}

+

+

+/**

+ * Store user data into texture memory.

+ * Called via glTex[Sub]Image1/2/3D()

+ */

+GLboolean

+_mesa_texstore(TEXSTORE_PARAMS)

+{

+   StoreTexImageFunc storeImage;

+   GLboolean success;

+

+   storeImage = _mesa_get_texstore_func(dstFormat);

+

+   success = storeImage(ctx, dims, baseInternalFormat,

+                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

+                        dstRowStride, dstImageOffsets,

+                        srcWidth, srcHeight, srcDepth,

+                        srcFormat, srcType, srcAddr, srcPacking);

+   return success;

+}

+

+

+/** Return texture size in bytes */

+static GLuint

+texture_size(const struct gl_texture_image *texImage)

+{

+   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,

+                                       texImage->Height, texImage->Depth);

+   return sz;

+}

+

+

+/** Return row stride in bytes */

+static GLuint

+texture_row_stride(const struct gl_texture_image *texImage)

+{

+   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,

+                                           texImage->Width);

+   return stride;

+}

+

+

+

+/**

+ * This is the software fallback for Driver.TexImage1D()

+ * and Driver.CopyTexImage1D().

+ * \sa _mesa_store_teximage2d()

+ */

+void

+_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint border,

+                       GLenum format, GLenum type, const GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage)

+{

+   GLuint sizeInBytes;

+   (void) border;

+

+   /* allocate memory */

+   sizeInBytes = texture_size(texImage);

+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

+   if (!texImage->Data) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

+      return;

+   }

+

+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

+                                        pixels, packing, "glTexImage1D");

+   if (!pixels) {

+      /* Note: we check for a NULL image pointer here, _after_ we allocated

+       * memory for the texture.  That's what the GL spec calls for.

+       */

+      return;

+   }

+   else {

+      const GLint dstRowStride = 0;

+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         0, 0, 0,  /* dstX/Y/Zoffset */

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, 1, 1,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+/**

+ * This is the software fallback for Driver.TexImage2D()

+ * and Driver.CopyTexImage2D().

+ *

+ * This function is oriented toward storing images in main memory, rather

+ * than VRAM.  Device driver's can easily plug in their own replacement.

+ */

+void

+_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint height, GLint border,

+                       GLenum format, GLenum type, const void *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage)

+{

+   GLuint sizeInBytes;

+   (void) border;

+

+   /* allocate memory */

+   sizeInBytes = texture_size(texImage);

+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

+   if (!texImage->Data) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

+      return;

+   }

+

+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

+                                        pixels, packing, "glTexImage2D");

+   if (!pixels) {

+      /* Note: we check for a NULL image pointer here, _after_ we allocated

+       * memory for the texture.  That's what the GL spec calls for.

+       */

+      return;

+   }

+   else {

+      GLint dstRowStride = texture_row_stride(texImage);

+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         0, 0, 0,  /* dstX/Y/Zoffset */

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, height, 1,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+

+/**

+ * This is the software fallback for Driver.TexImage3D()

+ * and Driver.CopyTexImage3D().

+ * \sa _mesa_store_teximage2d()

+ */

+void

+_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint height, GLint depth, GLint border,

+                       GLenum format, GLenum type, const void *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage)

+{

+   GLuint sizeInBytes;

+   (void) border;

+

+   /* allocate memory */

+   sizeInBytes = texture_size(texImage);

+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

+   if (!texImage->Data) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

+      return;

+   }

+

+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

+                                        type, pixels, packing, "glTexImage3D");

+   if (!pixels) {

+      /* Note: we check for a NULL image pointer here, _after_ we allocated

+       * memory for the texture.  That's what the GL spec calls for.

+       */

+      return;

+   }

+   else {

+      GLint dstRowStride = texture_row_stride(texImage);

+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         0, 0, 0,  /* dstX/Y/Zoffset */

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, height, depth,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+

+

+/*

+ * This is the software fallback for Driver.TexSubImage1D()

+ * and Driver.CopyTexSubImage1D().

+ */

+void

+_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint width,

+                          GLenum format, GLenum type, const void *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage)

+{

+   /* get pointer to src pixels (may be in a pbo which we'll map here) */

+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

+                                        pixels, packing, "glTexSubImage1D");

+   if (!pixels)

+      return;

+

+   {

+      const GLint dstRowStride = 0;

+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         xoffset, 0, 0,  /* offsets */

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, 1, 1,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+

+/**

+ * This is the software fallback for Driver.TexSubImage2D()

+ * and Driver.CopyTexSubImage2D().

+ */

+void

+_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint yoffset,

+                          GLint width, GLint height,

+                          GLenum format, GLenum type, const void *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage)

+{

+   /* get pointer to src pixels (may be in a pbo which we'll map here) */

+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

+                                        pixels, packing, "glTexSubImage2D");

+   if (!pixels)

+      return;

+

+   {

+      GLint dstRowStride = texture_row_stride(texImage);

+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         xoffset, yoffset, 0,

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, height, 1,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+/*

+ * This is the software fallback for Driver.TexSubImage3D().

+ * and Driver.CopyTexSubImage3D().

+ */

+void

+_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint yoffset, GLint zoffset,

+                          GLint width, GLint height, GLint depth,

+                          GLenum format, GLenum type, const void *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage)

+{

+   /* get pointer to src pixels (may be in a pbo which we'll map here) */

+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

+                                        type, pixels, packing,

+                                        "glTexSubImage3D");

+   if (!pixels)

+      return;

+

+   {

+      GLint dstRowStride = texture_row_stride(texImage);

+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

+                                         texImage->TexFormat,

+                                         texImage->Data,

+                                         xoffset, yoffset, zoffset,

+                                         dstRowStride,

+                                         texImage->ImageOffsets,

+                                         width, height, depth,

+                                         format, type, pixels, packing);

+      if (!success) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");

+      }

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, packing);

+}

+

+

+/*

+ * Fallback for Driver.CompressedTexImage1D()

+ */

+void

+_mesa_store_compressed_teximage1d(struct gl_context *ctx,

+                                  GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage)

+{

+   /* this space intentionally left blank */

+   (void) ctx;

+   (void) target; (void) level;

+   (void) internalFormat;

+   (void) width; (void) border;

+   (void) imageSize; (void) data;

+   (void) texObj;

+   (void) texImage;

+}

+

+

+

+/**

+ * Fallback for Driver.CompressedTexImage2D()

+ */

+void

+_mesa_store_compressed_teximage2d(struct gl_context *ctx,

+                                  GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint height, GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage)

+{

+   (void) width; (void) height; (void) border;

+

+   /* This is pretty simple, basically just do a memcpy without worrying

+    * about the usual image unpacking or image transfer operations.

+    */

+   ASSERT(texObj);

+   ASSERT(texImage);

+   ASSERT(texImage->Width > 0);

+   ASSERT(texImage->Height > 0);

+   ASSERT(texImage->Depth == 1);

+   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */

+

+   /* allocate storage */

+   texImage->Data = _mesa_alloc_texmemory(imageSize);

+   if (!texImage->Data) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");

+      return;

+   }

+

+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

+                                                 &ctx->Unpack,

+                                                 "glCompressedTexImage2D");

+   if (!data)

+      return;

+

+   /* copy the data */

+   memcpy(texImage->Data, data, imageSize);

+

+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

+}

+

+

+

+/*

+ * Fallback for Driver.CompressedTexImage3D()

+ */

+void

+_mesa_store_compressed_teximage3d(struct gl_context *ctx,

+                                  GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint height, GLint depth,

+                                  GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage)

+{

+   /* this space intentionally left blank */

+   (void) ctx;

+   (void) target; (void) level;

+   (void) internalFormat;

+   (void) width; (void) height; (void) depth;

+   (void) border;

+   (void) imageSize; (void) data;

+   (void) texObj;

+   (void) texImage;

+}

+

+

+

+/**

+ * Fallback for Driver.CompressedTexSubImage1D()

+ */

+void

+_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,

+                                     GLint level,

+                                     GLint xoffset, GLsizei width,

+                                     GLenum format,

+                                     GLsizei imageSize, const GLvoid *data,

+                                     struct gl_texture_object *texObj,

+                                     struct gl_texture_image *texImage)

+{

+   /* there are no compressed 1D texture formats yet */

+   (void) ctx;

+   (void) target; (void) level;

+   (void) xoffset; (void) width;

+   (void) format;

+   (void) imageSize; (void) data;

+   (void) texObj;

+   (void) texImage;

+}

+

+

+/**

+ * Fallback for Driver.CompressedTexSubImage2D()

+ */

+void

+_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,

+                                     GLint level,

+                                     GLint xoffset, GLint yoffset,

+                                     GLsizei width, GLsizei height,

+                                     GLenum format,

+                                     GLsizei imageSize, const GLvoid *data,

+                                     struct gl_texture_object *texObj,

+                                     struct gl_texture_image *texImage)

+{

+   GLint bytesPerRow, destRowStride, srcRowStride;

+   GLint i, rows;

+   GLubyte *dest;

+   const GLubyte *src;

+   const gl_format texFormat = texImage->TexFormat;

+   const GLint destWidth = texImage->Width;

+   GLuint bw, bh;

+

+   _mesa_get_format_block_size(texFormat, &bw, &bh);

+

+   (void) level;

+   (void) format;

+

+   /* these should have been caught sooner */

+   ASSERT((width % bw) == 0 || width == 2 || width == 1);

+   ASSERT((height % bh) == 0 || height == 2 || height == 1);

+   ASSERT((xoffset % bw) == 0);

+   ASSERT((yoffset % bh) == 0);

+

+   /* get pointer to src pixels (may be in a pbo which we'll map here) */

+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

+                                                 &ctx->Unpack,

+                                                 "glCompressedTexSubImage2D");

+   if (!data)

+      return;

+

+   srcRowStride = _mesa_format_row_stride(texFormat, width);

+   src = (const GLubyte *) data;

+

+   destRowStride = _mesa_format_row_stride(texFormat, destWidth);

+   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,

+                                         texFormat, destWidth,

+                                         (GLubyte *) texImage->Data);

+

+   bytesPerRow = srcRowStride;  /* bytes per row of blocks */

+   rows = height / bh;  /* rows in blocks */

+

+   /* copy rows of blocks */

+   for (i = 0; i < rows; i++) {

+      memcpy(dest, src, bytesPerRow);

+      dest += destRowStride;

+      src += srcRowStride;

+   }

+

+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

+}

+

+

+/**

+ * Fallback for Driver.CompressedTexSubImage3D()

+ */

+void

+_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,

+                                GLint level,

+                                GLint xoffset, GLint yoffset, GLint zoffset,

+                                GLsizei width, GLsizei height, GLsizei depth,

+                                GLenum format,

+                                GLsizei imageSize, const GLvoid *data,

+                                struct gl_texture_object *texObj,

+                                struct gl_texture_image *texImage)

+{

+   /* there are no compressed 3D texture formats yet */

+   (void) ctx;

+   (void) target; (void) level;

+   (void) xoffset; (void) yoffset; (void) zoffset;

+   (void) width; (void) height; (void) depth;

+   (void) format;

+   (void) imageSize; (void) data;

+   (void) texObj;

+   (void) texImage;

+}

diff --git a/mesalib/src/mesa/main/texstore.h b/mesalib/src/mesa/main/texstore.h
index d56318709..1d0ce7d4a 100644
--- a/mesalib/src/mesa/main/texstore.h
+++ b/mesalib/src/mesa/main/texstore.h
@@ -1,209 +1,209 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
- * Copyright (c) 2008 VMware, Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file texstore.h
- * Texture image storage routines.
- *
- * \author Brian Paul
- */
-
-
-#ifndef TEXSTORE_H
-#define TEXSTORE_H
-
-
-#include "mtypes.h"
-#include "formats.h"
-
-
-/**
- * This macro defines the (many) parameters to the texstore functions.
- * \param dims  either 1 or 2 or 3
- * \param baseInternalFormat  user-specified base internal format
- * \param dstFormat  destination Mesa texture format
- * \param dstAddr  destination image address
- * \param dstX/Y/Zoffset  destination x/y/z offset (ala TexSubImage), in texels
- * \param dstRowStride  destination image row stride, in bytes
- * \param dstImageOffsets  offset of each 2D slice within 3D texture, in texels
- * \param srcWidth/Height/Depth  source image size, in pixels
- * \param srcFormat  incoming image format
- * \param srcType  incoming image data type
- * \param srcAddr  source image address
- * \param srcPacking  source image packing parameters
- */
-#define TEXSTORE_PARAMS \
-	struct gl_context *ctx, GLuint dims, \
-	GLenum baseInternalFormat, \
-	gl_format dstFormat, \
-	GLvoid *dstAddr, \
-	GLint dstXoffset, GLint dstYoffset, GLint dstZoffset, \
-	GLint dstRowStride, const GLuint *dstImageOffsets, \
-	GLint srcWidth, GLint srcHeight, GLint srcDepth, \
-	GLenum srcFormat, GLenum srcType, \
-	const GLvoid *srcAddr, \
-	const struct gl_pixelstore_attrib *srcPacking
-
-
-extern GLboolean
-_mesa_texstore(TEXSTORE_PARAMS);
-
-
-extern GLchan *
-_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,
-                           GLenum logicalBaseFormat,
-                           GLenum textureBaseFormat,
-                           GLint srcWidth, GLint srcHeight, GLint srcDepth,
-                           GLenum srcFormat, GLenum srcType,
-                           const GLvoid *srcAddr,
-                           const struct gl_pixelstore_attrib *srcPacking);
-
-GLfloat *
-_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
-			    GLenum logicalBaseFormat,
-			    GLenum textureBaseFormat,
-			    GLint srcWidth, GLint srcHeight, GLint srcDepth,
-			    GLenum srcFormat, GLenum srcType,
-			    const GLvoid *srcAddr,
-			    const struct gl_pixelstore_attrib *srcPacking,
-			    GLbitfield transferOps);
-
-extern void
-_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint border,
-                       GLenum format, GLenum type, const GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint height, GLint border,
-                       GLenum format, GLenum type, const GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,
-                       GLint internalFormat,
-                       GLint width, GLint height, GLint depth, GLint border,
-                       GLenum format, GLenum type, const GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       struct gl_texture_object *texObj,
-                       struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint width,
-                          GLenum format, GLenum type, const GLvoid *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint yoffset,
-                          GLint width, GLint height,
-                          GLenum format, GLenum type, const GLvoid *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint xoffset, GLint yoffset, GLint zoffset,
-                          GLint width, GLint height, GLint depth,
-                          GLenum format, GLenum type, const GLvoid *pixels,
-                          const struct gl_pixelstore_attrib *packing,
-                          struct gl_texture_object *texObj,
-                          struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_compressed_teximage1d(struct gl_context *ctx, GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage);
-
-extern void
-_mesa_store_compressed_teximage2d(struct gl_context *ctx, GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint height, GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage);
-
-extern void
-_mesa_store_compressed_teximage3d(struct gl_context *ctx, GLenum target, GLint level,
-                                  GLint internalFormat,
-                                  GLint width, GLint height, GLint depth,
-                                  GLint border,
-                                  GLsizei imageSize, const GLvoid *data,
-                                  struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,
-                                     GLint level,
-                                     GLint xoffset, GLsizei width,
-                                     GLenum format,
-                                     GLsizei imageSize, const GLvoid *data,
-                                     struct gl_texture_object *texObj,
-                                     struct gl_texture_image *texImage);
-
-extern void
-_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,
-                                     GLint level,
-                                     GLint xoffset, GLint yoffset,
-                                     GLsizei width, GLsizei height,
-                                     GLenum format,
-                                     GLsizei imageSize, const GLvoid *data,
-                                     struct gl_texture_object *texObj,
-                                     struct gl_texture_image *texImage);
-
-extern void
-_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,
-                                GLint level,
-                                GLint xoffset, GLint yoffset, GLint zoffset,
-                                GLsizei width, GLsizei height, GLsizei depth,
-                                GLenum format,
-                                GLsizei imageSize, const GLvoid *data,
-                                struct gl_texture_object *texObj,
-                                struct gl_texture_image *texImage);
-
-
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.

+ * Copyright (c) 2008 VMware, Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file texstore.h

+ * Texture image storage routines.

+ *

+ * \author Brian Paul

+ */

+

+

+#ifndef TEXSTORE_H

+#define TEXSTORE_H

+

+

+#include "mtypes.h"

+#include "formats.h"

+

+

+/**

+ * This macro defines the (many) parameters to the texstore functions.

+ * \param dims  either 1 or 2 or 3

+ * \param baseInternalFormat  user-specified base internal format

+ * \param dstFormat  destination Mesa texture format

+ * \param dstAddr  destination image address

+ * \param dstX/Y/Zoffset  destination x/y/z offset (ala TexSubImage), in texels

+ * \param dstRowStride  destination image row stride, in bytes

+ * \param dstImageOffsets  offset of each 2D slice within 3D texture, in texels

+ * \param srcWidth/Height/Depth  source image size, in pixels

+ * \param srcFormat  incoming image format

+ * \param srcType  incoming image data type

+ * \param srcAddr  source image address

+ * \param srcPacking  source image packing parameters

+ */

+#define TEXSTORE_PARAMS \

+	struct gl_context *ctx, GLuint dims, \

+	GLenum baseInternalFormat, \

+	gl_format dstFormat, \

+	GLvoid *dstAddr, \

+	GLint dstXoffset, GLint dstYoffset, GLint dstZoffset, \

+	GLint dstRowStride, const GLuint *dstImageOffsets, \

+	GLint srcWidth, GLint srcHeight, GLint srcDepth, \

+	GLenum srcFormat, GLenum srcType, \

+	const GLvoid *srcAddr, \

+	const struct gl_pixelstore_attrib *srcPacking

+

+

+extern GLboolean

+_mesa_texstore(TEXSTORE_PARAMS);

+

+

+extern GLchan *

+_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,

+                           GLenum logicalBaseFormat,

+                           GLenum textureBaseFormat,

+                           GLint srcWidth, GLint srcHeight, GLint srcDepth,

+                           GLenum srcFormat, GLenum srcType,

+                           const GLvoid *srcAddr,

+                           const struct gl_pixelstore_attrib *srcPacking);

+

+GLfloat *

+_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,

+			    GLenum logicalBaseFormat,

+			    GLenum textureBaseFormat,

+			    GLint srcWidth, GLint srcHeight, GLint srcDepth,

+			    GLenum srcFormat, GLenum srcType,

+			    const GLvoid *srcAddr,

+			    const struct gl_pixelstore_attrib *srcPacking,

+			    GLbitfield transferOps);

+

+extern void

+_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint border,

+                       GLenum format, GLenum type, const GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint height, GLint border,

+                       GLenum format, GLenum type, const GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,

+                       GLint internalFormat,

+                       GLint width, GLint height, GLint depth, GLint border,

+                       GLenum format, GLenum type, const GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       struct gl_texture_object *texObj,

+                       struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint width,

+                          GLenum format, GLenum type, const GLvoid *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint yoffset,

+                          GLint width, GLint height,

+                          GLenum format, GLenum type, const GLvoid *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint xoffset, GLint yoffset, GLint zoffset,

+                          GLint width, GLint height, GLint depth,

+                          GLenum format, GLenum type, const GLvoid *pixels,

+                          const struct gl_pixelstore_attrib *packing,

+                          struct gl_texture_object *texObj,

+                          struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_compressed_teximage1d(struct gl_context *ctx, GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage);

+

+extern void

+_mesa_store_compressed_teximage2d(struct gl_context *ctx, GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint height, GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage);

+

+extern void

+_mesa_store_compressed_teximage3d(struct gl_context *ctx, GLenum target, GLint level,

+                                  GLint internalFormat,

+                                  GLint width, GLint height, GLint depth,

+                                  GLint border,

+                                  GLsizei imageSize, const GLvoid *data,

+                                  struct gl_texture_object *texObj,

+                                  struct gl_texture_image *texImage);

+

+

+extern void

+_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,

+                                     GLint level,

+                                     GLint xoffset, GLsizei width,

+                                     GLenum format,

+                                     GLsizei imageSize, const GLvoid *data,

+                                     struct gl_texture_object *texObj,

+                                     struct gl_texture_image *texImage);

+

+extern void

+_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,

+                                     GLint level,

+                                     GLint xoffset, GLint yoffset,

+                                     GLsizei width, GLsizei height,

+                                     GLenum format,

+                                     GLsizei imageSize, const GLvoid *data,

+                                     struct gl_texture_object *texObj,

+                                     struct gl_texture_image *texImage);

+

+extern void

+_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,

+                                GLint level,

+                                GLint xoffset, GLint yoffset, GLint zoffset,

+                                GLsizei width, GLsizei height, GLsizei depth,

+                                GLenum format,

+                                GLsizei imageSize, const GLvoid *data,

+                                struct gl_texture_object *texObj,

+                                struct gl_texture_image *texImage);

+

+

+#endif

diff --git a/mesalib/src/mesa/program/doflexbison.bat b/mesalib/src/mesa/program/doflexbison.bat
new file mode 100644
index 000000000..d54e5ac65
--- /dev/null
+++ b/mesalib/src/mesa/program/doflexbison.bat
@@ -0,0 +1,18 @@
+@echo off

+setlocal

+

+cd "%~dp0"

+

+set M4=..\..\..\..\tools\mhmake\m4.exe

+set BISON_PKGDATADIR=../../../../tools/mhmake/src/bisondata

+

+set path=..\..\..\..\tools\mhmake;%path%

+

+..\..\..\..\tools\mhmake\bison.exe -v -d --output=program_parse.tab.c program_parse.y

+

+copy "..\..\..\..\tools\mhmake\flex++.exe" flex.exe

+flex.exe --never-interactive --outfile=lex.yy.c program_lexer.l

+del flex.exe

+

+endlocal

+

diff --git a/mesalib/src/mesa/program/prog_instruction.h b/mesalib/src/mesa/program/prog_instruction.h
index 669d71029..11f2ac53e 100644
--- a/mesalib/src/mesa/program/prog_instruction.h
+++ b/mesalib/src/mesa/program/prog_instruction.h
@@ -1,454 +1,454 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/**
- * \file prog_instruction.h
- *
- * Vertex/fragment program instruction datatypes and constants.
- *
- * \author Brian Paul
- * \author Keith Whitwell
- * \author Ian Romanick <idr@us.ibm.com>
- */
-
-
-#ifndef PROG_INSTRUCTION_H
-#define PROG_INSTRUCTION_H
-
-
-#include "main/glheader.h"
-
-
-/**
- * Swizzle indexes.
- * Do not change!
- */
-/*@{*/
-#define SWIZZLE_X    0
-#define SWIZZLE_Y    1
-#define SWIZZLE_Z    2
-#define SWIZZLE_W    3
-#define SWIZZLE_ZERO 4   /**< For SWZ instruction only */
-#define SWIZZLE_ONE  5   /**< For SWZ instruction only */
-#define SWIZZLE_NIL  7   /**< used during shader code gen (undefined value) */
-/*@}*/
-
-#define MAKE_SWIZZLE4(a,b,c,d) (((a)<<0) | ((b)<<3) | ((c)<<6) | ((d)<<9))
-#define SWIZZLE_NOOP           MAKE_SWIZZLE4(0,1,2,3)
-#define GET_SWZ(swz, idx)      (((swz) >> ((idx)*3)) & 0x7)
-#define GET_BIT(msk, idx)      (((msk) >> (idx)) & 0x1)
-
-#define SWIZZLE_XYZW MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W)
-#define SWIZZLE_XXXX MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X)
-#define SWIZZLE_YYYY MAKE_SWIZZLE4(SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y)
-#define SWIZZLE_ZZZZ MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z)
-#define SWIZZLE_WWWW MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
-
-
-/**
- * Writemask values, 1 bit per component.
- */
-/*@{*/
-#define WRITEMASK_X     0x1
-#define WRITEMASK_Y     0x2
-#define WRITEMASK_XY    0x3
-#define WRITEMASK_Z     0x4
-#define WRITEMASK_XZ    0x5
-#define WRITEMASK_YZ    0x6
-#define WRITEMASK_XYZ   0x7
-#define WRITEMASK_W     0x8
-#define WRITEMASK_XW    0x9
-#define WRITEMASK_YW    0xa
-#define WRITEMASK_XYW   0xb
-#define WRITEMASK_ZW    0xc
-#define WRITEMASK_XZW   0xd
-#define WRITEMASK_YZW   0xe
-#define WRITEMASK_XYZW  0xf
-/*@}*/
-
-
-/**
- * Condition codes
- */
-/*@{*/
-#define COND_GT  1  /**< greater than zero */
-#define COND_EQ  2  /**< equal to zero */
-#define COND_LT  3  /**< less than zero */
-#define COND_UN  4  /**< unordered (NaN) */
-#define COND_GE  5  /**< greater than or equal to zero */
-#define COND_LE  6  /**< less than or equal to zero */
-#define COND_NE  7  /**< not equal to zero */
-#define COND_TR  8  /**< always true */
-#define COND_FL  9  /**< always false */
-/*@}*/
-
-
-/**
- * Instruction precision for GL_NV_fragment_program
- */
-/*@{*/
-#define FLOAT32  0x1
-#define FLOAT16  0x2
-#define FIXED12  0x4
-/*@}*/
-
-
-/**
- * Saturation modes when storing values.
- */
-/*@{*/
-#define SATURATE_OFF            0
-#define SATURATE_ZERO_ONE       1
-/*@}*/
-
-
-/**
- * Per-component negation masks
- */
-/*@{*/
-#define NEGATE_X    0x1
-#define NEGATE_Y    0x2
-#define NEGATE_Z    0x4
-#define NEGATE_W    0x8
-#define NEGATE_XYZ  0x7
-#define NEGATE_XYZW 0xf
-#define NEGATE_NONE 0x0
-/*@}*/
-
-
-/**
- * Program instruction opcodes for vertex, fragment and geometry programs.
- */
-typedef enum prog_opcode {
-                     /* ARB_vp   ARB_fp   NV_vp   NV_fp     GLSL */
-                     /*------------------------------------------*/
-   OPCODE_NOP = 0,   /*                                      X   */
-   OPCODE_ABS,       /*   X        X       1.1               X   */
-   OPCODE_ADD,       /*   X        X       X       X         X   */
-   OPCODE_AND,       /*                                          */
-   OPCODE_ARA,       /*                    2                     */
-   OPCODE_ARL,       /*   X                X                 X   */
-   OPCODE_ARL_NV,    /*                    2                     */
-   OPCODE_ARR,       /*                    2                     */
-   OPCODE_BGNLOOP,   /*                                     opt  */
-   OPCODE_BGNSUB,    /*                                     opt  */
-   OPCODE_BRA,       /*                    2                 X   */
-   OPCODE_BRK,       /*                    2                opt  */
-   OPCODE_CAL,       /*                    2       2         X   */
-   OPCODE_CMP,       /*            X                         X   */
-   OPCODE_CONT,      /*                                     opt  */
-   OPCODE_COS,       /*            X       2       X         X   */
-   OPCODE_DDX,       /*                            X         X   */
-   OPCODE_DDY,       /*                            X         X   */
-   OPCODE_DP2,       /*                            2         X   */
-   OPCODE_DP2A,      /*                            2             */
-   OPCODE_DP3,       /*   X        X       X       X         X   */
-   OPCODE_DP4,       /*   X        X       X       X         X   */
-   OPCODE_DPH,       /*   X        X       1.1                   */
-   OPCODE_DST,       /*   X        X       X       X             */
-   OPCODE_ELSE,      /*                                      X   */
-   OPCODE_EMIT_VERTEX,/*                                     X   */
-   OPCODE_END,       /*   X        X       X       X        opt  */
-   OPCODE_END_PRIMITIVE,/*                                   X   */
-   OPCODE_ENDIF,     /*                                     opt  */
-   OPCODE_ENDLOOP,   /*                                     opt  */
-   OPCODE_ENDSUB,    /*                                     opt  */
-   OPCODE_EX2,       /*   X        X       2       X         X   */
-   OPCODE_EXP,       /*   X                X                 X   */
-   OPCODE_FLR,       /*   X        X       2       X         X   */
-   OPCODE_FRC,       /*   X        X       2       X         X   */
-   OPCODE_IF,        /*                                     opt  */
-   OPCODE_KIL,       /*            X                             */
-   OPCODE_KIL_NV,    /*                            X         X   */
-   OPCODE_LG2,       /*   X        X       2       X         X   */
-   OPCODE_LIT,       /*   X        X       X       X             */
-   OPCODE_LOG,       /*   X                X                 X   */
-   OPCODE_LRP,       /*            X               X         X   */
-   OPCODE_MAD,       /*   X        X       X       X         X   */
-   OPCODE_MAX,       /*   X        X       X       X         X   */
-   OPCODE_MIN,       /*   X        X       X       X         X   */
-   OPCODE_MOV,       /*   X        X       X       X         X   */
-   OPCODE_MUL,       /*   X        X       X       X         X   */
-   OPCODE_NOISE1,    /*                                      X   */
-   OPCODE_NOISE2,    /*                                      X   */
-   OPCODE_NOISE3,    /*                                      X   */
-   OPCODE_NOISE4,    /*                                      X   */
-   OPCODE_NOT,       /*                                          */
-   OPCODE_NRM3,      /*                                      X   */
-   OPCODE_NRM4,      /*                                      X   */
-   OPCODE_OR,        /*                                          */
-   OPCODE_PK2H,      /*                            X             */
-   OPCODE_PK2US,     /*                            X             */
-   OPCODE_PK4B,      /*                            X             */
-   OPCODE_PK4UB,     /*                            X             */
-   OPCODE_POW,       /*   X        X               X         X   */
-   OPCODE_POPA,      /*                    3                     */
-   OPCODE_PRINT,     /*                    X       X             */
-   OPCODE_PUSHA,     /*                    3                     */
-   OPCODE_RCC,       /*                    1.1                   */
-   OPCODE_RCP,       /*   X        X       X       X         X   */
-   OPCODE_RET,       /*                    2       2         X   */
-   OPCODE_RFL,       /*            X               X             */
-   OPCODE_RSQ,       /*   X        X       X       X         X   */
-   OPCODE_SCS,       /*            X                             */
-   OPCODE_SEQ,       /*                    2       X         X   */
-   OPCODE_SFL,       /*                    2       X             */
-   OPCODE_SGE,       /*   X        X       X       X         X   */
-   OPCODE_SGT,       /*                    2       X         X   */
-   OPCODE_SIN,       /*            X       2       X         X   */
-   OPCODE_SLE,       /*                    2       X         X   */
-   OPCODE_SLT,       /*   X        X       X       X         X   */
-   OPCODE_SNE,       /*                    2       X         X   */
-   OPCODE_SSG,       /*                    2                     */
-   OPCODE_STR,       /*                    2       X             */
-   OPCODE_SUB,       /*   X        X       1.1     X         X   */
-   OPCODE_SWZ,       /*   X        X                             */
-   OPCODE_TEX,       /*            X       3       X         X   */
-   OPCODE_TXB,       /*            X       3                 X   */
-   OPCODE_TXD,       /*                            X         X   */
-   OPCODE_TXL,       /*                    3       2         X   */
-   OPCODE_TXP,       /*            X                         X   */
-   OPCODE_TXP_NV,    /*                    3       X             */
-   OPCODE_TRUNC,     /*                                      X   */
-   OPCODE_UP2H,      /*                            X             */
-   OPCODE_UP2US,     /*                            X             */
-   OPCODE_UP4B,      /*                            X             */
-   OPCODE_UP4UB,     /*                            X             */
-   OPCODE_X2D,       /*                            X             */
-   OPCODE_XOR,       /*                                          */
-   OPCODE_XPD,       /*   X        X                         X   */
-   MAX_OPCODE
-} gl_inst_opcode;
-
-
-/**
- * Number of bits for the src/dst register Index field.
- * This limits the size of temp/uniform register files.
- */
-#define INST_INDEX_BITS 12
-
-
-/**
- * Instruction source register.
- */
-struct prog_src_register
-{
-   GLuint File:4;	/**< One of the PROGRAM_* register file values. */
-   GLint Index:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.
-                                     * May be negative for relative addressing.
-                                     */
-   GLuint Swizzle:12;
-   GLuint RelAddr:1;
-
-   /** Take the component-wise absolute value */
-   GLuint Abs:1;
-
-   /**
-    * Post-Abs negation.
-    * This will either be NEGATE_NONE or NEGATE_XYZW, except for the SWZ
-    * instruction which allows per-component negation.
-    */
-   GLuint Negate:4;
-
-   /**
-    * Is the register two-dimensional.
-    * Two dimensional registers are of the
-    * REGISTER[index][index2] format.
-    * They are used by the geometry shaders where
-    * the first index is the index within an array
-    * and the second index is the semantic of the
-    * array, e.g. gl_PositionIn[index] would become
-    * INPUT[index][gl_PositionIn]
-    */
-   GLuint HasIndex2:1;
-   GLuint RelAddr2:1;
-   GLint Index2:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.
-                                       * May be negative for relative
-                                       * addressing. */
-};
-
-
-/**
- * Instruction destination register.
- */
-struct prog_dst_register
-{
-   GLuint File:4;      /**< One of the PROGRAM_* register file values */
-   GLuint Index:INST_INDEX_BITS;  /**< Unsigned, never negative */
-   GLuint WriteMask:4;
-   GLuint RelAddr:1;
-
-   /**
-    * \name Conditional destination update control.
-    *
-    * \since
-    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
-    * NV_vertex_program2_option.
-    */
-   /*@{*/
-   /**
-    * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT,
-    * NE, TR, or UN).  Dest reg is only written to if the matching
-    * (swizzled) condition code value passes.  When a conditional update mask
-    * is not specified, this will be \c COND_TR.
-    */
-   GLuint CondMask:4;
-
-   /**
-    * Condition code swizzle value.
-    */
-   GLuint CondSwizzle:12;
-
-   /**
-    * Selects the condition code register to use for conditional destination
-    * update masking.  In NV_fragmnet_program or NV_vertex_program2 mode, only
-    * condition code register 0 is available.  In NV_vertex_program3 mode,
-    * condition code registers 0 and 1 are available.
-    */
-   GLuint CondSrc:1;
-   /*@}*/
-};
-
-
-/**
- * Vertex/fragment program instruction.
- */
-struct prog_instruction
-{
-   gl_inst_opcode Opcode;
-   struct prog_src_register SrcReg[3];
-   struct prog_dst_register DstReg;
-
-   /**
-    * Indicates that the instruction should update the condition code
-    * register.
-    *
-    * \since
-    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
-    * NV_vertex_program2_option.
-    */
-   GLuint CondUpdate:1;
-
-   /**
-    * If prog_instruction::CondUpdate is \c GL_TRUE, this value selects the
-    * condition code register that is to be updated.
-    *
-    * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition
-    * code register 0 is available.  In GL_NV_vertex_program3 mode, condition
-    * code registers 0 and 1 are available.
-    *
-    * \since
-    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
-    * NV_vertex_program2_option.
-    */
-   GLuint CondDst:1;
-
-   /**
-    * Saturate each value of the vectored result to the range [0,1] or the
-    * range [-1,1].  \c SSAT mode (i.e., saturation to the range [-1,1]) is
-    * only available in NV_fragment_program2 mode.
-    * Value is one of the SATURATE_* tokens.
-    *
-    * \since
-    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program3.
-    */
-   GLuint SaturateMode:2;
-
-   /**
-    * Per-instruction selectable precision: FLOAT32, FLOAT16, FIXED12.
-    *
-    * \since
-    * NV_fragment_program, NV_fragment_program_option.
-    */
-   GLuint Precision:3;
-
-   /**
-    * \name Extra fields for TEX, TXB, TXD, TXL, TXP instructions.
-    */
-   /*@{*/
-   /** Source texture unit. */
-   GLuint TexSrcUnit:5;
-
-   /** Source texture target, one of TEXTURE_{1D,2D,3D,CUBE,RECT}_INDEX */
-   GLuint TexSrcTarget:3;
-
-   /** True if tex instruction should do shadow comparison */
-   GLuint TexShadow:1;
-   /*@}*/
-
-   /**
-    * For BRA and CAL instructions, the location to jump to.
-    * For BGNLOOP, points to ENDLOOP (and vice-versa).
-    * For BRK, points to ENDLOOP
-    * For IF, points to ELSE or ENDIF.
-    * For ELSE, points to ENDIF.
-    */
-   GLint BranchTarget;
-
-   /** for debugging purposes */
-   const char *Comment;
-
-   /** Arbitrary data.  Used for OPCODE_PRINT and some drivers */
-   void *Data;
-
-   /** for driver use (try to remove someday) */
-   GLint Aux;
-};
-
-
-extern void
-_mesa_init_instructions(struct prog_instruction *inst, GLuint count);
-
-extern struct prog_instruction *
-_mesa_alloc_instructions(GLuint numInst);
-
-extern struct prog_instruction *
-_mesa_realloc_instructions(struct prog_instruction *oldInst,
-                           GLuint numOldInst, GLuint numNewInst);
-
-extern struct prog_instruction *
-_mesa_copy_instructions(struct prog_instruction *dest,
-                        const struct prog_instruction *src, GLuint n);
-
-extern void
-_mesa_free_instructions(struct prog_instruction *inst, GLuint count);
-
-extern GLuint
-_mesa_num_inst_src_regs(gl_inst_opcode opcode);
-
-extern GLuint
-_mesa_num_inst_dst_regs(gl_inst_opcode opcode);
-
-extern GLboolean
-_mesa_is_tex_instruction(gl_inst_opcode opcode);
-
-extern GLboolean
-_mesa_check_soa_dependencies(const struct prog_instruction *inst);
-
-extern const char *
-_mesa_opcode_string(gl_inst_opcode opcode);
-
-
-#endif /* PROG_INSTRUCTION_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+/**

+ * \file prog_instruction.h

+ *

+ * Vertex/fragment program instruction datatypes and constants.

+ *

+ * \author Brian Paul

+ * \author Keith Whitwell

+ * \author Ian Romanick <idr@us.ibm.com>

+ */

+

+

+#ifndef PROG_INSTRUCTION_H

+#define PROG_INSTRUCTION_H

+

+

+#include "main/glheader.h"

+

+

+/**

+ * Swizzle indexes.

+ * Do not change!

+ */

+/*@{*/

+#define SWIZZLE_X    0

+#define SWIZZLE_Y    1

+#define SWIZZLE_Z    2

+#define SWIZZLE_W    3

+#define SWIZZLE_ZERO 4   /**< For SWZ instruction only */

+#define SWIZZLE_ONE  5   /**< For SWZ instruction only */

+#define SWIZZLE_NIL  7   /**< used during shader code gen (undefined value) */

+/*@}*/

+

+#define MAKE_SWIZZLE4(a,b,c,d) (((a)<<0) | ((b)<<3) | ((c)<<6) | ((d)<<9))

+#define SWIZZLE_NOOP           MAKE_SWIZZLE4(0,1,2,3)

+#define GET_SWZ(swz, idx)      (((swz) >> ((idx)*3)) & 0x7)

+#define GET_BIT(msk, idx)      (((msk) >> (idx)) & 0x1)

+

+#define SWIZZLE_XYZW MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W)

+#define SWIZZLE_XXXX MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X)

+#define SWIZZLE_YYYY MAKE_SWIZZLE4(SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y)

+#define SWIZZLE_ZZZZ MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z)

+#define SWIZZLE_WWWW MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)

+

+

+/**

+ * Writemask values, 1 bit per component.

+ */

+/*@{*/

+#define WRITEMASK_X     0x1

+#define WRITEMASK_Y     0x2

+#define WRITEMASK_XY    0x3

+#define WRITEMASK_Z     0x4

+#define WRITEMASK_XZ    0x5

+#define WRITEMASK_YZ    0x6

+#define WRITEMASK_XYZ   0x7

+#define WRITEMASK_W     0x8

+#define WRITEMASK_XW    0x9

+#define WRITEMASK_YW    0xa

+#define WRITEMASK_XYW   0xb

+#define WRITEMASK_ZW    0xc

+#define WRITEMASK_XZW   0xd

+#define WRITEMASK_YZW   0xe

+#define WRITEMASK_XYZW  0xf

+/*@}*/

+

+

+/**

+ * Condition codes

+ */

+/*@{*/

+#define COND_GT  1  /**< greater than zero */

+#define COND_EQ  2  /**< equal to zero */

+#define COND_LT  3  /**< less than zero */

+#define COND_UN  4  /**< unordered (NaN) */

+#define COND_GE  5  /**< greater than or equal to zero */

+#define COND_LE  6  /**< less than or equal to zero */

+#define COND_NE  7  /**< not equal to zero */

+#define COND_TR  8  /**< always true */

+#define COND_FL  9  /**< always false */

+/*@}*/

+

+

+/**

+ * Instruction precision for GL_NV_fragment_program

+ */

+/*@{*/

+#define FLOAT32  0x1

+#define FLOAT16  0x2

+#define FIXED12  0x4

+/*@}*/

+

+

+/**

+ * Saturation modes when storing values.

+ */

+/*@{*/

+#define SATURATE_OFF            0

+#define SATURATE_ZERO_ONE       1

+/*@}*/

+

+

+/**

+ * Per-component negation masks

+ */

+/*@{*/

+#define NEGATE_X    0x1

+#define NEGATE_Y    0x2

+#define NEGATE_Z    0x4

+#define NEGATE_W    0x8

+#define NEGATE_XYZ  0x7

+#define NEGATE_XYZW 0xf

+#define NEGATE_NONE 0x0

+/*@}*/

+

+

+/**

+ * Program instruction opcodes for vertex, fragment and geometry programs.

+ */

+typedef enum prog_opcode {

+                     /* ARB_vp   ARB_fp   NV_vp   NV_fp     GLSL */

+                     /*------------------------------------------*/

+   OPCODE_NOP = 0,   /*                                      X   */

+   OPCODE_ABS,       /*   X        X       1.1               X   */

+   OPCODE_ADD,       /*   X        X       X       X         X   */

+   OPCODE_AND,       /*                                          */

+   OPCODE_ARA,       /*                    2                     */

+   OPCODE_ARL,       /*   X                X                 X   */

+   OPCODE_ARL_NV,    /*                    2                     */

+   OPCODE_ARR,       /*                    2                     */

+   OPCODE_BGNLOOP,   /*                                     opt  */

+   OPCODE_BGNSUB,    /*                                     opt  */

+   OPCODE_BRA,       /*                    2                 X   */

+   OPCODE_BRK,       /*                    2                opt  */

+   OPCODE_CAL,       /*                    2       2         X   */

+   OPCODE_CMP,       /*            X                         X   */

+   OPCODE_CONT,      /*                                     opt  */

+   OPCODE_COS,       /*            X       2       X         X   */

+   OPCODE_DDX,       /*                            X         X   */

+   OPCODE_DDY,       /*                            X         X   */

+   OPCODE_DP2,       /*                            2         X   */

+   OPCODE_DP2A,      /*                            2             */

+   OPCODE_DP3,       /*   X        X       X       X         X   */

+   OPCODE_DP4,       /*   X        X       X       X         X   */

+   OPCODE_DPH,       /*   X        X       1.1                   */

+   OPCODE_DST,       /*   X        X       X       X             */

+   OPCODE_ELSE,      /*                                      X   */

+   OPCODE_EMIT_VERTEX,/*                                     X   */

+   OPCODE_END,       /*   X        X       X       X        opt  */

+   OPCODE_END_PRIMITIVE,/*                                   X   */

+   OPCODE_ENDIF,     /*                                     opt  */

+   OPCODE_ENDLOOP,   /*                                     opt  */

+   OPCODE_ENDSUB,    /*                                     opt  */

+   OPCODE_EX2,       /*   X        X       2       X         X   */

+   OPCODE_EXP,       /*   X                X                 X   */

+   OPCODE_FLR,       /*   X        X       2       X         X   */

+   OPCODE_FRC,       /*   X        X       2       X         X   */

+   OPCODE_IF,        /*                                     opt  */

+   OPCODE_KIL,       /*            X                             */

+   OPCODE_KIL_NV,    /*                            X         X   */

+   OPCODE_LG2,       /*   X        X       2       X         X   */

+   OPCODE_LIT,       /*   X        X       X       X             */

+   OPCODE_LOG,       /*   X                X                 X   */

+   OPCODE_LRP,       /*            X               X         X   */

+   OPCODE_MAD,       /*   X        X       X       X         X   */

+   OPCODE_MAX,       /*   X        X       X       X         X   */

+   OPCODE_MIN,       /*   X        X       X       X         X   */

+   OPCODE_MOV,       /*   X        X       X       X         X   */

+   OPCODE_MUL,       /*   X        X       X       X         X   */

+   OPCODE_NOISE1,    /*                                      X   */

+   OPCODE_NOISE2,    /*                                      X   */

+   OPCODE_NOISE3,    /*                                      X   */

+   OPCODE_NOISE4,    /*                                      X   */

+   OPCODE_NOT,       /*                                          */

+   OPCODE_NRM3,      /*                                      X   */

+   OPCODE_NRM4,      /*                                      X   */

+   OPCODE_OR,        /*                                          */

+   OPCODE_PK2H,      /*                            X             */

+   OPCODE_PK2US,     /*                            X             */

+   OPCODE_PK4B,      /*                            X             */

+   OPCODE_PK4UB,     /*                            X             */

+   OPCODE_POW,       /*   X        X               X         X   */

+   OPCODE_POPA,      /*                    3                     */

+   OPCODE_PRINT,     /*                    X       X             */

+   OPCODE_PUSHA,     /*                    3                     */

+   OPCODE_RCC,       /*                    1.1                   */

+   OPCODE_RCP,       /*   X        X       X       X         X   */

+   OPCODE_RET,       /*                    2       2         X   */

+   OPCODE_RFL,       /*            X               X             */

+   OPCODE_RSQ,       /*   X        X       X       X         X   */

+   OPCODE_SCS,       /*            X                             */

+   OPCODE_SEQ,       /*                    2       X         X   */

+   OPCODE_SFL,       /*                    2       X             */

+   OPCODE_SGE,       /*   X        X       X       X         X   */

+   OPCODE_SGT,       /*                    2       X         X   */

+   OPCODE_SIN,       /*            X       2       X         X   */

+   OPCODE_SLE,       /*                    2       X         X   */

+   OPCODE_SLT,       /*   X        X       X       X         X   */

+   OPCODE_SNE,       /*                    2       X         X   */

+   OPCODE_SSG,       /*                    2                     */

+   OPCODE_STR,       /*                    2       X             */

+   OPCODE_SUB,       /*   X        X       1.1     X         X   */

+   OPCODE_SWZ,       /*   X        X                             */

+   OPCODE_TEX,       /*            X       3       X         X   */

+   OPCODE_TXB,       /*            X       3                 X   */

+   OPCODE_TXD,       /*                            X         X   */

+   OPCODE_TXL,       /*                    3       2         X   */

+   OPCODE_TXP,       /*            X                         X   */

+   OPCODE_TXP_NV,    /*                    3       X             */

+   OPCODE_TRUNC,     /*                                      X   */

+   OPCODE_UP2H,      /*                            X             */

+   OPCODE_UP2US,     /*                            X             */

+   OPCODE_UP4B,      /*                            X             */

+   OPCODE_UP4UB,     /*                            X             */

+   OPCODE_X2D,       /*                            X             */

+   OPCODE_XOR,       /*                                          */

+   OPCODE_XPD,       /*   X        X                         X   */

+   MAX_OPCODE

+} gl_inst_opcode;

+

+

+/**

+ * Number of bits for the src/dst register Index field.

+ * This limits the size of temp/uniform register files.

+ */

+#define INST_INDEX_BITS 12

+

+

+/**

+ * Instruction source register.

+ */

+struct prog_src_register

+{

+   GLuint File:4;	/**< One of the PROGRAM_* register file values. */

+   GLint Index:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.

+                                     * May be negative for relative addressing.

+                                     */

+   GLuint Swizzle:12;

+   GLuint RelAddr:1;

+

+   /** Take the component-wise absolute value */

+   GLuint Abs:1;

+

+   /**

+    * Post-Abs negation.

+    * This will either be NEGATE_NONE or NEGATE_XYZW, except for the SWZ

+    * instruction which allows per-component negation.

+    */

+   GLuint Negate:4;

+

+   /**

+    * Is the register two-dimensional.

+    * Two dimensional registers are of the

+    * REGISTER[index][index2] format.

+    * They are used by the geometry shaders where

+    * the first index is the index within an array

+    * and the second index is the semantic of the

+    * array, e.g. gl_PositionIn[index] would become

+    * INPUT[index][gl_PositionIn]

+    */

+   GLuint HasIndex2:1;

+   GLuint RelAddr2:1;

+   GLint Index2:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.

+                                       * May be negative for relative

+                                       * addressing. */

+};

+

+

+/**

+ * Instruction destination register.

+ */

+struct prog_dst_register

+{

+   GLuint File:4;      /**< One of the PROGRAM_* register file values */

+   GLuint Index:INST_INDEX_BITS;  /**< Unsigned, never negative */

+   GLuint WriteMask:4;

+   GLuint RelAddr:1;

+

+   /**

+    * \name Conditional destination update control.

+    *

+    * \since

+    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,

+    * NV_vertex_program2_option.

+    */

+   /*@{*/

+   /**

+    * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT,

+    * NE, TR, or UN).  Dest reg is only written to if the matching

+    * (swizzled) condition code value passes.  When a conditional update mask

+    * is not specified, this will be \c COND_TR.

+    */

+   GLuint CondMask:4;

+

+   /**

+    * Condition code swizzle value.

+    */

+   GLuint CondSwizzle:12;

+

+   /**

+    * Selects the condition code register to use for conditional destination

+    * update masking.  In NV_fragmnet_program or NV_vertex_program2 mode, only

+    * condition code register 0 is available.  In NV_vertex_program3 mode,

+    * condition code registers 0 and 1 are available.

+    */

+   GLuint CondSrc:1;

+   /*@}*/

+};

+

+

+/**

+ * Vertex/fragment program instruction.

+ */

+struct prog_instruction

+{

+   gl_inst_opcode Opcode;

+   struct prog_src_register SrcReg[3];

+   struct prog_dst_register DstReg;

+

+   /**

+    * Indicates that the instruction should update the condition code

+    * register.

+    *

+    * \since

+    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,

+    * NV_vertex_program2_option.

+    */

+   GLuint CondUpdate:1;

+

+   /**

+    * If prog_instruction::CondUpdate is \c GL_TRUE, this value selects the

+    * condition code register that is to be updated.

+    *

+    * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition

+    * code register 0 is available.  In GL_NV_vertex_program3 mode, condition

+    * code registers 0 and 1 are available.

+    *

+    * \since

+    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,

+    * NV_vertex_program2_option.

+    */

+   GLuint CondDst:1;

+

+   /**

+    * Saturate each value of the vectored result to the range [0,1] or the

+    * range [-1,1].  \c SSAT mode (i.e., saturation to the range [-1,1]) is

+    * only available in NV_fragment_program2 mode.

+    * Value is one of the SATURATE_* tokens.

+    *

+    * \since

+    * NV_fragment_program, NV_fragment_program_option, NV_vertex_program3.

+    */

+   GLuint SaturateMode:2;

+

+   /**

+    * Per-instruction selectable precision: FLOAT32, FLOAT16, FIXED12.

+    *

+    * \since

+    * NV_fragment_program, NV_fragment_program_option.

+    */

+   GLuint Precision:3;

+

+   /**

+    * \name Extra fields for TEX, TXB, TXD, TXL, TXP instructions.

+    */

+   /*@{*/

+   /** Source texture unit. */

+   GLuint TexSrcUnit:5;

+

+   /** Source texture target, one of TEXTURE_{1D,2D,3D,CUBE,RECT}_INDEX */

+   GLuint TexSrcTarget:3;

+

+   /** True if tex instruction should do shadow comparison */

+   GLuint TexShadow:1;

+   /*@}*/

+

+   /**

+    * For BRA and CAL instructions, the location to jump to.

+    * For BGNLOOP, points to ENDLOOP (and vice-versa).

+    * For BRK, points to ENDLOOP

+    * For IF, points to ELSE or ENDIF.

+    * For ELSE, points to ENDIF.

+    */

+   GLint BranchTarget;

+

+   /** for debugging purposes */

+   const char *Comment;

+

+   /** Arbitrary data.  Used for OPCODE_PRINT and some drivers */

+   void *Data;

+

+   /** for driver use (try to remove someday) */

+   GLint Aux;

+};

+

+

+extern void

+_mesa_init_instructions(struct prog_instruction *inst, GLuint count);

+

+extern struct prog_instruction *

+_mesa_alloc_instructions(GLuint numInst);

+

+extern struct prog_instruction *

+_mesa_realloc_instructions(struct prog_instruction *oldInst,

+                           GLuint numOldInst, GLuint numNewInst);

+

+extern struct prog_instruction *

+_mesa_copy_instructions(struct prog_instruction *dest,

+                        const struct prog_instruction *src, GLuint n);

+

+extern void

+_mesa_free_instructions(struct prog_instruction *inst, GLuint count);

+

+extern GLuint

+_mesa_num_inst_src_regs(gl_inst_opcode opcode);

+

+extern GLuint

+_mesa_num_inst_dst_regs(gl_inst_opcode opcode);

+

+extern GLboolean

+_mesa_is_tex_instruction(gl_inst_opcode opcode);

+

+extern GLboolean

+_mesa_check_soa_dependencies(const struct prog_instruction *inst);

+

+extern const char *

+_mesa_opcode_string(gl_inst_opcode opcode);

+

+

+#endif /* PROG_INSTRUCTION_H */

diff --git a/mesalib/src/mesa/program/program.c b/mesalib/src/mesa/program/program.c
index cfdd0da86..6c97787e8 100644
--- a/mesalib/src/mesa/program/program.c
+++ b/mesalib/src/mesa/program/program.c
@@ -1,1077 +1,1077 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file program.c
- * Vertex and fragment program support functions.
- * \author Brian Paul
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "program.h"
-#include "prog_cache.h"
-#include "prog_parameter.h"
-#include "prog_instruction.h"
-
-
-/**
- * A pointer to this dummy program is put into the hash table when
- * glGenPrograms is called.
- */
-struct gl_program _mesa_DummyProgram;
-
-
-/**
- * Init context's vertex/fragment program state
- */
-void
-_mesa_init_program(struct gl_context *ctx)
-{
-   GLuint i;
-
-   /*
-    * If this assertion fails, we need to increase the field
-    * size for register indexes (see INST_INDEX_BITS).
-    */
-   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents / 4
-          <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents / 4
-          <= (1 << INST_INDEX_BITS));
-
-   ASSERT(ctx->Const.VertexProgram.MaxTemps <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxTemps <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));
-
-   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);
-   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);
-
-   ASSERT(ctx->Const.VertexProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));
-
-   /* If this fails, increase prog_instruction::TexSrcUnit size */
-   ASSERT(MAX_TEXTURE_UNITS < (1 << 5));
-
-   /* If this fails, increase prog_instruction::TexSrcTarget size */
-   ASSERT(NUM_TEXTURE_TARGETS < (1 << 3));
-
-   ctx->Program.ErrorPos = -1;
-   ctx->Program.ErrorString = _mesa_strdup("");
-
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   ctx->VertexProgram.Enabled = GL_FALSE;
-#if FEATURE_es2_glsl
-   ctx->VertexProgram.PointSizeEnabled =
-      (ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;
-#else
-   ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
-#endif
-   ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
-                            ctx->Shared->DefaultVertexProgram);
-   assert(ctx->VertexProgram.Current);
-   for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
-      ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
-      ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
-   }
-   ctx->VertexProgram.Cache = _mesa_new_program_cache();
-#endif
-
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   ctx->FragmentProgram.Enabled = GL_FALSE;
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
-                            ctx->Shared->DefaultFragmentProgram);
-   assert(ctx->FragmentProgram.Current);
-   ctx->FragmentProgram.Cache = _mesa_new_program_cache();
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   ctx->GeometryProgram.Enabled = GL_FALSE;
-   /* right now by default we don't have a geometry program */
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,
-                            NULL);
-   ctx->GeometryProgram.Cache = _mesa_new_program_cache();
-#endif
-
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   ctx->ATIFragmentShader.Enabled = GL_FALSE;
-   ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;
-   assert(ctx->ATIFragmentShader.Current);
-   ctx->ATIFragmentShader.Current->RefCount++;
-#endif
-}
-
-
-/**
- * Free a context's vertex/fragment program state
- */
-void
-_mesa_free_program_data(struct gl_context *ctx)
-{
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);
-#endif
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->FragmentProgram.Cache);
-#endif
-#if FEATURE_ARB_geometry_shader4
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->GeometryProgram.Cache);
-#endif
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   if (ctx->ATIFragmentShader.Current) {
-      ctx->ATIFragmentShader.Current->RefCount--;
-      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
-         free(ctx->ATIFragmentShader.Current);
-      }
-   }
-#endif
-   free((void *) ctx->Program.ErrorString);
-}
-
-
-/**
- * Update the default program objects in the given context to reference those
- * specified in the shared state and release those referencing the old
- * shared state.
- */
-void
-_mesa_update_default_objects_program(struct gl_context *ctx)
-{
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
-                            (struct gl_vertex_program *)
-                            ctx->Shared->DefaultVertexProgram);
-   assert(ctx->VertexProgram.Current);
-#endif
-
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
-                            (struct gl_fragment_program *)
-                            ctx->Shared->DefaultFragmentProgram);
-   assert(ctx->FragmentProgram.Current);
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,
-                            (struct gl_geometry_program *)
-                            ctx->Shared->DefaultGeometryProgram);
-#endif
-
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   if (ctx->ATIFragmentShader.Current) {
-      ctx->ATIFragmentShader.Current->RefCount--;
-      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
-         free(ctx->ATIFragmentShader.Current);
-      }
-   }
-   ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;
-   assert(ctx->ATIFragmentShader.Current);
-   ctx->ATIFragmentShader.Current->RefCount++;
-#endif
-}
-
-
-/**
- * Set the vertex/fragment program error state (position and error string).
- * This is generally called from within the parsers.
- */
-void
-_mesa_set_program_error(struct gl_context *ctx, GLint pos, const char *string)
-{
-   ctx->Program.ErrorPos = pos;
-   free((void *) ctx->Program.ErrorString);
-   if (!string)
-      string = "";
-   ctx->Program.ErrorString = _mesa_strdup(string);
-}
-
-
-/**
- * Find the line number and column for 'pos' within 'string'.
- * Return a copy of the line which contains 'pos'.  Free the line with
- * free().
- * \param string  the program string
- * \param pos     the position within the string
- * \param line    returns the line number corresponding to 'pos'.
- * \param col     returns the column number corresponding to 'pos'.
- * \return copy of the line containing 'pos'.
- */
-const GLubyte *
-_mesa_find_line_column(const GLubyte *string, const GLubyte *pos,
-                       GLint *line, GLint *col)
-{
-   const GLubyte *lineStart = string;
-   const GLubyte *p = string;
-   GLubyte *s;
-   int len;
-
-   *line = 1;
-
-   while (p != pos) {
-      if (*p == (GLubyte) '\n') {
-         (*line)++;
-         lineStart = p + 1;
-      }
-      p++;
-   }
-
-   *col = (pos - lineStart) + 1;
-
-   /* return copy of this line */
-   while (*p != 0 && *p != '\n')
-      p++;
-   len = p - lineStart;
-   s = (GLubyte *) malloc(len + 1);
-   memcpy(s, lineStart, len);
-   s[len] = 0;
-
-   return s;
-}
-
-
-/**
- * Initialize a new vertex/fragment program object.
- */
-static struct gl_program *
-_mesa_init_program_struct( struct gl_context *ctx, struct gl_program *prog,
-                           GLenum target, GLuint id)
-{
-   (void) ctx;
-   if (prog) {
-      GLuint i;
-      memset(prog, 0, sizeof(*prog));
-      prog->Id = id;
-      prog->Target = target;
-      prog->Resident = GL_TRUE;
-      prog->RefCount = 1;
-      prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;
-
-      /* default mapping from samplers to texture units */
-      for (i = 0; i < MAX_SAMPLERS; i++)
-         prog->SamplerUnits[i] = i;
-   }
-
-   return prog;
-}
-
-
-/**
- * Initialize a new fragment program object.
- */
-struct gl_program *
-_mesa_init_fragment_program( struct gl_context *ctx, struct gl_fragment_program *prog,
-                             GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Initialize a new vertex program object.
- */
-struct gl_program *
-_mesa_init_vertex_program( struct gl_context *ctx, struct gl_vertex_program *prog,
-                           GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Initialize a new geometry program object.
- */
-struct gl_program *
-_mesa_init_geometry_program( struct gl_context *ctx, struct gl_geometry_program *prog,
-                             GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Allocate and initialize a new fragment/vertex program object but
- * don't put it into the program hash table.  Called via
- * ctx->Driver.NewProgram.  May be overridden (ie. replaced) by a
- * device driver function to implement OO deriviation with additional
- * types not understood by this function.
- *
- * \param ctx  context
- * \param id   program id/number
- * \param target  program target/type
- * \return  pointer to new program object
- */
-struct gl_program *
-_mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id)
-{
-   struct gl_program *prog;
-   switch (target) {
-   case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */
-   case GL_VERTEX_STATE_PROGRAM_NV:
-      prog = _mesa_init_vertex_program(ctx, CALLOC_STRUCT(gl_vertex_program),
-                                       target, id );
-      break;
-   case GL_FRAGMENT_PROGRAM_NV:
-   case GL_FRAGMENT_PROGRAM_ARB:
-      prog =_mesa_init_fragment_program(ctx,
-                                         CALLOC_STRUCT(gl_fragment_program),
-                                         target, id );
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      prog = _mesa_init_geometry_program(ctx,
-                                         CALLOC_STRUCT(gl_geometry_program),
-                                         target, id);
-      break;
-   default:
-      _mesa_problem(ctx, "bad target in _mesa_new_program");
-      prog = NULL;
-   }
-   return prog;
-}
-
-
-/**
- * Delete a program and remove it from the hash table, ignoring the
- * reference count.
- * Called via ctx->Driver.DeleteProgram.  May be wrapped (OO deriviation)
- * by a device driver function.
- */
-void
-_mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)
-{
-   (void) ctx;
-   ASSERT(prog);
-   ASSERT(prog->RefCount==0);
-
-   if (prog == &_mesa_DummyProgram)
-      return;
-
-   if (prog->String)
-      free(prog->String);
-
-   _mesa_free_instructions(prog->Instructions, prog->NumInstructions);
-
-   if (prog->Parameters) {
-      _mesa_free_parameter_list(prog->Parameters);
-   }
-   if (prog->Varying) {
-      _mesa_free_parameter_list(prog->Varying);
-   }
-   if (prog->Attributes) {
-      _mesa_free_parameter_list(prog->Attributes);
-   }
-
-   free(prog);
-}
-
-
-/**
- * Return the gl_program object for a given ID.
- * Basically just a wrapper for _mesa_HashLookup() to avoid a lot of
- * casts elsewhere.
- */
-struct gl_program *
-_mesa_lookup_program(struct gl_context *ctx, GLuint id)
-{
-   if (id)
-      return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);
-   else
-      return NULL;
-}
-
-
-/**
- * Reference counting for vertex/fragment programs
- */
-void
-_mesa_reference_program(struct gl_context *ctx,
-                        struct gl_program **ptr,
-                        struct gl_program *prog)
-{
-   assert(ptr);
-   if (*ptr && prog) {
-      /* sanity check */
-      if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)
-         ASSERT(prog->Target == GL_VERTEX_PROGRAM_ARB);
-      else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)
-         ASSERT(prog->Target == GL_FRAGMENT_PROGRAM_ARB ||
-                prog->Target == GL_FRAGMENT_PROGRAM_NV);
-      else if ((*ptr)->Target == MESA_GEOMETRY_PROGRAM)
-         ASSERT(prog->Target == MESA_GEOMETRY_PROGRAM);
-   }
-   if (*ptr == prog) {
-      return;  /* no change */
-   }
-   if (*ptr) {
-      GLboolean deleteFlag;
-
-      /*_glthread_LOCK_MUTEX((*ptr)->Mutex);*/
-#if 0
-      printf("Program %p ID=%u Target=%s  Refcount-- to %d\n",
-             *ptr, (*ptr)->Id,
-             ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :
-              ((*ptr)->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),
-             (*ptr)->RefCount - 1);
-#endif
-      ASSERT((*ptr)->RefCount > 0);
-      (*ptr)->RefCount--;
-
-      deleteFlag = ((*ptr)->RefCount == 0);
-      /*_glthread_UNLOCK_MUTEX((*ptr)->Mutex);*/
-
-      if (deleteFlag) {
-         ASSERT(ctx);
-         ctx->Driver.DeleteProgram(ctx, *ptr);
-      }
-
-      *ptr = NULL;
-   }
-
-   assert(!*ptr);
-   if (prog) {
-      /*_glthread_LOCK_MUTEX(prog->Mutex);*/
-      prog->RefCount++;
-#if 0
-      printf("Program %p ID=%u Target=%s  Refcount++ to %d\n",
-             prog, prog->Id,
-             (prog->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :
-              (prog->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),
-             prog->RefCount);
-#endif
-      /*_glthread_UNLOCK_MUTEX(prog->Mutex);*/
-   }
-
-   *ptr = prog;
-}
-
-
-/**
- * Return a copy of a program.
- * XXX Problem here if the program object is actually OO-derivation
- * made by a device driver.
- */
-struct gl_program *
-_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog)
-{
-   struct gl_program *clone;
-
-   clone = ctx->Driver.NewProgram(ctx, prog->Target, prog->Id);
-   if (!clone)
-      return NULL;
-
-   assert(clone->Target == prog->Target);
-   assert(clone->RefCount == 1);
-
-   clone->String = (GLubyte *) _mesa_strdup((char *) prog->String);
-   clone->Format = prog->Format;
-   clone->Instructions = _mesa_alloc_instructions(prog->NumInstructions);
-   if (!clone->Instructions) {
-      _mesa_reference_program(ctx, &clone, NULL);
-      return NULL;
-   }
-   _mesa_copy_instructions(clone->Instructions, prog->Instructions,
-                           prog->NumInstructions);
-   clone->InputsRead = prog->InputsRead;
-   clone->OutputsWritten = prog->OutputsWritten;
-   clone->SamplersUsed = prog->SamplersUsed;
-   clone->ShadowSamplers = prog->ShadowSamplers;
-   memcpy(clone->TexturesUsed, prog->TexturesUsed, sizeof(prog->TexturesUsed));
-
-   if (prog->Parameters)
-      clone->Parameters = _mesa_clone_parameter_list(prog->Parameters);
-   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
-   if (prog->Varying)
-      clone->Varying = _mesa_clone_parameter_list(prog->Varying);
-   if (prog->Attributes)
-      clone->Attributes = _mesa_clone_parameter_list(prog->Attributes);
-   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
-   clone->IndirectRegisterFiles = prog->IndirectRegisterFiles;
-   clone->NumInstructions = prog->NumInstructions;
-   clone->NumTemporaries = prog->NumTemporaries;
-   clone->NumParameters = prog->NumParameters;
-   clone->NumAttributes = prog->NumAttributes;
-   clone->NumAddressRegs = prog->NumAddressRegs;
-   clone->NumNativeInstructions = prog->NumNativeInstructions;
-   clone->NumNativeTemporaries = prog->NumNativeTemporaries;
-   clone->NumNativeParameters = prog->NumNativeParameters;
-   clone->NumNativeAttributes = prog->NumNativeAttributes;
-   clone->NumNativeAddressRegs = prog->NumNativeAddressRegs;
-   clone->NumAluInstructions = prog->NumAluInstructions;
-   clone->NumTexInstructions = prog->NumTexInstructions;
-   clone->NumTexIndirections = prog->NumTexIndirections;
-   clone->NumNativeAluInstructions = prog->NumNativeAluInstructions;
-   clone->NumNativeTexInstructions = prog->NumNativeTexInstructions;
-   clone->NumNativeTexIndirections = prog->NumNativeTexIndirections;
-
-   switch (prog->Target) {
-   case GL_VERTEX_PROGRAM_ARB:
-      {
-         const struct gl_vertex_program *vp
-            = (const struct gl_vertex_program *) prog;
-         struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone;
-         vpc->IsPositionInvariant = vp->IsPositionInvariant;
-         vpc->IsNVProgram = vp->IsNVProgram;
-      }
-      break;
-   case GL_FRAGMENT_PROGRAM_ARB:
-      {
-         const struct gl_fragment_program *fp
-            = (const struct gl_fragment_program *) prog;
-         struct gl_fragment_program *fpc = (struct gl_fragment_program *) clone;
-         fpc->FogOption = fp->FogOption;
-         fpc->UsesKill = fp->UsesKill;
-         fpc->OriginUpperLeft = fp->OriginUpperLeft;
-         fpc->PixelCenterInteger = fp->PixelCenterInteger;
-      }
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      {
-         const struct gl_geometry_program *gp
-            = (const struct gl_geometry_program *) prog;
-         struct gl_geometry_program *gpc = (struct gl_geometry_program *) clone;
-         gpc->VerticesOut = gp->VerticesOut;
-         gpc->InputType = gp->InputType;
-         gpc->OutputType = gp->OutputType;
-      }
-      break;
-   default:
-      _mesa_problem(NULL, "Unexpected target in _mesa_clone_program");
-   }
-
-   return clone;
-}
-
-
-/**
- * Insert 'count' NOP instructions at 'start' in the given program.
- * Adjust branch targets accordingly.
- */
-GLboolean
-_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
-{
-   const GLuint origLen = prog->NumInstructions;
-   const GLuint newLen = origLen + count;
-   struct prog_instruction *newInst;
-   GLuint i;
-
-   /* adjust branches */
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      if (inst->BranchTarget > 0) {
-         if ((GLuint)inst->BranchTarget >= start) {
-            inst->BranchTarget += count;
-         }
-      }
-   }
-
-   /* Alloc storage for new instructions */
-   newInst = _mesa_alloc_instructions(newLen);
-   if (!newInst) {
-      return GL_FALSE;
-   }
-
-   /* Copy 'start' instructions into new instruction buffer */
-   _mesa_copy_instructions(newInst, prog->Instructions, start);
-
-   /* init the new instructions */
-   _mesa_init_instructions(newInst + start, count);
-
-   /* Copy the remaining/tail instructions to new inst buffer */
-   _mesa_copy_instructions(newInst + start + count,
-                           prog->Instructions + start,
-                           origLen - start);
-
-   /* free old instructions */
-   _mesa_free_instructions(prog->Instructions, origLen);
-
-   /* install new instructions */
-   prog->Instructions = newInst;
-   prog->NumInstructions = newLen;
-
-   return GL_TRUE;
-}
-
-/**
- * Delete 'count' instructions at 'start' in the given program.
- * Adjust branch targets accordingly.
- */
-GLboolean
-_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)
-{
-   const GLuint origLen = prog->NumInstructions;
-   const GLuint newLen = origLen - count;
-   struct prog_instruction *newInst;
-   GLuint i;
-
-   /* adjust branches */
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      if (inst->BranchTarget > 0) {
-         if (inst->BranchTarget > (GLint) start) {
-            inst->BranchTarget -= count;
-         }
-      }
-   }
-
-   /* Alloc storage for new instructions */
-   newInst = _mesa_alloc_instructions(newLen);
-   if (!newInst) {
-      return GL_FALSE;
-   }
-
-   /* Copy 'start' instructions into new instruction buffer */
-   _mesa_copy_instructions(newInst, prog->Instructions, start);
-
-   /* Copy the remaining/tail instructions to new inst buffer */
-   _mesa_copy_instructions(newInst + start,
-                           prog->Instructions + start + count,
-                           newLen - start);
-
-   /* free old instructions */
-   _mesa_free_instructions(prog->Instructions, origLen);
-
-   /* install new instructions */
-   prog->Instructions = newInst;
-   prog->NumInstructions = newLen;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Search instructions for registers that match (oldFile, oldIndex),
- * replacing them with (newFile, newIndex).
- */
-static void
-replace_registers(struct prog_instruction *inst, GLuint numInst,
-                  GLuint oldFile, GLuint oldIndex,
-                  GLuint newFile, GLuint newIndex)
-{
-   GLuint i, j;
-   for (i = 0; i < numInst; i++) {
-      /* src regs */
-      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
-         if (inst[i].SrcReg[j].File == oldFile &&
-             inst[i].SrcReg[j].Index == oldIndex) {
-            inst[i].SrcReg[j].File = newFile;
-            inst[i].SrcReg[j].Index = newIndex;
-         }
-      }
-      /* dst reg */
-      if (inst[i].DstReg.File == oldFile && inst[i].DstReg.Index == oldIndex) {
-         inst[i].DstReg.File = newFile;
-         inst[i].DstReg.Index = newIndex;
-      }
-   }
-}
-
-
-/**
- * Search instructions for references to program parameters.  When found,
- * increment the parameter index by 'offset'.
- * Used when combining programs.
- */
-static void
-adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,
-                     GLuint offset)
-{
-   GLuint i, j;
-   for (i = 0; i < numInst; i++) {
-      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
-         GLuint f = inst[i].SrcReg[j].File;
-         if (f == PROGRAM_CONSTANT ||
-             f == PROGRAM_UNIFORM ||
-             f == PROGRAM_STATE_VAR) {
-            inst[i].SrcReg[j].Index += offset;
-         }
-      }
-   }
-}
-
-
-/**
- * Combine two programs into one.  Fix instructions so the outputs of
- * the first program go to the inputs of the second program.
- */
-struct gl_program *
-_mesa_combine_programs(struct gl_context *ctx,
-                       const struct gl_program *progA,
-                       const struct gl_program *progB)
-{
-   struct prog_instruction *newInst;
-   struct gl_program *newProg;
-   const GLuint lenA = progA->NumInstructions - 1; /* omit END instr */
-   const GLuint lenB = progB->NumInstructions;
-   const GLuint numParamsA = _mesa_num_parameters(progA->Parameters);
-   const GLuint newLength = lenA + lenB;
-   GLboolean usedTemps[MAX_PROGRAM_TEMPS];
-   GLuint firstTemp = 0;
-   GLbitfield inputsB;
-   GLuint i;
-
-   ASSERT(progA->Target == progB->Target);
-
-   newInst = _mesa_alloc_instructions(newLength);
-   if (!newInst)
-      return GL_FALSE;
-
-   _mesa_copy_instructions(newInst, progA->Instructions, lenA);
-   _mesa_copy_instructions(newInst + lenA, progB->Instructions, lenB);
-
-   /* adjust branch / instruction addresses for B's instructions */
-   for (i = 0; i < lenB; i++) {
-      newInst[lenA + i].BranchTarget += lenA;
-   }
-
-   newProg = ctx->Driver.NewProgram(ctx, progA->Target, 0);
-   newProg->Instructions = newInst;
-   newProg->NumInstructions = newLength;
-
-   /* find used temp regs (we may need new temps below) */
-   _mesa_find_used_registers(newProg, PROGRAM_TEMPORARY,
-                             usedTemps, MAX_PROGRAM_TEMPS);
-
-   if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) {
-      struct gl_fragment_program *fprogA, *fprogB, *newFprog;
-      GLbitfield progB_inputsRead = progB->InputsRead;
-      GLint progB_colorFile, progB_colorIndex;
-
-      fprogA = (struct gl_fragment_program *) progA;
-      fprogB = (struct gl_fragment_program *) progB;
-      newFprog = (struct gl_fragment_program *) newProg;
-
-      newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill;
-
-      /* We'll do a search and replace for instances
-       * of progB_colorFile/progB_colorIndex below...
-       */
-      progB_colorFile = PROGRAM_INPUT;
-      progB_colorIndex = FRAG_ATTRIB_COL0;
-
-      /*
-       * The fragment program may get color from a state var rather than
-       * a fragment input (vertex output) if it's constant.
-       * See the texenvprogram.c code.
-       * So, search the program's parameter list now to see if the program
-       * gets color from a state var instead of a conventional fragment
-       * input register.
-       */
-      for (i = 0; i < progB->Parameters->NumParameters; i++) {
-         struct gl_program_parameter *p = &progB->Parameters->Parameters[i];
-         if (p->Type == PROGRAM_STATE_VAR &&
-             p->StateIndexes[0] == STATE_INTERNAL &&
-             p->StateIndexes[1] == STATE_CURRENT_ATTRIB &&
-             (int) p->StateIndexes[2] == (int) VERT_ATTRIB_COLOR0) {
-            progB_inputsRead |= FRAG_BIT_COL0;
-            progB_colorFile = PROGRAM_STATE_VAR;
-            progB_colorIndex = i;
-            break;
-         }
-      }
-
-      /* Connect color outputs of fprogA to color inputs of fprogB, via a
-       * new temporary register.
-       */
-      if ((progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) &&
-          (progB_inputsRead & FRAG_BIT_COL0)) {
-         GLint tempReg = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS,
-                                                  firstTemp);
-         if (tempReg < 0) {
-            _mesa_problem(ctx, "No free temp regs found in "
-                          "_mesa_combine_programs(), using 31");
-            tempReg = 31;
-         }
-         firstTemp = tempReg + 1;
-
-         /* replace writes to result.color[0] with tempReg */
-         replace_registers(newInst, lenA,
-                           PROGRAM_OUTPUT, FRAG_RESULT_COLOR,
-                           PROGRAM_TEMPORARY, tempReg);
-         /* replace reads from the input color with tempReg */
-         replace_registers(newInst + lenA, lenB,
-                           progB_colorFile, progB_colorIndex, /* search for */
-                           PROGRAM_TEMPORARY, tempReg  /* replace with */ );
-      }
-
-      /* compute combined program's InputsRead */
-      inputsB = progB_inputsRead;
-      if (progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) {
-         inputsB &= ~(1 << FRAG_ATTRIB_COL0);
-      }
-      newProg->InputsRead = progA->InputsRead | inputsB;
-      newProg->OutputsWritten = progB->OutputsWritten;
-      newProg->SamplersUsed = progA->SamplersUsed | progB->SamplersUsed;
-   }
-   else {
-      /* vertex program */
-      assert(0);      /* XXX todo */
-   }
-
-   /*
-    * Merge parameters (uniforms, constants, etc)
-    */
-   newProg->Parameters = _mesa_combine_parameter_lists(progA->Parameters,
-                                                       progB->Parameters);
-
-   adjust_param_indexes(newInst + lenA, lenB, numParamsA);
-
-
-   return newProg;
-}
-
-
-/**
- * Populate the 'used' array with flags indicating which registers (TEMPs,
- * INPUTs, OUTPUTs, etc, are used by the given program.
- * \param file  type of register to scan for
- * \param used  returns true/false flags for in use / free
- * \param usedSize  size of the 'used' array
- */
-void
-_mesa_find_used_registers(const struct gl_program *prog,
-                          gl_register_file file,
-                          GLboolean used[], GLuint usedSize)
-{
-   GLuint i, j;
-
-   memset(used, 0, usedSize);
-
-   for (i = 0; i < prog->NumInstructions; i++) {
-      const struct prog_instruction *inst = prog->Instructions + i;
-      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);
-
-      if (inst->DstReg.File == file) {
-         ASSERT(inst->DstReg.Index < usedSize);
-         if(inst->DstReg.Index < usedSize)
-            used[inst->DstReg.Index] = GL_TRUE;
-      }
-
-      for (j = 0; j < n; j++) {
-         if (inst->SrcReg[j].File == file) {
-            ASSERT(inst->SrcReg[j].Index < usedSize);
-            if(inst->SrcReg[j].Index < usedSize)
-               used[inst->SrcReg[j].Index] = GL_TRUE;
-         }
-      }
-   }
-}
-
-
-/**
- * Scan the given 'used' register flag array for the first entry
- * that's >= firstReg.
- * \param used  vector of flags indicating registers in use (as returned
- *              by _mesa_find_used_registers())
- * \param usedSize  size of the 'used' array
- * \param firstReg  first register to start searching at
- * \return index of unused register, or -1 if none.
- */
-GLint
-_mesa_find_free_register(const GLboolean used[],
-                         GLuint usedSize, GLuint firstReg)
-{
-   GLuint i;
-
-   assert(firstReg < usedSize);
-
-   for (i = firstReg; i < usedSize; i++)
-      if (!used[i])
-         return i;
-
-   return -1;
-}
-
-
-
-/**
- * Check if the given register index is valid (doesn't exceed implementation-
- * dependent limits).
- * \return GL_TRUE if OK, GL_FALSE if bad index
- */
-GLboolean
-_mesa_valid_register_index(const struct gl_context *ctx,
-                           gl_shader_type shaderType,
-                           gl_register_file file, GLint index)
-{
-   const struct gl_program_constants *c;
-
-   switch (shaderType) {
-   case MESA_SHADER_VERTEX:
-      c = &ctx->Const.VertexProgram;
-      break;
-   case MESA_SHADER_FRAGMENT:
-      c = &ctx->Const.FragmentProgram;
-      break;
-   case MESA_SHADER_GEOMETRY:
-      c = &ctx->Const.GeometryProgram;
-      break;
-   default:
-      _mesa_problem(ctx,
-                    "unexpected shader type in _mesa_valid_register_index()");
-      return GL_FALSE;
-   }
-
-   switch (file) {
-   case PROGRAM_UNDEFINED:
-      return GL_TRUE;  /* XXX or maybe false? */
-
-   case PROGRAM_TEMPORARY:
-      return index >= 0 && index < c->MaxTemps;
-
-   case PROGRAM_ENV_PARAM:
-      return index >= 0 && index < c->MaxEnvParams;
-
-   case PROGRAM_LOCAL_PARAM:
-      return index >= 0 && index < c->MaxLocalParams;
-
-   case PROGRAM_NAMED_PARAM:
-      return index >= 0 && index < c->MaxParameters;
-
-   case PROGRAM_UNIFORM:
-   case PROGRAM_STATE_VAR:
-      /* aka constant buffer */
-      return index >= 0 && index < c->MaxUniformComponents / 4;
-
-   case PROGRAM_CONSTANT:
-      /* constant buffer w/ possible relative negative addressing */
-      return (index > (int) c->MaxUniformComponents / -4 &&
-              index < c->MaxUniformComponents / 4);
-
-   case PROGRAM_INPUT:
-      if (index < 0)
-         return GL_FALSE;
-
-      switch (shaderType) {
-      case MESA_SHADER_VERTEX:
-         return index < VERT_ATTRIB_GENERIC0 + c->MaxAttribs;
-      case MESA_SHADER_FRAGMENT:
-         return index < FRAG_ATTRIB_VAR0 + ctx->Const.MaxVarying;
-      case MESA_SHADER_GEOMETRY:
-         return index < GEOM_ATTRIB_VAR0 + ctx->Const.MaxVarying;
-      default:
-         return GL_FALSE;
-      }
-
-   case PROGRAM_OUTPUT:
-      if (index < 0)
-         return GL_FALSE;
-
-      switch (shaderType) {
-      case MESA_SHADER_VERTEX:
-         return index < VERT_RESULT_VAR0 + ctx->Const.MaxVarying;
-      case MESA_SHADER_FRAGMENT:
-         return index < FRAG_RESULT_DATA0 + ctx->Const.MaxDrawBuffers;
-      case MESA_SHADER_GEOMETRY:
-         return index < GEOM_RESULT_VAR0 + ctx->Const.MaxVarying;
-      default:
-         return GL_FALSE;
-      }
-
-   case PROGRAM_ADDRESS:
-      return index >= 0 && index < c->MaxAddressRegs;
-
-   default:
-      _mesa_problem(ctx,
-                    "unexpected register file in _mesa_valid_register_index()");
-      return GL_FALSE;
-   }
-}
-
-
-
-/**
- * "Post-process" a GPU program.  This is intended to be used for debugging.
- * Example actions include no-op'ing instructions or changing instruction
- * behaviour.
- */
-void
-_mesa_postprocess_program(struct gl_context *ctx, struct gl_program *prog)
-{
-   static const GLfloat white[4] = { 0.5, 0.5, 0.5, 0.5 };
-   GLuint i;
-   GLuint whiteSwizzle;
-   GLint whiteIndex = _mesa_add_unnamed_constant(prog->Parameters,
-                                                 white, 4, &whiteSwizzle);
-
-   (void) whiteIndex;
-
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);
-
-      (void) n;
-
-      if (_mesa_is_tex_instruction(inst->Opcode)) {
-#if 0
-         /* replace TEX/TXP/TXB with MOV */
-         inst->Opcode = OPCODE_MOV;
-         inst->DstReg.WriteMask = WRITEMASK_XYZW;
-         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;
-         inst->SrcReg[0].Negate = NEGATE_NONE;
-#endif
-
-#if 0
-         /* disable shadow texture mode */
-         inst->TexShadow = 0;
-#endif
-      }
-
-      if (inst->Opcode == OPCODE_TXP) {
-#if 0
-         inst->Opcode = OPCODE_MOV;
-         inst->DstReg.WriteMask = WRITEMASK_XYZW;
-         inst->SrcReg[0].File = PROGRAM_CONSTANT;
-         inst->SrcReg[0].Index = whiteIndex;
-         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;
-         inst->SrcReg[0].Negate = NEGATE_NONE;
-#endif
-#if 0
-         inst->TexShadow = 0;
-#endif
-#if 0
-         inst->Opcode = OPCODE_TEX;
-         inst->TexShadow = 0;
-#endif
-      }
-
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file program.c

+ * Vertex and fragment program support functions.

+ * \author Brian Paul

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "program.h"

+#include "prog_cache.h"

+#include "prog_parameter.h"

+#include "prog_instruction.h"

+

+

+/**

+ * A pointer to this dummy program is put into the hash table when

+ * glGenPrograms is called.

+ */

+struct gl_program _mesa_DummyProgram;

+

+

+/**

+ * Init context's vertex/fragment program state

+ */

+void

+_mesa_init_program(struct gl_context *ctx)

+{

+   GLuint i;

+

+   /*

+    * If this assertion fails, we need to increase the field

+    * size for register indexes (see INST_INDEX_BITS).

+    */

+   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents / 4

+          <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents / 4

+          <= (1 << INST_INDEX_BITS));

+

+   ASSERT(ctx->Const.VertexProgram.MaxTemps <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxTemps <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));

+

+   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);

+   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);

+

+   ASSERT(ctx->Const.VertexProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));

+

+   /* If this fails, increase prog_instruction::TexSrcUnit size */

+   ASSERT(MAX_TEXTURE_UNITS < (1 << 5));

+

+   /* If this fails, increase prog_instruction::TexSrcTarget size */

+   ASSERT(NUM_TEXTURE_TARGETS < (1 << 3));

+

+   ctx->Program.ErrorPos = -1;

+   ctx->Program.ErrorString = _mesa_strdup("");

+

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   ctx->VertexProgram.Enabled = GL_FALSE;

+#if FEATURE_es2_glsl

+   ctx->VertexProgram.PointSizeEnabled =

+      (ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;

+#else

+   ctx->VertexProgram.PointSizeEnabled = GL_FALSE;

+#endif

+   ctx->VertexProgram.TwoSideEnabled = GL_FALSE;

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,

+                            ctx->Shared->DefaultVertexProgram);

+   assert(ctx->VertexProgram.Current);

+   for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {

+      ctx->VertexProgram.TrackMatrix[i] = GL_NONE;

+      ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;

+   }

+   ctx->VertexProgram.Cache = _mesa_new_program_cache();

+#endif

+

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   ctx->FragmentProgram.Enabled = GL_FALSE;

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,

+                            ctx->Shared->DefaultFragmentProgram);

+   assert(ctx->FragmentProgram.Current);

+   ctx->FragmentProgram.Cache = _mesa_new_program_cache();

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   ctx->GeometryProgram.Enabled = GL_FALSE;

+   /* right now by default we don't have a geometry program */

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,

+                            NULL);

+   ctx->GeometryProgram.Cache = _mesa_new_program_cache();

+#endif

+

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   ctx->ATIFragmentShader.Enabled = GL_FALSE;

+   ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;

+   assert(ctx->ATIFragmentShader.Current);

+   ctx->ATIFragmentShader.Current->RefCount++;

+#endif

+}

+

+

+/**

+ * Free a context's vertex/fragment program state

+ */

+void

+_mesa_free_program_data(struct gl_context *ctx)

+{

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);

+   _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);

+#endif

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);

+   _mesa_delete_program_cache(ctx, ctx->FragmentProgram.Cache);

+#endif

+#if FEATURE_ARB_geometry_shader4

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);

+   _mesa_delete_program_cache(ctx, ctx->GeometryProgram.Cache);

+#endif

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   if (ctx->ATIFragmentShader.Current) {

+      ctx->ATIFragmentShader.Current->RefCount--;

+      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {

+         free(ctx->ATIFragmentShader.Current);

+      }

+   }

+#endif

+   free((void *) ctx->Program.ErrorString);

+}

+

+

+/**

+ * Update the default program objects in the given context to reference those

+ * specified in the shared state and release those referencing the old

+ * shared state.

+ */

+void

+_mesa_update_default_objects_program(struct gl_context *ctx)

+{

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,

+                            (struct gl_vertex_program *)

+                            ctx->Shared->DefaultVertexProgram);

+   assert(ctx->VertexProgram.Current);

+#endif

+

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,

+                            (struct gl_fragment_program *)

+                            ctx->Shared->DefaultFragmentProgram);

+   assert(ctx->FragmentProgram.Current);

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,

+                            (struct gl_geometry_program *)

+                            ctx->Shared->DefaultGeometryProgram);

+#endif

+

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   if (ctx->ATIFragmentShader.Current) {

+      ctx->ATIFragmentShader.Current->RefCount--;

+      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {

+         free(ctx->ATIFragmentShader.Current);

+      }

+   }

+   ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;

+   assert(ctx->ATIFragmentShader.Current);

+   ctx->ATIFragmentShader.Current->RefCount++;

+#endif

+}

+

+

+/**

+ * Set the vertex/fragment program error state (position and error string).

+ * This is generally called from within the parsers.

+ */

+void

+_mesa_set_program_error(struct gl_context *ctx, GLint pos, const char *string)

+{

+   ctx->Program.ErrorPos = pos;

+   free((void *) ctx->Program.ErrorString);

+   if (!string)

+      string = "";

+   ctx->Program.ErrorString = _mesa_strdup(string);

+}

+

+

+/**

+ * Find the line number and column for 'pos' within 'string'.

+ * Return a copy of the line which contains 'pos'.  Free the line with

+ * free().

+ * \param string  the program string

+ * \param pos     the position within the string

+ * \param line    returns the line number corresponding to 'pos'.

+ * \param col     returns the column number corresponding to 'pos'.

+ * \return copy of the line containing 'pos'.

+ */

+const GLubyte *

+_mesa_find_line_column(const GLubyte *string, const GLubyte *pos,

+                       GLint *line, GLint *col)

+{

+   const GLubyte *lineStart = string;

+   const GLubyte *p = string;

+   GLubyte *s;

+   int len;

+

+   *line = 1;

+

+   while (p != pos) {

+      if (*p == (GLubyte) '\n') {

+         (*line)++;

+         lineStart = p + 1;

+      }

+      p++;

+   }

+

+   *col = (pos - lineStart) + 1;

+

+   /* return copy of this line */

+   while (*p != 0 && *p != '\n')

+      p++;

+   len = p - lineStart;

+   s = (GLubyte *) malloc(len + 1);

+   memcpy(s, lineStart, len);

+   s[len] = 0;

+

+   return s;

+}

+

+

+/**

+ * Initialize a new vertex/fragment program object.

+ */

+static struct gl_program *

+_mesa_init_program_struct( struct gl_context *ctx, struct gl_program *prog,

+                           GLenum target, GLuint id)

+{

+   (void) ctx;

+   if (prog) {

+      GLuint i;

+      memset(prog, 0, sizeof(*prog));

+      prog->Id = id;

+      prog->Target = target;

+      prog->Resident = GL_TRUE;

+      prog->RefCount = 1;

+      prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;

+

+      /* default mapping from samplers to texture units */

+      for (i = 0; i < MAX_SAMPLERS; i++)

+         prog->SamplerUnits[i] = i;

+   }

+

+   return prog;

+}

+

+

+/**

+ * Initialize a new fragment program object.

+ */

+struct gl_program *

+_mesa_init_fragment_program( struct gl_context *ctx, struct gl_fragment_program *prog,

+                             GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Initialize a new vertex program object.

+ */

+struct gl_program *

+_mesa_init_vertex_program( struct gl_context *ctx, struct gl_vertex_program *prog,

+                           GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Initialize a new geometry program object.

+ */

+struct gl_program *

+_mesa_init_geometry_program( struct gl_context *ctx, struct gl_geometry_program *prog,

+                             GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Allocate and initialize a new fragment/vertex program object but

+ * don't put it into the program hash table.  Called via

+ * ctx->Driver.NewProgram.  May be overridden (ie. replaced) by a

+ * device driver function to implement OO deriviation with additional

+ * types not understood by this function.

+ *

+ * \param ctx  context

+ * \param id   program id/number

+ * \param target  program target/type

+ * \return  pointer to new program object

+ */

+struct gl_program *

+_mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id)

+{

+   struct gl_program *prog;

+   switch (target) {

+   case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */

+   case GL_VERTEX_STATE_PROGRAM_NV:

+      prog = _mesa_init_vertex_program(ctx, CALLOC_STRUCT(gl_vertex_program),

+                                       target, id );

+      break;

+   case GL_FRAGMENT_PROGRAM_NV:

+   case GL_FRAGMENT_PROGRAM_ARB:

+      prog =_mesa_init_fragment_program(ctx,

+                                         CALLOC_STRUCT(gl_fragment_program),

+                                         target, id );

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      prog = _mesa_init_geometry_program(ctx,

+                                         CALLOC_STRUCT(gl_geometry_program),

+                                         target, id);

+      break;

+   default:

+      _mesa_problem(ctx, "bad target in _mesa_new_program");

+      prog = NULL;

+   }

+   return prog;

+}

+

+

+/**

+ * Delete a program and remove it from the hash table, ignoring the

+ * reference count.

+ * Called via ctx->Driver.DeleteProgram.  May be wrapped (OO deriviation)

+ * by a device driver function.

+ */

+void

+_mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)

+{

+   (void) ctx;

+   ASSERT(prog);

+   ASSERT(prog->RefCount==0);

+

+   if (prog == &_mesa_DummyProgram)

+      return;

+

+   if (prog->String)

+      free(prog->String);

+

+   _mesa_free_instructions(prog->Instructions, prog->NumInstructions);

+

+   if (prog->Parameters) {

+      _mesa_free_parameter_list(prog->Parameters);

+   }

+   if (prog->Varying) {

+      _mesa_free_parameter_list(prog->Varying);

+   }

+   if (prog->Attributes) {

+      _mesa_free_parameter_list(prog->Attributes);

+   }

+

+   free(prog);

+}

+

+

+/**

+ * Return the gl_program object for a given ID.

+ * Basically just a wrapper for _mesa_HashLookup() to avoid a lot of

+ * casts elsewhere.

+ */

+struct gl_program *

+_mesa_lookup_program(struct gl_context *ctx, GLuint id)

+{

+   if (id)

+      return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);

+   else

+      return NULL;

+}

+

+

+/**

+ * Reference counting for vertex/fragment programs

+ */

+void

+_mesa_reference_program(struct gl_context *ctx,

+                        struct gl_program **ptr,

+                        struct gl_program *prog)

+{

+   assert(ptr);

+   if (*ptr && prog) {

+      /* sanity check */

+      if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)

+         ASSERT(prog->Target == GL_VERTEX_PROGRAM_ARB);

+      else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)

+         ASSERT(prog->Target == GL_FRAGMENT_PROGRAM_ARB ||

+                prog->Target == GL_FRAGMENT_PROGRAM_NV);

+      else if ((*ptr)->Target == MESA_GEOMETRY_PROGRAM)

+         ASSERT(prog->Target == MESA_GEOMETRY_PROGRAM);

+   }

+   if (*ptr == prog) {

+      return;  /* no change */

+   }

+   if (*ptr) {

+      GLboolean deleteFlag;

+

+      /*_glthread_LOCK_MUTEX((*ptr)->Mutex);*/

+#if 0

+      printf("Program %p ID=%u Target=%s  Refcount-- to %d\n",

+             *ptr, (*ptr)->Id,

+             ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :

+              ((*ptr)->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),

+             (*ptr)->RefCount - 1);

+#endif

+      ASSERT((*ptr)->RefCount > 0);

+      (*ptr)->RefCount--;

+

+      deleteFlag = ((*ptr)->RefCount == 0);

+      /*_glthread_UNLOCK_MUTEX((*ptr)->Mutex);*/

+

+      if (deleteFlag) {

+         ASSERT(ctx);

+         ctx->Driver.DeleteProgram(ctx, *ptr);

+      }

+

+      *ptr = NULL;

+   }

+

+   assert(!*ptr);

+   if (prog) {

+      /*_glthread_LOCK_MUTEX(prog->Mutex);*/

+      prog->RefCount++;

+#if 0

+      printf("Program %p ID=%u Target=%s  Refcount++ to %d\n",

+             prog, prog->Id,

+             (prog->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :

+              (prog->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),

+             prog->RefCount);

+#endif

+      /*_glthread_UNLOCK_MUTEX(prog->Mutex);*/

+   }

+

+   *ptr = prog;

+}

+

+

+/**

+ * Return a copy of a program.

+ * XXX Problem here if the program object is actually OO-derivation

+ * made by a device driver.

+ */

+struct gl_program *

+_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog)

+{

+   struct gl_program *clone;

+

+   clone = ctx->Driver.NewProgram(ctx, prog->Target, prog->Id);

+   if (!clone)

+      return NULL;

+

+   assert(clone->Target == prog->Target);

+   assert(clone->RefCount == 1);

+

+   clone->String = (GLubyte *) _mesa_strdup((char *) prog->String);

+   clone->Format = prog->Format;

+   clone->Instructions = _mesa_alloc_instructions(prog->NumInstructions);

+   if (!clone->Instructions) {

+      _mesa_reference_program(ctx, &clone, NULL);

+      return NULL;

+   }

+   _mesa_copy_instructions(clone->Instructions, prog->Instructions,

+                           prog->NumInstructions);

+   clone->InputsRead = prog->InputsRead;

+   clone->OutputsWritten = prog->OutputsWritten;

+   clone->SamplersUsed = prog->SamplersUsed;

+   clone->ShadowSamplers = prog->ShadowSamplers;

+   memcpy(clone->TexturesUsed, prog->TexturesUsed, sizeof(prog->TexturesUsed));

+

+   if (prog->Parameters)

+      clone->Parameters = _mesa_clone_parameter_list(prog->Parameters);

+   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));

+   if (prog->Varying)

+      clone->Varying = _mesa_clone_parameter_list(prog->Varying);

+   if (prog->Attributes)

+      clone->Attributes = _mesa_clone_parameter_list(prog->Attributes);

+   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));

+   clone->IndirectRegisterFiles = prog->IndirectRegisterFiles;

+   clone->NumInstructions = prog->NumInstructions;

+   clone->NumTemporaries = prog->NumTemporaries;

+   clone->NumParameters = prog->NumParameters;

+   clone->NumAttributes = prog->NumAttributes;

+   clone->NumAddressRegs = prog->NumAddressRegs;

+   clone->NumNativeInstructions = prog->NumNativeInstructions;

+   clone->NumNativeTemporaries = prog->NumNativeTemporaries;

+   clone->NumNativeParameters = prog->NumNativeParameters;

+   clone->NumNativeAttributes = prog->NumNativeAttributes;

+   clone->NumNativeAddressRegs = prog->NumNativeAddressRegs;

+   clone->NumAluInstructions = prog->NumAluInstructions;

+   clone->NumTexInstructions = prog->NumTexInstructions;

+   clone->NumTexIndirections = prog->NumTexIndirections;

+   clone->NumNativeAluInstructions = prog->NumNativeAluInstructions;

+   clone->NumNativeTexInstructions = prog->NumNativeTexInstructions;

+   clone->NumNativeTexIndirections = prog->NumNativeTexIndirections;

+

+   switch (prog->Target) {

+   case GL_VERTEX_PROGRAM_ARB:

+      {

+         const struct gl_vertex_program *vp

+            = (const struct gl_vertex_program *) prog;

+         struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone;

+         vpc->IsPositionInvariant = vp->IsPositionInvariant;

+         vpc->IsNVProgram = vp->IsNVProgram;

+      }

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      {

+         const struct gl_fragment_program *fp

+            = (const struct gl_fragment_program *) prog;

+         struct gl_fragment_program *fpc = (struct gl_fragment_program *) clone;

+         fpc->FogOption = fp->FogOption;

+         fpc->UsesKill = fp->UsesKill;

+         fpc->OriginUpperLeft = fp->OriginUpperLeft;

+         fpc->PixelCenterInteger = fp->PixelCenterInteger;

+      }

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      {

+         const struct gl_geometry_program *gp

+            = (const struct gl_geometry_program *) prog;

+         struct gl_geometry_program *gpc = (struct gl_geometry_program *) clone;

+         gpc->VerticesOut = gp->VerticesOut;

+         gpc->InputType = gp->InputType;

+         gpc->OutputType = gp->OutputType;

+      }

+      break;

+   default:

+      _mesa_problem(NULL, "Unexpected target in _mesa_clone_program");

+   }

+

+   return clone;

+}

+

+

+/**

+ * Insert 'count' NOP instructions at 'start' in the given program.

+ * Adjust branch targets accordingly.

+ */

+GLboolean

+_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)

+{

+   const GLuint origLen = prog->NumInstructions;

+   const GLuint newLen = origLen + count;

+   struct prog_instruction *newInst;

+   GLuint i;

+

+   /* adjust branches */

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      if (inst->BranchTarget > 0) {

+         if ((GLuint)inst->BranchTarget >= start) {

+            inst->BranchTarget += count;

+         }

+      }

+   }

+

+   /* Alloc storage for new instructions */

+   newInst = _mesa_alloc_instructions(newLen);

+   if (!newInst) {

+      return GL_FALSE;

+   }

+

+   /* Copy 'start' instructions into new instruction buffer */

+   _mesa_copy_instructions(newInst, prog->Instructions, start);

+

+   /* init the new instructions */

+   _mesa_init_instructions(newInst + start, count);

+

+   /* Copy the remaining/tail instructions to new inst buffer */

+   _mesa_copy_instructions(newInst + start + count,

+                           prog->Instructions + start,

+                           origLen - start);

+

+   /* free old instructions */

+   _mesa_free_instructions(prog->Instructions, origLen);

+

+   /* install new instructions */

+   prog->Instructions = newInst;

+   prog->NumInstructions = newLen;

+

+   return GL_TRUE;

+}

+

+/**

+ * Delete 'count' instructions at 'start' in the given program.

+ * Adjust branch targets accordingly.

+ */

+GLboolean

+_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)

+{

+   const GLuint origLen = prog->NumInstructions;

+   const GLuint newLen = origLen - count;

+   struct prog_instruction *newInst;

+   GLuint i;

+

+   /* adjust branches */

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      if (inst->BranchTarget > 0) {

+         if (inst->BranchTarget > (GLint) start) {

+            inst->BranchTarget -= count;

+         }

+      }

+   }

+

+   /* Alloc storage for new instructions */

+   newInst = _mesa_alloc_instructions(newLen);

+   if (!newInst) {

+      return GL_FALSE;

+   }

+

+   /* Copy 'start' instructions into new instruction buffer */

+   _mesa_copy_instructions(newInst, prog->Instructions, start);

+

+   /* Copy the remaining/tail instructions to new inst buffer */

+   _mesa_copy_instructions(newInst + start,

+                           prog->Instructions + start + count,

+                           newLen - start);

+

+   /* free old instructions */

+   _mesa_free_instructions(prog->Instructions, origLen);

+

+   /* install new instructions */

+   prog->Instructions = newInst;

+   prog->NumInstructions = newLen;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Search instructions for registers that match (oldFile, oldIndex),

+ * replacing them with (newFile, newIndex).

+ */

+static void

+replace_registers(struct prog_instruction *inst, GLuint numInst,

+                  GLuint oldFile, GLuint oldIndex,

+                  GLuint newFile, GLuint newIndex)

+{

+   GLuint i, j;

+   for (i = 0; i < numInst; i++) {

+      /* src regs */

+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {

+         if (inst[i].SrcReg[j].File == oldFile &&

+             inst[i].SrcReg[j].Index == oldIndex) {

+            inst[i].SrcReg[j].File = newFile;

+            inst[i].SrcReg[j].Index = newIndex;

+         }

+      }

+      /* dst reg */

+      if (inst[i].DstReg.File == oldFile && inst[i].DstReg.Index == oldIndex) {

+         inst[i].DstReg.File = newFile;

+         inst[i].DstReg.Index = newIndex;

+      }

+   }

+}

+

+

+/**

+ * Search instructions for references to program parameters.  When found,

+ * increment the parameter index by 'offset'.

+ * Used when combining programs.

+ */

+static void

+adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,

+                     GLuint offset)

+{

+   GLuint i, j;

+   for (i = 0; i < numInst; i++) {

+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {

+         GLuint f = inst[i].SrcReg[j].File;

+         if (f == PROGRAM_CONSTANT ||

+             f == PROGRAM_UNIFORM ||

+             f == PROGRAM_STATE_VAR) {

+            inst[i].SrcReg[j].Index += offset;

+         }

+      }

+   }

+}

+

+

+/**

+ * Combine two programs into one.  Fix instructions so the outputs of

+ * the first program go to the inputs of the second program.

+ */

+struct gl_program *

+_mesa_combine_programs(struct gl_context *ctx,

+                       const struct gl_program *progA,

+                       const struct gl_program *progB)

+{

+   struct prog_instruction *newInst;

+   struct gl_program *newProg;

+   const GLuint lenA = progA->NumInstructions - 1; /* omit END instr */

+   const GLuint lenB = progB->NumInstructions;

+   const GLuint numParamsA = _mesa_num_parameters(progA->Parameters);

+   const GLuint newLength = lenA + lenB;

+   GLboolean usedTemps[MAX_PROGRAM_TEMPS];

+   GLuint firstTemp = 0;

+   GLbitfield inputsB;

+   GLuint i;

+

+   ASSERT(progA->Target == progB->Target);

+

+   newInst = _mesa_alloc_instructions(newLength);

+   if (!newInst)

+      return GL_FALSE;

+

+   _mesa_copy_instructions(newInst, progA->Instructions, lenA);

+   _mesa_copy_instructions(newInst + lenA, progB->Instructions, lenB);

+

+   /* adjust branch / instruction addresses for B's instructions */

+   for (i = 0; i < lenB; i++) {

+      newInst[lenA + i].BranchTarget += lenA;

+   }

+

+   newProg = ctx->Driver.NewProgram(ctx, progA->Target, 0);

+   newProg->Instructions = newInst;

+   newProg->NumInstructions = newLength;

+

+   /* find used temp regs (we may need new temps below) */

+   _mesa_find_used_registers(newProg, PROGRAM_TEMPORARY,

+                             usedTemps, MAX_PROGRAM_TEMPS);

+

+   if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) {

+      struct gl_fragment_program *fprogA, *fprogB, *newFprog;

+      GLbitfield progB_inputsRead = progB->InputsRead;

+      GLint progB_colorFile, progB_colorIndex;

+

+      fprogA = (struct gl_fragment_program *) progA;

+      fprogB = (struct gl_fragment_program *) progB;

+      newFprog = (struct gl_fragment_program *) newProg;

+

+      newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill;

+

+      /* We'll do a search and replace for instances

+       * of progB_colorFile/progB_colorIndex below...

+       */

+      progB_colorFile = PROGRAM_INPUT;

+      progB_colorIndex = FRAG_ATTRIB_COL0;

+

+      /*

+       * The fragment program may get color from a state var rather than

+       * a fragment input (vertex output) if it's constant.

+       * See the texenvprogram.c code.

+       * So, search the program's parameter list now to see if the program

+       * gets color from a state var instead of a conventional fragment

+       * input register.

+       */

+      for (i = 0; i < progB->Parameters->NumParameters; i++) {

+         struct gl_program_parameter *p = &progB->Parameters->Parameters[i];

+         if (p->Type == PROGRAM_STATE_VAR &&

+             p->StateIndexes[0] == STATE_INTERNAL &&

+             p->StateIndexes[1] == STATE_CURRENT_ATTRIB &&

+             (int) p->StateIndexes[2] == (int) VERT_ATTRIB_COLOR0) {

+            progB_inputsRead |= FRAG_BIT_COL0;

+            progB_colorFile = PROGRAM_STATE_VAR;

+            progB_colorIndex = i;

+            break;

+         }

+      }

+

+      /* Connect color outputs of fprogA to color inputs of fprogB, via a

+       * new temporary register.

+       */

+      if ((progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) &&

+          (progB_inputsRead & FRAG_BIT_COL0)) {

+         GLint tempReg = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS,

+                                                  firstTemp);

+         if (tempReg < 0) {

+            _mesa_problem(ctx, "No free temp regs found in "

+                          "_mesa_combine_programs(), using 31");

+            tempReg = 31;

+         }

+         firstTemp = tempReg + 1;

+

+         /* replace writes to result.color[0] with tempReg */

+         replace_registers(newInst, lenA,

+                           PROGRAM_OUTPUT, FRAG_RESULT_COLOR,

+                           PROGRAM_TEMPORARY, tempReg);

+         /* replace reads from the input color with tempReg */

+         replace_registers(newInst + lenA, lenB,

+                           progB_colorFile, progB_colorIndex, /* search for */

+                           PROGRAM_TEMPORARY, tempReg  /* replace with */ );

+      }

+

+      /* compute combined program's InputsRead */

+      inputsB = progB_inputsRead;

+      if (progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) {

+         inputsB &= ~(1 << FRAG_ATTRIB_COL0);

+      }

+      newProg->InputsRead = progA->InputsRead | inputsB;

+      newProg->OutputsWritten = progB->OutputsWritten;

+      newProg->SamplersUsed = progA->SamplersUsed | progB->SamplersUsed;

+   }

+   else {

+      /* vertex program */

+      assert(0);      /* XXX todo */

+   }

+

+   /*

+    * Merge parameters (uniforms, constants, etc)

+    */

+   newProg->Parameters = _mesa_combine_parameter_lists(progA->Parameters,

+                                                       progB->Parameters);

+

+   adjust_param_indexes(newInst + lenA, lenB, numParamsA);

+

+

+   return newProg;

+}

+

+

+/**

+ * Populate the 'used' array with flags indicating which registers (TEMPs,

+ * INPUTs, OUTPUTs, etc, are used by the given program.

+ * \param file  type of register to scan for

+ * \param used  returns true/false flags for in use / free

+ * \param usedSize  size of the 'used' array

+ */

+void

+_mesa_find_used_registers(const struct gl_program *prog,

+                          gl_register_file file,

+                          GLboolean used[], GLuint usedSize)

+{

+   GLuint i, j;

+

+   memset(used, 0, usedSize);

+

+   for (i = 0; i < prog->NumInstructions; i++) {

+      const struct prog_instruction *inst = prog->Instructions + i;

+      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

+

+      if (inst->DstReg.File == file) {

+         ASSERT(inst->DstReg.Index < usedSize);

+         if(inst->DstReg.Index < usedSize)

+            used[inst->DstReg.Index] = GL_TRUE;

+      }

+

+      for (j = 0; j < n; j++) {

+         if (inst->SrcReg[j].File == file) {

+            ASSERT(inst->SrcReg[j].Index < usedSize);

+            if(inst->SrcReg[j].Index < usedSize)

+               used[inst->SrcReg[j].Index] = GL_TRUE;

+         }

+      }

+   }

+}

+

+

+/**

+ * Scan the given 'used' register flag array for the first entry

+ * that's >= firstReg.

+ * \param used  vector of flags indicating registers in use (as returned

+ *              by _mesa_find_used_registers())

+ * \param usedSize  size of the 'used' array

+ * \param firstReg  first register to start searching at

+ * \return index of unused register, or -1 if none.

+ */

+GLint

+_mesa_find_free_register(const GLboolean used[],

+                         GLuint usedSize, GLuint firstReg)

+{

+   GLuint i;

+

+   assert(firstReg < usedSize);

+

+   for (i = firstReg; i < usedSize; i++)

+      if (!used[i])

+         return i;

+

+   return -1;

+}

+

+

+

+/**

+ * Check if the given register index is valid (doesn't exceed implementation-

+ * dependent limits).

+ * \return GL_TRUE if OK, GL_FALSE if bad index

+ */

+GLboolean

+_mesa_valid_register_index(const struct gl_context *ctx,

+                           gl_shader_type shaderType,

+                           gl_register_file file, GLint index)

+{

+   const struct gl_program_constants *c;

+

+   switch (shaderType) {

+   case MESA_SHADER_VERTEX:

+      c = &ctx->Const.VertexProgram;

+      break;

+   case MESA_SHADER_FRAGMENT:

+      c = &ctx->Const.FragmentProgram;

+      break;

+   case MESA_SHADER_GEOMETRY:

+      c = &ctx->Const.GeometryProgram;

+      break;

+   default:

+      _mesa_problem(ctx,

+                    "unexpected shader type in _mesa_valid_register_index()");

+      return GL_FALSE;

+   }

+

+   switch (file) {

+   case PROGRAM_UNDEFINED:

+      return GL_TRUE;  /* XXX or maybe false? */

+

+   case PROGRAM_TEMPORARY:

+      return index >= 0 && index < c->MaxTemps;

+

+   case PROGRAM_ENV_PARAM:

+      return index >= 0 && index < c->MaxEnvParams;

+

+   case PROGRAM_LOCAL_PARAM:

+      return index >= 0 && index < c->MaxLocalParams;

+

+   case PROGRAM_NAMED_PARAM:

+      return index >= 0 && index < c->MaxParameters;

+

+   case PROGRAM_UNIFORM:

+   case PROGRAM_STATE_VAR:

+      /* aka constant buffer */

+      return index >= 0 && index < c->MaxUniformComponents / 4;

+

+   case PROGRAM_CONSTANT:

+      /* constant buffer w/ possible relative negative addressing */

+      return (index > (int) c->MaxUniformComponents / -4 &&

+              index < c->MaxUniformComponents / 4);

+

+   case PROGRAM_INPUT:

+      if (index < 0)

+         return GL_FALSE;

+

+      switch (shaderType) {

+      case MESA_SHADER_VERTEX:

+         return index < VERT_ATTRIB_GENERIC0 + c->MaxAttribs;

+      case MESA_SHADER_FRAGMENT:

+         return index < FRAG_ATTRIB_VAR0 + ctx->Const.MaxVarying;

+      case MESA_SHADER_GEOMETRY:

+         return index < GEOM_ATTRIB_VAR0 + ctx->Const.MaxVarying;

+      default:

+         return GL_FALSE;

+      }

+

+   case PROGRAM_OUTPUT:

+      if (index < 0)

+         return GL_FALSE;

+

+      switch (shaderType) {

+      case MESA_SHADER_VERTEX:

+         return index < VERT_RESULT_VAR0 + ctx->Const.MaxVarying;

+      case MESA_SHADER_FRAGMENT:

+         return index < FRAG_RESULT_DATA0 + ctx->Const.MaxDrawBuffers;

+      case MESA_SHADER_GEOMETRY:

+         return index < GEOM_RESULT_VAR0 + ctx->Const.MaxVarying;

+      default:

+         return GL_FALSE;

+      }

+

+   case PROGRAM_ADDRESS:

+      return index >= 0 && index < c->MaxAddressRegs;

+

+   default:

+      _mesa_problem(ctx,

+                    "unexpected register file in _mesa_valid_register_index()");

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * "Post-process" a GPU program.  This is intended to be used for debugging.

+ * Example actions include no-op'ing instructions or changing instruction

+ * behaviour.

+ */

+void

+_mesa_postprocess_program(struct gl_context *ctx, struct gl_program *prog)

+{

+   static const GLfloat white[4] = { 0.5, 0.5, 0.5, 0.5 };

+   GLuint i;

+   GLuint whiteSwizzle;

+   GLint whiteIndex = _mesa_add_unnamed_constant(prog->Parameters,

+                                                 white, 4, &whiteSwizzle);

+

+   (void) whiteIndex;

+

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

+

+      (void) n;

+

+      if (_mesa_is_tex_instruction(inst->Opcode)) {

+#if 0

+         /* replace TEX/TXP/TXB with MOV */

+         inst->Opcode = OPCODE_MOV;

+         inst->DstReg.WriteMask = WRITEMASK_XYZW;

+         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;

+         inst->SrcReg[0].Negate = NEGATE_NONE;

+#endif

+

+#if 0

+         /* disable shadow texture mode */

+         inst->TexShadow = 0;

+#endif

+      }

+

+      if (inst->Opcode == OPCODE_TXP) {

+#if 0

+         inst->Opcode = OPCODE_MOV;

+         inst->DstReg.WriteMask = WRITEMASK_XYZW;

+         inst->SrcReg[0].File = PROGRAM_CONSTANT;

+         inst->SrcReg[0].Index = whiteIndex;

+         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;

+         inst->SrcReg[0].Negate = NEGATE_NONE;

+#endif

+#if 0

+         inst->TexShadow = 0;

+#endif

+#if 0

+         inst->Opcode = OPCODE_TEX;

+         inst->TexShadow = 0;

+#endif

+      }

+

+   }

+}

diff --git a/mesalib/src/mesa/program/program_parse.y b/mesalib/src/mesa/program/program_parse.y
index 19aa8ccdb..e63a9f1e1 100644
--- a/mesalib/src/mesa/program/program_parse.y
+++ b/mesalib/src/mesa/program/program_parse.y
@@ -1,2768 +1,2768 @@
-%{
-/*
- * Copyright © 2009 Intel Corporation
- *
- * 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, sublicense,
- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "main/mtypes.h"
-#include "main/imports.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "program/prog_parameter_layout.h"
-#include "program/prog_statevars.h"
-#include "program/prog_instruction.h"
-
-#include "program/symbol_table.h"
-#include "program/program_parser.h"
-
-extern void *yy_scan_string(char *);
-extern void yy_delete_buffer(void *);
-
-static struct asm_symbol *declare_variable(struct asm_parser_state *state,
-    char *name, enum asm_type t, struct YYLTYPE *locp);
-
-static int add_state_reference(struct gl_program_parameter_list *param_list,
-    const gl_state_index tokens[STATE_LENGTH]);
-
-static int initialize_symbol_from_state(struct gl_program *prog,
-    struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]);
-
-static int initialize_symbol_from_param(struct gl_program *prog,
-    struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]);
-
-static int initialize_symbol_from_const(struct gl_program *prog,
-    struct asm_symbol *param_var, const struct asm_vector *vec,
-    GLboolean allowSwizzle);
-
-static int yyparse(struct asm_parser_state *state);
-
-static char *make_error_string(const char *fmt, ...);
-
-static void yyerror(struct YYLTYPE *locp, struct asm_parser_state *state,
-    const char *s);
-
-static int validate_inputs(struct YYLTYPE *locp,
-    struct asm_parser_state *state);
-
-static void init_dst_reg(struct prog_dst_register *r);
-
-static void set_dst_reg(struct prog_dst_register *r,
-                        gl_register_file file, GLint index);
-
-static void init_src_reg(struct asm_src_register *r);
-
-static void set_src_reg(struct asm_src_register *r,
-                        gl_register_file file, GLint index);
-
-static void set_src_reg_swz(struct asm_src_register *r,
-                            gl_register_file file, GLint index, GLuint swizzle);
-
-static void asm_instruction_set_operands(struct asm_instruction *inst,
-    const struct prog_dst_register *dst, const struct asm_src_register *src0,
-    const struct asm_src_register *src1, const struct asm_src_register *src2);
-
-static struct asm_instruction *asm_instruction_ctor(gl_inst_opcode op,
-    const struct prog_dst_register *dst, const struct asm_src_register *src0,
-    const struct asm_src_register *src1, const struct asm_src_register *src2);
-
-static struct asm_instruction *asm_instruction_copy_ctor(
-    const struct prog_instruction *base, const struct prog_dst_register *dst,
-    const struct asm_src_register *src0, const struct asm_src_register *src1,
-    const struct asm_src_register *src2);
-
-#ifndef FALSE
-#define FALSE 0
-#define TRUE (!FALSE)
-#endif
-
-#define YYLLOC_DEFAULT(Current, Rhs, N)					\
-   do {									\
-      if (YYID(N)) {							\
-	 (Current).first_line = YYRHSLOC(Rhs, 1).first_line;		\
-	 (Current).first_column = YYRHSLOC(Rhs, 1).first_column;	\
-	 (Current).position = YYRHSLOC(Rhs, 1).position;		\
-	 (Current).last_line = YYRHSLOC(Rhs, N).last_line;		\
-	 (Current).last_column = YYRHSLOC(Rhs, N).last_column;		\
-      } else {								\
-	 (Current).first_line = YYRHSLOC(Rhs, 0).last_line;		\
-	 (Current).last_line = (Current).first_line;			\
-	 (Current).first_column = YYRHSLOC(Rhs, 0).last_column;		\
-	 (Current).last_column = (Current).first_column;		\
-	 (Current).position = YYRHSLOC(Rhs, 0).position			\
-	    + (Current).first_column;					\
-      }									\
-   } while(YYID(0))
-
-#define YYLEX_PARAM state->scanner
-%}
-
-%pure-parser
-%locations
-%parse-param { struct asm_parser_state *state }
-%error-verbose
-%lex-param { void *scanner }
-
-%union {
-   struct asm_instruction *inst;
-   struct asm_symbol *sym;
-   struct asm_symbol temp_sym;
-   struct asm_swizzle_mask swiz_mask;
-   struct asm_src_register src_reg;
-   struct prog_dst_register dst_reg;
-   struct prog_instruction temp_inst;
-   char *string;
-   unsigned result;
-   unsigned attrib;
-   int integer;
-   float real;
-   gl_state_index state[STATE_LENGTH];
-   int negate;
-   struct asm_vector vector;
-   gl_inst_opcode opcode;
-
-   struct {
-      unsigned swz;
-      unsigned rgba_valid:1;
-      unsigned xyzw_valid:1;
-      unsigned negate:1;
-   } ext_swizzle;
-}
-
-%token ARBvp_10 ARBfp_10
-
-/* Tokens for assembler pseudo-ops */
-%token <integer> ADDRESS
-%token ALIAS ATTRIB
-%token OPTION OUTPUT
-%token PARAM
-%token <integer> TEMP
-%token END
-
- /* Tokens for instructions */
-%token <temp_inst> BIN_OP BINSC_OP SAMPLE_OP SCALAR_OP TRI_OP VECTOR_OP
-%token <temp_inst> ARL KIL SWZ TXD_OP
-
-%token <integer> INTEGER
-%token <real> REAL
-
-%token AMBIENT ATTENUATION
-%token BACK
-%token CLIP COLOR
-%token DEPTH DIFFUSE DIRECTION
-%token EMISSION ENV EYE
-%token FOG FOGCOORD FRAGMENT FRONT
-%token HALF
-%token INVERSE INVTRANS
-%token LIGHT LIGHTMODEL LIGHTPROD LOCAL
-%token MATERIAL MAT_PROGRAM MATRIX MATRIXINDEX MODELVIEW MVP
-%token NORMAL
-%token OBJECT
-%token PALETTE PARAMS PLANE POINT_TOK POINTSIZE POSITION PRIMARY PROGRAM PROJECTION
-%token RANGE RESULT ROW
-%token SCENECOLOR SECONDARY SHININESS SIZE_TOK SPECULAR SPOT STATE
-%token TEXCOORD TEXENV TEXGEN TEXGEN_Q TEXGEN_R TEXGEN_S TEXGEN_T TEXTURE TRANSPOSE
-%token TEXTURE_UNIT TEX_1D TEX_2D TEX_3D TEX_CUBE TEX_RECT
-%token TEX_SHADOW1D TEX_SHADOW2D TEX_SHADOWRECT
-%token TEX_ARRAY1D TEX_ARRAY2D TEX_ARRAYSHADOW1D TEX_ARRAYSHADOW2D 
-%token VERTEX VTXATTRIB
-%token WEIGHT
-
-%token <string> IDENTIFIER USED_IDENTIFIER
-%type <string> string
-%token <swiz_mask> MASK4 MASK3 MASK2 MASK1 SWIZZLE
-%token DOT_DOT
-%token DOT
-
-%type <inst> instruction ALU_instruction TexInstruction
-%type <inst> ARL_instruction VECTORop_instruction
-%type <inst> SCALARop_instruction BINSCop_instruction BINop_instruction
-%type <inst> TRIop_instruction TXD_instruction SWZ_instruction SAMPLE_instruction
-%type <inst> KIL_instruction
-
-%type <dst_reg> dstReg maskedDstReg maskedAddrReg
-%type <src_reg> srcReg scalarUse scalarSrcReg swizzleSrcReg
-%type <swiz_mask> scalarSuffix swizzleSuffix extendedSwizzle
-%type <ext_swizzle> extSwizComp extSwizSel
-%type <swiz_mask> optionalMask
-
-%type <sym> progParamArray
-%type <integer> addrRegRelOffset addrRegPosOffset addrRegNegOffset
-%type <src_reg> progParamArrayMem progParamArrayAbs progParamArrayRel
-%type <sym> addrReg
-%type <swiz_mask> addrComponent addrWriteMask
-
-%type <dst_reg> ccMaskRule ccTest ccMaskRule2 ccTest2 optionalCcMask
-
-%type <result> resultBinding resultColBinding
-%type <integer> optFaceType optColorType
-%type <integer> optResultFaceType optResultColorType
-
-%type <integer> optTexImageUnitNum texImageUnitNum
-%type <integer> optTexCoordUnitNum texCoordUnitNum
-%type <integer> optLegacyTexUnitNum legacyTexUnitNum
-%type <integer> texImageUnit texTarget
-%type <integer> vtxAttribNum
-
-%type <attrib> attribBinding vtxAttribItem fragAttribItem
-
-%type <temp_sym> paramSingleInit paramSingleItemDecl
-%type <integer> optArraySize
-
-%type <state> stateSingleItem stateMultipleItem
-%type <state> stateMaterialItem
-%type <state> stateLightItem stateLightModelItem stateLightProdItem
-%type <state> stateTexGenItem stateFogItem stateClipPlaneItem statePointItem
-%type <state> stateMatrixItem stateMatrixRow stateMatrixRows
-%type <state> stateTexEnvItem stateDepthItem
-
-%type <state> stateLModProperty
-%type <state> stateMatrixName optMatrixRows
-
-%type <integer> stateMatProperty
-%type <integer> stateLightProperty stateSpotProperty
-%type <integer> stateLightNumber stateLProdProperty
-%type <integer> stateTexGenType stateTexGenCoord
-%type <integer> stateTexEnvProperty
-%type <integer> stateFogProperty
-%type <integer> stateClipPlaneNum
-%type <integer> statePointProperty
-
-%type <integer> stateOptMatModifier stateMatModifier stateMatrixRowNum
-%type <integer> stateOptModMatNum stateModMatNum statePaletteMatNum 
-%type <integer> stateProgramMatNum
-
-%type <integer> ambDiffSpecProperty
-
-%type <state> programSingleItem progEnvParam progLocalParam
-%type <state> programMultipleItem progEnvParams progLocalParams
-
-%type <temp_sym> paramMultipleInit paramMultInitList paramMultipleItem
-%type <temp_sym> paramSingleItemUse
-
-%type <integer> progEnvParamNum progLocalParamNum
-%type <state> progEnvParamNums progLocalParamNums
-
-%type <vector> paramConstDecl paramConstUse
-%type <vector> paramConstScalarDecl paramConstScalarUse paramConstVector
-%type <real> signedFloatConstant
-%type <negate> optionalSign
-
-%{
-extern int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param,
-    void *yyscanner);
-%}
-
-%%
-
-program: language optionSequence statementSequence END
-	;
-
-language: ARBvp_10
-	{
-	   if (state->prog->Target != GL_VERTEX_PROGRAM_ARB) {
-	      yyerror(& @1, state, "invalid fragment program header");
-
-	   }
-	   state->mode = ARB_vertex;
-	}
-	| ARBfp_10
-	{
-	   if (state->prog->Target != GL_FRAGMENT_PROGRAM_ARB) {
-	      yyerror(& @1, state, "invalid vertex program header");
-	   }
-	   state->mode = ARB_fragment;
-
-	   state->option.TexRect =
-	      (state->ctx->Extensions.NV_texture_rectangle != GL_FALSE);
-	}
-	;
-
-optionSequence: optionSequence option
-	|
-	;
-
-option: OPTION string ';'
-	{
-	   int valid = 0;
-
-	   if (state->mode == ARB_vertex) {
-	      valid = _mesa_ARBvp_parse_option(state, $2);
-	   } else if (state->mode == ARB_fragment) {
-	      valid = _mesa_ARBfp_parse_option(state, $2);
-	   }
-
-
-	   free($2);
-
-	   if (!valid) {
-	      const char *const err_str = (state->mode == ARB_vertex)
-		 ? "invalid ARB vertex program option"
-		 : "invalid ARB fragment program option";
-
-	      yyerror(& @2, state, err_str);
-	      YYERROR;
-	   }
-	}
-	;
-
-statementSequence: statementSequence statement
-	|
-	;
-
-statement: instruction ';'
-	{
-	   if ($1 != NULL) {
-	      if (state->inst_tail == NULL) {
-		 state->inst_head = $1;
-	      } else {
-		 state->inst_tail->next = $1;
-	      }
-
-	      state->inst_tail = $1;
-	      $1->next = NULL;
-
-	      state->prog->NumInstructions++;
-	   }
-	}
-	| namingStatement ';'
-	;
-
-instruction: ALU_instruction
-	{
-	   $$ = $1;
-	   state->prog->NumAluInstructions++;
-	}
-	| TexInstruction
-	{
-	   $$ = $1;
-	   state->prog->NumTexInstructions++;
-	}
-	;
-
-ALU_instruction: ARL_instruction
-	| VECTORop_instruction
-	| SCALARop_instruction
-	| BINSCop_instruction
-	| BINop_instruction
-	| TRIop_instruction
-	| SWZ_instruction
-	;
-
-TexInstruction: SAMPLE_instruction
-	| KIL_instruction
-	| TXD_instruction
-	;
-
-ARL_instruction: ARL maskedAddrReg ',' scalarSrcReg
-	{
-	   $$ = asm_instruction_ctor(OPCODE_ARL, & $2, & $4, NULL, NULL);
-	}
-	;
-
-VECTORop_instruction: VECTOR_OP maskedDstReg ',' swizzleSrcReg
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);
-	}
-	;
-
-SCALARop_instruction: SCALAR_OP maskedDstReg ',' scalarSrcReg
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);
-	}
-	;
-
-BINSCop_instruction: BINSC_OP maskedDstReg ',' scalarSrcReg ',' scalarSrcReg
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, NULL);
-	}
-	;
-
-
-BINop_instruction: BIN_OP maskedDstReg ',' swizzleSrcReg ',' swizzleSrcReg
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, NULL);
-	}
-	;
-
-TRIop_instruction: TRI_OP maskedDstReg ','
-                   swizzleSrcReg ',' swizzleSrcReg ',' swizzleSrcReg
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, & $8);
-	}
-	;
-
-SAMPLE_instruction: SAMPLE_OP maskedDstReg ',' swizzleSrcReg ',' texImageUnit ',' texTarget
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);
-	   if ($$ != NULL) {
-	      const GLbitfield tex_mask = (1U << $6);
-	      GLbitfield shadow_tex = 0;
-	      GLbitfield target_mask = 0;
-
-
-	      $$->Base.TexSrcUnit = $6;
-
-	      if ($8 < 0) {
-		 shadow_tex = tex_mask;
-
-		 $$->Base.TexSrcTarget = -$8;
-		 $$->Base.TexShadow = 1;
-	      } else {
-		 $$->Base.TexSrcTarget = $8;
-	      }
-
-	      target_mask = (1U << $$->Base.TexSrcTarget);
-
-	      /* If this texture unit was previously accessed and that access
-	       * had a different texture target, generate an error.
-	       *
-	       * If this texture unit was previously accessed and that access
-	       * had a different shadow mode, generate an error.
-	       */
-	      if ((state->prog->TexturesUsed[$6] != 0)
-		  && ((state->prog->TexturesUsed[$6] != target_mask)
-		      || ((state->prog->ShadowSamplers & tex_mask)
-			  != shadow_tex))) {
-		 yyerror(& @8, state,
-			 "multiple targets used on one texture image unit");
-		 YYERROR;
-	      }
-
-
-	      state->prog->TexturesUsed[$6] |= target_mask;
-	      state->prog->ShadowSamplers |= shadow_tex;
-	   }
-	}
-	;
-
-KIL_instruction: KIL swizzleSrcReg
-	{
-	   $$ = asm_instruction_ctor(OPCODE_KIL, NULL, & $2, NULL, NULL);
-	   state->fragment.UsesKill = 1;
-	}
-	| KIL ccTest
-	{
-	   $$ = asm_instruction_ctor(OPCODE_KIL_NV, NULL, NULL, NULL, NULL);
-	   $$->Base.DstReg.CondMask = $2.CondMask;
-	   $$->Base.DstReg.CondSwizzle = $2.CondSwizzle;
-	   $$->Base.DstReg.CondSrc = $2.CondSrc;
-	   state->fragment.UsesKill = 1;
-	}
-	;
-
-TXD_instruction: TXD_OP maskedDstReg ',' swizzleSrcReg ',' swizzleSrcReg ',' swizzleSrcReg ',' texImageUnit ',' texTarget
-	{
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, & $8);
-	   if ($$ != NULL) {
-	      const GLbitfield tex_mask = (1U << $10);
-	      GLbitfield shadow_tex = 0;
-	      GLbitfield target_mask = 0;
-
-
-	      $$->Base.TexSrcUnit = $10;
-
-	      if ($12 < 0) {
-		 shadow_tex = tex_mask;
-
-		 $$->Base.TexSrcTarget = -$12;
-		 $$->Base.TexShadow = 1;
-	      } else {
-		 $$->Base.TexSrcTarget = $12;
-	      }
-
-	      target_mask = (1U << $$->Base.TexSrcTarget);
-
-	      /* If this texture unit was previously accessed and that access
-	       * had a different texture target, generate an error.
-	       *
-	       * If this texture unit was previously accessed and that access
-	       * had a different shadow mode, generate an error.
-	       */
-	      if ((state->prog->TexturesUsed[$10] != 0)
-		  && ((state->prog->TexturesUsed[$10] != target_mask)
-		      || ((state->prog->ShadowSamplers & tex_mask)
-			  != shadow_tex))) {
-		 yyerror(& @12, state,
-			 "multiple targets used on one texture image unit");
-		 YYERROR;
-	      }
-
-
-	      state->prog->TexturesUsed[$10] |= target_mask;
-	      state->prog->ShadowSamplers |= shadow_tex;
-	   }
-	}
-	;
-
-texImageUnit: TEXTURE_UNIT optTexImageUnitNum
-	{
-	   $$ = $2;
-	}
-	;
-
-texTarget: TEX_1D  { $$ = TEXTURE_1D_INDEX; }
-	| TEX_2D   { $$ = TEXTURE_2D_INDEX; }
-	| TEX_3D   { $$ = TEXTURE_3D_INDEX; }
-	| TEX_CUBE { $$ = TEXTURE_CUBE_INDEX; }
-	| TEX_RECT { $$ = TEXTURE_RECT_INDEX; }
-	| TEX_SHADOW1D   { $$ = -TEXTURE_1D_INDEX; }
-	| TEX_SHADOW2D   { $$ = -TEXTURE_2D_INDEX; }
-	| TEX_SHADOWRECT { $$ = -TEXTURE_RECT_INDEX; }
-	| TEX_ARRAY1D         { $$ = TEXTURE_1D_ARRAY_INDEX; }
-	| TEX_ARRAY2D         { $$ = TEXTURE_2D_ARRAY_INDEX; }
-	| TEX_ARRAYSHADOW1D   { $$ = -TEXTURE_1D_ARRAY_INDEX; }
-	| TEX_ARRAYSHADOW2D   { $$ = -TEXTURE_2D_ARRAY_INDEX; }
-	;
-
-SWZ_instruction: SWZ maskedDstReg ',' srcReg ',' extendedSwizzle
-	{
-	   /* FIXME: Is this correct?  Should the extenedSwizzle be applied
-	    * FIXME: to the existing swizzle?
-	    */
-	   $4.Base.Swizzle = $6.swizzle;
-	   $4.Base.Negate = $6.mask;
-
-	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);
-	}
-	;
-
-scalarSrcReg: optionalSign scalarUse
-	{
-	   $$ = $2;
-
-	   if ($1) {
-	      $$.Base.Negate = ~$$.Base.Negate;
-	   }
-	}
-	| optionalSign '|' scalarUse '|'
-	{
-	   $$ = $3;
-
-	   if (!state->option.NV_fragment) {
-	      yyerror(& @2, state, "unexpected character '|'");
-	      YYERROR;
-	   }
-
-	   if ($1) {
-	      $$.Base.Negate = ~$$.Base.Negate;
-	   }
-
-	   $$.Base.Abs = 1;
-	}
-	;
-
-scalarUse:  srcReg scalarSuffix
-	{
-	   $$ = $1;
-
-	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,
-						    $2.swizzle);
-	}
-	| paramConstScalarUse
-	{
-	   struct asm_symbol temp_sym;
-
-	   if (!state->option.NV_fragment) {
-	      yyerror(& @1, state, "expected scalar suffix");
-	      YYERROR;
-	   }
-
-	   memset(& temp_sym, 0, sizeof(temp_sym));
-	   temp_sym.param_binding_begin = ~0;
-	   initialize_symbol_from_const(state->prog, & temp_sym, & $1, GL_TRUE);
-
-	   set_src_reg_swz(& $$, PROGRAM_CONSTANT,
-                           temp_sym.param_binding_begin,
-                           temp_sym.param_binding_swizzle);
-	}
-	;
-
-swizzleSrcReg: optionalSign srcReg swizzleSuffix
-	{
-	   $$ = $2;
-
-	   if ($1) {
-	      $$.Base.Negate = ~$$.Base.Negate;
-	   }
-
-	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,
-						    $3.swizzle);
-	}
-	| optionalSign '|' srcReg swizzleSuffix '|'
-	{
-	   $$ = $3;
-
-	   if (!state->option.NV_fragment) {
-	      yyerror(& @2, state, "unexpected character '|'");
-	      YYERROR;
-	   }
-
-	   if ($1) {
-	      $$.Base.Negate = ~$$.Base.Negate;
-	   }
-
-	   $$.Base.Abs = 1;
-	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,
-						    $4.swizzle);
-	}
-
-	;
-
-maskedDstReg: dstReg optionalMask optionalCcMask
-	{
-	   $$ = $1;
-	   $$.WriteMask = $2.mask;
-	   $$.CondMask = $3.CondMask;
-	   $$.CondSwizzle = $3.CondSwizzle;
-	   $$.CondSrc = $3.CondSrc;
-
-	   if ($$.File == PROGRAM_OUTPUT) {
-	      /* Technically speaking, this should check that it is in
-	       * vertex program mode.  However, PositionInvariant can never be
-	       * set in fragment program mode, so it is somewhat irrelevant.
-	       */
-	      if (state->option.PositionInvariant
-	       && ($$.Index == VERT_RESULT_HPOS)) {
-		 yyerror(& @1, state, "position-invariant programs cannot "
-			 "write position");
-		 YYERROR;
-	      }
-
-	      state->prog->OutputsWritten |= BITFIELD64_BIT($$.Index);
-	   }
-	}
-	;
-
-maskedAddrReg: addrReg addrWriteMask
-	{
-	   set_dst_reg(& $$, PROGRAM_ADDRESS, 0);
-	   $$.WriteMask = $2.mask;
-	}
-	;
-
-extendedSwizzle: extSwizComp ',' extSwizComp ',' extSwizComp ',' extSwizComp
-	{
-	   const unsigned xyzw_valid =
-	      ($1.xyzw_valid << 0)
-	      | ($3.xyzw_valid << 1)
-	      | ($5.xyzw_valid << 2)
-	      | ($7.xyzw_valid << 3);
-	   const unsigned rgba_valid =
-	      ($1.rgba_valid << 0)
-	      | ($3.rgba_valid << 1)
-	      | ($5.rgba_valid << 2)
-	      | ($7.rgba_valid << 3);
-
-	   /* All of the swizzle components have to be valid in either RGBA
-	    * or XYZW.  Note that 0 and 1 are valid in both, so both masks
-	    * can have some bits set.
-	    *
-	    * We somewhat deviate from the spec here.  It would be really hard
-	    * to figure out which component is the error, and there probably
-	    * isn't a lot of benefit.
-	    */
-	   if ((rgba_valid != 0x0f) && (xyzw_valid != 0x0f)) {
-	      yyerror(& @1, state, "cannot combine RGBA and XYZW swizzle "
-		      "components");
-	      YYERROR;
-	   }
-
-	   $$.swizzle = MAKE_SWIZZLE4($1.swz, $3.swz, $5.swz, $7.swz);
-	   $$.mask = ($1.negate) | ($3.negate << 1) | ($5.negate << 2)
-	      | ($7.negate << 3);
-	}
-	;
-
-extSwizComp: optionalSign extSwizSel
-	{
-	   $$ = $2;
-	   $$.negate = ($1) ? 1 : 0;
-	}
-	;
-
-extSwizSel: INTEGER
-	{
-	   if (($1 != 0) && ($1 != 1)) {
-	      yyerror(& @1, state, "invalid extended swizzle selector");
-	      YYERROR;
-	   }
-
-	   $$.swz = ($1 == 0) ? SWIZZLE_ZERO : SWIZZLE_ONE;
-
-	   /* 0 and 1 are valid for both RGBA swizzle names and XYZW
-	    * swizzle names.
-	    */
-	   $$.xyzw_valid = 1;
-	   $$.rgba_valid = 1;
-	}
-	| string
-	{
-	   char s;
-
-	   if (strlen($1) > 1) {
-	      yyerror(& @1, state, "invalid extended swizzle selector");
-	      YYERROR;
-	   }
-
-	   s = $1[0];
-	   free($1);
-
-	   switch (s) {
-	   case 'x':
-	      $$.swz = SWIZZLE_X;
-	      $$.xyzw_valid = 1;
-	      break;
-	   case 'y':
-	      $$.swz = SWIZZLE_Y;
-	      $$.xyzw_valid = 1;
-	      break;
-	   case 'z':
-	      $$.swz = SWIZZLE_Z;
-	      $$.xyzw_valid = 1;
-	      break;
-	   case 'w':
-	      $$.swz = SWIZZLE_W;
-	      $$.xyzw_valid = 1;
-	      break;
-
-	   case 'r':
-	      $$.swz = SWIZZLE_X;
-	      $$.rgba_valid = 1;
-	      break;
-	   case 'g':
-	      $$.swz = SWIZZLE_Y;
-	      $$.rgba_valid = 1;
-	      break;
-	   case 'b':
-	      $$.swz = SWIZZLE_Z;
-	      $$.rgba_valid = 1;
-	      break;
-	   case 'a':
-	      $$.swz = SWIZZLE_W;
-	      $$.rgba_valid = 1;
-	      break;
-
-	   default:
-	      yyerror(& @1, state, "invalid extended swizzle selector");
-	      YYERROR;
-	      break;
-	   }
-	}
-	;
-
-srcReg: USED_IDENTIFIER /* temporaryReg | progParamSingle */
-	{
-	   struct asm_symbol *const s = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $1);
-
-	   free($1);
-
-	   if (s == NULL) {
-	      yyerror(& @1, state, "invalid operand variable");
-	      YYERROR;
-	   } else if ((s->type != at_param) && (s->type != at_temp)
-		      && (s->type != at_attrib)) {
-	      yyerror(& @1, state, "invalid operand variable");
-	      YYERROR;
-	   } else if ((s->type == at_param) && s->param_is_array) {
-	      yyerror(& @1, state, "non-array access to array PARAM");
-	      YYERROR;
-	   }
-
-	   init_src_reg(& $$);
-	   switch (s->type) {
-	   case at_temp:
-	      set_src_reg(& $$, PROGRAM_TEMPORARY, s->temp_binding);
-	      break;
-	   case at_param:
-              set_src_reg_swz(& $$, s->param_binding_type,
-                              s->param_binding_begin,
-                              s->param_binding_swizzle);
-	      break;
-	   case at_attrib:
-	      set_src_reg(& $$, PROGRAM_INPUT, s->attrib_binding);
-	      state->prog->InputsRead |= (1U << $$.Base.Index);
-
-	      if (!validate_inputs(& @1, state)) {
-		 YYERROR;
-	      }
-	      break;
-
-	   default:
-	      YYERROR;
-	      break;
-	   }
-	}
-	| attribBinding
-	{
-	   set_src_reg(& $$, PROGRAM_INPUT, $1);
-	   state->prog->InputsRead |= (1U << $$.Base.Index);
-
-	   if (!validate_inputs(& @1, state)) {
-	      YYERROR;
-	   }
-	}
-	| progParamArray '[' progParamArrayMem ']'
-	{
-	   if (! $3.Base.RelAddr
-	       && ((unsigned) $3.Base.Index >= $1->param_binding_length)) {
-	      yyerror(& @3, state, "out of bounds array access");
-	      YYERROR;
-	   }
-
-	   init_src_reg(& $$);
-	   $$.Base.File = $1->param_binding_type;
-
-	   if ($3.Base.RelAddr) {
-              state->prog->IndirectRegisterFiles |= (1 << $$.Base.File);
-	      $1->param_accessed_indirectly = 1;
-
-	      $$.Base.RelAddr = 1;
-	      $$.Base.Index = $3.Base.Index;
-	      $$.Symbol = $1;
-	   } else {
-	      $$.Base.Index = $1->param_binding_begin + $3.Base.Index;
-	   }
-	}
-	| paramSingleItemUse
-	{
-           gl_register_file file = ($1.name != NULL) 
-	      ? $1.param_binding_type
-	      : PROGRAM_CONSTANT;
-           set_src_reg_swz(& $$, file, $1.param_binding_begin,
-                           $1.param_binding_swizzle);
-	}
-	;
-
-dstReg: resultBinding
-	{
-	   set_dst_reg(& $$, PROGRAM_OUTPUT, $1);
-	}
-	| USED_IDENTIFIER /* temporaryReg | vertexResultReg */
-	{
-	   struct asm_symbol *const s = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $1);
-
-	   free($1);
-
-	   if (s == NULL) {
-	      yyerror(& @1, state, "invalid operand variable");
-	      YYERROR;
-	   } else if ((s->type != at_output) && (s->type != at_temp)) {
-	      yyerror(& @1, state, "invalid operand variable");
-	      YYERROR;
-	   }
-
-	   switch (s->type) {
-	   case at_temp:
-	      set_dst_reg(& $$, PROGRAM_TEMPORARY, s->temp_binding);
-	      break;
-	   case at_output:
-	      set_dst_reg(& $$, PROGRAM_OUTPUT, s->output_binding);
-	      break;
-	   default:
-	      set_dst_reg(& $$, s->param_binding_type, s->param_binding_begin);
-	      break;
-	   }
-	}
-	;
-
-progParamArray: USED_IDENTIFIER
-	{
-	   struct asm_symbol *const s = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $1);
-
-	   free($1);
-
-	   if (s == NULL) {
-	      yyerror(& @1, state, "invalid operand variable");
-	      YYERROR;
-	   } else if ((s->type != at_param) || !s->param_is_array) {
-	      yyerror(& @1, state, "array access to non-PARAM variable");
-	      YYERROR;
-	   } else {
-	      $$ = s;
-	   }
-	}
-	;
-
-progParamArrayMem: progParamArrayAbs | progParamArrayRel;
-
-progParamArrayAbs: INTEGER
-	{
-	   init_src_reg(& $$);
-	   $$.Base.Index = $1;
-	}
-	;
-
-progParamArrayRel: addrReg addrComponent addrRegRelOffset
-	{
-	   /* FINISHME: Add support for multiple address registers.
-	    */
-	   /* FINISHME: Add support for 4-component address registers.
-	    */
-	   init_src_reg(& $$);
-	   $$.Base.RelAddr = 1;
-	   $$.Base.Index = $3;
-	}
-	;
-
-addrRegRelOffset:              { $$ = 0; }
-	| '+' addrRegPosOffset { $$ = $2; }
-	| '-' addrRegNegOffset { $$ = -$2; }
-	;
-
-addrRegPosOffset: INTEGER
-	{
-	   if (($1 < 0) || ($1 > (state->limits->MaxAddressOffset - 1))) {
-              char s[100];
-              _mesa_snprintf(s, sizeof(s),
-                             "relative address offset too large (%d)", $1);
-	      yyerror(& @1, state, s);
-	      YYERROR;
-	   } else {
-	      $$ = $1;
-	   }
-	}
-	;
-
-addrRegNegOffset: INTEGER
-	{
-	   if (($1 < 0) || ($1 > state->limits->MaxAddressOffset)) {
-              char s[100];
-              _mesa_snprintf(s, sizeof(s),
-                             "relative address offset too large (%d)", $1);
-	      yyerror(& @1, state, s);
-	      YYERROR;
-	   } else {
-	      $$ = $1;
-	   }
-	}
-	;
-
-addrReg: USED_IDENTIFIER
-	{
-	   struct asm_symbol *const s = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $1);
-
-	   free($1);
-
-	   if (s == NULL) {
-	      yyerror(& @1, state, "invalid array member");
-	      YYERROR;
-	   } else if (s->type != at_address) {
-	      yyerror(& @1, state,
-		      "invalid variable for indexed array access");
-	      YYERROR;
-	   } else {
-	      $$ = s;
-	   }
-	}
-	;
-
-addrComponent: MASK1
-	{
-	   if ($1.mask != WRITEMASK_X) {
-	      yyerror(& @1, state, "invalid address component selector");
-	      YYERROR;
-	   } else {
-	      $$ = $1;
-	   }
-	}
-	;
-
-addrWriteMask: MASK1
-	{
-	   if ($1.mask != WRITEMASK_X) {
-	      yyerror(& @1, state,
-		      "address register write mask must be \".x\"");
-	      YYERROR;
-	   } else {
-	      $$ = $1;
-	   }
-	}
-	;
-
-scalarSuffix: MASK1;
-
-swizzleSuffix: MASK1
-	| MASK4
-	| SWIZZLE
-	|              { $$.swizzle = SWIZZLE_NOOP; $$.mask = WRITEMASK_XYZW; }
-	;
-
-optionalMask: MASK4 | MASK3 | MASK2 | MASK1 
-	|              { $$.swizzle = SWIZZLE_NOOP; $$.mask = WRITEMASK_XYZW; }
-	;
-
-optionalCcMask: '(' ccTest ')'
-	{
-	   $$ = $2;
-	}
-	| '(' ccTest2 ')'
-	{
-	   $$ = $2;
-	}
-	|
-	{
-	   $$.CondMask = COND_TR;
-	   $$.CondSwizzle = SWIZZLE_NOOP;
-	   $$.CondSrc = 0;
-	}
-	;
-
-ccTest: ccMaskRule swizzleSuffix
-	{
-	   $$ = $1;
-	   $$.CondSwizzle = $2.swizzle;
-	}
-	;
-
-ccTest2: ccMaskRule2 swizzleSuffix
-	{
-	   $$ = $1;
-	   $$.CondSwizzle = $2.swizzle;
-	}
-	;
-
-ccMaskRule: IDENTIFIER
-	{
-	   const int cond = _mesa_parse_cc($1);
-	   if ((cond == 0) || ($1[2] != '\0')) {
-	      char *const err_str =
-		 make_error_string("invalid condition code \"%s\"", $1);
-
-	      yyerror(& @1, state, (err_str != NULL)
-		      ? err_str : "invalid condition code");
-
-	      if (err_str != NULL) {
-		 free(err_str);
-	      }
-
-	      YYERROR;
-	   }
-
-	   $$.CondMask = cond;
-	   $$.CondSwizzle = SWIZZLE_NOOP;
-	   $$.CondSrc = 0;
-	}
-	;
-
-ccMaskRule2: USED_IDENTIFIER
-	{
-	   const int cond = _mesa_parse_cc($1);
-	   if ((cond == 0) || ($1[2] != '\0')) {
-	      char *const err_str =
-		 make_error_string("invalid condition code \"%s\"", $1);
-
-	      yyerror(& @1, state, (err_str != NULL)
-		      ? err_str : "invalid condition code");
-
-	      if (err_str != NULL) {
-		 free(err_str);
-	      }
-
-	      YYERROR;
-	   }
-
-	   $$.CondMask = cond;
-	   $$.CondSwizzle = SWIZZLE_NOOP;
-	   $$.CondSrc = 0;
-	}
-	;
-
-namingStatement: ATTRIB_statement
-	| PARAM_statement
-	| TEMP_statement
-	| ADDRESS_statement
-	| OUTPUT_statement
-	| ALIAS_statement
-	;
-
-ATTRIB_statement: ATTRIB IDENTIFIER '=' attribBinding
-	{
-	   struct asm_symbol *const s =
-	      declare_variable(state, $2, at_attrib, & @2);
-
-	   if (s == NULL) {
-	      free($2);
-	      YYERROR;
-	   } else {
-	      s->attrib_binding = $4;
-	      state->InputsBound |= (1U << s->attrib_binding);
-
-	      if (!validate_inputs(& @4, state)) {
-		 YYERROR;
-	      }
-	   }
-	}
-	;
-
-attribBinding: VERTEX vtxAttribItem
-	{
-	   $$ = $2;
-	}
-	| FRAGMENT fragAttribItem
-	{
-	   $$ = $2;
-	}
-	;
-
-vtxAttribItem: POSITION
-	{
-	   $$ = VERT_ATTRIB_POS;
-	}
-	| WEIGHT vtxOptWeightNum
-	{
-	   $$ = VERT_ATTRIB_WEIGHT;
-	}
-	| NORMAL
-	{
-	   $$ = VERT_ATTRIB_NORMAL;
-	}
-	| COLOR optColorType
-	{
-	   if (!state->ctx->Extensions.EXT_secondary_color) {
-	      yyerror(& @2, state, "GL_EXT_secondary_color not supported");
-	      YYERROR;
-	   }
-
-	   $$ = VERT_ATTRIB_COLOR0 + $2;
-	}
-	| FOGCOORD
-	{
-	   if (!state->ctx->Extensions.EXT_fog_coord) {
-	      yyerror(& @1, state, "GL_EXT_fog_coord not supported");
-	      YYERROR;
-	   }
-
-	   $$ = VERT_ATTRIB_FOG;
-	}
-	| TEXCOORD optTexCoordUnitNum
-	{
-	   $$ = VERT_ATTRIB_TEX0 + $2;
-	}
-	| MATRIXINDEX '[' vtxWeightNum ']'
-	{
-	   yyerror(& @1, state, "GL_ARB_matrix_palette not supported");
-	   YYERROR;
-	}
-	| VTXATTRIB '[' vtxAttribNum ']'
-	{
-	   $$ = VERT_ATTRIB_GENERIC0 + $3;
-	}
-	;
-
-vtxAttribNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->limits->MaxAttribs) {
-	      yyerror(& @1, state, "invalid vertex attribute reference");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-vtxOptWeightNum:  | '[' vtxWeightNum ']';
-vtxWeightNum: INTEGER;
-
-fragAttribItem: POSITION
-	{
-	   $$ = FRAG_ATTRIB_WPOS;
-	}
-	| COLOR optColorType
-	{
-	   $$ = FRAG_ATTRIB_COL0 + $2;
-	}
-	| FOGCOORD
-	{
-	   $$ = FRAG_ATTRIB_FOGC;
-	}
-	| TEXCOORD optTexCoordUnitNum
-	{
-	   $$ = FRAG_ATTRIB_TEX0 + $2;
-	}
-	;
-
-PARAM_statement: PARAM_singleStmt | PARAM_multipleStmt;
-
-PARAM_singleStmt: PARAM IDENTIFIER paramSingleInit
-	{
-	   struct asm_symbol *const s =
-	      declare_variable(state, $2, at_param, & @2);
-
-	   if (s == NULL) {
-	      free($2);
-	      YYERROR;
-	   } else {
-	      s->param_binding_type = $3.param_binding_type;
-	      s->param_binding_begin = $3.param_binding_begin;
-	      s->param_binding_length = $3.param_binding_length;
-              s->param_binding_swizzle = $3.param_binding_swizzle;
-	      s->param_is_array = 0;
-	   }
-	}
-	;
-
-PARAM_multipleStmt: PARAM IDENTIFIER '[' optArraySize ']' paramMultipleInit
-	{
-	   if (($4 != 0) && ((unsigned) $4 != $6.param_binding_length)) {
-	      free($2);
-	      yyerror(& @4, state, 
-		      "parameter array size and number of bindings must match");
-	      YYERROR;
-	   } else {
-	      struct asm_symbol *const s =
-		 declare_variable(state, $2, $6.type, & @2);
-
-	      if (s == NULL) {
-		 free($2);
-		 YYERROR;
-	      } else {
-		 s->param_binding_type = $6.param_binding_type;
-		 s->param_binding_begin = $6.param_binding_begin;
-		 s->param_binding_length = $6.param_binding_length;
-                 s->param_binding_swizzle = SWIZZLE_XYZW;
-		 s->param_is_array = 1;
-	      }
-	   }
-	}
-	;
-
-optArraySize:
-	{
-	   $$ = 0;
-	}
-	| INTEGER
-        {
-	   if (($1 < 1) || ((unsigned) $1 > state->limits->MaxParameters)) {
-	      yyerror(& @1, state, "invalid parameter array size");
-	      YYERROR;
-	   } else {
-	      $$ = $1;
-	   }
-	}
-	;
-
-paramSingleInit: '=' paramSingleItemDecl
-	{
-	   $$ = $2;
-	}
-	;
-
-paramMultipleInit: '=' '{' paramMultInitList '}'
-	{
-	   $$ = $3;
-	}
-	;
-
-paramMultInitList: paramMultipleItem
-	| paramMultInitList ',' paramMultipleItem
-	{
-	   $1.param_binding_length += $3.param_binding_length;
-	   $$ = $1;
-	}
-	;
-
-paramSingleItemDecl: stateSingleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_state(state->prog, & $$, $1);
-	}
-	| programSingleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_param(state->prog, & $$, $1);
-	}
-	| paramConstDecl
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_TRUE);
-	}
-	;
-
-paramSingleItemUse: stateSingleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_state(state->prog, & $$, $1);
-	}
-	| programSingleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_param(state->prog, & $$, $1);
-	}
-	| paramConstUse
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_TRUE);
-	}
-	;
-
-paramMultipleItem: stateMultipleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_state(state->prog, & $$, $1);
-	}
-	| programMultipleItem
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_param(state->prog, & $$, $1);
-	}
-	| paramConstDecl
-	{
-	   memset(& $$, 0, sizeof($$));
-	   $$.param_binding_begin = ~0;
-	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_FALSE);
-	}
-	;
-
-stateMultipleItem: stateSingleItem        { memcpy($$, $1, sizeof($$)); }
-	| STATE stateMatrixRows           { memcpy($$, $2, sizeof($$)); }
-	;
-
-stateSingleItem: STATE stateMaterialItem  { memcpy($$, $2, sizeof($$)); }
-	| STATE stateLightItem            { memcpy($$, $2, sizeof($$)); }
-	| STATE stateLightModelItem       { memcpy($$, $2, sizeof($$)); }
-	| STATE stateLightProdItem        { memcpy($$, $2, sizeof($$)); }
-	| STATE stateTexGenItem           { memcpy($$, $2, sizeof($$)); }
-	| STATE stateTexEnvItem           { memcpy($$, $2, sizeof($$)); }
-	| STATE stateFogItem              { memcpy($$, $2, sizeof($$)); }
-	| STATE stateClipPlaneItem        { memcpy($$, $2, sizeof($$)); }
-	| STATE statePointItem            { memcpy($$, $2, sizeof($$)); }
-	| STATE stateMatrixRow            { memcpy($$, $2, sizeof($$)); }
-	| STATE stateDepthItem            { memcpy($$, $2, sizeof($$)); }
-	;
-
-stateMaterialItem: MATERIAL optFaceType stateMatProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_MATERIAL;
-	   $$[1] = $2;
-	   $$[2] = $3;
-	}
-	;
-
-stateMatProperty: ambDiffSpecProperty
-	{
-	   $$ = $1;
-	}
-	| EMISSION
-	{
-	   $$ = STATE_EMISSION;
-	}
-	| SHININESS
-	{
-	   $$ = STATE_SHININESS;
-	}
-	;
-
-stateLightItem: LIGHT '[' stateLightNumber ']' stateLightProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_LIGHT;
-	   $$[1] = $3;
-	   $$[2] = $5;
-	}
-	;
-
-stateLightProperty: ambDiffSpecProperty
-	{
-	   $$ = $1;
-	}
-	| POSITION
-	{
-	   $$ = STATE_POSITION;
-	}
-	| ATTENUATION
-	{
-	   if (!state->ctx->Extensions.EXT_point_parameters) {
-	      yyerror(& @1, state, "GL_ARB_point_parameters not supported");
-	      YYERROR;
-	   }
-
-	   $$ = STATE_ATTENUATION;
-	}
-	| SPOT stateSpotProperty
-	{
-	   $$ = $2;
-	}
-	| HALF
-	{
-	   $$ = STATE_HALF_VECTOR;
-	}
-	;
-
-stateSpotProperty: DIRECTION
-	{
-	   $$ = STATE_SPOT_DIRECTION;
-	}
-	;
-
-stateLightModelItem: LIGHTMODEL stateLModProperty
-	{
-	   $$[0] = $2[0];
-	   $$[1] = $2[1];
-	}
-	;
-
-stateLModProperty: AMBIENT
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_LIGHTMODEL_AMBIENT;
-	}
-	| optFaceType SCENECOLOR
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_LIGHTMODEL_SCENECOLOR;
-	   $$[1] = $1;
-	}
-	;
-
-stateLightProdItem: LIGHTPROD '[' stateLightNumber ']' optFaceType stateLProdProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_LIGHTPROD;
-	   $$[1] = $3;
-	   $$[2] = $5;
-	   $$[3] = $6;
-	}
-	;
-
-stateLProdProperty: ambDiffSpecProperty;
-
-stateTexEnvItem: TEXENV optLegacyTexUnitNum stateTexEnvProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = $3;
-	   $$[1] = $2;
-	}
-	;
-
-stateTexEnvProperty: COLOR
-	{
-	   $$ = STATE_TEXENV_COLOR;
-	}
-	;
-
-ambDiffSpecProperty: AMBIENT
-	{
-	   $$ = STATE_AMBIENT;
-	}
-	| DIFFUSE
-	{
-	   $$ = STATE_DIFFUSE;
-	}
-	| SPECULAR
-	{
-	   $$ = STATE_SPECULAR;
-	}
-	;
-
-stateLightNumber: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxLights) {
-	      yyerror(& @1, state, "invalid light selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-stateTexGenItem: TEXGEN optTexCoordUnitNum stateTexGenType stateTexGenCoord
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_TEXGEN;
-	   $$[1] = $2;
-	   $$[2] = $3 + $4;
-	}
-	;
-
-stateTexGenType: EYE
-	{
-	   $$ = STATE_TEXGEN_EYE_S;
-	}
-	| OBJECT
-	{
-	   $$ = STATE_TEXGEN_OBJECT_S;
-	}
-	;
-stateTexGenCoord: TEXGEN_S
-	{
-	   $$ = STATE_TEXGEN_EYE_S - STATE_TEXGEN_EYE_S;
-	}
-	| TEXGEN_T
-	{
-	   $$ = STATE_TEXGEN_EYE_T - STATE_TEXGEN_EYE_S;
-	}
-	| TEXGEN_R
-	{
-	   $$ = STATE_TEXGEN_EYE_R - STATE_TEXGEN_EYE_S;
-	}
-	| TEXGEN_Q
-	{
-	   $$ = STATE_TEXGEN_EYE_Q - STATE_TEXGEN_EYE_S;
-	}
-	;
-
-stateFogItem: FOG stateFogProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = $2;
-	}
-	;
-
-stateFogProperty: COLOR
-	{
-	   $$ = STATE_FOG_COLOR;
-	}
-	| PARAMS
-	{
-	   $$ = STATE_FOG_PARAMS;
-	}
-	;
-
-stateClipPlaneItem: CLIP '[' stateClipPlaneNum ']' PLANE
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_CLIPPLANE;
-	   $$[1] = $3;
-	}
-	;
-
-stateClipPlaneNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxClipPlanes) {
-	      yyerror(& @1, state, "invalid clip plane selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-statePointItem: POINT_TOK statePointProperty
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = $2;
-	}
-	;
-
-statePointProperty: SIZE_TOK
-	{
-	   $$ = STATE_POINT_SIZE;
-	}
-	| ATTENUATION
-	{
-	   $$ = STATE_POINT_ATTENUATION;
-	}
-	;
-
-stateMatrixRow: stateMatrixItem ROW '[' stateMatrixRowNum ']'
-	{
-	   $$[0] = $1[0];
-	   $$[1] = $1[1];
-	   $$[2] = $4;
-	   $$[3] = $4;
-	   $$[4] = $1[2];
-	}
-	;
-
-stateMatrixRows: stateMatrixItem optMatrixRows
-	{
-	   $$[0] = $1[0];
-	   $$[1] = $1[1];
-	   $$[2] = $2[2];
-	   $$[3] = $2[3];
-	   $$[4] = $1[2];
-	}
-	;
-
-optMatrixRows:
-	{
-	   $$[2] = 0;
-	   $$[3] = 3;
-	}
-	| ROW '[' stateMatrixRowNum DOT_DOT stateMatrixRowNum ']'
-	{
-	   /* It seems logical that the matrix row range specifier would have
-	    * to specify a range or more than one row (i.e., $5 > $3).
-	    * However, the ARB_vertex_program spec says "a program will fail
-	    * to load if <a> is greater than <b>."  This means that $3 == $5
-	    * is valid.
-	    */
-	   if ($3 > $5) {
-	      yyerror(& @3, state, "invalid matrix row range");
-	      YYERROR;
-	   }
-
-	   $$[2] = $3;
-	   $$[3] = $5;
-	}
-	;
-
-stateMatrixItem: MATRIX stateMatrixName stateOptMatModifier
-	{
-	   $$[0] = $2[0];
-	   $$[1] = $2[1];
-	   $$[2] = $3;
-	}
-	;
-
-stateOptMatModifier: 
-	{
-	   $$ = 0;
-	}
-	| stateMatModifier
-	{
-	   $$ = $1;
-	}
-	;
-
-stateMatModifier: INVERSE 
-	{
-	   $$ = STATE_MATRIX_INVERSE;
-	}
-	| TRANSPOSE 
-	{
-	   $$ = STATE_MATRIX_TRANSPOSE;
-	}
-	| INVTRANS
-	{
-	   $$ = STATE_MATRIX_INVTRANS;
-	}
-	;
-
-stateMatrixRowNum: INTEGER
-	{
-	   if ($1 > 3) {
-	      yyerror(& @1, state, "invalid matrix row reference");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-stateMatrixName: MODELVIEW stateOptModMatNum
-	{
-	   $$[0] = STATE_MODELVIEW_MATRIX;
-	   $$[1] = $2;
-	}
-	| PROJECTION
-	{
-	   $$[0] = STATE_PROJECTION_MATRIX;
-	   $$[1] = 0;
-	}
-	| MVP
-	{
-	   $$[0] = STATE_MVP_MATRIX;
-	   $$[1] = 0;
-	}
-	| TEXTURE optTexCoordUnitNum
-	{
-	   $$[0] = STATE_TEXTURE_MATRIX;
-	   $$[1] = $2;
-	}
-	| PALETTE '[' statePaletteMatNum ']'
-	{
-	   yyerror(& @1, state, "GL_ARB_matrix_palette not supported");
-	   YYERROR;
-	}
-	| MAT_PROGRAM '[' stateProgramMatNum ']'
-	{
-	   $$[0] = STATE_PROGRAM_MATRIX;
-	   $$[1] = $3;
-	}
-	;
-
-stateOptModMatNum:
-	{
-	   $$ = 0;
-	}
-	| '[' stateModMatNum ']'
-	{
-	   $$ = $2;
-	}
-	;
-stateModMatNum: INTEGER
-	{
-	   /* Since GL_ARB_vertex_blend isn't supported, only modelview matrix
-	    * zero is valid.
-	    */
-	   if ($1 != 0) {
-	      yyerror(& @1, state, "invalid modelview matrix index");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-statePaletteMatNum: INTEGER
-	{
-	   /* Since GL_ARB_matrix_palette isn't supported, just let any value
-	    * through here.  The error will be generated later.
-	    */
-	   $$ = $1;
-	}
-	;
-stateProgramMatNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxProgramMatrices) {
-	      yyerror(& @1, state, "invalid program matrix selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-stateDepthItem: DEPTH RANGE
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = STATE_DEPTH_RANGE;
-	}
-	;
-
-
-programSingleItem: progEnvParam | progLocalParam;
-
-programMultipleItem: progEnvParams | progLocalParams;
-
-progEnvParams: PROGRAM ENV '[' progEnvParamNums ']'
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = state->state_param_enum;
-	   $$[1] = STATE_ENV;
-	   $$[2] = $4[0];
-	   $$[3] = $4[1];
-	}
-	;
-
-progEnvParamNums: progEnvParamNum
-	{
-	   $$[0] = $1;
-	   $$[1] = $1;
-	}
-	| progEnvParamNum DOT_DOT progEnvParamNum
-	{
-	   $$[0] = $1;
-	   $$[1] = $3;
-	}
-	;
-
-progEnvParam: PROGRAM ENV '[' progEnvParamNum ']'
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = state->state_param_enum;
-	   $$[1] = STATE_ENV;
-	   $$[2] = $4;
-	   $$[3] = $4;
-	}
-	;
-
-progLocalParams: PROGRAM LOCAL '[' progLocalParamNums ']'
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = state->state_param_enum;
-	   $$[1] = STATE_LOCAL;
-	   $$[2] = $4[0];
-	   $$[3] = $4[1];
-	}
-
-progLocalParamNums: progLocalParamNum
-	{
-	   $$[0] = $1;
-	   $$[1] = $1;
-	}
-	| progLocalParamNum DOT_DOT progLocalParamNum
-	{
-	   $$[0] = $1;
-	   $$[1] = $3;
-	}
-	;
-
-progLocalParam: PROGRAM LOCAL '[' progLocalParamNum ']'
-	{
-	   memset($$, 0, sizeof($$));
-	   $$[0] = state->state_param_enum;
-	   $$[1] = STATE_LOCAL;
-	   $$[2] = $4;
-	   $$[3] = $4;
-	}
-	;
-
-progEnvParamNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->limits->MaxEnvParams) {
-	      yyerror(& @1, state, "invalid environment parameter reference");
-	      YYERROR;
-	   }
-	   $$ = $1;
-	}
-	;
-
-progLocalParamNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->limits->MaxLocalParams) {
-	      yyerror(& @1, state, "invalid local parameter reference");
-	      YYERROR;
-	   }
-	   $$ = $1;
-	}
-	;
-
-
-
-paramConstDecl: paramConstScalarDecl | paramConstVector;
-paramConstUse: paramConstScalarUse | paramConstVector;
-
-paramConstScalarDecl: signedFloatConstant
-	{
-	   $$.count = 4;
-	   $$.data[0] = $1;
-	   $$.data[1] = $1;
-	   $$.data[2] = $1;
-	   $$.data[3] = $1;
-	}
-	;
-
-paramConstScalarUse: REAL
-	{
-	   $$.count = 1;
-	   $$.data[0] = $1;
-	   $$.data[1] = $1;
-	   $$.data[2] = $1;
-	   $$.data[3] = $1;
-	}
-	| INTEGER
-	{
-	   $$.count = 1;
-	   $$.data[0] = (float) $1;
-	   $$.data[1] = (float) $1;
-	   $$.data[2] = (float) $1;
-	   $$.data[3] = (float) $1;
-	}
-	;
-
-paramConstVector: '{' signedFloatConstant '}'
-	{
-	   $$.count = 4;
-	   $$.data[0] = $2;
-	   $$.data[1] = 0.0f;
-	   $$.data[2] = 0.0f;
-	   $$.data[3] = 1.0f;
-	}
-	| '{' signedFloatConstant ',' signedFloatConstant '}'
-	{
-	   $$.count = 4;
-	   $$.data[0] = $2;
-	   $$.data[1] = $4;
-	   $$.data[2] = 0.0f;
-	   $$.data[3] = 1.0f;
-	}
-	| '{' signedFloatConstant ',' signedFloatConstant ','
-              signedFloatConstant '}'
-	{
-	   $$.count = 4;
-	   $$.data[0] = $2;
-	   $$.data[1] = $4;
-	   $$.data[2] = $6;
-	   $$.data[3] = 1.0f;
-	}
-	| '{' signedFloatConstant ',' signedFloatConstant ','
-              signedFloatConstant ',' signedFloatConstant '}'
-	{
-	   $$.count = 4;
-	   $$.data[0] = $2;
-	   $$.data[1] = $4;
-	   $$.data[2] = $6;
-	   $$.data[3] = $8;
-	}
-	;
-
-signedFloatConstant: optionalSign REAL
-	{
-	   $$ = ($1) ? -$2 : $2;
-	}
-	| optionalSign INTEGER
-	{
-	   $$ = (float)(($1) ? -$2 : $2);
-	}
-	;
-
-optionalSign: '+'        { $$ = FALSE; }
-	| '-'            { $$ = TRUE;  }
-	|                { $$ = FALSE; }
-	;
-
-TEMP_statement: optVarSize TEMP { $<integer>$ = $2; } varNameList
-	;
-
-optVarSize: string
-	{
-	   /* NV_fragment_program_option defines the size qualifiers in a
-	    * fairly broken way.  "SHORT" or "LONG" can optionally be used
-	    * before TEMP or OUTPUT.  However, neither is a reserved word!
-	    * This means that we have to parse it as an identifier, then check
-	    * to make sure it's one of the valid values.  *sigh*
-	    *
-	    * In addition, the grammar in the extension spec does *not* allow
-	    * the size specifier to be optional, but all known implementations
-	    * do.
-	    */
-	   if (!state->option.NV_fragment) {
-	      yyerror(& @1, state, "unexpected IDENTIFIER");
-	      YYERROR;
-	   }
-
-	   if (strcmp("SHORT", $1) == 0) {
-	   } else if (strcmp("LONG", $1) == 0) {
-	   } else {
-	      char *const err_str =
-		 make_error_string("invalid storage size specifier \"%s\"",
-				   $1);
-
-	      yyerror(& @1, state, (err_str != NULL)
-		      ? err_str : "invalid storage size specifier");
-
-	      if (err_str != NULL) {
-		 free(err_str);
-	      }
-
-	      YYERROR;
-	   }
-	}
-	|
-	{
-	}
-	;
-
-ADDRESS_statement: ADDRESS { $<integer>$ = $1; } varNameList
-	;
-
-varNameList: varNameList ',' IDENTIFIER
-	{
-	   if (!declare_variable(state, $3, $<integer>0, & @3)) {
-	      free($3);
-	      YYERROR;
-	   }
-	}
-	| IDENTIFIER
-	{
-	   if (!declare_variable(state, $1, $<integer>0, & @1)) {
-	      free($1);
-	      YYERROR;
-	   }
-	}
-	;
-
-OUTPUT_statement: optVarSize OUTPUT IDENTIFIER '=' resultBinding
-	{
-	   struct asm_symbol *const s =
-	      declare_variable(state, $3, at_output, & @3);
-
-	   if (s == NULL) {
-	      free($3);
-	      YYERROR;
-	   } else {
-	      s->output_binding = $5;
-	   }
-	}
-	;
-
-resultBinding: RESULT POSITION
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_HPOS;
-	   } else {
-	      yyerror(& @2, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| RESULT FOGCOORD
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_FOGC;
-	   } else {
-	      yyerror(& @2, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| RESULT resultColBinding
-	{
-	   $$ = $2;
-	}
-	| RESULT POINTSIZE
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_PSIZ;
-	   } else {
-	      yyerror(& @2, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| RESULT TEXCOORD optTexCoordUnitNum
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_TEX0 + $3;
-	   } else {
-	      yyerror(& @2, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| RESULT DEPTH
-	{
-	   if (state->mode == ARB_fragment) {
-	      $$ = FRAG_RESULT_DEPTH;
-	   } else {
-	      yyerror(& @2, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	;
-
-resultColBinding: COLOR optResultFaceType optResultColorType
-	{
-	   $$ = $2 + $3;
-	}
-	;
-
-optResultFaceType:
-	{
-	   $$ = (state->mode == ARB_vertex)
-	      ? VERT_RESULT_COL0
-	      : FRAG_RESULT_COLOR;
-	}
-	| FRONT
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_COL0;
-	   } else {
-	      yyerror(& @1, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| BACK
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = VERT_RESULT_BFC0;
-	   } else {
-	      yyerror(& @1, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	;
-
-optResultColorType:
-	{
-	   $$ = 0; 
-	}
-	| PRIMARY
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = 0;
-	   } else {
-	      yyerror(& @1, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	| SECONDARY
-	{
-	   if (state->mode == ARB_vertex) {
-	      $$ = 1;
-	   } else {
-	      yyerror(& @1, state, "invalid program result name");
-	      YYERROR;
-	   }
-	}
-	;
-
-optFaceType:    { $$ = 0; }
-	| FRONT	{ $$ = 0; }
-	| BACK  { $$ = 1; }
-	;
-
-optColorType:       { $$ = 0; }
-	| PRIMARY   { $$ = 0; }
-	| SECONDARY { $$ = 1; }
-	;
-
-optTexCoordUnitNum:                { $$ = 0; }
-	| '[' texCoordUnitNum ']'  { $$ = $2; }
-	;
-
-optTexImageUnitNum:                { $$ = 0; }
-	| '[' texImageUnitNum ']'  { $$ = $2; }
-	;
-
-optLegacyTexUnitNum:               { $$ = 0; }
-	| '[' legacyTexUnitNum ']' { $$ = $2; }
-	;
-
-texCoordUnitNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxTextureCoordUnits) {
-	      yyerror(& @1, state, "invalid texture coordinate unit selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-texImageUnitNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxTextureImageUnits) {
-	      yyerror(& @1, state, "invalid texture image unit selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-legacyTexUnitNum: INTEGER
-	{
-	   if ((unsigned) $1 >= state->MaxTextureUnits) {
-	      yyerror(& @1, state, "invalid texture unit selector");
-	      YYERROR;
-	   }
-
-	   $$ = $1;
-	}
-	;
-
-ALIAS_statement: ALIAS IDENTIFIER '=' USED_IDENTIFIER
-	{
-	   struct asm_symbol *exist = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $2);
-	   struct asm_symbol *target = (struct asm_symbol *)
-	      _mesa_symbol_table_find_symbol(state->st, 0, $4);
-
-	   free($4);
-
-	   if (exist != NULL) {
-	      char m[1000];
-	      _mesa_snprintf(m, sizeof(m), "redeclared identifier: %s", $2);
-	      free($2);
-	      yyerror(& @2, state, m);
-	      YYERROR;
-	   } else if (target == NULL) {
-	      free($2);
-	      yyerror(& @4, state,
-		      "undefined variable binding in ALIAS statement");
-	      YYERROR;
-	   } else {
-	      _mesa_symbol_table_add_symbol(state->st, 0, $2, target);
-	   }
-	}
-	;
-
-string: IDENTIFIER
-	| USED_IDENTIFIER
-	;
-
-%%
-
-void
-asm_instruction_set_operands(struct asm_instruction *inst,
-			     const struct prog_dst_register *dst,
-			     const struct asm_src_register *src0,
-			     const struct asm_src_register *src1,
-			     const struct asm_src_register *src2)
-{
-   /* In the core ARB extensions only the KIL instruction doesn't have a
-    * destination register.
-    */
-   if (dst == NULL) {
-      init_dst_reg(& inst->Base.DstReg);
-   } else {
-      inst->Base.DstReg = *dst;
-   }
-
-   /* The only instruction that doesn't have any source registers is the
-    * condition-code based KIL instruction added by NV_fragment_program_option.
-    */
-   if (src0 != NULL) {
-      inst->Base.SrcReg[0] = src0->Base;
-      inst->SrcReg[0] = *src0;
-   } else {
-      init_src_reg(& inst->SrcReg[0]);
-   }
-
-   if (src1 != NULL) {
-      inst->Base.SrcReg[1] = src1->Base;
-      inst->SrcReg[1] = *src1;
-   } else {
-      init_src_reg(& inst->SrcReg[1]);
-   }
-
-   if (src2 != NULL) {
-      inst->Base.SrcReg[2] = src2->Base;
-      inst->SrcReg[2] = *src2;
-   } else {
-      init_src_reg(& inst->SrcReg[2]);
-   }
-}
-
-
-struct asm_instruction *
-asm_instruction_ctor(gl_inst_opcode op,
-		     const struct prog_dst_register *dst,
-		     const struct asm_src_register *src0,
-		     const struct asm_src_register *src1,
-		     const struct asm_src_register *src2)
-{
-   struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction);
-
-   if (inst) {
-      _mesa_init_instructions(& inst->Base, 1);
-      inst->Base.Opcode = op;
-
-      asm_instruction_set_operands(inst, dst, src0, src1, src2);
-   }
-
-   return inst;
-}
-
-
-struct asm_instruction *
-asm_instruction_copy_ctor(const struct prog_instruction *base,
-			  const struct prog_dst_register *dst,
-			  const struct asm_src_register *src0,
-			  const struct asm_src_register *src1,
-			  const struct asm_src_register *src2)
-{
-   struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction);
-
-   if (inst) {
-      _mesa_init_instructions(& inst->Base, 1);
-      inst->Base.Opcode = base->Opcode;
-      inst->Base.CondUpdate = base->CondUpdate;
-      inst->Base.CondDst = base->CondDst;
-      inst->Base.SaturateMode = base->SaturateMode;
-      inst->Base.Precision = base->Precision;
-
-      asm_instruction_set_operands(inst, dst, src0, src1, src2);
-   }
-
-   return inst;
-}
-
-
-void
-init_dst_reg(struct prog_dst_register *r)
-{
-   memset(r, 0, sizeof(*r));
-   r->File = PROGRAM_UNDEFINED;
-   r->WriteMask = WRITEMASK_XYZW;
-   r->CondMask = COND_TR;
-   r->CondSwizzle = SWIZZLE_NOOP;
-}
-
-
-/** Like init_dst_reg() but set the File and Index fields. */
-void
-set_dst_reg(struct prog_dst_register *r, gl_register_file file, GLint index)
-{
-   const GLint maxIndex = 1 << INST_INDEX_BITS;
-   const GLint minIndex = 0;
-   ASSERT(index >= minIndex);
-   (void) minIndex;
-   ASSERT(index <= maxIndex);
-   (void) maxIndex;
-   ASSERT(file == PROGRAM_TEMPORARY ||
-	  file == PROGRAM_ADDRESS ||
-	  file == PROGRAM_OUTPUT);
-   memset(r, 0, sizeof(*r));
-   r->File = file;
-   r->Index = index;
-   r->WriteMask = WRITEMASK_XYZW;
-   r->CondMask = COND_TR;
-   r->CondSwizzle = SWIZZLE_NOOP;
-}
-
-
-void
-init_src_reg(struct asm_src_register *r)
-{
-   memset(r, 0, sizeof(*r));
-   r->Base.File = PROGRAM_UNDEFINED;
-   r->Base.Swizzle = SWIZZLE_NOOP;
-   r->Symbol = NULL;
-}
-
-
-/** Like init_src_reg() but set the File and Index fields.
- * \return GL_TRUE if a valid src register, GL_FALSE otherwise
- */
-void
-set_src_reg(struct asm_src_register *r, gl_register_file file, GLint index)
-{
-   set_src_reg_swz(r, file, index, SWIZZLE_XYZW);
-}
-
-
-void
-set_src_reg_swz(struct asm_src_register *r, gl_register_file file, GLint index,
-                GLuint swizzle)
-{
-   const GLint maxIndex = (1 << INST_INDEX_BITS) - 1;
-   const GLint minIndex = -(1 << INST_INDEX_BITS);
-   ASSERT(file < PROGRAM_FILE_MAX);
-   ASSERT(index >= minIndex);
-   (void) minIndex;
-   ASSERT(index <= maxIndex);
-   (void) maxIndex;
-   memset(r, 0, sizeof(*r));
-   r->Base.File = file;
-   r->Base.Index = index;
-   r->Base.Swizzle = swizzle;
-   r->Symbol = NULL;
-}
-
-
-/**
- * Validate the set of inputs used by a program
- *
- * Validates that legal sets of inputs are used by the program.  In this case
- * "used" included both reading the input or binding the input to a name using
- * the \c ATTRIB command.
- *
- * \return
- * \c TRUE if the combination of inputs used is valid, \c FALSE otherwise.
- */
-int
-validate_inputs(struct YYLTYPE *locp, struct asm_parser_state *state)
-{
-   const int inputs = state->prog->InputsRead | state->InputsBound;
-
-   if (((inputs & 0x0ffff) & (inputs >> 16)) != 0) {
-      yyerror(locp, state, "illegal use of generic attribute and name attribute");
-      return 0;
-   }
-
-   return 1;
-}
-
-
-struct asm_symbol *
-declare_variable(struct asm_parser_state *state, char *name, enum asm_type t,
-		 struct YYLTYPE *locp)
-{
-   struct asm_symbol *s = NULL;
-   struct asm_symbol *exist = (struct asm_symbol *)
-      _mesa_symbol_table_find_symbol(state->st, 0, name);
-
-
-   if (exist != NULL) {
-      yyerror(locp, state, "redeclared identifier");
-   } else {
-      s = calloc(1, sizeof(struct asm_symbol));
-      s->name = name;
-      s->type = t;
-
-      switch (t) {
-      case at_temp:
-	 if (state->prog->NumTemporaries >= state->limits->MaxTemps) {
-	    yyerror(locp, state, "too many temporaries declared");
-	    free(s);
-	    return NULL;
-	 }
-
-	 s->temp_binding = state->prog->NumTemporaries;
-	 state->prog->NumTemporaries++;
-	 break;
-
-      case at_address:
-	 if (state->prog->NumAddressRegs >= state->limits->MaxAddressRegs) {
-	    yyerror(locp, state, "too many address registers declared");
-	    free(s);
-	    return NULL;
-	 }
-
-	 /* FINISHME: Add support for multiple address registers.
-	  */
-	 state->prog->NumAddressRegs++;
-	 break;
-
-      default:
-	 break;
-      }
-
-      _mesa_symbol_table_add_symbol(state->st, 0, s->name, s);
-      s->next = state->sym;
-      state->sym = s;
-   }
-
-   return s;
-}
-
-
-int add_state_reference(struct gl_program_parameter_list *param_list,
-			const gl_state_index tokens[STATE_LENGTH])
-{
-   const GLuint size = 4; /* XXX fix */
-   char *name;
-   GLint index;
-
-   name = _mesa_program_state_string(tokens);
-   index = _mesa_add_parameter(param_list, PROGRAM_STATE_VAR, name,
-                               size, GL_NONE, NULL, tokens, 0x0);
-   param_list->StateFlags |= _mesa_program_state_flags(tokens);
-
-   /* free name string here since we duplicated it in add_parameter() */
-   free(name);
-
-   return index;
-}
-
-
-int
-initialize_symbol_from_state(struct gl_program *prog,
-			     struct asm_symbol *param_var, 
-			     const gl_state_index tokens[STATE_LENGTH])
-{
-   int idx = -1;
-   gl_state_index state_tokens[STATE_LENGTH];
-
-
-   memcpy(state_tokens, tokens, sizeof(state_tokens));
-
-   param_var->type = at_param;
-   param_var->param_binding_type = PROGRAM_STATE_VAR;
-
-   /* If we are adding a STATE_MATRIX that has multiple rows, we need to
-    * unroll it and call add_state_reference() for each row
-    */
-   if ((state_tokens[0] == STATE_MODELVIEW_MATRIX ||
-	state_tokens[0] == STATE_PROJECTION_MATRIX ||
-	state_tokens[0] == STATE_MVP_MATRIX ||
-	state_tokens[0] == STATE_TEXTURE_MATRIX ||
-	state_tokens[0] == STATE_PROGRAM_MATRIX)
-       && (state_tokens[2] != state_tokens[3])) {
-      int row;
-      const int first_row = state_tokens[2];
-      const int last_row = state_tokens[3];
-
-      for (row = first_row; row <= last_row; row++) {
-	 state_tokens[2] = state_tokens[3] = row;
-
-	 idx = add_state_reference(prog->Parameters, state_tokens);
-	 if (param_var->param_binding_begin == ~0U) {
-	    param_var->param_binding_begin = idx;
-            param_var->param_binding_swizzle = SWIZZLE_XYZW;
-         }
-
-	 param_var->param_binding_length++;
-      }
-   }
-   else {
-      idx = add_state_reference(prog->Parameters, state_tokens);
-      if (param_var->param_binding_begin == ~0U) {
-	 param_var->param_binding_begin = idx;
-         param_var->param_binding_swizzle = SWIZZLE_XYZW;
-      }
-      param_var->param_binding_length++;
-   }
-
-   return idx;
-}
-
-
-int
-initialize_symbol_from_param(struct gl_program *prog,
-			     struct asm_symbol *param_var, 
-			     const gl_state_index tokens[STATE_LENGTH])
-{
-   int idx = -1;
-   gl_state_index state_tokens[STATE_LENGTH];
-
-
-   memcpy(state_tokens, tokens, sizeof(state_tokens));
-
-   assert((state_tokens[0] == STATE_VERTEX_PROGRAM)
-	  || (state_tokens[0] == STATE_FRAGMENT_PROGRAM));
-   assert((state_tokens[1] == STATE_ENV)
-	  || (state_tokens[1] == STATE_LOCAL));
-
-   /*
-    * The param type is STATE_VAR.  The program parameter entry will
-    * effectively be a pointer into the LOCAL or ENV parameter array.
-    */
-   param_var->type = at_param;
-   param_var->param_binding_type = PROGRAM_STATE_VAR;
-
-   /* If we are adding a STATE_ENV or STATE_LOCAL that has multiple elements,
-    * we need to unroll it and call add_state_reference() for each row
-    */
-   if (state_tokens[2] != state_tokens[3]) {
-      int row;
-      const int first_row = state_tokens[2];
-      const int last_row = state_tokens[3];
-
-      for (row = first_row; row <= last_row; row++) {
-	 state_tokens[2] = state_tokens[3] = row;
-
-	 idx = add_state_reference(prog->Parameters, state_tokens);
-	 if (param_var->param_binding_begin == ~0U) {
-	    param_var->param_binding_begin = idx;
-            param_var->param_binding_swizzle = SWIZZLE_XYZW;
-         }
-	 param_var->param_binding_length++;
-      }
-   }
-   else {
-      idx = add_state_reference(prog->Parameters, state_tokens);
-      if (param_var->param_binding_begin == ~0U) {
-	 param_var->param_binding_begin = idx;
-         param_var->param_binding_swizzle = SWIZZLE_XYZW;
-      }
-      param_var->param_binding_length++;
-   }
-
-   return idx;
-}
-
-
-/**
- * Put a float/vector constant/literal into the parameter list.
- * \param param_var  returns info about the parameter/constant's location,
- *                   binding, type, etc.
- * \param vec  the vector/constant to add
- * \param allowSwizzle  if true, try to consolidate constants which only differ
- *                      by a swizzle.  We don't want to do this when building
- *                      arrays of constants that may be indexed indirectly.
- * \return index of the constant in the parameter list.
- */
-int
-initialize_symbol_from_const(struct gl_program *prog,
-			     struct asm_symbol *param_var, 
-			     const struct asm_vector *vec,
-                             GLboolean allowSwizzle)
-{
-   unsigned swizzle;
-   const int idx = _mesa_add_unnamed_constant(prog->Parameters,
-                                              vec->data, vec->count,
-                                              allowSwizzle ? &swizzle : NULL);
-
-   param_var->type = at_param;
-   param_var->param_binding_type = PROGRAM_CONSTANT;
-
-   if (param_var->param_binding_begin == ~0U) {
-      param_var->param_binding_begin = idx;
-      param_var->param_binding_swizzle = allowSwizzle ? swizzle : SWIZZLE_XYZW;
-   }
-   param_var->param_binding_length++;
-
-   return idx;
-}
-
-
-char *
-make_error_string(const char *fmt, ...)
-{
-   int length;
-   char *str;
-   va_list args;
-
-
-   /* Call vsnprintf once to determine how large the final string is.  Call it
-    * again to do the actual formatting.  from the vsnprintf manual page:
-    *
-    *    Upon successful return, these functions return the number of
-    *    characters printed  (not including the trailing '\0' used to end
-    *    output to strings).
-    */
-   va_start(args, fmt);
-   length = 1 + vsnprintf(NULL, 0, fmt, args);
-   va_end(args);
-
-   str = malloc(length);
-   if (str) {
-      va_start(args, fmt);
-      vsnprintf(str, length, fmt, args);
-      va_end(args);
-   }
-
-   return str;
-}
-
-
-void
-yyerror(YYLTYPE *locp, struct asm_parser_state *state, const char *s)
-{
-   char *err_str;
-
-
-   err_str = make_error_string("glProgramStringARB(%s)\n", s);
-   if (err_str) {
-      _mesa_error(state->ctx, GL_INVALID_OPERATION, "%s", err_str);
-      free(err_str);
-   }
-
-   err_str = make_error_string("line %u, char %u: error: %s\n",
-			       locp->first_line, locp->first_column, s);
-   _mesa_set_program_error(state->ctx, locp->position, err_str);
-
-   if (err_str) {
-      free(err_str);
-   }
-}
-
-
-GLboolean
-_mesa_parse_arb_program(struct gl_context *ctx, GLenum target, const GLubyte *str,
-			GLsizei len, struct asm_parser_state *state)
-{
-   struct asm_instruction *inst;
-   unsigned i;
-   GLubyte *strz;
-   GLboolean result = GL_FALSE;
-   void *temp;
-   struct asm_symbol *sym;
-
-   state->ctx = ctx;
-   state->prog->Target = target;
-   state->prog->Parameters = _mesa_new_parameter_list();
-
-   /* Make a copy of the program string and force it to be NUL-terminated.
-    */
-   strz = (GLubyte *) malloc(len + 1);
-   if (strz == NULL) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
-      return GL_FALSE;
-   }
-   memcpy (strz, str, len);
-   strz[len] = '\0';
-
-   state->prog->String = strz;
-
-   state->st = _mesa_symbol_table_ctor();
-
-   state->limits = (target == GL_VERTEX_PROGRAM_ARB)
-      ? & ctx->Const.VertexProgram
-      : & ctx->Const.FragmentProgram;
-
-   state->MaxTextureImageUnits = ctx->Const.MaxTextureImageUnits;
-   state->MaxTextureCoordUnits = ctx->Const.MaxTextureCoordUnits;
-   state->MaxTextureUnits = ctx->Const.MaxTextureUnits;
-   state->MaxClipPlanes = ctx->Const.MaxClipPlanes;
-   state->MaxLights = ctx->Const.MaxLights;
-   state->MaxProgramMatrices = ctx->Const.MaxProgramMatrices;
-
-   state->state_param_enum = (target == GL_VERTEX_PROGRAM_ARB)
-      ? STATE_VERTEX_PROGRAM : STATE_FRAGMENT_PROGRAM;
-
-   _mesa_set_program_error(ctx, -1, NULL);
-
-   _mesa_program_lexer_ctor(& state->scanner, state, (const char *) str, len);
-   yyparse(state);
-   _mesa_program_lexer_dtor(state->scanner);
-
-
-   if (ctx->Program.ErrorPos != -1) {
-      goto error;
-   }
-
-   if (! _mesa_layout_parameters(state)) {
-      struct YYLTYPE loc;
-
-      loc.first_line = 0;
-      loc.first_column = 0;
-      loc.position = len;
-
-      yyerror(& loc, state, "invalid PARAM usage");
-      goto error;
-   }
-
-
-   
-   /* Add one instruction to store the "END" instruction.
-    */
-   state->prog->Instructions =
-      _mesa_alloc_instructions(state->prog->NumInstructions + 1);
-   inst = state->inst_head;
-   for (i = 0; i < state->prog->NumInstructions; i++) {
-      struct asm_instruction *const temp = inst->next;
-
-      state->prog->Instructions[i] = inst->Base;
-      inst = temp;
-   }
-
-   /* Finally, tag on an OPCODE_END instruction */
-   {
-      const GLuint numInst = state->prog->NumInstructions;
-      _mesa_init_instructions(state->prog->Instructions + numInst, 1);
-      state->prog->Instructions[numInst].Opcode = OPCODE_END;
-   }
-   state->prog->NumInstructions++;
-
-   state->prog->NumParameters = state->prog->Parameters->NumParameters;
-   state->prog->NumAttributes = _mesa_bitcount(state->prog->InputsRead);
-
-   /*
-    * Initialize native counts to logical counts.  The device driver may
-    * change them if program is translated into a hardware program.
-    */
-   state->prog->NumNativeInstructions = state->prog->NumInstructions;
-   state->prog->NumNativeTemporaries = state->prog->NumTemporaries;
-   state->prog->NumNativeParameters = state->prog->NumParameters;
-   state->prog->NumNativeAttributes = state->prog->NumAttributes;
-   state->prog->NumNativeAddressRegs = state->prog->NumAddressRegs;
-
-   result = GL_TRUE;
-
-error:
-   for (inst = state->inst_head; inst != NULL; inst = temp) {
-      temp = inst->next;
-      free(inst);
-   }
-
-   state->inst_head = NULL;
-   state->inst_tail = NULL;
-
-   for (sym = state->sym; sym != NULL; sym = temp) {
-      temp = sym->next;
-
-      free((void *) sym->name);
-      free(sym);
-   }
-   state->sym = NULL;
-
-   _mesa_symbol_table_dtor(state->st);
-   state->st = NULL;
-
-   return result;
-}
+%{

+/*

+ * Copyright © 2009 Intel Corporation

+ *

+ * 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, sublicense,

+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "main/mtypes.h"

+#include "main/imports.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "program/prog_parameter_layout.h"

+#include "program/prog_statevars.h"

+#include "program/prog_instruction.h"

+

+#include "program/symbol_table.h"

+#include "program/program_parser.h"

+

+extern void *yy_scan_string(char *);

+extern void yy_delete_buffer(void *);

+

+static struct asm_symbol *declare_variable(struct asm_parser_state *state,

+    char *name, enum asm_type t, struct YYLTYPE *locp);

+

+static int add_state_reference(struct gl_program_parameter_list *param_list,

+    const gl_state_index tokens[STATE_LENGTH]);

+

+static int initialize_symbol_from_state(struct gl_program *prog,

+    struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]);

+

+static int initialize_symbol_from_param(struct gl_program *prog,

+    struct asm_symbol *param_var, const gl_state_index tokens[STATE_LENGTH]);

+

+static int initialize_symbol_from_const(struct gl_program *prog,

+    struct asm_symbol *param_var, const struct asm_vector *vec,

+    GLboolean allowSwizzle);

+

+static int yyparse(struct asm_parser_state *state);

+

+static char *make_error_string(const char *fmt, ...);

+

+static void yyerror(struct YYLTYPE *locp, struct asm_parser_state *state,

+    const char *s);

+

+static int validate_inputs(struct YYLTYPE *locp,

+    struct asm_parser_state *state);

+

+static void init_dst_reg(struct prog_dst_register *r);

+

+static void set_dst_reg(struct prog_dst_register *r,

+                        gl_register_file file, GLint index);

+

+static void init_src_reg(struct asm_src_register *r);

+

+static void set_src_reg(struct asm_src_register *r,

+                        gl_register_file file, GLint index);

+

+static void set_src_reg_swz(struct asm_src_register *r,

+                            gl_register_file file, GLint index, GLuint swizzle);

+

+static void asm_instruction_set_operands(struct asm_instruction *inst,

+    const struct prog_dst_register *dst, const struct asm_src_register *src0,

+    const struct asm_src_register *src1, const struct asm_src_register *src2);

+

+static struct asm_instruction *asm_instruction_ctor(gl_inst_opcode op,

+    const struct prog_dst_register *dst, const struct asm_src_register *src0,

+    const struct asm_src_register *src1, const struct asm_src_register *src2);

+

+static struct asm_instruction *asm_instruction_copy_ctor(

+    const struct prog_instruction *base, const struct prog_dst_register *dst,

+    const struct asm_src_register *src0, const struct asm_src_register *src1,

+    const struct asm_src_register *src2);

+

+#ifndef FALSE

+#define FALSE 0

+#define TRUE (!FALSE)

+#endif

+

+#define YYLLOC_DEFAULT(Current, Rhs, N)					\

+   do {									\

+      if (YYID(N)) {							\

+	 (Current).first_line = YYRHSLOC(Rhs, 1).first_line;		\

+	 (Current).first_column = YYRHSLOC(Rhs, 1).first_column;	\

+	 (Current).position = YYRHSLOC(Rhs, 1).position;		\

+	 (Current).last_line = YYRHSLOC(Rhs, N).last_line;		\

+	 (Current).last_column = YYRHSLOC(Rhs, N).last_column;		\

+      } else {								\

+	 (Current).first_line = YYRHSLOC(Rhs, 0).last_line;		\

+	 (Current).last_line = (Current).first_line;			\

+	 (Current).first_column = YYRHSLOC(Rhs, 0).last_column;		\

+	 (Current).last_column = (Current).first_column;		\

+	 (Current).position = YYRHSLOC(Rhs, 0).position			\

+	    + (Current).first_column;					\

+      }									\

+   } while(YYID(0))

+

+#define YYLEX_PARAM state->scanner

+%}

+

+%pure-parser

+%locations

+%parse-param { struct asm_parser_state *state }

+%error-verbose

+%lex-param { void *scanner }

+

+%union {

+   struct asm_instruction *inst;

+   struct asm_symbol *sym;

+   struct asm_symbol temp_sym;

+   struct asm_swizzle_mask swiz_mask;

+   struct asm_src_register src_reg;

+   struct prog_dst_register dst_reg;

+   struct prog_instruction temp_inst;

+   char *string;

+   unsigned result;

+   unsigned attrib;

+   int integer;

+   float real;

+   gl_state_index state[STATE_LENGTH];

+   int negate;

+   struct asm_vector vector;

+   gl_inst_opcode opcode;

+

+   struct {

+      unsigned swz;

+      unsigned rgba_valid:1;

+      unsigned xyzw_valid:1;

+      unsigned negate:1;

+   } ext_swizzle;

+}

+

+%token ARBvp_10 ARBfp_10

+

+/* Tokens for assembler pseudo-ops */

+%token <integer> ADDRESS

+%token ALIAS ATTRIB

+%token OPTION OUTPUT

+%token PARAM

+%token <integer> TEMP

+%token END

+

+ /* Tokens for instructions */

+%token <temp_inst> BIN_OP BINSC_OP SAMPLE_OP SCALAR_OP TRI_OP VECTOR_OP

+%token <temp_inst> ARL KIL SWZ TXD_OP

+

+%token <integer> INTEGER

+%token <real> REAL

+

+%token AMBIENT ATTENUATION

+%token BACK

+%token CLIP COLOR

+%token DEPTH DIFFUSE DIRECTION

+%token EMISSION ENV EYE

+%token FOG FOGCOORD FRAGMENT FRONT

+%token HALF

+%token INVERSE INVTRANS

+%token LIGHT LIGHTMODEL LIGHTPROD LOCAL

+%token MATERIAL MAT_PROGRAM MATRIX MATRIXINDEX MODELVIEW MVP

+%token NORMAL

+%token OBJECT

+%token PALETTE PARAMS PLANE POINT_TOK POINTSIZE POSITION PRIMARY PROGRAM PROJECTION

+%token RANGE RESULT ROW

+%token SCENECOLOR SECONDARY SHININESS SIZE_TOK SPECULAR SPOT STATE

+%token TEXCOORD TEXENV TEXGEN TEXGEN_Q TEXGEN_R TEXGEN_S TEXGEN_T TEXTURE TRANSPOSE

+%token TEXTURE_UNIT TEX_1D TEX_2D TEX_3D TEX_CUBE TEX_RECT

+%token TEX_SHADOW1D TEX_SHADOW2D TEX_SHADOWRECT

+%token TEX_ARRAY1D TEX_ARRAY2D TEX_ARRAYSHADOW1D TEX_ARRAYSHADOW2D 

+%token VERTEX VTXATTRIB

+%token WEIGHT

+

+%token <string> IDENTIFIER USED_IDENTIFIER

+%type <string> string

+%token <swiz_mask> MASK4 MASK3 MASK2 MASK1 SWIZZLE

+%token DOT_DOT

+%token DOT

+

+%type <inst> instruction ALU_instruction TexInstruction

+%type <inst> ARL_instruction VECTORop_instruction

+%type <inst> SCALARop_instruction BINSCop_instruction BINop_instruction

+%type <inst> TRIop_instruction TXD_instruction SWZ_instruction SAMPLE_instruction

+%type <inst> KIL_instruction

+

+%type <dst_reg> dstReg maskedDstReg maskedAddrReg

+%type <src_reg> srcReg scalarUse scalarSrcReg swizzleSrcReg

+%type <swiz_mask> scalarSuffix swizzleSuffix extendedSwizzle

+%type <ext_swizzle> extSwizComp extSwizSel

+%type <swiz_mask> optionalMask

+

+%type <sym> progParamArray

+%type <integer> addrRegRelOffset addrRegPosOffset addrRegNegOffset

+%type <src_reg> progParamArrayMem progParamArrayAbs progParamArrayRel

+%type <sym> addrReg

+%type <swiz_mask> addrComponent addrWriteMask

+

+%type <dst_reg> ccMaskRule ccTest ccMaskRule2 ccTest2 optionalCcMask

+

+%type <result> resultBinding resultColBinding

+%type <integer> optFaceType optColorType

+%type <integer> optResultFaceType optResultColorType

+

+%type <integer> optTexImageUnitNum texImageUnitNum

+%type <integer> optTexCoordUnitNum texCoordUnitNum

+%type <integer> optLegacyTexUnitNum legacyTexUnitNum

+%type <integer> texImageUnit texTarget

+%type <integer> vtxAttribNum

+

+%type <attrib> attribBinding vtxAttribItem fragAttribItem

+

+%type <temp_sym> paramSingleInit paramSingleItemDecl

+%type <integer> optArraySize

+

+%type <state> stateSingleItem stateMultipleItem

+%type <state> stateMaterialItem

+%type <state> stateLightItem stateLightModelItem stateLightProdItem

+%type <state> stateTexGenItem stateFogItem stateClipPlaneItem statePointItem

+%type <state> stateMatrixItem stateMatrixRow stateMatrixRows

+%type <state> stateTexEnvItem stateDepthItem

+

+%type <state> stateLModProperty

+%type <state> stateMatrixName optMatrixRows

+

+%type <integer> stateMatProperty

+%type <integer> stateLightProperty stateSpotProperty

+%type <integer> stateLightNumber stateLProdProperty

+%type <integer> stateTexGenType stateTexGenCoord

+%type <integer> stateTexEnvProperty

+%type <integer> stateFogProperty

+%type <integer> stateClipPlaneNum

+%type <integer> statePointProperty

+

+%type <integer> stateOptMatModifier stateMatModifier stateMatrixRowNum

+%type <integer> stateOptModMatNum stateModMatNum statePaletteMatNum 

+%type <integer> stateProgramMatNum

+

+%type <integer> ambDiffSpecProperty

+

+%type <state> programSingleItem progEnvParam progLocalParam

+%type <state> programMultipleItem progEnvParams progLocalParams

+

+%type <temp_sym> paramMultipleInit paramMultInitList paramMultipleItem

+%type <temp_sym> paramSingleItemUse

+

+%type <integer> progEnvParamNum progLocalParamNum

+%type <state> progEnvParamNums progLocalParamNums

+

+%type <vector> paramConstDecl paramConstUse

+%type <vector> paramConstScalarDecl paramConstScalarUse paramConstVector

+%type <real> signedFloatConstant

+%type <negate> optionalSign

+

+%{

+extern int yylex(YYSTYPE *yylval_param, YYLTYPE *yylloc_param,

+    void *yyscanner);

+%}

+

+%%

+

+program: language optionSequence statementSequence END

+	;

+

+language: ARBvp_10

+	{

+	   if (state->prog->Target != GL_VERTEX_PROGRAM_ARB) {

+	      yyerror(& @1, state, "invalid fragment program header");

+

+	   }

+	   state->mode = ARB_vertex;

+	}

+	| ARBfp_10

+	{

+	   if (state->prog->Target != GL_FRAGMENT_PROGRAM_ARB) {

+	      yyerror(& @1, state, "invalid vertex program header");

+	   }

+	   state->mode = ARB_fragment;

+

+	   state->option.TexRect =

+	      (state->ctx->Extensions.NV_texture_rectangle != GL_FALSE);

+	}

+	;

+

+optionSequence: optionSequence option

+	|

+	;

+

+option: OPTION string ';'

+	{

+	   int valid = 0;

+

+	   if (state->mode == ARB_vertex) {

+	      valid = _mesa_ARBvp_parse_option(state, $2);

+	   } else if (state->mode == ARB_fragment) {

+	      valid = _mesa_ARBfp_parse_option(state, $2);

+	   }

+

+

+	   free($2);

+

+	   if (!valid) {

+	      const char *const err_str = (state->mode == ARB_vertex)

+		 ? "invalid ARB vertex program option"

+		 : "invalid ARB fragment program option";

+

+	      yyerror(& @2, state, err_str);

+	      YYERROR;

+	   }

+	}

+	;

+

+statementSequence: statementSequence statement

+	|

+	;

+

+statement: instruction ';'

+	{

+	   if ($1 != NULL) {

+	      if (state->inst_tail == NULL) {

+		 state->inst_head = $1;

+	      } else {

+		 state->inst_tail->next = $1;

+	      }

+

+	      state->inst_tail = $1;

+	      $1->next = NULL;

+

+	      state->prog->NumInstructions++;

+	   }

+	}

+	| namingStatement ';'

+	;

+

+instruction: ALU_instruction

+	{

+	   $$ = $1;

+	   state->prog->NumAluInstructions++;

+	}

+	| TexInstruction

+	{

+	   $$ = $1;

+	   state->prog->NumTexInstructions++;

+	}

+	;

+

+ALU_instruction: ARL_instruction

+	| VECTORop_instruction

+	| SCALARop_instruction

+	| BINSCop_instruction

+	| BINop_instruction

+	| TRIop_instruction

+	| SWZ_instruction

+	;

+

+TexInstruction: SAMPLE_instruction

+	| KIL_instruction

+	| TXD_instruction

+	;

+

+ARL_instruction: ARL maskedAddrReg ',' scalarSrcReg

+	{

+	   $$ = asm_instruction_ctor(OPCODE_ARL, & $2, & $4, NULL, NULL);

+	}

+	;

+

+VECTORop_instruction: VECTOR_OP maskedDstReg ',' swizzleSrcReg

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);

+	}

+	;

+

+SCALARop_instruction: SCALAR_OP maskedDstReg ',' scalarSrcReg

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);

+	}

+	;

+

+BINSCop_instruction: BINSC_OP maskedDstReg ',' scalarSrcReg ',' scalarSrcReg

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, NULL);

+	}

+	;

+

+

+BINop_instruction: BIN_OP maskedDstReg ',' swizzleSrcReg ',' swizzleSrcReg

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, NULL);

+	}

+	;

+

+TRIop_instruction: TRI_OP maskedDstReg ','

+                   swizzleSrcReg ',' swizzleSrcReg ',' swizzleSrcReg

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, & $8);

+	}

+	;

+

+SAMPLE_instruction: SAMPLE_OP maskedDstReg ',' swizzleSrcReg ',' texImageUnit ',' texTarget

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);

+	   if ($$ != NULL) {

+	      const GLbitfield tex_mask = (1U << $6);

+	      GLbitfield shadow_tex = 0;

+	      GLbitfield target_mask = 0;

+

+

+	      $$->Base.TexSrcUnit = $6;

+

+	      if ($8 < 0) {

+		 shadow_tex = tex_mask;

+

+		 $$->Base.TexSrcTarget = -$8;

+		 $$->Base.TexShadow = 1;

+	      } else {

+		 $$->Base.TexSrcTarget = $8;

+	      }

+

+	      target_mask = (1U << $$->Base.TexSrcTarget);

+

+	      /* If this texture unit was previously accessed and that access

+	       * had a different texture target, generate an error.

+	       *

+	       * If this texture unit was previously accessed and that access

+	       * had a different shadow mode, generate an error.

+	       */

+	      if ((state->prog->TexturesUsed[$6] != 0)

+		  && ((state->prog->TexturesUsed[$6] != target_mask)

+		      || ((state->prog->ShadowSamplers & tex_mask)

+			  != shadow_tex))) {

+		 yyerror(& @8, state,

+			 "multiple targets used on one texture image unit");

+		 YYERROR;

+	      }

+

+

+	      state->prog->TexturesUsed[$6] |= target_mask;

+	      state->prog->ShadowSamplers |= shadow_tex;

+	   }

+	}

+	;

+

+KIL_instruction: KIL swizzleSrcReg

+	{

+	   $$ = asm_instruction_ctor(OPCODE_KIL, NULL, & $2, NULL, NULL);

+	   state->fragment.UsesKill = 1;

+	}

+	| KIL ccTest

+	{

+	   $$ = asm_instruction_ctor(OPCODE_KIL_NV, NULL, NULL, NULL, NULL);

+	   $$->Base.DstReg.CondMask = $2.CondMask;

+	   $$->Base.DstReg.CondSwizzle = $2.CondSwizzle;

+	   $$->Base.DstReg.CondSrc = $2.CondSrc;

+	   state->fragment.UsesKill = 1;

+	}

+	;

+

+TXD_instruction: TXD_OP maskedDstReg ',' swizzleSrcReg ',' swizzleSrcReg ',' swizzleSrcReg ',' texImageUnit ',' texTarget

+	{

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, & $6, & $8);

+	   if ($$ != NULL) {

+	      const GLbitfield tex_mask = (1U << $10);

+	      GLbitfield shadow_tex = 0;

+	      GLbitfield target_mask = 0;

+

+

+	      $$->Base.TexSrcUnit = $10;

+

+	      if ($12 < 0) {

+		 shadow_tex = tex_mask;

+

+		 $$->Base.TexSrcTarget = -$12;

+		 $$->Base.TexShadow = 1;

+	      } else {

+		 $$->Base.TexSrcTarget = $12;

+	      }

+

+	      target_mask = (1U << $$->Base.TexSrcTarget);

+

+	      /* If this texture unit was previously accessed and that access

+	       * had a different texture target, generate an error.

+	       *

+	       * If this texture unit was previously accessed and that access

+	       * had a different shadow mode, generate an error.

+	       */

+	      if ((state->prog->TexturesUsed[$10] != 0)

+		  && ((state->prog->TexturesUsed[$10] != target_mask)

+		      || ((state->prog->ShadowSamplers & tex_mask)

+			  != shadow_tex))) {

+		 yyerror(& @12, state,

+			 "multiple targets used on one texture image unit");

+		 YYERROR;

+	      }

+

+

+	      state->prog->TexturesUsed[$10] |= target_mask;

+	      state->prog->ShadowSamplers |= shadow_tex;

+	   }

+	}

+	;

+

+texImageUnit: TEXTURE_UNIT optTexImageUnitNum

+	{

+	   $$ = $2;

+	}

+	;

+

+texTarget: TEX_1D  { $$ = TEXTURE_1D_INDEX; }

+	| TEX_2D   { $$ = TEXTURE_2D_INDEX; }

+	| TEX_3D   { $$ = TEXTURE_3D_INDEX; }

+	| TEX_CUBE { $$ = TEXTURE_CUBE_INDEX; }

+	| TEX_RECT { $$ = TEXTURE_RECT_INDEX; }

+	| TEX_SHADOW1D   { $$ = -TEXTURE_1D_INDEX; }

+	| TEX_SHADOW2D   { $$ = -TEXTURE_2D_INDEX; }

+	| TEX_SHADOWRECT { $$ = -TEXTURE_RECT_INDEX; }

+	| TEX_ARRAY1D         { $$ = TEXTURE_1D_ARRAY_INDEX; }

+	| TEX_ARRAY2D         { $$ = TEXTURE_2D_ARRAY_INDEX; }

+	| TEX_ARRAYSHADOW1D   { $$ = -TEXTURE_1D_ARRAY_INDEX; }

+	| TEX_ARRAYSHADOW2D   { $$ = -TEXTURE_2D_ARRAY_INDEX; }

+	;

+

+SWZ_instruction: SWZ maskedDstReg ',' srcReg ',' extendedSwizzle

+	{

+	   /* FIXME: Is this correct?  Should the extenedSwizzle be applied

+	    * FIXME: to the existing swizzle?

+	    */

+	   $4.Base.Swizzle = $6.swizzle;

+	   $4.Base.Negate = $6.mask;

+

+	   $$ = asm_instruction_copy_ctor(& $1, & $2, & $4, NULL, NULL);

+	}

+	;

+

+scalarSrcReg: optionalSign scalarUse

+	{

+	   $$ = $2;

+

+	   if ($1) {

+	      $$.Base.Negate = ~$$.Base.Negate;

+	   }

+	}

+	| optionalSign '|' scalarUse '|'

+	{

+	   $$ = $3;

+

+	   if (!state->option.NV_fragment) {

+	      yyerror(& @2, state, "unexpected character '|'");

+	      YYERROR;

+	   }

+

+	   if ($1) {

+	      $$.Base.Negate = ~$$.Base.Negate;

+	   }

+

+	   $$.Base.Abs = 1;

+	}

+	;

+

+scalarUse:  srcReg scalarSuffix

+	{

+	   $$ = $1;

+

+	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,

+						    $2.swizzle);

+	}

+	| paramConstScalarUse

+	{

+	   struct asm_symbol temp_sym;

+

+	   if (!state->option.NV_fragment) {

+	      yyerror(& @1, state, "expected scalar suffix");

+	      YYERROR;

+	   }

+

+	   memset(& temp_sym, 0, sizeof(temp_sym));

+	   temp_sym.param_binding_begin = ~0;

+	   initialize_symbol_from_const(state->prog, & temp_sym, & $1, GL_TRUE);

+

+	   set_src_reg_swz(& $$, PROGRAM_CONSTANT,

+                           temp_sym.param_binding_begin,

+                           temp_sym.param_binding_swizzle);

+	}

+	;

+

+swizzleSrcReg: optionalSign srcReg swizzleSuffix

+	{

+	   $$ = $2;

+

+	   if ($1) {

+	      $$.Base.Negate = ~$$.Base.Negate;

+	   }

+

+	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,

+						    $3.swizzle);

+	}

+	| optionalSign '|' srcReg swizzleSuffix '|'

+	{

+	   $$ = $3;

+

+	   if (!state->option.NV_fragment) {

+	      yyerror(& @2, state, "unexpected character '|'");

+	      YYERROR;

+	   }

+

+	   if ($1) {

+	      $$.Base.Negate = ~$$.Base.Negate;

+	   }

+

+	   $$.Base.Abs = 1;

+	   $$.Base.Swizzle = _mesa_combine_swizzles($$.Base.Swizzle,

+						    $4.swizzle);

+	}

+

+	;

+

+maskedDstReg: dstReg optionalMask optionalCcMask

+	{

+	   $$ = $1;

+	   $$.WriteMask = $2.mask;

+	   $$.CondMask = $3.CondMask;

+	   $$.CondSwizzle = $3.CondSwizzle;

+	   $$.CondSrc = $3.CondSrc;

+

+	   if ($$.File == PROGRAM_OUTPUT) {

+	      /* Technically speaking, this should check that it is in

+	       * vertex program mode.  However, PositionInvariant can never be

+	       * set in fragment program mode, so it is somewhat irrelevant.

+	       */

+	      if (state->option.PositionInvariant

+	       && ($$.Index == VERT_RESULT_HPOS)) {

+		 yyerror(& @1, state, "position-invariant programs cannot "

+			 "write position");

+		 YYERROR;

+	      }

+

+	      state->prog->OutputsWritten |= BITFIELD64_BIT($$.Index);

+	   }

+	}

+	;

+

+maskedAddrReg: addrReg addrWriteMask

+	{

+	   set_dst_reg(& $$, PROGRAM_ADDRESS, 0);

+	   $$.WriteMask = $2.mask;

+	}

+	;

+

+extendedSwizzle: extSwizComp ',' extSwizComp ',' extSwizComp ',' extSwizComp

+	{

+	   const unsigned xyzw_valid =

+	      ($1.xyzw_valid << 0)

+	      | ($3.xyzw_valid << 1)

+	      | ($5.xyzw_valid << 2)

+	      | ($7.xyzw_valid << 3);

+	   const unsigned rgba_valid =

+	      ($1.rgba_valid << 0)

+	      | ($3.rgba_valid << 1)

+	      | ($5.rgba_valid << 2)

+	      | ($7.rgba_valid << 3);

+

+	   /* All of the swizzle components have to be valid in either RGBA

+	    * or XYZW.  Note that 0 and 1 are valid in both, so both masks

+	    * can have some bits set.

+	    *

+	    * We somewhat deviate from the spec here.  It would be really hard

+	    * to figure out which component is the error, and there probably

+	    * isn't a lot of benefit.

+	    */

+	   if ((rgba_valid != 0x0f) && (xyzw_valid != 0x0f)) {

+	      yyerror(& @1, state, "cannot combine RGBA and XYZW swizzle "

+		      "components");

+	      YYERROR;

+	   }

+

+	   $$.swizzle = MAKE_SWIZZLE4($1.swz, $3.swz, $5.swz, $7.swz);

+	   $$.mask = ($1.negate) | ($3.negate << 1) | ($5.negate << 2)

+	      | ($7.negate << 3);

+	}

+	;

+

+extSwizComp: optionalSign extSwizSel

+	{

+	   $$ = $2;

+	   $$.negate = ($1) ? 1 : 0;

+	}

+	;

+

+extSwizSel: INTEGER

+	{

+	   if (($1 != 0) && ($1 != 1)) {

+	      yyerror(& @1, state, "invalid extended swizzle selector");

+	      YYERROR;

+	   }

+

+	   $$.swz = ($1 == 0) ? SWIZZLE_ZERO : SWIZZLE_ONE;

+

+	   /* 0 and 1 are valid for both RGBA swizzle names and XYZW

+	    * swizzle names.

+	    */

+	   $$.xyzw_valid = 1;

+	   $$.rgba_valid = 1;

+	}

+	| string

+	{

+	   char s;

+

+	   if (strlen($1) > 1) {

+	      yyerror(& @1, state, "invalid extended swizzle selector");

+	      YYERROR;

+	   }

+

+	   s = $1[0];

+	   free($1);

+

+	   switch (s) {

+	   case 'x':

+	      $$.swz = SWIZZLE_X;

+	      $$.xyzw_valid = 1;

+	      break;

+	   case 'y':

+	      $$.swz = SWIZZLE_Y;

+	      $$.xyzw_valid = 1;

+	      break;

+	   case 'z':

+	      $$.swz = SWIZZLE_Z;

+	      $$.xyzw_valid = 1;

+	      break;

+	   case 'w':

+	      $$.swz = SWIZZLE_W;

+	      $$.xyzw_valid = 1;

+	      break;

+

+	   case 'r':

+	      $$.swz = SWIZZLE_X;

+	      $$.rgba_valid = 1;

+	      break;

+	   case 'g':

+	      $$.swz = SWIZZLE_Y;

+	      $$.rgba_valid = 1;

+	      break;

+	   case 'b':

+	      $$.swz = SWIZZLE_Z;

+	      $$.rgba_valid = 1;

+	      break;

+	   case 'a':

+	      $$.swz = SWIZZLE_W;

+	      $$.rgba_valid = 1;

+	      break;

+

+	   default:

+	      yyerror(& @1, state, "invalid extended swizzle selector");

+	      YYERROR;

+	      break;

+	   }

+	}

+	;

+

+srcReg: USED_IDENTIFIER /* temporaryReg | progParamSingle */

+	{

+	   struct asm_symbol *const s = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $1);

+

+	   free($1);

+

+	   if (s == NULL) {

+	      yyerror(& @1, state, "invalid operand variable");

+	      YYERROR;

+	   } else if ((s->type != at_param) && (s->type != at_temp)

+		      && (s->type != at_attrib)) {

+	      yyerror(& @1, state, "invalid operand variable");

+	      YYERROR;

+	   } else if ((s->type == at_param) && s->param_is_array) {

+	      yyerror(& @1, state, "non-array access to array PARAM");

+	      YYERROR;

+	   }

+

+	   init_src_reg(& $$);

+	   switch (s->type) {

+	   case at_temp:

+	      set_src_reg(& $$, PROGRAM_TEMPORARY, s->temp_binding);

+	      break;

+	   case at_param:

+              set_src_reg_swz(& $$, s->param_binding_type,

+                              s->param_binding_begin,

+                              s->param_binding_swizzle);

+	      break;

+	   case at_attrib:

+	      set_src_reg(& $$, PROGRAM_INPUT, s->attrib_binding);

+	      state->prog->InputsRead |= (1U << $$.Base.Index);

+

+	      if (!validate_inputs(& @1, state)) {

+		 YYERROR;

+	      }

+	      break;

+

+	   default:

+	      YYERROR;

+	      break;

+	   }

+	}

+	| attribBinding

+	{

+	   set_src_reg(& $$, PROGRAM_INPUT, $1);

+	   state->prog->InputsRead |= (1U << $$.Base.Index);

+

+	   if (!validate_inputs(& @1, state)) {

+	      YYERROR;

+	   }

+	}

+	| progParamArray '[' progParamArrayMem ']'

+	{

+	   if (! $3.Base.RelAddr

+	       && ((unsigned) $3.Base.Index >= $1->param_binding_length)) {

+	      yyerror(& @3, state, "out of bounds array access");

+	      YYERROR;

+	   }

+

+	   init_src_reg(& $$);

+	   $$.Base.File = $1->param_binding_type;

+

+	   if ($3.Base.RelAddr) {

+              state->prog->IndirectRegisterFiles |= (1 << $$.Base.File);

+	      $1->param_accessed_indirectly = 1;

+

+	      $$.Base.RelAddr = 1;

+	      $$.Base.Index = $3.Base.Index;

+	      $$.Symbol = $1;

+	   } else {

+	      $$.Base.Index = $1->param_binding_begin + $3.Base.Index;

+	   }

+	}

+	| paramSingleItemUse

+	{

+           gl_register_file file = ($1.name != NULL) 

+	      ? $1.param_binding_type

+	      : PROGRAM_CONSTANT;

+           set_src_reg_swz(& $$, file, $1.param_binding_begin,

+                           $1.param_binding_swizzle);

+	}

+	;

+

+dstReg: resultBinding

+	{

+	   set_dst_reg(& $$, PROGRAM_OUTPUT, $1);

+	}

+	| USED_IDENTIFIER /* temporaryReg | vertexResultReg */

+	{

+	   struct asm_symbol *const s = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $1);

+

+	   free($1);

+

+	   if (s == NULL) {

+	      yyerror(& @1, state, "invalid operand variable");

+	      YYERROR;

+	   } else if ((s->type != at_output) && (s->type != at_temp)) {

+	      yyerror(& @1, state, "invalid operand variable");

+	      YYERROR;

+	   }

+

+	   switch (s->type) {

+	   case at_temp:

+	      set_dst_reg(& $$, PROGRAM_TEMPORARY, s->temp_binding);

+	      break;

+	   case at_output:

+	      set_dst_reg(& $$, PROGRAM_OUTPUT, s->output_binding);

+	      break;

+	   default:

+	      set_dst_reg(& $$, s->param_binding_type, s->param_binding_begin);

+	      break;

+	   }

+	}

+	;

+

+progParamArray: USED_IDENTIFIER

+	{

+	   struct asm_symbol *const s = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $1);

+

+	   free($1);

+

+	   if (s == NULL) {

+	      yyerror(& @1, state, "invalid operand variable");

+	      YYERROR;

+	   } else if ((s->type != at_param) || !s->param_is_array) {

+	      yyerror(& @1, state, "array access to non-PARAM variable");

+	      YYERROR;

+	   } else {

+	      $$ = s;

+	   }

+	}

+	;

+

+progParamArrayMem: progParamArrayAbs | progParamArrayRel;

+

+progParamArrayAbs: INTEGER

+	{

+	   init_src_reg(& $$);

+	   $$.Base.Index = $1;

+	}

+	;

+

+progParamArrayRel: addrReg addrComponent addrRegRelOffset

+	{

+	   /* FINISHME: Add support for multiple address registers.

+	    */

+	   /* FINISHME: Add support for 4-component address registers.

+	    */

+	   init_src_reg(& $$);

+	   $$.Base.RelAddr = 1;

+	   $$.Base.Index = $3;

+	}

+	;

+

+addrRegRelOffset:              { $$ = 0; }

+	| '+' addrRegPosOffset { $$ = $2; }

+	| '-' addrRegNegOffset { $$ = -$2; }

+	;

+

+addrRegPosOffset: INTEGER

+	{

+	   if (($1 < 0) || ($1 > (state->limits->MaxAddressOffset - 1))) {

+              char s[100];

+              _mesa_snprintf(s, sizeof(s),

+                             "relative address offset too large (%d)", $1);

+	      yyerror(& @1, state, s);

+	      YYERROR;

+	   } else {

+	      $$ = $1;

+	   }

+	}

+	;

+

+addrRegNegOffset: INTEGER

+	{

+	   if (($1 < 0) || ($1 > state->limits->MaxAddressOffset)) {

+              char s[100];

+              _mesa_snprintf(s, sizeof(s),

+                             "relative address offset too large (%d)", $1);

+	      yyerror(& @1, state, s);

+	      YYERROR;

+	   } else {

+	      $$ = $1;

+	   }

+	}

+	;

+

+addrReg: USED_IDENTIFIER

+	{

+	   struct asm_symbol *const s = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $1);

+

+	   free($1);

+

+	   if (s == NULL) {

+	      yyerror(& @1, state, "invalid array member");

+	      YYERROR;

+	   } else if (s->type != at_address) {

+	      yyerror(& @1, state,

+		      "invalid variable for indexed array access");

+	      YYERROR;

+	   } else {

+	      $$ = s;

+	   }

+	}

+	;

+

+addrComponent: MASK1

+	{

+	   if ($1.mask != WRITEMASK_X) {

+	      yyerror(& @1, state, "invalid address component selector");

+	      YYERROR;

+	   } else {

+	      $$ = $1;

+	   }

+	}

+	;

+

+addrWriteMask: MASK1

+	{

+	   if ($1.mask != WRITEMASK_X) {

+	      yyerror(& @1, state,

+		      "address register write mask must be \".x\"");

+	      YYERROR;

+	   } else {

+	      $$ = $1;

+	   }

+	}

+	;

+

+scalarSuffix: MASK1;

+

+swizzleSuffix: MASK1

+	| MASK4

+	| SWIZZLE

+	|              { $$.swizzle = SWIZZLE_NOOP; $$.mask = WRITEMASK_XYZW; }

+	;

+

+optionalMask: MASK4 | MASK3 | MASK2 | MASK1 

+	|              { $$.swizzle = SWIZZLE_NOOP; $$.mask = WRITEMASK_XYZW; }

+	;

+

+optionalCcMask: '(' ccTest ')'

+	{

+	   $$ = $2;

+	}

+	| '(' ccTest2 ')'

+	{

+	   $$ = $2;

+	}

+	|

+	{

+	   $$.CondMask = COND_TR;

+	   $$.CondSwizzle = SWIZZLE_NOOP;

+	   $$.CondSrc = 0;

+	}

+	;

+

+ccTest: ccMaskRule swizzleSuffix

+	{

+	   $$ = $1;

+	   $$.CondSwizzle = $2.swizzle;

+	}

+	;

+

+ccTest2: ccMaskRule2 swizzleSuffix

+	{

+	   $$ = $1;

+	   $$.CondSwizzle = $2.swizzle;

+	}

+	;

+

+ccMaskRule: IDENTIFIER

+	{

+	   const int cond = _mesa_parse_cc($1);

+	   if ((cond == 0) || ($1[2] != '\0')) {

+	      char *const err_str =

+		 make_error_string("invalid condition code \"%s\"", $1);

+

+	      yyerror(& @1, state, (err_str != NULL)

+		      ? err_str : "invalid condition code");

+

+	      if (err_str != NULL) {

+		 free(err_str);

+	      }

+

+	      YYERROR;

+	   }

+

+	   $$.CondMask = cond;

+	   $$.CondSwizzle = SWIZZLE_NOOP;

+	   $$.CondSrc = 0;

+	}

+	;

+

+ccMaskRule2: USED_IDENTIFIER

+	{

+	   const int cond = _mesa_parse_cc($1);

+	   if ((cond == 0) || ($1[2] != '\0')) {

+	      char *const err_str =

+		 make_error_string("invalid condition code \"%s\"", $1);

+

+	      yyerror(& @1, state, (err_str != NULL)

+		      ? err_str : "invalid condition code");

+

+	      if (err_str != NULL) {

+		 free(err_str);

+	      }

+

+	      YYERROR;

+	   }

+

+	   $$.CondMask = cond;

+	   $$.CondSwizzle = SWIZZLE_NOOP;

+	   $$.CondSrc = 0;

+	}

+	;

+

+namingStatement: ATTRIB_statement

+	| PARAM_statement

+	| TEMP_statement

+	| ADDRESS_statement

+	| OUTPUT_statement

+	| ALIAS_statement

+	;

+

+ATTRIB_statement: ATTRIB IDENTIFIER '=' attribBinding

+	{

+	   struct asm_symbol *const s =

+	      declare_variable(state, $2, at_attrib, & @2);

+

+	   if (s == NULL) {

+	      free($2);

+	      YYERROR;

+	   } else {

+	      s->attrib_binding = $4;

+	      state->InputsBound |= (1U << s->attrib_binding);

+

+	      if (!validate_inputs(& @4, state)) {

+		 YYERROR;

+	      }

+	   }

+	}

+	;

+

+attribBinding: VERTEX vtxAttribItem

+	{

+	   $$ = $2;

+	}

+	| FRAGMENT fragAttribItem

+	{

+	   $$ = $2;

+	}

+	;

+

+vtxAttribItem: POSITION

+	{

+	   $$ = VERT_ATTRIB_POS;

+	}

+	| WEIGHT vtxOptWeightNum

+	{

+	   $$ = VERT_ATTRIB_WEIGHT;

+	}

+	| NORMAL

+	{

+	   $$ = VERT_ATTRIB_NORMAL;

+	}

+	| COLOR optColorType

+	{

+	   if (!state->ctx->Extensions.EXT_secondary_color) {

+	      yyerror(& @2, state, "GL_EXT_secondary_color not supported");

+	      YYERROR;

+	   }

+

+	   $$ = VERT_ATTRIB_COLOR0 + $2;

+	}

+	| FOGCOORD

+	{

+	   if (!state->ctx->Extensions.EXT_fog_coord) {

+	      yyerror(& @1, state, "GL_EXT_fog_coord not supported");

+	      YYERROR;

+	   }

+

+	   $$ = VERT_ATTRIB_FOG;

+	}

+	| TEXCOORD optTexCoordUnitNum

+	{

+	   $$ = VERT_ATTRIB_TEX0 + $2;

+	}

+	| MATRIXINDEX '[' vtxWeightNum ']'

+	{

+	   yyerror(& @1, state, "GL_ARB_matrix_palette not supported");

+	   YYERROR;

+	}

+	| VTXATTRIB '[' vtxAttribNum ']'

+	{

+	   $$ = VERT_ATTRIB_GENERIC0 + $3;

+	}

+	;

+

+vtxAttribNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->limits->MaxAttribs) {

+	      yyerror(& @1, state, "invalid vertex attribute reference");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+vtxOptWeightNum:  | '[' vtxWeightNum ']';

+vtxWeightNum: INTEGER;

+

+fragAttribItem: POSITION

+	{

+	   $$ = FRAG_ATTRIB_WPOS;

+	}

+	| COLOR optColorType

+	{

+	   $$ = FRAG_ATTRIB_COL0 + $2;

+	}

+	| FOGCOORD

+	{

+	   $$ = FRAG_ATTRIB_FOGC;

+	}

+	| TEXCOORD optTexCoordUnitNum

+	{

+	   $$ = FRAG_ATTRIB_TEX0 + $2;

+	}

+	;

+

+PARAM_statement: PARAM_singleStmt | PARAM_multipleStmt;

+

+PARAM_singleStmt: PARAM IDENTIFIER paramSingleInit

+	{

+	   struct asm_symbol *const s =

+	      declare_variable(state, $2, at_param, & @2);

+

+	   if (s == NULL) {

+	      free($2);

+	      YYERROR;

+	   } else {

+	      s->param_binding_type = $3.param_binding_type;

+	      s->param_binding_begin = $3.param_binding_begin;

+	      s->param_binding_length = $3.param_binding_length;

+              s->param_binding_swizzle = $3.param_binding_swizzle;

+	      s->param_is_array = 0;

+	   }

+	}

+	;

+

+PARAM_multipleStmt: PARAM IDENTIFIER '[' optArraySize ']' paramMultipleInit

+	{

+	   if (($4 != 0) && ((unsigned) $4 != $6.param_binding_length)) {

+	      free($2);

+	      yyerror(& @4, state, 

+		      "parameter array size and number of bindings must match");

+	      YYERROR;

+	   } else {

+	      struct asm_symbol *const s =

+		 declare_variable(state, $2, $6.type, & @2);

+

+	      if (s == NULL) {

+		 free($2);

+		 YYERROR;

+	      } else {

+		 s->param_binding_type = $6.param_binding_type;

+		 s->param_binding_begin = $6.param_binding_begin;

+		 s->param_binding_length = $6.param_binding_length;

+                 s->param_binding_swizzle = SWIZZLE_XYZW;

+		 s->param_is_array = 1;

+	      }

+	   }

+	}

+	;

+

+optArraySize:

+	{

+	   $$ = 0;

+	}

+	| INTEGER

+        {

+	   if (($1 < 1) || ((unsigned) $1 > state->limits->MaxParameters)) {

+	      yyerror(& @1, state, "invalid parameter array size");

+	      YYERROR;

+	   } else {

+	      $$ = $1;

+	   }

+	}

+	;

+

+paramSingleInit: '=' paramSingleItemDecl

+	{

+	   $$ = $2;

+	}

+	;

+

+paramMultipleInit: '=' '{' paramMultInitList '}'

+	{

+	   $$ = $3;

+	}

+	;

+

+paramMultInitList: paramMultipleItem

+	| paramMultInitList ',' paramMultipleItem

+	{

+	   $1.param_binding_length += $3.param_binding_length;

+	   $$ = $1;

+	}

+	;

+

+paramSingleItemDecl: stateSingleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_state(state->prog, & $$, $1);

+	}

+	| programSingleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_param(state->prog, & $$, $1);

+	}

+	| paramConstDecl

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_TRUE);

+	}

+	;

+

+paramSingleItemUse: stateSingleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_state(state->prog, & $$, $1);

+	}

+	| programSingleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_param(state->prog, & $$, $1);

+	}

+	| paramConstUse

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_TRUE);

+	}

+	;

+

+paramMultipleItem: stateMultipleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_state(state->prog, & $$, $1);

+	}

+	| programMultipleItem

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_param(state->prog, & $$, $1);

+	}

+	| paramConstDecl

+	{

+	   memset(& $$, 0, sizeof($$));

+	   $$.param_binding_begin = ~0;

+	   initialize_symbol_from_const(state->prog, & $$, & $1, GL_FALSE);

+	}

+	;

+

+stateMultipleItem: stateSingleItem        { memcpy($$, $1, sizeof($$)); }

+	| STATE stateMatrixRows           { memcpy($$, $2, sizeof($$)); }

+	;

+

+stateSingleItem: STATE stateMaterialItem  { memcpy($$, $2, sizeof($$)); }

+	| STATE stateLightItem            { memcpy($$, $2, sizeof($$)); }

+	| STATE stateLightModelItem       { memcpy($$, $2, sizeof($$)); }

+	| STATE stateLightProdItem        { memcpy($$, $2, sizeof($$)); }

+	| STATE stateTexGenItem           { memcpy($$, $2, sizeof($$)); }

+	| STATE stateTexEnvItem           { memcpy($$, $2, sizeof($$)); }

+	| STATE stateFogItem              { memcpy($$, $2, sizeof($$)); }

+	| STATE stateClipPlaneItem        { memcpy($$, $2, sizeof($$)); }

+	| STATE statePointItem            { memcpy($$, $2, sizeof($$)); }

+	| STATE stateMatrixRow            { memcpy($$, $2, sizeof($$)); }

+	| STATE stateDepthItem            { memcpy($$, $2, sizeof($$)); }

+	;

+

+stateMaterialItem: MATERIAL optFaceType stateMatProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_MATERIAL;

+	   $$[1] = $2;

+	   $$[2] = $3;

+	}

+	;

+

+stateMatProperty: ambDiffSpecProperty

+	{

+	   $$ = $1;

+	}

+	| EMISSION

+	{

+	   $$ = STATE_EMISSION;

+	}

+	| SHININESS

+	{

+	   $$ = STATE_SHININESS;

+	}

+	;

+

+stateLightItem: LIGHT '[' stateLightNumber ']' stateLightProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_LIGHT;

+	   $$[1] = $3;

+	   $$[2] = $5;

+	}

+	;

+

+stateLightProperty: ambDiffSpecProperty

+	{

+	   $$ = $1;

+	}

+	| POSITION

+	{

+	   $$ = STATE_POSITION;

+	}

+	| ATTENUATION

+	{

+	   if (!state->ctx->Extensions.EXT_point_parameters) {

+	      yyerror(& @1, state, "GL_ARB_point_parameters not supported");

+	      YYERROR;

+	   }

+

+	   $$ = STATE_ATTENUATION;

+	}

+	| SPOT stateSpotProperty

+	{

+	   $$ = $2;

+	}

+	| HALF

+	{

+	   $$ = STATE_HALF_VECTOR;

+	}

+	;

+

+stateSpotProperty: DIRECTION

+	{

+	   $$ = STATE_SPOT_DIRECTION;

+	}

+	;

+

+stateLightModelItem: LIGHTMODEL stateLModProperty

+	{

+	   $$[0] = $2[0];

+	   $$[1] = $2[1];

+	}

+	;

+

+stateLModProperty: AMBIENT

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_LIGHTMODEL_AMBIENT;

+	}

+	| optFaceType SCENECOLOR

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_LIGHTMODEL_SCENECOLOR;

+	   $$[1] = $1;

+	}

+	;

+

+stateLightProdItem: LIGHTPROD '[' stateLightNumber ']' optFaceType stateLProdProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_LIGHTPROD;

+	   $$[1] = $3;

+	   $$[2] = $5;

+	   $$[3] = $6;

+	}

+	;

+

+stateLProdProperty: ambDiffSpecProperty;

+

+stateTexEnvItem: TEXENV optLegacyTexUnitNum stateTexEnvProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = $3;

+	   $$[1] = $2;

+	}

+	;

+

+stateTexEnvProperty: COLOR

+	{

+	   $$ = STATE_TEXENV_COLOR;

+	}

+	;

+

+ambDiffSpecProperty: AMBIENT

+	{

+	   $$ = STATE_AMBIENT;

+	}

+	| DIFFUSE

+	{

+	   $$ = STATE_DIFFUSE;

+	}

+	| SPECULAR

+	{

+	   $$ = STATE_SPECULAR;

+	}

+	;

+

+stateLightNumber: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxLights) {

+	      yyerror(& @1, state, "invalid light selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+stateTexGenItem: TEXGEN optTexCoordUnitNum stateTexGenType stateTexGenCoord

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_TEXGEN;

+	   $$[1] = $2;

+	   $$[2] = $3 + $4;

+	}

+	;

+

+stateTexGenType: EYE

+	{

+	   $$ = STATE_TEXGEN_EYE_S;

+	}

+	| OBJECT

+	{

+	   $$ = STATE_TEXGEN_OBJECT_S;

+	}

+	;

+stateTexGenCoord: TEXGEN_S

+	{

+	   $$ = STATE_TEXGEN_EYE_S - STATE_TEXGEN_EYE_S;

+	}

+	| TEXGEN_T

+	{

+	   $$ = STATE_TEXGEN_EYE_T - STATE_TEXGEN_EYE_S;

+	}

+	| TEXGEN_R

+	{

+	   $$ = STATE_TEXGEN_EYE_R - STATE_TEXGEN_EYE_S;

+	}

+	| TEXGEN_Q

+	{

+	   $$ = STATE_TEXGEN_EYE_Q - STATE_TEXGEN_EYE_S;

+	}

+	;

+

+stateFogItem: FOG stateFogProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = $2;

+	}

+	;

+

+stateFogProperty: COLOR

+	{

+	   $$ = STATE_FOG_COLOR;

+	}

+	| PARAMS

+	{

+	   $$ = STATE_FOG_PARAMS;

+	}

+	;

+

+stateClipPlaneItem: CLIP '[' stateClipPlaneNum ']' PLANE

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_CLIPPLANE;

+	   $$[1] = $3;

+	}

+	;

+

+stateClipPlaneNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxClipPlanes) {

+	      yyerror(& @1, state, "invalid clip plane selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+statePointItem: POINT_TOK statePointProperty

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = $2;

+	}

+	;

+

+statePointProperty: SIZE_TOK

+	{

+	   $$ = STATE_POINT_SIZE;

+	}

+	| ATTENUATION

+	{

+	   $$ = STATE_POINT_ATTENUATION;

+	}

+	;

+

+stateMatrixRow: stateMatrixItem ROW '[' stateMatrixRowNum ']'

+	{

+	   $$[0] = $1[0];

+	   $$[1] = $1[1];

+	   $$[2] = $4;

+	   $$[3] = $4;

+	   $$[4] = $1[2];

+	}

+	;

+

+stateMatrixRows: stateMatrixItem optMatrixRows

+	{

+	   $$[0] = $1[0];

+	   $$[1] = $1[1];

+	   $$[2] = $2[2];

+	   $$[3] = $2[3];

+	   $$[4] = $1[2];

+	}

+	;

+

+optMatrixRows:

+	{

+	   $$[2] = 0;

+	   $$[3] = 3;

+	}

+	| ROW '[' stateMatrixRowNum DOT_DOT stateMatrixRowNum ']'

+	{

+	   /* It seems logical that the matrix row range specifier would have

+	    * to specify a range or more than one row (i.e., $5 > $3).

+	    * However, the ARB_vertex_program spec says "a program will fail

+	    * to load if <a> is greater than <b>."  This means that $3 == $5

+	    * is valid.

+	    */

+	   if ($3 > $5) {

+	      yyerror(& @3, state, "invalid matrix row range");

+	      YYERROR;

+	   }

+

+	   $$[2] = $3;

+	   $$[3] = $5;

+	}

+	;

+

+stateMatrixItem: MATRIX stateMatrixName stateOptMatModifier

+	{

+	   $$[0] = $2[0];

+	   $$[1] = $2[1];

+	   $$[2] = $3;

+	}

+	;

+

+stateOptMatModifier: 

+	{

+	   $$ = 0;

+	}

+	| stateMatModifier

+	{

+	   $$ = $1;

+	}

+	;

+

+stateMatModifier: INVERSE 

+	{

+	   $$ = STATE_MATRIX_INVERSE;

+	}

+	| TRANSPOSE 

+	{

+	   $$ = STATE_MATRIX_TRANSPOSE;

+	}

+	| INVTRANS

+	{

+	   $$ = STATE_MATRIX_INVTRANS;

+	}

+	;

+

+stateMatrixRowNum: INTEGER

+	{

+	   if ($1 > 3) {

+	      yyerror(& @1, state, "invalid matrix row reference");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+stateMatrixName: MODELVIEW stateOptModMatNum

+	{

+	   $$[0] = STATE_MODELVIEW_MATRIX;

+	   $$[1] = $2;

+	}

+	| PROJECTION

+	{

+	   $$[0] = STATE_PROJECTION_MATRIX;

+	   $$[1] = 0;

+	}

+	| MVP

+	{

+	   $$[0] = STATE_MVP_MATRIX;

+	   $$[1] = 0;

+	}

+	| TEXTURE optTexCoordUnitNum

+	{

+	   $$[0] = STATE_TEXTURE_MATRIX;

+	   $$[1] = $2;

+	}

+	| PALETTE '[' statePaletteMatNum ']'

+	{

+	   yyerror(& @1, state, "GL_ARB_matrix_palette not supported");

+	   YYERROR;

+	}

+	| MAT_PROGRAM '[' stateProgramMatNum ']'

+	{

+	   $$[0] = STATE_PROGRAM_MATRIX;

+	   $$[1] = $3;

+	}

+	;

+

+stateOptModMatNum:

+	{

+	   $$ = 0;

+	}

+	| '[' stateModMatNum ']'

+	{

+	   $$ = $2;

+	}

+	;

+stateModMatNum: INTEGER

+	{

+	   /* Since GL_ARB_vertex_blend isn't supported, only modelview matrix

+	    * zero is valid.

+	    */

+	   if ($1 != 0) {

+	      yyerror(& @1, state, "invalid modelview matrix index");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+statePaletteMatNum: INTEGER

+	{

+	   /* Since GL_ARB_matrix_palette isn't supported, just let any value

+	    * through here.  The error will be generated later.

+	    */

+	   $$ = $1;

+	}

+	;

+stateProgramMatNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxProgramMatrices) {

+	      yyerror(& @1, state, "invalid program matrix selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+stateDepthItem: DEPTH RANGE

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = STATE_DEPTH_RANGE;

+	}

+	;

+

+

+programSingleItem: progEnvParam | progLocalParam;

+

+programMultipleItem: progEnvParams | progLocalParams;

+

+progEnvParams: PROGRAM ENV '[' progEnvParamNums ']'

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = state->state_param_enum;

+	   $$[1] = STATE_ENV;

+	   $$[2] = $4[0];

+	   $$[3] = $4[1];

+	}

+	;

+

+progEnvParamNums: progEnvParamNum

+	{

+	   $$[0] = $1;

+	   $$[1] = $1;

+	}

+	| progEnvParamNum DOT_DOT progEnvParamNum

+	{

+	   $$[0] = $1;

+	   $$[1] = $3;

+	}

+	;

+

+progEnvParam: PROGRAM ENV '[' progEnvParamNum ']'

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = state->state_param_enum;

+	   $$[1] = STATE_ENV;

+	   $$[2] = $4;

+	   $$[3] = $4;

+	}

+	;

+

+progLocalParams: PROGRAM LOCAL '[' progLocalParamNums ']'

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = state->state_param_enum;

+	   $$[1] = STATE_LOCAL;

+	   $$[2] = $4[0];

+	   $$[3] = $4[1];

+	}

+

+progLocalParamNums: progLocalParamNum

+	{

+	   $$[0] = $1;

+	   $$[1] = $1;

+	}

+	| progLocalParamNum DOT_DOT progLocalParamNum

+	{

+	   $$[0] = $1;

+	   $$[1] = $3;

+	}

+	;

+

+progLocalParam: PROGRAM LOCAL '[' progLocalParamNum ']'

+	{

+	   memset($$, 0, sizeof($$));

+	   $$[0] = state->state_param_enum;

+	   $$[1] = STATE_LOCAL;

+	   $$[2] = $4;

+	   $$[3] = $4;

+	}

+	;

+

+progEnvParamNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->limits->MaxEnvParams) {

+	      yyerror(& @1, state, "invalid environment parameter reference");

+	      YYERROR;

+	   }

+	   $$ = $1;

+	}

+	;

+

+progLocalParamNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->limits->MaxLocalParams) {

+	      yyerror(& @1, state, "invalid local parameter reference");

+	      YYERROR;

+	   }

+	   $$ = $1;

+	}

+	;

+

+

+

+paramConstDecl: paramConstScalarDecl | paramConstVector;

+paramConstUse: paramConstScalarUse | paramConstVector;

+

+paramConstScalarDecl: signedFloatConstant

+	{

+	   $$.count = 4;

+	   $$.data[0] = $1;

+	   $$.data[1] = $1;

+	   $$.data[2] = $1;

+	   $$.data[3] = $1;

+	}

+	;

+

+paramConstScalarUse: REAL

+	{

+	   $$.count = 1;

+	   $$.data[0] = $1;

+	   $$.data[1] = $1;

+	   $$.data[2] = $1;

+	   $$.data[3] = $1;

+	}

+	| INTEGER

+	{

+	   $$.count = 1;

+	   $$.data[0] = (float) $1;

+	   $$.data[1] = (float) $1;

+	   $$.data[2] = (float) $1;

+	   $$.data[3] = (float) $1;

+	}

+	;

+

+paramConstVector: '{' signedFloatConstant '}'

+	{

+	   $$.count = 4;

+	   $$.data[0] = $2;

+	   $$.data[1] = 0.0f;

+	   $$.data[2] = 0.0f;

+	   $$.data[3] = 1.0f;

+	}

+	| '{' signedFloatConstant ',' signedFloatConstant '}'

+	{

+	   $$.count = 4;

+	   $$.data[0] = $2;

+	   $$.data[1] = $4;

+	   $$.data[2] = 0.0f;

+	   $$.data[3] = 1.0f;

+	}

+	| '{' signedFloatConstant ',' signedFloatConstant ','

+              signedFloatConstant '}'

+	{

+	   $$.count = 4;

+	   $$.data[0] = $2;

+	   $$.data[1] = $4;

+	   $$.data[2] = $6;

+	   $$.data[3] = 1.0f;

+	}

+	| '{' signedFloatConstant ',' signedFloatConstant ','

+              signedFloatConstant ',' signedFloatConstant '}'

+	{

+	   $$.count = 4;

+	   $$.data[0] = $2;

+	   $$.data[1] = $4;

+	   $$.data[2] = $6;

+	   $$.data[3] = $8;

+	}

+	;

+

+signedFloatConstant: optionalSign REAL

+	{

+	   $$ = ($1) ? -$2 : $2;

+	}

+	| optionalSign INTEGER

+	{

+	   $$ = (float)(($1) ? -$2 : $2);

+	}

+	;

+

+optionalSign: '+'        { $$ = FALSE; }

+	| '-'            { $$ = TRUE;  }

+	|                { $$ = FALSE; }

+	;

+

+TEMP_statement: optVarSize TEMP { $<integer>$ = $2; } varNameList

+	;

+

+optVarSize: string

+	{

+	   /* NV_fragment_program_option defines the size qualifiers in a

+	    * fairly broken way.  "SHORT" or "LONG" can optionally be used

+	    * before TEMP or OUTPUT.  However, neither is a reserved word!

+	    * This means that we have to parse it as an identifier, then check

+	    * to make sure it's one of the valid values.  *sigh*

+	    *

+	    * In addition, the grammar in the extension spec does *not* allow

+	    * the size specifier to be optional, but all known implementations

+	    * do.

+	    */

+	   if (!state->option.NV_fragment) {

+	      yyerror(& @1, state, "unexpected IDENTIFIER");

+	      YYERROR;

+	   }

+

+	   if (strcmp("SHORT", $1) == 0) {

+	   } else if (strcmp("LONG", $1) == 0) {

+	   } else {

+	      char *const err_str =

+		 make_error_string("invalid storage size specifier \"%s\"",

+				   $1);

+

+	      yyerror(& @1, state, (err_str != NULL)

+		      ? err_str : "invalid storage size specifier");

+

+	      if (err_str != NULL) {

+		 free(err_str);

+	      }

+

+	      YYERROR;

+	   }

+	}

+	|

+	{

+	}

+	;

+

+ADDRESS_statement: ADDRESS { $<integer>$ = $1; } varNameList

+	;

+

+varNameList: varNameList ',' IDENTIFIER

+	{

+	   if (!declare_variable(state, $3, $<integer>0, & @3)) {

+	      free($3);

+	      YYERROR;

+	   }

+	}

+	| IDENTIFIER

+	{

+	   if (!declare_variable(state, $1, $<integer>0, & @1)) {

+	      free($1);

+	      YYERROR;

+	   }

+	}

+	;

+

+OUTPUT_statement: optVarSize OUTPUT IDENTIFIER '=' resultBinding

+	{

+	   struct asm_symbol *const s =

+	      declare_variable(state, $3, at_output, & @3);

+

+	   if (s == NULL) {

+	      free($3);

+	      YYERROR;

+	   } else {

+	      s->output_binding = $5;

+	   }

+	}

+	;

+

+resultBinding: RESULT POSITION

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_HPOS;

+	   } else {

+	      yyerror(& @2, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| RESULT FOGCOORD

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_FOGC;

+	   } else {

+	      yyerror(& @2, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| RESULT resultColBinding

+	{

+	   $$ = $2;

+	}

+	| RESULT POINTSIZE

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_PSIZ;

+	   } else {

+	      yyerror(& @2, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| RESULT TEXCOORD optTexCoordUnitNum

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_TEX0 + $3;

+	   } else {

+	      yyerror(& @2, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| RESULT DEPTH

+	{

+	   if (state->mode == ARB_fragment) {

+	      $$ = FRAG_RESULT_DEPTH;

+	   } else {

+	      yyerror(& @2, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	;

+

+resultColBinding: COLOR optResultFaceType optResultColorType

+	{

+	   $$ = $2 + $3;

+	}

+	;

+

+optResultFaceType:

+	{

+	   $$ = (state->mode == ARB_vertex)

+	      ? VERT_RESULT_COL0

+	      : FRAG_RESULT_COLOR;

+	}

+	| FRONT

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_COL0;

+	   } else {

+	      yyerror(& @1, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| BACK

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = VERT_RESULT_BFC0;

+	   } else {

+	      yyerror(& @1, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	;

+

+optResultColorType:

+	{

+	   $$ = 0; 

+	}

+	| PRIMARY

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = 0;

+	   } else {

+	      yyerror(& @1, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	| SECONDARY

+	{

+	   if (state->mode == ARB_vertex) {

+	      $$ = 1;

+	   } else {

+	      yyerror(& @1, state, "invalid program result name");

+	      YYERROR;

+	   }

+	}

+	;

+

+optFaceType:    { $$ = 0; }

+	| FRONT	{ $$ = 0; }

+	| BACK  { $$ = 1; }

+	;

+

+optColorType:       { $$ = 0; }

+	| PRIMARY   { $$ = 0; }

+	| SECONDARY { $$ = 1; }

+	;

+

+optTexCoordUnitNum:                { $$ = 0; }

+	| '[' texCoordUnitNum ']'  { $$ = $2; }

+	;

+

+optTexImageUnitNum:                { $$ = 0; }

+	| '[' texImageUnitNum ']'  { $$ = $2; }

+	;

+

+optLegacyTexUnitNum:               { $$ = 0; }

+	| '[' legacyTexUnitNum ']' { $$ = $2; }

+	;

+

+texCoordUnitNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxTextureCoordUnits) {

+	      yyerror(& @1, state, "invalid texture coordinate unit selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+texImageUnitNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxTextureImageUnits) {

+	      yyerror(& @1, state, "invalid texture image unit selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+legacyTexUnitNum: INTEGER

+	{

+	   if ((unsigned) $1 >= state->MaxTextureUnits) {

+	      yyerror(& @1, state, "invalid texture unit selector");

+	      YYERROR;

+	   }

+

+	   $$ = $1;

+	}

+	;

+

+ALIAS_statement: ALIAS IDENTIFIER '=' USED_IDENTIFIER

+	{

+	   struct asm_symbol *exist = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $2);

+	   struct asm_symbol *target = (struct asm_symbol *)

+	      _mesa_symbol_table_find_symbol(state->st, 0, $4);

+

+	   free($4);

+

+	   if (exist != NULL) {

+	      char m[1000];

+	      _mesa_snprintf(m, sizeof(m), "redeclared identifier: %s", $2);

+	      free($2);

+	      yyerror(& @2, state, m);

+	      YYERROR;

+	   } else if (target == NULL) {

+	      free($2);

+	      yyerror(& @4, state,

+		      "undefined variable binding in ALIAS statement");

+	      YYERROR;

+	   } else {

+	      _mesa_symbol_table_add_symbol(state->st, 0, $2, target);

+	   }

+	}

+	;

+

+string: IDENTIFIER

+	| USED_IDENTIFIER

+	;

+

+%%

+

+void

+asm_instruction_set_operands(struct asm_instruction *inst,

+			     const struct prog_dst_register *dst,

+			     const struct asm_src_register *src0,

+			     const struct asm_src_register *src1,

+			     const struct asm_src_register *src2)

+{

+   /* In the core ARB extensions only the KIL instruction doesn't have a

+    * destination register.

+    */

+   if (dst == NULL) {

+      init_dst_reg(& inst->Base.DstReg);

+   } else {

+      inst->Base.DstReg = *dst;

+   }

+

+   /* The only instruction that doesn't have any source registers is the

+    * condition-code based KIL instruction added by NV_fragment_program_option.

+    */

+   if (src0 != NULL) {

+      inst->Base.SrcReg[0] = src0->Base;

+      inst->SrcReg[0] = *src0;

+   } else {

+      init_src_reg(& inst->SrcReg[0]);

+   }

+

+   if (src1 != NULL) {

+      inst->Base.SrcReg[1] = src1->Base;

+      inst->SrcReg[1] = *src1;

+   } else {

+      init_src_reg(& inst->SrcReg[1]);

+   }

+

+   if (src2 != NULL) {

+      inst->Base.SrcReg[2] = src2->Base;

+      inst->SrcReg[2] = *src2;

+   } else {

+      init_src_reg(& inst->SrcReg[2]);

+   }

+}

+

+

+struct asm_instruction *

+asm_instruction_ctor(gl_inst_opcode op,

+		     const struct prog_dst_register *dst,

+		     const struct asm_src_register *src0,

+		     const struct asm_src_register *src1,

+		     const struct asm_src_register *src2)

+{

+   struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction);

+

+   if (inst) {

+      _mesa_init_instructions(& inst->Base, 1);

+      inst->Base.Opcode = op;

+

+      asm_instruction_set_operands(inst, dst, src0, src1, src2);

+   }

+

+   return inst;

+}

+

+

+struct asm_instruction *

+asm_instruction_copy_ctor(const struct prog_instruction *base,

+			  const struct prog_dst_register *dst,

+			  const struct asm_src_register *src0,

+			  const struct asm_src_register *src1,

+			  const struct asm_src_register *src2)

+{

+   struct asm_instruction *inst = CALLOC_STRUCT(asm_instruction);

+

+   if (inst) {

+      _mesa_init_instructions(& inst->Base, 1);

+      inst->Base.Opcode = base->Opcode;

+      inst->Base.CondUpdate = base->CondUpdate;

+      inst->Base.CondDst = base->CondDst;

+      inst->Base.SaturateMode = base->SaturateMode;

+      inst->Base.Precision = base->Precision;

+

+      asm_instruction_set_operands(inst, dst, src0, src1, src2);

+   }

+

+   return inst;

+}

+

+

+void

+init_dst_reg(struct prog_dst_register *r)

+{

+   memset(r, 0, sizeof(*r));

+   r->File = PROGRAM_UNDEFINED;

+   r->WriteMask = WRITEMASK_XYZW;

+   r->CondMask = COND_TR;

+   r->CondSwizzle = SWIZZLE_NOOP;

+}

+

+

+/** Like init_dst_reg() but set the File and Index fields. */

+void

+set_dst_reg(struct prog_dst_register *r, gl_register_file file, GLint index)

+{

+   const GLint maxIndex = 1 << INST_INDEX_BITS;

+   const GLint minIndex = 0;

+   ASSERT(index >= minIndex);

+   (void) minIndex;

+   ASSERT(index <= maxIndex);

+   (void) maxIndex;

+   ASSERT(file == PROGRAM_TEMPORARY ||

+	  file == PROGRAM_ADDRESS ||

+	  file == PROGRAM_OUTPUT);

+   memset(r, 0, sizeof(*r));

+   r->File = file;

+   r->Index = index;

+   r->WriteMask = WRITEMASK_XYZW;

+   r->CondMask = COND_TR;

+   r->CondSwizzle = SWIZZLE_NOOP;

+}

+

+

+void

+init_src_reg(struct asm_src_register *r)

+{

+   memset(r, 0, sizeof(*r));

+   r->Base.File = PROGRAM_UNDEFINED;

+   r->Base.Swizzle = SWIZZLE_NOOP;

+   r->Symbol = NULL;

+}

+

+

+/** Like init_src_reg() but set the File and Index fields.

+ * \return GL_TRUE if a valid src register, GL_FALSE otherwise

+ */

+void

+set_src_reg(struct asm_src_register *r, gl_register_file file, GLint index)

+{

+   set_src_reg_swz(r, file, index, SWIZZLE_XYZW);

+}

+

+

+void

+set_src_reg_swz(struct asm_src_register *r, gl_register_file file, GLint index,

+                GLuint swizzle)

+{

+   const GLint maxIndex = (1 << INST_INDEX_BITS) - 1;

+   const GLint minIndex = -(1 << INST_INDEX_BITS);

+   ASSERT(file < PROGRAM_FILE_MAX);

+   ASSERT(index >= minIndex);

+   (void) minIndex;

+   ASSERT(index <= maxIndex);

+   (void) maxIndex;

+   memset(r, 0, sizeof(*r));

+   r->Base.File = file;

+   r->Base.Index = index;

+   r->Base.Swizzle = swizzle;

+   r->Symbol = NULL;

+}

+

+

+/**

+ * Validate the set of inputs used by a program

+ *

+ * Validates that legal sets of inputs are used by the program.  In this case

+ * "used" included both reading the input or binding the input to a name using

+ * the \c ATTRIB command.

+ *

+ * \return

+ * \c TRUE if the combination of inputs used is valid, \c FALSE otherwise.

+ */

+int

+validate_inputs(struct YYLTYPE *locp, struct asm_parser_state *state)

+{

+   const int inputs = state->prog->InputsRead | state->InputsBound;

+

+   if (((inputs & 0x0ffff) & (inputs >> 16)) != 0) {

+      yyerror(locp, state, "illegal use of generic attribute and name attribute");

+      return 0;

+   }

+

+   return 1;

+}

+

+

+struct asm_symbol *

+declare_variable(struct asm_parser_state *state, char *name, enum asm_type t,

+		 struct YYLTYPE *locp)

+{

+   struct asm_symbol *s = NULL;

+   struct asm_symbol *exist = (struct asm_symbol *)

+      _mesa_symbol_table_find_symbol(state->st, 0, name);

+

+

+   if (exist != NULL) {

+      yyerror(locp, state, "redeclared identifier");

+   } else {

+      s = calloc(1, sizeof(struct asm_symbol));

+      s->name = name;

+      s->type = t;

+

+      switch (t) {

+      case at_temp:

+	 if (state->prog->NumTemporaries >= state->limits->MaxTemps) {

+	    yyerror(locp, state, "too many temporaries declared");

+	    free(s);

+	    return NULL;

+	 }

+

+	 s->temp_binding = state->prog->NumTemporaries;

+	 state->prog->NumTemporaries++;

+	 break;

+

+      case at_address:

+	 if (state->prog->NumAddressRegs >= state->limits->MaxAddressRegs) {

+	    yyerror(locp, state, "too many address registers declared");

+	    free(s);

+	    return NULL;

+	 }

+

+	 /* FINISHME: Add support for multiple address registers.

+	  */

+	 state->prog->NumAddressRegs++;

+	 break;

+

+      default:

+	 break;

+      }

+

+      _mesa_symbol_table_add_symbol(state->st, 0, s->name, s);

+      s->next = state->sym;

+      state->sym = s;

+   }

+

+   return s;

+}

+

+

+int add_state_reference(struct gl_program_parameter_list *param_list,

+			const gl_state_index tokens[STATE_LENGTH])

+{

+   const GLuint size = 4; /* XXX fix */

+   char *name;

+   GLint index;

+

+   name = _mesa_program_state_string(tokens);

+   index = _mesa_add_parameter(param_list, PROGRAM_STATE_VAR, name,

+                               size, GL_NONE, NULL, tokens, 0x0);

+   param_list->StateFlags |= _mesa_program_state_flags(tokens);

+

+   /* free name string here since we duplicated it in add_parameter() */

+   free(name);

+

+   return index;

+}

+

+

+int

+initialize_symbol_from_state(struct gl_program *prog,

+			     struct asm_symbol *param_var, 

+			     const gl_state_index tokens[STATE_LENGTH])

+{

+   int idx = -1;

+   gl_state_index state_tokens[STATE_LENGTH];

+

+

+   memcpy(state_tokens, tokens, sizeof(state_tokens));

+

+   param_var->type = at_param;

+   param_var->param_binding_type = PROGRAM_STATE_VAR;

+

+   /* If we are adding a STATE_MATRIX that has multiple rows, we need to

+    * unroll it and call add_state_reference() for each row

+    */

+   if ((state_tokens[0] == STATE_MODELVIEW_MATRIX ||

+	state_tokens[0] == STATE_PROJECTION_MATRIX ||

+	state_tokens[0] == STATE_MVP_MATRIX ||

+	state_tokens[0] == STATE_TEXTURE_MATRIX ||

+	state_tokens[0] == STATE_PROGRAM_MATRIX)

+       && (state_tokens[2] != state_tokens[3])) {

+      int row;

+      const int first_row = state_tokens[2];

+      const int last_row = state_tokens[3];

+

+      for (row = first_row; row <= last_row; row++) {

+	 state_tokens[2] = state_tokens[3] = row;

+

+	 idx = add_state_reference(prog->Parameters, state_tokens);

+	 if (param_var->param_binding_begin == ~0U) {

+	    param_var->param_binding_begin = idx;

+            param_var->param_binding_swizzle = SWIZZLE_XYZW;

+         }

+

+	 param_var->param_binding_length++;

+      }

+   }

+   else {

+      idx = add_state_reference(prog->Parameters, state_tokens);

+      if (param_var->param_binding_begin == ~0U) {

+	 param_var->param_binding_begin = idx;

+         param_var->param_binding_swizzle = SWIZZLE_XYZW;

+      }

+      param_var->param_binding_length++;

+   }

+

+   return idx;

+}

+

+

+int

+initialize_symbol_from_param(struct gl_program *prog,

+			     struct asm_symbol *param_var, 

+			     const gl_state_index tokens[STATE_LENGTH])

+{

+   int idx = -1;

+   gl_state_index state_tokens[STATE_LENGTH];

+

+

+   memcpy(state_tokens, tokens, sizeof(state_tokens));

+

+   assert((state_tokens[0] == STATE_VERTEX_PROGRAM)

+	  || (state_tokens[0] == STATE_FRAGMENT_PROGRAM));

+   assert((state_tokens[1] == STATE_ENV)

+	  || (state_tokens[1] == STATE_LOCAL));

+

+   /*

+    * The param type is STATE_VAR.  The program parameter entry will

+    * effectively be a pointer into the LOCAL or ENV parameter array.

+    */

+   param_var->type = at_param;

+   param_var->param_binding_type = PROGRAM_STATE_VAR;

+

+   /* If we are adding a STATE_ENV or STATE_LOCAL that has multiple elements,

+    * we need to unroll it and call add_state_reference() for each row

+    */

+   if (state_tokens[2] != state_tokens[3]) {

+      int row;

+      const int first_row = state_tokens[2];

+      const int last_row = state_tokens[3];

+

+      for (row = first_row; row <= last_row; row++) {

+	 state_tokens[2] = state_tokens[3] = row;

+

+	 idx = add_state_reference(prog->Parameters, state_tokens);

+	 if (param_var->param_binding_begin == ~0U) {

+	    param_var->param_binding_begin = idx;

+            param_var->param_binding_swizzle = SWIZZLE_XYZW;

+         }

+	 param_var->param_binding_length++;

+      }

+   }

+   else {

+      idx = add_state_reference(prog->Parameters, state_tokens);

+      if (param_var->param_binding_begin == ~0U) {

+	 param_var->param_binding_begin = idx;

+         param_var->param_binding_swizzle = SWIZZLE_XYZW;

+      }

+      param_var->param_binding_length++;

+   }

+

+   return idx;

+}

+

+

+/**

+ * Put a float/vector constant/literal into the parameter list.

+ * \param param_var  returns info about the parameter/constant's location,

+ *                   binding, type, etc.

+ * \param vec  the vector/constant to add

+ * \param allowSwizzle  if true, try to consolidate constants which only differ

+ *                      by a swizzle.  We don't want to do this when building

+ *                      arrays of constants that may be indexed indirectly.

+ * \return index of the constant in the parameter list.

+ */

+int

+initialize_symbol_from_const(struct gl_program *prog,

+			     struct asm_symbol *param_var, 

+			     const struct asm_vector *vec,

+                             GLboolean allowSwizzle)

+{

+   unsigned swizzle;

+   const int idx = _mesa_add_unnamed_constant(prog->Parameters,

+                                              vec->data, vec->count,

+                                              allowSwizzle ? &swizzle : NULL);

+

+   param_var->type = at_param;

+   param_var->param_binding_type = PROGRAM_CONSTANT;

+

+   if (param_var->param_binding_begin == ~0U) {

+      param_var->param_binding_begin = idx;

+      param_var->param_binding_swizzle = allowSwizzle ? swizzle : SWIZZLE_XYZW;

+   }

+   param_var->param_binding_length++;

+

+   return idx;

+}

+

+

+char *

+make_error_string(const char *fmt, ...)

+{

+   int length;

+   char *str;

+   va_list args;

+

+

+   /* Call vsnprintf once to determine how large the final string is.  Call it

+    * again to do the actual formatting.  from the vsnprintf manual page:

+    *

+    *    Upon successful return, these functions return the number of

+    *    characters printed  (not including the trailing '\0' used to end

+    *    output to strings).

+    */

+   va_start(args, fmt);

+   length = 1 + vsnprintf(NULL, 0, fmt, args);

+   va_end(args);

+

+   str = malloc(length);

+   if (str) {

+      va_start(args, fmt);

+      vsnprintf(str, length, fmt, args);

+      va_end(args);

+   }

+

+   return str;

+}

+

+

+void

+yyerror(YYLTYPE *locp, struct asm_parser_state *state, const char *s)

+{

+   char *err_str;

+

+

+   err_str = make_error_string("glProgramStringARB(%s)\n", s);

+   if (err_str) {

+      _mesa_error(state->ctx, GL_INVALID_OPERATION, "%s", err_str);

+      free(err_str);

+   }

+

+   err_str = make_error_string("line %u, char %u: error: %s\n",

+			       locp->first_line, locp->first_column, s);

+   _mesa_set_program_error(state->ctx, locp->position, err_str);

+

+   if (err_str) {

+      free(err_str);

+   }

+}

+

+

+GLboolean

+_mesa_parse_arb_program(struct gl_context *ctx, GLenum target, const GLubyte *str,

+			GLsizei len, struct asm_parser_state *state)

+{

+   struct asm_instruction *inst;

+   unsigned i;

+   GLubyte *strz;

+   GLboolean result = GL_FALSE;

+   void *temp;

+   struct asm_symbol *sym;

+

+   state->ctx = ctx;

+   state->prog->Target = target;

+   state->prog->Parameters = _mesa_new_parameter_list();

+

+   /* Make a copy of the program string and force it to be NUL-terminated.

+    */

+   strz = (GLubyte *) malloc(len + 1);

+   if (strz == NULL) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");

+      return GL_FALSE;

+   }

+   memcpy (strz, str, len);

+   strz[len] = '\0';

+

+   state->prog->String = strz;

+

+   state->st = _mesa_symbol_table_ctor();

+

+   state->limits = (target == GL_VERTEX_PROGRAM_ARB)

+      ? & ctx->Const.VertexProgram

+      : & ctx->Const.FragmentProgram;

+

+   state->MaxTextureImageUnits = ctx->Const.MaxTextureImageUnits;

+   state->MaxTextureCoordUnits = ctx->Const.MaxTextureCoordUnits;

+   state->MaxTextureUnits = ctx->Const.MaxTextureUnits;

+   state->MaxClipPlanes = ctx->Const.MaxClipPlanes;

+   state->MaxLights = ctx->Const.MaxLights;

+   state->MaxProgramMatrices = ctx->Const.MaxProgramMatrices;

+

+   state->state_param_enum = (target == GL_VERTEX_PROGRAM_ARB)

+      ? STATE_VERTEX_PROGRAM : STATE_FRAGMENT_PROGRAM;

+

+   _mesa_set_program_error(ctx, -1, NULL);

+

+   _mesa_program_lexer_ctor(& state->scanner, state, (const char *) str, len);

+   yyparse(state);

+   _mesa_program_lexer_dtor(state->scanner);

+

+

+   if (ctx->Program.ErrorPos != -1) {

+      goto error;

+   }

+

+   if (! _mesa_layout_parameters(state)) {

+      struct YYLTYPE loc;

+

+      loc.first_line = 0;

+      loc.first_column = 0;

+      loc.position = len;

+

+      yyerror(& loc, state, "invalid PARAM usage");

+      goto error;

+   }

+

+

+   

+   /* Add one instruction to store the "END" instruction.

+    */

+   state->prog->Instructions =

+      _mesa_alloc_instructions(state->prog->NumInstructions + 1);

+   inst = state->inst_head;

+   for (i = 0; i < state->prog->NumInstructions; i++) {

+      struct asm_instruction *const temp = inst->next;

+

+      state->prog->Instructions[i] = inst->Base;

+      inst = temp;

+   }

+

+   /* Finally, tag on an OPCODE_END instruction */

+   {

+      const GLuint numInst = state->prog->NumInstructions;

+      _mesa_init_instructions(state->prog->Instructions + numInst, 1);

+      state->prog->Instructions[numInst].Opcode = OPCODE_END;

+   }

+   state->prog->NumInstructions++;

+

+   state->prog->NumParameters = state->prog->Parameters->NumParameters;

+   state->prog->NumAttributes = _mesa_bitcount(state->prog->InputsRead);

+

+   /*

+    * Initialize native counts to logical counts.  The device driver may

+    * change them if program is translated into a hardware program.

+    */

+   state->prog->NumNativeInstructions = state->prog->NumInstructions;

+   state->prog->NumNativeTemporaries = state->prog->NumTemporaries;

+   state->prog->NumNativeParameters = state->prog->NumParameters;

+   state->prog->NumNativeAttributes = state->prog->NumAttributes;

+   state->prog->NumNativeAddressRegs = state->prog->NumAddressRegs;

+

+   result = GL_TRUE;

+

+error:

+   for (inst = state->inst_head; inst != NULL; inst = temp) {

+      temp = inst->next;

+      free(inst);

+   }

+

+   state->inst_head = NULL;

+   state->inst_tail = NULL;

+

+   for (sym = state->sym; sym != NULL; sym = temp) {

+      temp = sym->next;

+

+      free((void *) sym->name);

+      free(sym);

+   }

+   state->sym = NULL;

+

+   _mesa_symbol_table_dtor(state->st);

+   state->st = NULL;

+

+   return result;

+}

diff --git a/mesalib/src/mesa/program/sampler.cpp b/mesalib/src/mesa/program/sampler.cpp
index 1457d1199..b219d7016 100644
--- a/mesalib/src/mesa/program/sampler.cpp
+++ b/mesalib/src/mesa/program/sampler.cpp
@@ -1,137 +1,137 @@
-/*
- * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
- * Copyright (C) 2008  VMware, Inc.   All Rights Reserved.
- * Copyright © 2010 Intel Corporation
- *
- * 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, sublicense,
- * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- */
-
-#include "ir.h"
-#include "glsl_types.h"
-#include "ir_visitor.h"
-
-extern "C" {
-#include "main/compiler.h"
-#include "main/mtypes.h"
-#include "program/prog_parameter.h"
-}
-
-static void fail_link(struct gl_shader_program *prog, const char *fmt, ...) PRINTFLIKE(2, 3);
-
-static void fail_link(struct gl_shader_program *prog, const char *fmt, ...)
-{
-   va_list args;
-   va_start(args, fmt);
-   ralloc_vasprintf_append(&prog->InfoLog, fmt, args);
-   va_end(args);
-
-   prog->LinkStatus = GL_FALSE;
-}
-
-class get_sampler_name : public ir_hierarchical_visitor
-{
-public:
-   get_sampler_name(ir_dereference *last,
-		    struct gl_shader_program *shader_program)
-   {
-      this->mem_ctx = ralloc_context(NULL);
-      this->shader_program = shader_program;
-      this->name = NULL;
-      this->offset = 0;
-      this->last = last;
-   }
-
-   ~get_sampler_name()
-   {
-      ralloc_free(this->mem_ctx);
-   }
-
-   virtual ir_visitor_status visit(ir_dereference_variable *ir)
-   {
-      this->name = ir->var->name;
-      return visit_continue;
-   }
-
-   virtual ir_visitor_status visit_leave(ir_dereference_record *ir)
-   {
-      this->name = ralloc_asprintf(mem_ctx, "%s.%s", name, ir->field);
-      return visit_continue;
-   }
-
-   virtual ir_visitor_status visit_leave(ir_dereference_array *ir)
-   {
-      ir_constant *index = ir->array_index->as_constant();
-      int i;
-
-      if (index) {
-	 i = index->value.i[0];
-      } else {
-	 /* GLSL 1.10 and 1.20 allowed variable sampler array indices,
-	  * while GLSL 1.30 requires that the array indices be
-	  * constant integer expressions.  We don't expect any driver
-	  * to actually work with a really variable array index, so
-	  * all that would work would be an unrolled loop counter that ends
-	  * up being constant above.
-	  */
-	 ralloc_strcat(&shader_program->InfoLog,
-		       "warning: Variable sampler array index unsupported.\n"
-		       "This feature of the language was removed in GLSL 1.20 "
-		       "and is unlikely to be supported for 1.10 in Mesa.\n");
-	 i = 0;
-      }
-      if (ir != last) {
-	 this->name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i);
-      } else {
-	 offset = i;
-      }
-      return visit_continue;
-   }
-
-   struct gl_shader_program *shader_program;
-   const char *name;
-   void *mem_ctx;
-   int offset;
-   ir_dereference *last;
-};
-
-extern "C" {
-int
-_mesa_get_sampler_uniform_value(class ir_dereference *sampler,
-				struct gl_shader_program *shader_program,
-				const struct gl_program *prog)
-{
-   get_sampler_name getname(sampler, shader_program);
-
-   sampler->accept(&getname);
-
-   GLint index = _mesa_lookup_parameter_index(prog->Parameters, -1,
-					      getname.name);
-
-   if (index < 0) {
-      fail_link(shader_program,
-		"failed to find sampler named %s.\n", getname.name);
-      return 0;
-   }
-
-   index += getname.offset;
-
-   return prog->Parameters->ParameterValues[index][0];
-}
-}
+/*

+ * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2008  VMware, Inc.   All Rights Reserved.

+ * Copyright © 2010 Intel Corporation

+ *

+ * 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, sublicense,

+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+

+#include "ir.h"

+#include "glsl_types.h"

+#include "ir_visitor.h"

+

+extern "C" {

+#include "main/compiler.h"

+#include "main/mtypes.h"

+#include "program/prog_parameter.h"

+}

+

+static void fail_link(struct gl_shader_program *prog, const char *fmt, ...) PRINTFLIKE(2, 3);

+

+static void fail_link(struct gl_shader_program *prog, const char *fmt, ...)

+{

+   va_list args;

+   va_start(args, fmt);

+   ralloc_vasprintf_append(&prog->InfoLog, fmt, args);

+   va_end(args);

+

+   prog->LinkStatus = GL_FALSE;

+}

+

+class get_sampler_name : public ir_hierarchical_visitor

+{

+public:

+   get_sampler_name(ir_dereference *last,

+		    struct gl_shader_program *shader_program)

+   {

+      this->mem_ctx = ralloc_context(NULL);

+      this->shader_program = shader_program;

+      this->name = NULL;

+      this->offset = 0;

+      this->last = last;

+   }

+

+   ~get_sampler_name()

+   {

+      ralloc_free(this->mem_ctx);

+   }

+

+   virtual ir_visitor_status visit(ir_dereference_variable *ir)

+   {

+      this->name = ir->var->name;

+      return visit_continue;

+   }

+

+   virtual ir_visitor_status visit_leave(ir_dereference_record *ir)

+   {

+      this->name = ralloc_asprintf(mem_ctx, "%s.%s", name, ir->field);

+      return visit_continue;

+   }

+

+   virtual ir_visitor_status visit_leave(ir_dereference_array *ir)

+   {

+      ir_constant *index = ir->array_index->as_constant();

+      int i;

+

+      if (index) {

+	 i = index->value.i[0];

+      } else {

+	 /* GLSL 1.10 and 1.20 allowed variable sampler array indices,

+	  * while GLSL 1.30 requires that the array indices be

+	  * constant integer expressions.  We don't expect any driver

+	  * to actually work with a really variable array index, so

+	  * all that would work would be an unrolled loop counter that ends

+	  * up being constant above.

+	  */

+	 ralloc_strcat(&shader_program->InfoLog,

+		       "warning: Variable sampler array index unsupported.\n"

+		       "This feature of the language was removed in GLSL 1.20 "

+		       "and is unlikely to be supported for 1.10 in Mesa.\n");

+	 i = 0;

+      }

+      if (ir != last) {

+	 this->name = ralloc_asprintf(mem_ctx, "%s[%d]", name, i);

+      } else {

+	 offset = i;

+      }

+      return visit_continue;

+   }

+

+   struct gl_shader_program *shader_program;

+   const char *name;

+   void *mem_ctx;

+   int offset;

+   ir_dereference *last;

+};

+

+extern "C" {

+int

+_mesa_get_sampler_uniform_value(class ir_dereference *sampler,

+				struct gl_shader_program *shader_program,

+				const struct gl_program *prog)

+{

+   get_sampler_name getname(sampler, shader_program);

+

+   sampler->accept(&getname);

+

+   GLint index = _mesa_lookup_parameter_index(prog->Parameters, -1,

+					      getname.name);

+

+   if (index < 0) {

+      fail_link(shader_program,

+		"failed to find sampler named %s.\n", getname.name);

+      return 0;

+   }

+

+   index += getname.offset;

+

+   return prog->Parameters->ParameterValues[index][0];

+}

+}

diff --git a/mesalib/src/mesa/sources.mak b/mesalib/src/mesa/sources.mak
index 95330947a..b76f63de4 100644
--- a/mesalib/src/mesa/sources.mak
+++ b/mesalib/src/mesa/sources.mak
@@ -1,372 +1,372 @@
-### Lists of source files, included by Makefiles
-
-# this is part of MAIN_SOURCES
-MAIN_ES_SOURCES = \
-	main/api_exec_es1.c \
-	main/api_exec_es2.c
-
-MAIN_SOURCES = \
-	main/api_arrayelt.c \
-	main/api_exec.c \
-	main/api_loopback.c \
-	main/api_noop.c \
-	main/api_validate.c \
-	main/accum.c \
-	main/arbprogram.c \
-	main/atifragshader.c \
-	main/attrib.c \
-	main/arrayobj.c \
-	main/blend.c \
-	main/bufferobj.c \
-	main/buffers.c \
-	main/clear.c \
-	main/clip.c \
-	main/colortab.c \
-	main/condrender.c \
-	main/context.c \
-	main/convolve.c \
-	main/cpuinfo.c \
-	main/debug.c \
-	main/depth.c \
-	main/depthstencil.c \
-	main/dlist.c \
-	main/dlopen.c \
-	main/drawpix.c \
-	main/drawtex.c \
-	main/enable.c \
-	main/enums.c \
-	main/eval.c \
-	main/execmem.c \
-	main/extensions.c \
-	main/fbobject.c \
-	main/feedback.c \
-	main/ffvertex_prog.c \
-	main/fog.c \
-	main/formats.c \
-	main/framebuffer.c \
-	main/get.c \
-	main/getstring.c \
-	main/hash.c \
-	main/hint.c \
-	main/histogram.c \
-	main/image.c \
-	main/imports.c \
-	main/light.c \
-	main/lines.c \
-	main/matrix.c \
-	main/mipmap.c \
-	main/mm.c \
-	main/multisample.c \
-	main/nvprogram.c \
-	main/pack.c \
-	main/pbo.c \
-	main/pixel.c \
-	main/pixelstore.c \
-	main/pixeltransfer.c \
-	main/points.c \
-	main/polygon.c \
-	main/queryobj.c \
-	main/querymatrix.c \
-	main/rastpos.c \
-	main/readpix.c \
-	main/remap.c \
-	main/renderbuffer.c \
-	main/scissor.c \
-	main/shaderapi.c \
-	main/shaderobj.c \
-	main/shared.c \
-	main/state.c \
-	main/stencil.c \
-	main/syncobj.c \
-	main/texcompress.c \
-	main/texcompress_rgtc.c \
-	main/texcompress_s3tc.c \
-	main/texcompress_fxt1.c \
-	main/texenv.c \
-	main/texenvprogram.c \
-	main/texfetch.c \
-	main/texformat.c \
-	main/texgen.c \
-	main/texgetimage.c \
-	main/teximage.c \
-	main/texobj.c \
-	main/texpal.c \
-	main/texparam.c \
-	main/texrender.c \
-	main/texstate.c \
-	main/texstore.c \
-	main/transformfeedback.c \
-	main/uniforms.c \
-	main/varray.c \
-	main/version.c \
-	main/viewport.c \
-	main/vtxfmt.c \
-	$(MAIN_ES_SOURCES)
-
-MATH_SOURCES = \
-	math/m_debug_clip.c \
-	math/m_debug_norm.c \
-	math/m_debug_xform.c \
-	math/m_eval.c \
-	math/m_matrix.c \
-	math/m_translate.c \
-	math/m_vector.c
-
-MATH_XFORM_SOURCES = \
-	math/m_xform.c
-
-SWRAST_SOURCES = \
-	swrast/s_aaline.c \
-	swrast/s_aatriangle.c \
-	swrast/s_accum.c \
-	swrast/s_alpha.c \
-	swrast/s_atifragshader.c \
-	swrast/s_bitmap.c \
-	swrast/s_blend.c \
-	swrast/s_blit.c \
-	swrast/s_clear.c \
-	swrast/s_copypix.c \
-	swrast/s_context.c \
-	swrast/s_depth.c \
-	swrast/s_drawpix.c \
-	swrast/s_feedback.c \
-	swrast/s_fog.c \
-	swrast/s_fragprog.c \
-	swrast/s_lines.c \
-	swrast/s_logic.c \
-	swrast/s_masking.c \
-	swrast/s_points.c \
-	swrast/s_readpix.c \
-	swrast/s_span.c \
-	swrast/s_stencil.c \
-	swrast/s_texcombine.c \
-	swrast/s_texfilter.c \
-	swrast/s_triangle.c \
-	swrast/s_zoom.c
-
-SWRAST_SETUP_SOURCES = \
-	swrast_setup/ss_context.c \
-	swrast_setup/ss_triangle.c 
-
-TNL_SOURCES = \
-	tnl/t_context.c \
-	tnl/t_pipeline.c \
-	tnl/t_draw.c \
-	tnl/t_rasterpos.c \
-	tnl/t_vb_program.c \
-	tnl/t_vb_render.c \
-	tnl/t_vb_texgen.c \
-	tnl/t_vb_texmat.c \
-	tnl/t_vb_vertex.c \
-	tnl/t_vb_fog.c \
-	tnl/t_vb_light.c \
-	tnl/t_vb_normals.c \
-	tnl/t_vb_points.c \
-	tnl/t_vp_build.c \
-	tnl/t_vertex.c \
-	tnl/t_vertex_sse.c \
-	tnl/t_vertex_generic.c 
-
-VBO_SOURCES = \
-	vbo/vbo_context.c \
-	vbo/vbo_exec.c \
-	vbo/vbo_exec_api.c \
-	vbo/vbo_exec_array.c \
-	vbo/vbo_exec_draw.c \
-	vbo/vbo_exec_eval.c \
-	vbo/vbo_rebase.c \
-	vbo/vbo_split.c \
-	vbo/vbo_split_copy.c \
-	vbo/vbo_split_inplace.c \
-	vbo/vbo_save.c \
-	vbo/vbo_save_api.c \
-	vbo/vbo_save_draw.c \
-	vbo/vbo_save_loopback.c 
-
-STATETRACKER_SOURCES = \
-	state_tracker/st_atom.c \
-	state_tracker/st_atom_blend.c \
-	state_tracker/st_atom_clip.c \
-	state_tracker/st_atom_constbuf.c \
-	state_tracker/st_atom_depth.c \
-	state_tracker/st_atom_framebuffer.c \
-	state_tracker/st_atom_msaa.c \
-	state_tracker/st_atom_pixeltransfer.c \
-	state_tracker/st_atom_sampler.c \
-	state_tracker/st_atom_scissor.c \
-	state_tracker/st_atom_shader.c \
-	state_tracker/st_atom_rasterizer.c \
-	state_tracker/st_atom_stipple.c \
-	state_tracker/st_atom_texture.c \
-	state_tracker/st_atom_viewport.c \
-	state_tracker/st_cb_accum.c \
-	state_tracker/st_cb_bitmap.c \
-	state_tracker/st_cb_blit.c \
-	state_tracker/st_cb_bufferobjects.c \
-	state_tracker/st_cb_clear.c \
-	state_tracker/st_cb_condrender.c \
-	state_tracker/st_cb_flush.c \
-	state_tracker/st_cb_drawpixels.c \
-	state_tracker/st_cb_drawtex.c \
-	state_tracker/st_cb_eglimage.c \
-	state_tracker/st_cb_fbo.c \
-	state_tracker/st_cb_feedback.c \
-	state_tracker/st_cb_program.c \
-	state_tracker/st_cb_queryobj.c \
-	state_tracker/st_cb_rasterpos.c \
-	state_tracker/st_cb_readpixels.c \
-	state_tracker/st_cb_syncobj.c \
-	state_tracker/st_cb_strings.c \
-	state_tracker/st_cb_texture.c \
-	state_tracker/st_cb_viewport.c \
-	state_tracker/st_cb_xformfb.c \
-	state_tracker/st_context.c \
-	state_tracker/st_debug.c \
-	state_tracker/st_draw.c \
-	state_tracker/st_draw_feedback.c \
-	state_tracker/st_extensions.c \
-	state_tracker/st_format.c \
-	state_tracker/st_gen_mipmap.c \
-	state_tracker/st_manager.c \
-	state_tracker/st_mesa_to_tgsi.c \
-	state_tracker/st_program.c \
-	state_tracker/st_texture.c
-
-PROGRAM_SOURCES = \
-	program/arbprogparse.c \
-	program/hash_table.c \
-	program/lex.yy.c \
-	program/nvfragparse.c \
-	program/nvvertparse.c \
-	program/program.c \
-	program/program_parse.tab.c \
-	program/program_parse_extra.c \
-	program/prog_cache.c \
-	program/prog_execute.c \
-	program/prog_instruction.c \
-	program/prog_noise.c \
-	program/prog_optimize.c \
-	program/prog_parameter.c \
-	program/prog_parameter_layout.c \
-	program/prog_print.c \
-	program/prog_statevars.c \
-	program/prog_uniform.c \
-	program/programopt.c \
-	program/register_allocate.c \
-	program/symbol_table.c
-
-
-SHADER_CXX_SOURCES = \
-	program/ir_to_mesa.cpp \
-	program/sampler.cpp
-
-ASM_C_SOURCES =	\
-	x86/common_x86.c \
-	x86/x86_xform.c \
-	x86/3dnow.c \
-	x86/sse.c \
-	x86/rtasm/x86sse.c \
-	sparc/sparc.c \
-	ppc/common_ppc.c \
-	x86-64/x86-64.c
-
-X86_SOURCES =			\
-	x86/common_x86_asm.S	\
-	x86/x86_xform2.S	\
-	x86/x86_xform3.S	\
-	x86/x86_xform4.S	\
-	x86/x86_cliptest.S	\
-	x86/mmx_blend.S		\
-	x86/3dnow_xform1.S	\
-	x86/3dnow_xform2.S	\
-	x86/3dnow_xform3.S	\
-	x86/3dnow_xform4.S	\
-	x86/3dnow_normal.S	\
-	x86/sse_xform1.S	\
-	x86/sse_xform2.S	\
-	x86/sse_xform3.S	\
-	x86/sse_xform4.S	\
-	x86/sse_normal.S	\
-	x86/read_rgba_span_x86.S
-
-X86-64_SOURCES =		\
-	x86-64/xform4.S
-
-SPARC_SOURCES =			\
-	sparc/clip.S		\
-	sparc/norm.S		\
-	sparc/xform.S
-
-COMMON_DRIVER_SOURCES =			\
-	drivers/common/driverfuncs.c	\
-	drivers/common/meta.c
-
-
-# Sources for building non-Gallium drivers
-MESA_SOURCES = \
-	$(MAIN_SOURCES)		\
-	$(MATH_SOURCES)		\
-	$(MATH_XFORM_SOURCES)	\
-	$(VBO_SOURCES)		\
-	$(TNL_SOURCES)		\
-	$(PROGRAM_SOURCES)	\
-	$(SWRAST_SOURCES)	\
-	$(SWRAST_SETUP_SOURCES)	\
-	$(COMMON_DRIVER_SOURCES)\
-	$(ASM_C_SOURCES)
-
-MESA_CXX_SOURCES = \
-	 $(SHADER_CXX_SOURCES)
-
-# Sources for building Gallium drivers
-MESA_GALLIUM_SOURCES = \
-	$(MAIN_SOURCES)		\
-	$(MATH_SOURCES)		\
-	$(VBO_SOURCES)		\
-	$(STATETRACKER_SOURCES)	\
-	$(PROGRAM_SOURCES)	\
-	ppc/common_ppc.c	\
-	x86/common_x86.c
-
-MESA_GALLIUM_CXX_SOURCES = \
-	 $(SHADER_CXX_SOURCES)
-
-# All the core C sources, for dependency checking
-ALL_SOURCES = \
-	$(MESA_SOURCES)		\
-	$(MESA_CXX_SOURCES)	\
-	$(MESA_ASM_SOURCES)	\
-	$(STATETRACKER_SOURCES)
-
-
-### Object files
-
-MESA_OBJECTS = \
-	$(MESA_SOURCES:.c=.o) \
-	$(MESA_CXX_SOURCES:.cpp=.o) \
-	$(MESA_ASM_SOURCES:.S=.o)
-
-MESA_GALLIUM_OBJECTS = \
-	$(MESA_GALLIUM_SOURCES:.c=.o) \
-	$(MESA_GALLIUM_CXX_SOURCES:.cpp=.o) \
-	$(MESA_ASM_SOURCES:.S=.o)
-
-
-COMMON_DRIVER_OBJECTS = $(COMMON_DRIVER_SOURCES:.c=.o)
-
-
-### Other archives/libraries
-
-GLSL_LIBS = \
-	$(TOP)/src/glsl/libglsl.a
-
-
-### Include directories
-
-INCLUDE_DIRS = \
-	-I$(TOP)/include \
-	-I$(TOP)/src/glsl \
-	-I$(TOP)/src/mesa \
-	-I$(TOP)/src/mapi \
-	-I$(TOP)/src/gallium/include \
-	-I$(TOP)/src/gallium/auxiliary
+### Lists of source files, included by Makefiles

+

+# this is part of MAIN_SOURCES

+MAIN_ES_SOURCES = \

+	main/api_exec_es1.c \

+	main/api_exec_es2.c

+

+MAIN_SOURCES = \

+	main/api_arrayelt.c \

+	main/api_exec.c \

+	main/api_loopback.c \

+	main/api_noop.c \

+	main/api_validate.c \

+	main/accum.c \

+	main/arbprogram.c \

+	main/atifragshader.c \

+	main/attrib.c \

+	main/arrayobj.c \

+	main/blend.c \

+	main/bufferobj.c \

+	main/buffers.c \

+	main/clear.c \

+	main/clip.c \

+	main/colortab.c \

+	main/condrender.c \

+	main/context.c \

+	main/convolve.c \

+	main/cpuinfo.c \

+	main/debug.c \

+	main/depth.c \

+	main/depthstencil.c \

+	main/dlist.c \

+	main/dlopen.c \

+	main/drawpix.c \

+	main/drawtex.c \

+	main/enable.c \

+	main/enums.c \

+	main/eval.c \

+	main/execmem.c \

+	main/extensions.c \

+	main/fbobject.c \

+	main/feedback.c \

+	main/ffvertex_prog.c \

+	main/fog.c \

+	main/formats.c \

+	main/framebuffer.c \

+	main/get.c \

+	main/getstring.c \

+	main/hash.c \

+	main/hint.c \

+	main/histogram.c \

+	main/image.c \

+	main/imports.c \

+	main/light.c \

+	main/lines.c \

+	main/matrix.c \

+	main/mipmap.c \

+	main/mm.c \

+	main/multisample.c \

+	main/nvprogram.c \

+	main/pack.c \

+	main/pbo.c \

+	main/pixel.c \

+	main/pixelstore.c \

+	main/pixeltransfer.c \

+	main/points.c \

+	main/polygon.c \

+	main/queryobj.c \

+	main/querymatrix.c \

+	main/rastpos.c \

+	main/readpix.c \

+	main/remap.c \

+	main/renderbuffer.c \

+	main/scissor.c \

+	main/shaderapi.c \

+	main/shaderobj.c \

+	main/shared.c \

+	main/state.c \

+	main/stencil.c \

+	main/syncobj.c \

+	main/texcompress.c \

+	main/texcompress_rgtc.c \

+	main/texcompress_s3tc.c \

+	main/texcompress_fxt1.c \

+	main/texenv.c \

+	main/texenvprogram.c \

+	main/texfetch.c \

+	main/texformat.c \

+	main/texgen.c \

+	main/texgetimage.c \

+	main/teximage.c \

+	main/texobj.c \

+	main/texpal.c \

+	main/texparam.c \

+	main/texrender.c \

+	main/texstate.c \

+	main/texstore.c \

+	main/transformfeedback.c \

+	main/uniforms.c \

+	main/varray.c \

+	main/version.c \

+	main/viewport.c \

+	main/vtxfmt.c \

+	$(MAIN_ES_SOURCES)

+

+MATH_SOURCES = \

+	math/m_debug_clip.c \

+	math/m_debug_norm.c \

+	math/m_debug_xform.c \

+	math/m_eval.c \

+	math/m_matrix.c \

+	math/m_translate.c \

+	math/m_vector.c

+

+MATH_XFORM_SOURCES = \

+	math/m_xform.c

+

+SWRAST_SOURCES = \

+	swrast/s_aaline.c \

+	swrast/s_aatriangle.c \

+	swrast/s_accum.c \

+	swrast/s_alpha.c \

+	swrast/s_atifragshader.c \

+	swrast/s_bitmap.c \

+	swrast/s_blend.c \

+	swrast/s_blit.c \

+	swrast/s_clear.c \

+	swrast/s_copypix.c \

+	swrast/s_context.c \

+	swrast/s_depth.c \

+	swrast/s_drawpix.c \

+	swrast/s_feedback.c \

+	swrast/s_fog.c \

+	swrast/s_fragprog.c \

+	swrast/s_lines.c \

+	swrast/s_logic.c \

+	swrast/s_masking.c \

+	swrast/s_points.c \

+	swrast/s_readpix.c \

+	swrast/s_span.c \

+	swrast/s_stencil.c \

+	swrast/s_texcombine.c \

+	swrast/s_texfilter.c \

+	swrast/s_triangle.c \

+	swrast/s_zoom.c

+

+SWRAST_SETUP_SOURCES = \

+	swrast_setup/ss_context.c \

+	swrast_setup/ss_triangle.c 

+

+TNL_SOURCES = \

+	tnl/t_context.c \

+	tnl/t_pipeline.c \

+	tnl/t_draw.c \

+	tnl/t_rasterpos.c \

+	tnl/t_vb_program.c \

+	tnl/t_vb_render.c \

+	tnl/t_vb_texgen.c \

+	tnl/t_vb_texmat.c \

+	tnl/t_vb_vertex.c \

+	tnl/t_vb_fog.c \

+	tnl/t_vb_light.c \

+	tnl/t_vb_normals.c \

+	tnl/t_vb_points.c \

+	tnl/t_vp_build.c \

+	tnl/t_vertex.c \

+	tnl/t_vertex_sse.c \

+	tnl/t_vertex_generic.c 

+

+VBO_SOURCES = \

+	vbo/vbo_context.c \

+	vbo/vbo_exec.c \

+	vbo/vbo_exec_api.c \

+	vbo/vbo_exec_array.c \

+	vbo/vbo_exec_draw.c \

+	vbo/vbo_exec_eval.c \

+	vbo/vbo_rebase.c \

+	vbo/vbo_split.c \

+	vbo/vbo_split_copy.c \

+	vbo/vbo_split_inplace.c \

+	vbo/vbo_save.c \

+	vbo/vbo_save_api.c \

+	vbo/vbo_save_draw.c \

+	vbo/vbo_save_loopback.c 

+

+STATETRACKER_SOURCES = \

+	state_tracker/st_atom.c \

+	state_tracker/st_atom_blend.c \

+	state_tracker/st_atom_clip.c \

+	state_tracker/st_atom_constbuf.c \

+	state_tracker/st_atom_depth.c \

+	state_tracker/st_atom_framebuffer.c \

+	state_tracker/st_atom_msaa.c \

+	state_tracker/st_atom_pixeltransfer.c \

+	state_tracker/st_atom_sampler.c \

+	state_tracker/st_atom_scissor.c \

+	state_tracker/st_atom_shader.c \

+	state_tracker/st_atom_rasterizer.c \

+	state_tracker/st_atom_stipple.c \

+	state_tracker/st_atom_texture.c \

+	state_tracker/st_atom_viewport.c \

+	state_tracker/st_cb_accum.c \

+	state_tracker/st_cb_bitmap.c \

+	state_tracker/st_cb_blit.c \

+	state_tracker/st_cb_bufferobjects.c \

+	state_tracker/st_cb_clear.c \

+	state_tracker/st_cb_condrender.c \

+	state_tracker/st_cb_flush.c \

+	state_tracker/st_cb_drawpixels.c \

+	state_tracker/st_cb_drawtex.c \

+	state_tracker/st_cb_eglimage.c \

+	state_tracker/st_cb_fbo.c \

+	state_tracker/st_cb_feedback.c \

+	state_tracker/st_cb_program.c \

+	state_tracker/st_cb_queryobj.c \

+	state_tracker/st_cb_rasterpos.c \

+	state_tracker/st_cb_readpixels.c \

+	state_tracker/st_cb_syncobj.c \

+	state_tracker/st_cb_strings.c \

+	state_tracker/st_cb_texture.c \

+	state_tracker/st_cb_viewport.c \

+	state_tracker/st_cb_xformfb.c \

+	state_tracker/st_context.c \

+	state_tracker/st_debug.c \

+	state_tracker/st_draw.c \

+	state_tracker/st_draw_feedback.c \

+	state_tracker/st_extensions.c \

+	state_tracker/st_format.c \

+	state_tracker/st_gen_mipmap.c \

+	state_tracker/st_manager.c \

+	state_tracker/st_mesa_to_tgsi.c \

+	state_tracker/st_program.c \

+	state_tracker/st_texture.c

+

+PROGRAM_SOURCES = \

+	program/arbprogparse.c \

+	program/hash_table.c \

+	program/lex.yy.c \

+	program/nvfragparse.c \

+	program/nvvertparse.c \

+	program/program.c \

+	program/program_parse.tab.c \

+	program/program_parse_extra.c \

+	program/prog_cache.c \

+	program/prog_execute.c \

+	program/prog_instruction.c \

+	program/prog_noise.c \

+	program/prog_optimize.c \

+	program/prog_parameter.c \

+	program/prog_parameter_layout.c \

+	program/prog_print.c \

+	program/prog_statevars.c \

+	program/prog_uniform.c \

+	program/programopt.c \

+	program/register_allocate.c \

+	program/symbol_table.c

+

+

+SHADER_CXX_SOURCES = \

+	program/ir_to_mesa.cpp \

+	program/sampler.cpp

+

+ASM_C_SOURCES =	\

+	x86/common_x86.c \

+	x86/x86_xform.c \

+	x86/3dnow.c \

+	x86/sse.c \

+	x86/rtasm/x86sse.c \

+	sparc/sparc.c \

+	ppc/common_ppc.c \

+	x86-64/x86-64.c

+

+X86_SOURCES =			\

+	x86/common_x86_asm.S	\

+	x86/x86_xform2.S	\

+	x86/x86_xform3.S	\

+	x86/x86_xform4.S	\

+	x86/x86_cliptest.S	\

+	x86/mmx_blend.S		\

+	x86/3dnow_xform1.S	\

+	x86/3dnow_xform2.S	\

+	x86/3dnow_xform3.S	\

+	x86/3dnow_xform4.S	\

+	x86/3dnow_normal.S	\

+	x86/sse_xform1.S	\

+	x86/sse_xform2.S	\

+	x86/sse_xform3.S	\

+	x86/sse_xform4.S	\

+	x86/sse_normal.S	\

+	x86/read_rgba_span_x86.S

+

+X86-64_SOURCES =		\

+	x86-64/xform4.S

+

+SPARC_SOURCES =			\

+	sparc/clip.S		\

+	sparc/norm.S		\

+	sparc/xform.S

+

+COMMON_DRIVER_SOURCES =			\

+	drivers/common/driverfuncs.c	\

+	drivers/common/meta.c

+

+

+# Sources for building non-Gallium drivers

+MESA_SOURCES = \

+	$(MAIN_SOURCES)		\

+	$(MATH_SOURCES)		\

+	$(MATH_XFORM_SOURCES)	\

+	$(VBO_SOURCES)		\

+	$(TNL_SOURCES)		\

+	$(PROGRAM_SOURCES)	\

+	$(SWRAST_SOURCES)	\

+	$(SWRAST_SETUP_SOURCES)	\

+	$(COMMON_DRIVER_SOURCES)\

+	$(ASM_C_SOURCES)

+

+MESA_CXX_SOURCES = \

+	 $(SHADER_CXX_SOURCES)

+

+# Sources for building Gallium drivers

+MESA_GALLIUM_SOURCES = \

+	$(MAIN_SOURCES)		\

+	$(MATH_SOURCES)		\

+	$(VBO_SOURCES)		\

+	$(STATETRACKER_SOURCES)	\

+	$(PROGRAM_SOURCES)	\

+	ppc/common_ppc.c	\

+	x86/common_x86.c

+

+MESA_GALLIUM_CXX_SOURCES = \

+	 $(SHADER_CXX_SOURCES)

+

+# All the core C sources, for dependency checking

+ALL_SOURCES = \

+	$(MESA_SOURCES)		\

+	$(MESA_CXX_SOURCES)	\

+	$(MESA_ASM_SOURCES)	\

+	$(STATETRACKER_SOURCES)

+

+

+### Object files

+

+MESA_OBJECTS = \

+	$(MESA_SOURCES:.c=.o) \

+	$(MESA_CXX_SOURCES:.cpp=.o) \

+	$(MESA_ASM_SOURCES:.S=.o)

+

+MESA_GALLIUM_OBJECTS = \

+	$(MESA_GALLIUM_SOURCES:.c=.o) \

+	$(MESA_GALLIUM_CXX_SOURCES:.cpp=.o) \

+	$(MESA_ASM_SOURCES:.S=.o)

+

+

+COMMON_DRIVER_OBJECTS = $(COMMON_DRIVER_SOURCES:.c=.o)

+

+

+### Other archives/libraries

+

+GLSL_LIBS = \

+	$(TOP)/src/glsl/libglsl.a

+

+

+### Include directories

+

+INCLUDE_DIRS = \

+	-I$(TOP)/include \

+	-I$(TOP)/src/glsl \

+	-I$(TOP)/src/mesa \

+	-I$(TOP)/src/mapi \

+	-I$(TOP)/src/gallium/include \

+	-I$(TOP)/src/gallium/auxiliary

diff --git a/mesalib/src/mesa/state_tracker/st_atom_blend.c b/mesalib/src/mesa/state_tracker/st_atom_blend.c
index fb1c7a4ef..e3b3b9936 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_blend.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_blend.c
@@ -1,302 +1,302 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
- 
-
-#include "st_context.h"
-#include "st_atom.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "cso_cache/cso_context.h"
-
-#include "main/macros.h"
-
-/**
- * Convert GLenum blend tokens to pipe tokens.
- * Both blend factors and blend funcs are accepted.
- */
-static GLuint
-translate_blend(GLenum blend)
-{
-   switch (blend) {
-   /* blend functions */
-   case GL_FUNC_ADD:
-      return PIPE_BLEND_ADD;
-   case GL_FUNC_SUBTRACT:
-      return PIPE_BLEND_SUBTRACT;
-   case GL_FUNC_REVERSE_SUBTRACT:
-      return PIPE_BLEND_REVERSE_SUBTRACT;
-   case GL_MIN:
-      return PIPE_BLEND_MIN;
-   case GL_MAX:
-      return PIPE_BLEND_MAX;
-
-   /* blend factors */
-   case GL_ONE:
-      return PIPE_BLENDFACTOR_ONE;
-   case GL_SRC_COLOR:
-      return PIPE_BLENDFACTOR_SRC_COLOR;
-   case GL_SRC_ALPHA:
-      return PIPE_BLENDFACTOR_SRC_ALPHA;
-   case GL_DST_ALPHA:
-      return PIPE_BLENDFACTOR_DST_ALPHA;
-   case GL_DST_COLOR:
-      return PIPE_BLENDFACTOR_DST_COLOR;
-   case GL_SRC_ALPHA_SATURATE:
-      return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
-   case GL_CONSTANT_COLOR:
-      return PIPE_BLENDFACTOR_CONST_COLOR;
-   case GL_CONSTANT_ALPHA:
-      return PIPE_BLENDFACTOR_CONST_ALPHA;
-      /*
-      return PIPE_BLENDFACTOR_SRC1_COLOR;
-      return PIPE_BLENDFACTOR_SRC1_ALPHA;
-      */
-   case GL_ZERO:
-      return PIPE_BLENDFACTOR_ZERO;
-   case GL_ONE_MINUS_SRC_COLOR:
-      return PIPE_BLENDFACTOR_INV_SRC_COLOR;
-   case GL_ONE_MINUS_SRC_ALPHA:
-      return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
-   case GL_ONE_MINUS_DST_COLOR:
-      return PIPE_BLENDFACTOR_INV_DST_COLOR;
-   case GL_ONE_MINUS_DST_ALPHA:
-      return PIPE_BLENDFACTOR_INV_DST_ALPHA;
-   case GL_ONE_MINUS_CONSTANT_COLOR:
-      return PIPE_BLENDFACTOR_INV_CONST_COLOR;
-   case GL_ONE_MINUS_CONSTANT_ALPHA:
-      return PIPE_BLENDFACTOR_INV_CONST_ALPHA;
-      /*
-      return PIPE_BLENDFACTOR_INV_SRC1_COLOR;
-      return PIPE_BLENDFACTOR_INV_SRC1_ALPHA;
-      */
-   default:
-      assert("invalid GL token in translate_blend()" == NULL);
-      return 0;
-   }
-}
-
-
-/**
- * Convert GLenum logicop tokens to pipe tokens.
- */
-static GLuint
-translate_logicop(GLenum logicop)
-{
-   switch (logicop) {
-   case GL_CLEAR:
-      return PIPE_LOGICOP_CLEAR;
-   case GL_NOR:
-      return PIPE_LOGICOP_NOR;
-   case GL_AND_INVERTED:
-      return PIPE_LOGICOP_AND_INVERTED;
-   case GL_COPY_INVERTED:
-      return PIPE_LOGICOP_COPY_INVERTED;
-   case GL_AND_REVERSE:
-      return PIPE_LOGICOP_AND_REVERSE;
-   case GL_INVERT:
-      return PIPE_LOGICOP_INVERT;
-   case GL_XOR:
-      return PIPE_LOGICOP_XOR;
-   case GL_NAND:
-      return PIPE_LOGICOP_NAND;
-   case GL_AND:
-      return PIPE_LOGICOP_AND;
-   case GL_EQUIV:
-      return PIPE_LOGICOP_EQUIV;
-   case GL_NOOP:
-      return PIPE_LOGICOP_NOOP;
-   case GL_OR_INVERTED:
-      return PIPE_LOGICOP_OR_INVERTED;
-   case GL_COPY:
-      return PIPE_LOGICOP_COPY;
-   case GL_OR_REVERSE:
-      return PIPE_LOGICOP_OR_REVERSE;
-   case GL_OR:
-      return PIPE_LOGICOP_OR;
-   case GL_SET:
-      return PIPE_LOGICOP_SET;
-   default:
-      assert("invalid GL token in translate_logicop()" == NULL);
-      return 0;
-   }
-}
-
-/**
- * Figure out if colormasks are different per rt.
- */
-static GLboolean
-colormask_per_rt(struct gl_context *ctx)
-{
-   /* a bit suboptimal have to compare lots of values */
-   unsigned i;
-   for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
-      if (memcmp(ctx->Color.ColorMask[0], ctx->Color.ColorMask[i], 4)) {
-         return GL_TRUE;
-      }
-   }
-   return GL_FALSE;
-}
-
-/**
- * Figure out if blend enables/state are different per rt.
- */
-static GLboolean
-blend_per_rt(struct gl_context *ctx)
-{
-   if (ctx->Color.BlendEnabled &&
-      (ctx->Color.BlendEnabled != ((1 << ctx->Const.MaxDrawBuffers) - 1))) {
-      /* This can only happen if GL_EXT_draw_buffers2 is enabled */
-      return GL_TRUE;
-   }
-   if (ctx->Color._BlendFuncPerBuffer || ctx->Color._BlendEquationPerBuffer) {
-      /* this can only happen if GL_ARB_draw_buffers_blend is enabled */
-      return GL_TRUE;
-   }
-   return GL_FALSE;
-}
-
-static void 
-update_blend( struct st_context *st )
-{
-   struct pipe_blend_state *blend = &st->state.blend;
-   unsigned num_state = 1;
-   unsigned i, j;
-
-   memset(blend, 0, sizeof(*blend));
-
-   if (blend_per_rt(st->ctx) || colormask_per_rt(st->ctx)) {
-      num_state = st->ctx->Const.MaxDrawBuffers;
-      blend->independent_blend_enable = 1;
-   }
-   /* Note it is impossible to correctly deal with EXT_blend_logic_op and
-      EXT_draw_buffers2/EXT_blend_equation_separate at the same time.
-      These combinations would require support for per-rt logicop enables
-      and separate alpha/rgb logicop/blend support respectively. Neither
-      possible in gallium nor most hardware. Assume these combinations
-      don't happen. */
-   if (st->ctx->Color.ColorLogicOpEnabled ||
-       (st->ctx->Color.BlendEnabled &&
-        st->ctx->Color.Blend[0].EquationRGB == GL_LOGIC_OP)) {
-      /* logicop enabled */
-      blend->logicop_enable = 1;
-      blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp);
-   }
-   else if (st->ctx->Color.BlendEnabled) {
-      /* blending enabled */
-      for (i = 0, j = 0; i < num_state; i++) {
-
-         blend->rt[i].blend_enable = (st->ctx->Color.BlendEnabled >> i) & 0x1;
-
-         if (st->ctx->Extensions.ARB_draw_buffers_blend)
-            j = i;
-
-         blend->rt[i].rgb_func =
-            translate_blend(st->ctx->Color.Blend[j].EquationRGB);
-
-         if (st->ctx->Color.Blend[i].EquationRGB == GL_MIN ||
-             st->ctx->Color.Blend[i].EquationRGB == GL_MAX) {
-            /* Min/max are special */
-            blend->rt[i].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-            blend->rt[i].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
-         }
-         else {
-            blend->rt[i].rgb_src_factor =
-               translate_blend(st->ctx->Color.Blend[j].SrcRGB);
-            blend->rt[i].rgb_dst_factor =
-               translate_blend(st->ctx->Color.Blend[j].DstRGB);
-         }
-
-         blend->rt[i].alpha_func =
-            translate_blend(st->ctx->Color.Blend[j].EquationA);
-
-         if (st->ctx->Color.Blend[i].EquationA == GL_MIN ||
-             st->ctx->Color.Blend[i].EquationA == GL_MAX) {
-            /* Min/max are special */
-            blend->rt[i].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-            blend->rt[i].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
-         }
-         else {
-            blend->rt[i].alpha_src_factor =
-               translate_blend(st->ctx->Color.Blend[j].SrcA);
-            blend->rt[i].alpha_dst_factor =
-               translate_blend(st->ctx->Color.Blend[j].DstA);
-         }
-      }
-   }
-   else {
-      /* no blending / logicop */
-   }
-
-   /* Colormask - maybe reverse these bits? */
-   for (i = 0; i < num_state; i++) {
-      if (st->ctx->Color.ColorMask[i][0])
-         blend->rt[i].colormask |= PIPE_MASK_R;
-      if (st->ctx->Color.ColorMask[i][1])
-         blend->rt[i].colormask |= PIPE_MASK_G;
-      if (st->ctx->Color.ColorMask[i][2])
-         blend->rt[i].colormask |= PIPE_MASK_B;
-      if (st->ctx->Color.ColorMask[i][3])
-         blend->rt[i].colormask |= PIPE_MASK_A;
-   }
-
-   if (st->ctx->Color.DitherFlag)
-      blend->dither = 1;
-
-   if (st->ctx->Multisample.Enabled) {
-      /* unlike in gallium/d3d10 these operations are only performed
-         if msaa is enabled */
-      if (st->ctx->Multisample.SampleAlphaToCoverage)
-         blend->alpha_to_coverage = 1;
-      if (st->ctx->Multisample.SampleAlphaToOne)
-         blend->alpha_to_one = 1;
-   }
-
-   cso_set_blend(st->cso_context, blend);
-
-   {
-      struct pipe_blend_color bc;
-      COPY_4FV(bc.color, st->ctx->Color.BlendColor);
-      cso_set_blend_color(st->cso_context, &bc);
-   }
-}
-
-
-const struct st_tracked_state st_update_blend = {
-   "st_update_blend",					/* name */
-   {							/* dirty */
-      (_NEW_COLOR | _NEW_MULTISAMPLE),  /* XXX _NEW_BLEND someday? */	/* mesa */
-      0,						/* st */
-   },
-   update_blend,					/* update */
-};
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+ 

+

+#include "st_context.h"

+#include "st_atom.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "cso_cache/cso_context.h"

+

+#include "main/macros.h"

+

+/**

+ * Convert GLenum blend tokens to pipe tokens.

+ * Both blend factors and blend funcs are accepted.

+ */

+static GLuint

+translate_blend(GLenum blend)

+{

+   switch (blend) {

+   /* blend functions */

+   case GL_FUNC_ADD:

+      return PIPE_BLEND_ADD;

+   case GL_FUNC_SUBTRACT:

+      return PIPE_BLEND_SUBTRACT;

+   case GL_FUNC_REVERSE_SUBTRACT:

+      return PIPE_BLEND_REVERSE_SUBTRACT;

+   case GL_MIN:

+      return PIPE_BLEND_MIN;

+   case GL_MAX:

+      return PIPE_BLEND_MAX;

+

+   /* blend factors */

+   case GL_ONE:

+      return PIPE_BLENDFACTOR_ONE;

+   case GL_SRC_COLOR:

+      return PIPE_BLENDFACTOR_SRC_COLOR;

+   case GL_SRC_ALPHA:

+      return PIPE_BLENDFACTOR_SRC_ALPHA;

+   case GL_DST_ALPHA:

+      return PIPE_BLENDFACTOR_DST_ALPHA;

+   case GL_DST_COLOR:

+      return PIPE_BLENDFACTOR_DST_COLOR;

+   case GL_SRC_ALPHA_SATURATE:

+      return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;

+   case GL_CONSTANT_COLOR:

+      return PIPE_BLENDFACTOR_CONST_COLOR;

+   case GL_CONSTANT_ALPHA:

+      return PIPE_BLENDFACTOR_CONST_ALPHA;

+      /*

+      return PIPE_BLENDFACTOR_SRC1_COLOR;

+      return PIPE_BLENDFACTOR_SRC1_ALPHA;

+      */

+   case GL_ZERO:

+      return PIPE_BLENDFACTOR_ZERO;

+   case GL_ONE_MINUS_SRC_COLOR:

+      return PIPE_BLENDFACTOR_INV_SRC_COLOR;

+   case GL_ONE_MINUS_SRC_ALPHA:

+      return PIPE_BLENDFACTOR_INV_SRC_ALPHA;

+   case GL_ONE_MINUS_DST_COLOR:

+      return PIPE_BLENDFACTOR_INV_DST_COLOR;

+   case GL_ONE_MINUS_DST_ALPHA:

+      return PIPE_BLENDFACTOR_INV_DST_ALPHA;

+   case GL_ONE_MINUS_CONSTANT_COLOR:

+      return PIPE_BLENDFACTOR_INV_CONST_COLOR;

+   case GL_ONE_MINUS_CONSTANT_ALPHA:

+      return PIPE_BLENDFACTOR_INV_CONST_ALPHA;

+      /*

+      return PIPE_BLENDFACTOR_INV_SRC1_COLOR;

+      return PIPE_BLENDFACTOR_INV_SRC1_ALPHA;

+      */

+   default:

+      assert("invalid GL token in translate_blend()" == NULL);

+      return 0;

+   }

+}

+

+

+/**

+ * Convert GLenum logicop tokens to pipe tokens.

+ */

+static GLuint

+translate_logicop(GLenum logicop)

+{

+   switch (logicop) {

+   case GL_CLEAR:

+      return PIPE_LOGICOP_CLEAR;

+   case GL_NOR:

+      return PIPE_LOGICOP_NOR;

+   case GL_AND_INVERTED:

+      return PIPE_LOGICOP_AND_INVERTED;

+   case GL_COPY_INVERTED:

+      return PIPE_LOGICOP_COPY_INVERTED;

+   case GL_AND_REVERSE:

+      return PIPE_LOGICOP_AND_REVERSE;

+   case GL_INVERT:

+      return PIPE_LOGICOP_INVERT;

+   case GL_XOR:

+      return PIPE_LOGICOP_XOR;

+   case GL_NAND:

+      return PIPE_LOGICOP_NAND;

+   case GL_AND:

+      return PIPE_LOGICOP_AND;

+   case GL_EQUIV:

+      return PIPE_LOGICOP_EQUIV;

+   case GL_NOOP:

+      return PIPE_LOGICOP_NOOP;

+   case GL_OR_INVERTED:

+      return PIPE_LOGICOP_OR_INVERTED;

+   case GL_COPY:

+      return PIPE_LOGICOP_COPY;

+   case GL_OR_REVERSE:

+      return PIPE_LOGICOP_OR_REVERSE;

+   case GL_OR:

+      return PIPE_LOGICOP_OR;

+   case GL_SET:

+      return PIPE_LOGICOP_SET;

+   default:

+      assert("invalid GL token in translate_logicop()" == NULL);

+      return 0;

+   }

+}

+

+/**

+ * Figure out if colormasks are different per rt.

+ */

+static GLboolean

+colormask_per_rt(struct gl_context *ctx)

+{

+   /* a bit suboptimal have to compare lots of values */

+   unsigned i;

+   for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {

+      if (memcmp(ctx->Color.ColorMask[0], ctx->Color.ColorMask[i], 4)) {

+         return GL_TRUE;

+      }

+   }

+   return GL_FALSE;

+}

+

+/**

+ * Figure out if blend enables/state are different per rt.

+ */

+static GLboolean

+blend_per_rt(struct gl_context *ctx)

+{

+   if (ctx->Color.BlendEnabled &&

+      (ctx->Color.BlendEnabled != ((1 << ctx->Const.MaxDrawBuffers) - 1))) {

+      /* This can only happen if GL_EXT_draw_buffers2 is enabled */

+      return GL_TRUE;

+   }

+   if (ctx->Color._BlendFuncPerBuffer || ctx->Color._BlendEquationPerBuffer) {

+      /* this can only happen if GL_ARB_draw_buffers_blend is enabled */

+      return GL_TRUE;

+   }

+   return GL_FALSE;

+}

+

+static void 

+update_blend( struct st_context *st )

+{

+   struct pipe_blend_state *blend = &st->state.blend;

+   unsigned num_state = 1;

+   unsigned i, j;

+

+   memset(blend, 0, sizeof(*blend));

+

+   if (blend_per_rt(st->ctx) || colormask_per_rt(st->ctx)) {

+      num_state = st->ctx->Const.MaxDrawBuffers;

+      blend->independent_blend_enable = 1;

+   }

+   /* Note it is impossible to correctly deal with EXT_blend_logic_op and

+      EXT_draw_buffers2/EXT_blend_equation_separate at the same time.

+      These combinations would require support for per-rt logicop enables

+      and separate alpha/rgb logicop/blend support respectively. Neither

+      possible in gallium nor most hardware. Assume these combinations

+      don't happen. */

+   if (st->ctx->Color.ColorLogicOpEnabled ||

+       (st->ctx->Color.BlendEnabled &&

+        st->ctx->Color.Blend[0].EquationRGB == GL_LOGIC_OP)) {

+      /* logicop enabled */

+      blend->logicop_enable = 1;

+      blend->logicop_func = translate_logicop(st->ctx->Color.LogicOp);

+   }

+   else if (st->ctx->Color.BlendEnabled) {

+      /* blending enabled */

+      for (i = 0, j = 0; i < num_state; i++) {

+

+         blend->rt[i].blend_enable = (st->ctx->Color.BlendEnabled >> i) & 0x1;

+

+         if (st->ctx->Extensions.ARB_draw_buffers_blend)

+            j = i;

+

+         blend->rt[i].rgb_func =

+            translate_blend(st->ctx->Color.Blend[j].EquationRGB);

+

+         if (st->ctx->Color.Blend[i].EquationRGB == GL_MIN ||

+             st->ctx->Color.Blend[i].EquationRGB == GL_MAX) {

+            /* Min/max are special */

+            blend->rt[i].rgb_src_factor = PIPE_BLENDFACTOR_ONE;

+            blend->rt[i].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;

+         }

+         else {

+            blend->rt[i].rgb_src_factor =

+               translate_blend(st->ctx->Color.Blend[j].SrcRGB);

+            blend->rt[i].rgb_dst_factor =

+               translate_blend(st->ctx->Color.Blend[j].DstRGB);

+         }

+

+         blend->rt[i].alpha_func =

+            translate_blend(st->ctx->Color.Blend[j].EquationA);

+

+         if (st->ctx->Color.Blend[i].EquationA == GL_MIN ||

+             st->ctx->Color.Blend[i].EquationA == GL_MAX) {

+            /* Min/max are special */

+            blend->rt[i].alpha_src_factor = PIPE_BLENDFACTOR_ONE;

+            blend->rt[i].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;

+         }

+         else {

+            blend->rt[i].alpha_src_factor =

+               translate_blend(st->ctx->Color.Blend[j].SrcA);

+            blend->rt[i].alpha_dst_factor =

+               translate_blend(st->ctx->Color.Blend[j].DstA);

+         }

+      }

+   }

+   else {

+      /* no blending / logicop */

+   }

+

+   /* Colormask - maybe reverse these bits? */

+   for (i = 0; i < num_state; i++) {

+      if (st->ctx->Color.ColorMask[i][0])

+         blend->rt[i].colormask |= PIPE_MASK_R;

+      if (st->ctx->Color.ColorMask[i][1])

+         blend->rt[i].colormask |= PIPE_MASK_G;

+      if (st->ctx->Color.ColorMask[i][2])

+         blend->rt[i].colormask |= PIPE_MASK_B;

+      if (st->ctx->Color.ColorMask[i][3])

+         blend->rt[i].colormask |= PIPE_MASK_A;

+   }

+

+   if (st->ctx->Color.DitherFlag)

+      blend->dither = 1;

+

+   if (st->ctx->Multisample.Enabled) {

+      /* unlike in gallium/d3d10 these operations are only performed

+         if msaa is enabled */

+      if (st->ctx->Multisample.SampleAlphaToCoverage)

+         blend->alpha_to_coverage = 1;

+      if (st->ctx->Multisample.SampleAlphaToOne)

+         blend->alpha_to_one = 1;

+   }

+

+   cso_set_blend(st->cso_context, blend);

+

+   {

+      struct pipe_blend_color bc;

+      COPY_4FV(bc.color, st->ctx->Color.BlendColor);

+      cso_set_blend_color(st->cso_context, &bc);

+   }

+}

+

+

+const struct st_tracked_state st_update_blend = {

+   "st_update_blend",					/* name */

+   {							/* dirty */

+      (_NEW_COLOR | _NEW_MULTISAMPLE),  /* XXX _NEW_BLEND someday? */	/* mesa */

+      0,						/* st */

+   },

+   update_blend,					/* update */

+};

diff --git a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c
index 76386fe01..678a270c7 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c
@@ -1,182 +1,182 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
- 
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_fbo.h"
-#include "st_texture.h"
-#include "pipe/p_context.h"
-#include "cso_cache/cso_context.h"
-#include "util/u_math.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-
-
-/**
- * When doing GL render to texture, we have to be sure that finalize_texture()
- * didn't yank out the pipe_resource that we earlier created a surface for.
- * Check for that here and create a new surface if needed.
- */
-static void
-update_renderbuffer_surface(struct st_context *st,
-                            struct st_renderbuffer *strb)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_resource *resource = strb->rtt->pt;
-   int rtt_width = strb->Base.Width;
-   int rtt_height = strb->Base.Height;
-   enum pipe_format format = st->ctx->Color.sRGBEnabled ? resource->format : util_format_linear(resource->format);
-
-   if (!strb->surface ||
-       strb->surface->format != format ||
-       strb->surface->texture != resource ||
-       strb->surface->width != rtt_width ||
-       strb->surface->height != rtt_height) {
-      GLuint level;
-      /* find matching mipmap level size */
-      for (level = 0; level <= resource->last_level; level++) {
-         if (u_minify(resource->width0, level) == rtt_width &&
-             u_minify(resource->height0, level) == rtt_height) {
-            struct pipe_surface surf_tmpl;
-            memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-            surf_tmpl.format = format;
-            surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;
-            surf_tmpl.u.tex.level = level;
-            surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;
-            surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;
-
-            pipe_surface_reference(&strb->surface, NULL);
-
-            strb->surface = pipe->create_surface(pipe,
-                                                 resource,
-                                                 &surf_tmpl);
-#if 0
-            printf("-- alloc new surface %d x %d into tex %p\n",
-                   strb->surface->width, strb->surface->height,
-                   texture);
-#endif
-            break;
-         }
-      }
-   }
-}
-
-
-/**
- * Update framebuffer state (color, depth, stencil, etc. buffers)
- */
-static void
-update_framebuffer_state( struct st_context *st )
-{
-   struct pipe_framebuffer_state *framebuffer = &st->state.framebuffer;
-   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   struct st_renderbuffer *strb;
-   GLuint i;
-
-   framebuffer->width = fb->Width;
-   framebuffer->height = fb->Height;
-
-   /*printf("------ fb size %d x %d\n", fb->Width, fb->Height);*/
-
-   /* Examine Mesa's ctx->DrawBuffer->_ColorDrawBuffers state
-    * to determine which surfaces to draw to
-    */
-   framebuffer->nr_cbufs = 0;
-   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
-      strb = st_renderbuffer(fb->_ColorDrawBuffers[i]);
-
-      if (strb) {
-         /*printf("--------- framebuffer surface rtt %p\n", strb->rtt);*/
-         if (strb->rtt) {
-            /* rendering to a GL texture, may have to update surface */
-            update_renderbuffer_surface(st, strb);
-         }
-
-         if (strb->surface) {
-            pipe_surface_reference(&framebuffer->cbufs[framebuffer->nr_cbufs],
-                                   strb->surface);
-            framebuffer->nr_cbufs++;
-         }
-         strb->defined = GL_TRUE; /* we'll be drawing something */
-      }
-   }
-   for (i = framebuffer->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; i++) {
-      pipe_surface_reference(&framebuffer->cbufs[i], NULL);
-   }
-
-   /*
-    * Depth/Stencil renderbuffer/surface.
-    */
-   strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
-   if (strb) {
-      strb = st_renderbuffer(strb->Base.Wrapped);
-      if (strb->rtt) {
-         /* rendering to a GL texture, may have to update surface */
-         update_renderbuffer_surface(st, strb);
-      }
-      pipe_surface_reference(&framebuffer->zsbuf, strb->surface);
-   }
-   else {
-      strb = st_renderbuffer(fb->Attachment[BUFFER_STENCIL].Renderbuffer);
-      if (strb) {
-         strb = st_renderbuffer(strb->Base.Wrapped);
-         assert(strb->surface);
-         pipe_surface_reference(&framebuffer->zsbuf, strb->surface);
-      }
-      else
-         pipe_surface_reference(&framebuffer->zsbuf, NULL);
-   }
-
-#ifdef DEBUG
-   /* Make sure the resource binding flags were set properly */
-   for (i = 0; i < framebuffer->nr_cbufs; i++) {
-      assert(framebuffer->cbufs[i]->texture->bind & PIPE_BIND_RENDER_TARGET);
-   }
-   if (framebuffer->zsbuf) {
-      assert(framebuffer->zsbuf->texture->bind & PIPE_BIND_DEPTH_STENCIL);
-   }
-#endif
-
-   cso_set_framebuffer(st->cso_context, framebuffer);
-}
-
-
-const struct st_tracked_state st_update_framebuffer = {
-   "st_update_framebuffer",				/* name */
-   {							/* dirty */
-      _NEW_BUFFERS,					/* mesa */
-      ST_NEW_FRAMEBUFFER,				/* st */
-   },
-   update_framebuffer_state				/* update */
-};
-
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+ 

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_fbo.h"

+#include "st_texture.h"

+#include "pipe/p_context.h"

+#include "cso_cache/cso_context.h"

+#include "util/u_math.h"

+#include "util/u_inlines.h"

+#include "util/u_format.h"

+

+

+/**

+ * When doing GL render to texture, we have to be sure that finalize_texture()

+ * didn't yank out the pipe_resource that we earlier created a surface for.

+ * Check for that here and create a new surface if needed.

+ */

+static void

+update_renderbuffer_surface(struct st_context *st,

+                            struct st_renderbuffer *strb)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_resource *resource = strb->rtt->pt;

+   int rtt_width = strb->Base.Width;

+   int rtt_height = strb->Base.Height;

+   enum pipe_format format = st->ctx->Color.sRGBEnabled ? resource->format : util_format_linear(resource->format);

+

+   if (!strb->surface ||

+       strb->surface->format != format ||

+       strb->surface->texture != resource ||

+       strb->surface->width != rtt_width ||

+       strb->surface->height != rtt_height) {

+      GLuint level;

+      /* find matching mipmap level size */

+      for (level = 0; level <= resource->last_level; level++) {

+         if (u_minify(resource->width0, level) == rtt_width &&

+             u_minify(resource->height0, level) == rtt_height) {

+            struct pipe_surface surf_tmpl;

+            memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+            surf_tmpl.format = format;

+            surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;

+            surf_tmpl.u.tex.level = level;

+            surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;

+            surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;

+

+            pipe_surface_reference(&strb->surface, NULL);

+

+            strb->surface = pipe->create_surface(pipe,

+                                                 resource,

+                                                 &surf_tmpl);

+#if 0

+            printf("-- alloc new surface %d x %d into tex %p\n",

+                   strb->surface->width, strb->surface->height,

+                   texture);

+#endif

+            break;

+         }

+      }

+   }

+}

+

+

+/**

+ * Update framebuffer state (color, depth, stencil, etc. buffers)

+ */

+static void

+update_framebuffer_state( struct st_context *st )

+{

+   struct pipe_framebuffer_state *framebuffer = &st->state.framebuffer;

+   struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   struct st_renderbuffer *strb;

+   GLuint i;

+

+   framebuffer->width = fb->Width;

+   framebuffer->height = fb->Height;

+

+   /*printf("------ fb size %d x %d\n", fb->Width, fb->Height);*/

+

+   /* Examine Mesa's ctx->DrawBuffer->_ColorDrawBuffers state

+    * to determine which surfaces to draw to

+    */

+   framebuffer->nr_cbufs = 0;

+   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {

+      strb = st_renderbuffer(fb->_ColorDrawBuffers[i]);

+

+      if (strb) {

+         /*printf("--------- framebuffer surface rtt %p\n", strb->rtt);*/

+         if (strb->rtt) {

+            /* rendering to a GL texture, may have to update surface */

+            update_renderbuffer_surface(st, strb);

+         }

+

+         if (strb->surface) {

+            pipe_surface_reference(&framebuffer->cbufs[framebuffer->nr_cbufs],

+                                   strb->surface);

+            framebuffer->nr_cbufs++;

+         }

+         strb->defined = GL_TRUE; /* we'll be drawing something */

+      }

+   }

+   for (i = framebuffer->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; i++) {

+      pipe_surface_reference(&framebuffer->cbufs[i], NULL);

+   }

+

+   /*

+    * Depth/Stencil renderbuffer/surface.

+    */

+   strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);

+   if (strb) {

+      strb = st_renderbuffer(strb->Base.Wrapped);

+      if (strb->rtt) {

+         /* rendering to a GL texture, may have to update surface */

+         update_renderbuffer_surface(st, strb);

+      }

+      pipe_surface_reference(&framebuffer->zsbuf, strb->surface);

+   }

+   else {

+      strb = st_renderbuffer(fb->Attachment[BUFFER_STENCIL].Renderbuffer);

+      if (strb) {

+         strb = st_renderbuffer(strb->Base.Wrapped);

+         assert(strb->surface);

+         pipe_surface_reference(&framebuffer->zsbuf, strb->surface);

+      }

+      else

+         pipe_surface_reference(&framebuffer->zsbuf, NULL);

+   }

+

+#ifdef DEBUG

+   /* Make sure the resource binding flags were set properly */

+   for (i = 0; i < framebuffer->nr_cbufs; i++) {

+      assert(framebuffer->cbufs[i]->texture->bind & PIPE_BIND_RENDER_TARGET);

+   }

+   if (framebuffer->zsbuf) {

+      assert(framebuffer->zsbuf->texture->bind & PIPE_BIND_DEPTH_STENCIL);

+   }

+#endif

+

+   cso_set_framebuffer(st->cso_context, framebuffer);

+}

+

+

+const struct st_tracked_state st_update_framebuffer = {

+   "st_update_framebuffer",				/* name */

+   {							/* dirty */

+      _NEW_BUFFERS,					/* mesa */

+      ST_NEW_FRAMEBUFFER,				/* st */

+   },

+   update_framebuffer_state				/* update */

+};

+

diff --git a/mesalib/src/mesa/state_tracker/st_atom_sampler.c b/mesalib/src/mesa/state_tracker/st_atom_sampler.c
index 474cbd589..17596d4c8 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_sampler.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_sampler.c
@@ -1,228 +1,228 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
- 
-
-#include "main/macros.h"
-
-#include "st_context.h"
-#include "st_cb_texture.h"
-#include "st_format.h"
-#include "st_atom.h"
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-
-#include "cso_cache/cso_context.h"
-
-
-/**
- * Convert GLenum texcoord wrap tokens to pipe tokens.
- */
-static GLuint
-gl_wrap_xlate(GLenum wrap)
-{
-   switch (wrap) {
-   case GL_REPEAT:
-      return PIPE_TEX_WRAP_REPEAT;
-   case GL_CLAMP:
-      return PIPE_TEX_WRAP_CLAMP;
-   case GL_CLAMP_TO_EDGE:
-      return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   case GL_CLAMP_TO_BORDER:
-      return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
-   case GL_MIRRORED_REPEAT:
-      return PIPE_TEX_WRAP_MIRROR_REPEAT;
-   case GL_MIRROR_CLAMP_EXT:
-      return PIPE_TEX_WRAP_MIRROR_CLAMP;
-   case GL_MIRROR_CLAMP_TO_EDGE_EXT:
-      return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
-   case GL_MIRROR_CLAMP_TO_BORDER_EXT:
-      return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
-   default:
-      assert(0);
-      return 0;
-   }
-}
-
-
-static GLuint
-gl_filter_to_mip_filter(GLenum filter)
-{
-   switch (filter) {
-   case GL_NEAREST:
-   case GL_LINEAR:
-      return PIPE_TEX_MIPFILTER_NONE;
-
-   case GL_NEAREST_MIPMAP_NEAREST:
-   case GL_LINEAR_MIPMAP_NEAREST:
-      return PIPE_TEX_MIPFILTER_NEAREST;
-
-   case GL_NEAREST_MIPMAP_LINEAR:
-   case GL_LINEAR_MIPMAP_LINEAR:
-      return PIPE_TEX_MIPFILTER_LINEAR;
-
-   default:
-      assert(0);
-      return PIPE_TEX_MIPFILTER_NONE;
-   }
-}
-
-
-static GLuint
-gl_filter_to_img_filter(GLenum filter)
-{
-   switch (filter) {
-   case GL_NEAREST:
-   case GL_NEAREST_MIPMAP_NEAREST:
-   case GL_NEAREST_MIPMAP_LINEAR:
-      return PIPE_TEX_FILTER_NEAREST;
-
-   case GL_LINEAR:
-   case GL_LINEAR_MIPMAP_NEAREST:
-   case GL_LINEAR_MIPMAP_LINEAR:
-      return PIPE_TEX_FILTER_LINEAR;
-
-   default:
-      assert(0);
-      return PIPE_TEX_FILTER_NEAREST;
-   }
-}
-
-
-static void 
-update_samplers(struct st_context *st)
-{
-   struct gl_vertex_program *vprog = st->ctx->VertexProgram._Current;
-   struct gl_fragment_program *fprog = st->ctx->FragmentProgram._Current;
-   const GLbitfield samplersUsed = (vprog->Base.SamplersUsed |
-                                    fprog->Base.SamplersUsed);
-   GLuint su;
-
-   st->state.num_samplers = 0;
-
-   /* loop over sampler units (aka tex image units) */
-   for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) {
-      struct pipe_sampler_state *sampler = st->state.samplers + su;
-
-      memset(sampler, 0, sizeof(*sampler));
-
-      if (samplersUsed & (1 << su)) {
-         struct gl_texture_object *texobj;
-         struct gl_texture_image *teximg;
-         GLuint texUnit;
-
-         if (fprog->Base.SamplersUsed & (1 << su))
-            texUnit = fprog->Base.SamplerUnits[su];
-         else
-            texUnit = vprog->Base.SamplerUnits[su];
-
-         texobj = st->ctx->Texture.Unit[texUnit]._Current;
-         if (!texobj) {
-            texobj = st_get_default_texture(st);
-         }
-
-         teximg = texobj->Image[0][texobj->BaseLevel];
-
-         sampler->wrap_s = gl_wrap_xlate(texobj->WrapS);
-         sampler->wrap_t = gl_wrap_xlate(texobj->WrapT);
-         sampler->wrap_r = gl_wrap_xlate(texobj->WrapR);
-
-         sampler->min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
-         sampler->min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
-         sampler->mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
-
-         if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB)
-            sampler->normalized_coords = 1;
-
-         sampler->lod_bias = st->ctx->Texture.Unit[su].LodBias;
-
-         sampler->min_lod = texobj->BaseLevel + texobj->MinLod;
-         if (sampler->min_lod < texobj->BaseLevel)
-            sampler->min_lod = texobj->BaseLevel;
-
-         sampler->max_lod = MIN2((GLfloat) texobj->MaxLevel,
-                                 (texobj->MaxLod + texobj->BaseLevel));
-         if (sampler->max_lod < sampler->min_lod) {
-            /* The GL spec doesn't seem to specify what to do in this case.
-             * Swap the values.
-             */
-            float tmp = sampler->max_lod;
-            sampler->max_lod = sampler->min_lod;
-            sampler->min_lod = tmp;
-            assert(sampler->min_lod <= sampler->max_lod);
-         }
-
-         st_translate_color(texobj->BorderColor.f,
-                            teximg ? teximg->_BaseFormat : GL_RGBA,
-                            sampler->border_color);
-
-	 sampler->max_anisotropy = (texobj->MaxAnisotropy == 1.0 ? 0 : (GLuint)texobj->MaxAnisotropy);
-
-         /* only care about ARB_shadow, not SGI shadow */
-         if (texobj->CompareMode == GL_COMPARE_R_TO_TEXTURE) {
-            sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
-            sampler->compare_func
-               = st_compare_func_to_pipe(texobj->CompareFunc);
-         }
-
-         st->state.num_samplers = su + 1;
-
-         /*printf("%s su=%u non-null\n", __FUNCTION__, su);*/
-         cso_single_sampler(st->cso_context, su, sampler);
-         if (su < st->ctx->Const.MaxVertexTextureImageUnits) {
-            cso_single_vertex_sampler(st->cso_context, su, sampler);
-         }
-      }
-      else {
-         /*printf("%s su=%u null\n", __FUNCTION__, su);*/
-         cso_single_sampler(st->cso_context, su, NULL);
-         if (su < st->ctx->Const.MaxVertexTextureImageUnits) {
-            cso_single_vertex_sampler(st->cso_context, su, NULL);
-         }
-      }
-   }
-
-   cso_single_sampler_done(st->cso_context);
-   if (st->ctx->Const.MaxVertexTextureImageUnits > 0) {
-      cso_single_vertex_sampler_done(st->cso_context);
-   }
-}
-
-
-const struct st_tracked_state st_update_sampler = {
-   "st_update_sampler",					/* name */
-   {							/* dirty */
-      _NEW_TEXTURE,					/* mesa */
-      0,						/* st */
-   },
-   update_samplers					/* update */
-};
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+ 

+

+#include "main/macros.h"

+

+#include "st_context.h"

+#include "st_cb_texture.h"

+#include "st_format.h"

+#include "st_atom.h"

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+

+#include "cso_cache/cso_context.h"

+

+

+/**

+ * Convert GLenum texcoord wrap tokens to pipe tokens.

+ */

+static GLuint

+gl_wrap_xlate(GLenum wrap)

+{

+   switch (wrap) {

+   case GL_REPEAT:

+      return PIPE_TEX_WRAP_REPEAT;

+   case GL_CLAMP:

+      return PIPE_TEX_WRAP_CLAMP;

+   case GL_CLAMP_TO_EDGE:

+      return PIPE_TEX_WRAP_CLAMP_TO_EDGE;

+   case GL_CLAMP_TO_BORDER:

+      return PIPE_TEX_WRAP_CLAMP_TO_BORDER;

+   case GL_MIRRORED_REPEAT:

+      return PIPE_TEX_WRAP_MIRROR_REPEAT;

+   case GL_MIRROR_CLAMP_EXT:

+      return PIPE_TEX_WRAP_MIRROR_CLAMP;

+   case GL_MIRROR_CLAMP_TO_EDGE_EXT:

+      return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;

+   case GL_MIRROR_CLAMP_TO_BORDER_EXT:

+      return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;

+   default:

+      assert(0);

+      return 0;

+   }

+}

+

+

+static GLuint

+gl_filter_to_mip_filter(GLenum filter)

+{

+   switch (filter) {

+   case GL_NEAREST:

+   case GL_LINEAR:

+      return PIPE_TEX_MIPFILTER_NONE;

+

+   case GL_NEAREST_MIPMAP_NEAREST:

+   case GL_LINEAR_MIPMAP_NEAREST:

+      return PIPE_TEX_MIPFILTER_NEAREST;

+

+   case GL_NEAREST_MIPMAP_LINEAR:

+   case GL_LINEAR_MIPMAP_LINEAR:

+      return PIPE_TEX_MIPFILTER_LINEAR;

+

+   default:

+      assert(0);

+      return PIPE_TEX_MIPFILTER_NONE;

+   }

+}

+

+

+static GLuint

+gl_filter_to_img_filter(GLenum filter)

+{

+   switch (filter) {

+   case GL_NEAREST:

+   case GL_NEAREST_MIPMAP_NEAREST:

+   case GL_NEAREST_MIPMAP_LINEAR:

+      return PIPE_TEX_FILTER_NEAREST;

+

+   case GL_LINEAR:

+   case GL_LINEAR_MIPMAP_NEAREST:

+   case GL_LINEAR_MIPMAP_LINEAR:

+      return PIPE_TEX_FILTER_LINEAR;

+

+   default:

+      assert(0);

+      return PIPE_TEX_FILTER_NEAREST;

+   }

+}

+

+

+static void 

+update_samplers(struct st_context *st)

+{

+   struct gl_vertex_program *vprog = st->ctx->VertexProgram._Current;

+   struct gl_fragment_program *fprog = st->ctx->FragmentProgram._Current;

+   const GLbitfield samplersUsed = (vprog->Base.SamplersUsed |

+                                    fprog->Base.SamplersUsed);

+   GLuint su;

+

+   st->state.num_samplers = 0;

+

+   /* loop over sampler units (aka tex image units) */

+   for (su = 0; su < st->ctx->Const.MaxTextureImageUnits; su++) {

+      struct pipe_sampler_state *sampler = st->state.samplers + su;

+

+      memset(sampler, 0, sizeof(*sampler));

+

+      if (samplersUsed & (1 << su)) {

+         struct gl_texture_object *texobj;

+         struct gl_texture_image *teximg;

+         GLuint texUnit;

+

+         if (fprog->Base.SamplersUsed & (1 << su))

+            texUnit = fprog->Base.SamplerUnits[su];

+         else

+            texUnit = vprog->Base.SamplerUnits[su];

+

+         texobj = st->ctx->Texture.Unit[texUnit]._Current;

+         if (!texobj) {

+            texobj = st_get_default_texture(st);

+         }

+

+         teximg = texobj->Image[0][texobj->BaseLevel];

+

+         sampler->wrap_s = gl_wrap_xlate(texobj->WrapS);

+         sampler->wrap_t = gl_wrap_xlate(texobj->WrapT);

+         sampler->wrap_r = gl_wrap_xlate(texobj->WrapR);

+

+         sampler->min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);

+         sampler->min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);

+         sampler->mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);

+

+         if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB)

+            sampler->normalized_coords = 1;

+

+         sampler->lod_bias = st->ctx->Texture.Unit[su].LodBias;

+

+         sampler->min_lod = texobj->BaseLevel + texobj->MinLod;

+         if (sampler->min_lod < texobj->BaseLevel)

+            sampler->min_lod = texobj->BaseLevel;

+

+         sampler->max_lod = MIN2((GLfloat) texobj->MaxLevel,

+                                 (texobj->MaxLod + texobj->BaseLevel));

+         if (sampler->max_lod < sampler->min_lod) {

+            /* The GL spec doesn't seem to specify what to do in this case.

+             * Swap the values.

+             */

+            float tmp = sampler->max_lod;

+            sampler->max_lod = sampler->min_lod;

+            sampler->min_lod = tmp;

+            assert(sampler->min_lod <= sampler->max_lod);

+         }

+

+         st_translate_color(texobj->BorderColor.f,

+                            teximg ? teximg->_BaseFormat : GL_RGBA,

+                            sampler->border_color);

+

+	 sampler->max_anisotropy = (texobj->MaxAnisotropy == 1.0 ? 0 : (GLuint)texobj->MaxAnisotropy);

+

+         /* only care about ARB_shadow, not SGI shadow */

+         if (texobj->CompareMode == GL_COMPARE_R_TO_TEXTURE) {

+            sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;

+            sampler->compare_func

+               = st_compare_func_to_pipe(texobj->CompareFunc);

+         }

+

+         st->state.num_samplers = su + 1;

+

+         /*printf("%s su=%u non-null\n", __FUNCTION__, su);*/

+         cso_single_sampler(st->cso_context, su, sampler);

+         if (su < st->ctx->Const.MaxVertexTextureImageUnits) {

+            cso_single_vertex_sampler(st->cso_context, su, sampler);

+         }

+      }

+      else {

+         /*printf("%s su=%u null\n", __FUNCTION__, su);*/

+         cso_single_sampler(st->cso_context, su, NULL);

+         if (su < st->ctx->Const.MaxVertexTextureImageUnits) {

+            cso_single_vertex_sampler(st->cso_context, su, NULL);

+         }

+      }

+   }

+

+   cso_single_sampler_done(st->cso_context);

+   if (st->ctx->Const.MaxVertexTextureImageUnits > 0) {

+      cso_single_vertex_sampler_done(st->cso_context);

+   }

+}

+

+

+const struct st_tracked_state st_update_sampler = {

+   "st_update_sampler",					/* name */

+   {							/* dirty */

+      _NEW_TEXTURE,					/* mesa */

+      0,						/* st */

+   },

+   update_samplers					/* update */

+};

diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
index 149f1ca44..d602c0b41 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
@@ -1,894 +1,894 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Brian Paul
-  */
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/bufferobj.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/pbo.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_atom_constbuf.h"
-#include "st_program.h"
-#include "st_cb_bitmap.h"
-#include "st_texture.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-#include "util/u_inlines.h"
-#include "util/u_draw_quad.h"
-#include "util/u_simple_shaders.h"
-#include "program/prog_instruction.h"
-#include "cso_cache/cso_context.h"
-
-
-#if FEATURE_drawpix
-
-/**
- * glBitmaps are drawn as textured quads.  The user's bitmap pattern
- * is stored in a texture image.  An alpha8 texture format is used.
- * The fragment shader samples a bit (texel) from the texture, then
- * discards the fragment if the bit is off.
- *
- * Note that we actually store the inverse image of the bitmap to
- * simplify the fragment program.  An "on" bit gets stored as texel=0x0
- * and an "off" bit is stored as texel=0xff.  Then we kill the
- * fragment if the negated texel value is less than zero.
- */
-
-
-/**
- * The bitmap cache attempts to accumulate multiple glBitmap calls in a
- * buffer which is then rendered en mass upon a flush, state change, etc.
- * A wide, short buffer is used to target the common case of a series
- * of glBitmap calls being used to draw text.
- */
-static GLboolean UseBitmapCache = GL_TRUE;
-
-
-#define BITMAP_CACHE_WIDTH  512
-#define BITMAP_CACHE_HEIGHT 32
-
-struct bitmap_cache
-{
-   /** Window pos to render the cached image */
-   GLint xpos, ypos;
-   /** Bounds of region used in window coords */
-   GLint xmin, ymin, xmax, ymax;
-
-   GLfloat color[4];
-
-   /** Bitmap's Z position */
-   GLfloat zpos;
-
-   struct pipe_resource *texture;
-   struct pipe_transfer *trans;
-
-   GLboolean empty;
-
-   /** An I8 texture image: */
-   ubyte *buffer;
-};
-
-
-/** Epsilon for Z comparisons */
-#define Z_EPSILON 1e-06
-
-
-/**
- * Make fragment program for glBitmap:
- *   Sample the texture and kill the fragment if the bit is 0.
- * This program will be combined with the user's fragment program.
- */
-static struct st_fragment_program *
-make_bitmap_fragment_program(struct gl_context *ctx, GLuint samplerIndex)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_fragment_program *stfp;
-   struct gl_program *p;
-   GLuint ic = 0;
-
-   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = 3;
-
-   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, p->NumInstructions);
-
-   /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */
-   p->Instructions[ic].Opcode = OPCODE_TEX;
-   p->Instructions[ic].DstReg.File = PROGRAM_TEMPORARY;
-   p->Instructions[ic].DstReg.Index = 0;
-   p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-   p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-   p->Instructions[ic].TexSrcUnit = samplerIndex;
-   p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-   ic++;
-
-   /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */
-   p->Instructions[ic].Opcode = OPCODE_KIL;
-   p->Instructions[ic].SrcReg[0].File = PROGRAM_TEMPORARY;
-
-   if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM)
-      p->Instructions[ic].SrcReg[0].Swizzle = SWIZZLE_XXXX;
-
-   p->Instructions[ic].SrcReg[0].Index = 0;
-   p->Instructions[ic].SrcReg[0].Negate = NEGATE_XYZW;
-   ic++;
-
-   /* END; */
-   p->Instructions[ic++].Opcode = OPCODE_END;
-
-   assert(ic == p->NumInstructions);
-
-   p->InputsRead = FRAG_BIT_TEX0;
-   p->OutputsWritten = 0x0;
-   p->SamplersUsed = (1 << samplerIndex);
-
-   stfp = (struct st_fragment_program *) p;
-   stfp->Base.UsesKill = GL_TRUE;
-
-   return stfp;
-}
-
-
-static int
-find_free_bit(uint bitfield)
-{
-   int i;
-   for (i = 0; i < 32; i++) {
-      if ((bitfield & (1 << i)) == 0) {
-         return i;
-      }
-   }
-   return -1;
-}
-
-
-/**
- * Combine basic bitmap fragment program with the user-defined program.
- * \param st  current context
- * \param fpIn  the incoming fragment program
- * \param fpOut  the new fragment program which does fragment culling
- * \param bitmap_sampler  sampler number for the bitmap texture
- */
-void
-st_make_bitmap_fragment_program(struct st_context *st,
-                                struct gl_fragment_program *fpIn,
-                                struct gl_fragment_program **fpOut,
-                                GLuint *bitmap_sampler)
-{
-   struct st_fragment_program *bitmap_prog;
-   struct gl_program *newProg;
-   uint sampler;
-
-   /*
-    * Generate new program which is the user-defined program prefixed
-    * with the bitmap sampler/kill instructions.
-    */
-   sampler = find_free_bit(fpIn->Base.SamplersUsed);
-   bitmap_prog = make_bitmap_fragment_program(st->ctx, sampler);
-
-   newProg = _mesa_combine_programs(st->ctx,
-                                    &bitmap_prog->Base.Base,
-                                    &fpIn->Base);
-   /* done with this after combining */
-   st_reference_fragprog(st, &bitmap_prog, NULL);
-
-#if 0
-   {
-      printf("Combined bitmap program:\n");
-      _mesa_print_program(newProg);
-      printf("InputsRead: 0x%x\n", newProg->InputsRead);
-      printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);
-      _mesa_print_parameter_list(newProg->Parameters);
-   }
-#endif
-
-   /* return results */
-   *fpOut = (struct gl_fragment_program *) newProg;
-   *bitmap_sampler = sampler;
-}
-
-
-/**
- * Copy user-provide bitmap bits into texture buffer, expanding
- * bits into texels.
- * "On" bits will set texels to 0x0.
- * "Off" bits will not modify texels.
- * Note that the image is actually going to be upside down in
- * the texture.  We deal with that with texcoords.
- */
-static void
-unpack_bitmap(struct st_context *st,
-              GLint px, GLint py, GLsizei width, GLsizei height,
-              const struct gl_pixelstore_attrib *unpack,
-              const GLubyte *bitmap,
-              ubyte *destBuffer, uint destStride)
-{
-   destBuffer += py * destStride + px;
-
-   _mesa_expand_bitmap(width, height, unpack, bitmap,
-                       destBuffer, destStride, 0x0);
-}
-
-
-/**
- * Create a texture which represents a bitmap image.
- */
-static struct pipe_resource *
-make_bitmap_texture(struct gl_context *ctx, GLsizei width, GLsizei height,
-                    const struct gl_pixelstore_attrib *unpack,
-                    const GLubyte *bitmap)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_transfer *transfer;
-   ubyte *dest;
-   struct pipe_resource *pt;
-
-   /* PBO source... */
-   bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap);
-   if (!bitmap) {
-      return NULL;
-   }
-
-   /**
-    * Create texture to hold bitmap pattern.
-    */
-   pt = st_texture_create(st, st->internal_target, st->bitmap.tex_format,
-                          0, width, height, 1, 1,
-                          PIPE_BIND_SAMPLER_VIEW);
-   if (!pt) {
-      _mesa_unmap_pbo_source(ctx, unpack);
-      return NULL;
-   }
-
-   transfer = pipe_get_transfer(st->pipe, pt, 0, 0,
-                                PIPE_TRANSFER_WRITE,
-                                0, 0, width, height);
-
-   dest = pipe_transfer_map(pipe, transfer);
-
-   /* Put image into texture transfer */
-   memset(dest, 0xff, height * transfer->stride);
-   unpack_bitmap(st, 0, 0, width, height, unpack, bitmap,
-                 dest, transfer->stride);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-
-   /* Release transfer */
-   pipe_transfer_unmap(pipe, transfer);
-   pipe->transfer_destroy(pipe, transfer);
-
-   return pt;
-}
-
-static GLuint
-setup_bitmap_vertex_data(struct st_context *st, bool normalized,
-                         int x, int y, int width, int height,
-                         float z, const float color[4])
-{
-   struct pipe_context *pipe = st->pipe;
-   const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   const GLfloat fb_width = (GLfloat)fb->Width;
-   const GLfloat fb_height = (GLfloat)fb->Height;
-   const GLfloat x0 = (GLfloat)x;
-   const GLfloat x1 = (GLfloat)(x + width);
-   const GLfloat y0 = (GLfloat)y;
-   const GLfloat y1 = (GLfloat)(y + height);
-   GLfloat sLeft = (GLfloat)0.0, sRight = (GLfloat)1.0;
-   GLfloat tTop = (GLfloat)0.0, tBot = (GLfloat)1.0 - tTop;
-   const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);
-   const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);
-   const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);
-   const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);
-   const GLuint max_slots = 1; /* 4096 / sizeof(st->bitmap.vertices); */
-   GLuint i;
-
-   if(!normalized)
-   {
-      sRight = width;
-      tBot = height;
-   }
-
-   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as
-    * no_flush) updates to buffers where we know there is no conflict
-    * with previous data.  Currently using max_slots > 1 will cause
-    * synchronous rendering if the driver flushes its command buffers
-    * between one bitmap and the next.  Our flush hook below isn't
-    * sufficient to catch this as the driver doesn't tell us when it
-    * flushes its own command buffers.  Until this gets fixed, pay the
-    * price of allocating a new buffer for each bitmap cache-flush to
-    * avoid synchronous rendering.
-    */
-   if (st->bitmap.vbuf_slot >= max_slots) {
-      pipe_resource_reference(&st->bitmap.vbuf, NULL);
-      st->bitmap.vbuf_slot = 0;
-   }
-
-   if (!st->bitmap.vbuf) {
-      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 
-                                           PIPE_BIND_VERTEX_BUFFER,
-                                           PIPE_USAGE_STREAM,
-                                           max_slots *
-                                           sizeof(st->bitmap.vertices));
-   }
-
-   /* Positions are in clip coords since we need to do clipping in case
-    * the bitmap quad goes beyond the window bounds.
-    */
-   st->bitmap.vertices[0][0][0] = clip_x0;
-   st->bitmap.vertices[0][0][1] = clip_y0;
-   st->bitmap.vertices[0][2][0] = sLeft;
-   st->bitmap.vertices[0][2][1] = tTop;
-
-   st->bitmap.vertices[1][0][0] = clip_x1;
-   st->bitmap.vertices[1][0][1] = clip_y0;
-   st->bitmap.vertices[1][2][0] = sRight;
-   st->bitmap.vertices[1][2][1] = tTop;
-   
-   st->bitmap.vertices[2][0][0] = clip_x1;
-   st->bitmap.vertices[2][0][1] = clip_y1;
-   st->bitmap.vertices[2][2][0] = sRight;
-   st->bitmap.vertices[2][2][1] = tBot;
-   
-   st->bitmap.vertices[3][0][0] = clip_x0;
-   st->bitmap.vertices[3][0][1] = clip_y1;
-   st->bitmap.vertices[3][2][0] = sLeft;
-   st->bitmap.vertices[3][2][1] = tBot;
-   
-   /* same for all verts: */
-   for (i = 0; i < 4; i++) {
-      st->bitmap.vertices[i][0][2] = z;
-      st->bitmap.vertices[i][0][3] = 1.0;
-      st->bitmap.vertices[i][1][0] = color[0];
-      st->bitmap.vertices[i][1][1] = color[1];
-      st->bitmap.vertices[i][1][2] = color[2];
-      st->bitmap.vertices[i][1][3] = color[3];
-      st->bitmap.vertices[i][2][2] = 0.0; /*R*/
-      st->bitmap.vertices[i][2][3] = 1.0; /*Q*/
-   }
-
-   /* put vertex data into vbuf */
-   pipe_buffer_write_nooverlap(st->pipe,
-                               st->bitmap.vbuf,
-                               st->bitmap.vbuf_slot
-                               * sizeof(st->bitmap.vertices),
-                               sizeof st->bitmap.vertices,
-                               st->bitmap.vertices);
-
-   return st->bitmap.vbuf_slot++ * sizeof st->bitmap.vertices;
-}
-
-
-
-/**
- * Render a glBitmap by drawing a textured quad
- */
-static void
-draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
-                 GLsizei width, GLsizei height,
-                 struct pipe_sampler_view *sv,
-                 const GLfloat *color)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = st->cso_context;
-   struct st_fp_variant *fpv;
-   struct st_fp_variant_key key;
-   GLuint maxSize;
-   GLuint offset;
-
-   memset(&key, 0, sizeof(key));
-   key.st = st;
-   key.bitmap = GL_TRUE;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   /* As an optimization, Mesa's fragment programs will sometimes get the
-    * primary color from a statevar/constant rather than a varying variable.
-    * when that's the case, we need to ensure that we use the 'color'
-    * parameter and not the current attribute color (which may have changed
-    * through glRasterPos and state validation.
-    * So, we force the proper color here.  Not elegant, but it works.
-    */
-   {
-      GLfloat colorSave[4];
-      COPY_4V(colorSave, ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
-      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color);
-      st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], colorSave);
-   }
-
-
-   /* limit checks */
-   /* XXX if the bitmap is larger than the max texture size, break
-    * it up into chunks.
-    */
-   maxSize = 1 << (pipe->screen->get_param(pipe->screen,
-                                    PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
-   assert(width <= (GLsizei)maxSize);
-   assert(height <= (GLsizei)maxSize);
-
-   cso_save_rasterizer(cso);
-   cso_save_samplers(cso);
-   cso_save_fragment_sampler_views(cso);
-   cso_save_viewport(cso);
-   cso_save_fragment_shader(cso);
-   cso_save_vertex_shader(cso);
-   cso_save_vertex_elements(cso);
-   cso_save_vertex_buffers(cso);
-
-   /* rasterizer state: just scissor */
-   st->bitmap.rasterizer.scissor = ctx->Scissor.Enabled;
-   cso_set_rasterizer(cso, &st->bitmap.rasterizer);
-
-   /* fragment shader state: TEX lookup program */
-   cso_set_fragment_shader_handle(cso, fpv->driver_shader);
-
-   /* vertex shader state: position + texcoord pass-through */
-   cso_set_vertex_shader_handle(cso, st->bitmap.vs);
-
-   /* user samplers, plus our bitmap sampler */
-   {
-      struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
-      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_samplers);
-      uint i;
-      for (i = 0; i < st->state.num_samplers; i++) {
-         samplers[i] = &st->state.samplers[i];
-      }
-      samplers[fpv->bitmap_sampler] =
-         &st->bitmap.samplers[sv->texture->target != PIPE_TEXTURE_RECT];
-      cso_set_samplers(cso, num, (const struct pipe_sampler_state **) samplers);
-   }
-
-   /* user textures, plus the bitmap texture */
-   {
-      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
-      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_textures);
-      memcpy(sampler_views, st->state.sampler_views, sizeof(sampler_views));
-      sampler_views[fpv->bitmap_sampler] = sv;
-      cso_set_fragment_sampler_views(cso, num, sampler_views);
-   }
-
-   /* viewport state: viewport matching window dims */
-   {
-      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);
-      const GLfloat width = (GLfloat)fb->Width;
-      const GLfloat height = (GLfloat)fb->Height;
-      struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5f * width;
-      vp.scale[1] = height * (invert ? -0.5f : 0.5f);
-      vp.scale[2] = 0.5f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * width;
-      vp.translate[1] = 0.5f * height;
-      vp.translate[2] = 0.5f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(cso, &vp);
-   }
-
-   cso_set_vertex_elements(cso, 3, st->velems_util_draw);
-
-   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */
-   z = z * 2.0 - 1.0;
-
-   /* draw textured quad */
-   offset = setup_bitmap_vertex_data(st,
-                                     sv->texture->target != PIPE_TEXTURE_RECT,
-                                     x, y, width, height, z, color);
-
-   util_draw_vertex_buffer(pipe, st->cso_context, st->bitmap.vbuf, offset,
-                           PIPE_PRIM_TRIANGLE_FAN,
-                           4,  /* verts */
-                           3); /* attribs/vert */
-
-
-   /* restore state */
-   cso_restore_rasterizer(cso);
-   cso_restore_samplers(cso);
-   cso_restore_fragment_sampler_views(cso);
-   cso_restore_viewport(cso);
-   cso_restore_fragment_shader(cso);
-   cso_restore_vertex_shader(cso);
-   cso_restore_vertex_elements(cso);
-   cso_restore_vertex_buffers(cso);
-}
-
-
-static void
-reset_cache(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   /*memset(cache->buffer, 0xff, sizeof(cache->buffer));*/
-   cache->empty = GL_TRUE;
-
-   cache->xmin = 1000000;
-   cache->xmax = -1000000;
-   cache->ymin = 1000000;
-   cache->ymax = -1000000;
-
-   if (cache->trans) {
-      pipe->transfer_destroy(pipe, cache->trans);
-      cache->trans = NULL;
-   }
-
-   assert(!cache->texture);
-
-   /* allocate a new texture */
-   cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,
-                                      st->bitmap.tex_format, 0,
-                                      BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
-                                      1, 1,
-				      PIPE_BIND_SAMPLER_VIEW);
-}
-
-
-/** Print bitmap image to stdout (debug) */
-static void
-print_cache(const struct bitmap_cache *cache)
-{
-   int i, j, k;
-
-   for (i = 0; i < BITMAP_CACHE_HEIGHT; i++) {
-      k = BITMAP_CACHE_WIDTH * (BITMAP_CACHE_HEIGHT - i - 1);
-      for (j = 0; j < BITMAP_CACHE_WIDTH; j++) {
-         if (cache->buffer[k])
-            printf("X");
-         else
-            printf(" ");
-         k++;
-      }
-      printf("\n");
-   }
-}
-
-
-/**
- * Create gallium pipe_transfer object for the bitmap cache.
- */
-static void
-create_cache_trans(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   if (cache->trans)
-      return;
-
-   /* Map the texture transfer.
-    * Subsequent glBitmap calls will write into the texture image.
-    */
-   cache->trans = pipe_get_transfer(st->pipe, cache->texture, 0, 0,
-                                    PIPE_TRANSFER_WRITE, 0, 0,
-                                    BITMAP_CACHE_WIDTH,
-                                    BITMAP_CACHE_HEIGHT);
-   cache->buffer = pipe_transfer_map(pipe, cache->trans);
-
-   /* init image to all 0xff */
-   memset(cache->buffer, 0xff, cache->trans->stride * BITMAP_CACHE_HEIGHT);
-}
-
-
-/**
- * If there's anything in the bitmap cache, draw/flush it now.
- */
-void
-st_flush_bitmap_cache(struct st_context *st)
-{
-   if (!st->bitmap.cache->empty) {
-      struct bitmap_cache *cache = st->bitmap.cache;
-
-      if (st->ctx->DrawBuffer) {
-         struct pipe_context *pipe = st->pipe;
-         struct pipe_sampler_view *sv;
-
-         assert(cache->xmin <= cache->xmax);
- 
-/*         printf("flush size %d x %d  at %d, %d\n",
-                cache->xmax - cache->xmin,
-                cache->ymax - cache->ymin,
-                cache->xpos, cache->ypos);
-*/
-
-         /* The texture transfer has been mapped until now.
-          * So unmap and release the texture transfer before drawing.
-          */
-         if (cache->trans) {
-            if (0)
-               print_cache(cache);
-            pipe_transfer_unmap(pipe, cache->trans);
-            cache->buffer = NULL;
-
-            pipe->transfer_destroy(pipe, cache->trans);
-            cache->trans = NULL;
-         }
-
-         sv = st_create_texture_sampler_view(st->pipe, cache->texture);
-         if (sv) {
-            draw_bitmap_quad(st->ctx,
-                             cache->xpos,
-                             cache->ypos,
-                             cache->zpos,
-                             BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
-                             sv,
-                             cache->color);
-
-            pipe_sampler_view_reference(&sv, NULL);
-         }
-      }
-
-      /* release/free the texture */
-      pipe_resource_reference(&cache->texture, NULL);
-
-      reset_cache(st);
-   }
-}
-
-
-/**
- * Flush bitmap cache and release vertex buffer.
- */
-void
-st_flush_bitmap( struct st_context *st )
-{
-   st_flush_bitmap_cache(st);
-
-   /* Release vertex buffer to avoid synchronous rendering if we were
-    * to map it in the next frame.
-    */
-   pipe_resource_reference(&st->bitmap.vbuf, NULL);
-   st->bitmap.vbuf_slot = 0;
-}
-
-
-/**
- * Try to accumulate this glBitmap call in the bitmap cache.
- * \return  GL_TRUE for success, GL_FALSE if bitmap is too large, etc.
- */
-static GLboolean
-accum_bitmap(struct st_context *st,
-             GLint x, GLint y, GLsizei width, GLsizei height,
-             const struct gl_pixelstore_attrib *unpack,
-             const GLubyte *bitmap )
-{
-   struct bitmap_cache *cache = st->bitmap.cache;
-   int px = -999, py = -999;
-   const GLfloat z = st->ctx->Current.RasterPos[2];
-
-   if (width > BITMAP_CACHE_WIDTH ||
-       height > BITMAP_CACHE_HEIGHT)
-      return GL_FALSE; /* too big to cache */
-
-   if (!cache->empty) {
-      px = x - cache->xpos;  /* pos in buffer */
-      py = y - cache->ypos;
-      if (px < 0 || px + width > BITMAP_CACHE_WIDTH ||
-          py < 0 || py + height > BITMAP_CACHE_HEIGHT ||
-          !TEST_EQ_4V(st->ctx->Current.RasterColor, cache->color) ||
-          ((fabs(z - cache->zpos) > Z_EPSILON))) {
-         /* This bitmap would extend beyond cache bounds, or the bitmap
-          * color is changing
-          * so flush and continue.
-          */
-         st_flush_bitmap_cache(st);
-      }
-   }
-
-   if (cache->empty) {
-      /* Initialize.  Center bitmap vertically in the buffer. */
-      px = 0;
-      py = (BITMAP_CACHE_HEIGHT - height) / 2;
-      cache->xpos = x;
-      cache->ypos = y - py;
-      cache->zpos = z;
-      cache->empty = GL_FALSE;
-      COPY_4FV(cache->color, st->ctx->Current.RasterColor);
-   }
-
-   assert(px != -999);
-   assert(py != -999);
-
-   if (x < cache->xmin)
-      cache->xmin = x;
-   if (y < cache->ymin)
-      cache->ymin = y;
-   if (x + width > cache->xmax)
-      cache->xmax = x + width;
-   if (y + height > cache->ymax)
-      cache->ymax = y + height;
-
-   /* create the transfer if needed */
-   create_cache_trans(st);
-
-   unpack_bitmap(st, px, py, width, height, unpack, bitmap,
-                 cache->buffer, BITMAP_CACHE_WIDTH);
-
-   return GL_TRUE; /* accumulated */
-}
-
-
-
-/**
- * Called via ctx->Driver.Bitmap()
- */
-static void
-st_Bitmap(struct gl_context *ctx, GLint x, GLint y,
-          GLsizei width, GLsizei height,
-          const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap )
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_resource *pt;
-
-   if (width == 0 || height == 0)
-      return;
-
-   st_validate_state(st);
-
-   if (!st->bitmap.vs) {
-      /* create pass-through vertex shader now */
-      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
-                                      TGSI_SEMANTIC_COLOR,
-                                      TGSI_SEMANTIC_GENERIC };
-      const uint semantic_indexes[] = { 0, 0, 0 };
-      st->bitmap.vs = util_make_vertex_passthrough_shader(st->pipe, 3,
-                                                          semantic_names,
-                                                          semantic_indexes);
-   }
-
-   if (UseBitmapCache && accum_bitmap(st, x, y, width, height, unpack, bitmap))
-      return;
-
-   pt = make_bitmap_texture(ctx, width, height, unpack, bitmap);
-   if (pt) {
-      struct pipe_sampler_view *sv =
-         st_create_texture_sampler_view(st->pipe, pt);
-
-      assert(pt->target == PIPE_TEXTURE_2D || pt->target == PIPE_TEXTURE_RECT);
-
-      if (sv) {
-         draw_bitmap_quad(ctx, x, y, ctx->Current.RasterPos[2],
-                          width, height, sv,
-                          st->ctx->Current.RasterColor);
-
-         pipe_sampler_view_reference(&sv, NULL);
-      }
-
-      /* release/free the texture */
-      pipe_resource_reference(&pt, NULL);
-   }
-}
-
-
-/** Per-context init */
-void
-st_init_bitmap_functions(struct dd_function_table *functions)
-{
-   functions->Bitmap = st_Bitmap;
-}
-
-
-/** Per-context init */
-void
-st_init_bitmap(struct st_context *st)
-{
-   struct pipe_sampler_state *sampler = &st->bitmap.samplers[0];
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-
-   /* init sampler state once */
-   memset(sampler, 0, sizeof(*sampler));
-   sampler->wrap_s = PIPE_TEX_WRAP_CLAMP;
-   sampler->wrap_t = PIPE_TEX_WRAP_CLAMP;
-   sampler->wrap_r = PIPE_TEX_WRAP_CLAMP;
-   sampler->min_img_filter = PIPE_TEX_FILTER_NEAREST;
-   sampler->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   sampler->mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-   st->bitmap.samplers[1] = *sampler;
-   st->bitmap.samplers[1].normalized_coords = 1;
-
-   /* init baseline rasterizer state once */
-   memset(&st->bitmap.rasterizer, 0, sizeof(st->bitmap.rasterizer));
-   st->bitmap.rasterizer.gl_rasterization_rules = 1;
-
-   /* find a usable texture format */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;
-   }
-   else {
-      /* XXX support more formats */
-      assert(0);
-   }
-
-   /* alloc bitmap cache object */
-   st->bitmap.cache = ST_CALLOC_STRUCT(bitmap_cache);
-
-   reset_cache(st);
-}
-
-
-/** Per-context tear-down */
-void
-st_destroy_bitmap(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   if (st->bitmap.vs) {
-      cso_delete_vertex_shader(st->cso_context, st->bitmap.vs);
-      st->bitmap.vs = NULL;
-   }
-
-   if (st->bitmap.vbuf) {
-      pipe_resource_reference(&st->bitmap.vbuf, NULL);
-      st->bitmap.vbuf = NULL;
-   }
-
-   if (cache) {
-      if (cache->trans) {
-         pipe_transfer_unmap(pipe, cache->trans);
-         pipe->transfer_destroy(pipe, cache->trans);
-      }
-      pipe_resource_reference(&st->bitmap.cache->texture, NULL);
-      free(st->bitmap.cache);
-      st->bitmap.cache = NULL;
-   }
-}
-
-#endif /* FEATURE_drawpix */
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Brian Paul

+  */

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/bufferobj.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/pbo.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_atom_constbuf.h"

+#include "st_program.h"

+#include "st_cb_bitmap.h"

+#include "st_texture.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_shader_tokens.h"

+#include "util/u_inlines.h"

+#include "util/u_draw_quad.h"

+#include "util/u_simple_shaders.h"

+#include "program/prog_instruction.h"

+#include "cso_cache/cso_context.h"

+

+

+#if FEATURE_drawpix

+

+/**

+ * glBitmaps are drawn as textured quads.  The user's bitmap pattern

+ * is stored in a texture image.  An alpha8 texture format is used.

+ * The fragment shader samples a bit (texel) from the texture, then

+ * discards the fragment if the bit is off.

+ *

+ * Note that we actually store the inverse image of the bitmap to

+ * simplify the fragment program.  An "on" bit gets stored as texel=0x0

+ * and an "off" bit is stored as texel=0xff.  Then we kill the

+ * fragment if the negated texel value is less than zero.

+ */

+

+

+/**

+ * The bitmap cache attempts to accumulate multiple glBitmap calls in a

+ * buffer which is then rendered en mass upon a flush, state change, etc.

+ * A wide, short buffer is used to target the common case of a series

+ * of glBitmap calls being used to draw text.

+ */

+static GLboolean UseBitmapCache = GL_TRUE;

+

+

+#define BITMAP_CACHE_WIDTH  512

+#define BITMAP_CACHE_HEIGHT 32

+

+struct bitmap_cache

+{

+   /** Window pos to render the cached image */

+   GLint xpos, ypos;

+   /** Bounds of region used in window coords */

+   GLint xmin, ymin, xmax, ymax;

+

+   GLfloat color[4];

+

+   /** Bitmap's Z position */

+   GLfloat zpos;

+

+   struct pipe_resource *texture;

+   struct pipe_transfer *trans;

+

+   GLboolean empty;

+

+   /** An I8 texture image: */

+   ubyte *buffer;

+};

+

+

+/** Epsilon for Z comparisons */

+#define Z_EPSILON 1e-06

+

+

+/**

+ * Make fragment program for glBitmap:

+ *   Sample the texture and kill the fragment if the bit is 0.

+ * This program will be combined with the user's fragment program.

+ */

+static struct st_fragment_program *

+make_bitmap_fragment_program(struct gl_context *ctx, GLuint samplerIndex)

+{

+   struct st_context *st = st_context(ctx);

+   struct st_fragment_program *stfp;

+   struct gl_program *p;

+   GLuint ic = 0;

+

+   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

+   if (!p)

+      return NULL;

+

+   p->NumInstructions = 3;

+

+   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);

+   if (!p->Instructions) {

+      ctx->Driver.DeleteProgram(ctx, p);

+      return NULL;

+   }

+   _mesa_init_instructions(p->Instructions, p->NumInstructions);

+

+   /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */

+   p->Instructions[ic].Opcode = OPCODE_TEX;

+   p->Instructions[ic].DstReg.File = PROGRAM_TEMPORARY;

+   p->Instructions[ic].DstReg.Index = 0;

+   p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+   p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+   p->Instructions[ic].TexSrcUnit = samplerIndex;

+   p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+   ic++;

+

+   /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */

+   p->Instructions[ic].Opcode = OPCODE_KIL;

+   p->Instructions[ic].SrcReg[0].File = PROGRAM_TEMPORARY;

+

+   if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM)

+      p->Instructions[ic].SrcReg[0].Swizzle = SWIZZLE_XXXX;

+

+   p->Instructions[ic].SrcReg[0].Index = 0;

+   p->Instructions[ic].SrcReg[0].Negate = NEGATE_XYZW;

+   ic++;

+

+   /* END; */

+   p->Instructions[ic++].Opcode = OPCODE_END;

+

+   assert(ic == p->NumInstructions);

+

+   p->InputsRead = FRAG_BIT_TEX0;

+   p->OutputsWritten = 0x0;

+   p->SamplersUsed = (1 << samplerIndex);

+

+   stfp = (struct st_fragment_program *) p;

+   stfp->Base.UsesKill = GL_TRUE;

+

+   return stfp;

+}

+

+

+static int

+find_free_bit(uint bitfield)

+{

+   int i;

+   for (i = 0; i < 32; i++) {

+      if ((bitfield & (1 << i)) == 0) {

+         return i;

+      }

+   }

+   return -1;

+}

+

+

+/**

+ * Combine basic bitmap fragment program with the user-defined program.

+ * \param st  current context

+ * \param fpIn  the incoming fragment program

+ * \param fpOut  the new fragment program which does fragment culling

+ * \param bitmap_sampler  sampler number for the bitmap texture

+ */

+void

+st_make_bitmap_fragment_program(struct st_context *st,

+                                struct gl_fragment_program *fpIn,

+                                struct gl_fragment_program **fpOut,

+                                GLuint *bitmap_sampler)

+{

+   struct st_fragment_program *bitmap_prog;

+   struct gl_program *newProg;

+   uint sampler;

+

+   /*

+    * Generate new program which is the user-defined program prefixed

+    * with the bitmap sampler/kill instructions.

+    */

+   sampler = find_free_bit(fpIn->Base.SamplersUsed);

+   bitmap_prog = make_bitmap_fragment_program(st->ctx, sampler);

+

+   newProg = _mesa_combine_programs(st->ctx,

+                                    &bitmap_prog->Base.Base,

+                                    &fpIn->Base);

+   /* done with this after combining */

+   st_reference_fragprog(st, &bitmap_prog, NULL);

+

+#if 0

+   {

+      printf("Combined bitmap program:\n");

+      _mesa_print_program(newProg);

+      printf("InputsRead: 0x%x\n", newProg->InputsRead);

+      printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);

+      _mesa_print_parameter_list(newProg->Parameters);

+   }

+#endif

+

+   /* return results */

+   *fpOut = (struct gl_fragment_program *) newProg;

+   *bitmap_sampler = sampler;

+}

+

+

+/**

+ * Copy user-provide bitmap bits into texture buffer, expanding

+ * bits into texels.

+ * "On" bits will set texels to 0x0.

+ * "Off" bits will not modify texels.

+ * Note that the image is actually going to be upside down in

+ * the texture.  We deal with that with texcoords.

+ */

+static void

+unpack_bitmap(struct st_context *st,

+              GLint px, GLint py, GLsizei width, GLsizei height,

+              const struct gl_pixelstore_attrib *unpack,

+              const GLubyte *bitmap,

+              ubyte *destBuffer, uint destStride)

+{

+   destBuffer += py * destStride + px;

+

+   _mesa_expand_bitmap(width, height, unpack, bitmap,

+                       destBuffer, destStride, 0x0);

+}

+

+

+/**

+ * Create a texture which represents a bitmap image.

+ */

+static struct pipe_resource *

+make_bitmap_texture(struct gl_context *ctx, GLsizei width, GLsizei height,

+                    const struct gl_pixelstore_attrib *unpack,

+                    const GLubyte *bitmap)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_transfer *transfer;

+   ubyte *dest;

+   struct pipe_resource *pt;

+

+   /* PBO source... */

+   bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap);

+   if (!bitmap) {

+      return NULL;

+   }

+

+   /**

+    * Create texture to hold bitmap pattern.

+    */

+   pt = st_texture_create(st, st->internal_target, st->bitmap.tex_format,

+                          0, width, height, 1, 1,

+                          PIPE_BIND_SAMPLER_VIEW);

+   if (!pt) {

+      _mesa_unmap_pbo_source(ctx, unpack);

+      return NULL;

+   }

+

+   transfer = pipe_get_transfer(st->pipe, pt, 0, 0,

+                                PIPE_TRANSFER_WRITE,

+                                0, 0, width, height);

+

+   dest = pipe_transfer_map(pipe, transfer);

+

+   /* Put image into texture transfer */

+   memset(dest, 0xff, height * transfer->stride);

+   unpack_bitmap(st, 0, 0, width, height, unpack, bitmap,

+                 dest, transfer->stride);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+

+   /* Release transfer */

+   pipe_transfer_unmap(pipe, transfer);

+   pipe->transfer_destroy(pipe, transfer);

+

+   return pt;

+}

+

+static GLuint

+setup_bitmap_vertex_data(struct st_context *st, bool normalized,

+                         int x, int y, int width, int height,

+                         float z, const float color[4])

+{

+   struct pipe_context *pipe = st->pipe;

+   const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   const GLfloat fb_width = (GLfloat)fb->Width;

+   const GLfloat fb_height = (GLfloat)fb->Height;

+   const GLfloat x0 = (GLfloat)x;

+   const GLfloat x1 = (GLfloat)(x + width);

+   const GLfloat y0 = (GLfloat)y;

+   const GLfloat y1 = (GLfloat)(y + height);

+   GLfloat sLeft = (GLfloat)0.0, sRight = (GLfloat)1.0;

+   GLfloat tTop = (GLfloat)0.0, tBot = (GLfloat)1.0 - tTop;

+   const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);

+   const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);

+   const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);

+   const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);

+   const GLuint max_slots = 1; /* 4096 / sizeof(st->bitmap.vertices); */

+   GLuint i;

+

+   if(!normalized)

+   {

+      sRight = width;

+      tBot = height;

+   }

+

+   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as

+    * no_flush) updates to buffers where we know there is no conflict

+    * with previous data.  Currently using max_slots > 1 will cause

+    * synchronous rendering if the driver flushes its command buffers

+    * between one bitmap and the next.  Our flush hook below isn't

+    * sufficient to catch this as the driver doesn't tell us when it

+    * flushes its own command buffers.  Until this gets fixed, pay the

+    * price of allocating a new buffer for each bitmap cache-flush to

+    * avoid synchronous rendering.

+    */

+   if (st->bitmap.vbuf_slot >= max_slots) {

+      pipe_resource_reference(&st->bitmap.vbuf, NULL);

+      st->bitmap.vbuf_slot = 0;

+   }

+

+   if (!st->bitmap.vbuf) {

+      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 

+                                           PIPE_BIND_VERTEX_BUFFER,

+                                           PIPE_USAGE_STREAM,

+                                           max_slots *

+                                           sizeof(st->bitmap.vertices));

+   }

+

+   /* Positions are in clip coords since we need to do clipping in case

+    * the bitmap quad goes beyond the window bounds.

+    */

+   st->bitmap.vertices[0][0][0] = clip_x0;

+   st->bitmap.vertices[0][0][1] = clip_y0;

+   st->bitmap.vertices[0][2][0] = sLeft;

+   st->bitmap.vertices[0][2][1] = tTop;

+

+   st->bitmap.vertices[1][0][0] = clip_x1;

+   st->bitmap.vertices[1][0][1] = clip_y0;

+   st->bitmap.vertices[1][2][0] = sRight;

+   st->bitmap.vertices[1][2][1] = tTop;

+   

+   st->bitmap.vertices[2][0][0] = clip_x1;

+   st->bitmap.vertices[2][0][1] = clip_y1;

+   st->bitmap.vertices[2][2][0] = sRight;

+   st->bitmap.vertices[2][2][1] = tBot;

+   

+   st->bitmap.vertices[3][0][0] = clip_x0;

+   st->bitmap.vertices[3][0][1] = clip_y1;

+   st->bitmap.vertices[3][2][0] = sLeft;

+   st->bitmap.vertices[3][2][1] = tBot;

+   

+   /* same for all verts: */

+   for (i = 0; i < 4; i++) {

+      st->bitmap.vertices[i][0][2] = z;

+      st->bitmap.vertices[i][0][3] = 1.0;

+      st->bitmap.vertices[i][1][0] = color[0];

+      st->bitmap.vertices[i][1][1] = color[1];

+      st->bitmap.vertices[i][1][2] = color[2];

+      st->bitmap.vertices[i][1][3] = color[3];

+      st->bitmap.vertices[i][2][2] = 0.0; /*R*/

+      st->bitmap.vertices[i][2][3] = 1.0; /*Q*/

+   }

+

+   /* put vertex data into vbuf */

+   pipe_buffer_write_nooverlap(st->pipe,

+                               st->bitmap.vbuf,

+                               st->bitmap.vbuf_slot

+                               * sizeof(st->bitmap.vertices),

+                               sizeof st->bitmap.vertices,

+                               st->bitmap.vertices);

+

+   return st->bitmap.vbuf_slot++ * sizeof st->bitmap.vertices;

+}

+

+

+

+/**

+ * Render a glBitmap by drawing a textured quad

+ */

+static void

+draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,

+                 GLsizei width, GLsizei height,

+                 struct pipe_sampler_view *sv,

+                 const GLfloat *color)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = st->cso_context;

+   struct st_fp_variant *fpv;

+   struct st_fp_variant_key key;

+   GLuint maxSize;

+   GLuint offset;

+

+   memset(&key, 0, sizeof(key));

+   key.st = st;

+   key.bitmap = GL_TRUE;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   /* As an optimization, Mesa's fragment programs will sometimes get the

+    * primary color from a statevar/constant rather than a varying variable.

+    * when that's the case, we need to ensure that we use the 'color'

+    * parameter and not the current attribute color (which may have changed

+    * through glRasterPos and state validation.

+    * So, we force the proper color here.  Not elegant, but it works.

+    */

+   {

+      GLfloat colorSave[4];

+      COPY_4V(colorSave, ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);

+      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color);

+      st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], colorSave);

+   }

+

+

+   /* limit checks */

+   /* XXX if the bitmap is larger than the max texture size, break

+    * it up into chunks.

+    */

+   maxSize = 1 << (pipe->screen->get_param(pipe->screen,

+                                    PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);

+   assert(width <= (GLsizei)maxSize);

+   assert(height <= (GLsizei)maxSize);

+

+   cso_save_rasterizer(cso);

+   cso_save_samplers(cso);

+   cso_save_fragment_sampler_views(cso);

+   cso_save_viewport(cso);

+   cso_save_fragment_shader(cso);

+   cso_save_vertex_shader(cso);

+   cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

+

+   /* rasterizer state: just scissor */

+   st->bitmap.rasterizer.scissor = ctx->Scissor.Enabled;

+   cso_set_rasterizer(cso, &st->bitmap.rasterizer);

+

+   /* fragment shader state: TEX lookup program */

+   cso_set_fragment_shader_handle(cso, fpv->driver_shader);

+

+   /* vertex shader state: position + texcoord pass-through */

+   cso_set_vertex_shader_handle(cso, st->bitmap.vs);

+

+   /* user samplers, plus our bitmap sampler */

+   {

+      struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];

+      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_samplers);

+      uint i;

+      for (i = 0; i < st->state.num_samplers; i++) {

+         samplers[i] = &st->state.samplers[i];

+      }

+      samplers[fpv->bitmap_sampler] =

+         &st->bitmap.samplers[sv->texture->target != PIPE_TEXTURE_RECT];

+      cso_set_samplers(cso, num, (const struct pipe_sampler_state **) samplers);

+   }

+

+   /* user textures, plus the bitmap texture */

+   {

+      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];

+      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_textures);

+      memcpy(sampler_views, st->state.sampler_views, sizeof(sampler_views));

+      sampler_views[fpv->bitmap_sampler] = sv;

+      cso_set_fragment_sampler_views(cso, num, sampler_views);

+   }

+

+   /* viewport state: viewport matching window dims */

+   {

+      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);

+      const GLfloat width = (GLfloat)fb->Width;

+      const GLfloat height = (GLfloat)fb->Height;

+      struct pipe_viewport_state vp;

+      vp.scale[0] =  0.5f * width;

+      vp.scale[1] = height * (invert ? -0.5f : 0.5f);

+      vp.scale[2] = 0.5f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * width;

+      vp.translate[1] = 0.5f * height;

+      vp.translate[2] = 0.5f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(cso, &vp);

+   }

+

+   cso_set_vertex_elements(cso, 3, st->velems_util_draw);

+

+   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */

+   z = z * 2.0 - 1.0;

+

+   /* draw textured quad */

+   offset = setup_bitmap_vertex_data(st,

+                                     sv->texture->target != PIPE_TEXTURE_RECT,

+                                     x, y, width, height, z, color);

+

+   util_draw_vertex_buffer(pipe, st->cso_context, st->bitmap.vbuf, offset,

+                           PIPE_PRIM_TRIANGLE_FAN,

+                           4,  /* verts */

+                           3); /* attribs/vert */

+

+

+   /* restore state */

+   cso_restore_rasterizer(cso);

+   cso_restore_samplers(cso);

+   cso_restore_fragment_sampler_views(cso);

+   cso_restore_viewport(cso);

+   cso_restore_fragment_shader(cso);

+   cso_restore_vertex_shader(cso);

+   cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

+}

+

+

+static void

+reset_cache(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   /*memset(cache->buffer, 0xff, sizeof(cache->buffer));*/

+   cache->empty = GL_TRUE;

+

+   cache->xmin = 1000000;

+   cache->xmax = -1000000;

+   cache->ymin = 1000000;

+   cache->ymax = -1000000;

+

+   if (cache->trans) {

+      pipe->transfer_destroy(pipe, cache->trans);

+      cache->trans = NULL;

+   }

+

+   assert(!cache->texture);

+

+   /* allocate a new texture */

+   cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,

+                                      st->bitmap.tex_format, 0,

+                                      BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,

+                                      1, 1,

+				      PIPE_BIND_SAMPLER_VIEW);

+}

+

+

+/** Print bitmap image to stdout (debug) */

+static void

+print_cache(const struct bitmap_cache *cache)

+{

+   int i, j, k;

+

+   for (i = 0; i < BITMAP_CACHE_HEIGHT; i++) {

+      k = BITMAP_CACHE_WIDTH * (BITMAP_CACHE_HEIGHT - i - 1);

+      for (j = 0; j < BITMAP_CACHE_WIDTH; j++) {

+         if (cache->buffer[k])

+            printf("X");

+         else

+            printf(" ");

+         k++;

+      }

+      printf("\n");

+   }

+}

+

+

+/**

+ * Create gallium pipe_transfer object for the bitmap cache.

+ */

+static void

+create_cache_trans(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   if (cache->trans)

+      return;

+

+   /* Map the texture transfer.

+    * Subsequent glBitmap calls will write into the texture image.

+    */

+   cache->trans = pipe_get_transfer(st->pipe, cache->texture, 0, 0,

+                                    PIPE_TRANSFER_WRITE, 0, 0,

+                                    BITMAP_CACHE_WIDTH,

+                                    BITMAP_CACHE_HEIGHT);

+   cache->buffer = pipe_transfer_map(pipe, cache->trans);

+

+   /* init image to all 0xff */

+   memset(cache->buffer, 0xff, cache->trans->stride * BITMAP_CACHE_HEIGHT);

+}

+

+

+/**

+ * If there's anything in the bitmap cache, draw/flush it now.

+ */

+void

+st_flush_bitmap_cache(struct st_context *st)

+{

+   if (!st->bitmap.cache->empty) {

+      struct bitmap_cache *cache = st->bitmap.cache;

+

+      if (st->ctx->DrawBuffer) {

+         struct pipe_context *pipe = st->pipe;

+         struct pipe_sampler_view *sv;

+

+         assert(cache->xmin <= cache->xmax);

+ 

+/*         printf("flush size %d x %d  at %d, %d\n",

+                cache->xmax - cache->xmin,

+                cache->ymax - cache->ymin,

+                cache->xpos, cache->ypos);

+*/

+

+         /* The texture transfer has been mapped until now.

+          * So unmap and release the texture transfer before drawing.

+          */

+         if (cache->trans) {

+            if (0)

+               print_cache(cache);

+            pipe_transfer_unmap(pipe, cache->trans);

+            cache->buffer = NULL;

+

+            pipe->transfer_destroy(pipe, cache->trans);

+            cache->trans = NULL;

+         }

+

+         sv = st_create_texture_sampler_view(st->pipe, cache->texture);

+         if (sv) {

+            draw_bitmap_quad(st->ctx,

+                             cache->xpos,

+                             cache->ypos,

+                             cache->zpos,

+                             BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,

+                             sv,

+                             cache->color);

+

+            pipe_sampler_view_reference(&sv, NULL);

+         }

+      }

+

+      /* release/free the texture */

+      pipe_resource_reference(&cache->texture, NULL);

+

+      reset_cache(st);

+   }

+}

+

+

+/**

+ * Flush bitmap cache and release vertex buffer.

+ */

+void

+st_flush_bitmap( struct st_context *st )

+{

+   st_flush_bitmap_cache(st);

+

+   /* Release vertex buffer to avoid synchronous rendering if we were

+    * to map it in the next frame.

+    */

+   pipe_resource_reference(&st->bitmap.vbuf, NULL);

+   st->bitmap.vbuf_slot = 0;

+}

+

+

+/**

+ * Try to accumulate this glBitmap call in the bitmap cache.

+ * \return  GL_TRUE for success, GL_FALSE if bitmap is too large, etc.

+ */

+static GLboolean

+accum_bitmap(struct st_context *st,

+             GLint x, GLint y, GLsizei width, GLsizei height,

+             const struct gl_pixelstore_attrib *unpack,

+             const GLubyte *bitmap )

+{

+   struct bitmap_cache *cache = st->bitmap.cache;

+   int px = -999, py = -999;

+   const GLfloat z = st->ctx->Current.RasterPos[2];

+

+   if (width > BITMAP_CACHE_WIDTH ||

+       height > BITMAP_CACHE_HEIGHT)

+      return GL_FALSE; /* too big to cache */

+

+   if (!cache->empty) {

+      px = x - cache->xpos;  /* pos in buffer */

+      py = y - cache->ypos;

+      if (px < 0 || px + width > BITMAP_CACHE_WIDTH ||

+          py < 0 || py + height > BITMAP_CACHE_HEIGHT ||

+          !TEST_EQ_4V(st->ctx->Current.RasterColor, cache->color) ||

+          ((fabs(z - cache->zpos) > Z_EPSILON))) {

+         /* This bitmap would extend beyond cache bounds, or the bitmap

+          * color is changing

+          * so flush and continue.

+          */

+         st_flush_bitmap_cache(st);

+      }

+   }

+

+   if (cache->empty) {

+      /* Initialize.  Center bitmap vertically in the buffer. */

+      px = 0;

+      py = (BITMAP_CACHE_HEIGHT - height) / 2;

+      cache->xpos = x;

+      cache->ypos = y - py;

+      cache->zpos = z;

+      cache->empty = GL_FALSE;

+      COPY_4FV(cache->color, st->ctx->Current.RasterColor);

+   }

+

+   assert(px != -999);

+   assert(py != -999);

+

+   if (x < cache->xmin)

+      cache->xmin = x;

+   if (y < cache->ymin)

+      cache->ymin = y;

+   if (x + width > cache->xmax)

+      cache->xmax = x + width;

+   if (y + height > cache->ymax)

+      cache->ymax = y + height;

+

+   /* create the transfer if needed */

+   create_cache_trans(st);

+

+   unpack_bitmap(st, px, py, width, height, unpack, bitmap,

+                 cache->buffer, BITMAP_CACHE_WIDTH);

+

+   return GL_TRUE; /* accumulated */

+}

+

+

+

+/**

+ * Called via ctx->Driver.Bitmap()

+ */

+static void

+st_Bitmap(struct gl_context *ctx, GLint x, GLint y,

+          GLsizei width, GLsizei height,

+          const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap )

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_resource *pt;

+

+   if (width == 0 || height == 0)

+      return;

+

+   st_validate_state(st);

+

+   if (!st->bitmap.vs) {

+      /* create pass-through vertex shader now */

+      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,

+                                      TGSI_SEMANTIC_COLOR,

+                                      TGSI_SEMANTIC_GENERIC };

+      const uint semantic_indexes[] = { 0, 0, 0 };

+      st->bitmap.vs = util_make_vertex_passthrough_shader(st->pipe, 3,

+                                                          semantic_names,

+                                                          semantic_indexes);

+   }

+

+   if (UseBitmapCache && accum_bitmap(st, x, y, width, height, unpack, bitmap))

+      return;

+

+   pt = make_bitmap_texture(ctx, width, height, unpack, bitmap);

+   if (pt) {

+      struct pipe_sampler_view *sv =

+         st_create_texture_sampler_view(st->pipe, pt);

+

+      assert(pt->target == PIPE_TEXTURE_2D || pt->target == PIPE_TEXTURE_RECT);

+

+      if (sv) {

+         draw_bitmap_quad(ctx, x, y, ctx->Current.RasterPos[2],

+                          width, height, sv,

+                          st->ctx->Current.RasterColor);

+

+         pipe_sampler_view_reference(&sv, NULL);

+      }

+

+      /* release/free the texture */

+      pipe_resource_reference(&pt, NULL);

+   }

+}

+

+

+/** Per-context init */

+void

+st_init_bitmap_functions(struct dd_function_table *functions)

+{

+   functions->Bitmap = st_Bitmap;

+}

+

+

+/** Per-context init */

+void

+st_init_bitmap(struct st_context *st)

+{

+   struct pipe_sampler_state *sampler = &st->bitmap.samplers[0];

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+

+   /* init sampler state once */

+   memset(sampler, 0, sizeof(*sampler));

+   sampler->wrap_s = PIPE_TEX_WRAP_CLAMP;

+   sampler->wrap_t = PIPE_TEX_WRAP_CLAMP;

+   sampler->wrap_r = PIPE_TEX_WRAP_CLAMP;

+   sampler->min_img_filter = PIPE_TEX_FILTER_NEAREST;

+   sampler->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;

+   sampler->mag_img_filter = PIPE_TEX_FILTER_NEAREST;

+   st->bitmap.samplers[1] = *sampler;

+   st->bitmap.samplers[1].normalized_coords = 1;

+

+   /* init baseline rasterizer state once */

+   memset(&st->bitmap.rasterizer, 0, sizeof(st->bitmap.rasterizer));

+   st->bitmap.rasterizer.gl_rasterization_rules = 1;

+

+   /* find a usable texture format */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {

+      st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {

+      st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;

+   }

+   else {

+      /* XXX support more formats */

+      assert(0);

+   }

+

+   /* alloc bitmap cache object */

+   st->bitmap.cache = ST_CALLOC_STRUCT(bitmap_cache);

+

+   reset_cache(st);

+}

+

+

+/** Per-context tear-down */

+void

+st_destroy_bitmap(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   if (st->bitmap.vs) {

+      cso_delete_vertex_shader(st->cso_context, st->bitmap.vs);

+      st->bitmap.vs = NULL;

+   }

+

+   if (st->bitmap.vbuf) {

+      pipe_resource_reference(&st->bitmap.vbuf, NULL);

+      st->bitmap.vbuf = NULL;

+   }

+

+   if (cache) {

+      if (cache->trans) {

+         pipe_transfer_unmap(pipe, cache->trans);

+         pipe->transfer_destroy(pipe, cache->trans);

+      }

+      pipe_resource_reference(&st->bitmap.cache->texture, NULL);

+      free(st->bitmap.cache);

+      st->bitmap.cache = NULL;

+   }

+}

+

+#endif /* FEATURE_drawpix */

diff --git a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
index 12528f49f..9dd1f8a3e 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
@@ -1,468 +1,468 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-/**
- * Functions for pixel buffer objects and vertex/element buffer objects.
- */
-
-
-#include "main/imports.h"
-#include "main/mtypes.h"
-#include "main/arrayobj.h"
-#include "main/bufferobj.h"
-
-#include "st_context.h"
-#include "st_cb_bufferobjects.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-
-
-/**
- * There is some duplication between mesa's bufferobjects and our
- * bufmgr buffers.  Both have an integer handle and a hashtable to
- * lookup an opaque structure.  It would be nice if the handles and
- * internal structure where somehow shared.
- */
-static struct gl_buffer_object *
-st_bufferobj_alloc(struct gl_context *ctx, GLuint name, GLenum target)
-{
-   struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object);
-
-   if (!st_obj)
-      return NULL;
-
-   _mesa_initialize_buffer_object(&st_obj->Base, name, target);
-
-   return &st_obj->Base;
-}
-
-
-
-/**
- * Deallocate/free a vertex/pixel buffer object.
- * Called via glDeleteBuffersARB().
- */
-static void
-st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj)
-{
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-
-   assert(obj->RefCount == 0);
-   assert(st_obj->transfer == NULL);
-
-   if (st_obj->buffer) 
-      pipe_resource_reference(&st_obj->buffer, NULL);
-
-   free(st_obj);
-}
-
-
-
-/**
- * Replace data in a subrange of buffer object.  If the data range
- * specified by size + offset extends beyond the end of the buffer or
- * if data is NULL, no copy is performed.
- * Called via glBufferSubDataARB().
- */
-static void
-st_bufferobj_subdata(struct gl_context *ctx,
-		     GLenum target,
-		     GLintptrARB offset,
-		     GLsizeiptrARB size,
-		     const GLvoid * data, struct gl_buffer_object *obj)
-{
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-
-   /* we may be called from VBO code, so double-check params here */
-   ASSERT(offset >= 0);
-   ASSERT(size >= 0);
-   ASSERT(offset + size <= obj->Size);
-
-   if (!size)
-      return;
-
-   /*
-    * According to ARB_vertex_buffer_object specification, if data is null,
-    * then the contents of the buffer object's data store is undefined. We just
-    * ignore, and leave it unchanged.
-    */
-   if (!data)
-      return;
-
-   /* Now that transfers are per-context, we don't have to figure out
-    * flushing here.  Usually drivers won't need to flush in this case
-    * even if the buffer is currently referenced by hardware - they
-    * just queue the upload as dma rather than mapping the underlying
-    * buffer directly.
-    */
-   pipe_buffer_write(st_context(ctx)->pipe,
-		     st_obj->buffer,
-		     offset, size, data);
-}
-
-
-/**
- * Called via glGetBufferSubDataARB().
- */
-static void
-st_bufferobj_get_subdata(struct gl_context *ctx,
-                         GLenum target,
-                         GLintptrARB offset,
-                         GLsizeiptrARB size,
-                         GLvoid * data, struct gl_buffer_object *obj)
-{
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-
-   /* we may be called from VBO code, so double-check params here */
-   ASSERT(offset >= 0);
-   ASSERT(size >= 0);
-   ASSERT(offset + size <= obj->Size);
-
-   if (!size)
-      return;
-
-   pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer,
-                    offset, size, data);
-}
-
-
-/**
- * Allocate space for and store data in a buffer object.  Any data that was
- * previously stored in the buffer object is lost.  If data is NULL,
- * memory will be allocated, but no copy will occur.
- * Called via ctx->Driver.BufferData().
- * \return GL_TRUE for success, GL_FALSE if out of memory
- */
-static GLboolean
-st_bufferobj_data(struct gl_context *ctx,
-		  GLenum target,
-		  GLsizeiptrARB size,
-		  const GLvoid * data,
-		  GLenum usage, 
-		  struct gl_buffer_object *obj)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-   unsigned bind, pipe_usage;
-
-   st_obj->Base.Size = size;
-   st_obj->Base.Usage = usage;
-   
-   switch(target) {
-   case GL_PIXEL_PACK_BUFFER_ARB:
-   case GL_PIXEL_UNPACK_BUFFER_ARB:
-      bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
-      break;
-   case GL_ARRAY_BUFFER_ARB:
-      bind = PIPE_BIND_VERTEX_BUFFER;
-      break;
-   case GL_ELEMENT_ARRAY_BUFFER_ARB:
-      bind = PIPE_BIND_INDEX_BUFFER;
-      break;
-   default:
-      bind = 0;
-   }
-
-   switch (usage) {
-   case GL_STATIC_DRAW:
-   case GL_STATIC_READ:
-   case GL_STATIC_COPY:
-      pipe_usage = PIPE_USAGE_STATIC;
-      break;
-   case GL_DYNAMIC_DRAW:
-   case GL_DYNAMIC_READ:
-   case GL_DYNAMIC_COPY:
-      pipe_usage = PIPE_USAGE_DYNAMIC;
-      break;
-   case GL_STREAM_DRAW:
-   case GL_STREAM_READ:
-   case GL_STREAM_COPY:
-      pipe_usage = PIPE_USAGE_STREAM;
-      break;
-   default:
-      pipe_usage = PIPE_USAGE_DEFAULT;
-   }
-
-   pipe_resource_reference( &st_obj->buffer, NULL );
-
-   if (size != 0) {
-      st_obj->buffer = pipe_buffer_create(pipe->screen, bind,
-                                          pipe_usage, size);
-
-      if (!st_obj->buffer) {
-         return GL_FALSE;
-      }
-
-      if (data)
-         pipe_buffer_write(st_context(ctx)->pipe, st_obj->buffer, 0,
-				       size, data);
-      return GL_TRUE;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Dummy data whose's pointer is used for zero size buffers or ranges.
- */
-static long st_bufferobj_zero_length = 0;
-
-
-
-/**
- * Called via glMapBufferARB().
- */
-static void *
-st_bufferobj_map(struct gl_context *ctx, GLenum target, GLenum access,
-                 struct gl_buffer_object *obj)
-{
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-   uint flags;
-
-   switch (access) {
-   case GL_WRITE_ONLY:
-      flags = PIPE_TRANSFER_WRITE;
-      break;
-   case GL_READ_ONLY:
-      flags = PIPE_TRANSFER_READ;
-      break;
-   case GL_READ_WRITE:
-   default:
-      flags = PIPE_TRANSFER_READ_WRITE;
-      break;      
-   }
-
-   /* Handle zero-size buffers here rather than in drivers */
-   if (obj->Size == 0) {
-      obj->Pointer = &st_bufferobj_zero_length;
-   }
-   else {
-      obj->Pointer = pipe_buffer_map(st_context(ctx)->pipe,
-                                     st_obj->buffer,
-                                     flags,
-                                     &st_obj->transfer);
-   }
-
-   if (obj->Pointer) {
-      obj->Offset = 0;
-      obj->Length = obj->Size;
-   }
-   return obj->Pointer;
-}
-
-
-/**
- * Called via glMapBufferRange().
- */
-static void *
-st_bufferobj_map_range(struct gl_context *ctx, GLenum target, 
-                       GLintptr offset, GLsizeiptr length, GLbitfield access,
-                       struct gl_buffer_object *obj)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-   enum pipe_transfer_usage flags = 0x0;
-
-   if (access & GL_MAP_WRITE_BIT)
-      flags |= PIPE_TRANSFER_WRITE;
-
-   if (access & GL_MAP_READ_BIT)
-      flags |= PIPE_TRANSFER_READ;
-
-   if (access & GL_MAP_FLUSH_EXPLICIT_BIT)
-      flags |= PIPE_TRANSFER_FLUSH_EXPLICIT;
-
-   if (access & GL_MAP_INVALIDATE_RANGE_BIT)
-      flags |= PIPE_TRANSFER_DISCARD;
-
-   if (access & GL_MAP_INVALIDATE_BUFFER_BIT)
-      flags |= PIPE_TRANSFER_DISCARD;
-   
-   if (access & GL_MAP_UNSYNCHRONIZED_BIT)
-      flags |= PIPE_TRANSFER_UNSYNCHRONIZED;
-
-   /* ... other flags ...
-    */
-
-   if (access & MESA_MAP_NOWAIT_BIT)
-      flags |= PIPE_TRANSFER_DONTBLOCK;
-
-   assert(offset >= 0);
-   assert(length >= 0);
-   assert(offset < obj->Size);
-   assert(offset + length <= obj->Size);
-
-   /*
-    * We go out of way here to hide the degenerate yet valid case of zero
-    * length range from the pipe driver.
-    */
-   if (!length) {
-      obj->Pointer = &st_bufferobj_zero_length;
-   }
-   else {
-      obj->Pointer = pipe_buffer_map_range(pipe, 
-                                           st_obj->buffer,
-                                           offset, length,
-                                           flags,
-                                           &st_obj->transfer);
-      if (obj->Pointer) {
-         obj->Pointer = (ubyte *) obj->Pointer + offset;
-      }
-   }
-   
-   if (obj->Pointer) {
-      obj->Offset = offset;
-      obj->Length = length;
-      obj->AccessFlags = access;
-   }
-
-   return obj->Pointer;
-}
-
-
-static void
-st_bufferobj_flush_mapped_range(struct gl_context *ctx, GLenum target, 
-                                GLintptr offset, GLsizeiptr length,
-                                struct gl_buffer_object *obj)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-
-   /* Subrange is relative to mapped range */
-   assert(offset >= 0);
-   assert(length >= 0);
-   assert(offset + length <= obj->Length);
-   assert(obj->Pointer);
-   
-   if (!length)
-      return;
-
-   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer, 
-                                  obj->Offset + offset, length);
-}
-
-
-/**
- * Called via glUnmapBufferARB().
- */
-static GLboolean
-st_bufferobj_unmap(struct gl_context *ctx, GLenum target, struct gl_buffer_object *obj)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_buffer_object *st_obj = st_buffer_object(obj);
-
-   if (obj->Length)
-      pipe_buffer_unmap(pipe, st_obj->transfer);
-
-   st_obj->transfer = NULL;
-   obj->Pointer = NULL;
-   obj->Offset = 0;
-   obj->Length = 0;
-   return GL_TRUE;
-}
-
-
-/**
- * Called via glCopyBufferSubData().
- */
-static void
-st_copy_buffer_subdata(struct gl_context *ctx,
-                       struct gl_buffer_object *src,
-                       struct gl_buffer_object *dst,
-                       GLintptr readOffset, GLintptr writeOffset,
-                       GLsizeiptr size)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_buffer_object *srcObj = st_buffer_object(src);
-   struct st_buffer_object *dstObj = st_buffer_object(dst);
-   struct pipe_transfer *src_transfer;
-   struct pipe_transfer *dst_transfer;
-   ubyte *srcPtr, *dstPtr;
-
-   if(!size)
-      return;
-
-   /* buffer should not already be mapped */
-   assert(!src->Pointer);
-   assert(!dst->Pointer);
-
-   srcPtr = (ubyte *) pipe_buffer_map_range(pipe,
-                                            srcObj->buffer,
-                                            readOffset, size,
-                                            PIPE_TRANSFER_READ,
-					    &src_transfer);
-
-   dstPtr = (ubyte *) pipe_buffer_map_range(pipe,
-                                            dstObj->buffer,
-                                            writeOffset, size,
-                                            PIPE_TRANSFER_WRITE,
-					    &dst_transfer);
-
-   if (srcPtr && dstPtr)
-      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
-
-   pipe_buffer_unmap(pipe, src_transfer);
-   pipe_buffer_unmap(pipe, dst_transfer);
-}
-
-
-/* TODO: if buffer wasn't created with appropriate usage flags, need
- * to recreate it now and copy contents -- or possibly create a
- * gallium entrypoint to extend the usage flags and let the driver
- * decide if a copy is necessary.
- */
-void
-st_bufferobj_validate_usage(struct st_context *st,
-			    struct st_buffer_object *obj,
-			    unsigned usage)
-{
-}
-
-
-void
-st_init_bufferobject_functions(struct dd_function_table *functions)
-{
-   functions->NewBufferObject = st_bufferobj_alloc;
-   functions->DeleteBuffer = st_bufferobj_free;
-   functions->BufferData = st_bufferobj_data;
-   functions->BufferSubData = st_bufferobj_subdata;
-   functions->GetBufferSubData = st_bufferobj_get_subdata;
-   functions->MapBuffer = st_bufferobj_map;
-   functions->MapBufferRange = st_bufferobj_map_range;
-   functions->FlushMappedBufferRange = st_bufferobj_flush_mapped_range;
-   functions->UnmapBuffer = st_bufferobj_unmap;
-   functions->CopyBufferSubData = st_copy_buffer_subdata;
-
-   /* For GL_APPLE_vertex_array_object */
-   functions->NewArrayObject = _mesa_new_array_object;
-   functions->DeleteArrayObject = _mesa_delete_array_object;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * Functions for pixel buffer objects and vertex/element buffer objects.

+ */

+

+

+#include "main/imports.h"

+#include "main/mtypes.h"

+#include "main/arrayobj.h"

+#include "main/bufferobj.h"

+

+#include "st_context.h"

+#include "st_cb_bufferobjects.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+

+

+/**

+ * There is some duplication between mesa's bufferobjects and our

+ * bufmgr buffers.  Both have an integer handle and a hashtable to

+ * lookup an opaque structure.  It would be nice if the handles and

+ * internal structure where somehow shared.

+ */

+static struct gl_buffer_object *

+st_bufferobj_alloc(struct gl_context *ctx, GLuint name, GLenum target)

+{

+   struct st_buffer_object *st_obj = ST_CALLOC_STRUCT(st_buffer_object);

+

+   if (!st_obj)

+      return NULL;

+

+   _mesa_initialize_buffer_object(&st_obj->Base, name, target);

+

+   return &st_obj->Base;

+}

+

+

+

+/**

+ * Deallocate/free a vertex/pixel buffer object.

+ * Called via glDeleteBuffersARB().

+ */

+static void

+st_bufferobj_free(struct gl_context *ctx, struct gl_buffer_object *obj)

+{

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+

+   assert(obj->RefCount == 0);

+   assert(st_obj->transfer == NULL);

+

+   if (st_obj->buffer) 

+      pipe_resource_reference(&st_obj->buffer, NULL);

+

+   free(st_obj);

+}

+

+

+

+/**

+ * Replace data in a subrange of buffer object.  If the data range

+ * specified by size + offset extends beyond the end of the buffer or

+ * if data is NULL, no copy is performed.

+ * Called via glBufferSubDataARB().

+ */

+static void

+st_bufferobj_subdata(struct gl_context *ctx,

+		     GLenum target,

+		     GLintptrARB offset,

+		     GLsizeiptrARB size,

+		     const GLvoid * data, struct gl_buffer_object *obj)

+{

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+

+   /* we may be called from VBO code, so double-check params here */

+   ASSERT(offset >= 0);

+   ASSERT(size >= 0);

+   ASSERT(offset + size <= obj->Size);

+

+   if (!size)

+      return;

+

+   /*

+    * According to ARB_vertex_buffer_object specification, if data is null,

+    * then the contents of the buffer object's data store is undefined. We just

+    * ignore, and leave it unchanged.

+    */

+   if (!data)

+      return;

+

+   /* Now that transfers are per-context, we don't have to figure out

+    * flushing here.  Usually drivers won't need to flush in this case

+    * even if the buffer is currently referenced by hardware - they

+    * just queue the upload as dma rather than mapping the underlying

+    * buffer directly.

+    */

+   pipe_buffer_write(st_context(ctx)->pipe,

+		     st_obj->buffer,

+		     offset, size, data);

+}

+

+

+/**

+ * Called via glGetBufferSubDataARB().

+ */

+static void

+st_bufferobj_get_subdata(struct gl_context *ctx,

+                         GLenum target,

+                         GLintptrARB offset,

+                         GLsizeiptrARB size,

+                         GLvoid * data, struct gl_buffer_object *obj)

+{

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+

+   /* we may be called from VBO code, so double-check params here */

+   ASSERT(offset >= 0);

+   ASSERT(size >= 0);

+   ASSERT(offset + size <= obj->Size);

+

+   if (!size)

+      return;

+

+   pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer,

+                    offset, size, data);

+}

+

+

+/**

+ * Allocate space for and store data in a buffer object.  Any data that was

+ * previously stored in the buffer object is lost.  If data is NULL,

+ * memory will be allocated, but no copy will occur.

+ * Called via ctx->Driver.BufferData().

+ * \return GL_TRUE for success, GL_FALSE if out of memory

+ */

+static GLboolean

+st_bufferobj_data(struct gl_context *ctx,

+		  GLenum target,

+		  GLsizeiptrARB size,

+		  const GLvoid * data,

+		  GLenum usage, 

+		  struct gl_buffer_object *obj)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+   unsigned bind, pipe_usage;

+

+   st_obj->Base.Size = size;

+   st_obj->Base.Usage = usage;

+   

+   switch(target) {

+   case GL_PIXEL_PACK_BUFFER_ARB:

+   case GL_PIXEL_UNPACK_BUFFER_ARB:

+      bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;

+      break;

+   case GL_ARRAY_BUFFER_ARB:

+      bind = PIPE_BIND_VERTEX_BUFFER;

+      break;

+   case GL_ELEMENT_ARRAY_BUFFER_ARB:

+      bind = PIPE_BIND_INDEX_BUFFER;

+      break;

+   default:

+      bind = 0;

+   }

+

+   switch (usage) {

+   case GL_STATIC_DRAW:

+   case GL_STATIC_READ:

+   case GL_STATIC_COPY:

+      pipe_usage = PIPE_USAGE_STATIC;

+      break;

+   case GL_DYNAMIC_DRAW:

+   case GL_DYNAMIC_READ:

+   case GL_DYNAMIC_COPY:

+      pipe_usage = PIPE_USAGE_DYNAMIC;

+      break;

+   case GL_STREAM_DRAW:

+   case GL_STREAM_READ:

+   case GL_STREAM_COPY:

+      pipe_usage = PIPE_USAGE_STREAM;

+      break;

+   default:

+      pipe_usage = PIPE_USAGE_DEFAULT;

+   }

+

+   pipe_resource_reference( &st_obj->buffer, NULL );

+

+   if (size != 0) {

+      st_obj->buffer = pipe_buffer_create(pipe->screen, bind,

+                                          pipe_usage, size);

+

+      if (!st_obj->buffer) {

+         return GL_FALSE;

+      }

+

+      if (data)

+         pipe_buffer_write(st_context(ctx)->pipe, st_obj->buffer, 0,

+				       size, data);

+      return GL_TRUE;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Dummy data whose's pointer is used for zero size buffers or ranges.

+ */

+static long st_bufferobj_zero_length = 0;

+

+

+

+/**

+ * Called via glMapBufferARB().

+ */

+static void *

+st_bufferobj_map(struct gl_context *ctx, GLenum target, GLenum access,

+                 struct gl_buffer_object *obj)

+{

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+   uint flags;

+

+   switch (access) {

+   case GL_WRITE_ONLY:

+      flags = PIPE_TRANSFER_WRITE;

+      break;

+   case GL_READ_ONLY:

+      flags = PIPE_TRANSFER_READ;

+      break;

+   case GL_READ_WRITE:

+   default:

+      flags = PIPE_TRANSFER_READ_WRITE;

+      break;      

+   }

+

+   /* Handle zero-size buffers here rather than in drivers */

+   if (obj->Size == 0) {

+      obj->Pointer = &st_bufferobj_zero_length;

+   }

+   else {

+      obj->Pointer = pipe_buffer_map(st_context(ctx)->pipe,

+                                     st_obj->buffer,

+                                     flags,

+                                     &st_obj->transfer);

+   }

+

+   if (obj->Pointer) {

+      obj->Offset = 0;

+      obj->Length = obj->Size;

+   }

+   return obj->Pointer;

+}

+

+

+/**

+ * Called via glMapBufferRange().

+ */

+static void *

+st_bufferobj_map_range(struct gl_context *ctx, GLenum target, 

+                       GLintptr offset, GLsizeiptr length, GLbitfield access,

+                       struct gl_buffer_object *obj)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+   enum pipe_transfer_usage flags = 0x0;

+

+   if (access & GL_MAP_WRITE_BIT)

+      flags |= PIPE_TRANSFER_WRITE;

+

+   if (access & GL_MAP_READ_BIT)

+      flags |= PIPE_TRANSFER_READ;

+

+   if (access & GL_MAP_FLUSH_EXPLICIT_BIT)

+      flags |= PIPE_TRANSFER_FLUSH_EXPLICIT;

+

+   if (access & GL_MAP_INVALIDATE_RANGE_BIT)

+      flags |= PIPE_TRANSFER_DISCARD;

+

+   if (access & GL_MAP_INVALIDATE_BUFFER_BIT)

+      flags |= PIPE_TRANSFER_DISCARD;

+   

+   if (access & GL_MAP_UNSYNCHRONIZED_BIT)

+      flags |= PIPE_TRANSFER_UNSYNCHRONIZED;

+

+   /* ... other flags ...

+    */

+

+   if (access & MESA_MAP_NOWAIT_BIT)

+      flags |= PIPE_TRANSFER_DONTBLOCK;

+

+   assert(offset >= 0);

+   assert(length >= 0);

+   assert(offset < obj->Size);

+   assert(offset + length <= obj->Size);

+

+   /*

+    * We go out of way here to hide the degenerate yet valid case of zero

+    * length range from the pipe driver.

+    */

+   if (!length) {

+      obj->Pointer = &st_bufferobj_zero_length;

+   }

+   else {

+      obj->Pointer = pipe_buffer_map_range(pipe, 

+                                           st_obj->buffer,

+                                           offset, length,

+                                           flags,

+                                           &st_obj->transfer);

+      if (obj->Pointer) {

+         obj->Pointer = (ubyte *) obj->Pointer + offset;

+      }

+   }

+   

+   if (obj->Pointer) {

+      obj->Offset = offset;

+      obj->Length = length;

+      obj->AccessFlags = access;

+   }

+

+   return obj->Pointer;

+}

+

+

+static void

+st_bufferobj_flush_mapped_range(struct gl_context *ctx, GLenum target, 

+                                GLintptr offset, GLsizeiptr length,

+                                struct gl_buffer_object *obj)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+

+   /* Subrange is relative to mapped range */

+   assert(offset >= 0);

+   assert(length >= 0);

+   assert(offset + length <= obj->Length);

+   assert(obj->Pointer);

+   

+   if (!length)

+      return;

+

+   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer, 

+                                  obj->Offset + offset, length);

+}

+

+

+/**

+ * Called via glUnmapBufferARB().

+ */

+static GLboolean

+st_bufferobj_unmap(struct gl_context *ctx, GLenum target, struct gl_buffer_object *obj)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_buffer_object *st_obj = st_buffer_object(obj);

+

+   if (obj->Length)

+      pipe_buffer_unmap(pipe, st_obj->transfer);

+

+   st_obj->transfer = NULL;

+   obj->Pointer = NULL;

+   obj->Offset = 0;

+   obj->Length = 0;

+   return GL_TRUE;

+}

+

+

+/**

+ * Called via glCopyBufferSubData().

+ */

+static void

+st_copy_buffer_subdata(struct gl_context *ctx,

+                       struct gl_buffer_object *src,

+                       struct gl_buffer_object *dst,

+                       GLintptr readOffset, GLintptr writeOffset,

+                       GLsizeiptr size)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_buffer_object *srcObj = st_buffer_object(src);

+   struct st_buffer_object *dstObj = st_buffer_object(dst);

+   struct pipe_transfer *src_transfer;

+   struct pipe_transfer *dst_transfer;

+   ubyte *srcPtr, *dstPtr;

+

+   if(!size)

+      return;

+

+   /* buffer should not already be mapped */

+   assert(!src->Pointer);

+   assert(!dst->Pointer);

+

+   srcPtr = (ubyte *) pipe_buffer_map_range(pipe,

+                                            srcObj->buffer,

+                                            readOffset, size,

+                                            PIPE_TRANSFER_READ,

+					    &src_transfer);

+

+   dstPtr = (ubyte *) pipe_buffer_map_range(pipe,

+                                            dstObj->buffer,

+                                            writeOffset, size,

+                                            PIPE_TRANSFER_WRITE,

+					    &dst_transfer);

+

+   if (srcPtr && dstPtr)

+      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);

+

+   pipe_buffer_unmap(pipe, src_transfer);

+   pipe_buffer_unmap(pipe, dst_transfer);

+}

+

+

+/* TODO: if buffer wasn't created with appropriate usage flags, need

+ * to recreate it now and copy contents -- or possibly create a

+ * gallium entrypoint to extend the usage flags and let the driver

+ * decide if a copy is necessary.

+ */

+void

+st_bufferobj_validate_usage(struct st_context *st,

+			    struct st_buffer_object *obj,

+			    unsigned usage)

+{

+}

+

+

+void

+st_init_bufferobject_functions(struct dd_function_table *functions)

+{

+   functions->NewBufferObject = st_bufferobj_alloc;

+   functions->DeleteBuffer = st_bufferobj_free;

+   functions->BufferData = st_bufferobj_data;

+   functions->BufferSubData = st_bufferobj_subdata;

+   functions->GetBufferSubData = st_bufferobj_get_subdata;

+   functions->MapBuffer = st_bufferobj_map;

+   functions->MapBufferRange = st_bufferobj_map_range;

+   functions->FlushMappedBufferRange = st_bufferobj_flush_mapped_range;

+   functions->UnmapBuffer = st_bufferobj_unmap;

+   functions->CopyBufferSubData = st_copy_buffer_subdata;

+

+   /* For GL_APPLE_vertex_array_object */

+   functions->NewArrayObject = _mesa_new_array_object;

+   functions->DeleteArrayObject = _mesa_delete_array_object;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_clear.c b/mesalib/src/mesa/state_tracker/st_cb_clear.c
index 0e0c4326e..79e58182f 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_clear.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_clear.c
@@ -1,579 +1,579 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- * Copyright 2009 VMware, Inc.  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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  *   Michel Dänzer
-  */
-
-#include "main/glheader.h"
-#include "main/formats.h"
-#include "main/macros.h"
-#include "program/prog_instruction.h"
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_accum.h"
-#include "st_cb_clear.h"
-#include "st_cb_fbo.h"
-#include "st_format.h"
-#include "st_program.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_shader_tokens.h"
-#include "pipe/p_state.h"
-#include "pipe/p_defines.h"
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_simple_shaders.h"
-#include "util/u_draw_quad.h"
-
-#include "cso_cache/cso_context.h"
-
-
-/**
- * Do per-context initialization for glClear.
- */
-void
-st_init_clear(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *pscreen = st->pipe->screen;
-
-   memset(&st->clear, 0, sizeof(st->clear));
-
-   st->clear.raster.gl_rasterization_rules = 1;
-   st->clear.enable_ds_separate = pscreen->get_param(pscreen, PIPE_CAP_DEPTHSTENCIL_CLEAR_SEPARATE);
-
-   /* fragment shader state: color pass-through program */
-   st->clear.fs = util_make_fragment_passthrough_shader(pipe);
-
-   /* vertex shader state: color/position pass-through */
-   {
-      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
-                                      TGSI_SEMANTIC_COLOR };
-      const uint semantic_indexes[] = { 0, 0 };
-      st->clear.vs = util_make_vertex_passthrough_shader(pipe, 2,
-                                                         semantic_names,
-                                                         semantic_indexes);
-   }
-}
-
-
-/**
- * Free per-context state for glClear.
- */
-void
-st_destroy_clear(struct st_context *st)
-{
-   if (st->clear.fs) {
-      cso_delete_fragment_shader(st->cso_context, st->clear.fs);
-      st->clear.fs = NULL;
-   }
-   if (st->clear.vs) {
-      cso_delete_vertex_shader(st->cso_context, st->clear.vs);
-      st->clear.vs = NULL;
-   }
-   if (st->clear.vbuf) {
-      pipe_resource_reference(&st->clear.vbuf, NULL);
-      st->clear.vbuf = NULL;
-   }
-}
-
-
-/**
- * Draw a screen-aligned quadrilateral.
- * Coords are clip coords with y=0=bottom.
- */
-static void
-draw_quad(struct st_context *st,
-          float x0, float y0, float x1, float y1, GLfloat z,
-          const GLfloat color[4])
-{
-   struct pipe_context *pipe = st->pipe;
-
-   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as
-    * no_flush) updates to buffers where we know there is no conflict
-    * with previous data.  Currently using max_slots > 1 will cause
-    * synchronous rendering if the driver flushes its command buffers
-    * between one bitmap and the next.  Our flush hook below isn't
-    * sufficient to catch this as the driver doesn't tell us when it
-    * flushes its own command buffers.  Until this gets fixed, pay the
-    * price of allocating a new buffer for each bitmap cache-flush to
-    * avoid synchronous rendering.
-    */
-   const GLuint max_slots = 1; /* 1024 / sizeof(st->clear.vertices); */
-   GLuint i;
-
-   if (st->clear.vbuf_slot >= max_slots) {
-      pipe_resource_reference(&st->clear.vbuf, NULL);
-      st->clear.vbuf_slot = 0;
-   }
-
-   if (!st->clear.vbuf) {
-      st->clear.vbuf = pipe_buffer_create(pipe->screen,
-                                          PIPE_BIND_VERTEX_BUFFER,
-                                          PIPE_USAGE_STREAM,
-                                          max_slots * sizeof(st->clear.vertices));
-   }
-
-   /* positions */
-   st->clear.vertices[0][0][0] = x0;
-   st->clear.vertices[0][0][1] = y0;
-
-   st->clear.vertices[1][0][0] = x1;
-   st->clear.vertices[1][0][1] = y0;
-
-   st->clear.vertices[2][0][0] = x1;
-   st->clear.vertices[2][0][1] = y1;
-
-   st->clear.vertices[3][0][0] = x0;
-   st->clear.vertices[3][0][1] = y1;
-
-   /* same for all verts: */
-   for (i = 0; i < 4; i++) {
-      st->clear.vertices[i][0][2] = z;
-      st->clear.vertices[i][0][3] = 1.0;
-      st->clear.vertices[i][1][0] = color[0];
-      st->clear.vertices[i][1][1] = color[1];
-      st->clear.vertices[i][1][2] = color[2];
-      st->clear.vertices[i][1][3] = color[3];
-   }
-
-   /* put vertex data into vbuf */
-   pipe_buffer_write_nooverlap(st->pipe, st->clear.vbuf,
-                                           st->clear.vbuf_slot
-                                             * sizeof(st->clear.vertices),
-                                           sizeof(st->clear.vertices),
-                                           st->clear.vertices);
-
-   /* draw */
-   util_draw_vertex_buffer(pipe,
-                           st->cso_context,
-                           st->clear.vbuf, 
-                           st->clear.vbuf_slot * sizeof(st->clear.vertices),
-                           PIPE_PRIM_TRIANGLE_FAN,
-                           4,  /* verts */
-                           2); /* attribs/vert */
-
-   /* Increment slot */
-   st->clear.vbuf_slot++;
-}
-
-
-
-/**
- * Do glClear by drawing a quadrilateral.
- * The vertices of the quad will be computed from the
- * ctx->DrawBuffer->_X/Ymin/max fields.
- */
-static void
-clear_with_quad(struct gl_context *ctx,
-                GLboolean color, GLboolean depth, GLboolean stencil)
-{
-   struct st_context *st = st_context(ctx);
-   const struct gl_framebuffer *fb = ctx->DrawBuffer;
-   const GLfloat fb_width = (GLfloat) fb->Width;
-   const GLfloat fb_height = (GLfloat) fb->Height;
-   const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin / fb_width * 2.0f - 1.0f;
-   const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax / fb_width * 2.0f - 1.0f;
-   const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin / fb_height * 2.0f - 1.0f;
-   const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax / fb_height * 2.0f - 1.0f;
-   float clearColor[4];
-
-   /*
-   printf("%s %s%s%s %f,%f %f,%f\n", __FUNCTION__, 
-	  color ? "color, " : "",
-	  depth ? "depth, " : "",
-	  stencil ? "stencil" : "",
-	  x0, y0,
-	  x1, y1);
-   */
-
-   cso_save_blend(st->cso_context);
-   cso_save_stencil_ref(st->cso_context);
-   cso_save_depth_stencil_alpha(st->cso_context);
-   cso_save_rasterizer(st->cso_context);
-   cso_save_viewport(st->cso_context);
-   cso_save_clip(st->cso_context);
-   cso_save_fragment_shader(st->cso_context);
-   cso_save_vertex_shader(st->cso_context);
-   cso_save_vertex_elements(st->cso_context);
-   cso_save_vertex_buffers(st->cso_context);
-
-   /* blend state: RGBA masking */
-   {
-      struct pipe_blend_state blend;
-      memset(&blend, 0, sizeof(blend));
-      blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-      blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
-      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-      if (color) {
-         if (ctx->Color.ColorMask[0][0])
-            blend.rt[0].colormask |= PIPE_MASK_R;
-         if (ctx->Color.ColorMask[0][1])
-            blend.rt[0].colormask |= PIPE_MASK_G;
-         if (ctx->Color.ColorMask[0][2])
-            blend.rt[0].colormask |= PIPE_MASK_B;
-         if (ctx->Color.ColorMask[0][3])
-            blend.rt[0].colormask |= PIPE_MASK_A;
-         if (st->ctx->Color.DitherFlag)
-            blend.dither = 1;
-      }
-      cso_set_blend(st->cso_context, &blend);
-   }
-
-   /* depth_stencil state: always pass/set to ref value */
-   {
-      struct pipe_depth_stencil_alpha_state depth_stencil;
-      memset(&depth_stencil, 0, sizeof(depth_stencil));
-      if (depth) {
-         depth_stencil.depth.enabled = 1;
-         depth_stencil.depth.writemask = 1;
-         depth_stencil.depth.func = PIPE_FUNC_ALWAYS;
-      }
-
-      if (stencil) {
-         struct pipe_stencil_ref stencil_ref;
-         memset(&stencil_ref, 0, sizeof(stencil_ref));
-         depth_stencil.stencil[0].enabled = 1;
-         depth_stencil.stencil[0].func = PIPE_FUNC_ALWAYS;
-         depth_stencil.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;
-         depth_stencil.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
-         depth_stencil.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;
-         depth_stencil.stencil[0].valuemask = 0xff;
-         depth_stencil.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;
-         stencil_ref.ref_value[0] = ctx->Stencil.Clear;
-         cso_set_stencil_ref(st->cso_context, &stencil_ref);
-      }
-
-      cso_set_depth_stencil_alpha(st->cso_context, &depth_stencil);
-   }
-
-   cso_set_vertex_elements(st->cso_context, 2, st->velems_util_draw);
-
-   cso_set_rasterizer(st->cso_context, &st->clear.raster);
-
-   /* viewport state: viewport matching window dims */
-   {
-      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);
-      struct pipe_viewport_state vp;
-      vp.scale[0] = 0.5f * fb_width;
-      vp.scale[1] = fb_height * (invert ? -0.5f : 0.5f);
-      vp.scale[2] = 1.0f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * fb_width;
-      vp.translate[1] = 0.5f * fb_height;
-      vp.translate[2] = 0.0f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(st->cso_context, &vp);
-   }
-
-   cso_set_clip(st->cso_context, &st->clear.clip);
-   cso_set_fragment_shader_handle(st->cso_context, st->clear.fs);
-   cso_set_vertex_shader_handle(st->cso_context, st->clear.vs);
-
-   if (ctx->DrawBuffer->_ColorDrawBuffers[0]) {
-      st_translate_color(ctx->Color.ClearColor,
-                         ctx->DrawBuffer->_ColorDrawBuffers[0]->_BaseFormat,
-                         clearColor);
-   }
-
-   /* draw quad matching scissor rect */
-   draw_quad(st, x0, y0, x1, y1, (GLfloat) ctx->Depth.Clear, clearColor);
-
-   /* Restore pipe state */
-   cso_restore_blend(st->cso_context);
-   cso_restore_stencil_ref(st->cso_context);
-   cso_restore_depth_stencil_alpha(st->cso_context);
-   cso_restore_rasterizer(st->cso_context);
-   cso_restore_viewport(st->cso_context);
-   cso_restore_clip(st->cso_context);
-   cso_restore_fragment_shader(st->cso_context);
-   cso_restore_vertex_shader(st->cso_context);
-   cso_restore_vertex_elements(st->cso_context);
-   cso_restore_vertex_buffers(st->cso_context);
-}
-
-
-/**
- * Determine if we need to clear the depth buffer by drawing a quad.
- */
-static INLINE GLboolean
-check_clear_color_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb)
-{
-   if (ctx->Scissor.Enabled &&
-       (ctx->Scissor.X != 0 ||
-        ctx->Scissor.Y != 0 ||
-        ctx->Scissor.Width < rb->Width ||
-        ctx->Scissor.Height < rb->Height))
-      return GL_TRUE;
-
-   if (!ctx->Color.ColorMask[0][0] ||
-       !ctx->Color.ColorMask[0][1] ||
-       !ctx->Color.ColorMask[0][2] ||
-       !ctx->Color.ColorMask[0][3])
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-/**
- * Determine if we need to clear the combiend depth/stencil buffer by
- * drawing a quad.
- */
-static INLINE GLboolean
-check_clear_depth_stencil_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb)
-{
-   const GLuint stencilMax = 0xff;
-   GLboolean maskStencil
-      = (ctx->Stencil.WriteMask[0] & stencilMax) != stencilMax;
-
-   assert(rb->Format == MESA_FORMAT_S8 ||
-          rb->Format == MESA_FORMAT_Z24_S8 ||
-          rb->Format == MESA_FORMAT_S8_Z24);
-
-   if (ctx->Scissor.Enabled &&
-       (ctx->Scissor.X != 0 ||
-        ctx->Scissor.Y != 0 ||
-        ctx->Scissor.Width < rb->Width ||
-        ctx->Scissor.Height < rb->Height))
-      return GL_TRUE;
-
-   if (maskStencil)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-/**
- * Determine if we need to clear the depth buffer by drawing a quad.
- */
-static INLINE GLboolean
-check_clear_depth_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                            boolean ds_separate)
-{
-   const struct st_renderbuffer *strb = st_renderbuffer(rb);
-   const GLboolean isDS = util_format_is_depth_and_stencil(strb->surface->format);
-
-   if (ctx->Scissor.Enabled &&
-       (ctx->Scissor.X != 0 ||
-        ctx->Scissor.Y != 0 ||
-        ctx->Scissor.Width < rb->Width ||
-        ctx->Scissor.Height < rb->Height))
-      return GL_TRUE;
-
-   if (!ds_separate && isDS && ctx->DrawBuffer->Visual.stencilBits > 0)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-/**
- * Determine if we need to clear the stencil buffer by drawing a quad.
- */
-static INLINE GLboolean
-check_clear_stencil_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                              boolean ds_separate)
-{
-   const struct st_renderbuffer *strb = st_renderbuffer(rb);
-   const GLboolean isDS = util_format_is_depth_and_stencil(strb->surface->format);
-   const GLuint stencilMax = 0xff;
-   const GLboolean maskStencil
-      = (ctx->Stencil.WriteMask[0] & stencilMax) != stencilMax;
-
-   assert(rb->Format == MESA_FORMAT_S8 ||
-          rb->Format == MESA_FORMAT_Z24_S8 ||
-          rb->Format == MESA_FORMAT_S8_Z24);
-
-   if (maskStencil) 
-      return GL_TRUE;
-
-   if (ctx->Scissor.Enabled &&
-       (ctx->Scissor.X != 0 ||
-        ctx->Scissor.Y != 0 ||
-        ctx->Scissor.Width < rb->Width ||
-        ctx->Scissor.Height < rb->Height))
-      return GL_TRUE;
-
-   /* This is correct, but it is necessary to look at the depth clear
-    * value held in the surface when it comes time to issue the clear,
-    * rather than taking depth and stencil clear values from the
-    * current state.
-    */
-   if (!ds_separate && isDS && ctx->DrawBuffer->Visual.depthBits > 0)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-
-/**
- * Called when we need to flush.
- */
-void
-st_flush_clear(struct st_context *st)
-{
-   /* Release vertex buffer to avoid synchronous rendering if we were
-    * to map it in the next frame.
-    */
-   pipe_resource_reference(&st->clear.vbuf, NULL);
-   st->clear.vbuf_slot = 0;
-}
- 
-
-
-/**
- * Called via ctx->Driver.Clear()
- */
-static void
-st_Clear(struct gl_context *ctx, GLbitfield mask)
-{
-   static const GLbitfield BUFFER_BITS_DS
-      = (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL);
-   struct st_context *st = st_context(ctx);
-   struct gl_renderbuffer *depthRb
-      = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-   struct gl_renderbuffer *stencilRb
-      = ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-   GLbitfield quad_buffers = 0x0;
-   GLbitfield clear_buffers = 0x0;
-   GLuint i;
-
-   /* This makes sure the pipe has the latest scissor, etc values */
-   st_validate_state( st );
-
-   if (mask & BUFFER_BITS_COLOR) {
-      for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {
-         GLuint b = ctx->DrawBuffer->_ColorDrawBufferIndexes[i];
-
-         if (mask & (1 << b)) {
-            struct gl_renderbuffer *rb
-               = ctx->DrawBuffer->Attachment[b].Renderbuffer;
-            struct st_renderbuffer *strb = st_renderbuffer(rb);
-
-            if (!strb || !strb->surface)
-               continue;
-
-            if (check_clear_color_with_quad( ctx, rb ))
-               quad_buffers |= PIPE_CLEAR_COLOR;
-            else
-               clear_buffers |= PIPE_CLEAR_COLOR;
-         }
-      }
-   }
-
-   if ((mask & BUFFER_BITS_DS) == BUFFER_BITS_DS && depthRb == stencilRb) {
-      /* clearing combined depth + stencil */
-      struct st_renderbuffer *strb = st_renderbuffer(depthRb);
-
-      if (strb->surface) {
-         if (check_clear_depth_stencil_with_quad(ctx, depthRb))
-            quad_buffers |= PIPE_CLEAR_DEPTHSTENCIL;
-         else
-            clear_buffers |= PIPE_CLEAR_DEPTHSTENCIL;
-      }
-   }
-   else {
-      /* separate depth/stencil clears */
-      /* I don't think truly separate buffers are actually possible in gallium or hw? */
-      if (mask & BUFFER_BIT_DEPTH) {
-         struct st_renderbuffer *strb = st_renderbuffer(depthRb);
-
-         if (strb->surface) {
-            if (check_clear_depth_with_quad(ctx, depthRb,
-                                            st->clear.enable_ds_separate))
-               quad_buffers |= PIPE_CLEAR_DEPTH;
-            else
-               clear_buffers |= PIPE_CLEAR_DEPTH;
-         }
-      }
-      if (mask & BUFFER_BIT_STENCIL) {
-         struct st_renderbuffer *strb = st_renderbuffer(stencilRb);
-
-         if (strb->surface) {
-            if (check_clear_stencil_with_quad(ctx, stencilRb,
-                                              st->clear.enable_ds_separate))
-               quad_buffers |= PIPE_CLEAR_STENCIL;
-            else
-               clear_buffers |= PIPE_CLEAR_STENCIL;
-         }
-      }
-   }
-
-   /*
-    * If we're going to use clear_with_quad() for any reason, use it for
-    * everything possible.
-    */
-   if (quad_buffers) {
-      quad_buffers |= clear_buffers;
-      clear_with_quad(ctx,
-                      quad_buffers & PIPE_CLEAR_COLOR,
-                      quad_buffers & PIPE_CLEAR_DEPTH,
-                      quad_buffers & PIPE_CLEAR_STENCIL);
-   } else if (clear_buffers) {
-      /* driver cannot know it can clear everything if the buffer
-       * is a combined depth/stencil buffer but this wasn't actually
-       * required from the visual. Hence fix this up to avoid potential
-       * read-modify-write in the driver.
-       */
-      float clearColor[4];
-
-      if ((clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) &&
-          ((clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
-          (depthRb == stencilRb) &&
-          (ctx->DrawBuffer->Visual.depthBits == 0 ||
-           ctx->DrawBuffer->Visual.stencilBits == 0))
-         clear_buffers |= PIPE_CLEAR_DEPTHSTENCIL;
-
-      if (ctx->DrawBuffer->_ColorDrawBuffers[0]) {
-         st_translate_color(ctx->Color.ClearColor,
-                            ctx->DrawBuffer->_ColorDrawBuffers[0]->_BaseFormat,
-                            clearColor);
-      }
-
-      st->pipe->clear(st->pipe, clear_buffers, ctx->Color.ClearColor,
-                      ctx->Depth.Clear, ctx->Stencil.Clear);
-   }
-   if (mask & BUFFER_BIT_ACCUM)
-      st_clear_accum_buffer(ctx,
-                            ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);
-}
-
-
-void
-st_init_clear_functions(struct dd_function_table *functions)
-{
-   functions->Clear = st_Clear;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * All Rights Reserved.

+ * Copyright 2009 VMware, Inc.  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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  *   Michel Dänzer

+  */

+

+#include "main/glheader.h"

+#include "main/formats.h"

+#include "main/macros.h"

+#include "program/prog_instruction.h"

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_accum.h"

+#include "st_cb_clear.h"

+#include "st_cb_fbo.h"

+#include "st_format.h"

+#include "st_program.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_shader_tokens.h"

+#include "pipe/p_state.h"

+#include "pipe/p_defines.h"

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_simple_shaders.h"

+#include "util/u_draw_quad.h"

+

+#include "cso_cache/cso_context.h"

+

+

+/**

+ * Do per-context initialization for glClear.

+ */

+void

+st_init_clear(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *pscreen = st->pipe->screen;

+

+   memset(&st->clear, 0, sizeof(st->clear));

+

+   st->clear.raster.gl_rasterization_rules = 1;

+   st->clear.enable_ds_separate = pscreen->get_param(pscreen, PIPE_CAP_DEPTHSTENCIL_CLEAR_SEPARATE);

+

+   /* fragment shader state: color pass-through program */

+   st->clear.fs = util_make_fragment_passthrough_shader(pipe);

+

+   /* vertex shader state: color/position pass-through */

+   {

+      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,

+                                      TGSI_SEMANTIC_COLOR };

+      const uint semantic_indexes[] = { 0, 0 };

+      st->clear.vs = util_make_vertex_passthrough_shader(pipe, 2,

+                                                         semantic_names,

+                                                         semantic_indexes);

+   }

+}

+

+

+/**

+ * Free per-context state for glClear.

+ */

+void

+st_destroy_clear(struct st_context *st)

+{

+   if (st->clear.fs) {

+      cso_delete_fragment_shader(st->cso_context, st->clear.fs);

+      st->clear.fs = NULL;

+   }

+   if (st->clear.vs) {

+      cso_delete_vertex_shader(st->cso_context, st->clear.vs);

+      st->clear.vs = NULL;

+   }

+   if (st->clear.vbuf) {

+      pipe_resource_reference(&st->clear.vbuf, NULL);

+      st->clear.vbuf = NULL;

+   }

+}

+

+

+/**

+ * Draw a screen-aligned quadrilateral.

+ * Coords are clip coords with y=0=bottom.

+ */

+static void

+draw_quad(struct st_context *st,

+          float x0, float y0, float x1, float y1, GLfloat z,

+          const GLfloat color[4])

+{

+   struct pipe_context *pipe = st->pipe;

+

+   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as

+    * no_flush) updates to buffers where we know there is no conflict

+    * with previous data.  Currently using max_slots > 1 will cause

+    * synchronous rendering if the driver flushes its command buffers

+    * between one bitmap and the next.  Our flush hook below isn't

+    * sufficient to catch this as the driver doesn't tell us when it

+    * flushes its own command buffers.  Until this gets fixed, pay the

+    * price of allocating a new buffer for each bitmap cache-flush to

+    * avoid synchronous rendering.

+    */

+   const GLuint max_slots = 1; /* 1024 / sizeof(st->clear.vertices); */

+   GLuint i;

+

+   if (st->clear.vbuf_slot >= max_slots) {

+      pipe_resource_reference(&st->clear.vbuf, NULL);

+      st->clear.vbuf_slot = 0;

+   }

+

+   if (!st->clear.vbuf) {

+      st->clear.vbuf = pipe_buffer_create(pipe->screen,

+                                          PIPE_BIND_VERTEX_BUFFER,

+                                          PIPE_USAGE_STREAM,

+                                          max_slots * sizeof(st->clear.vertices));

+   }

+

+   /* positions */

+   st->clear.vertices[0][0][0] = x0;

+   st->clear.vertices[0][0][1] = y0;

+

+   st->clear.vertices[1][0][0] = x1;

+   st->clear.vertices[1][0][1] = y0;

+

+   st->clear.vertices[2][0][0] = x1;

+   st->clear.vertices[2][0][1] = y1;

+

+   st->clear.vertices[3][0][0] = x0;

+   st->clear.vertices[3][0][1] = y1;

+

+   /* same for all verts: */

+   for (i = 0; i < 4; i++) {

+      st->clear.vertices[i][0][2] = z;

+      st->clear.vertices[i][0][3] = 1.0;

+      st->clear.vertices[i][1][0] = color[0];

+      st->clear.vertices[i][1][1] = color[1];

+      st->clear.vertices[i][1][2] = color[2];

+      st->clear.vertices[i][1][3] = color[3];

+   }

+

+   /* put vertex data into vbuf */

+   pipe_buffer_write_nooverlap(st->pipe, st->clear.vbuf,

+                                           st->clear.vbuf_slot

+                                             * sizeof(st->clear.vertices),

+                                           sizeof(st->clear.vertices),

+                                           st->clear.vertices);

+

+   /* draw */

+   util_draw_vertex_buffer(pipe,

+                           st->cso_context,

+                           st->clear.vbuf, 

+                           st->clear.vbuf_slot * sizeof(st->clear.vertices),

+                           PIPE_PRIM_TRIANGLE_FAN,

+                           4,  /* verts */

+                           2); /* attribs/vert */

+

+   /* Increment slot */

+   st->clear.vbuf_slot++;

+}

+

+

+

+/**

+ * Do glClear by drawing a quadrilateral.

+ * The vertices of the quad will be computed from the

+ * ctx->DrawBuffer->_X/Ymin/max fields.

+ */

+static void

+clear_with_quad(struct gl_context *ctx,

+                GLboolean color, GLboolean depth, GLboolean stencil)

+{

+   struct st_context *st = st_context(ctx);

+   const struct gl_framebuffer *fb = ctx->DrawBuffer;

+   const GLfloat fb_width = (GLfloat) fb->Width;

+   const GLfloat fb_height = (GLfloat) fb->Height;

+   const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin / fb_width * 2.0f - 1.0f;

+   const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax / fb_width * 2.0f - 1.0f;

+   const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin / fb_height * 2.0f - 1.0f;

+   const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax / fb_height * 2.0f - 1.0f;

+   float clearColor[4];

+

+   /*

+   printf("%s %s%s%s %f,%f %f,%f\n", __FUNCTION__, 

+	  color ? "color, " : "",

+	  depth ? "depth, " : "",

+	  stencil ? "stencil" : "",

+	  x0, y0,

+	  x1, y1);

+   */

+

+   cso_save_blend(st->cso_context);

+   cso_save_stencil_ref(st->cso_context);

+   cso_save_depth_stencil_alpha(st->cso_context);

+   cso_save_rasterizer(st->cso_context);

+   cso_save_viewport(st->cso_context);

+   cso_save_clip(st->cso_context);

+   cso_save_fragment_shader(st->cso_context);

+   cso_save_vertex_shader(st->cso_context);

+   cso_save_vertex_elements(st->cso_context);

+   cso_save_vertex_buffers(st->cso_context);

+

+   /* blend state: RGBA masking */

+   {

+      struct pipe_blend_state blend;

+      memset(&blend, 0, sizeof(blend));

+      blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;

+      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;

+      blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;

+      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;

+      if (color) {

+         if (ctx->Color.ColorMask[0][0])

+            blend.rt[0].colormask |= PIPE_MASK_R;

+         if (ctx->Color.ColorMask[0][1])

+            blend.rt[0].colormask |= PIPE_MASK_G;

+         if (ctx->Color.ColorMask[0][2])

+            blend.rt[0].colormask |= PIPE_MASK_B;

+         if (ctx->Color.ColorMask[0][3])

+            blend.rt[0].colormask |= PIPE_MASK_A;

+         if (st->ctx->Color.DitherFlag)

+            blend.dither = 1;

+      }

+      cso_set_blend(st->cso_context, &blend);

+   }

+

+   /* depth_stencil state: always pass/set to ref value */

+   {

+      struct pipe_depth_stencil_alpha_state depth_stencil;

+      memset(&depth_stencil, 0, sizeof(depth_stencil));

+      if (depth) {

+         depth_stencil.depth.enabled = 1;

+         depth_stencil.depth.writemask = 1;

+         depth_stencil.depth.func = PIPE_FUNC_ALWAYS;

+      }

+

+      if (stencil) {

+         struct pipe_stencil_ref stencil_ref;

+         memset(&stencil_ref, 0, sizeof(stencil_ref));

+         depth_stencil.stencil[0].enabled = 1;

+         depth_stencil.stencil[0].func = PIPE_FUNC_ALWAYS;

+         depth_stencil.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;

+         depth_stencil.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;

+         depth_stencil.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;

+         depth_stencil.stencil[0].valuemask = 0xff;

+         depth_stencil.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;

+         stencil_ref.ref_value[0] = ctx->Stencil.Clear;

+         cso_set_stencil_ref(st->cso_context, &stencil_ref);

+      }

+

+      cso_set_depth_stencil_alpha(st->cso_context, &depth_stencil);

+   }

+

+   cso_set_vertex_elements(st->cso_context, 2, st->velems_util_draw);

+

+   cso_set_rasterizer(st->cso_context, &st->clear.raster);

+

+   /* viewport state: viewport matching window dims */

+   {

+      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);

+      struct pipe_viewport_state vp;

+      vp.scale[0] = 0.5f * fb_width;

+      vp.scale[1] = fb_height * (invert ? -0.5f : 0.5f);

+      vp.scale[2] = 1.0f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * fb_width;

+      vp.translate[1] = 0.5f * fb_height;

+      vp.translate[2] = 0.0f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(st->cso_context, &vp);

+   }

+

+   cso_set_clip(st->cso_context, &st->clear.clip);

+   cso_set_fragment_shader_handle(st->cso_context, st->clear.fs);

+   cso_set_vertex_shader_handle(st->cso_context, st->clear.vs);

+

+   if (ctx->DrawBuffer->_ColorDrawBuffers[0]) {

+      st_translate_color(ctx->Color.ClearColor,

+                         ctx->DrawBuffer->_ColorDrawBuffers[0]->_BaseFormat,

+                         clearColor);

+   }

+

+   /* draw quad matching scissor rect */

+   draw_quad(st, x0, y0, x1, y1, (GLfloat) ctx->Depth.Clear, clearColor);

+

+   /* Restore pipe state */

+   cso_restore_blend(st->cso_context);

+   cso_restore_stencil_ref(st->cso_context);

+   cso_restore_depth_stencil_alpha(st->cso_context);

+   cso_restore_rasterizer(st->cso_context);

+   cso_restore_viewport(st->cso_context);

+   cso_restore_clip(st->cso_context);

+   cso_restore_fragment_shader(st->cso_context);

+   cso_restore_vertex_shader(st->cso_context);

+   cso_restore_vertex_elements(st->cso_context);

+   cso_restore_vertex_buffers(st->cso_context);

+}

+

+

+/**

+ * Determine if we need to clear the depth buffer by drawing a quad.

+ */

+static INLINE GLboolean

+check_clear_color_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb)

+{

+   if (ctx->Scissor.Enabled &&

+       (ctx->Scissor.X != 0 ||

+        ctx->Scissor.Y != 0 ||

+        ctx->Scissor.Width < rb->Width ||

+        ctx->Scissor.Height < rb->Height))

+      return GL_TRUE;

+

+   if (!ctx->Color.ColorMask[0][0] ||

+       !ctx->Color.ColorMask[0][1] ||

+       !ctx->Color.ColorMask[0][2] ||

+       !ctx->Color.ColorMask[0][3])

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Determine if we need to clear the combiend depth/stencil buffer by

+ * drawing a quad.

+ */

+static INLINE GLboolean

+check_clear_depth_stencil_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb)

+{

+   const GLuint stencilMax = 0xff;

+   GLboolean maskStencil

+      = (ctx->Stencil.WriteMask[0] & stencilMax) != stencilMax;

+

+   assert(rb->Format == MESA_FORMAT_S8 ||

+          rb->Format == MESA_FORMAT_Z24_S8 ||

+          rb->Format == MESA_FORMAT_S8_Z24);

+

+   if (ctx->Scissor.Enabled &&

+       (ctx->Scissor.X != 0 ||

+        ctx->Scissor.Y != 0 ||

+        ctx->Scissor.Width < rb->Width ||

+        ctx->Scissor.Height < rb->Height))

+      return GL_TRUE;

+

+   if (maskStencil)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Determine if we need to clear the depth buffer by drawing a quad.

+ */

+static INLINE GLboolean

+check_clear_depth_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                            boolean ds_separate)

+{

+   const struct st_renderbuffer *strb = st_renderbuffer(rb);

+   const GLboolean isDS = util_format_is_depth_and_stencil(strb->surface->format);

+

+   if (ctx->Scissor.Enabled &&

+       (ctx->Scissor.X != 0 ||

+        ctx->Scissor.Y != 0 ||

+        ctx->Scissor.Width < rb->Width ||

+        ctx->Scissor.Height < rb->Height))

+      return GL_TRUE;

+

+   if (!ds_separate && isDS && ctx->DrawBuffer->Visual.stencilBits > 0)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Determine if we need to clear the stencil buffer by drawing a quad.

+ */

+static INLINE GLboolean

+check_clear_stencil_with_quad(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                              boolean ds_separate)

+{

+   const struct st_renderbuffer *strb = st_renderbuffer(rb);

+   const GLboolean isDS = util_format_is_depth_and_stencil(strb->surface->format);

+   const GLuint stencilMax = 0xff;

+   const GLboolean maskStencil

+      = (ctx->Stencil.WriteMask[0] & stencilMax) != stencilMax;

+

+   assert(rb->Format == MESA_FORMAT_S8 ||

+          rb->Format == MESA_FORMAT_Z24_S8 ||

+          rb->Format == MESA_FORMAT_S8_Z24);

+

+   if (maskStencil) 

+      return GL_TRUE;

+

+   if (ctx->Scissor.Enabled &&

+       (ctx->Scissor.X != 0 ||

+        ctx->Scissor.Y != 0 ||

+        ctx->Scissor.Width < rb->Width ||

+        ctx->Scissor.Height < rb->Height))

+      return GL_TRUE;

+

+   /* This is correct, but it is necessary to look at the depth clear

+    * value held in the surface when it comes time to issue the clear,

+    * rather than taking depth and stencil clear values from the

+    * current state.

+    */

+   if (!ds_separate && isDS && ctx->DrawBuffer->Visual.depthBits > 0)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+

+/**

+ * Called when we need to flush.

+ */

+void

+st_flush_clear(struct st_context *st)

+{

+   /* Release vertex buffer to avoid synchronous rendering if we were

+    * to map it in the next frame.

+    */

+   pipe_resource_reference(&st->clear.vbuf, NULL);

+   st->clear.vbuf_slot = 0;

+}

+ 

+

+

+/**

+ * Called via ctx->Driver.Clear()

+ */

+static void

+st_Clear(struct gl_context *ctx, GLbitfield mask)

+{

+   static const GLbitfield BUFFER_BITS_DS

+      = (BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL);

+   struct st_context *st = st_context(ctx);

+   struct gl_renderbuffer *depthRb

+      = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+   struct gl_renderbuffer *stencilRb

+      = ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;

+   GLbitfield quad_buffers = 0x0;

+   GLbitfield clear_buffers = 0x0;

+   GLuint i;

+

+   /* This makes sure the pipe has the latest scissor, etc values */

+   st_validate_state( st );

+

+   if (mask & BUFFER_BITS_COLOR) {

+      for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {

+         GLuint b = ctx->DrawBuffer->_ColorDrawBufferIndexes[i];

+

+         if (mask & (1 << b)) {

+            struct gl_renderbuffer *rb

+               = ctx->DrawBuffer->Attachment[b].Renderbuffer;

+            struct st_renderbuffer *strb = st_renderbuffer(rb);

+

+            if (!strb || !strb->surface)

+               continue;

+

+            if (check_clear_color_with_quad( ctx, rb ))

+               quad_buffers |= PIPE_CLEAR_COLOR;

+            else

+               clear_buffers |= PIPE_CLEAR_COLOR;

+         }

+      }

+   }

+

+   if ((mask & BUFFER_BITS_DS) == BUFFER_BITS_DS && depthRb == stencilRb) {

+      /* clearing combined depth + stencil */

+      struct st_renderbuffer *strb = st_renderbuffer(depthRb);

+

+      if (strb->surface) {

+         if (check_clear_depth_stencil_with_quad(ctx, depthRb))

+            quad_buffers |= PIPE_CLEAR_DEPTHSTENCIL;

+         else

+            clear_buffers |= PIPE_CLEAR_DEPTHSTENCIL;

+      }

+   }

+   else {

+      /* separate depth/stencil clears */

+      /* I don't think truly separate buffers are actually possible in gallium or hw? */

+      if (mask & BUFFER_BIT_DEPTH) {

+         struct st_renderbuffer *strb = st_renderbuffer(depthRb);

+

+         if (strb->surface) {

+            if (check_clear_depth_with_quad(ctx, depthRb,

+                                            st->clear.enable_ds_separate))

+               quad_buffers |= PIPE_CLEAR_DEPTH;

+            else

+               clear_buffers |= PIPE_CLEAR_DEPTH;

+         }

+      }

+      if (mask & BUFFER_BIT_STENCIL) {

+         struct st_renderbuffer *strb = st_renderbuffer(stencilRb);

+

+         if (strb->surface) {

+            if (check_clear_stencil_with_quad(ctx, stencilRb,

+                                              st->clear.enable_ds_separate))

+               quad_buffers |= PIPE_CLEAR_STENCIL;

+            else

+               clear_buffers |= PIPE_CLEAR_STENCIL;

+         }

+      }

+   }

+

+   /*

+    * If we're going to use clear_with_quad() for any reason, use it for

+    * everything possible.

+    */

+   if (quad_buffers) {

+      quad_buffers |= clear_buffers;

+      clear_with_quad(ctx,

+                      quad_buffers & PIPE_CLEAR_COLOR,

+                      quad_buffers & PIPE_CLEAR_DEPTH,

+                      quad_buffers & PIPE_CLEAR_STENCIL);

+   } else if (clear_buffers) {

+      /* driver cannot know it can clear everything if the buffer

+       * is a combined depth/stencil buffer but this wasn't actually

+       * required from the visual. Hence fix this up to avoid potential

+       * read-modify-write in the driver.

+       */

+      float clearColor[4];

+

+      if ((clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) &&

+          ((clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&

+          (depthRb == stencilRb) &&

+          (ctx->DrawBuffer->Visual.depthBits == 0 ||

+           ctx->DrawBuffer->Visual.stencilBits == 0))

+         clear_buffers |= PIPE_CLEAR_DEPTHSTENCIL;

+

+      if (ctx->DrawBuffer->_ColorDrawBuffers[0]) {

+         st_translate_color(ctx->Color.ClearColor,

+                            ctx->DrawBuffer->_ColorDrawBuffers[0]->_BaseFormat,

+                            clearColor);

+      }

+

+      st->pipe->clear(st->pipe, clear_buffers, ctx->Color.ClearColor,

+                      ctx->Depth.Clear, ctx->Stencil.Clear);

+   }

+   if (mask & BUFFER_BIT_ACCUM)

+      st_clear_accum_buffer(ctx,

+                            ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer);

+}

+

+

+void

+st_init_clear_functions(struct dd_function_table *functions)

+{

+   functions->Clear = st_Clear;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index c2b4e1808..c5950304f 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -1,1488 +1,1488 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Brian Paul
-  */
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/bufferobj.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/pack.h"
-#include "main/pbo.h"
-#include "main/texformat.h"
-#include "main/texstore.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-#include "program/prog_instruction.h"
-
-#include "st_atom.h"
-#include "st_atom_constbuf.h"
-#include "st_cb_drawpixels.h"
-#include "st_cb_readpixels.h"
-#include "st_cb_fbo.h"
-#include "st_context.h"
-#include "st_debug.h"
-#include "st_format.h"
-#include "st_program.h"
-#include "st_texture.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "tgsi/tgsi_ureg.h"
-#include "util/u_draw_quad.h"
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_math.h"
-#include "util/u_tile.h"
-#include "cso_cache/cso_context.h"
-
-
-#if FEATURE_drawpix
-
-/**
- * Check if the given program is:
- * 0: MOVE result.color, fragment.color;
- * 1: END;
- */
-static GLboolean
-is_passthrough_program(const struct gl_fragment_program *prog)
-{
-   if (prog->Base.NumInstructions == 2) {
-      const struct prog_instruction *inst = prog->Base.Instructions;
-      if (inst[0].Opcode == OPCODE_MOV &&
-          inst[1].Opcode == OPCODE_END &&
-          inst[0].DstReg.File == PROGRAM_OUTPUT &&
-          inst[0].DstReg.Index == FRAG_RESULT_COLOR &&
-          inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&
-          inst[0].SrcReg[0].File == PROGRAM_INPUT &&
-          inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&
-          inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {
-         return GL_TRUE;
-      }
-   }
-   return GL_FALSE;
-}
-
-
-
-/**
- * Make fragment shader for glDraw/CopyPixels.  This shader is made
- * by combining the pixel transfer shader with the user-defined shader.
- * \param fpIn  the current/incoming fragment program
- * \param fpOut  returns the combined fragment program
- */
-void
-st_make_drawpix_fragment_program(struct st_context *st,
-                                 struct gl_fragment_program *fpIn,
-                                 struct gl_fragment_program **fpOut)
-{
-   struct gl_program *newProg;
-
-   if (is_passthrough_program(fpIn)) {
-      newProg = (struct gl_program *) _mesa_clone_fragment_program(st->ctx,
-                                             &st->pixel_xfer.program->Base);
-   }
-   else {
-#if 0
-      /* debug */
-      printf("Base program:\n");
-      _mesa_print_program(&fpIn->Base);
-      printf("DrawPix program:\n");
-      _mesa_print_program(&st->pixel_xfer.program->Base.Base);
-#endif
-      newProg = _mesa_combine_programs(st->ctx,
-                                       &st->pixel_xfer.program->Base.Base,
-                                       &fpIn->Base);
-   }
-
-#if 0
-   /* debug */
-   printf("Combined DrawPixels program:\n");
-   _mesa_print_program(newProg);
-   printf("InputsRead: 0x%x\n", newProg->InputsRead);
-   printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);
-   _mesa_print_parameter_list(newProg->Parameters);
-#endif
-
-   *fpOut = (struct gl_fragment_program *) newProg;
-}
-
-
-/**
- * Create fragment program that does a TEX() instruction to get a Z and/or
- * stencil value value, then writes to FRAG_RESULT_DEPTH/FRAG_RESULT_STENCIL.
- * Used for glDrawPixels(GL_DEPTH_COMPONENT / GL_STENCIL_INDEX).
- * Pass fragment color through as-is.
- * \return pointer to the gl_fragment program
- */
-struct gl_fragment_program *
-st_make_drawpix_z_stencil_program(struct st_context *st,
-                                  GLboolean write_depth,
-                                  GLboolean write_stencil)
-{
-   struct gl_context *ctx = st->ctx;
-   struct gl_program *p;
-   struct gl_fragment_program *fp;
-   GLuint ic = 0;
-   const GLuint shaderIndex = write_depth * 2 + write_stencil;
-
-   assert(shaderIndex < Elements(st->drawpix.shaders));
-
-   if (st->drawpix.shaders[shaderIndex]) {
-      /* already have the proper shader */
-      return st->drawpix.shaders[shaderIndex];
-   }
-
-   /*
-    * Create shader now
-    */
-   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = write_depth ? 2 : 1;
-   p->NumInstructions += write_stencil ? 1 : 0;
-
-   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, p->NumInstructions);
-
-   if (write_depth) {
-      /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */
-      p->Instructions[ic].Opcode = OPCODE_TEX;
-      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
-      p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;
-      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;
-      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-      p->Instructions[ic].TexSrcUnit = 0;
-      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-      ic++;
-   }
-
-   if (write_stencil) {
-      /* TEX result.stencil, fragment.texcoord[0], texture[0], 2D; */
-      p->Instructions[ic].Opcode = OPCODE_TEX;
-      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
-      p->Instructions[ic].DstReg.Index = FRAG_RESULT_STENCIL;
-      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Y;
-      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-      p->Instructions[ic].TexSrcUnit = 1;
-      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-      ic++;
-   }
-
-   /* END; */
-   p->Instructions[ic++].Opcode = OPCODE_END;
-
-   assert(ic == p->NumInstructions);
-
-   p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;
-   p->OutputsWritten = 0;
-   if (write_depth)
-      p->OutputsWritten |= (1 << FRAG_RESULT_DEPTH);
-   if (write_stencil)
-      p->OutputsWritten |= (1 << FRAG_RESULT_STENCIL);
-
-   p->SamplersUsed =  0x1;  /* sampler 0 (bit 0) is used */
-   if (write_stencil)
-      p->SamplersUsed |= 1 << 1;
-
-   fp = (struct gl_fragment_program *) p;
-
-   /* save the new shader */
-   st->drawpix.shaders[shaderIndex] = fp;
-
-   return fp;
-}
-
-
-/**
- * Create a simple vertex shader that just passes through the
- * vertex position and texcoord (and optionally, color).
- */
-static void *
-make_passthrough_vertex_shader(struct st_context *st, 
-                               GLboolean passColor)
-{
-   if (!st->drawpix.vert_shaders[passColor]) {
-      struct ureg_program *ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
-
-      if (ureg == NULL)
-         return NULL;
-
-      /* MOV result.pos, vertex.pos; */
-      ureg_MOV(ureg, 
-               ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),
-               ureg_DECL_vs_input( ureg, 0 ));
-      
-      /* MOV result.texcoord0, vertex.attr[1]; */
-      ureg_MOV(ureg, 
-               ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),
-               ureg_DECL_vs_input( ureg, 1 ));
-      
-      if (passColor) {
-         /* MOV result.color0, vertex.attr[2]; */
-         ureg_MOV(ureg, 
-                  ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),
-                  ureg_DECL_vs_input( ureg, 2 ));
-      }
-
-      ureg_END( ureg );
-      
-      st->drawpix.vert_shaders[passColor] = 
-         ureg_create_shader_and_destroy( ureg, st->pipe );
-   }
-
-   return st->drawpix.vert_shaders[passColor];
-}
-
-
-/**
- * Return a texture base format for drawing/copying an image
- * of the given format.
- */
-static GLenum
-base_format(GLenum format)
-{
-   switch (format) {
-   case GL_DEPTH_COMPONENT:
-      return GL_DEPTH_COMPONENT;
-   case GL_DEPTH_STENCIL:
-      return GL_DEPTH_STENCIL;
-   case GL_STENCIL_INDEX:
-      return GL_STENCIL_INDEX;
-   default:
-      return GL_RGBA;
-   }
-}
-
-
-/**
- * Return a texture internalFormat for drawing/copying an image
- * of the given format and type.
- */
-static GLenum
-internal_format(GLenum format, GLenum type)
-{
-   switch (format) {
-   case GL_DEPTH_COMPONENT:
-      return GL_DEPTH_COMPONENT;
-   case GL_DEPTH_STENCIL:
-      return GL_DEPTH_STENCIL;
-   case GL_STENCIL_INDEX:
-      return GL_STENCIL_INDEX;
-   default:
-      if (_mesa_is_integer_format(format)) {
-         switch (type) {
-         case GL_BYTE:
-            return GL_RGBA8I;
-         case GL_UNSIGNED_BYTE:
-            return GL_RGBA8UI;
-         case GL_SHORT:
-            return GL_RGBA16I;
-         case GL_UNSIGNED_SHORT:
-            return GL_RGBA16UI;
-         case GL_INT:
-            return GL_RGBA32I;
-         case GL_UNSIGNED_INT:
-            return GL_RGBA32UI;
-         default:
-            assert(0 && "Unexpected type in internal_format()");
-            return GL_RGBA_INTEGER;
-         }
-      }
-      else {
-         return GL_RGBA;
-      }
-   }
-}
-
-
-/**
- * Create a temporary texture to hold an image of the given size.
- * If width, height are not POT and the driver only handles POT textures,
- * allocate the next larger size of texture that is POT.
- */
-static struct pipe_resource *
-alloc_texture(struct st_context *st, GLsizei width, GLsizei height,
-              enum pipe_format texFormat)
-{
-   struct pipe_resource *pt;
-
-   pt = st_texture_create(st, st->internal_target, texFormat, 0,
-                          width, height, 1, 1, PIPE_BIND_SAMPLER_VIEW);
-
-   return pt;
-}
-
-
-/**
- * Make texture containing an image for glDrawPixels image.
- * If 'pixels' is NULL, leave the texture image data undefined.
- */
-static struct pipe_resource *
-make_texture(struct st_context *st,
-	     GLsizei width, GLsizei height, GLenum format, GLenum type,
-	     const struct gl_pixelstore_attrib *unpack,
-	     const GLvoid *pixels)
-{
-   struct gl_context *ctx = st->ctx;
-   struct pipe_context *pipe = st->pipe;
-   gl_format mformat;
-   struct pipe_resource *pt;
-   enum pipe_format pipeFormat;
-   GLuint cpp;
-   GLenum baseFormat, intFormat;
-
-   baseFormat = base_format(format);
-   intFormat = internal_format(format, type);
-
-   mformat = st_ChooseTextureFormat_renderable(ctx, intFormat,
-                                               format, type, GL_FALSE);
-   assert(mformat);
-
-   pipeFormat = st_mesa_format_to_pipe_format(mformat);
-   assert(pipeFormat);
-   cpp = util_format_get_blocksize(pipeFormat);
-
-   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
-   if (!pixels)
-      return NULL;
-
-   /* alloc temporary texture */
-   pt = alloc_texture(st, width, height, pipeFormat);
-   if (!pt) {
-      _mesa_unmap_pbo_source(ctx, unpack);
-      return NULL;
-   }
-
-   {
-      struct pipe_transfer *transfer;
-      static const GLuint dstImageOffsets = 0;
-      GLboolean success;
-      GLubyte *dest;
-      const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;
-
-      /* we'll do pixel transfer in a fragment shader */
-      ctx->_ImageTransferState = 0x0;
-
-      transfer = pipe_get_transfer(st->pipe, pt, 0, 0,
-                                   PIPE_TRANSFER_WRITE, 0, 0,
-                                   width, height);
-
-      /* map texture transfer */
-      dest = pipe_transfer_map(pipe, transfer);
-
-
-      /* Put image into texture transfer.
-       * Note that the image is actually going to be upside down in
-       * the texture.  We deal with that with texcoords.
-       */
-      success = _mesa_texstore(ctx, 2,           /* dims */
-                               baseFormat,       /* baseInternalFormat */
-                               mformat,          /* gl_format */
-                               dest,             /* dest */
-                               0, 0, 0,          /* dstX/Y/Zoffset */
-                               transfer->stride, /* dstRowStride, bytes */
-                               &dstImageOffsets, /* dstImageOffsets */
-                               width, height, 1, /* size */
-                               format, type,     /* src format/type */
-                               pixels,           /* data source */
-                               unpack);
-
-      /* unmap */
-      pipe_transfer_unmap(pipe, transfer);
-      pipe->transfer_destroy(pipe, transfer);
-
-      assert(success);
-
-      /* restore */
-      ctx->_ImageTransferState = imageTransferStateSave;
-   }
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-
-   return pt;
-}
-
-
-/**
- * Draw quad with texcoords and optional color.
- * Coords are gallium window coords with y=0=top.
- * \param color  may be null
- * \param invertTex  if true, flip texcoords vertically
- */
-static void
-draw_quad(struct gl_context *ctx, GLfloat x0, GLfloat y0, GLfloat z,
-          GLfloat x1, GLfloat y1, const GLfloat *color,
-          GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
-
-   /* setup vertex data */
-   {
-      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-      const GLfloat fb_width = (GLfloat) fb->Width;
-      const GLfloat fb_height = (GLfloat) fb->Height;
-      const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;
-      const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;
-      const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;
-      const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;
-      const GLfloat sLeft = 0.0f, sRight = maxXcoord;
-      const GLfloat tTop = invertTex ? maxYcoord : 0.0f;
-      const GLfloat tBot = invertTex ? 0.0f : maxYcoord;
-      GLuint i;
-
-      /* upper-left */
-      verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */
-      verts[0][0][1] = clip_y0;    /* v[0].attr[0].y */
-
-      /* upper-right */
-      verts[1][0][0] = clip_x1;
-      verts[1][0][1] = clip_y0;
-
-      /* lower-right */
-      verts[2][0][0] = clip_x1;
-      verts[2][0][1] = clip_y1;
-
-      /* lower-left */
-      verts[3][0][0] = clip_x0;
-      verts[3][0][1] = clip_y1;
-
-      verts[0][1][0] = sLeft; /* v[0].attr[1].S */
-      verts[0][1][1] = tTop;  /* v[0].attr[1].T */
-      verts[1][1][0] = sRight;
-      verts[1][1][1] = tTop;
-      verts[2][1][0] = sRight;
-      verts[2][1][1] = tBot;
-      verts[3][1][0] = sLeft;
-      verts[3][1][1] = tBot;
-
-      /* same for all verts: */
-      if (color) {
-         for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;         /* v[i].attr[0].z */
-            verts[i][0][3] = 1.0f;      /* v[i].attr[0].w */
-            verts[i][2][0] = color[0];  /* v[i].attr[2].r */
-            verts[i][2][1] = color[1];  /* v[i].attr[2].g */
-            verts[i][2][2] = color[2];  /* v[i].attr[2].b */
-            verts[i][2][3] = color[3];  /* v[i].attr[2].a */
-            verts[i][1][2] = 0.0f;      /* v[i].attr[1].R */
-            verts[i][1][3] = 1.0f;      /* v[i].attr[1].Q */
-         }
-      }
-      else {
-         for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;    /*Z*/
-            verts[i][0][3] = 1.0f; /*W*/
-            verts[i][1][2] = 0.0f; /*R*/
-            verts[i][1][3] = 1.0f; /*Q*/
-         }
-      }
-   }
-
-   {
-      struct pipe_resource *buf;
-
-      /* allocate/load buffer object with vertex data */
-      buf = pipe_buffer_create(pipe->screen,
-			       PIPE_BIND_VERTEX_BUFFER,
-			       PIPE_USAGE_STATIC,
-                               sizeof(verts));
-      pipe_buffer_write(st->pipe, buf, 0, sizeof(verts), verts);
-
-      util_draw_vertex_buffer(pipe, st->cso_context, buf, 0,
-                              PIPE_PRIM_QUADS,
-                              4,  /* verts */
-                              3); /* attribs/vert */
-      pipe_resource_reference(&buf, NULL);
-   }
-}
-
-
-
-static void
-draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
-                   GLsizei width, GLsizei height,
-                   GLfloat zoomX, GLfloat zoomY,
-                   struct pipe_sampler_view **sv,
-                   int num_sampler_view,
-                   void *driver_vp,
-                   void *driver_fp,
-                   const GLfloat *color,
-                   GLboolean invertTex,
-                   GLboolean write_depth, GLboolean write_stencil)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = st->cso_context;
-   GLfloat x0, y0, x1, y1;
-   GLsizei maxSize;
-   boolean normalized = sv[0]->texture->target != PIPE_TEXTURE_RECT;
-
-   /* limit checks */
-   /* XXX if DrawPixels image is larger than max texture size, break
-    * it up into chunks.
-    */
-   maxSize = 1 << (pipe->screen->get_param(pipe->screen,
-                                        PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
-   assert(width <= maxSize);
-   assert(height <= maxSize);
-
-   cso_save_rasterizer(cso);
-   cso_save_viewport(cso);
-   cso_save_samplers(cso);
-   cso_save_fragment_sampler_views(cso);
-   cso_save_fragment_shader(cso);
-   cso_save_vertex_shader(cso);
-   cso_save_vertex_elements(cso);
-   cso_save_vertex_buffers(cso);
-   if (write_stencil) {
-      cso_save_depth_stencil_alpha(cso);
-      cso_save_blend(cso);
-   }
-
-   /* rasterizer state: just scissor */
-   {
-      struct pipe_rasterizer_state rasterizer;
-      memset(&rasterizer, 0, sizeof(rasterizer));
-      rasterizer.gl_rasterization_rules = 1;
-      rasterizer.scissor = ctx->Scissor.Enabled;
-      cso_set_rasterizer(cso, &rasterizer);
-   }
-
-   if (write_stencil) {
-      /* Stencil writing bypasses the normal fragment pipeline to
-       * disable color writing and set stencil test to always pass.
-       */
-      struct pipe_depth_stencil_alpha_state dsa;
-      struct pipe_blend_state blend;
-
-      /* depth/stencil */
-      memset(&dsa, 0, sizeof(dsa));
-      dsa.stencil[0].enabled = 1;
-      dsa.stencil[0].func = PIPE_FUNC_ALWAYS;
-      dsa.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;
-      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
-      if (write_depth) {
-         /* writing depth+stencil: depth test always passes */
-         dsa.depth.enabled = 1;
-         dsa.depth.writemask = ctx->Depth.Mask;
-         dsa.depth.func = PIPE_FUNC_ALWAYS;
-      }
-      cso_set_depth_stencil_alpha(cso, &dsa);
-
-      /* blend (colormask) */
-      memset(&blend, 0, sizeof(blend));
-      cso_set_blend(cso, &blend);
-   }
-
-   /* fragment shader state: TEX lookup program */
-   cso_set_fragment_shader_handle(cso, driver_fp);
-
-   /* vertex shader state: position + texcoord pass-through */
-   cso_set_vertex_shader_handle(cso, driver_vp);
-
-
-   /* texture sampling state: */
-   {
-      struct pipe_sampler_state sampler;
-      memset(&sampler, 0, sizeof(sampler));
-      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
-      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
-      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;
-      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
-      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-      sampler.normalized_coords = normalized;
-
-      cso_single_sampler(cso, 0, &sampler);
-      if (num_sampler_view > 1) {
-         cso_single_sampler(cso, 1, &sampler);
-      }
-      cso_single_sampler_done(cso);
-   }
-
-   /* viewport state: viewport matching window dims */
-   {
-      const float w = (float) ctx->DrawBuffer->Width;
-      const float h = (float) ctx->DrawBuffer->Height;
-      struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5f * w;
-      vp.scale[1] = -0.5f * h;
-      vp.scale[2] = 0.5f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * w;
-      vp.translate[1] = 0.5f * h;
-      vp.translate[2] = 0.5f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(cso, &vp);
-   }
-
-   cso_set_vertex_elements(cso, 3, st->velems_util_draw);
-
-   /* texture state: */
-   cso_set_fragment_sampler_views(cso, num_sampler_view, sv);
-
-   /* Compute Gallium window coords (y=0=top) with pixel zoom.
-    * Recall that these coords are transformed by the current
-    * vertex shader and viewport transformation.
-    */
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM) {
-      y = ctx->DrawBuffer->Height - (int) (y + height * ctx->Pixel.ZoomY);
-      invertTex = !invertTex;
-   }
-
-   x0 = (GLfloat) x;
-   x1 = x + width * ctx->Pixel.ZoomX;
-   y0 = (GLfloat) y;
-   y1 = y + height * ctx->Pixel.ZoomY;
-
-   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */
-   z = z * 2.0 - 1.0;
-
-   draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,
-             normalized ? ((GLfloat) width / sv[0]->texture->width0) : (GLfloat)width,
-             normalized ? ((GLfloat) height / sv[0]->texture->height0) : (GLfloat)height);
-
-   /* restore state */
-   cso_restore_rasterizer(cso);
-   cso_restore_viewport(cso);
-   cso_restore_samplers(cso);
-   cso_restore_fragment_sampler_views(cso);
-   cso_restore_fragment_shader(cso);
-   cso_restore_vertex_shader(cso);
-   cso_restore_vertex_elements(cso);
-   cso_restore_vertex_buffers(cso);
-   if (write_stencil) {
-      cso_restore_depth_stencil_alpha(cso);
-      cso_restore_blend(cso);
-   }
-}
-
-
-/**
- * Software fallback to do glDrawPixels(GL_STENCIL_INDEX) when we
- * can't use a fragment shader to write stencil values.
- */
-static void
-draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
-                    GLsizei width, GLsizei height, GLenum format, GLenum type,
-                    const struct gl_pixelstore_attrib *unpack,
-                    const GLvoid *pixels)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct st_renderbuffer *strb;
-   enum pipe_transfer_usage usage;
-   struct pipe_transfer *pt;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   GLint skipPixels;
-   ubyte *stmap;
-   struct gl_pixelstore_attrib clippedUnpack = *unpack;
-
-   if (!zoom) {
-      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
-                                 &clippedUnpack)) {
-         /* totally clipped */
-         return;
-      }
-   }
-
-   strb = st_renderbuffer(ctx->DrawBuffer->
-                          Attachment[BUFFER_STENCIL].Renderbuffer);
-
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-      y = ctx->DrawBuffer->Height - y - height;
-   }
-
-   if(format != GL_DEPTH_STENCIL && 
-      util_format_get_component_bits(strb->format,
-                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
-      usage = PIPE_TRANSFER_READ_WRITE;
-   else
-      usage = PIPE_TRANSFER_WRITE;
-
-   pt = pipe_get_transfer(st_context(ctx)->pipe, strb->texture, 0, 0,
-                                     usage, x, y,
-                                     width, height);
-
-   stmap = pipe_transfer_map(pipe, pt);
-
-   pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
-   assert(pixels);
-
-   /* if width > MAX_WIDTH, have to process image in chunks */
-   skipPixels = 0;
-   while (skipPixels < width) {
-      const GLint spanX = skipPixels;
-      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-      GLint row;
-      for (row = 0; row < height; row++) {
-         GLubyte sValues[MAX_WIDTH];
-         GLuint zValues[MAX_WIDTH];
-         GLenum destType = GL_UNSIGNED_BYTE;
-         const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,
-                                                      width, height,
-                                                      format, type,
-                                                      row, skipPixels);
-         _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,
-                                   type, source, &clippedUnpack,
-                                   ctx->_ImageTransferState);
-
-         if (format == GL_DEPTH_STENCIL) {
-            _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,
-                                    (1 << 24) - 1, type, source,
-                                    &clippedUnpack);
-         }
-
-         if (zoom) {
-            _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "
-                          "zoom not complete");
-         }
-
-         {
-            GLint spanY;
-
-            if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-               spanY = height - row - 1;
-            }
-            else {
-               spanY = row;
-            }
-
-            /* now pack the stencil (and Z) values in the dest format */
-            switch (pt->resource->format) {
-            case PIPE_FORMAT_S8_USCALED:
-               {
-                  ubyte *dest = stmap + spanY * pt->stride + spanX;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  memcpy(dest, sValues, spanWidth);
-               }
-               break;
-            case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-               if (format == GL_DEPTH_STENCIL) {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = zValues[k] | (sValues[k] << 24);
-                  }
-               }
-               else {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_READ_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);
-                  }
-               }
-               break;
-            case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-               if (format == GL_DEPTH_STENCIL) {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);
-                  }
-               }
-               else {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_READ_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);
-                  }
-               }
-               break;
-            default:
-               assert(0);
-            }
-         }
-      }
-      skipPixels += spanWidth;
-   }
-
-   _mesa_unmap_pbo_source(ctx, &clippedUnpack);
-
-   /* unmap the stencil buffer */
-   pipe_transfer_unmap(pipe, pt);
-   pipe->transfer_destroy(pipe, pt);
-}
-
-
-/**
- * Get fragment program variant for a glDrawPixels or glCopyPixels
- * command for RGBA data.
- */
-static struct st_fp_variant *
-get_color_fp_variant(struct st_context *st)
-{
-   struct gl_context *ctx = st->ctx;
-   struct st_fp_variant_key key;
-   struct st_fp_variant *fpv;
-
-   memset(&key, 0, sizeof(key));
-
-   key.st = st;
-   key.drawpixels = 1;
-   key.scaleAndBias = (ctx->Pixel.RedBias != 0.0 ||
-                       ctx->Pixel.RedScale != 1.0 ||
-                       ctx->Pixel.GreenBias != 0.0 ||
-                       ctx->Pixel.GreenScale != 1.0 ||
-                       ctx->Pixel.BlueBias != 0.0 ||
-                       ctx->Pixel.BlueScale != 1.0 ||
-                       ctx->Pixel.AlphaBias != 0.0 ||
-                       ctx->Pixel.AlphaScale != 1.0);
-   key.pixelMaps = ctx->Pixel.MapColorFlag;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   return fpv;
-}
-
-
-/**
- * Get fragment program variant for a glDrawPixels or glCopyPixels
- * command for depth/stencil data.
- */
-static struct st_fp_variant *
-get_depth_stencil_fp_variant(struct st_context *st, GLboolean write_depth,
-                             GLboolean write_stencil)
-{
-   struct st_fp_variant_key key;
-   struct st_fp_variant *fpv;
-
-   memset(&key, 0, sizeof(key));
-
-   key.st = st;
-   key.drawpixels = 1;
-   key.drawpixels_z = write_depth;
-   key.drawpixels_stencil = write_stencil;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   return fpv;
-}
-
-
-/**
- * Called via ctx->Driver.DrawPixels()
- */
-static void
-st_DrawPixels(struct gl_context *ctx, GLint x, GLint y,
-              GLsizei width, GLsizei height,
-              GLenum format, GLenum type,
-              const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)
-{
-   void *driver_vp, *driver_fp;
-   struct st_context *st = st_context(ctx);
-   const GLfloat *color;
-   struct pipe_context *pipe = st->pipe;
-   GLboolean write_stencil = GL_FALSE, write_depth = GL_FALSE;
-   struct pipe_sampler_view *sv[2];
-   int num_sampler_view = 1;
-   enum pipe_format stencil_format = PIPE_FORMAT_NONE;
-   struct st_fp_variant *fpv;
-
-   if (format == GL_DEPTH_STENCIL)
-      write_stencil = write_depth = GL_TRUE;
-   else if (format == GL_STENCIL_INDEX)
-      write_stencil = GL_TRUE;
-   else if (format == GL_DEPTH_COMPONENT)
-      write_depth = GL_TRUE;
-
-   if (write_stencil) {
-      enum pipe_format tex_format;
-      /* can we write to stencil if not fallback */
-      if (!pipe->screen->get_param(pipe->screen, PIPE_CAP_SHADER_STENCIL_EXPORT))
-	 goto stencil_fallback;
-      
-      tex_format = st_choose_format(st->pipe->screen, base_format(format),
-                                    PIPE_TEXTURE_2D,
-				    0, PIPE_BIND_SAMPLER_VIEW);
-      if (tex_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)
-	 stencil_format = PIPE_FORMAT_X24S8_USCALED;
-      else if (tex_format == PIPE_FORMAT_S8_USCALED_Z24_UNORM)
-	 stencil_format = PIPE_FORMAT_S8X24_USCALED;
-      else
-	 stencil_format = PIPE_FORMAT_S8_USCALED;
-      if (stencil_format == PIPE_FORMAT_NONE)
-	 goto stencil_fallback;
-   }
-
-   /* Mesa state should be up to date by now */
-   assert(ctx->NewState == 0x0);
-
-   st_validate_state(st);
-
-   /*
-    * Get vertex/fragment shaders
-    */
-   if (write_depth || write_stencil) {
-      fpv = get_depth_stencil_fp_variant(st, write_depth, write_stencil);
-
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
-
-      color = ctx->Current.RasterColor;
-   }
-   else {
-      fpv = get_color_fp_variant(st);
-
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
-
-      color = NULL;
-      if (st->pixel_xfer.pixelmap_enabled) {
-	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;
-	  num_sampler_view++;
-      }
-   }
-
-   /* update fragment program constants */
-   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-
-   /* draw with textured quad */
-   {
-      struct pipe_resource *pt
-         = make_texture(st, width, height, format, type, unpack, pixels);
-      if (pt) {
-         sv[0] = st_create_texture_sampler_view(st->pipe, pt);
-
-         if (sv[0]) {
-	    if (write_stencil) {
-	       sv[1] = st_create_texture_sampler_view_format(st->pipe, pt,
-                                                             stencil_format);
-	       num_sampler_view++;
-	    }
-
-            draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
-                               width, height,
-                               ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                               sv,
-                               num_sampler_view,
-                               driver_vp,
-                               driver_fp,
-                               color, GL_FALSE, write_depth, write_stencil);
-            pipe_sampler_view_reference(&sv[0], NULL);
-            if (num_sampler_view > 1)
-               pipe_sampler_view_reference(&sv[1], NULL);
-         }
-         pipe_resource_reference(&pt, NULL);
-      }
-   }
-   return;
-
-stencil_fallback:
-   draw_stencil_pixels(ctx, x, y, width, height, format, type,
-		       unpack, pixels);
-}
-
-
-
-/**
- * Software fallback for glCopyPixels(GL_STENCIL).
- */
-static void
-copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-                    GLsizei width, GLsizei height,
-                    GLint dstx, GLint dsty)
-{
-   struct st_renderbuffer *rbDraw;
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   enum pipe_transfer_usage usage;
-   struct pipe_transfer *ptDraw;
-   ubyte *drawMap;
-   ubyte *buffer;
-   int i;
-
-   buffer = malloc(width * height * sizeof(ubyte));
-   if (!buffer) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");
-      return;
-   }
-
-   /* Get the dest renderbuffer.  If there's a wrapper, use the
-    * underlying renderbuffer.
-    */
-   rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
-   if (rbDraw->Base.Wrapped)
-      rbDraw = st_renderbuffer(rbDraw->Base.Wrapped);
-
-   /* this will do stencil pixel transfer ops */
-   st_read_stencil_pixels(ctx, srcx, srcy, width, height,
-                          GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
-                          &ctx->DefaultPacking, buffer);
-
-   if (0) {
-      /* debug code: dump stencil values */
-      GLint row, col;
-      for (row = 0; row < height; row++) {
-         printf("%3d: ", row);
-         for (col = 0; col < width; col++) {
-            printf("%02x ", buffer[col + row * width]);
-         }
-         printf("\n");
-      }
-   }
-
-   if (util_format_get_component_bits(rbDraw->format,
-                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
-      usage = PIPE_TRANSFER_READ_WRITE;
-   else
-      usage = PIPE_TRANSFER_WRITE;
-
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-      dsty = rbDraw->Base.Height - dsty - height;
-   }
-
-   ptDraw = pipe_get_transfer(st_context(ctx)->pipe,
-                              rbDraw->texture, 0, 0,
-                              usage, dstx, dsty,
-                              width, height);
-
-   assert(util_format_get_blockwidth(ptDraw->resource->format) == 1);
-   assert(util_format_get_blockheight(ptDraw->resource->format) == 1);
-
-   /* map the stencil buffer */
-   drawMap = pipe_transfer_map(pipe, ptDraw);
-
-   /* draw */
-   /* XXX PixelZoom not handled yet */
-   for (i = 0; i < height; i++) {
-      ubyte *dst;
-      const ubyte *src;
-      int y;
-
-      y = i;
-
-      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-         y = height - y - 1;
-      }
-
-      dst = drawMap + y * ptDraw->stride;
-      src = buffer + i * width;
-
-      switch (ptDraw->resource->format) {
-      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-         {
-            uint *dst4 = (uint *) dst;
-            int j;
-            assert(usage == PIPE_TRANSFER_READ_WRITE);
-            for (j = 0; j < width; j++) {
-               *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);
-               dst4++;
-            }
-         }
-         break;
-      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-         {
-            uint *dst4 = (uint *) dst;
-            int j;
-            assert(usage == PIPE_TRANSFER_READ_WRITE);
-            for (j = 0; j < width; j++) {
-               *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);
-               dst4++;
-            }
-         }
-         break;
-      case PIPE_FORMAT_S8_USCALED:
-         assert(usage == PIPE_TRANSFER_WRITE);
-         memcpy(dst, src, width);
-         break;
-      default:
-         assert(0);
-      }
-   }
-
-   free(buffer);
-
-   /* unmap the stencil buffer */
-   pipe_transfer_unmap(pipe, ptDraw);
-   pipe->transfer_destroy(pipe, ptDraw);
-}
-
-
-/** Do the src/dest regions overlap? */
-static GLboolean
-regions_overlap(GLint srcX, GLint srcY, GLint dstX, GLint dstY,
-                GLsizei width, GLsizei height)
-{
-   if (srcX + width <= dstX ||
-       dstX + width <= srcX ||
-       srcY + height <= dstY ||
-       dstY + height <= srcY)
-      return GL_FALSE;
-   else
-      return GL_TRUE;
-}
-
-
-/**
- * Try to do a glCopyPixels for simple cases with a blit by calling
- * pipe->resource_copy_region().
- *
- * We can do this when we're copying color pixels (depth/stencil
- * eventually) with no pixel zoom, no pixel transfer ops, no
- * per-fragment ops, the src/dest regions don't overlap and the
- * src/dest pixel formats are the same.
- */
-static GLboolean
-blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-                 GLsizei width, GLsizei height,
-                 GLint dstx, GLint dsty, GLenum type)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct gl_pixelstore_attrib pack, unpack;
-   GLint readX, readY, readW, readH;
-
-   if (type == GL_COLOR &&
-       ctx->Pixel.ZoomX == 1.0 &&
-       ctx->Pixel.ZoomY == 1.0 &&
-       ctx->_ImageTransferState == 0x0 &&
-       !ctx->Color.BlendEnabled &&
-       !ctx->Color.AlphaEnabled &&
-       !ctx->Depth.Test &&
-       !ctx->Fog.Enabled &&
-       !ctx->Stencil.Enabled &&
-       !ctx->FragmentProgram.Enabled &&
-       !ctx->VertexProgram.Enabled &&
-       !ctx->Shader.CurrentFragmentProgram &&
-       st_fb_orientation(ctx->ReadBuffer) == st_fb_orientation(ctx->DrawBuffer) &&
-       ctx->DrawBuffer->_NumColorDrawBuffers == 1) {
-      struct st_renderbuffer *rbRead, *rbDraw;
-      GLint drawX, drawY;
-
-      /*
-       * Clip the read region against the src buffer bounds.
-       * We'll still allocate a temporary buffer/texture for the original
-       * src region size but we'll only read the region which is on-screen.
-       * This may mean that we draw garbage pixels into the dest region, but
-       * that's expected.
-       */
-      readX = srcx;
-      readY = srcy;
-      readW = width;
-      readH = height;
-      pack = ctx->DefaultPacking;
-      if (!_mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack))
-         return GL_TRUE; /* all done */
-
-      /* clip against dest buffer bounds and scissor box */
-      drawX = dstx + pack.SkipPixels;
-      drawY = dsty + pack.SkipRows;
-      unpack = pack;
-      if (!_mesa_clip_drawpixels(ctx, &drawX, &drawY, &readW, &readH, &unpack))
-         return GL_TRUE; /* all done */
-
-      readX = readX - pack.SkipPixels + unpack.SkipPixels;
-      readY = readY - pack.SkipRows + unpack.SkipRows;
-
-      rbRead = st_get_color_read_renderbuffer(ctx);
-      rbDraw = st_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);
-
-      if ((rbRead != rbDraw ||
-           !regions_overlap(readX, readY, drawX, drawY, readW, readH)) &&
-          rbRead->Base.Format == rbDraw->Base.Format) {
-         struct pipe_box srcBox;
-
-         /* flip src/dst position if needed */
-         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-            /* both buffers will have the same orientation */
-            readY = ctx->ReadBuffer->Height - readY - readH;
-            drawY = ctx->DrawBuffer->Height - drawY - readH;
-         }
-
-         u_box_2d(readX, readY, readW, readH, &srcBox);
-
-         pipe->resource_copy_region(pipe,
-                                    rbDraw->texture, 0, drawX, drawY, 0,
-                                    rbRead->texture, 0, &srcBox);
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-static void
-st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-              GLsizei width, GLsizei height,
-              GLint dstx, GLint dsty, GLenum type)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct st_renderbuffer *rbRead;
-   void *driver_vp, *driver_fp;
-   struct pipe_resource *pt;
-   struct pipe_sampler_view *sv[2];
-   int num_sampler_view = 1;
-   GLfloat *color;
-   enum pipe_format srcFormat, texFormat;
-   GLboolean invertTex = GL_FALSE;
-   GLint readX, readY, readW, readH;
-   GLuint sample_count;
-   struct gl_pixelstore_attrib pack = ctx->DefaultPacking;
-   struct st_fp_variant *fpv;
-
-   st_validate_state(st);
-
-   if (type == GL_STENCIL) {
-      /* can't use texturing to do stencil */
-      copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);
-      return;
-   }
-
-   if (blit_copy_pixels(ctx, srcx, srcy, width, height, dstx, dsty, type))
-      return;
-
-   /*
-    * The subsequent code implements glCopyPixels by copying the source
-    * pixels into a temporary texture that's then applied to a textured quad.
-    * When we draw the textured quad, all the usual per-fragment operations
-    * are handled.
-    */
-
-
-   /*
-    * Get vertex/fragment shaders
-    */
-   if (type == GL_COLOR) {
-      rbRead = st_get_color_read_renderbuffer(ctx);
-      color = NULL;
-
-      fpv = get_color_fp_variant(st);
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
-
-      if (st->pixel_xfer.pixelmap_enabled) {
-	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;
-	  num_sampler_view++;
-      }
-   }
-   else {
-      assert(type == GL_DEPTH);
-      rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
-      color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
-
-      fpv = get_depth_stencil_fp_variant(st, GL_TRUE, GL_FALSE);
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
-   }
-
-   /* update fragment program constants */
-   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-
-
-   if (rbRead->Base.Wrapped)
-      rbRead = st_renderbuffer(rbRead->Base.Wrapped);
-
-   sample_count = rbRead->texture->nr_samples;
-   /* I believe this would be legal, presumably would need to do a resolve
-      for color, and for depth/stencil spec says to just use one of the
-      depth/stencil samples per pixel? Need some transfer clarifications. */
-   assert(sample_count < 2);
-
-   srcFormat = rbRead->texture->format;
-
-   if (screen->is_format_supported(screen, srcFormat, st->internal_target,
-                                   sample_count,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      texFormat = srcFormat;
-   }
-   else {
-      /* srcFormat can't be used as a texture format */
-      if (type == GL_DEPTH) {
-         texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,
-                                      st->internal_target, sample_count,
-                                      PIPE_BIND_DEPTH_STENCIL);
-         assert(texFormat != PIPE_FORMAT_NONE);
-      }
-      else {
-         /* default color format */
-         texFormat = st_choose_format(screen, GL_RGBA, st->internal_target,
-                                      sample_count, PIPE_BIND_SAMPLER_VIEW);
-         assert(texFormat != PIPE_FORMAT_NONE);
-      }
-   }
-
-   /* Invert src region if needed */
-   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-      srcy = ctx->ReadBuffer->Height - srcy - height;
-      invertTex = !invertTex;
-   }
-
-   /* Clip the read region against the src buffer bounds.
-    * We'll still allocate a temporary buffer/texture for the original
-    * src region size but we'll only read the region which is on-screen.
-    * This may mean that we draw garbage pixels into the dest region, but
-    * that's expected.
-    */
-   readX = srcx;
-   readY = srcy;
-   readW = width;
-   readH = height;
-   _mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack);
-   readW = MAX2(0, readW);
-   readH = MAX2(0, readH);
-
-   /* alloc temporary texture */
-   pt = alloc_texture(st, width, height, texFormat);
-   if (!pt)
-      return;
-
-   sv[0] = st_create_texture_sampler_view(st->pipe, pt);
-   if (!sv[0]) {
-      pipe_resource_reference(&pt, NULL);
-      return;
-   }
-
-   /* Make temporary texture which is a copy of the src region.
-    */
-   if (srcFormat == texFormat) {
-      struct pipe_box src_box;
-      u_box_2d(readX, readY, readW, readH, &src_box);
-      /* copy source framebuffer surface into mipmap/texture */
-      pipe->resource_copy_region(pipe,
-                                 pt,                                /* dest tex */
-                                 0,
-                                 pack.SkipPixels, pack.SkipRows, 0, /* dest pos */
-                                 rbRead->texture,                   /* src tex */
-                                 0,
-                                 &src_box);
-
-   }
-   else {
-      /* CPU-based fallback/conversion */
-      struct pipe_transfer *ptRead =
-         pipe_get_transfer(st->pipe, rbRead->texture,
-                           0, 0, /* level, layer */
-                           PIPE_TRANSFER_READ,
-                           readX, readY, readW, readH);
-      struct pipe_transfer *ptTex;
-      enum pipe_transfer_usage transfer_usage;
-
-      if (ST_DEBUG & DEBUG_FALLBACK)
-         debug_printf("%s: fallback processing\n", __FUNCTION__);
-
-      if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))
-         transfer_usage = PIPE_TRANSFER_READ_WRITE;
-      else
-         transfer_usage = PIPE_TRANSFER_WRITE;
-
-      ptTex = pipe_get_transfer(st->pipe, pt, 0, 0, transfer_usage,
-                                0, 0, width, height);
-
-      /* copy image from ptRead surface to ptTex surface */
-      if (type == GL_COLOR) {
-         /* alternate path using get/put_tile() */
-         GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-         enum pipe_format readFormat, drawFormat;
-         readFormat = util_format_linear(rbRead->texture->format);
-         drawFormat = util_format_linear(pt->format);
-         pipe_get_tile_rgba_format(pipe, ptRead, 0, 0, readW, readH,
-                                   readFormat, buf);
-         pipe_put_tile_rgba_format(pipe, ptTex, pack.SkipPixels, pack.SkipRows,
-                                   readW, readH, drawFormat, buf);
-         free(buf);
-      }
-      else {
-         /* GL_DEPTH */
-         GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));
-         pipe_get_tile_z(pipe, ptRead, 0, 0, readW, readH, buf);
-         pipe_put_tile_z(pipe, ptTex, pack.SkipPixels, pack.SkipRows,
-                         readW, readH, buf);
-         free(buf);
-      }
-
-      pipe->transfer_destroy(pipe, ptRead);
-      pipe->transfer_destroy(pipe, ptTex);
-   }
-
-   /* OK, the texture 'pt' contains the src image/pixels.  Now draw a
-    * textured quad with that texture.
-    */
-   draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],
-                      width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                      sv,
-                      num_sampler_view,
-                      driver_vp, 
-                      driver_fp,
-                      color, invertTex, GL_FALSE, GL_FALSE);
-
-   pipe_resource_reference(&pt, NULL);
-   pipe_sampler_view_reference(&sv[0], NULL);
-}
-
-
-
-void st_init_drawpixels_functions(struct dd_function_table *functions)
-{
-   functions->DrawPixels = st_DrawPixels;
-   functions->CopyPixels = st_CopyPixels;
-}
-
-
-void
-st_destroy_drawpix(struct st_context *st)
-{
-   GLuint i;
-
-   for (i = 0; i < Elements(st->drawpix.shaders); i++) {
-      if (st->drawpix.shaders[i])
-         _mesa_reference_fragprog(st->ctx, &st->drawpix.shaders[i], NULL);
-   }
-
-   st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
-   if (st->drawpix.vert_shaders[0])
-      ureg_free_tokens(st->drawpix.vert_shaders[0]);
-   if (st->drawpix.vert_shaders[1])
-      ureg_free_tokens(st->drawpix.vert_shaders[1]);
-}
-
-#endif /* FEATURE_drawpix */
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Brian Paul

+  */

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/bufferobj.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/pack.h"

+#include "main/pbo.h"

+#include "main/texformat.h"

+#include "main/texstore.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+#include "program/prog_instruction.h"

+

+#include "st_atom.h"

+#include "st_atom_constbuf.h"

+#include "st_cb_drawpixels.h"

+#include "st_cb_readpixels.h"

+#include "st_cb_fbo.h"

+#include "st_context.h"

+#include "st_debug.h"

+#include "st_format.h"

+#include "st_program.h"

+#include "st_texture.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "tgsi/tgsi_ureg.h"

+#include "util/u_draw_quad.h"

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_math.h"

+#include "util/u_tile.h"

+#include "cso_cache/cso_context.h"

+

+

+#if FEATURE_drawpix

+

+/**

+ * Check if the given program is:

+ * 0: MOVE result.color, fragment.color;

+ * 1: END;

+ */

+static GLboolean

+is_passthrough_program(const struct gl_fragment_program *prog)

+{

+   if (prog->Base.NumInstructions == 2) {

+      const struct prog_instruction *inst = prog->Base.Instructions;

+      if (inst[0].Opcode == OPCODE_MOV &&

+          inst[1].Opcode == OPCODE_END &&

+          inst[0].DstReg.File == PROGRAM_OUTPUT &&

+          inst[0].DstReg.Index == FRAG_RESULT_COLOR &&

+          inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&

+          inst[0].SrcReg[0].File == PROGRAM_INPUT &&

+          inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&

+          inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {

+         return GL_TRUE;

+      }

+   }

+   return GL_FALSE;

+}

+

+

+

+/**

+ * Make fragment shader for glDraw/CopyPixels.  This shader is made

+ * by combining the pixel transfer shader with the user-defined shader.

+ * \param fpIn  the current/incoming fragment program

+ * \param fpOut  returns the combined fragment program

+ */

+void

+st_make_drawpix_fragment_program(struct st_context *st,

+                                 struct gl_fragment_program *fpIn,

+                                 struct gl_fragment_program **fpOut)

+{

+   struct gl_program *newProg;

+

+   if (is_passthrough_program(fpIn)) {

+      newProg = (struct gl_program *) _mesa_clone_fragment_program(st->ctx,

+                                             &st->pixel_xfer.program->Base);

+   }

+   else {

+#if 0

+      /* debug */

+      printf("Base program:\n");

+      _mesa_print_program(&fpIn->Base);

+      printf("DrawPix program:\n");

+      _mesa_print_program(&st->pixel_xfer.program->Base.Base);

+#endif

+      newProg = _mesa_combine_programs(st->ctx,

+                                       &st->pixel_xfer.program->Base.Base,

+                                       &fpIn->Base);

+   }

+

+#if 0

+   /* debug */

+   printf("Combined DrawPixels program:\n");

+   _mesa_print_program(newProg);

+   printf("InputsRead: 0x%x\n", newProg->InputsRead);

+   printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);

+   _mesa_print_parameter_list(newProg->Parameters);

+#endif

+

+   *fpOut = (struct gl_fragment_program *) newProg;

+}

+

+

+/**

+ * Create fragment program that does a TEX() instruction to get a Z and/or

+ * stencil value value, then writes to FRAG_RESULT_DEPTH/FRAG_RESULT_STENCIL.

+ * Used for glDrawPixels(GL_DEPTH_COMPONENT / GL_STENCIL_INDEX).

+ * Pass fragment color through as-is.

+ * \return pointer to the gl_fragment program

+ */

+struct gl_fragment_program *

+st_make_drawpix_z_stencil_program(struct st_context *st,

+                                  GLboolean write_depth,

+                                  GLboolean write_stencil)

+{

+   struct gl_context *ctx = st->ctx;

+   struct gl_program *p;

+   struct gl_fragment_program *fp;

+   GLuint ic = 0;

+   const GLuint shaderIndex = write_depth * 2 + write_stencil;

+

+   assert(shaderIndex < Elements(st->drawpix.shaders));

+

+   if (st->drawpix.shaders[shaderIndex]) {

+      /* already have the proper shader */

+      return st->drawpix.shaders[shaderIndex];

+   }

+

+   /*

+    * Create shader now

+    */

+   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

+   if (!p)

+      return NULL;

+

+   p->NumInstructions = write_depth ? 2 : 1;

+   p->NumInstructions += write_stencil ? 1 : 0;

+

+   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);

+   if (!p->Instructions) {

+      ctx->Driver.DeleteProgram(ctx, p);

+      return NULL;

+   }

+   _mesa_init_instructions(p->Instructions, p->NumInstructions);

+

+   if (write_depth) {

+      /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */

+      p->Instructions[ic].Opcode = OPCODE_TEX;

+      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;

+      p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;

+      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;

+      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+      p->Instructions[ic].TexSrcUnit = 0;

+      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+      ic++;

+   }

+

+   if (write_stencil) {

+      /* TEX result.stencil, fragment.texcoord[0], texture[0], 2D; */

+      p->Instructions[ic].Opcode = OPCODE_TEX;

+      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;

+      p->Instructions[ic].DstReg.Index = FRAG_RESULT_STENCIL;

+      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Y;

+      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+      p->Instructions[ic].TexSrcUnit = 1;

+      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+      ic++;

+   }

+

+   /* END; */

+   p->Instructions[ic++].Opcode = OPCODE_END;

+

+   assert(ic == p->NumInstructions);

+

+   p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;

+   p->OutputsWritten = 0;

+   if (write_depth)

+      p->OutputsWritten |= (1 << FRAG_RESULT_DEPTH);

+   if (write_stencil)

+      p->OutputsWritten |= (1 << FRAG_RESULT_STENCIL);

+

+   p->SamplersUsed =  0x1;  /* sampler 0 (bit 0) is used */

+   if (write_stencil)

+      p->SamplersUsed |= 1 << 1;

+

+   fp = (struct gl_fragment_program *) p;

+

+   /* save the new shader */

+   st->drawpix.shaders[shaderIndex] = fp;

+

+   return fp;

+}

+

+

+/**

+ * Create a simple vertex shader that just passes through the

+ * vertex position and texcoord (and optionally, color).

+ */

+static void *

+make_passthrough_vertex_shader(struct st_context *st, 

+                               GLboolean passColor)

+{

+   if (!st->drawpix.vert_shaders[passColor]) {

+      struct ureg_program *ureg = ureg_create( TGSI_PROCESSOR_VERTEX );

+

+      if (ureg == NULL)

+         return NULL;

+

+      /* MOV result.pos, vertex.pos; */

+      ureg_MOV(ureg, 

+               ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),

+               ureg_DECL_vs_input( ureg, 0 ));

+      

+      /* MOV result.texcoord0, vertex.attr[1]; */

+      ureg_MOV(ureg, 

+               ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),

+               ureg_DECL_vs_input( ureg, 1 ));

+      

+      if (passColor) {

+         /* MOV result.color0, vertex.attr[2]; */

+         ureg_MOV(ureg, 

+                  ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),

+                  ureg_DECL_vs_input( ureg, 2 ));

+      }

+

+      ureg_END( ureg );

+      

+      st->drawpix.vert_shaders[passColor] = 

+         ureg_create_shader_and_destroy( ureg, st->pipe );

+   }

+

+   return st->drawpix.vert_shaders[passColor];

+}

+

+

+/**

+ * Return a texture base format for drawing/copying an image

+ * of the given format.

+ */

+static GLenum

+base_format(GLenum format)

+{

+   switch (format) {

+   case GL_DEPTH_COMPONENT:

+      return GL_DEPTH_COMPONENT;

+   case GL_DEPTH_STENCIL:

+      return GL_DEPTH_STENCIL;

+   case GL_STENCIL_INDEX:

+      return GL_STENCIL_INDEX;

+   default:

+      return GL_RGBA;

+   }

+}

+

+

+/**

+ * Return a texture internalFormat for drawing/copying an image

+ * of the given format and type.

+ */

+static GLenum

+internal_format(GLenum format, GLenum type)

+{

+   switch (format) {

+   case GL_DEPTH_COMPONENT:

+      return GL_DEPTH_COMPONENT;

+   case GL_DEPTH_STENCIL:

+      return GL_DEPTH_STENCIL;

+   case GL_STENCIL_INDEX:

+      return GL_STENCIL_INDEX;

+   default:

+      if (_mesa_is_integer_format(format)) {

+         switch (type) {

+         case GL_BYTE:

+            return GL_RGBA8I;

+         case GL_UNSIGNED_BYTE:

+            return GL_RGBA8UI;

+         case GL_SHORT:

+            return GL_RGBA16I;

+         case GL_UNSIGNED_SHORT:

+            return GL_RGBA16UI;

+         case GL_INT:

+            return GL_RGBA32I;

+         case GL_UNSIGNED_INT:

+            return GL_RGBA32UI;

+         default:

+            assert(0 && "Unexpected type in internal_format()");

+            return GL_RGBA_INTEGER;

+         }

+      }

+      else {

+         return GL_RGBA;

+      }

+   }

+}

+

+

+/**

+ * Create a temporary texture to hold an image of the given size.

+ * If width, height are not POT and the driver only handles POT textures,

+ * allocate the next larger size of texture that is POT.

+ */

+static struct pipe_resource *

+alloc_texture(struct st_context *st, GLsizei width, GLsizei height,

+              enum pipe_format texFormat)

+{

+   struct pipe_resource *pt;

+

+   pt = st_texture_create(st, st->internal_target, texFormat, 0,

+                          width, height, 1, 1, PIPE_BIND_SAMPLER_VIEW);

+

+   return pt;

+}

+

+

+/**

+ * Make texture containing an image for glDrawPixels image.

+ * If 'pixels' is NULL, leave the texture image data undefined.

+ */

+static struct pipe_resource *

+make_texture(struct st_context *st,

+	     GLsizei width, GLsizei height, GLenum format, GLenum type,

+	     const struct gl_pixelstore_attrib *unpack,

+	     const GLvoid *pixels)

+{

+   struct gl_context *ctx = st->ctx;

+   struct pipe_context *pipe = st->pipe;

+   gl_format mformat;

+   struct pipe_resource *pt;

+   enum pipe_format pipeFormat;

+   GLuint cpp;

+   GLenum baseFormat, intFormat;

+

+   baseFormat = base_format(format);

+   intFormat = internal_format(format, type);

+

+   mformat = st_ChooseTextureFormat_renderable(ctx, intFormat,

+                                               format, type, GL_FALSE);

+   assert(mformat);

+

+   pipeFormat = st_mesa_format_to_pipe_format(mformat);

+   assert(pipeFormat);

+   cpp = util_format_get_blocksize(pipeFormat);

+

+   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);

+   if (!pixels)

+      return NULL;

+

+   /* alloc temporary texture */

+   pt = alloc_texture(st, width, height, pipeFormat);

+   if (!pt) {

+      _mesa_unmap_pbo_source(ctx, unpack);

+      return NULL;

+   }

+

+   {

+      struct pipe_transfer *transfer;

+      static const GLuint dstImageOffsets = 0;

+      GLboolean success;

+      GLubyte *dest;

+      const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;

+

+      /* we'll do pixel transfer in a fragment shader */

+      ctx->_ImageTransferState = 0x0;

+

+      transfer = pipe_get_transfer(st->pipe, pt, 0, 0,

+                                   PIPE_TRANSFER_WRITE, 0, 0,

+                                   width, height);

+

+      /* map texture transfer */

+      dest = pipe_transfer_map(pipe, transfer);

+

+

+      /* Put image into texture transfer.

+       * Note that the image is actually going to be upside down in

+       * the texture.  We deal with that with texcoords.

+       */

+      success = _mesa_texstore(ctx, 2,           /* dims */

+                               baseFormat,       /* baseInternalFormat */

+                               mformat,          /* gl_format */

+                               dest,             /* dest */

+                               0, 0, 0,          /* dstX/Y/Zoffset */

+                               transfer->stride, /* dstRowStride, bytes */

+                               &dstImageOffsets, /* dstImageOffsets */

+                               width, height, 1, /* size */

+                               format, type,     /* src format/type */

+                               pixels,           /* data source */

+                               unpack);

+

+      /* unmap */

+      pipe_transfer_unmap(pipe, transfer);

+      pipe->transfer_destroy(pipe, transfer);

+

+      assert(success);

+

+      /* restore */

+      ctx->_ImageTransferState = imageTransferStateSave;

+   }

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+

+   return pt;

+}

+

+

+/**

+ * Draw quad with texcoords and optional color.

+ * Coords are gallium window coords with y=0=top.

+ * \param color  may be null

+ * \param invertTex  if true, flip texcoords vertically

+ */

+static void

+draw_quad(struct gl_context *ctx, GLfloat x0, GLfloat y0, GLfloat z,

+          GLfloat x1, GLfloat y1, const GLfloat *color,

+          GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */

+

+   /* setup vertex data */

+   {

+      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+      const GLfloat fb_width = (GLfloat) fb->Width;

+      const GLfloat fb_height = (GLfloat) fb->Height;

+      const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;

+      const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;

+      const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;

+      const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;

+      const GLfloat sLeft = 0.0f, sRight = maxXcoord;

+      const GLfloat tTop = invertTex ? maxYcoord : 0.0f;

+      const GLfloat tBot = invertTex ? 0.0f : maxYcoord;

+      GLuint i;

+

+      /* upper-left */

+      verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */

+      verts[0][0][1] = clip_y0;    /* v[0].attr[0].y */

+

+      /* upper-right */

+      verts[1][0][0] = clip_x1;

+      verts[1][0][1] = clip_y0;

+

+      /* lower-right */

+      verts[2][0][0] = clip_x1;

+      verts[2][0][1] = clip_y1;

+

+      /* lower-left */

+      verts[3][0][0] = clip_x0;

+      verts[3][0][1] = clip_y1;

+

+      verts[0][1][0] = sLeft; /* v[0].attr[1].S */

+      verts[0][1][1] = tTop;  /* v[0].attr[1].T */

+      verts[1][1][0] = sRight;

+      verts[1][1][1] = tTop;

+      verts[2][1][0] = sRight;

+      verts[2][1][1] = tBot;

+      verts[3][1][0] = sLeft;

+      verts[3][1][1] = tBot;

+

+      /* same for all verts: */

+      if (color) {

+         for (i = 0; i < 4; i++) {

+            verts[i][0][2] = z;         /* v[i].attr[0].z */

+            verts[i][0][3] = 1.0f;      /* v[i].attr[0].w */

+            verts[i][2][0] = color[0];  /* v[i].attr[2].r */

+            verts[i][2][1] = color[1];  /* v[i].attr[2].g */

+            verts[i][2][2] = color[2];  /* v[i].attr[2].b */

+            verts[i][2][3] = color[3];  /* v[i].attr[2].a */

+            verts[i][1][2] = 0.0f;      /* v[i].attr[1].R */

+            verts[i][1][3] = 1.0f;      /* v[i].attr[1].Q */

+         }

+      }

+      else {

+         for (i = 0; i < 4; i++) {

+            verts[i][0][2] = z;    /*Z*/

+            verts[i][0][3] = 1.0f; /*W*/

+            verts[i][1][2] = 0.0f; /*R*/

+            verts[i][1][3] = 1.0f; /*Q*/

+         }

+      }

+   }

+

+   {

+      struct pipe_resource *buf;

+

+      /* allocate/load buffer object with vertex data */

+      buf = pipe_buffer_create(pipe->screen,

+			       PIPE_BIND_VERTEX_BUFFER,

+			       PIPE_USAGE_STATIC,

+                               sizeof(verts));

+      pipe_buffer_write(st->pipe, buf, 0, sizeof(verts), verts);

+

+      util_draw_vertex_buffer(pipe, st->cso_context, buf, 0,

+                              PIPE_PRIM_QUADS,

+                              4,  /* verts */

+                              3); /* attribs/vert */

+      pipe_resource_reference(&buf, NULL);

+   }

+}

+

+

+

+static void

+draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,

+                   GLsizei width, GLsizei height,

+                   GLfloat zoomX, GLfloat zoomY,

+                   struct pipe_sampler_view **sv,

+                   int num_sampler_view,

+                   void *driver_vp,

+                   void *driver_fp,

+                   const GLfloat *color,

+                   GLboolean invertTex,

+                   GLboolean write_depth, GLboolean write_stencil)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = st->cso_context;

+   GLfloat x0, y0, x1, y1;

+   GLsizei maxSize;

+   boolean normalized = sv[0]->texture->target != PIPE_TEXTURE_RECT;

+

+   /* limit checks */

+   /* XXX if DrawPixels image is larger than max texture size, break

+    * it up into chunks.

+    */

+   maxSize = 1 << (pipe->screen->get_param(pipe->screen,

+                                        PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);

+   assert(width <= maxSize);

+   assert(height <= maxSize);

+

+   cso_save_rasterizer(cso);

+   cso_save_viewport(cso);

+   cso_save_samplers(cso);

+   cso_save_fragment_sampler_views(cso);

+   cso_save_fragment_shader(cso);

+   cso_save_vertex_shader(cso);

+   cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

+   if (write_stencil) {

+      cso_save_depth_stencil_alpha(cso);

+      cso_save_blend(cso);

+   }

+

+   /* rasterizer state: just scissor */

+   {

+      struct pipe_rasterizer_state rasterizer;

+      memset(&rasterizer, 0, sizeof(rasterizer));

+      rasterizer.gl_rasterization_rules = 1;

+      rasterizer.scissor = ctx->Scissor.Enabled;

+      cso_set_rasterizer(cso, &rasterizer);

+   }

+

+   if (write_stencil) {

+      /* Stencil writing bypasses the normal fragment pipeline to

+       * disable color writing and set stencil test to always pass.

+       */

+      struct pipe_depth_stencil_alpha_state dsa;

+      struct pipe_blend_state blend;

+

+      /* depth/stencil */

+      memset(&dsa, 0, sizeof(dsa));

+      dsa.stencil[0].enabled = 1;

+      dsa.stencil[0].func = PIPE_FUNC_ALWAYS;

+      dsa.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;

+      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;

+      if (write_depth) {

+         /* writing depth+stencil: depth test always passes */

+         dsa.depth.enabled = 1;

+         dsa.depth.writemask = ctx->Depth.Mask;

+         dsa.depth.func = PIPE_FUNC_ALWAYS;

+      }

+      cso_set_depth_stencil_alpha(cso, &dsa);

+

+      /* blend (colormask) */

+      memset(&blend, 0, sizeof(blend));

+      cso_set_blend(cso, &blend);

+   }

+

+   /* fragment shader state: TEX lookup program */

+   cso_set_fragment_shader_handle(cso, driver_fp);

+

+   /* vertex shader state: position + texcoord pass-through */

+   cso_set_vertex_shader_handle(cso, driver_vp);

+

+

+   /* texture sampling state: */

+   {

+      struct pipe_sampler_state sampler;

+      memset(&sampler, 0, sizeof(sampler));

+      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;

+      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;

+      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;

+      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;

+      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;

+      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;

+      sampler.normalized_coords = normalized;

+

+      cso_single_sampler(cso, 0, &sampler);

+      if (num_sampler_view > 1) {

+         cso_single_sampler(cso, 1, &sampler);

+      }

+      cso_single_sampler_done(cso);

+   }

+

+   /* viewport state: viewport matching window dims */

+   {

+      const float w = (float) ctx->DrawBuffer->Width;

+      const float h = (float) ctx->DrawBuffer->Height;

+      struct pipe_viewport_state vp;

+      vp.scale[0] =  0.5f * w;

+      vp.scale[1] = -0.5f * h;

+      vp.scale[2] = 0.5f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * w;

+      vp.translate[1] = 0.5f * h;

+      vp.translate[2] = 0.5f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(cso, &vp);

+   }

+

+   cso_set_vertex_elements(cso, 3, st->velems_util_draw);

+

+   /* texture state: */

+   cso_set_fragment_sampler_views(cso, num_sampler_view, sv);

+

+   /* Compute Gallium window coords (y=0=top) with pixel zoom.

+    * Recall that these coords are transformed by the current

+    * vertex shader and viewport transformation.

+    */

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM) {

+      y = ctx->DrawBuffer->Height - (int) (y + height * ctx->Pixel.ZoomY);

+      invertTex = !invertTex;

+   }

+

+   x0 = (GLfloat) x;

+   x1 = x + width * ctx->Pixel.ZoomX;

+   y0 = (GLfloat) y;

+   y1 = y + height * ctx->Pixel.ZoomY;

+

+   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */

+   z = z * 2.0 - 1.0;

+

+   draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,

+             normalized ? ((GLfloat) width / sv[0]->texture->width0) : (GLfloat)width,

+             normalized ? ((GLfloat) height / sv[0]->texture->height0) : (GLfloat)height);

+

+   /* restore state */

+   cso_restore_rasterizer(cso);

+   cso_restore_viewport(cso);

+   cso_restore_samplers(cso);

+   cso_restore_fragment_sampler_views(cso);

+   cso_restore_fragment_shader(cso);

+   cso_restore_vertex_shader(cso);

+   cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

+   if (write_stencil) {

+      cso_restore_depth_stencil_alpha(cso);

+      cso_restore_blend(cso);

+   }

+}

+

+

+/**

+ * Software fallback to do glDrawPixels(GL_STENCIL_INDEX) when we

+ * can't use a fragment shader to write stencil values.

+ */

+static void

+draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,

+                    GLsizei width, GLsizei height, GLenum format, GLenum type,

+                    const struct gl_pixelstore_attrib *unpack,

+                    const GLvoid *pixels)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct st_renderbuffer *strb;

+   enum pipe_transfer_usage usage;

+   struct pipe_transfer *pt;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   GLint skipPixels;

+   ubyte *stmap;

+   struct gl_pixelstore_attrib clippedUnpack = *unpack;

+

+   if (!zoom) {

+      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,

+                                 &clippedUnpack)) {

+         /* totally clipped */

+         return;

+      }

+   }

+

+   strb = st_renderbuffer(ctx->DrawBuffer->

+                          Attachment[BUFFER_STENCIL].Renderbuffer);

+

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+      y = ctx->DrawBuffer->Height - y - height;

+   }

+

+   if(format != GL_DEPTH_STENCIL && 

+      util_format_get_component_bits(strb->format,

+                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)

+      usage = PIPE_TRANSFER_READ_WRITE;

+   else

+      usage = PIPE_TRANSFER_WRITE;

+

+   pt = pipe_get_transfer(st_context(ctx)->pipe, strb->texture, 0, 0,

+                                     usage, x, y,

+                                     width, height);

+

+   stmap = pipe_transfer_map(pipe, pt);

+

+   pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);

+   assert(pixels);

+

+   /* if width > MAX_WIDTH, have to process image in chunks */

+   skipPixels = 0;

+   while (skipPixels < width) {

+      const GLint spanX = skipPixels;

+      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+      GLint row;

+      for (row = 0; row < height; row++) {

+         GLubyte sValues[MAX_WIDTH];

+         GLuint zValues[MAX_WIDTH];

+         GLenum destType = GL_UNSIGNED_BYTE;

+         const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,

+                                                      width, height,

+                                                      format, type,

+                                                      row, skipPixels);

+         _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,

+                                   type, source, &clippedUnpack,

+                                   ctx->_ImageTransferState);

+

+         if (format == GL_DEPTH_STENCIL) {

+            _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,

+                                    (1 << 24) - 1, type, source,

+                                    &clippedUnpack);

+         }

+

+         if (zoom) {

+            _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "

+                          "zoom not complete");

+         }

+

+         {

+            GLint spanY;

+

+            if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+               spanY = height - row - 1;

+            }

+            else {

+               spanY = row;

+            }

+

+            /* now pack the stencil (and Z) values in the dest format */

+            switch (pt->resource->format) {

+            case PIPE_FORMAT_S8_USCALED:

+               {

+                  ubyte *dest = stmap + spanY * pt->stride + spanX;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  memcpy(dest, sValues, spanWidth);

+               }

+               break;

+            case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+               if (format == GL_DEPTH_STENCIL) {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = zValues[k] | (sValues[k] << 24);

+                  }

+               }

+               else {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_READ_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);

+                  }

+               }

+               break;

+            case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+               if (format == GL_DEPTH_STENCIL) {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);

+                  }

+               }

+               else {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_READ_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);

+                  }

+               }

+               break;

+            default:

+               assert(0);

+            }

+         }

+      }

+      skipPixels += spanWidth;

+   }

+

+   _mesa_unmap_pbo_source(ctx, &clippedUnpack);

+

+   /* unmap the stencil buffer */

+   pipe_transfer_unmap(pipe, pt);

+   pipe->transfer_destroy(pipe, pt);

+}

+

+

+/**

+ * Get fragment program variant for a glDrawPixels or glCopyPixels

+ * command for RGBA data.

+ */

+static struct st_fp_variant *

+get_color_fp_variant(struct st_context *st)

+{

+   struct gl_context *ctx = st->ctx;

+   struct st_fp_variant_key key;

+   struct st_fp_variant *fpv;

+

+   memset(&key, 0, sizeof(key));

+

+   key.st = st;

+   key.drawpixels = 1;

+   key.scaleAndBias = (ctx->Pixel.RedBias != 0.0 ||

+                       ctx->Pixel.RedScale != 1.0 ||

+                       ctx->Pixel.GreenBias != 0.0 ||

+                       ctx->Pixel.GreenScale != 1.0 ||

+                       ctx->Pixel.BlueBias != 0.0 ||

+                       ctx->Pixel.BlueScale != 1.0 ||

+                       ctx->Pixel.AlphaBias != 0.0 ||

+                       ctx->Pixel.AlphaScale != 1.0);

+   key.pixelMaps = ctx->Pixel.MapColorFlag;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   return fpv;

+}

+

+

+/**

+ * Get fragment program variant for a glDrawPixels or glCopyPixels

+ * command for depth/stencil data.

+ */

+static struct st_fp_variant *

+get_depth_stencil_fp_variant(struct st_context *st, GLboolean write_depth,

+                             GLboolean write_stencil)

+{

+   struct st_fp_variant_key key;

+   struct st_fp_variant *fpv;

+

+   memset(&key, 0, sizeof(key));

+

+   key.st = st;

+   key.drawpixels = 1;

+   key.drawpixels_z = write_depth;

+   key.drawpixels_stencil = write_stencil;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   return fpv;

+}

+

+

+/**

+ * Called via ctx->Driver.DrawPixels()

+ */

+static void

+st_DrawPixels(struct gl_context *ctx, GLint x, GLint y,

+              GLsizei width, GLsizei height,

+              GLenum format, GLenum type,

+              const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)

+{

+   void *driver_vp, *driver_fp;

+   struct st_context *st = st_context(ctx);

+   const GLfloat *color;

+   struct pipe_context *pipe = st->pipe;

+   GLboolean write_stencil = GL_FALSE, write_depth = GL_FALSE;

+   struct pipe_sampler_view *sv[2];

+   int num_sampler_view = 1;

+   enum pipe_format stencil_format = PIPE_FORMAT_NONE;

+   struct st_fp_variant *fpv;

+

+   if (format == GL_DEPTH_STENCIL)

+      write_stencil = write_depth = GL_TRUE;

+   else if (format == GL_STENCIL_INDEX)

+      write_stencil = GL_TRUE;

+   else if (format == GL_DEPTH_COMPONENT)

+      write_depth = GL_TRUE;

+

+   if (write_stencil) {

+      enum pipe_format tex_format;

+      /* can we write to stencil if not fallback */

+      if (!pipe->screen->get_param(pipe->screen, PIPE_CAP_SHADER_STENCIL_EXPORT))

+	 goto stencil_fallback;

+      

+      tex_format = st_choose_format(st->pipe->screen, base_format(format),

+                                    PIPE_TEXTURE_2D,

+				    0, PIPE_BIND_SAMPLER_VIEW);

+      if (tex_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)

+	 stencil_format = PIPE_FORMAT_X24S8_USCALED;

+      else if (tex_format == PIPE_FORMAT_S8_USCALED_Z24_UNORM)

+	 stencil_format = PIPE_FORMAT_S8X24_USCALED;

+      else

+	 stencil_format = PIPE_FORMAT_S8_USCALED;

+      if (stencil_format == PIPE_FORMAT_NONE)

+	 goto stencil_fallback;

+   }

+

+   /* Mesa state should be up to date by now */

+   assert(ctx->NewState == 0x0);

+

+   st_validate_state(st);

+

+   /*

+    * Get vertex/fragment shaders

+    */

+   if (write_depth || write_stencil) {

+      fpv = get_depth_stencil_fp_variant(st, write_depth, write_stencil);

+

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);

+

+      color = ctx->Current.RasterColor;

+   }

+   else {

+      fpv = get_color_fp_variant(st);

+

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);

+

+      color = NULL;

+      if (st->pixel_xfer.pixelmap_enabled) {

+	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;

+	  num_sampler_view++;

+      }

+   }

+

+   /* update fragment program constants */

+   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+

+   /* draw with textured quad */

+   {

+      struct pipe_resource *pt

+         = make_texture(st, width, height, format, type, unpack, pixels);

+      if (pt) {

+         sv[0] = st_create_texture_sampler_view(st->pipe, pt);

+

+         if (sv[0]) {

+	    if (write_stencil) {

+	       sv[1] = st_create_texture_sampler_view_format(st->pipe, pt,

+                                                             stencil_format);

+	       num_sampler_view++;

+	    }

+

+            draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],

+                               width, height,

+                               ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,

+                               sv,

+                               num_sampler_view,

+                               driver_vp,

+                               driver_fp,

+                               color, GL_FALSE, write_depth, write_stencil);

+            pipe_sampler_view_reference(&sv[0], NULL);

+            if (num_sampler_view > 1)

+               pipe_sampler_view_reference(&sv[1], NULL);

+         }

+         pipe_resource_reference(&pt, NULL);

+      }

+   }

+   return;

+

+stencil_fallback:

+   draw_stencil_pixels(ctx, x, y, width, height, format, type,

+		       unpack, pixels);

+}

+

+

+

+/**

+ * Software fallback for glCopyPixels(GL_STENCIL).

+ */

+static void

+copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                    GLsizei width, GLsizei height,

+                    GLint dstx, GLint dsty)

+{

+   struct st_renderbuffer *rbDraw;

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   enum pipe_transfer_usage usage;

+   struct pipe_transfer *ptDraw;

+   ubyte *drawMap;

+   ubyte *buffer;

+   int i;

+

+   buffer = malloc(width * height * sizeof(ubyte));

+   if (!buffer) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");

+      return;

+   }

+

+   /* Get the dest renderbuffer.  If there's a wrapper, use the

+    * underlying renderbuffer.

+    */

+   rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);

+   if (rbDraw->Base.Wrapped)

+      rbDraw = st_renderbuffer(rbDraw->Base.Wrapped);

+

+   /* this will do stencil pixel transfer ops */

+   st_read_stencil_pixels(ctx, srcx, srcy, width, height,

+                          GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,

+                          &ctx->DefaultPacking, buffer);

+

+   if (0) {

+      /* debug code: dump stencil values */

+      GLint row, col;

+      for (row = 0; row < height; row++) {

+         printf("%3d: ", row);

+         for (col = 0; col < width; col++) {

+            printf("%02x ", buffer[col + row * width]);

+         }

+         printf("\n");

+      }

+   }

+

+   if (util_format_get_component_bits(rbDraw->format,

+                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)

+      usage = PIPE_TRANSFER_READ_WRITE;

+   else

+      usage = PIPE_TRANSFER_WRITE;

+

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+      dsty = rbDraw->Base.Height - dsty - height;

+   }

+

+   ptDraw = pipe_get_transfer(st_context(ctx)->pipe,

+                              rbDraw->texture, 0, 0,

+                              usage, dstx, dsty,

+                              width, height);

+

+   assert(util_format_get_blockwidth(ptDraw->resource->format) == 1);

+   assert(util_format_get_blockheight(ptDraw->resource->format) == 1);

+

+   /* map the stencil buffer */

+   drawMap = pipe_transfer_map(pipe, ptDraw);

+

+   /* draw */

+   /* XXX PixelZoom not handled yet */

+   for (i = 0; i < height; i++) {

+      ubyte *dst;

+      const ubyte *src;

+      int y;

+

+      y = i;

+

+      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+         y = height - y - 1;

+      }

+

+      dst = drawMap + y * ptDraw->stride;

+      src = buffer + i * width;

+

+      switch (ptDraw->resource->format) {

+      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+         {

+            uint *dst4 = (uint *) dst;

+            int j;

+            assert(usage == PIPE_TRANSFER_READ_WRITE);

+            for (j = 0; j < width; j++) {

+               *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);

+               dst4++;

+            }

+         }

+         break;

+      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+         {

+            uint *dst4 = (uint *) dst;

+            int j;

+            assert(usage == PIPE_TRANSFER_READ_WRITE);

+            for (j = 0; j < width; j++) {

+               *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);

+               dst4++;

+            }

+         }

+         break;

+      case PIPE_FORMAT_S8_USCALED:

+         assert(usage == PIPE_TRANSFER_WRITE);

+         memcpy(dst, src, width);

+         break;

+      default:

+         assert(0);

+      }

+   }

+

+   free(buffer);

+

+   /* unmap the stencil buffer */

+   pipe_transfer_unmap(pipe, ptDraw);

+   pipe->transfer_destroy(pipe, ptDraw);

+}

+

+

+/** Do the src/dest regions overlap? */

+static GLboolean

+regions_overlap(GLint srcX, GLint srcY, GLint dstX, GLint dstY,

+                GLsizei width, GLsizei height)

+{

+   if (srcX + width <= dstX ||

+       dstX + width <= srcX ||

+       srcY + height <= dstY ||

+       dstY + height <= srcY)

+      return GL_FALSE;

+   else

+      return GL_TRUE;

+}

+

+

+/**

+ * Try to do a glCopyPixels for simple cases with a blit by calling

+ * pipe->resource_copy_region().

+ *

+ * We can do this when we're copying color pixels (depth/stencil

+ * eventually) with no pixel zoom, no pixel transfer ops, no

+ * per-fragment ops, the src/dest regions don't overlap and the

+ * src/dest pixel formats are the same.

+ */

+static GLboolean

+blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                 GLsizei width, GLsizei height,

+                 GLint dstx, GLint dsty, GLenum type)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct gl_pixelstore_attrib pack, unpack;

+   GLint readX, readY, readW, readH;

+

+   if (type == GL_COLOR &&

+       ctx->Pixel.ZoomX == 1.0 &&

+       ctx->Pixel.ZoomY == 1.0 &&

+       ctx->_ImageTransferState == 0x0 &&

+       !ctx->Color.BlendEnabled &&

+       !ctx->Color.AlphaEnabled &&

+       !ctx->Depth.Test &&

+       !ctx->Fog.Enabled &&

+       !ctx->Stencil.Enabled &&

+       !ctx->FragmentProgram.Enabled &&

+       !ctx->VertexProgram.Enabled &&

+       !ctx->Shader.CurrentFragmentProgram &&

+       st_fb_orientation(ctx->ReadBuffer) == st_fb_orientation(ctx->DrawBuffer) &&

+       ctx->DrawBuffer->_NumColorDrawBuffers == 1) {

+      struct st_renderbuffer *rbRead, *rbDraw;

+      GLint drawX, drawY;

+

+      /*

+       * Clip the read region against the src buffer bounds.

+       * We'll still allocate a temporary buffer/texture for the original

+       * src region size but we'll only read the region which is on-screen.

+       * This may mean that we draw garbage pixels into the dest region, but

+       * that's expected.

+       */

+      readX = srcx;

+      readY = srcy;

+      readW = width;

+      readH = height;

+      pack = ctx->DefaultPacking;

+      if (!_mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack))

+         return GL_TRUE; /* all done */

+

+      /* clip against dest buffer bounds and scissor box */

+      drawX = dstx + pack.SkipPixels;

+      drawY = dsty + pack.SkipRows;

+      unpack = pack;

+      if (!_mesa_clip_drawpixels(ctx, &drawX, &drawY, &readW, &readH, &unpack))

+         return GL_TRUE; /* all done */

+

+      readX = readX - pack.SkipPixels + unpack.SkipPixels;

+      readY = readY - pack.SkipRows + unpack.SkipRows;

+

+      rbRead = st_get_color_read_renderbuffer(ctx);

+      rbDraw = st_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);

+

+      if ((rbRead != rbDraw ||

+           !regions_overlap(readX, readY, drawX, drawY, readW, readH)) &&

+          rbRead->Base.Format == rbDraw->Base.Format) {

+         struct pipe_box srcBox;

+

+         /* flip src/dst position if needed */

+         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+            /* both buffers will have the same orientation */

+            readY = ctx->ReadBuffer->Height - readY - readH;

+            drawY = ctx->DrawBuffer->Height - drawY - readH;

+         }

+

+         u_box_2d(readX, readY, readW, readH, &srcBox);

+

+         pipe->resource_copy_region(pipe,

+                                    rbDraw->texture, 0, drawX, drawY, 0,

+                                    rbRead->texture, 0, &srcBox);

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+static void

+st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+              GLsizei width, GLsizei height,

+              GLint dstx, GLint dsty, GLenum type)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+   struct st_renderbuffer *rbRead;

+   void *driver_vp, *driver_fp;

+   struct pipe_resource *pt;

+   struct pipe_sampler_view *sv[2];

+   int num_sampler_view = 1;

+   GLfloat *color;

+   enum pipe_format srcFormat, texFormat;

+   GLboolean invertTex = GL_FALSE;

+   GLint readX, readY, readW, readH;

+   GLuint sample_count;

+   struct gl_pixelstore_attrib pack = ctx->DefaultPacking;

+   struct st_fp_variant *fpv;

+

+   st_validate_state(st);

+

+   if (type == GL_STENCIL) {

+      /* can't use texturing to do stencil */

+      copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);

+      return;

+   }

+

+   if (blit_copy_pixels(ctx, srcx, srcy, width, height, dstx, dsty, type))

+      return;

+

+   /*

+    * The subsequent code implements glCopyPixels by copying the source

+    * pixels into a temporary texture that's then applied to a textured quad.

+    * When we draw the textured quad, all the usual per-fragment operations

+    * are handled.

+    */

+

+

+   /*

+    * Get vertex/fragment shaders

+    */

+   if (type == GL_COLOR) {

+      rbRead = st_get_color_read_renderbuffer(ctx);

+      color = NULL;

+

+      fpv = get_color_fp_variant(st);

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);

+

+      if (st->pixel_xfer.pixelmap_enabled) {

+	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;

+	  num_sampler_view++;

+      }

+   }

+   else {

+      assert(type == GL_DEPTH);

+      rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);

+      color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];

+

+      fpv = get_depth_stencil_fp_variant(st, GL_TRUE, GL_FALSE);

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);

+   }

+

+   /* update fragment program constants */

+   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+

+

+   if (rbRead->Base.Wrapped)

+      rbRead = st_renderbuffer(rbRead->Base.Wrapped);

+

+   sample_count = rbRead->texture->nr_samples;

+   /* I believe this would be legal, presumably would need to do a resolve

+      for color, and for depth/stencil spec says to just use one of the

+      depth/stencil samples per pixel? Need some transfer clarifications. */

+   assert(sample_count < 2);

+

+   srcFormat = rbRead->texture->format;

+

+   if (screen->is_format_supported(screen, srcFormat, st->internal_target,

+                                   sample_count,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      texFormat = srcFormat;

+   }

+   else {

+      /* srcFormat can't be used as a texture format */

+      if (type == GL_DEPTH) {

+         texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,

+                                      st->internal_target, sample_count,

+                                      PIPE_BIND_DEPTH_STENCIL);

+         assert(texFormat != PIPE_FORMAT_NONE);

+      }

+      else {

+         /* default color format */

+         texFormat = st_choose_format(screen, GL_RGBA, st->internal_target,

+                                      sample_count, PIPE_BIND_SAMPLER_VIEW);

+         assert(texFormat != PIPE_FORMAT_NONE);

+      }

+   }

+

+   /* Invert src region if needed */

+   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+      srcy = ctx->ReadBuffer->Height - srcy - height;

+      invertTex = !invertTex;

+   }

+

+   /* Clip the read region against the src buffer bounds.

+    * We'll still allocate a temporary buffer/texture for the original

+    * src region size but we'll only read the region which is on-screen.

+    * This may mean that we draw garbage pixels into the dest region, but

+    * that's expected.

+    */

+   readX = srcx;

+   readY = srcy;

+   readW = width;

+   readH = height;

+   _mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack);

+   readW = MAX2(0, readW);

+   readH = MAX2(0, readH);

+

+   /* alloc temporary texture */

+   pt = alloc_texture(st, width, height, texFormat);

+   if (!pt)

+      return;

+

+   sv[0] = st_create_texture_sampler_view(st->pipe, pt);

+   if (!sv[0]) {

+      pipe_resource_reference(&pt, NULL);

+      return;

+   }

+

+   /* Make temporary texture which is a copy of the src region.

+    */

+   if (srcFormat == texFormat) {

+      struct pipe_box src_box;

+      u_box_2d(readX, readY, readW, readH, &src_box);

+      /* copy source framebuffer surface into mipmap/texture */

+      pipe->resource_copy_region(pipe,

+                                 pt,                                /* dest tex */

+                                 0,

+                                 pack.SkipPixels, pack.SkipRows, 0, /* dest pos */

+                                 rbRead->texture,                   /* src tex */

+                                 0,

+                                 &src_box);

+

+   }

+   else {

+      /* CPU-based fallback/conversion */

+      struct pipe_transfer *ptRead =

+         pipe_get_transfer(st->pipe, rbRead->texture,

+                           0, 0, /* level, layer */

+                           PIPE_TRANSFER_READ,

+                           readX, readY, readW, readH);

+      struct pipe_transfer *ptTex;

+      enum pipe_transfer_usage transfer_usage;

+

+      if (ST_DEBUG & DEBUG_FALLBACK)

+         debug_printf("%s: fallback processing\n", __FUNCTION__);

+

+      if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))

+         transfer_usage = PIPE_TRANSFER_READ_WRITE;

+      else

+         transfer_usage = PIPE_TRANSFER_WRITE;

+

+      ptTex = pipe_get_transfer(st->pipe, pt, 0, 0, transfer_usage,

+                                0, 0, width, height);

+

+      /* copy image from ptRead surface to ptTex surface */

+      if (type == GL_COLOR) {

+         /* alternate path using get/put_tile() */

+         GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));

+         enum pipe_format readFormat, drawFormat;

+         readFormat = util_format_linear(rbRead->texture->format);

+         drawFormat = util_format_linear(pt->format);

+         pipe_get_tile_rgba_format(pipe, ptRead, 0, 0, readW, readH,

+                                   readFormat, buf);

+         pipe_put_tile_rgba_format(pipe, ptTex, pack.SkipPixels, pack.SkipRows,

+                                   readW, readH, drawFormat, buf);

+         free(buf);

+      }

+      else {

+         /* GL_DEPTH */

+         GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));

+         pipe_get_tile_z(pipe, ptRead, 0, 0, readW, readH, buf);

+         pipe_put_tile_z(pipe, ptTex, pack.SkipPixels, pack.SkipRows,

+                         readW, readH, buf);

+         free(buf);

+      }

+

+      pipe->transfer_destroy(pipe, ptRead);

+      pipe->transfer_destroy(pipe, ptTex);

+   }

+

+   /* OK, the texture 'pt' contains the src image/pixels.  Now draw a

+    * textured quad with that texture.

+    */

+   draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],

+                      width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,

+                      sv,

+                      num_sampler_view,

+                      driver_vp, 

+                      driver_fp,

+                      color, invertTex, GL_FALSE, GL_FALSE);

+

+   pipe_resource_reference(&pt, NULL);

+   pipe_sampler_view_reference(&sv[0], NULL);

+}

+

+

+

+void st_init_drawpixels_functions(struct dd_function_table *functions)

+{

+   functions->DrawPixels = st_DrawPixels;

+   functions->CopyPixels = st_CopyPixels;

+}

+

+

+void

+st_destroy_drawpix(struct st_context *st)

+{

+   GLuint i;

+

+   for (i = 0; i < Elements(st->drawpix.shaders); i++) {

+      if (st->drawpix.shaders[i])

+         _mesa_reference_fragprog(st->ctx, &st->drawpix.shaders[i], NULL);

+   }

+

+   st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);

+   if (st->drawpix.vert_shaders[0])

+      ureg_free_tokens(st->drawpix.vert_shaders[0]);

+   if (st->drawpix.vert_shaders[1])

+      ureg_free_tokens(st->drawpix.vert_shaders[1]);

+}

+

+#endif /* FEATURE_drawpix */

diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
index 86ceb9d78..db299eb8d 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c
@@ -1,307 +1,307 @@
-/**************************************************************************
- * 
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- **************************************************************************/
-
-
-/**
- * Implementation of glDrawTex() for GL_OES_draw_tex
- */
-
-
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_drawtex.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-#include "pipe/p_shader_tokens.h"
-#include "util/u_draw_quad.h"
-#include "util/u_simple_shaders.h"
-
-#include "cso_cache/cso_context.h"
-
-
-#if FEATURE_OES_draw_texture
-
-
-struct cached_shader
-{
-   void *handle;
-
-   uint num_attribs;
-   uint semantic_names[2 + MAX_TEXTURE_UNITS];
-   uint semantic_indexes[2 + MAX_TEXTURE_UNITS];
-};
-
-#define MAX_SHADERS (2 * MAX_TEXTURE_UNITS)
-
-/**
- * Simple linear list cache.
- * Most of the time there'll only be one cached shader.
- */
-static struct cached_shader CachedShaders[MAX_SHADERS];
-static GLuint NumCachedShaders = 0;
-
-
-static void *
-lookup_shader(struct pipe_context *pipe,
-              uint num_attribs,
-              const uint *semantic_names,
-              const uint *semantic_indexes)
-{
-   GLuint i, j;
-
-   /* look for existing shader with same attributes */
-   for (i = 0; i < NumCachedShaders; i++) {
-      if (CachedShaders[i].num_attribs == num_attribs) {
-         GLboolean match = GL_TRUE;
-         for (j = 0; j < num_attribs; j++) {
-            if (semantic_names[j] != CachedShaders[i].semantic_names[j] ||
-                semantic_indexes[j] != CachedShaders[i].semantic_indexes[j]) {
-               match = GL_FALSE;
-               break;
-            }
-         }
-         if (match)
-            return CachedShaders[i].handle;
-      }
-   }
-
-   /* not found - create new one now */
-   if (NumCachedShaders >= MAX_SHADERS) {
-      return NULL;
-   }
-
-   CachedShaders[i].num_attribs = num_attribs;
-   for (j = 0; j < num_attribs; j++) {
-      CachedShaders[i].semantic_names[j] = semantic_names[j];
-      CachedShaders[i].semantic_indexes[j] = semantic_indexes[j];
-   }
-
-   CachedShaders[i].handle =
-      util_make_vertex_passthrough_shader(pipe,
-                                          num_attribs,
-                                          semantic_names,
-                                          semantic_indexes);
-   NumCachedShaders++;
-
-   return CachedShaders[i].handle;
-}
-
-static void
-st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
-           GLfloat width, GLfloat height)
-{
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = ctx->st->cso_context;
-   struct pipe_resource *vbuffer;
-   struct pipe_transfer *vbuffer_transfer;
-   GLuint i, numTexCoords, numAttribs;
-   GLboolean emitColor;
-   uint semantic_names[2 + MAX_TEXTURE_UNITS];
-   uint semantic_indexes[2 + MAX_TEXTURE_UNITS];
-   struct pipe_vertex_element velements[2 + MAX_TEXTURE_UNITS];
-   GLbitfield inputs = VERT_BIT_POS;
-
-   st_validate_state(st);
-
-   /* determine if we need vertex color */
-   if (ctx->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL0)
-      emitColor = GL_TRUE;
-   else
-      emitColor = GL_FALSE;
-
-   /* determine how many enabled sets of texcoords */
-   numTexCoords = 0;
-   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-      if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) {
-         inputs |= VERT_BIT_TEX(i);
-         numTexCoords++;
-      }
-   }
-
-   /* total number of attributes per vertex */
-   numAttribs = 1 + emitColor + numTexCoords;
-
-
-   /* create the vertex buffer */
-   vbuffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,
-                                PIPE_USAGE_STREAM,
-                                numAttribs * 4 * 4 * sizeof(GLfloat));
-
-   /* load vertex buffer */
-   {
-#define SET_ATTRIB(VERT, ATTR, X, Y, Z, W)                              \
-      do {                                                              \
-         GLuint k = (((VERT) * numAttribs + (ATTR)) * 4);               \
-         assert(k < 4 * 4 * numAttribs);                                \
-         vbuf[k + 0] = X;                                               \
-         vbuf[k + 1] = Y;                                               \
-         vbuf[k + 2] = Z;                                               \
-         vbuf[k + 3] = W;                                               \
-      } while (0)
-
-      const GLfloat x0 = x, y0 = y, x1 = x + width, y1 = y + height;
-      GLfloat *vbuf = (GLfloat *) pipe_buffer_map(pipe, vbuffer,
-                                                  PIPE_TRANSFER_WRITE,
-                                                  &vbuffer_transfer);
-      GLuint attr;
-      
-      z = CLAMP(z, 0.0f, 1.0f);
-
-      /* positions (in clip coords) */
-      {
-         const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-         const GLfloat fb_width = (GLfloat)fb->Width;
-         const GLfloat fb_height = (GLfloat)fb->Height;
-
-         const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);
-         const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);
-         const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);
-         const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);
-
-         SET_ATTRIB(0, 0, clip_x0, clip_y0, z, 1.0f);   /* lower left */
-         SET_ATTRIB(1, 0, clip_x1, clip_y0, z, 1.0f);   /* lower right */
-         SET_ATTRIB(2, 0, clip_x1, clip_y1, z, 1.0f);   /* upper right */
-         SET_ATTRIB(3, 0, clip_x0, clip_y1, z, 1.0f);   /* upper left */
-
-         semantic_names[0] = TGSI_SEMANTIC_POSITION;
-         semantic_indexes[0] = 0;
-      }
-
-      /* colors */
-      if (emitColor) {
-         const GLfloat *c = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
-         SET_ATTRIB(0, 1, c[0], c[1], c[2], c[3]);
-         SET_ATTRIB(1, 1, c[0], c[1], c[2], c[3]);
-         SET_ATTRIB(2, 1, c[0], c[1], c[2], c[3]);
-         SET_ATTRIB(3, 1, c[0], c[1], c[2], c[3]);
-         semantic_names[1] = TGSI_SEMANTIC_COLOR;
-         semantic_indexes[1] = 0;
-         attr = 2;
-      }
-      else {
-         attr = 1;
-      }
-
-      /* texcoords */
-      for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-         if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) {
-            struct gl_texture_object *obj = ctx->Texture.Unit[i]._Current;
-            struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];
-            const GLfloat wt = (GLfloat) img->Width;
-            const GLfloat ht = (GLfloat) img->Height;
-            const GLfloat s0 = obj->CropRect[0] / wt;
-            const GLfloat t0 = obj->CropRect[1] / ht;
-            const GLfloat s1 = (obj->CropRect[0] + obj->CropRect[2]) / wt;
-            const GLfloat t1 = (obj->CropRect[1] + obj->CropRect[3]) / ht;
-
-            /*printf("crop texcoords: %g, %g .. %g, %g\n", s0, t0, s1, t1);*/
-            SET_ATTRIB(0, attr, s0, t0, 0.0f, 1.0f);  /* lower left */
-            SET_ATTRIB(1, attr, s1, t0, 0.0f, 1.0f);  /* lower right */
-            SET_ATTRIB(2, attr, s1, t1, 0.0f, 1.0f);  /* upper right */
-            SET_ATTRIB(3, attr, s0, t1, 0.0f, 1.0f);  /* upper left */
-
-            semantic_names[attr] = TGSI_SEMANTIC_GENERIC;
-            semantic_indexes[attr] = 0;
-
-            attr++;
-         }
-      }
-
-      pipe_buffer_unmap(pipe, vbuffer_transfer);
-
-#undef SET_ATTRIB
-   }
-
-
-   cso_save_viewport(cso);
-   cso_save_vertex_shader(cso);
-   cso_save_vertex_elements(cso);
-   cso_save_vertex_buffers(cso);
-
-   {
-      void *vs = lookup_shader(pipe, numAttribs,
-                               semantic_names, semantic_indexes);
-      cso_set_vertex_shader_handle(cso, vs);
-   }
-
-   for (i = 0; i < numAttribs; i++) {
-      velements[i].src_offset = i * 4 * sizeof(float);
-      velements[i].instance_divisor = 0;
-      velements[i].vertex_buffer_index = 0;
-      velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-   }
-   cso_set_vertex_elements(cso, numAttribs, velements);
-
-   /* viewport state: viewport matching window dims */
-   {
-      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);
-      const GLfloat width = (GLfloat)fb->Width;
-      const GLfloat height = (GLfloat)fb->Height;
-      struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5f * width;
-      vp.scale[1] = height * (invert ? -0.5f : 0.5f);
-      vp.scale[2] = 1.0f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * width;
-      vp.translate[1] = 0.5f * height;
-      vp.translate[2] = 0.0f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(cso, &vp);
-   }
-
-
-   util_draw_vertex_buffer(pipe, cso, vbuffer,
-                           0,  /* offset */
-                           PIPE_PRIM_TRIANGLE_FAN,
-                           4,  /* verts */
-                           numAttribs); /* attribs/vert */
-
-
-   pipe_resource_reference(&vbuffer, NULL);
-
-   /* restore state */
-   cso_restore_viewport(cso);
-   cso_restore_vertex_shader(cso);
-   cso_restore_vertex_elements(cso);
-   cso_restore_vertex_buffers(cso);
-}
-
-
-void
-st_init_drawtex_functions(struct dd_function_table *functions)
-{
-   functions->DrawTex = st_DrawTex;
-}
-
-
-/**
- * Free any cached shaders
- */
-void
-st_destroy_drawtex(struct st_context *st)
-{
-   GLuint i;
-   for (i = 0; i < NumCachedShaders; i++) {
-      cso_delete_vertex_shader(st->cso_context, CachedShaders[i].handle);
-   }
-   NumCachedShaders = 0;
-}
-
-
-#endif /* FEATURE_OES_draw_texture */
+/**************************************************************************

+ * 

+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * All Rights Reserved.

+ *

+ **************************************************************************/

+

+

+/**

+ * Implementation of glDrawTex() for GL_OES_draw_tex

+ */

+

+

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_drawtex.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+#include "pipe/p_shader_tokens.h"

+#include "util/u_draw_quad.h"

+#include "util/u_simple_shaders.h"

+

+#include "cso_cache/cso_context.h"

+

+

+#if FEATURE_OES_draw_texture

+

+

+struct cached_shader

+{

+   void *handle;

+

+   uint num_attribs;

+   uint semantic_names[2 + MAX_TEXTURE_UNITS];

+   uint semantic_indexes[2 + MAX_TEXTURE_UNITS];

+};

+

+#define MAX_SHADERS (2 * MAX_TEXTURE_UNITS)

+

+/**

+ * Simple linear list cache.

+ * Most of the time there'll only be one cached shader.

+ */

+static struct cached_shader CachedShaders[MAX_SHADERS];

+static GLuint NumCachedShaders = 0;

+

+

+static void *

+lookup_shader(struct pipe_context *pipe,

+              uint num_attribs,

+              const uint *semantic_names,

+              const uint *semantic_indexes)

+{

+   GLuint i, j;

+

+   /* look for existing shader with same attributes */

+   for (i = 0; i < NumCachedShaders; i++) {

+      if (CachedShaders[i].num_attribs == num_attribs) {

+         GLboolean match = GL_TRUE;

+         for (j = 0; j < num_attribs; j++) {

+            if (semantic_names[j] != CachedShaders[i].semantic_names[j] ||

+                semantic_indexes[j] != CachedShaders[i].semantic_indexes[j]) {

+               match = GL_FALSE;

+               break;

+            }

+         }

+         if (match)

+            return CachedShaders[i].handle;

+      }

+   }

+

+   /* not found - create new one now */

+   if (NumCachedShaders >= MAX_SHADERS) {

+      return NULL;

+   }

+

+   CachedShaders[i].num_attribs = num_attribs;

+   for (j = 0; j < num_attribs; j++) {

+      CachedShaders[i].semantic_names[j] = semantic_names[j];

+      CachedShaders[i].semantic_indexes[j] = semantic_indexes[j];

+   }

+

+   CachedShaders[i].handle =

+      util_make_vertex_passthrough_shader(pipe,

+                                          num_attribs,

+                                          semantic_names,

+                                          semantic_indexes);

+   NumCachedShaders++;

+

+   return CachedShaders[i].handle;

+}

+

+static void

+st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,

+           GLfloat width, GLfloat height)

+{

+   struct st_context *st = ctx->st;

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = ctx->st->cso_context;

+   struct pipe_resource *vbuffer;

+   struct pipe_transfer *vbuffer_transfer;

+   GLuint i, numTexCoords, numAttribs;

+   GLboolean emitColor;

+   uint semantic_names[2 + MAX_TEXTURE_UNITS];

+   uint semantic_indexes[2 + MAX_TEXTURE_UNITS];

+   struct pipe_vertex_element velements[2 + MAX_TEXTURE_UNITS];

+   GLbitfield inputs = VERT_BIT_POS;

+

+   st_validate_state(st);

+

+   /* determine if we need vertex color */

+   if (ctx->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL0)

+      emitColor = GL_TRUE;

+   else

+      emitColor = GL_FALSE;

+

+   /* determine how many enabled sets of texcoords */

+   numTexCoords = 0;

+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

+      if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) {

+         inputs |= VERT_BIT_TEX(i);

+         numTexCoords++;

+      }

+   }

+

+   /* total number of attributes per vertex */

+   numAttribs = 1 + emitColor + numTexCoords;

+

+

+   /* create the vertex buffer */

+   vbuffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,

+                                PIPE_USAGE_STREAM,

+                                numAttribs * 4 * 4 * sizeof(GLfloat));

+

+   /* load vertex buffer */

+   {

+#define SET_ATTRIB(VERT, ATTR, X, Y, Z, W)                              \

+      do {                                                              \

+         GLuint k = (((VERT) * numAttribs + (ATTR)) * 4);               \

+         assert(k < 4 * 4 * numAttribs);                                \

+         vbuf[k + 0] = X;                                               \

+         vbuf[k + 1] = Y;                                               \

+         vbuf[k + 2] = Z;                                               \

+         vbuf[k + 3] = W;                                               \

+      } while (0)

+

+      const GLfloat x0 = x, y0 = y, x1 = x + width, y1 = y + height;

+      GLfloat *vbuf = (GLfloat *) pipe_buffer_map(pipe, vbuffer,

+                                                  PIPE_TRANSFER_WRITE,

+                                                  &vbuffer_transfer);

+      GLuint attr;

+      

+      z = CLAMP(z, 0.0f, 1.0f);

+

+      /* positions (in clip coords) */

+      {

+         const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+         const GLfloat fb_width = (GLfloat)fb->Width;

+         const GLfloat fb_height = (GLfloat)fb->Height;

+

+         const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);

+         const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);

+         const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);

+         const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);

+

+         SET_ATTRIB(0, 0, clip_x0, clip_y0, z, 1.0f);   /* lower left */

+         SET_ATTRIB(1, 0, clip_x1, clip_y0, z, 1.0f);   /* lower right */

+         SET_ATTRIB(2, 0, clip_x1, clip_y1, z, 1.0f);   /* upper right */

+         SET_ATTRIB(3, 0, clip_x0, clip_y1, z, 1.0f);   /* upper left */

+

+         semantic_names[0] = TGSI_SEMANTIC_POSITION;

+         semantic_indexes[0] = 0;

+      }

+

+      /* colors */

+      if (emitColor) {

+         const GLfloat *c = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];

+         SET_ATTRIB(0, 1, c[0], c[1], c[2], c[3]);

+         SET_ATTRIB(1, 1, c[0], c[1], c[2], c[3]);

+         SET_ATTRIB(2, 1, c[0], c[1], c[2], c[3]);

+         SET_ATTRIB(3, 1, c[0], c[1], c[2], c[3]);

+         semantic_names[1] = TGSI_SEMANTIC_COLOR;

+         semantic_indexes[1] = 0;

+         attr = 2;

+      }

+      else {

+         attr = 1;

+      }

+

+      /* texcoords */

+      for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

+         if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) {

+            struct gl_texture_object *obj = ctx->Texture.Unit[i]._Current;

+            struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];

+            const GLfloat wt = (GLfloat) img->Width;

+            const GLfloat ht = (GLfloat) img->Height;

+            const GLfloat s0 = obj->CropRect[0] / wt;

+            const GLfloat t0 = obj->CropRect[1] / ht;

+            const GLfloat s1 = (obj->CropRect[0] + obj->CropRect[2]) / wt;

+            const GLfloat t1 = (obj->CropRect[1] + obj->CropRect[3]) / ht;

+

+            /*printf("crop texcoords: %g, %g .. %g, %g\n", s0, t0, s1, t1);*/

+            SET_ATTRIB(0, attr, s0, t0, 0.0f, 1.0f);  /* lower left */

+            SET_ATTRIB(1, attr, s1, t0, 0.0f, 1.0f);  /* lower right */

+            SET_ATTRIB(2, attr, s1, t1, 0.0f, 1.0f);  /* upper right */

+            SET_ATTRIB(3, attr, s0, t1, 0.0f, 1.0f);  /* upper left */

+

+            semantic_names[attr] = TGSI_SEMANTIC_GENERIC;

+            semantic_indexes[attr] = 0;

+

+            attr++;

+         }

+      }

+

+      pipe_buffer_unmap(pipe, vbuffer_transfer);

+

+#undef SET_ATTRIB

+   }

+

+

+   cso_save_viewport(cso);

+   cso_save_vertex_shader(cso);

+   cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

+

+   {

+      void *vs = lookup_shader(pipe, numAttribs,

+                               semantic_names, semantic_indexes);

+      cso_set_vertex_shader_handle(cso, vs);

+   }

+

+   for (i = 0; i < numAttribs; i++) {

+      velements[i].src_offset = i * 4 * sizeof(float);

+      velements[i].instance_divisor = 0;

+      velements[i].vertex_buffer_index = 0;

+      velements[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;

+   }

+   cso_set_vertex_elements(cso, numAttribs, velements);

+

+   /* viewport state: viewport matching window dims */

+   {

+      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);

+      const GLfloat width = (GLfloat)fb->Width;

+      const GLfloat height = (GLfloat)fb->Height;

+      struct pipe_viewport_state vp;

+      vp.scale[0] =  0.5f * width;

+      vp.scale[1] = height * (invert ? -0.5f : 0.5f);

+      vp.scale[2] = 1.0f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * width;

+      vp.translate[1] = 0.5f * height;

+      vp.translate[2] = 0.0f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(cso, &vp);

+   }

+

+

+   util_draw_vertex_buffer(pipe, cso, vbuffer,

+                           0,  /* offset */

+                           PIPE_PRIM_TRIANGLE_FAN,

+                           4,  /* verts */

+                           numAttribs); /* attribs/vert */

+

+

+   pipe_resource_reference(&vbuffer, NULL);

+

+   /* restore state */

+   cso_restore_viewport(cso);

+   cso_restore_vertex_shader(cso);

+   cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

+}

+

+

+void

+st_init_drawtex_functions(struct dd_function_table *functions)

+{

+   functions->DrawTex = st_DrawTex;

+}

+

+

+/**

+ * Free any cached shaders

+ */

+void

+st_destroy_drawtex(struct st_context *st)

+{

+   GLuint i;

+   for (i = 0; i < NumCachedShaders; i++) {

+      cso_delete_vertex_shader(st->cso_context, CachedShaders[i].handle);

+   }

+   NumCachedShaders = 0;

+}

+

+

+#endif /* FEATURE_OES_draw_texture */

diff --git a/mesalib/src/mesa/state_tracker/st_cb_fbo.c b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
index ae49434ca..534fa7041 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_fbo.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
@@ -1,645 +1,645 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-/**
- * Framebuffer/renderbuffer functions.
- *
- * \author Brian Paul
- */
-
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/fbobject.h"
-#include "main/framebuffer.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/renderbuffer.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "st_context.h"
-#include "st_cb_fbo.h"
-#include "st_cb_flush.h"
-#include "st_format.h"
-#include "st_texture.h"
-#include "st_manager.h"
-
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_surface.h"
-
-
-/**
- * gl_renderbuffer::AllocStorage()
- * This is called to allocate the original drawing surface, and
- * during window resize.
- */
-static GLboolean
-st_renderbuffer_alloc_storage(struct gl_context * ctx,
-                              struct gl_renderbuffer *rb,
-                              GLenum internalFormat,
-                              GLuint width, GLuint height)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = st->pipe->screen;
-   struct st_renderbuffer *strb = st_renderbuffer(rb);
-   enum pipe_format format;
-   struct pipe_surface surf_tmpl;
-
-   if (strb->format != PIPE_FORMAT_NONE)
-      format = strb->format;
-   else
-      format = st_choose_renderbuffer_format(screen, internalFormat,
-                                             rb->NumSamples);
-
-   if (format == PIPE_FORMAT_NONE) {
-      return FALSE;
-   }
-
-   /* init renderbuffer fields */
-   strb->Base.Width  = width;
-   strb->Base.Height = height;
-   strb->Base.Format = st_pipe_format_to_mesa_format(format);
-   strb->Base._BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);
-   strb->Base.DataType = st_format_datatype(format);
-
-   strb->defined = GL_FALSE;  /* undefined contents now */
-
-   if (strb->software) {
-      size_t size;
-      
-      free(strb->data);
-
-      assert(strb->format != PIPE_FORMAT_NONE);
-      
-      strb->stride = util_format_get_stride(strb->format, width);
-      size = util_format_get_2d_size(strb->format, strb->stride, height);
-      
-      strb->data = malloc(size);
-      
-      return strb->data != NULL;
-   }
-   else {
-      struct pipe_resource template;
-    
-      /* Free the old surface and texture
-       */
-      pipe_surface_reference( &strb->surface, NULL );
-      pipe_resource_reference( &strb->texture, NULL );
-      pipe_sampler_view_reference(&strb->sampler_view, NULL);
-
-      /* Setup new texture template.
-       */
-      memset(&template, 0, sizeof(template));
-      template.target = st->internal_target;
-      template.format = format;
-      template.width0 = width;
-      template.height0 = height;
-      template.depth0 = 1;
-      template.array_size = 1;
-      template.last_level = 0;
-      template.nr_samples = rb->NumSamples;
-      if (util_format_is_depth_or_stencil(format)) {
-         template.bind = PIPE_BIND_DEPTH_STENCIL;
-      }
-      else {
-         template.bind = (PIPE_BIND_DISPLAY_TARGET |
-                          PIPE_BIND_RENDER_TARGET);
-      }
-
-      strb->texture = screen->resource_create(screen, &template);
-
-      if (!strb->texture) 
-         return FALSE;
-
-      memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-      u_surface_default_template(&surf_tmpl, strb->texture, template.bind);
-      strb->surface = pipe->create_surface(pipe,
-                                           strb->texture,
-                                           &surf_tmpl);
-      if (strb->surface) {
-         assert(strb->surface->texture);
-         assert(strb->surface->format);
-         assert(strb->surface->width == width);
-         assert(strb->surface->height == height);
-      }
-
-      return strb->surface != NULL;
-   }
-}
-
-
-/**
- * gl_renderbuffer::Delete()
- */
-static void
-st_renderbuffer_delete(struct gl_renderbuffer *rb)
-{
-   struct st_renderbuffer *strb = st_renderbuffer(rb);
-   ASSERT(strb);
-   pipe_surface_reference(&strb->surface, NULL);
-   pipe_resource_reference(&strb->texture, NULL);
-   pipe_sampler_view_reference(&strb->sampler_view, NULL);
-   free(strb->data);
-   free(strb);
-}
-
-
-/**
- * gl_renderbuffer::GetPointer()
- */
-static void *
-null_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb,
-                 GLint x, GLint y)
-{
-   /* By returning NULL we force all software rendering to go through
-    * the span routines.
-    */
-#if 0
-   assert(0);  /* Should never get called with softpipe */
-#endif
-   return NULL;
-}
-
-
-/**
- * Called via ctx->Driver.NewFramebuffer()
- */
-static struct gl_framebuffer *
-st_new_framebuffer(struct gl_context *ctx, GLuint name)
-{
-   /* XXX not sure we need to subclass gl_framebuffer for pipe */
-   return _mesa_new_framebuffer(ctx, name);
-}
-
-
-/**
- * Called via ctx->Driver.NewRenderbuffer()
- */
-static struct gl_renderbuffer *
-st_new_renderbuffer(struct gl_context *ctx, GLuint name)
-{
-   struct st_renderbuffer *strb = ST_CALLOC_STRUCT(st_renderbuffer);
-   if (strb) {
-      _mesa_init_renderbuffer(&strb->Base, name);
-      strb->Base.Delete = st_renderbuffer_delete;
-      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
-      strb->Base.GetPointer = null_get_pointer;
-      strb->format = PIPE_FORMAT_NONE;
-      return &strb->Base;
-   }
-   return NULL;
-}
-
-
-/**
- * Allocate a renderbuffer for a an on-screen window (not a user-created
- * renderbuffer).  The window system code determines the format.
- */
-struct gl_renderbuffer *
-st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
-{
-   struct st_renderbuffer *strb;
-
-   strb = ST_CALLOC_STRUCT(st_renderbuffer);
-   if (!strb) {
-      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
-      return NULL;
-   }
-
-   _mesa_init_renderbuffer(&strb->Base, 0);
-   strb->Base.ClassID = 0x4242; /* just a unique value */
-   strb->Base.NumSamples = samples;
-   strb->Base.Format = st_pipe_format_to_mesa_format(format);
-   strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format);
-   strb->Base.DataType = st_format_datatype(format);
-   strb->format = format;
-   strb->software = sw;
-   
-   switch (format) {
-   case PIPE_FORMAT_R8G8B8A8_UNORM:
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-   case PIPE_FORMAT_R8G8B8X8_UNORM:
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-   case PIPE_FORMAT_X8R8G8B8_UNORM:
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      strb->Base.InternalFormat = GL_RGBA;
-      break;
-   case PIPE_FORMAT_Z16_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;
-      break;
-   case PIPE_FORMAT_Z32_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
-      break;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-   case PIPE_FORMAT_Z24X8_UNORM:
-   case PIPE_FORMAT_X8Z24_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
-      break;
-   case PIPE_FORMAT_S8_USCALED:
-      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
-      break;
-   case PIPE_FORMAT_R16G16B16A16_SNORM:
-      strb->Base.InternalFormat = GL_RGBA16;
-      break;
-   case PIPE_FORMAT_R8_UNORM:
-      strb->Base.InternalFormat = GL_R8;
-      break;
-   case PIPE_FORMAT_R8G8_UNORM:
-      strb->Base.InternalFormat = GL_RG8;
-      break;
-   case PIPE_FORMAT_R16_UNORM:
-      strb->Base.InternalFormat = GL_R16;
-      break;
-   case PIPE_FORMAT_R16G16_UNORM:
-      strb->Base.InternalFormat = GL_RG16;
-      break;
-   default:
-      _mesa_problem(NULL,
-		    "Unexpected format in st_new_renderbuffer_fb");
-      free(strb);
-      return NULL;
-   }
-
-   /* st-specific methods */
-   strb->Base.Delete = st_renderbuffer_delete;
-   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
-   strb->Base.GetPointer = null_get_pointer;
-
-   /* surface is allocated in st_renderbuffer_alloc_storage() */
-   strb->surface = NULL;
-
-   return &strb->Base;
-}
-
-
-
-
-/**
- * Called via ctx->Driver.BindFramebufferEXT().
- */
-static void
-st_bind_framebuffer(struct gl_context *ctx, GLenum target,
-                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
-{
-
-}
-
-/**
- * Called by ctx->Driver.FramebufferRenderbuffer
- */
-static void
-st_framebuffer_renderbuffer(struct gl_context *ctx, 
-                            struct gl_framebuffer *fb,
-                            GLenum attachment,
-                            struct gl_renderbuffer *rb)
-{
-   /* XXX no need for derivation? */
-   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
-}
-
-
-/**
- * Called by ctx->Driver.RenderTexture
- */
-static void
-st_render_texture(struct gl_context *ctx,
-                  struct gl_framebuffer *fb,
-                  struct gl_renderbuffer_attachment *att)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct st_renderbuffer *strb;
-   struct gl_renderbuffer *rb;
-   struct pipe_resource *pt = st_get_texobj_resource(att->Texture);
-   struct st_texture_object *stObj;
-   const struct gl_texture_image *texImage;
-   struct pipe_surface surf_tmpl;
-
-   /* When would this fail?  Perhaps assert? */
-   if (!pt) 
-      return;
-
-   /* get pointer to texture image we're rendeing to */
-   texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
-
-   /* create new renderbuffer which wraps the texture image */
-   rb = st_new_renderbuffer(ctx, 0);
-   if (!rb) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");
-      return;
-   }
-
-   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);
-   assert(rb->RefCount == 1);
-   rb->AllocStorage = NULL; /* should not get called */
-   strb = st_renderbuffer(rb);
-
-   assert(strb->Base.RefCount > 0);
-
-   /* get the texture for the texture object */
-   stObj = st_texture_object(att->Texture);
-
-   /* point renderbuffer at texobject */
-   strb->rtt = stObj;
-   strb->rtt_level = att->TextureLevel;
-   strb->rtt_face = att->CubeMapFace;
-   strb->rtt_slice = att->Zoffset;
-
-   rb->Width = texImage->Width2;
-   rb->Height = texImage->Height2;
-   rb->_BaseFormat = texImage->_BaseFormat;
-   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/
-
-   /*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/
-
-   pipe_resource_reference( &strb->texture, pt );
-
-   pipe_surface_reference(&strb->surface, NULL);
-
-   pipe_sampler_view_reference(&strb->sampler_view,
-                               st_get_texture_sampler_view(stObj, pipe));
-
-   assert(strb->rtt_level <= strb->texture->last_level);
-
-   /* new surface for rendering into the texture */
-   memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-   surf_tmpl.format = ctx->Color.sRGBEnabled ? strb->texture->format : util_format_linear(strb->texture->format);
-   surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;
-   surf_tmpl.u.tex.level = strb->rtt_level;
-   surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;
-   surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;
-   strb->surface = pipe->create_surface(pipe,
-                                        strb->texture,
-                                        &surf_tmpl);
-
-   strb->format = pt->format;
-
-   strb->Base.Format = st_pipe_format_to_mesa_format(pt->format);
-   strb->Base.DataType = st_format_datatype(pt->format);
-
-   /*
-   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",
-          att->Texture, pt, strb->surface, rb->Width, rb->Height);
-   */
-
-   /* Invalidate buffer state so that the pipe's framebuffer state
-    * gets updated.
-    * That's where the new renderbuffer (which we just created) gets
-    * passed to the pipe as a (color/depth) render target.
-    */
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-/**
- * Called via ctx->Driver.FinishRenderTexture.
- */
-static void
-st_finish_render_texture(struct gl_context *ctx,
-                         struct gl_renderbuffer_attachment *att)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);
-
-   if (!strb)
-      return;
-
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   strb->rtt = NULL;
-
-   /*
-   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);
-   */
-
-   /* restore previous framebuffer state */
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-/**
- * Validate a renderbuffer attachment for a particular set of bindings.
- */
-static GLboolean
-st_validate_attachment(struct gl_context *ctx,
-		       struct pipe_screen *screen,
-		       const struct gl_renderbuffer_attachment *att,
-		       unsigned bindings)
-{
-   const struct st_texture_object *stObj = st_texture_object(att->Texture);
-   enum pipe_format format;
-   gl_format texFormat;
-
-   /* Only validate texture attachments for now, since
-    * st_renderbuffer_alloc_storage makes sure that
-    * the format is supported.
-    */
-   if (att->Type != GL_TEXTURE)
-      return GL_TRUE;
-
-   if (!stObj)
-      return GL_FALSE;
-
-   format = stObj->pt->format;
-   texFormat =
-      stObj->base.Image[att->CubeMapFace][att->TextureLevel]->TexFormat;
-
-   /* If the encoding is sRGB and sRGB rendering cannot be enabled,
-    * check for linear format support instead.
-    * Later when we create a surface, we change the format to a linear one. */
-   if (!ctx->Const.sRGBCapable &&
-       _mesa_get_format_color_encoding(texFormat) == GL_SRGB) {
-      const gl_format linearFormat = _mesa_get_srgb_format_linear(texFormat);
-      format = st_mesa_format_to_pipe_format(linearFormat);
-   }
-
-   return screen->is_format_supported(screen, format,
-                                      PIPE_TEXTURE_2D,
-                                      stObj->pt->nr_samples, bindings, 0);
-}
-
-
-/**
- * Check if two renderbuffer attachments name a combined depth/stencil
- * renderbuffer.
- */
-GLboolean
-st_is_depth_stencil_combined(const struct gl_renderbuffer_attachment *depth,
-                             const struct gl_renderbuffer_attachment *stencil)
-{
-   assert(depth && stencil);
-
-   if (depth->Type == stencil->Type) {
-      if (depth->Type == GL_RENDERBUFFER_EXT &&
-          depth->Renderbuffer == stencil->Renderbuffer)
-         return GL_TRUE;
-
-      if (depth->Type == GL_TEXTURE &&
-          depth->Texture == stencil->Texture)
-         return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
- 
-
-/**
- * Check that the framebuffer configuration is valid in terms of what
- * the driver can support.
- *
- * For Gallium we only supports combined Z+stencil, not separate buffers.
- */
-static void
-st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_screen *screen = st->pipe->screen;
-   const struct gl_renderbuffer_attachment *depth =
-         &fb->Attachment[BUFFER_DEPTH];
-   const struct gl_renderbuffer_attachment *stencil =
-         &fb->Attachment[BUFFER_STENCIL];
-   GLuint i;
-
-   if (depth->Type && stencil->Type && depth->Type != stencil->Type) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (depth->Type == GL_RENDERBUFFER_EXT &&
-       stencil->Type == GL_RENDERBUFFER_EXT &&
-       depth->Renderbuffer != stencil->Renderbuffer) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (depth->Type == GL_TEXTURE &&
-       stencil->Type == GL_TEXTURE &&
-       depth->Texture != stencil->Texture) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-
-   if (!st_validate_attachment(ctx,
-                               screen,
-                               depth,
-			       PIPE_BIND_DEPTH_STENCIL)) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (!st_validate_attachment(ctx,
-                               screen,
-                               stencil,
-			       PIPE_BIND_DEPTH_STENCIL)) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {
-      if (!st_validate_attachment(ctx,
-                                  screen,
-				  &fb->Attachment[BUFFER_COLOR0 + i],
-				  PIPE_BIND_RENDER_TARGET)) {
-	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-	 return;
-      }
-   }
-}
-
-
-/**
- * Called via glDrawBuffer.
- */
-static void
-st_DrawBuffers(struct gl_context *ctx, GLsizei count, const GLenum *buffers)
-{
-   struct st_context *st = st_context(ctx);
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   GLuint i;
-
-   (void) count;
-   (void) buffers;
-
-   /* add the renderbuffers on demand */
-   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
-      gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];
-      st_manager_add_color_renderbuffer(st, fb, idx);
-   }
-}
-
-
-/**
- * Called via glReadBuffer.
- */
-static void
-st_ReadBuffer(struct gl_context *ctx, GLenum buffer)
-{
-   struct st_context *st = st_context(ctx);
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-
-   (void) buffer;
-
-   /* add the renderbuffer on demand */
-   st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex);
-}
-
-
-void st_init_fbo_functions(struct dd_function_table *functions)
-{
-#if FEATURE_EXT_framebuffer_object
-   functions->NewFramebuffer = st_new_framebuffer;
-   functions->NewRenderbuffer = st_new_renderbuffer;
-   functions->BindFramebuffer = st_bind_framebuffer;
-   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;
-   functions->RenderTexture = st_render_texture;
-   functions->FinishRenderTexture = st_finish_render_texture;
-   functions->ValidateFramebuffer = st_validate_framebuffer;
-#endif
-   /* no longer needed by core Mesa, drivers handle resizes...
-   functions->ResizeBuffers = st_resize_buffers;
-   */
-
-   functions->DrawBuffers = st_DrawBuffers;
-   functions->ReadBuffer = st_ReadBuffer;
-}
-
-/* XXX unused ? */
-struct pipe_sampler_view *
-st_get_renderbuffer_sampler_view(struct st_renderbuffer *rb,
-                                 struct pipe_context *pipe)
-{
-   if (!rb->sampler_view) {
-      rb->sampler_view = st_create_texture_sampler_view(pipe, rb->texture);
-   }
-
-   return rb->sampler_view;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * Framebuffer/renderbuffer functions.

+ *

+ * \author Brian Paul

+ */

+

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/fbobject.h"

+#include "main/framebuffer.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/renderbuffer.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "st_context.h"

+#include "st_cb_fbo.h"

+#include "st_cb_flush.h"

+#include "st_format.h"

+#include "st_texture.h"

+#include "st_manager.h"

+

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_surface.h"

+

+

+/**

+ * gl_renderbuffer::AllocStorage()

+ * This is called to allocate the original drawing surface, and

+ * during window resize.

+ */

+static GLboolean

+st_renderbuffer_alloc_storage(struct gl_context * ctx,

+                              struct gl_renderbuffer *rb,

+                              GLenum internalFormat,

+                              GLuint width, GLuint height)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = st->pipe->screen;

+   struct st_renderbuffer *strb = st_renderbuffer(rb);

+   enum pipe_format format;

+   struct pipe_surface surf_tmpl;

+

+   if (strb->format != PIPE_FORMAT_NONE)

+      format = strb->format;

+   else

+      format = st_choose_renderbuffer_format(screen, internalFormat,

+                                             rb->NumSamples);

+

+   if (format == PIPE_FORMAT_NONE) {

+      return FALSE;

+   }

+

+   /* init renderbuffer fields */

+   strb->Base.Width  = width;

+   strb->Base.Height = height;

+   strb->Base.Format = st_pipe_format_to_mesa_format(format);

+   strb->Base._BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);

+   strb->Base.DataType = st_format_datatype(format);

+

+   strb->defined = GL_FALSE;  /* undefined contents now */

+

+   if (strb->software) {

+      size_t size;

+      

+      free(strb->data);

+

+      assert(strb->format != PIPE_FORMAT_NONE);

+      

+      strb->stride = util_format_get_stride(strb->format, width);

+      size = util_format_get_2d_size(strb->format, strb->stride, height);

+      

+      strb->data = malloc(size);

+      

+      return strb->data != NULL;

+   }

+   else {

+      struct pipe_resource template;

+    

+      /* Free the old surface and texture

+       */

+      pipe_surface_reference( &strb->surface, NULL );

+      pipe_resource_reference( &strb->texture, NULL );

+      pipe_sampler_view_reference(&strb->sampler_view, NULL);

+

+      /* Setup new texture template.

+       */

+      memset(&template, 0, sizeof(template));

+      template.target = st->internal_target;

+      template.format = format;

+      template.width0 = width;

+      template.height0 = height;

+      template.depth0 = 1;

+      template.array_size = 1;

+      template.last_level = 0;

+      template.nr_samples = rb->NumSamples;

+      if (util_format_is_depth_or_stencil(format)) {

+         template.bind = PIPE_BIND_DEPTH_STENCIL;

+      }

+      else {

+         template.bind = (PIPE_BIND_DISPLAY_TARGET |

+                          PIPE_BIND_RENDER_TARGET);

+      }

+

+      strb->texture = screen->resource_create(screen, &template);

+

+      if (!strb->texture) 

+         return FALSE;

+

+      memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+      u_surface_default_template(&surf_tmpl, strb->texture, template.bind);

+      strb->surface = pipe->create_surface(pipe,

+                                           strb->texture,

+                                           &surf_tmpl);

+      if (strb->surface) {

+         assert(strb->surface->texture);

+         assert(strb->surface->format);

+         assert(strb->surface->width == width);

+         assert(strb->surface->height == height);

+      }

+

+      return strb->surface != NULL;

+   }

+}

+

+

+/**

+ * gl_renderbuffer::Delete()

+ */

+static void

+st_renderbuffer_delete(struct gl_renderbuffer *rb)

+{

+   struct st_renderbuffer *strb = st_renderbuffer(rb);

+   ASSERT(strb);

+   pipe_surface_reference(&strb->surface, NULL);

+   pipe_resource_reference(&strb->texture, NULL);

+   pipe_sampler_view_reference(&strb->sampler_view, NULL);

+   free(strb->data);

+   free(strb);

+}

+

+

+/**

+ * gl_renderbuffer::GetPointer()

+ */

+static void *

+null_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb,

+                 GLint x, GLint y)

+{

+   /* By returning NULL we force all software rendering to go through

+    * the span routines.

+    */

+#if 0

+   assert(0);  /* Should never get called with softpipe */

+#endif

+   return NULL;

+}

+

+

+/**

+ * Called via ctx->Driver.NewFramebuffer()

+ */

+static struct gl_framebuffer *

+st_new_framebuffer(struct gl_context *ctx, GLuint name)

+{

+   /* XXX not sure we need to subclass gl_framebuffer for pipe */

+   return _mesa_new_framebuffer(ctx, name);

+}

+

+

+/**

+ * Called via ctx->Driver.NewRenderbuffer()

+ */

+static struct gl_renderbuffer *

+st_new_renderbuffer(struct gl_context *ctx, GLuint name)

+{

+   struct st_renderbuffer *strb = ST_CALLOC_STRUCT(st_renderbuffer);

+   if (strb) {

+      _mesa_init_renderbuffer(&strb->Base, name);

+      strb->Base.Delete = st_renderbuffer_delete;

+      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;

+      strb->Base.GetPointer = null_get_pointer;

+      strb->format = PIPE_FORMAT_NONE;

+      return &strb->Base;

+   }

+   return NULL;

+}

+

+

+/**

+ * Allocate a renderbuffer for a an on-screen window (not a user-created

+ * renderbuffer).  The window system code determines the format.

+ */

+struct gl_renderbuffer *

+st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)

+{

+   struct st_renderbuffer *strb;

+

+   strb = ST_CALLOC_STRUCT(st_renderbuffer);

+   if (!strb) {

+      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");

+      return NULL;

+   }

+

+   _mesa_init_renderbuffer(&strb->Base, 0);

+   strb->Base.ClassID = 0x4242; /* just a unique value */

+   strb->Base.NumSamples = samples;

+   strb->Base.Format = st_pipe_format_to_mesa_format(format);

+   strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format);

+   strb->Base.DataType = st_format_datatype(format);

+   strb->format = format;

+   strb->software = sw;

+   

+   switch (format) {

+   case PIPE_FORMAT_R8G8B8A8_UNORM:

+   case PIPE_FORMAT_B8G8R8A8_UNORM:

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+   case PIPE_FORMAT_R8G8B8X8_UNORM:

+   case PIPE_FORMAT_B8G8R8X8_UNORM:

+   case PIPE_FORMAT_X8R8G8B8_UNORM:

+   case PIPE_FORMAT_B5G5R5A1_UNORM:

+   case PIPE_FORMAT_B4G4R4A4_UNORM:

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      strb->Base.InternalFormat = GL_RGBA;

+      break;

+   case PIPE_FORMAT_Z16_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;

+      break;

+   case PIPE_FORMAT_Z32_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;

+      break;

+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+   case PIPE_FORMAT_Z24X8_UNORM:

+   case PIPE_FORMAT_X8Z24_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;

+      break;

+   case PIPE_FORMAT_S8_USCALED:

+      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;

+      break;

+   case PIPE_FORMAT_R16G16B16A16_SNORM:

+      strb->Base.InternalFormat = GL_RGBA16;

+      break;

+   case PIPE_FORMAT_R8_UNORM:

+      strb->Base.InternalFormat = GL_R8;

+      break;

+   case PIPE_FORMAT_R8G8_UNORM:

+      strb->Base.InternalFormat = GL_RG8;

+      break;

+   case PIPE_FORMAT_R16_UNORM:

+      strb->Base.InternalFormat = GL_R16;

+      break;

+   case PIPE_FORMAT_R16G16_UNORM:

+      strb->Base.InternalFormat = GL_RG16;

+      break;

+   default:

+      _mesa_problem(NULL,

+		    "Unexpected format in st_new_renderbuffer_fb");

+      free(strb);

+      return NULL;

+   }

+

+   /* st-specific methods */

+   strb->Base.Delete = st_renderbuffer_delete;

+   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;

+   strb->Base.GetPointer = null_get_pointer;

+

+   /* surface is allocated in st_renderbuffer_alloc_storage() */

+   strb->surface = NULL;

+

+   return &strb->Base;

+}

+

+

+

+

+/**

+ * Called via ctx->Driver.BindFramebufferEXT().

+ */

+static void

+st_bind_framebuffer(struct gl_context *ctx, GLenum target,

+                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)

+{

+

+}

+

+/**

+ * Called by ctx->Driver.FramebufferRenderbuffer

+ */

+static void

+st_framebuffer_renderbuffer(struct gl_context *ctx, 

+                            struct gl_framebuffer *fb,

+                            GLenum attachment,

+                            struct gl_renderbuffer *rb)

+{

+   /* XXX no need for derivation? */

+   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);

+}

+

+

+/**

+ * Called by ctx->Driver.RenderTexture

+ */

+static void

+st_render_texture(struct gl_context *ctx,

+                  struct gl_framebuffer *fb,

+                  struct gl_renderbuffer_attachment *att)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct st_renderbuffer *strb;

+   struct gl_renderbuffer *rb;

+   struct pipe_resource *pt = st_get_texobj_resource(att->Texture);

+   struct st_texture_object *stObj;

+   const struct gl_texture_image *texImage;

+   struct pipe_surface surf_tmpl;

+

+   /* When would this fail?  Perhaps assert? */

+   if (!pt) 

+      return;

+

+   /* get pointer to texture image we're rendeing to */

+   texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];

+

+   /* create new renderbuffer which wraps the texture image */

+   rb = st_new_renderbuffer(ctx, 0);

+   if (!rb) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");

+      return;

+   }

+

+   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);

+   assert(rb->RefCount == 1);

+   rb->AllocStorage = NULL; /* should not get called */

+   strb = st_renderbuffer(rb);

+

+   assert(strb->Base.RefCount > 0);

+

+   /* get the texture for the texture object */

+   stObj = st_texture_object(att->Texture);

+

+   /* point renderbuffer at texobject */

+   strb->rtt = stObj;

+   strb->rtt_level = att->TextureLevel;

+   strb->rtt_face = att->CubeMapFace;

+   strb->rtt_slice = att->Zoffset;

+

+   rb->Width = texImage->Width2;

+   rb->Height = texImage->Height2;

+   rb->_BaseFormat = texImage->_BaseFormat;

+   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/

+

+   /*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/

+

+   pipe_resource_reference( &strb->texture, pt );

+

+   pipe_surface_reference(&strb->surface, NULL);

+

+   pipe_sampler_view_reference(&strb->sampler_view,

+                               st_get_texture_sampler_view(stObj, pipe));

+

+   assert(strb->rtt_level <= strb->texture->last_level);

+

+   /* new surface for rendering into the texture */

+   memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+   surf_tmpl.format = ctx->Color.sRGBEnabled ? strb->texture->format : util_format_linear(strb->texture->format);

+   surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;

+   surf_tmpl.u.tex.level = strb->rtt_level;

+   surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;

+   surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;

+   strb->surface = pipe->create_surface(pipe,

+                                        strb->texture,

+                                        &surf_tmpl);

+

+   strb->format = pt->format;

+

+   strb->Base.Format = st_pipe_format_to_mesa_format(pt->format);

+   strb->Base.DataType = st_format_datatype(pt->format);

+

+   /*

+   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",

+          att->Texture, pt, strb->surface, rb->Width, rb->Height);

+   */

+

+   /* Invalidate buffer state so that the pipe's framebuffer state

+    * gets updated.

+    * That's where the new renderbuffer (which we just created) gets

+    * passed to the pipe as a (color/depth) render target.

+    */

+   st_invalidate_state(ctx, _NEW_BUFFERS);

+}

+

+

+/**

+ * Called via ctx->Driver.FinishRenderTexture.

+ */

+static void

+st_finish_render_texture(struct gl_context *ctx,

+                         struct gl_renderbuffer_attachment *att)

+{

+   struct st_context *st = st_context(ctx);

+   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);

+

+   if (!strb)

+      return;

+

+   st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);

+

+   strb->rtt = NULL;

+

+   /*

+   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);

+   */

+

+   /* restore previous framebuffer state */

+   st_invalidate_state(ctx, _NEW_BUFFERS);

+}

+

+

+/**

+ * Validate a renderbuffer attachment for a particular set of bindings.

+ */

+static GLboolean

+st_validate_attachment(struct gl_context *ctx,

+		       struct pipe_screen *screen,

+		       const struct gl_renderbuffer_attachment *att,

+		       unsigned bindings)

+{

+   const struct st_texture_object *stObj = st_texture_object(att->Texture);

+   enum pipe_format format;

+   gl_format texFormat;

+

+   /* Only validate texture attachments for now, since

+    * st_renderbuffer_alloc_storage makes sure that

+    * the format is supported.

+    */

+   if (att->Type != GL_TEXTURE)

+      return GL_TRUE;

+

+   if (!stObj)

+      return GL_FALSE;

+

+   format = stObj->pt->format;

+   texFormat =

+      stObj->base.Image[att->CubeMapFace][att->TextureLevel]->TexFormat;

+

+   /* If the encoding is sRGB and sRGB rendering cannot be enabled,

+    * check for linear format support instead.

+    * Later when we create a surface, we change the format to a linear one. */

+   if (!ctx->Const.sRGBCapable &&

+       _mesa_get_format_color_encoding(texFormat) == GL_SRGB) {

+      const gl_format linearFormat = _mesa_get_srgb_format_linear(texFormat);

+      format = st_mesa_format_to_pipe_format(linearFormat);

+   }

+

+   return screen->is_format_supported(screen, format,

+                                      PIPE_TEXTURE_2D,

+                                      stObj->pt->nr_samples, bindings, 0);

+}

+

+

+/**

+ * Check if two renderbuffer attachments name a combined depth/stencil

+ * renderbuffer.

+ */

+GLboolean

+st_is_depth_stencil_combined(const struct gl_renderbuffer_attachment *depth,

+                             const struct gl_renderbuffer_attachment *stencil)

+{

+   assert(depth && stencil);

+

+   if (depth->Type == stencil->Type) {

+      if (depth->Type == GL_RENDERBUFFER_EXT &&

+          depth->Renderbuffer == stencil->Renderbuffer)

+         return GL_TRUE;

+

+      if (depth->Type == GL_TEXTURE &&

+          depth->Texture == stencil->Texture)

+         return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+ 

+

+/**

+ * Check that the framebuffer configuration is valid in terms of what

+ * the driver can support.

+ *

+ * For Gallium we only supports combined Z+stencil, not separate buffers.

+ */

+static void

+st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_screen *screen = st->pipe->screen;

+   const struct gl_renderbuffer_attachment *depth =

+         &fb->Attachment[BUFFER_DEPTH];

+   const struct gl_renderbuffer_attachment *stencil =

+         &fb->Attachment[BUFFER_STENCIL];

+   GLuint i;

+

+   if (depth->Type && stencil->Type && depth->Type != stencil->Type) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (depth->Type == GL_RENDERBUFFER_EXT &&

+       stencil->Type == GL_RENDERBUFFER_EXT &&

+       depth->Renderbuffer != stencil->Renderbuffer) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (depth->Type == GL_TEXTURE &&

+       stencil->Type == GL_TEXTURE &&

+       depth->Texture != stencil->Texture) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+

+   if (!st_validate_attachment(ctx,

+                               screen,

+                               depth,

+			       PIPE_BIND_DEPTH_STENCIL)) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (!st_validate_attachment(ctx,

+                               screen,

+                               stencil,

+			       PIPE_BIND_DEPTH_STENCIL)) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {

+      if (!st_validate_attachment(ctx,

+                                  screen,

+				  &fb->Attachment[BUFFER_COLOR0 + i],

+				  PIPE_BIND_RENDER_TARGET)) {

+	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+	 return;

+      }

+   }

+}

+

+

+/**

+ * Called via glDrawBuffer.

+ */

+static void

+st_DrawBuffers(struct gl_context *ctx, GLsizei count, const GLenum *buffers)

+{

+   struct st_context *st = st_context(ctx);

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   GLuint i;

+

+   (void) count;

+   (void) buffers;

+

+   /* add the renderbuffers on demand */

+   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {

+      gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];

+      st_manager_add_color_renderbuffer(st, fb, idx);

+   }

+}

+

+

+/**

+ * Called via glReadBuffer.

+ */

+static void

+st_ReadBuffer(struct gl_context *ctx, GLenum buffer)

+{

+   struct st_context *st = st_context(ctx);

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+

+   (void) buffer;

+

+   /* add the renderbuffer on demand */

+   st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex);

+}

+

+

+void st_init_fbo_functions(struct dd_function_table *functions)

+{

+#if FEATURE_EXT_framebuffer_object

+   functions->NewFramebuffer = st_new_framebuffer;

+   functions->NewRenderbuffer = st_new_renderbuffer;

+   functions->BindFramebuffer = st_bind_framebuffer;

+   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;

+   functions->RenderTexture = st_render_texture;

+   functions->FinishRenderTexture = st_finish_render_texture;

+   functions->ValidateFramebuffer = st_validate_framebuffer;

+#endif

+   /* no longer needed by core Mesa, drivers handle resizes...

+   functions->ResizeBuffers = st_resize_buffers;

+   */

+

+   functions->DrawBuffers = st_DrawBuffers;

+   functions->ReadBuffer = st_ReadBuffer;

+}

+

+/* XXX unused ? */

+struct pipe_sampler_view *

+st_get_renderbuffer_sampler_view(struct st_renderbuffer *rb,

+                                 struct pipe_context *pipe)

+{

+   if (!rb->sampler_view) {

+      rb->sampler_view = st_create_texture_sampler_view(pipe, rb->texture);

+   }

+

+   return rb->sampler_view;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_flush.c b/mesalib/src/mesa/state_tracker/st_cb_flush.c
index 35ab00f6d..01496ed07 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_flush.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_flush.c
@@ -1,165 +1,165 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
-
-#include "main/glheader.h"
-#include "main/macros.h"
-#include "main/context.h"
-#include "st_context.h"
-#include "st_cb_bitmap.h"
-#include "st_cb_flush.h"
-#include "st_cb_clear.h"
-#include "st_cb_fbo.h"
-#include "st_manager.h"
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "util/u_gen_mipmap.h"
-#include "util/u_blit.h"
-
-
-/** Check if we have a front color buffer and if it's been drawn to. */
-static INLINE GLboolean
-is_front_buffer_dirty(struct st_context *st)
-{
-   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   struct st_renderbuffer *strb
-      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-   return strb && strb->defined;
-}
-
-
-/**
- * Tell the screen to display the front color buffer on-screen.
- */
-static void
-display_front_buffer(struct st_context *st)
-{
-   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   struct st_renderbuffer *strb
-      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-
-   if (strb) {
-      /* Hook for copying "fake" frontbuffer if necessary:
-       */
-      st_manager_flush_frontbuffer(st);
-   }
-}
-
-
-void st_flush( struct st_context *st, uint pipeFlushFlags,
-               struct pipe_fence_handle **fence )
-{
-   FLUSH_CURRENT(st->ctx, 0);
-
-   /* Release any vertex buffers that might potentially be accessed in
-    * successive frames:
-    */
-   st_flush_bitmap(st);
-   st_flush_clear(st);
-   util_blit_flush(st->blit);
-   util_gen_mipmap_flush(st->gen_mipmap);
-
-   st->pipe->flush( st->pipe, pipeFlushFlags, fence );
-}
-
-
-/**
- * Flush, and wait for completion.
- */
-void st_finish( struct st_context *st )
-{
-   struct pipe_fence_handle *fence = NULL;
-
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);
-
-   if(fence) {
-      st->pipe->screen->fence_finish(st->pipe->screen, fence, 0,
-                                     PIPE_TIMEOUT_INFINITE);
-      st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);
-   }
-}
-
-
-
-/**
- * Called via ctx->Driver.Flush()
- */
-static void st_glFlush(struct gl_context *ctx)
-{
-   struct st_context *st = st_context(ctx);
-
-   /* Don't call st_finish() here.  It is not the state tracker's
-    * responsibilty to inject sleeps in the hope of avoiding buffer
-    * synchronization issues.  Calling finish() here will just hide
-    * problems that need to be fixed elsewhere.
-    */
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-
-   if (is_front_buffer_dirty(st)) {
-      display_front_buffer(st);
-   }
-}
-
-
-/**
- * Called via ctx->Driver.Finish()
- */
-static void st_glFinish(struct gl_context *ctx)
-{
-   struct st_context *st = st_context(ctx);
-
-   st_finish(st);
-
-   if (is_front_buffer_dirty(st)) {
-      display_front_buffer(st);
-   }
-}
-
-
-void st_init_flush_functions(struct dd_function_table *functions)
-{
-   functions->Flush = st_glFlush;
-   functions->Finish = st_glFinish;
-
-   /* Windows opengl32.dll calls glFinish prior to every swapbuffers.
-    * This is unnecessary and degrades performance.  Luckily we have some
-    * scope to work around this, as the externally-visible behaviour of
-    * Finish() is identical to Flush() in all cases - no differences in
-    * rendering or ReadPixels are visible if we opt not to wait here.
-    *
-    * Only set this up on windows to avoid suprise elsewhere.
-    */
-#ifdef PIPE_OS_WINDOWS
-   functions->Finish = st_glFlush;
-#endif
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+

+#include "main/glheader.h"

+#include "main/macros.h"

+#include "main/context.h"

+#include "st_context.h"

+#include "st_cb_bitmap.h"

+#include "st_cb_flush.h"

+#include "st_cb_clear.h"

+#include "st_cb_fbo.h"

+#include "st_manager.h"

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "util/u_gen_mipmap.h"

+#include "util/u_blit.h"

+

+

+/** Check if we have a front color buffer and if it's been drawn to. */

+static INLINE GLboolean

+is_front_buffer_dirty(struct st_context *st)

+{

+   struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   struct st_renderbuffer *strb

+      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+   return strb && strb->defined;

+}

+

+

+/**

+ * Tell the screen to display the front color buffer on-screen.

+ */

+static void

+display_front_buffer(struct st_context *st)

+{

+   struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   struct st_renderbuffer *strb

+      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+

+   if (strb) {

+      /* Hook for copying "fake" frontbuffer if necessary:

+       */

+      st_manager_flush_frontbuffer(st);

+   }

+}

+

+

+void st_flush( struct st_context *st, uint pipeFlushFlags,

+               struct pipe_fence_handle **fence )

+{

+   FLUSH_CURRENT(st->ctx, 0);

+

+   /* Release any vertex buffers that might potentially be accessed in

+    * successive frames:

+    */

+   st_flush_bitmap(st);

+   st_flush_clear(st);

+   util_blit_flush(st->blit);

+   util_gen_mipmap_flush(st->gen_mipmap);

+

+   st->pipe->flush( st->pipe, pipeFlushFlags, fence );

+}

+

+

+/**

+ * Flush, and wait for completion.

+ */

+void st_finish( struct st_context *st )

+{

+   struct pipe_fence_handle *fence = NULL;

+

+   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);

+

+   if(fence) {

+      st->pipe->screen->fence_finish(st->pipe->screen, fence, 0,

+                                     PIPE_TIMEOUT_INFINITE);

+      st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);

+   }

+}

+

+

+

+/**

+ * Called via ctx->Driver.Flush()

+ */

+static void st_glFlush(struct gl_context *ctx)

+{

+   struct st_context *st = st_context(ctx);

+

+   /* Don't call st_finish() here.  It is not the state tracker's

+    * responsibilty to inject sleeps in the hope of avoiding buffer

+    * synchronization issues.  Calling finish() here will just hide

+    * problems that need to be fixed elsewhere.

+    */

+   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);

+

+   if (is_front_buffer_dirty(st)) {

+      display_front_buffer(st);

+   }

+}

+

+

+/**

+ * Called via ctx->Driver.Finish()

+ */

+static void st_glFinish(struct gl_context *ctx)

+{

+   struct st_context *st = st_context(ctx);

+

+   st_finish(st);

+

+   if (is_front_buffer_dirty(st)) {

+      display_front_buffer(st);

+   }

+}

+

+

+void st_init_flush_functions(struct dd_function_table *functions)

+{

+   functions->Flush = st_glFlush;

+   functions->Finish = st_glFinish;

+

+   /* Windows opengl32.dll calls glFinish prior to every swapbuffers.

+    * This is unnecessary and degrades performance.  Luckily we have some

+    * scope to work around this, as the externally-visible behaviour of

+    * Finish() is identical to Flush() in all cases - no differences in

+    * rendering or ReadPixels are visible if we opt not to wait here.

+    *

+    * Only set this up on windows to avoid suprise elsewhere.

+    */

+#ifdef PIPE_OS_WINDOWS

+   functions->Finish = st_glFlush;

+#endif

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
index f8da2a4d1..687a49a57 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_readpixels.c
@@ -1,561 +1,561 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-/**
- * glReadPixels interface to pipe
- *
- * \author Brian Paul
- */
-
-
-#include "main/imports.h"
-#include "main/bufferobj.h"
-#include "main/context.h"
-#include "main/image.h"
-#include "main/pack.h"
-#include "main/pbo.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_tile.h"
-
-#include "st_debug.h"
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_bitmap.h"
-#include "st_cb_readpixels.h"
-#include "st_cb_fbo.h"
-
-/**
- * Special case for reading stencil buffer.
- * For color/depth we use get_tile().  For stencil, map the stencil buffer.
- */
-void
-st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       const struct gl_pixelstore_attrib *packing,
-                       GLvoid *pixels)
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_renderbuffer *strb = st_renderbuffer(fb->_StencilBuffer);
-   struct pipe_transfer *pt;
-   ubyte *stmap;
-   GLint j;
-
-   if (strb->Base.Wrapped) {
-      strb = st_renderbuffer(strb->Base.Wrapped);
-   }
-
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-      y = ctx->DrawBuffer->Height - y - height;
-   }
-
-   /* Create a read transfer from the renderbuffer's texture */
-
-   pt = pipe_get_transfer(pipe, strb->texture,
-                          0, 0,
-                          PIPE_TRANSFER_READ,
-                          x, y, width, height);
-
-   /* map the stencil buffer */
-   stmap = pipe_transfer_map(pipe, pt);
-
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   /* process image row by row */
-   for (j = 0; j < height; j++) {
-      GLvoid *dest;
-      GLstencil sValues[MAX_WIDTH];
-      GLfloat zValues[MAX_WIDTH];
-      GLint srcY;
-
-      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-         srcY = height - j - 1;
-      }
-      else {
-         srcY = j;
-      }
-
-      /* get stencil (and Z) values */
-      switch (pt->resource->format) {
-      case PIPE_FORMAT_S8_USCALED:
-         {
-            const ubyte *src = stmap + srcY * pt->stride;
-            memcpy(sValues, src, width);
-         }
-         break;
-      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-         if (format == GL_DEPTH_STENCIL) {
-            const uint *src = (uint *) (stmap + srcY * pt->stride);
-            const GLfloat scale = 1.0f / (0xffffff);
-            GLint k;
-            for (k = 0; k < width; k++) {
-               sValues[k] = src[k] >> 24;
-               zValues[k] = (src[k] & 0xffffff) * scale;
-            }
-         }
-         else {
-            const uint *src = (uint *) (stmap + srcY * pt->stride);
-            GLint k;
-            for (k = 0; k < width; k++) {
-               sValues[k] = src[k] >> 24;
-            }
-         }
-         break;
-      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-         if (format == GL_DEPTH_STENCIL) {
-            const uint *src = (uint *) (stmap + srcY * pt->stride);
-            const GLfloat scale = 1.0f / (0xffffff);
-            GLint k;
-            for (k = 0; k < width; k++) {
-               sValues[k] = src[k] & 0xff;
-               zValues[k] = (src[k] >> 8) * scale;
-            }
-         }
-         else {
-            const uint *src = (uint *) (stmap + srcY * pt->stride);
-            GLint k;
-            for (k = 0; k < width; k++) {
-               sValues[k] = src[k] & 0xff;
-            }
-         }
-         break;
-      default:
-         assert(0);
-      }
-
-      /* store */
-      dest = _mesa_image_address2d(packing, pixels, width, height,
-                                   format, type, j, 0);
-      if (format == GL_DEPTH_STENCIL) {
-         _mesa_pack_depth_stencil_span(ctx, width, dest,
-                                       zValues, sValues, packing);
-      }
-      else {
-         _mesa_pack_stencil_span(ctx, width, type, dest, sValues, packing);
-      }
-   }
-
-   /* unmap the stencil buffer */
-   pipe_transfer_unmap(pipe, pt);
-   pipe->transfer_destroy(pipe, pt);
-}
-
-
-/**
- * Return renderbuffer to use for reading color pixels for glRead/CopyPixel
- * commands.
- */
-struct st_renderbuffer *
-st_get_color_read_renderbuffer(struct gl_context *ctx)
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct st_renderbuffer *strb =
-      st_renderbuffer(fb->_ColorReadBuffer);
-
-   return strb;
-}
-
-
-/**
- * Try to do glReadPixels in a fast manner for common cases.
- * \return GL_TRUE for success, GL_FALSE for failure
- */
-static GLboolean
-st_fast_readpixels(struct gl_context *ctx, struct st_renderbuffer *strb,
-                   GLint x, GLint y, GLsizei width, GLsizei height,
-                   GLenum format, GLenum type,
-                   const struct gl_pixelstore_attrib *pack,
-                   GLvoid *dest)
-{
-   enum combination {
-      A8R8G8B8_UNORM_TO_RGBA_UBYTE,
-      A8R8G8B8_UNORM_TO_RGB_UBYTE,
-      A8R8G8B8_UNORM_TO_BGRA_UINT
-   } combo;
-
-   if (ctx->_ImageTransferState)
-      return GL_FALSE;
-
-   if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&
-       format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
-      combo = A8R8G8B8_UNORM_TO_RGBA_UBYTE;
-   }
-   else if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&
-            format == GL_RGB && type == GL_UNSIGNED_BYTE) {
-      combo = A8R8G8B8_UNORM_TO_RGB_UBYTE;
-   }
-   else if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&
-            format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV) {
-      combo = A8R8G8B8_UNORM_TO_BGRA_UINT;
-   }
-   else {
-      return GL_FALSE;
-   }
-
-   /*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/
-
-   {
-      struct pipe_context *pipe = st_context(ctx)->pipe;
-      struct pipe_transfer *trans;
-      const GLubyte *map;
-      GLubyte *dst;
-      GLint row, col, dy, dstStride;
-
-      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-         /* convert GL Y to Gallium Y */
-         y = strb->texture->height0 - y - height;
-      }
-
-      trans = pipe_get_transfer(pipe, strb->texture,
-                                0, 0,
-                                PIPE_TRANSFER_READ,
-                                x, y, width, height);
-      if (!trans) {
-         return GL_FALSE;
-      }
-
-      map = pipe_transfer_map(pipe, trans);
-      if (!map) {
-         pipe->transfer_destroy(pipe, trans);
-         return GL_FALSE;
-      }
-
-      /* We always write to the user/dest buffer from low addr to high addr
-       * but the read order depends on renderbuffer orientation
-       */
-      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-         /* read source rows from bottom to top */
-         y = height - 1;
-         dy = -1;
-      }
-      else {
-         /* read source rows from top to bottom */
-         y = 0;
-         dy = 1;
-      }
-
-      dst = _mesa_image_address2d(pack, dest, width, height,
-                                  format, type, 0, 0);
-      dstStride = _mesa_image_row_stride(pack, width, format, type);
-
-      switch (combo) {
-      case A8R8G8B8_UNORM_TO_RGBA_UBYTE:
-         for (row = 0; row < height; row++) {
-            const GLubyte *src = map + y * trans->stride;
-            for (col = 0; col < width; col++) {
-               GLuint pixel = ((GLuint *) src)[col];
-               dst[col*4+0] = (pixel >> 16) & 0xff;
-               dst[col*4+1] = (pixel >>  8) & 0xff;
-               dst[col*4+2] = (pixel >>  0) & 0xff;
-               dst[col*4+3] = (pixel >> 24) & 0xff;
-            }
-            dst += dstStride;
-            y += dy;
-         }
-         break;
-      case A8R8G8B8_UNORM_TO_RGB_UBYTE:
-         for (row = 0; row < height; row++) {
-            const GLubyte *src = map + y * trans->stride;
-            for (col = 0; col < width; col++) {
-               GLuint pixel = ((GLuint *) src)[col];
-               dst[col*3+0] = (pixel >> 16) & 0xff;
-               dst[col*3+1] = (pixel >>  8) & 0xff;
-               dst[col*3+2] = (pixel >>  0) & 0xff;
-            }
-            dst += dstStride;
-            y += dy;
-         }
-         break;
-      case A8R8G8B8_UNORM_TO_BGRA_UINT:
-         for (row = 0; row < height; row++) {
-            const GLubyte *src = map + y * trans->stride;
-            memcpy(dst, src, 4 * width);
-            dst += dstStride;
-            y += dy;
-         }
-         break;
-      default:
-         ; /* nothing */
-      }
-
-      pipe_transfer_unmap(pipe, trans);
-      pipe->transfer_destroy(pipe, trans);
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do glReadPixels by getting rows from the framebuffer transfer with
- * get_tile().  Convert to requested format/type with Mesa image routines.
- * Image transfer ops are done in software too.
- */
-static void
-st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
-              GLenum format, GLenum type,
-              const struct gl_pixelstore_attrib *pack,
-              GLvoid *dest)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   GLfloat (*temp)[4];
-   const GLbitfield transferOps = ctx->_ImageTransferState;
-   GLsizei i, j;
-   GLint yStep, dfStride;
-   GLfloat *df;
-   struct st_renderbuffer *strb;
-   struct gl_pixelstore_attrib clippedPacking = *pack;
-   struct pipe_transfer *trans;
-   enum pipe_format pformat;
-
-   assert(ctx->ReadBuffer->Width > 0);
-
-   st_validate_state(st);
-
-   /* Do all needed clipping here, so that we can forget about it later */
-   if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {
-      /* The ReadPixels transfer is totally outside the window bounds */
-      return;
-   }
-
-   st_flush_bitmap_cache(st);
-
-   dest = _mesa_map_pbo_dest(ctx, &clippedPacking, dest);
-   if (!dest)
-      return;
-
-   if (format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_STENCIL) {
-      st_read_stencil_pixels(ctx, x, y, width, height,
-                             format, type, pack, dest);
-      return;
-   }
-   else if (format == GL_DEPTH_COMPONENT) {
-      strb = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
-      if (strb->Base.Wrapped) {
-         strb = st_renderbuffer(strb->Base.Wrapped);
-      }
-   }
-   else {
-      /* Read color buffer */
-      strb = st_get_color_read_renderbuffer(ctx);
-   }
-
-   if (!strb)
-      return;
-
-   /* try a fast-path readpixels before anything else */
-   if (st_fast_readpixels(ctx, strb, x, y, width, height,
-                          format, type, pack, dest)) {
-      /* success! */
-      _mesa_unmap_pbo_dest(ctx, &clippedPacking);
-      return;
-   }
-
-   /* allocate temp pixel row buffer */
-   temp = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));
-   if (!temp) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
-      return;
-   }
-
-   if (format == GL_RGBA && type == GL_FLOAT) {
-      /* write tile(row) directly into user's buffer */
-      df = (GLfloat *) _mesa_image_address2d(&clippedPacking, dest, width,
-                                             height, format, type, 0, 0);
-      dfStride = width * 4;
-   }
-   else {
-      /* write tile(row) into temp row buffer */
-      df = (GLfloat *) temp;
-      dfStride = 0;
-   }
-
-   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-      /* convert GL Y to Gallium Y */
-      y = strb->Base.Height - y - height;
-   }
-
-   /* Create a read transfer from the renderbuffer's texture */
-   trans = pipe_get_transfer(pipe, strb->texture,
-                             0, 0,
-                             PIPE_TRANSFER_READ,
-                             x, y, width, height);
-
-   /* determine bottom-to-top vs. top-to-bottom order */
-   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-      y = height - 1;
-      yStep = -1;
-   }
-   else {
-      y = 0;
-      yStep = 1;
-   }
-
-   /* possibly convert sRGB format to linear RGB format */
-   pformat = util_format_linear(trans->resource->format);
-
-   if (ST_DEBUG & DEBUG_FALLBACK)
-      debug_printf("%s: fallback processing\n", __FUNCTION__);
-
-   /*
-    * Copy pixels from pipe_transfer to user memory
-    */
-   {
-      /* dest of first pixel in client memory */
-      GLubyte *dst = _mesa_image_address2d(&clippedPacking, dest, width,
-                                           height, format, type, 0, 0);
-      /* dest row stride */
-      const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,
-                                                     format, type);
-
-      if (pformat == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
-          pformat == PIPE_FORMAT_Z24X8_UNORM) {
-         if (format == GL_DEPTH_COMPONENT) {
-            for (i = 0; i < height; i++) {
-               GLuint ztemp[MAX_WIDTH];
-               GLfloat zfloat[MAX_WIDTH];
-               const double scale = 1.0 / ((1 << 24) - 1);
-               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);
-               y += yStep;
-               for (j = 0; j < width; j++) {
-                  zfloat[j] = (float) (scale * (ztemp[j] & 0xffffff));
-               }
-               _mesa_pack_depth_span(ctx, width, dst, type,
-                                     zfloat, &clippedPacking);
-               dst += dstStride;
-            }
-         }
-         else {
-            /* XXX: unreachable code -- should be before st_read_stencil_pixels */
-            assert(format == GL_DEPTH_STENCIL_EXT);
-            for (i = 0; i < height; i++) {
-               GLuint *zshort = (GLuint *)dst;
-               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0);
-               y += yStep;
-               /* Reverse into 24/8 */
-               for (j = 0; j < width; j++) {
-                  zshort[j] = (zshort[j] << 8) | (zshort[j] >> 24);
-               }
-               dst += dstStride;
-            }
-         }
-      }
-      else if (pformat == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
-               pformat == PIPE_FORMAT_X8Z24_UNORM) {
-         if (format == GL_DEPTH_COMPONENT) {
-            for (i = 0; i < height; i++) {
-               GLuint ztemp[MAX_WIDTH];
-               GLfloat zfloat[MAX_WIDTH];
-               const double scale = 1.0 / ((1 << 24) - 1);
-               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);
-               y += yStep;
-               for (j = 0; j < width; j++) {
-                  zfloat[j] = (float) (scale * ((ztemp[j] >> 8) & 0xffffff));
-               }
-               _mesa_pack_depth_span(ctx, width, dst, type,
-                                     zfloat, &clippedPacking);
-               dst += dstStride;
-            }
-         }
-         else {
-            /* XXX: unreachable code -- should be before st_read_stencil_pixels */
-            assert(format == GL_DEPTH_STENCIL_EXT);
-            for (i = 0; i < height; i++) {
-               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0);
-               y += yStep;
-               dst += dstStride;
-            }
-         }
-      }
-      else if (pformat == PIPE_FORMAT_Z16_UNORM) {
-         for (i = 0; i < height; i++) {
-            GLushort ztemp[MAX_WIDTH];
-            GLfloat zfloat[MAX_WIDTH];
-            const double scale = 1.0 / 0xffff;
-            pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);
-            y += yStep;
-            for (j = 0; j < width; j++) {
-               zfloat[j] = (float) (scale * ztemp[j]);
-            }
-            _mesa_pack_depth_span(ctx, width, dst, type,
-                                  zfloat, &clippedPacking);
-            dst += dstStride;
-         }
-      }
-      else if (pformat == PIPE_FORMAT_Z32_UNORM) {
-         for (i = 0; i < height; i++) {
-            GLuint ztemp[MAX_WIDTH];
-            GLfloat zfloat[MAX_WIDTH];
-            const double scale = 1.0 / 0xffffffff;
-            pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);
-            y += yStep;
-            for (j = 0; j < width; j++) {
-               zfloat[j] = (float) (scale * ztemp[j]);
-            }
-            _mesa_pack_depth_span(ctx, width, dst, type,
-                                  zfloat, &clippedPacking);
-            dst += dstStride;
-         }
-      }
-      else {
-         /* RGBA format */
-         /* Do a row at a time to flip image data vertically */
-         for (i = 0; i < height; i++) {
-            pipe_get_tile_rgba_format(pipe, trans, 0, y, width, 1,
-                                      pformat, df);
-            y += yStep;
-            df += dfStride;
-            if (!dfStride) {
-               _mesa_pack_rgba_span_float(ctx, width, temp, format, type, dst,
-                                          &clippedPacking, transferOps);
-               dst += dstStride;
-            }
-         }
-      }
-   }
-
-   free(temp);
-
-   pipe->transfer_destroy(pipe, trans);
-
-   _mesa_unmap_pbo_dest(ctx, &clippedPacking);
-}
-
-
-void st_init_readpixels_functions(struct dd_function_table *functions)
-{
-   functions->ReadPixels = st_readpixels;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * glReadPixels interface to pipe

+ *

+ * \author Brian Paul

+ */

+

+

+#include "main/imports.h"

+#include "main/bufferobj.h"

+#include "main/context.h"

+#include "main/image.h"

+#include "main/pack.h"

+#include "main/pbo.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_tile.h"

+

+#include "st_debug.h"

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_bitmap.h"

+#include "st_cb_readpixels.h"

+#include "st_cb_fbo.h"

+

+/**

+ * Special case for reading stencil buffer.

+ * For color/depth we use get_tile().  For stencil, map the stencil buffer.

+ */

+void

+st_read_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,

+                       GLsizei width, GLsizei height,

+                       GLenum format, GLenum type,

+                       const struct gl_pixelstore_attrib *packing,

+                       GLvoid *pixels)

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_renderbuffer *strb = st_renderbuffer(fb->_StencilBuffer);

+   struct pipe_transfer *pt;

+   ubyte *stmap;

+   GLint j;

+

+   if (strb->Base.Wrapped) {

+      strb = st_renderbuffer(strb->Base.Wrapped);

+   }

+

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+      y = ctx->DrawBuffer->Height - y - height;

+   }

+

+   /* Create a read transfer from the renderbuffer's texture */

+

+   pt = pipe_get_transfer(pipe, strb->texture,

+                          0, 0,

+                          PIPE_TRANSFER_READ,

+                          x, y, width, height);

+

+   /* map the stencil buffer */

+   stmap = pipe_transfer_map(pipe, pt);

+

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   /* process image row by row */

+   for (j = 0; j < height; j++) {

+      GLvoid *dest;

+      GLstencil sValues[MAX_WIDTH];

+      GLfloat zValues[MAX_WIDTH];

+      GLint srcY;

+

+      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+         srcY = height - j - 1;

+      }

+      else {

+         srcY = j;

+      }

+

+      /* get stencil (and Z) values */

+      switch (pt->resource->format) {

+      case PIPE_FORMAT_S8_USCALED:

+         {

+            const ubyte *src = stmap + srcY * pt->stride;

+            memcpy(sValues, src, width);

+         }

+         break;

+      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+         if (format == GL_DEPTH_STENCIL) {

+            const uint *src = (uint *) (stmap + srcY * pt->stride);

+            const GLfloat scale = 1.0f / (0xffffff);

+            GLint k;

+            for (k = 0; k < width; k++) {

+               sValues[k] = src[k] >> 24;

+               zValues[k] = (src[k] & 0xffffff) * scale;

+            }

+         }

+         else {

+            const uint *src = (uint *) (stmap + srcY * pt->stride);

+            GLint k;

+            for (k = 0; k < width; k++) {

+               sValues[k] = src[k] >> 24;

+            }

+         }

+         break;

+      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+         if (format == GL_DEPTH_STENCIL) {

+            const uint *src = (uint *) (stmap + srcY * pt->stride);

+            const GLfloat scale = 1.0f / (0xffffff);

+            GLint k;

+            for (k = 0; k < width; k++) {

+               sValues[k] = src[k] & 0xff;

+               zValues[k] = (src[k] >> 8) * scale;

+            }

+         }

+         else {

+            const uint *src = (uint *) (stmap + srcY * pt->stride);

+            GLint k;

+            for (k = 0; k < width; k++) {

+               sValues[k] = src[k] & 0xff;

+            }

+         }

+         break;

+      default:

+         assert(0);

+      }

+

+      /* store */

+      dest = _mesa_image_address2d(packing, pixels, width, height,

+                                   format, type, j, 0);

+      if (format == GL_DEPTH_STENCIL) {

+         _mesa_pack_depth_stencil_span(ctx, width, dest,

+                                       zValues, sValues, packing);

+      }

+      else {

+         _mesa_pack_stencil_span(ctx, width, type, dest, sValues, packing);

+      }

+   }

+

+   /* unmap the stencil buffer */

+   pipe_transfer_unmap(pipe, pt);

+   pipe->transfer_destroy(pipe, pt);

+}

+

+

+/**

+ * Return renderbuffer to use for reading color pixels for glRead/CopyPixel

+ * commands.

+ */

+struct st_renderbuffer *

+st_get_color_read_renderbuffer(struct gl_context *ctx)

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct st_renderbuffer *strb =

+      st_renderbuffer(fb->_ColorReadBuffer);

+

+   return strb;

+}

+

+

+/**

+ * Try to do glReadPixels in a fast manner for common cases.

+ * \return GL_TRUE for success, GL_FALSE for failure

+ */

+static GLboolean

+st_fast_readpixels(struct gl_context *ctx, struct st_renderbuffer *strb,

+                   GLint x, GLint y, GLsizei width, GLsizei height,

+                   GLenum format, GLenum type,

+                   const struct gl_pixelstore_attrib *pack,

+                   GLvoid *dest)

+{

+   enum combination {

+      A8R8G8B8_UNORM_TO_RGBA_UBYTE,

+      A8R8G8B8_UNORM_TO_RGB_UBYTE,

+      A8R8G8B8_UNORM_TO_BGRA_UINT

+   } combo;

+

+   if (ctx->_ImageTransferState)

+      return GL_FALSE;

+

+   if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&

+       format == GL_RGBA && type == GL_UNSIGNED_BYTE) {

+      combo = A8R8G8B8_UNORM_TO_RGBA_UBYTE;

+   }

+   else if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&

+            format == GL_RGB && type == GL_UNSIGNED_BYTE) {

+      combo = A8R8G8B8_UNORM_TO_RGB_UBYTE;

+   }

+   else if (strb->format == PIPE_FORMAT_B8G8R8A8_UNORM &&

+            format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV) {

+      combo = A8R8G8B8_UNORM_TO_BGRA_UINT;

+   }

+   else {

+      return GL_FALSE;

+   }

+

+   /*printf("st_fast_readpixels combo %d\n", (GLint) combo);*/

+

+   {

+      struct pipe_context *pipe = st_context(ctx)->pipe;

+      struct pipe_transfer *trans;

+      const GLubyte *map;

+      GLubyte *dst;

+      GLint row, col, dy, dstStride;

+

+      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+         /* convert GL Y to Gallium Y */

+         y = strb->texture->height0 - y - height;

+      }

+

+      trans = pipe_get_transfer(pipe, strb->texture,

+                                0, 0,

+                                PIPE_TRANSFER_READ,

+                                x, y, width, height);

+      if (!trans) {

+         return GL_FALSE;

+      }

+

+      map = pipe_transfer_map(pipe, trans);

+      if (!map) {

+         pipe->transfer_destroy(pipe, trans);

+         return GL_FALSE;

+      }

+

+      /* We always write to the user/dest buffer from low addr to high addr

+       * but the read order depends on renderbuffer orientation

+       */

+      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+         /* read source rows from bottom to top */

+         y = height - 1;

+         dy = -1;

+      }

+      else {

+         /* read source rows from top to bottom */

+         y = 0;

+         dy = 1;

+      }

+

+      dst = _mesa_image_address2d(pack, dest, width, height,

+                                  format, type, 0, 0);

+      dstStride = _mesa_image_row_stride(pack, width, format, type);

+

+      switch (combo) {

+      case A8R8G8B8_UNORM_TO_RGBA_UBYTE:

+         for (row = 0; row < height; row++) {

+            const GLubyte *src = map + y * trans->stride;

+            for (col = 0; col < width; col++) {

+               GLuint pixel = ((GLuint *) src)[col];

+               dst[col*4+0] = (pixel >> 16) & 0xff;

+               dst[col*4+1] = (pixel >>  8) & 0xff;

+               dst[col*4+2] = (pixel >>  0) & 0xff;

+               dst[col*4+3] = (pixel >> 24) & 0xff;

+            }

+            dst += dstStride;

+            y += dy;

+         }

+         break;

+      case A8R8G8B8_UNORM_TO_RGB_UBYTE:

+         for (row = 0; row < height; row++) {

+            const GLubyte *src = map + y * trans->stride;

+            for (col = 0; col < width; col++) {

+               GLuint pixel = ((GLuint *) src)[col];

+               dst[col*3+0] = (pixel >> 16) & 0xff;

+               dst[col*3+1] = (pixel >>  8) & 0xff;

+               dst[col*3+2] = (pixel >>  0) & 0xff;

+            }

+            dst += dstStride;

+            y += dy;

+         }

+         break;

+      case A8R8G8B8_UNORM_TO_BGRA_UINT:

+         for (row = 0; row < height; row++) {

+            const GLubyte *src = map + y * trans->stride;

+            memcpy(dst, src, 4 * width);

+            dst += dstStride;

+            y += dy;

+         }

+         break;

+      default:

+         ; /* nothing */

+      }

+

+      pipe_transfer_unmap(pipe, trans);

+      pipe->transfer_destroy(pipe, trans);

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do glReadPixels by getting rows from the framebuffer transfer with

+ * get_tile().  Convert to requested format/type with Mesa image routines.

+ * Image transfer ops are done in software too.

+ */

+static void

+st_readpixels(struct gl_context *ctx, GLint x, GLint y, GLsizei width, GLsizei height,

+              GLenum format, GLenum type,

+              const struct gl_pixelstore_attrib *pack,

+              GLvoid *dest)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   GLfloat (*temp)[4];

+   const GLbitfield transferOps = ctx->_ImageTransferState;

+   GLsizei i, j;

+   GLint yStep, dfStride;

+   GLfloat *df;

+   struct st_renderbuffer *strb;

+   struct gl_pixelstore_attrib clippedPacking = *pack;

+   struct pipe_transfer *trans;

+   enum pipe_format pformat;

+

+   assert(ctx->ReadBuffer->Width > 0);

+

+   st_validate_state(st);

+

+   /* Do all needed clipping here, so that we can forget about it later */

+   if (!_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {

+      /* The ReadPixels transfer is totally outside the window bounds */

+      return;

+   }

+

+   st_flush_bitmap_cache(st);

+

+   dest = _mesa_map_pbo_dest(ctx, &clippedPacking, dest);

+   if (!dest)

+      return;

+

+   if (format == GL_STENCIL_INDEX ||

+       format == GL_DEPTH_STENCIL) {

+      st_read_stencil_pixels(ctx, x, y, width, height,

+                             format, type, pack, dest);

+      return;

+   }

+   else if (format == GL_DEPTH_COMPONENT) {

+      strb = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);

+      if (strb->Base.Wrapped) {

+         strb = st_renderbuffer(strb->Base.Wrapped);

+      }

+   }

+   else {

+      /* Read color buffer */

+      strb = st_get_color_read_renderbuffer(ctx);

+   }

+

+   if (!strb)

+      return;

+

+   /* try a fast-path readpixels before anything else */

+   if (st_fast_readpixels(ctx, strb, x, y, width, height,

+                          format, type, pack, dest)) {

+      /* success! */

+      _mesa_unmap_pbo_dest(ctx, &clippedPacking);

+      return;

+   }

+

+   /* allocate temp pixel row buffer */

+   temp = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));

+   if (!temp) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");

+      return;

+   }

+

+   if (format == GL_RGBA && type == GL_FLOAT) {

+      /* write tile(row) directly into user's buffer */

+      df = (GLfloat *) _mesa_image_address2d(&clippedPacking, dest, width,

+                                             height, format, type, 0, 0);

+      dfStride = width * 4;

+   }

+   else {

+      /* write tile(row) into temp row buffer */

+      df = (GLfloat *) temp;

+      dfStride = 0;

+   }

+

+   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+      /* convert GL Y to Gallium Y */

+      y = strb->Base.Height - y - height;

+   }

+

+   /* Create a read transfer from the renderbuffer's texture */

+   trans = pipe_get_transfer(pipe, strb->texture,

+                             0, 0,

+                             PIPE_TRANSFER_READ,

+                             x, y, width, height);

+

+   /* determine bottom-to-top vs. top-to-bottom order */

+   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+      y = height - 1;

+      yStep = -1;

+   }

+   else {

+      y = 0;

+      yStep = 1;

+   }

+

+   /* possibly convert sRGB format to linear RGB format */

+   pformat = util_format_linear(trans->resource->format);

+

+   if (ST_DEBUG & DEBUG_FALLBACK)

+      debug_printf("%s: fallback processing\n", __FUNCTION__);

+

+   /*

+    * Copy pixels from pipe_transfer to user memory

+    */

+   {

+      /* dest of first pixel in client memory */

+      GLubyte *dst = _mesa_image_address2d(&clippedPacking, dest, width,

+                                           height, format, type, 0, 0);

+      /* dest row stride */

+      const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,

+                                                     format, type);

+

+      if (pformat == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||

+          pformat == PIPE_FORMAT_Z24X8_UNORM) {

+         if (format == GL_DEPTH_COMPONENT) {

+            for (i = 0; i < height; i++) {

+               GLuint ztemp[MAX_WIDTH];

+               GLfloat zfloat[MAX_WIDTH];

+               const double scale = 1.0 / ((1 << 24) - 1);

+               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);

+               y += yStep;

+               for (j = 0; j < width; j++) {

+                  zfloat[j] = (float) (scale * (ztemp[j] & 0xffffff));

+               }

+               _mesa_pack_depth_span(ctx, width, dst, type,

+                                     zfloat, &clippedPacking);

+               dst += dstStride;

+            }

+         }

+         else {

+            /* XXX: unreachable code -- should be before st_read_stencil_pixels */

+            assert(format == GL_DEPTH_STENCIL_EXT);

+            for (i = 0; i < height; i++) {

+               GLuint *zshort = (GLuint *)dst;

+               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0);

+               y += yStep;

+               /* Reverse into 24/8 */

+               for (j = 0; j < width; j++) {

+                  zshort[j] = (zshort[j] << 8) | (zshort[j] >> 24);

+               }

+               dst += dstStride;

+            }

+         }

+      }

+      else if (pformat == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||

+               pformat == PIPE_FORMAT_X8Z24_UNORM) {

+         if (format == GL_DEPTH_COMPONENT) {

+            for (i = 0; i < height; i++) {

+               GLuint ztemp[MAX_WIDTH];

+               GLfloat zfloat[MAX_WIDTH];

+               const double scale = 1.0 / ((1 << 24) - 1);

+               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);

+               y += yStep;

+               for (j = 0; j < width; j++) {

+                  zfloat[j] = (float) (scale * ((ztemp[j] >> 8) & 0xffffff));

+               }

+               _mesa_pack_depth_span(ctx, width, dst, type,

+                                     zfloat, &clippedPacking);

+               dst += dstStride;

+            }

+         }

+         else {

+            /* XXX: unreachable code -- should be before st_read_stencil_pixels */

+            assert(format == GL_DEPTH_STENCIL_EXT);

+            for (i = 0; i < height; i++) {

+               pipe_get_tile_raw(pipe, trans, 0, y, width, 1, dst, 0);

+               y += yStep;

+               dst += dstStride;

+            }

+         }

+      }

+      else if (pformat == PIPE_FORMAT_Z16_UNORM) {

+         for (i = 0; i < height; i++) {

+            GLushort ztemp[MAX_WIDTH];

+            GLfloat zfloat[MAX_WIDTH];

+            const double scale = 1.0 / 0xffff;

+            pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);

+            y += yStep;

+            for (j = 0; j < width; j++) {

+               zfloat[j] = (float) (scale * ztemp[j]);

+            }

+            _mesa_pack_depth_span(ctx, width, dst, type,

+                                  zfloat, &clippedPacking);

+            dst += dstStride;

+         }

+      }

+      else if (pformat == PIPE_FORMAT_Z32_UNORM) {

+         for (i = 0; i < height; i++) {

+            GLuint ztemp[MAX_WIDTH];

+            GLfloat zfloat[MAX_WIDTH];

+            const double scale = 1.0 / 0xffffffff;

+            pipe_get_tile_raw(pipe, trans, 0, y, width, 1, ztemp, 0);

+            y += yStep;

+            for (j = 0; j < width; j++) {

+               zfloat[j] = (float) (scale * ztemp[j]);

+            }

+            _mesa_pack_depth_span(ctx, width, dst, type,

+                                  zfloat, &clippedPacking);

+            dst += dstStride;

+         }

+      }

+      else {

+         /* RGBA format */

+         /* Do a row at a time to flip image data vertically */

+         for (i = 0; i < height; i++) {

+            pipe_get_tile_rgba_format(pipe, trans, 0, y, width, 1,

+                                      pformat, df);

+            y += yStep;

+            df += dfStride;

+            if (!dfStride) {

+               _mesa_pack_rgba_span_float(ctx, width, temp, format, type, dst,

+                                          &clippedPacking, transferOps);

+               dst += dstStride;

+            }

+         }

+      }

+   }

+

+   free(temp);

+

+   pipe->transfer_destroy(pipe, trans);

+

+   _mesa_unmap_pbo_dest(ctx, &clippedPacking);

+}

+

+

+void st_init_readpixels_functions(struct dd_function_table *functions)

+{

+   functions->ReadPixels = st_readpixels;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_context.c b/mesalib/src/mesa/state_tracker/st_context.c
index 60972e07d..c1b4cde77 100644
--- a/mesalib/src/mesa/state_tracker/st_context.c
+++ b/mesalib/src/mesa/state_tracker/st_context.c
@@ -1,299 +1,299 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/shaderobj.h"
-#include "program/prog_cache.h"
-#include "vbo/vbo.h"
-#include "glapi/glapi.h"
-#include "st_context.h"
-#include "st_debug.h"
-#include "st_cb_accum.h"
-#include "st_cb_bitmap.h"
-#include "st_cb_blit.h"
-#include "st_cb_bufferobjects.h"
-#include "st_cb_clear.h"
-#include "st_cb_condrender.h"
-#include "st_cb_drawpixels.h"
-#include "st_cb_rasterpos.h"
-#include "st_cb_drawtex.h"
-#include "st_cb_eglimage.h"
-#include "st_cb_fbo.h"
-#include "st_cb_feedback.h"
-#include "st_cb_program.h"
-#include "st_cb_queryobj.h"
-#include "st_cb_readpixels.h"
-#include "st_cb_texture.h"
-#include "st_cb_xformfb.h"
-#include "st_cb_flush.h"
-#include "st_cb_syncobj.h"
-#include "st_cb_strings.h"
-#include "st_cb_viewport.h"
-#include "st_atom.h"
-#include "st_draw.h"
-#include "st_extensions.h"
-#include "st_gen_mipmap.h"
-#include "st_program.h"
-#include "pipe/p_context.h"
-#include "util/u_inlines.h"
-#include "cso_cache/cso_context.h"
-
-
-DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)
-
-
-/**
- * Called via ctx->Driver.UpdateState()
- */
-void st_invalidate_state(struct gl_context * ctx, GLuint new_state)
-{
-   struct st_context *st = st_context(ctx);
-
-   st->dirty.mesa |= new_state;
-   st->dirty.st |= ST_NEW_MESA;
-
-   /* This is the only core Mesa module we depend upon.
-    * No longer use swrast, swsetup, tnl.
-    */
-   _vbo_InvalidateState(ctx, new_state);
-}
-
-
-/**
- * Check for multisample env var override.
- */
-int
-st_get_msaa(void)
-{
-   const char *msaa = _mesa_getenv("__GL_FSAA_MODE");
-   if (msaa)
-      return atoi(msaa);
-   return 0;
-}
-
-
-static struct st_context *
-st_create_context_priv( struct gl_context *ctx, struct pipe_context *pipe )
-{
-   uint i;
-   struct st_context *st = ST_CALLOC_STRUCT( st_context );
-   
-   ctx->st = st;
-
-   st->ctx = ctx;
-   st->pipe = pipe;
-
-   /* XXX: this is one-off, per-screen init: */
-   st_debug_init();
-   
-   /* state tracker needs the VBO module */
-   _vbo_CreateContext(ctx);
-
-   st->dirty.mesa = ~0;
-   st->dirty.st = ~0;
-
-   st->cso_context = cso_create_context(pipe);
-
-   st_init_atoms( st );
-   st_init_bitmap(st);
-   st_init_clear(st);
-   st_init_draw( st );
-   st_init_generate_mipmap(st);
-   st_init_blit(st);
-
-   if(pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES))
-      st->internal_target = PIPE_TEXTURE_2D;
-   else
-      st->internal_target = PIPE_TEXTURE_RECT;
-
-   for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
-      st->state.sampler_list[i] = &st->state.samplers[i];
-
-   for (i = 0; i < 3; i++) {
-      memset(&st->velems_util_draw[i], 0, sizeof(struct pipe_vertex_element));
-      st->velems_util_draw[i].src_offset = i * 4 * sizeof(float);
-      st->velems_util_draw[i].instance_divisor = 0;
-      st->velems_util_draw[i].vertex_buffer_index = 0;
-      st->velems_util_draw[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-   }
-
-   /* we want all vertex data to be placed in buffer objects */
-   vbo_use_buffer_objects(ctx);
-
-   /* Need these flags:
-    */
-   st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-
-   st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
-
-   st->pixel_xfer.cache = _mesa_new_program_cache();
-
-   st->force_msaa = st_get_msaa();
-
-   /* GL limits and extensions */
-   st_init_limits(st);
-   st_init_extensions(st);
-
-   return st;
-}
-
-
-struct st_context *st_create_context(gl_api api, struct pipe_context *pipe,
-                                     const struct gl_config *visual,
-                                     struct st_context *share)
-{
-   struct gl_context *ctx;
-   struct gl_context *shareCtx = share ? share->ctx : NULL;
-   struct dd_function_table funcs;
-
-   /* Sanity checks */
-   assert(MESA_SHADER_VERTEX == PIPE_SHADER_VERTEX);
-   assert(MESA_SHADER_FRAGMENT == PIPE_SHADER_FRAGMENT);
-   assert(MESA_SHADER_GEOMETRY == PIPE_SHADER_GEOMETRY);
-
-   memset(&funcs, 0, sizeof(funcs));
-   st_init_driver_functions(&funcs);
-
-   ctx = _mesa_create_context(api, visual, shareCtx, &funcs, NULL);
-
-   /* XXX: need a capability bit in gallium to query if the pipe
-    * driver prefers DP4 or MUL/MAD for vertex transformation.
-    */
-   if (debug_get_option_mesa_mvp_dp4())
-      _mesa_set_mvp_with_dp4( ctx, GL_TRUE );
-
-   return st_create_context_priv(ctx, pipe);
-}
-
-
-static void st_destroy_context_priv( struct st_context *st )
-{
-   uint i;
-
-   st_destroy_atoms( st );
-   st_destroy_draw( st );
-   st_destroy_generate_mipmap(st);
-   st_destroy_blit(st);
-   st_destroy_clear(st);
-   st_destroy_bitmap(st);
-   st_destroy_drawpix(st);
-   st_destroy_drawtex(st);
-
-   /* Unreference any user vertex buffers. */
-   for (i = 0; i < st->num_user_vbs; i++) {
-      pipe_resource_reference(&st->user_vb[i], NULL);
-   }
-
-   for (i = 0; i < Elements(st->state.sampler_views); i++) {
-      pipe_sampler_view_reference(&st->state.sampler_views[i], NULL);
-   }
-
-   if (st->default_texture) {
-      st->ctx->Driver.DeleteTexture(st->ctx, st->default_texture);
-      st->default_texture = NULL;
-   }
-
-   free( st );
-}
-
- 
-void st_destroy_context( struct st_context *st )
-{
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = st->cso_context;
-   struct gl_context *ctx = st->ctx;
-   GLuint i;
-
-   /* need to unbind and destroy CSO objects before anything else */
-   cso_release_all(st->cso_context);
-
-   st_reference_fragprog(st, &st->fp, NULL);
-   st_reference_vertprog(st, &st->vp, NULL);
-
-   /* release framebuffer surfaces */
-   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
-      pipe_surface_reference(&st->state.framebuffer.cbufs[i], NULL);
-   }
-   pipe_surface_reference(&st->state.framebuffer.zsbuf, NULL);
-
-   pipe->set_index_buffer(pipe, NULL);
-
-   for (i = 0; i < PIPE_SHADER_TYPES; i++) {
-      pipe->set_constant_buffer(pipe, i, 0, NULL);
-   }
-
-   _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);
-
-   _vbo_DestroyContext(st->ctx);
-
-   st_destroy_program_variants(st);
-
-   _mesa_free_context_data(ctx);
-
-   st_destroy_context_priv(st);
-
-   cso_destroy_context(cso);
-
-   pipe->destroy( pipe );
-
-   free(ctx);
-}
-
-
-void st_init_driver_functions(struct dd_function_table *functions)
-{
-   _mesa_init_shader_object_functions(functions);
-
-   st_init_accum_functions(functions);
-   st_init_blit_functions(functions);
-   st_init_bufferobject_functions(functions);
-   st_init_clear_functions(functions);
-   st_init_bitmap_functions(functions);
-   st_init_drawpixels_functions(functions);
-   st_init_rasterpos_functions(functions);
-
-   st_init_drawtex_functions(functions);
-
-   st_init_eglimage_functions(functions);
-
-   st_init_fbo_functions(functions);
-   st_init_feedback_functions(functions);
-   st_init_program_functions(functions);
-   st_init_query_functions(functions);
-   st_init_cond_render_functions(functions);
-   st_init_readpixels_functions(functions);
-   st_init_texture_functions(functions);
-   st_init_flush_functions(functions);
-   st_init_string_functions(functions);
-   st_init_viewport_functions(functions);
-
-   st_init_xformfb_functions(functions);
-   st_init_syncobj_functions(functions);
-
-   functions->UpdateState = st_invalidate_state;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/shaderobj.h"

+#include "program/prog_cache.h"

+#include "vbo/vbo.h"

+#include "glapi/glapi.h"

+#include "st_context.h"

+#include "st_debug.h"

+#include "st_cb_accum.h"

+#include "st_cb_bitmap.h"

+#include "st_cb_blit.h"

+#include "st_cb_bufferobjects.h"

+#include "st_cb_clear.h"

+#include "st_cb_condrender.h"

+#include "st_cb_drawpixels.h"

+#include "st_cb_rasterpos.h"

+#include "st_cb_drawtex.h"

+#include "st_cb_eglimage.h"

+#include "st_cb_fbo.h"

+#include "st_cb_feedback.h"

+#include "st_cb_program.h"

+#include "st_cb_queryobj.h"

+#include "st_cb_readpixels.h"

+#include "st_cb_texture.h"

+#include "st_cb_xformfb.h"

+#include "st_cb_flush.h"

+#include "st_cb_syncobj.h"

+#include "st_cb_strings.h"

+#include "st_cb_viewport.h"

+#include "st_atom.h"

+#include "st_draw.h"

+#include "st_extensions.h"

+#include "st_gen_mipmap.h"

+#include "st_program.h"

+#include "pipe/p_context.h"

+#include "util/u_inlines.h"

+#include "cso_cache/cso_context.h"

+

+

+DEBUG_GET_ONCE_BOOL_OPTION(mesa_mvp_dp4, "MESA_MVP_DP4", FALSE)

+

+

+/**

+ * Called via ctx->Driver.UpdateState()

+ */

+void st_invalidate_state(struct gl_context * ctx, GLuint new_state)

+{

+   struct st_context *st = st_context(ctx);

+

+   st->dirty.mesa |= new_state;

+   st->dirty.st |= ST_NEW_MESA;

+

+   /* This is the only core Mesa module we depend upon.

+    * No longer use swrast, swsetup, tnl.

+    */

+   _vbo_InvalidateState(ctx, new_state);

+}

+

+

+/**

+ * Check for multisample env var override.

+ */

+int

+st_get_msaa(void)

+{

+   const char *msaa = _mesa_getenv("__GL_FSAA_MODE");

+   if (msaa)

+      return atoi(msaa);

+   return 0;

+}

+

+

+static struct st_context *

+st_create_context_priv( struct gl_context *ctx, struct pipe_context *pipe )

+{

+   uint i;

+   struct st_context *st = ST_CALLOC_STRUCT( st_context );

+   

+   ctx->st = st;

+

+   st->ctx = ctx;

+   st->pipe = pipe;

+

+   /* XXX: this is one-off, per-screen init: */

+   st_debug_init();

+   

+   /* state tracker needs the VBO module */

+   _vbo_CreateContext(ctx);

+

+   st->dirty.mesa = ~0;

+   st->dirty.st = ~0;

+

+   st->cso_context = cso_create_context(pipe);

+

+   st_init_atoms( st );

+   st_init_bitmap(st);

+   st_init_clear(st);

+   st_init_draw( st );

+   st_init_generate_mipmap(st);

+   st_init_blit(st);

+

+   if(pipe->screen->get_param(pipe->screen, PIPE_CAP_NPOT_TEXTURES))

+      st->internal_target = PIPE_TEXTURE_2D;

+   else

+      st->internal_target = PIPE_TEXTURE_RECT;

+

+   for (i = 0; i < PIPE_MAX_SAMPLERS; i++)

+      st->state.sampler_list[i] = &st->state.samplers[i];

+

+   for (i = 0; i < 3; i++) {

+      memset(&st->velems_util_draw[i], 0, sizeof(struct pipe_vertex_element));

+      st->velems_util_draw[i].src_offset = i * 4 * sizeof(float);

+      st->velems_util_draw[i].instance_divisor = 0;

+      st->velems_util_draw[i].vertex_buffer_index = 0;

+      st->velems_util_draw[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;

+   }

+

+   /* we want all vertex data to be placed in buffer objects */

+   vbo_use_buffer_objects(ctx);

+

+   /* Need these flags:

+    */

+   st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;

+

+   st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;

+

+   st->pixel_xfer.cache = _mesa_new_program_cache();

+

+   st->force_msaa = st_get_msaa();

+

+   /* GL limits and extensions */

+   st_init_limits(st);

+   st_init_extensions(st);

+

+   return st;

+}

+

+

+struct st_context *st_create_context(gl_api api, struct pipe_context *pipe,

+                                     const struct gl_config *visual,

+                                     struct st_context *share)

+{

+   struct gl_context *ctx;

+   struct gl_context *shareCtx = share ? share->ctx : NULL;

+   struct dd_function_table funcs;

+

+   /* Sanity checks */

+   assert(MESA_SHADER_VERTEX == PIPE_SHADER_VERTEX);

+   assert(MESA_SHADER_FRAGMENT == PIPE_SHADER_FRAGMENT);

+   assert(MESA_SHADER_GEOMETRY == PIPE_SHADER_GEOMETRY);

+

+   memset(&funcs, 0, sizeof(funcs));

+   st_init_driver_functions(&funcs);

+

+   ctx = _mesa_create_context(api, visual, shareCtx, &funcs, NULL);

+

+   /* XXX: need a capability bit in gallium to query if the pipe

+    * driver prefers DP4 or MUL/MAD for vertex transformation.

+    */

+   if (debug_get_option_mesa_mvp_dp4())

+      _mesa_set_mvp_with_dp4( ctx, GL_TRUE );

+

+   return st_create_context_priv(ctx, pipe);

+}

+

+

+static void st_destroy_context_priv( struct st_context *st )

+{

+   uint i;

+

+   st_destroy_atoms( st );

+   st_destroy_draw( st );

+   st_destroy_generate_mipmap(st);

+   st_destroy_blit(st);

+   st_destroy_clear(st);

+   st_destroy_bitmap(st);

+   st_destroy_drawpix(st);

+   st_destroy_drawtex(st);

+

+   /* Unreference any user vertex buffers. */

+   for (i = 0; i < st->num_user_vbs; i++) {

+      pipe_resource_reference(&st->user_vb[i], NULL);

+   }

+

+   for (i = 0; i < Elements(st->state.sampler_views); i++) {

+      pipe_sampler_view_reference(&st->state.sampler_views[i], NULL);

+   }

+

+   if (st->default_texture) {

+      st->ctx->Driver.DeleteTexture(st->ctx, st->default_texture);

+      st->default_texture = NULL;

+   }

+

+   free( st );

+}

+

+ 

+void st_destroy_context( struct st_context *st )

+{

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = st->cso_context;

+   struct gl_context *ctx = st->ctx;

+   GLuint i;

+

+   /* need to unbind and destroy CSO objects before anything else */

+   cso_release_all(st->cso_context);

+

+   st_reference_fragprog(st, &st->fp, NULL);

+   st_reference_vertprog(st, &st->vp, NULL);

+

+   /* release framebuffer surfaces */

+   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {

+      pipe_surface_reference(&st->state.framebuffer.cbufs[i], NULL);

+   }

+   pipe_surface_reference(&st->state.framebuffer.zsbuf, NULL);

+

+   pipe->set_index_buffer(pipe, NULL);

+

+   for (i = 0; i < PIPE_SHADER_TYPES; i++) {

+      pipe->set_constant_buffer(pipe, i, 0, NULL);

+   }

+

+   _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);

+

+   _vbo_DestroyContext(st->ctx);

+

+   st_destroy_program_variants(st);

+

+   _mesa_free_context_data(ctx);

+

+   st_destroy_context_priv(st);

+

+   cso_destroy_context(cso);

+

+   pipe->destroy( pipe );

+

+   free(ctx);

+}

+

+

+void st_init_driver_functions(struct dd_function_table *functions)

+{

+   _mesa_init_shader_object_functions(functions);

+

+   st_init_accum_functions(functions);

+   st_init_blit_functions(functions);

+   st_init_bufferobject_functions(functions);

+   st_init_clear_functions(functions);

+   st_init_bitmap_functions(functions);

+   st_init_drawpixels_functions(functions);

+   st_init_rasterpos_functions(functions);

+

+   st_init_drawtex_functions(functions);

+

+   st_init_eglimage_functions(functions);

+

+   st_init_fbo_functions(functions);

+   st_init_feedback_functions(functions);

+   st_init_program_functions(functions);

+   st_init_query_functions(functions);

+   st_init_cond_render_functions(functions);

+   st_init_readpixels_functions(functions);

+   st_init_texture_functions(functions);

+   st_init_flush_functions(functions);

+   st_init_string_functions(functions);

+   st_init_viewport_functions(functions);

+

+   st_init_xformfb_functions(functions);

+   st_init_syncobj_functions(functions);

+

+   functions->UpdateState = st_invalidate_state;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_context.h b/mesalib/src/mesa/state_tracker/st_context.h
index 77765f023..ef54fd7cd 100644
--- a/mesalib/src/mesa/state_tracker/st_context.h
+++ b/mesalib/src/mesa/state_tracker/st_context.h
@@ -1,270 +1,270 @@
-/**************************************************************************
- * 
- * Copyright 2003 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-#ifndef ST_CONTEXT_H
-#define ST_CONTEXT_H
-
-#include "main/mtypes.h"
-#include "pipe/p_state.h"
-#include "state_tracker/st_api.h"
-
-struct bitmap_cache;
-struct blit_state;
-struct dd_function_table;
-struct draw_context;
-struct draw_stage;
-struct gen_mipmap_state;
-struct st_context;
-struct st_fragment_program;
-
-
-#define ST_NEW_MESA                    0x1 /* Mesa state has changed */
-#define ST_NEW_FRAGMENT_PROGRAM        0x2
-#define ST_NEW_VERTEX_PROGRAM          0x4
-#define ST_NEW_FRAMEBUFFER             0x8
-#define ST_NEW_EDGEFLAGS_DATA          0x10
-#define ST_NEW_GEOMETRY_PROGRAM        0x20
-
-
-struct st_state_flags {
-   GLuint mesa;
-   GLuint st;
-};
-
-struct st_tracked_state {
-   const char *name;
-   struct st_state_flags dirty;
-   void (*update)( struct st_context *st );
-};
-
-
-
-struct st_context
-{
-   struct st_context_iface iface;
-
-   struct gl_context *ctx;
-
-   struct pipe_context *pipe;
-
-   struct draw_context *draw;  /**< For selection/feedback/rastpos only */
-   struct draw_stage *feedback_stage;  /**< For GL_FEEDBACK rendermode */
-   struct draw_stage *selection_stage;  /**< For GL_SELECT rendermode */
-   struct draw_stage *rastpos_stage;  /**< For glRasterPos */
-
-
-   /* On old libGL's for linux we need to invalidate the drawables
-    * on glViewpport calls, this is set via a option.
-    */
-   boolean invalidate_on_gl_viewport;
-
-   /* Some state is contained in constant objects.
-    * Other state is just parameter values.
-    */
-   struct {
-      struct pipe_blend_state               blend;
-      struct pipe_depth_stencil_alpha_state depth_stencil;
-      struct pipe_rasterizer_state          rasterizer;
-      struct pipe_sampler_state             samplers[PIPE_MAX_SAMPLERS];
-      struct pipe_sampler_state             *sampler_list[PIPE_MAX_SAMPLERS];
-      struct pipe_clip_state clip;
-      struct {
-         void *ptr;
-         unsigned size;
-      } constants[PIPE_SHADER_TYPES];
-      struct pipe_framebuffer_state framebuffer;
-      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
-      struct pipe_scissor_state scissor;
-      struct pipe_viewport_state viewport;
-      unsigned sample_mask;
-
-      GLuint num_samplers;
-      GLuint num_textures;
-
-      GLuint poly_stipple[32];  /**< In OpenGL's bottom-to-top order */
-   } state;
-
-   char vendor[100];
-   char renderer[100];
-
-   struct st_state_flags dirty;
-
-   GLboolean missing_textures;
-   GLboolean vertdata_edgeflags;
-
-   /** Mapping from VERT_RESULT_x to post-transformed vertex slot */
-   const GLuint *vertex_result_to_slot;
-
-   struct st_vertex_program *vp;    /**< Currently bound vertex program */
-   struct st_fragment_program *fp;  /**< Currently bound fragment program */
-   struct st_geometry_program *gp;  /**< Currently bound geometry program */
-
-   struct st_vp_variant *vp_variant;
-   struct st_fp_variant *fp_variant;
-   struct st_gp_variant *gp_variant;
-
-   struct gl_texture_object *default_texture;
-
-   struct {
-      struct gl_program_cache *cache;
-      struct st_fragment_program *program;  /**< cur pixel transfer prog */
-      GLuint xfer_prog_sn;  /**< pixel xfer program serial no. */
-      GLuint user_prog_sn;  /**< user fragment program serial no. */
-      struct st_fragment_program *combined_prog;
-      GLuint combined_prog_sn;
-      struct pipe_resource *pixelmap_texture;
-      struct pipe_sampler_view *pixelmap_sampler_view;
-      boolean pixelmap_enabled;  /**< use the pixelmap texture? */
-   } pixel_xfer;
-
-   /** for glBitmap */
-   struct {
-      struct pipe_rasterizer_state rasterizer;
-      struct pipe_sampler_state samplers[2];
-      enum pipe_format tex_format;
-      void *vs;
-      float vertices[4][3][4];  /**< vertex pos + color + texcoord */
-      struct pipe_resource *vbuf;
-      unsigned vbuf_slot;       /* next free slot in vbuf */
-      struct bitmap_cache *cache;
-   } bitmap;
-
-   /** for glDraw/CopyPixels */
-   struct {
-      struct gl_fragment_program *shaders[4];
-      void *vert_shaders[2];   /**< ureg shaders */
-   } drawpix;
-
-   /** for glClear */
-   struct {
-      struct pipe_rasterizer_state raster;
-      struct pipe_viewport_state viewport;
-      struct pipe_clip_state clip;
-      void *vs;
-      void *fs;
-      float vertices[4][2][4];  /**< vertex pos + color */
-      struct pipe_resource *vbuf;
-      unsigned vbuf_slot;
-      boolean enable_ds_separate;
-   } clear;
-
-   /** used for anything using util_draw_vertex_buffer */
-   struct pipe_vertex_element velems_util_draw[3];
-
-   void *passthrough_fs;  /**< simple pass-through frag shader */
-
-   enum pipe_texture_target internal_target;
-   struct gen_mipmap_state *gen_mipmap;
-   struct blit_state *blit;
-
-   struct cso_context *cso_context;
-
-   int force_msaa;
-   void *winsys_drawable_handle;
-
-   /* User vertex buffers. */
-   struct pipe_resource *user_vb[PIPE_MAX_ATTRIBS];
-   unsigned user_vb_stride[PIPE_MAX_ATTRIBS];
-   unsigned num_user_vbs;
-};
-
-
-/* Need this so that we can implement Mesa callbacks in this module.
- */
-static INLINE struct st_context *st_context(struct gl_context *ctx)
-{
-   return ctx->st;
-}
-
-
-/**
- * Wrapper for struct gl_framebuffer.
- * This is an opaque type to the outside world.
- */
-struct st_framebuffer
-{
-   struct gl_framebuffer Base;
-   void *Private;
-
-   struct st_framebuffer_iface *iface;
-   enum st_attachment_type statts[ST_ATTACHMENT_COUNT];
-   unsigned num_statts;
-   int32_t revalidate;
-};
-
-
-extern void st_init_driver_functions(struct dd_function_table *functions);
-
-void st_invalidate_state(struct gl_context * ctx, GLuint new_state);
-
-
-
-#define Y_0_TOP 1
-#define Y_0_BOTTOM 2
-
-static INLINE GLuint
-st_fb_orientation(const struct gl_framebuffer *fb)
-{
-   if (fb && fb->Name == 0) {
-      /* Drawing into a window (on-screen buffer).
-       *
-       * Negate Y scale to flip image vertically.
-       * The NDC Y coords prior to viewport transformation are in the range
-       * [y=-1=bottom, y=1=top]
-       * Hardware window coords are in the range [y=0=top, y=H-1=bottom] where
-       * H is the window height.
-       * Use the viewport transformation to invert Y.
-       */
-      return Y_0_TOP;
-   }
-   else {
-      /* Drawing into user-created FBO (very likely a texture).
-       *
-       * For textures, T=0=Bottom, so by extension Y=0=Bottom for rendering.
-       */
-      return Y_0_BOTTOM;
-   }
-}
-
-
-/** clear-alloc a struct-sized object, with casting */
-#define ST_CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))
-
-
-extern int
-st_get_msaa(void);
-
-extern struct st_context *
-st_create_context(gl_api api, struct pipe_context *pipe,
-                  const struct gl_config *visual,
-                  struct st_context *share);
-
-extern void
-st_destroy_context(struct st_context *st);
-
-
-#endif
+/**************************************************************************

+ * 

+ * Copyright 2003 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+#ifndef ST_CONTEXT_H

+#define ST_CONTEXT_H

+

+#include "main/mtypes.h"

+#include "pipe/p_state.h"

+#include "state_tracker/st_api.h"

+

+struct bitmap_cache;

+struct blit_state;

+struct dd_function_table;

+struct draw_context;

+struct draw_stage;

+struct gen_mipmap_state;

+struct st_context;

+struct st_fragment_program;

+

+

+#define ST_NEW_MESA                    0x1 /* Mesa state has changed */

+#define ST_NEW_FRAGMENT_PROGRAM        0x2

+#define ST_NEW_VERTEX_PROGRAM          0x4

+#define ST_NEW_FRAMEBUFFER             0x8

+#define ST_NEW_EDGEFLAGS_DATA          0x10

+#define ST_NEW_GEOMETRY_PROGRAM        0x20

+

+

+struct st_state_flags {

+   GLuint mesa;

+   GLuint st;

+};

+

+struct st_tracked_state {

+   const char *name;

+   struct st_state_flags dirty;

+   void (*update)( struct st_context *st );

+};

+

+

+

+struct st_context

+{

+   struct st_context_iface iface;

+

+   struct gl_context *ctx;

+

+   struct pipe_context *pipe;

+

+   struct draw_context *draw;  /**< For selection/feedback/rastpos only */

+   struct draw_stage *feedback_stage;  /**< For GL_FEEDBACK rendermode */

+   struct draw_stage *selection_stage;  /**< For GL_SELECT rendermode */

+   struct draw_stage *rastpos_stage;  /**< For glRasterPos */

+

+

+   /* On old libGL's for linux we need to invalidate the drawables

+    * on glViewpport calls, this is set via a option.

+    */

+   boolean invalidate_on_gl_viewport;

+

+   /* Some state is contained in constant objects.

+    * Other state is just parameter values.

+    */

+   struct {

+      struct pipe_blend_state               blend;

+      struct pipe_depth_stencil_alpha_state depth_stencil;

+      struct pipe_rasterizer_state          rasterizer;

+      struct pipe_sampler_state             samplers[PIPE_MAX_SAMPLERS];

+      struct pipe_sampler_state             *sampler_list[PIPE_MAX_SAMPLERS];

+      struct pipe_clip_state clip;

+      struct {

+         void *ptr;

+         unsigned size;

+      } constants[PIPE_SHADER_TYPES];

+      struct pipe_framebuffer_state framebuffer;

+      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];

+      struct pipe_scissor_state scissor;

+      struct pipe_viewport_state viewport;

+      unsigned sample_mask;

+

+      GLuint num_samplers;

+      GLuint num_textures;

+

+      GLuint poly_stipple[32];  /**< In OpenGL's bottom-to-top order */

+   } state;

+

+   char vendor[100];

+   char renderer[100];

+

+   struct st_state_flags dirty;

+

+   GLboolean missing_textures;

+   GLboolean vertdata_edgeflags;

+

+   /** Mapping from VERT_RESULT_x to post-transformed vertex slot */

+   const GLuint *vertex_result_to_slot;

+

+   struct st_vertex_program *vp;    /**< Currently bound vertex program */

+   struct st_fragment_program *fp;  /**< Currently bound fragment program */

+   struct st_geometry_program *gp;  /**< Currently bound geometry program */

+

+   struct st_vp_variant *vp_variant;

+   struct st_fp_variant *fp_variant;

+   struct st_gp_variant *gp_variant;

+

+   struct gl_texture_object *default_texture;

+

+   struct {

+      struct gl_program_cache *cache;

+      struct st_fragment_program *program;  /**< cur pixel transfer prog */

+      GLuint xfer_prog_sn;  /**< pixel xfer program serial no. */

+      GLuint user_prog_sn;  /**< user fragment program serial no. */

+      struct st_fragment_program *combined_prog;

+      GLuint combined_prog_sn;

+      struct pipe_resource *pixelmap_texture;

+      struct pipe_sampler_view *pixelmap_sampler_view;

+      boolean pixelmap_enabled;  /**< use the pixelmap texture? */

+   } pixel_xfer;

+

+   /** for glBitmap */

+   struct {

+      struct pipe_rasterizer_state rasterizer;

+      struct pipe_sampler_state samplers[2];

+      enum pipe_format tex_format;

+      void *vs;

+      float vertices[4][3][4];  /**< vertex pos + color + texcoord */

+      struct pipe_resource *vbuf;

+      unsigned vbuf_slot;       /* next free slot in vbuf */

+      struct bitmap_cache *cache;

+   } bitmap;

+

+   /** for glDraw/CopyPixels */

+   struct {

+      struct gl_fragment_program *shaders[4];

+      void *vert_shaders[2];   /**< ureg shaders */

+   } drawpix;

+

+   /** for glClear */

+   struct {

+      struct pipe_rasterizer_state raster;

+      struct pipe_viewport_state viewport;

+      struct pipe_clip_state clip;

+      void *vs;

+      void *fs;

+      float vertices[4][2][4];  /**< vertex pos + color */

+      struct pipe_resource *vbuf;

+      unsigned vbuf_slot;

+      boolean enable_ds_separate;

+   } clear;

+

+   /** used for anything using util_draw_vertex_buffer */

+   struct pipe_vertex_element velems_util_draw[3];

+

+   void *passthrough_fs;  /**< simple pass-through frag shader */

+

+   enum pipe_texture_target internal_target;

+   struct gen_mipmap_state *gen_mipmap;

+   struct blit_state *blit;

+

+   struct cso_context *cso_context;

+

+   int force_msaa;

+   void *winsys_drawable_handle;

+

+   /* User vertex buffers. */

+   struct pipe_resource *user_vb[PIPE_MAX_ATTRIBS];

+   unsigned user_vb_stride[PIPE_MAX_ATTRIBS];

+   unsigned num_user_vbs;

+};

+

+

+/* Need this so that we can implement Mesa callbacks in this module.

+ */

+static INLINE struct st_context *st_context(struct gl_context *ctx)

+{

+   return ctx->st;

+}

+

+

+/**

+ * Wrapper for struct gl_framebuffer.

+ * This is an opaque type to the outside world.

+ */

+struct st_framebuffer

+{

+   struct gl_framebuffer Base;

+   void *Private;

+

+   struct st_framebuffer_iface *iface;

+   enum st_attachment_type statts[ST_ATTACHMENT_COUNT];

+   unsigned num_statts;

+   int32_t revalidate;

+};

+

+

+extern void st_init_driver_functions(struct dd_function_table *functions);

+

+void st_invalidate_state(struct gl_context * ctx, GLuint new_state);

+

+

+

+#define Y_0_TOP 1

+#define Y_0_BOTTOM 2

+

+static INLINE GLuint

+st_fb_orientation(const struct gl_framebuffer *fb)

+{

+   if (fb && fb->Name == 0) {

+      /* Drawing into a window (on-screen buffer).

+       *

+       * Negate Y scale to flip image vertically.

+       * The NDC Y coords prior to viewport transformation are in the range

+       * [y=-1=bottom, y=1=top]

+       * Hardware window coords are in the range [y=0=top, y=H-1=bottom] where

+       * H is the window height.

+       * Use the viewport transformation to invert Y.

+       */

+      return Y_0_TOP;

+   }

+   else {

+      /* Drawing into user-created FBO (very likely a texture).

+       *

+       * For textures, T=0=Bottom, so by extension Y=0=Bottom for rendering.

+       */

+      return Y_0_BOTTOM;

+   }

+}

+

+

+/** clear-alloc a struct-sized object, with casting */

+#define ST_CALLOC_STRUCT(T)   (struct T *) calloc(1, sizeof(struct T))

+

+

+extern int

+st_get_msaa(void);

+

+extern struct st_context *

+st_create_context(gl_api api, struct pipe_context *pipe,

+                  const struct gl_config *visual,

+                  struct st_context *share);

+

+extern void

+st_destroy_context(struct st_context *st);

+

+

+#endif

diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c
index 40afa4362..2f4027bc4 100644
--- a/mesalib/src/mesa/state_tracker/st_draw.c
+++ b/mesalib/src/mesa/state_tracker/st_draw.c
@@ -1,773 +1,773 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-/*
- * This file implements the st_draw_vbo() function which is called from
- * Mesa's VBO module.  All point/line/triangle rendering is done through
- * this function whether the user called glBegin/End, glDrawArrays,
- * glDrawElements, glEvalMesh, or glCalList, etc.
- *
- * We basically convert the VBO's vertex attribute/array information into
- * Gallium vertex state, bind the vertex buffer objects and call
- * pipe->draw_elements(), pipe->draw_range_elements() or pipe->draw_arrays().
- *
- * Authors:
- *   Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "program/prog_uniform.h"
-
-#include "vbo/vbo.h"
-
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_bufferobjects.h"
-#include "st_draw.h"
-#include "st_program.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_prim.h"
-#include "util/u_draw_quad.h"
-#include "draw/draw_context.h"
-#include "cso_cache/cso_context.h"
-
-
-static GLuint double_types[4] = {
-   PIPE_FORMAT_R64_FLOAT,
-   PIPE_FORMAT_R64G64_FLOAT,
-   PIPE_FORMAT_R64G64B64_FLOAT,
-   PIPE_FORMAT_R64G64B64A64_FLOAT
-};
-
-static GLuint float_types[4] = {
-   PIPE_FORMAT_R32_FLOAT,
-   PIPE_FORMAT_R32G32_FLOAT,
-   PIPE_FORMAT_R32G32B32_FLOAT,
-   PIPE_FORMAT_R32G32B32A32_FLOAT
-};
-
-static GLuint half_float_types[4] = {
-   PIPE_FORMAT_R16_FLOAT,
-   PIPE_FORMAT_R16G16_FLOAT,
-   PIPE_FORMAT_R16G16B16_FLOAT,
-   PIPE_FORMAT_R16G16B16A16_FLOAT
-};
-
-static GLuint uint_types_norm[4] = {
-   PIPE_FORMAT_R32_UNORM,
-   PIPE_FORMAT_R32G32_UNORM,
-   PIPE_FORMAT_R32G32B32_UNORM,
-   PIPE_FORMAT_R32G32B32A32_UNORM
-};
-
-static GLuint uint_types_scale[4] = {
-   PIPE_FORMAT_R32_USCALED,
-   PIPE_FORMAT_R32G32_USCALED,
-   PIPE_FORMAT_R32G32B32_USCALED,
-   PIPE_FORMAT_R32G32B32A32_USCALED
-};
-
-static GLuint int_types_norm[4] = {
-   PIPE_FORMAT_R32_SNORM,
-   PIPE_FORMAT_R32G32_SNORM,
-   PIPE_FORMAT_R32G32B32_SNORM,
-   PIPE_FORMAT_R32G32B32A32_SNORM
-};
-
-static GLuint int_types_scale[4] = {
-   PIPE_FORMAT_R32_SSCALED,
-   PIPE_FORMAT_R32G32_SSCALED,
-   PIPE_FORMAT_R32G32B32_SSCALED,
-   PIPE_FORMAT_R32G32B32A32_SSCALED
-};
-
-static GLuint ushort_types_norm[4] = {
-   PIPE_FORMAT_R16_UNORM,
-   PIPE_FORMAT_R16G16_UNORM,
-   PIPE_FORMAT_R16G16B16_UNORM,
-   PIPE_FORMAT_R16G16B16A16_UNORM
-};
-
-static GLuint ushort_types_scale[4] = {
-   PIPE_FORMAT_R16_USCALED,
-   PIPE_FORMAT_R16G16_USCALED,
-   PIPE_FORMAT_R16G16B16_USCALED,
-   PIPE_FORMAT_R16G16B16A16_USCALED
-};
-
-static GLuint short_types_norm[4] = {
-   PIPE_FORMAT_R16_SNORM,
-   PIPE_FORMAT_R16G16_SNORM,
-   PIPE_FORMAT_R16G16B16_SNORM,
-   PIPE_FORMAT_R16G16B16A16_SNORM
-};
-
-static GLuint short_types_scale[4] = {
-   PIPE_FORMAT_R16_SSCALED,
-   PIPE_FORMAT_R16G16_SSCALED,
-   PIPE_FORMAT_R16G16B16_SSCALED,
-   PIPE_FORMAT_R16G16B16A16_SSCALED
-};
-
-static GLuint ubyte_types_norm[4] = {
-   PIPE_FORMAT_R8_UNORM,
-   PIPE_FORMAT_R8G8_UNORM,
-   PIPE_FORMAT_R8G8B8_UNORM,
-   PIPE_FORMAT_R8G8B8A8_UNORM
-};
-
-static GLuint ubyte_types_scale[4] = {
-   PIPE_FORMAT_R8_USCALED,
-   PIPE_FORMAT_R8G8_USCALED,
-   PIPE_FORMAT_R8G8B8_USCALED,
-   PIPE_FORMAT_R8G8B8A8_USCALED
-};
-
-static GLuint byte_types_norm[4] = {
-   PIPE_FORMAT_R8_SNORM,
-   PIPE_FORMAT_R8G8_SNORM,
-   PIPE_FORMAT_R8G8B8_SNORM,
-   PIPE_FORMAT_R8G8B8A8_SNORM
-};
-
-static GLuint byte_types_scale[4] = {
-   PIPE_FORMAT_R8_SSCALED,
-   PIPE_FORMAT_R8G8_SSCALED,
-   PIPE_FORMAT_R8G8B8_SSCALED,
-   PIPE_FORMAT_R8G8B8A8_SSCALED
-};
-
-static GLuint fixed_types[4] = {
-   PIPE_FORMAT_R32_FIXED,
-   PIPE_FORMAT_R32G32_FIXED,
-   PIPE_FORMAT_R32G32B32_FIXED,
-   PIPE_FORMAT_R32G32B32A32_FIXED
-};
-
-
-
-/**
- * Return a PIPE_FORMAT_x for the given GL datatype and size.
- */
-GLuint
-st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
-                      GLboolean normalized)
-{
-   assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
-          type == GL_FIXED || type == GL_HALF_FLOAT);
-   assert(size >= 1);
-   assert(size <= 4);
-   assert(format == GL_RGBA || format == GL_BGRA);
-
-   if (format == GL_BGRA) {
-      /* this is an odd-ball case */
-      assert(type == GL_UNSIGNED_BYTE);
-      assert(normalized);
-      return PIPE_FORMAT_B8G8R8A8_UNORM;
-   }
-
-   if (normalized) {
-      switch (type) {
-      case GL_DOUBLE: return double_types[size-1];
-      case GL_FLOAT: return float_types[size-1];
-      case GL_HALF_FLOAT: return half_float_types[size-1];
-      case GL_INT: return int_types_norm[size-1];
-      case GL_SHORT: return short_types_norm[size-1];
-      case GL_BYTE: return byte_types_norm[size-1];
-      case GL_UNSIGNED_INT: return uint_types_norm[size-1];
-      case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];
-      case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];
-      case GL_FIXED: return fixed_types[size-1];
-      default: assert(0); return 0;
-      }      
-   }
-   else {
-      switch (type) {
-      case GL_DOUBLE: return double_types[size-1];
-      case GL_FLOAT: return float_types[size-1];
-      case GL_HALF_FLOAT: return half_float_types[size-1];
-      case GL_INT: return int_types_scale[size-1];
-      case GL_SHORT: return short_types_scale[size-1];
-      case GL_BYTE: return byte_types_scale[size-1];
-      case GL_UNSIGNED_INT: return uint_types_scale[size-1];
-      case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];
-      case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];
-      case GL_FIXED: return fixed_types[size-1];
-      default: assert(0); return 0;
-      }      
-   }
-   return 0; /* silence compiler warning */
-}
-
-
-
-
-
-/**
- * Examine the active arrays to determine if we have interleaved
- * vertex arrays all living in one VBO, or all living in user space.
- * \param userSpace  returns whether the arrays are in user space.
- */
-static GLboolean
-is_interleaved_arrays(const struct st_vertex_program *vp,
-                      const struct st_vp_variant *vpv,
-                      const struct gl_client_array **arrays)
-{
-   GLuint attr;
-   const struct gl_buffer_object *firstBufObj = NULL;
-   GLint firstStride = -1;
-   const GLubyte *client_addr = NULL;
-   GLboolean user_memory;
-
-   for (attr = 0; attr < vpv->num_inputs; attr++) {
-      const GLuint mesaAttr = vp->index_to_input[attr];
-      const struct gl_buffer_object *bufObj = arrays[mesaAttr]->BufferObj;
-      const GLsizei stride = arrays[mesaAttr]->StrideB; /* in bytes */
-
-      if (firstStride < 0) {
-         firstStride = stride;
-         user_memory = !bufObj || !bufObj->Name;
-      }
-      else if (firstStride != stride) {
-         return GL_FALSE;
-      }
-
-      if (!bufObj || !bufObj->Name) {
-         /* Try to detect if the client-space arrays are
-          * "close" to each other.
-          */
-         if (!user_memory) {
-            return GL_FALSE;
-         }
-         if (!client_addr) {
-            client_addr = arrays[mesaAttr]->Ptr;
-         }
-         else if (abs(arrays[mesaAttr]->Ptr - client_addr) > firstStride) {
-            /* arrays start too far apart */
-            return GL_FALSE;
-         }
-      }
-      else if (!firstBufObj) {
-         if (user_memory) {
-            return GL_FALSE;
-         }
-         firstBufObj = bufObj;
-      }
-      else if (bufObj != firstBufObj) {
-         return GL_FALSE;
-      }
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Set up for drawing interleaved arrays that all live in one VBO
- * or all live in user space.
- * \param vbuffer  returns vertex buffer info
- * \param velements  returns vertex element info
- */
-static void
-setup_interleaved_attribs(struct gl_context *ctx,
-                          const struct st_vertex_program *vp,
-                          const struct st_vp_variant *vpv,
-                          const struct gl_client_array **arrays,
-                          struct pipe_vertex_buffer *vbuffer,
-                          struct pipe_vertex_element velements[],
-                          unsigned max_index,
-                          unsigned num_instances)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   GLuint attr;
-   const GLubyte *low_addr = NULL;
-
-   /* Find the lowest address. */
-   if(vpv->num_inputs) {
-      low_addr = arrays[vp->index_to_input[0]]->Ptr;
-
-      for (attr = 1; attr < vpv->num_inputs; attr++) {
-         const GLubyte *start = arrays[vp->index_to_input[attr]]->Ptr;
-         low_addr = MIN2(low_addr, start);
-      }
-   }
-
-   for (attr = 0; attr < vpv->num_inputs; attr++) {
-      const GLuint mesaAttr = vp->index_to_input[attr];
-      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
-      struct st_buffer_object *stobj = st_buffer_object(bufobj);
-      GLsizei stride = arrays[mesaAttr]->StrideB;
-
-      if (attr == 0) {
-         if (bufobj && bufobj->Name) {
-            vbuffer->buffer = NULL;
-            pipe_resource_reference(&vbuffer->buffer, stobj->buffer);
-            vbuffer->buffer_offset = pointer_to_offset(low_addr);
-         } else {
-            uint divisor = arrays[mesaAttr]->InstanceDivisor;
-            uint length = (divisor ? num_instances / divisor : max_index) + 1;
-            vbuffer->buffer =
-               pipe_user_buffer_create(pipe->screen, (void*)low_addr,
-                                       stride * length,
-				       PIPE_BIND_VERTEX_BUFFER);
-            vbuffer->buffer_offset = 0;
-
-            /* Track user vertex buffers. */
-            pipe_resource_reference(&st->user_vb[0], vbuffer->buffer);
-            st->user_vb_stride[0] = stride;
-            st->num_user_vbs = 1;
-         }
-         vbuffer->stride = stride; /* in bytes */
-      }
-
-      velements[attr].src_offset =
-         (unsigned) (arrays[mesaAttr]->Ptr - low_addr);
-      velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;
-      velements[attr].vertex_buffer_index = 0;
-      velements[attr].src_format =
-         st_pipe_vertex_format(arrays[mesaAttr]->Type,
-                               arrays[mesaAttr]->Size,
-                               arrays[mesaAttr]->Format,
-                               arrays[mesaAttr]->Normalized);
-      assert(velements[attr].src_format);
-   }
-}
-
-
-/**
- * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each
- * vertex attribute.
- * \param vbuffer  returns vertex buffer info
- * \param velements  returns vertex element info
- */
-static void
-setup_non_interleaved_attribs(struct gl_context *ctx,
-                              const struct st_vertex_program *vp,
-                              const struct st_vp_variant *vpv,
-                              const struct gl_client_array **arrays,
-                              struct pipe_vertex_buffer vbuffer[],
-                              struct pipe_vertex_element velements[],
-                              unsigned max_index,
-                              unsigned num_instances)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   GLuint attr;
-
-   for (attr = 0; attr < vpv->num_inputs; attr++) {
-      const GLuint mesaAttr = vp->index_to_input[attr];
-      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
-      GLsizei stride = arrays[mesaAttr]->StrideB;
-
-      if (bufobj && bufobj->Name) {
-         /* Attribute data is in a VBO.
-          * Recall that for VBOs, the gl_client_array->Ptr field is
-          * really an offset from the start of the VBO, not a pointer.
-          */
-         struct st_buffer_object *stobj = st_buffer_object(bufobj);
-         assert(stobj->buffer);
-
-         vbuffer[attr].buffer = NULL;
-         pipe_resource_reference(&vbuffer[attr].buffer, stobj->buffer);
-         vbuffer[attr].buffer_offset = pointer_to_offset(arrays[mesaAttr]->Ptr);
-      }
-      else {
-         /* wrap user data */
-         if (arrays[mesaAttr]->Ptr) {
-            uint divisor = arrays[mesaAttr]->InstanceDivisor;
-            uint length = (divisor ? num_instances / divisor : max_index) + 1;
-            vbuffer[attr].buffer =
-	       pipe_user_buffer_create(pipe->screen,
-				       (void *) arrays[mesaAttr]->Ptr,
-				       stride * length,
-				       PIPE_BIND_VERTEX_BUFFER);
-         }
-         else {
-            /* no array, use ctx->Current.Attrib[] value */
-            uint bytes = sizeof(ctx->Current.Attrib[0]);
-            vbuffer[attr].buffer =
-	       pipe_user_buffer_create(pipe->screen,
-				       (void *) ctx->Current.Attrib[mesaAttr],
-				       bytes,
-				       PIPE_BIND_VERTEX_BUFFER);
-            stride = 0;
-         }
-
-         vbuffer[attr].buffer_offset = 0;
-
-         /* Track user vertex buffers. */
-         pipe_resource_reference(&st->user_vb[attr], vbuffer[attr].buffer);
-         st->user_vb_stride[attr] = stride;
-         st->num_user_vbs = MAX2(st->num_user_vbs, attr+1);
-      }
-
-      /* common-case setup */
-      vbuffer[attr].stride = stride; /* in bytes */
-
-      velements[attr].src_offset = 0;
-      velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;
-      velements[attr].vertex_buffer_index = attr;
-      velements[attr].src_format
-         = st_pipe_vertex_format(arrays[mesaAttr]->Type,
-                                 arrays[mesaAttr]->Size,
-                                 arrays[mesaAttr]->Format,
-                                 arrays[mesaAttr]->Normalized);
-      assert(velements[attr].src_format);
-   }
-}
-
-
-static void
-setup_index_buffer(struct gl_context *ctx,
-                   const struct _mesa_index_buffer *ib,
-                   struct pipe_index_buffer *ibuffer)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-
-   memset(ibuffer, 0, sizeof(*ibuffer));
-   if (ib) {
-      struct gl_buffer_object *bufobj = ib->obj;
-
-      switch (ib->type) {
-      case GL_UNSIGNED_INT:
-         ibuffer->index_size = 4;
-         break;
-      case GL_UNSIGNED_SHORT:
-         ibuffer->index_size = 2;
-         break;
-      case GL_UNSIGNED_BYTE:
-         ibuffer->index_size = 1;
-         break;
-      default:
-         assert(0);
-	 return;
-      }
-
-      /* get/create the index buffer object */
-      if (bufobj && bufobj->Name) {
-         /* elements/indexes are in a real VBO */
-         struct st_buffer_object *stobj = st_buffer_object(bufobj);
-         pipe_resource_reference(&ibuffer->buffer, stobj->buffer);
-         ibuffer->offset = pointer_to_offset(ib->ptr);
-      }
-      else {
-         /* element/indicies are in user space memory */
-         ibuffer->buffer =
-            pipe_user_buffer_create(pipe->screen, (void *) ib->ptr,
-                                    ib->count * ibuffer->index_size,
-                                    PIPE_BIND_INDEX_BUFFER);
-      }
-   }
-}
-
-/**
- * Prior to drawing, check that any uniforms referenced by the
- * current shader have been set.  If a uniform has not been set,
- * issue a warning.
- */
-static void
-check_uniforms(struct gl_context *ctx)
-{
-   struct gl_shader_program *shProg[3] = {
-      ctx->Shader.CurrentVertexProgram,
-      ctx->Shader.CurrentGeometryProgram,
-      ctx->Shader.CurrentFragmentProgram,
-   };
-   unsigned j;
-
-   for (j = 0; j < 3; j++) {
-      unsigned i;
-
-      if (shProg[j] == NULL || !shProg[j]->LinkStatus)
-	 continue;
-
-      for (i = 0; i < shProg[j]->Uniforms->NumUniforms; i++) {
-         const struct gl_uniform *u = &shProg[j]->Uniforms->Uniforms[i];
-         if (!u->Initialized) {
-            _mesa_warning(ctx,
-                          "Using shader with uninitialized uniform: %s",
-                          u->Name);
-         }
-      }
-   }
-}
-
-
-/**
- * Translate OpenGL primtive type (GL_POINTS, GL_TRIANGLE_STRIP, etc) to
- * the corresponding Gallium type.
- */
-static unsigned
-translate_prim(const struct gl_context *ctx, unsigned prim)
-{
-   /* GL prims should match Gallium prims, spot-check a few */
-   assert(GL_POINTS == PIPE_PRIM_POINTS);
-   assert(GL_QUADS == PIPE_PRIM_QUADS);
-   assert(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
-
-   /* Avoid quadstrips if it's easy to do so:
-    * Note: it's imporant to do the correct trimming if we change the prim type!
-    * We do that wherever this function is called.
-    */
-   if (prim == GL_QUAD_STRIP &&
-       ctx->Light.ShadeModel != GL_FLAT &&
-       ctx->Polygon.FrontMode == GL_FILL &&
-       ctx->Polygon.BackMode == GL_FILL)
-      prim = GL_TRIANGLE_STRIP;
-
-   return prim;
-}
-
-
-static void
-st_validate_varrays(struct gl_context *ctx,
-                    const struct gl_client_array **arrays,
-                    unsigned max_index,
-                    unsigned num_instances)
-{
-   struct st_context *st = st_context(ctx);
-   const struct st_vertex_program *vp;
-   const struct st_vp_variant *vpv;
-   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
-   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
-   unsigned num_vbuffers, num_velements;
-   GLuint attr;
-   unsigned i;
-
-   /* must get these after state validation! */
-   vp = st->vp;
-   vpv = st->vp_variant;
-
-   memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);
-
-   /* Unreference any user vertex buffers. */
-   for (i = 0; i < st->num_user_vbs; i++) {
-      pipe_resource_reference(&st->user_vb[i], NULL);
-   }
-   st->num_user_vbs = 0;
-
-   /*
-    * Setup the vbuffer[] and velements[] arrays.
-    */
-   if (is_interleaved_arrays(vp, vpv, arrays)) {
-      setup_interleaved_attribs(ctx, vp, vpv, arrays, vbuffer, velements,
-                                max_index, num_instances);
-
-      num_vbuffers = 1;
-      num_velements = vpv->num_inputs;
-      if (num_velements == 0)
-         num_vbuffers = 0;
-   }
-   else {
-      setup_non_interleaved_attribs(ctx, vp, vpv, arrays,
-                                    vbuffer, velements, max_index, num_instances);
-      num_vbuffers = vpv->num_inputs;
-      num_velements = vpv->num_inputs;
-   }
-
-   cso_set_vertex_buffers(st->cso_context, num_vbuffers, vbuffer);
-   cso_set_vertex_elements(st->cso_context, num_velements, velements);
-
-   /* unreference buffers (frees wrapped user-space buffer objects)
-    * This is OK, because the pipe driver should reference buffers by itself
-    * in set_vertex_buffers. */
-   for (attr = 0; attr < num_vbuffers; attr++) {
-      pipe_resource_reference(&vbuffer[attr].buffer, NULL);
-      assert(!vbuffer[attr].buffer);
-   }
-}
-
-
-/**
- * This function gets plugged into the VBO module and is called when
- * we have something to render.
- * Basically, translate the information into the format expected by gallium.
- */
-void
-st_draw_vbo(struct gl_context *ctx,
-            const struct gl_client_array **arrays,
-            const struct _mesa_prim *prims,
-            GLuint nr_prims,
-            const struct _mesa_index_buffer *ib,
-	    GLboolean index_bounds_valid,
-            GLuint min_index,
-            GLuint max_index)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_index_buffer ibuffer;
-   struct pipe_draw_info info;
-   unsigned i, num_instances = 1;
-   GLboolean new_array =
-         st->dirty.st && (st->dirty.mesa & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;
-
-   /* Mesa core state should have been validated already */
-   assert(ctx->NewState == 0x0);
-
-   if (ib) {
-      /* Gallium probably doesn't want this in some cases. */
-      if (!index_bounds_valid)
-         if (!vbo_all_varyings_in_vbos(arrays))
-            vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);
-
-      for (i = 0; i < nr_prims; i++) {
-         num_instances = MAX2(num_instances, prims[i].num_instances);
-      }
-   } else {
-      /* Get min/max index for non-indexed drawing. */
-      min_index = ~0;
-      max_index = 0;
-
-      for (i = 0; i < nr_prims; i++) {
-         min_index = MIN2(min_index, prims[i].start);
-         max_index = MAX2(max_index, prims[i].start + prims[i].count - 1);
-         num_instances = MAX2(num_instances, prims[i].num_instances);
-      }
-   }
-
-   /* Validate state. */
-   if (st->dirty.st) {
-      GLboolean vertDataEdgeFlags;
-
-      /* sanity check for pointer arithmetic below */
-      assert(sizeof(arrays[0]->Ptr[0]) == 1);
-
-      vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&
-                          arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;
-      if (vertDataEdgeFlags != st->vertdata_edgeflags) {
-         st->vertdata_edgeflags = vertDataEdgeFlags;
-         st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;
-      }
-
-      st_validate_state(st);
-
-      if (new_array) {
-         st_validate_varrays(ctx, arrays, max_index, num_instances);
-      }
-
-#if 0
-      if (MESA_VERBOSE & VERBOSE_GLSL) {
-         check_uniforms(ctx);
-      }
-#else
-      (void) check_uniforms;
-#endif
-   }
-
-   /* Notify the driver that the content of user buffers may have been
-    * changed. */
-   if (!new_array && st->num_user_vbs) {
-      for (i = 0; i < st->num_user_vbs; i++) {
-         if (st->user_vb[i]) {
-            unsigned stride = st->user_vb_stride[i];
-
-            if (stride) {
-               pipe->redefine_user_buffer(pipe, st->user_vb[i],
-                                          min_index * stride,
-                                          (max_index + 1 - min_index) * stride);
-            } else {
-               /* stride == 0 */
-               pipe->redefine_user_buffer(pipe, st->user_vb[i],
-                                          0, st->user_vb[i]->width0);
-            }
-         }
-      }
-   }
-
-   setup_index_buffer(ctx, ib, &ibuffer);
-   pipe->set_index_buffer(pipe, &ibuffer);
-
-   util_draw_init_info(&info);
-   if (ib) {
-      info.indexed = TRUE;
-      if (min_index != ~0 && max_index != ~0) {
-         info.min_index = min_index;
-         info.max_index = max_index;
-      }
-   }
-
-   info.primitive_restart = st->ctx->Array.PrimitiveRestart;
-   info.restart_index = st->ctx->Array.RestartIndex;
-
-   /* do actual drawing */
-   for (i = 0; i < nr_prims; i++) {
-      info.mode = translate_prim( ctx, prims[i].mode );
-      info.start = prims[i].start;
-      info.count = prims[i].count;
-      info.instance_count = prims[i].num_instances;
-      info.index_bias = prims[i].basevertex;
-      if (!ib) {
-         info.min_index = info.start;
-         info.max_index = info.start + info.count - 1;
-      }
-
-      if (u_trim_pipe_prim(info.mode, &info.count))
-         pipe->draw_vbo(pipe, &info);
-   }
-
-   pipe_resource_reference(&ibuffer.buffer, NULL);
-}
-
-
-void st_init_draw( struct st_context *st )
-{
-   struct gl_context *ctx = st->ctx;
-
-   vbo_set_draw_func(ctx, st_draw_vbo);
-
-#if FEATURE_feedback || FEATURE_rastpos
-   st->draw = draw_create(st->pipe); /* for selection/feedback */
-
-   /* Disable draw options that might convert points/lines to tris, etc.
-    * as that would foul-up feedback/selection mode.
-    */
-   draw_wide_line_threshold(st->draw, 1000.0f);
-   draw_wide_point_threshold(st->draw, 1000.0f);
-   draw_enable_line_stipple(st->draw, FALSE);
-   draw_enable_point_sprites(st->draw, FALSE);
-#endif
-}
-
-
-void st_destroy_draw( struct st_context *st )
-{
-#if FEATURE_feedback || FEATURE_rastpos
-   draw_destroy(st->draw);
-#endif
-}
-
-
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+/*

+ * This file implements the st_draw_vbo() function which is called from

+ * Mesa's VBO module.  All point/line/triangle rendering is done through

+ * this function whether the user called glBegin/End, glDrawArrays,

+ * glDrawElements, glEvalMesh, or glCalList, etc.

+ *

+ * We basically convert the VBO's vertex attribute/array information into

+ * Gallium vertex state, bind the vertex buffer objects and call

+ * pipe->draw_elements(), pipe->draw_range_elements() or pipe->draw_arrays().

+ *

+ * Authors:

+ *   Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "program/prog_uniform.h"

+

+#include "vbo/vbo.h"

+

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_bufferobjects.h"

+#include "st_draw.h"

+#include "st_program.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+#include "util/u_format.h"

+#include "util/u_prim.h"

+#include "util/u_draw_quad.h"

+#include "draw/draw_context.h"

+#include "cso_cache/cso_context.h"

+

+

+static GLuint double_types[4] = {

+   PIPE_FORMAT_R64_FLOAT,

+   PIPE_FORMAT_R64G64_FLOAT,

+   PIPE_FORMAT_R64G64B64_FLOAT,

+   PIPE_FORMAT_R64G64B64A64_FLOAT

+};

+

+static GLuint float_types[4] = {

+   PIPE_FORMAT_R32_FLOAT,

+   PIPE_FORMAT_R32G32_FLOAT,

+   PIPE_FORMAT_R32G32B32_FLOAT,

+   PIPE_FORMAT_R32G32B32A32_FLOAT

+};

+

+static GLuint half_float_types[4] = {

+   PIPE_FORMAT_R16_FLOAT,

+   PIPE_FORMAT_R16G16_FLOAT,

+   PIPE_FORMAT_R16G16B16_FLOAT,

+   PIPE_FORMAT_R16G16B16A16_FLOAT

+};

+

+static GLuint uint_types_norm[4] = {

+   PIPE_FORMAT_R32_UNORM,

+   PIPE_FORMAT_R32G32_UNORM,

+   PIPE_FORMAT_R32G32B32_UNORM,

+   PIPE_FORMAT_R32G32B32A32_UNORM

+};

+

+static GLuint uint_types_scale[4] = {

+   PIPE_FORMAT_R32_USCALED,

+   PIPE_FORMAT_R32G32_USCALED,

+   PIPE_FORMAT_R32G32B32_USCALED,

+   PIPE_FORMAT_R32G32B32A32_USCALED

+};

+

+static GLuint int_types_norm[4] = {

+   PIPE_FORMAT_R32_SNORM,

+   PIPE_FORMAT_R32G32_SNORM,

+   PIPE_FORMAT_R32G32B32_SNORM,

+   PIPE_FORMAT_R32G32B32A32_SNORM

+};

+

+static GLuint int_types_scale[4] = {

+   PIPE_FORMAT_R32_SSCALED,

+   PIPE_FORMAT_R32G32_SSCALED,

+   PIPE_FORMAT_R32G32B32_SSCALED,

+   PIPE_FORMAT_R32G32B32A32_SSCALED

+};

+

+static GLuint ushort_types_norm[4] = {

+   PIPE_FORMAT_R16_UNORM,

+   PIPE_FORMAT_R16G16_UNORM,

+   PIPE_FORMAT_R16G16B16_UNORM,

+   PIPE_FORMAT_R16G16B16A16_UNORM

+};

+

+static GLuint ushort_types_scale[4] = {

+   PIPE_FORMAT_R16_USCALED,

+   PIPE_FORMAT_R16G16_USCALED,

+   PIPE_FORMAT_R16G16B16_USCALED,

+   PIPE_FORMAT_R16G16B16A16_USCALED

+};

+

+static GLuint short_types_norm[4] = {

+   PIPE_FORMAT_R16_SNORM,

+   PIPE_FORMAT_R16G16_SNORM,

+   PIPE_FORMAT_R16G16B16_SNORM,

+   PIPE_FORMAT_R16G16B16A16_SNORM

+};

+

+static GLuint short_types_scale[4] = {

+   PIPE_FORMAT_R16_SSCALED,

+   PIPE_FORMAT_R16G16_SSCALED,

+   PIPE_FORMAT_R16G16B16_SSCALED,

+   PIPE_FORMAT_R16G16B16A16_SSCALED

+};

+

+static GLuint ubyte_types_norm[4] = {

+   PIPE_FORMAT_R8_UNORM,

+   PIPE_FORMAT_R8G8_UNORM,

+   PIPE_FORMAT_R8G8B8_UNORM,

+   PIPE_FORMAT_R8G8B8A8_UNORM

+};

+

+static GLuint ubyte_types_scale[4] = {

+   PIPE_FORMAT_R8_USCALED,

+   PIPE_FORMAT_R8G8_USCALED,

+   PIPE_FORMAT_R8G8B8_USCALED,

+   PIPE_FORMAT_R8G8B8A8_USCALED

+};

+

+static GLuint byte_types_norm[4] = {

+   PIPE_FORMAT_R8_SNORM,

+   PIPE_FORMAT_R8G8_SNORM,

+   PIPE_FORMAT_R8G8B8_SNORM,

+   PIPE_FORMAT_R8G8B8A8_SNORM

+};

+

+static GLuint byte_types_scale[4] = {

+   PIPE_FORMAT_R8_SSCALED,

+   PIPE_FORMAT_R8G8_SSCALED,

+   PIPE_FORMAT_R8G8B8_SSCALED,

+   PIPE_FORMAT_R8G8B8A8_SSCALED

+};

+

+static GLuint fixed_types[4] = {

+   PIPE_FORMAT_R32_FIXED,

+   PIPE_FORMAT_R32G32_FIXED,

+   PIPE_FORMAT_R32G32B32_FIXED,

+   PIPE_FORMAT_R32G32B32A32_FIXED

+};

+

+

+

+/**

+ * Return a PIPE_FORMAT_x for the given GL datatype and size.

+ */

+GLuint

+st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,

+                      GLboolean normalized)

+{

+   assert((type >= GL_BYTE && type <= GL_DOUBLE) ||

+          type == GL_FIXED || type == GL_HALF_FLOAT);

+   assert(size >= 1);

+   assert(size <= 4);

+   assert(format == GL_RGBA || format == GL_BGRA);

+

+   if (format == GL_BGRA) {

+      /* this is an odd-ball case */

+      assert(type == GL_UNSIGNED_BYTE);

+      assert(normalized);

+      return PIPE_FORMAT_B8G8R8A8_UNORM;

+   }

+

+   if (normalized) {

+      switch (type) {

+      case GL_DOUBLE: return double_types[size-1];

+      case GL_FLOAT: return float_types[size-1];

+      case GL_HALF_FLOAT: return half_float_types[size-1];

+      case GL_INT: return int_types_norm[size-1];

+      case GL_SHORT: return short_types_norm[size-1];

+      case GL_BYTE: return byte_types_norm[size-1];

+      case GL_UNSIGNED_INT: return uint_types_norm[size-1];

+      case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];

+      case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];

+      case GL_FIXED: return fixed_types[size-1];

+      default: assert(0); return 0;

+      }      

+   }

+   else {

+      switch (type) {

+      case GL_DOUBLE: return double_types[size-1];

+      case GL_FLOAT: return float_types[size-1];

+      case GL_HALF_FLOAT: return half_float_types[size-1];

+      case GL_INT: return int_types_scale[size-1];

+      case GL_SHORT: return short_types_scale[size-1];

+      case GL_BYTE: return byte_types_scale[size-1];

+      case GL_UNSIGNED_INT: return uint_types_scale[size-1];

+      case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];

+      case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];

+      case GL_FIXED: return fixed_types[size-1];

+      default: assert(0); return 0;

+      }      

+   }

+   return 0; /* silence compiler warning */

+}

+

+

+

+

+

+/**

+ * Examine the active arrays to determine if we have interleaved

+ * vertex arrays all living in one VBO, or all living in user space.

+ * \param userSpace  returns whether the arrays are in user space.

+ */

+static GLboolean

+is_interleaved_arrays(const struct st_vertex_program *vp,

+                      const struct st_vp_variant *vpv,

+                      const struct gl_client_array **arrays)

+{

+   GLuint attr;

+   const struct gl_buffer_object *firstBufObj = NULL;

+   GLint firstStride = -1;

+   const GLubyte *client_addr = NULL;

+   GLboolean user_memory;

+

+   for (attr = 0; attr < vpv->num_inputs; attr++) {

+      const GLuint mesaAttr = vp->index_to_input[attr];

+      const struct gl_buffer_object *bufObj = arrays[mesaAttr]->BufferObj;

+      const GLsizei stride = arrays[mesaAttr]->StrideB; /* in bytes */

+

+      if (firstStride < 0) {

+         firstStride = stride;

+         user_memory = !bufObj || !bufObj->Name;

+      }

+      else if (firstStride != stride) {

+         return GL_FALSE;

+      }

+

+      if (!bufObj || !bufObj->Name) {

+         /* Try to detect if the client-space arrays are

+          * "close" to each other.

+          */

+         if (!user_memory) {

+            return GL_FALSE;

+         }

+         if (!client_addr) {

+            client_addr = arrays[mesaAttr]->Ptr;

+         }

+         else if (abs(arrays[mesaAttr]->Ptr - client_addr) > firstStride) {

+            /* arrays start too far apart */

+            return GL_FALSE;

+         }

+      }

+      else if (!firstBufObj) {

+         if (user_memory) {

+            return GL_FALSE;

+         }

+         firstBufObj = bufObj;

+      }

+      else if (bufObj != firstBufObj) {

+         return GL_FALSE;

+      }

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Set up for drawing interleaved arrays that all live in one VBO

+ * or all live in user space.

+ * \param vbuffer  returns vertex buffer info

+ * \param velements  returns vertex element info

+ */

+static void

+setup_interleaved_attribs(struct gl_context *ctx,

+                          const struct st_vertex_program *vp,

+                          const struct st_vp_variant *vpv,

+                          const struct gl_client_array **arrays,

+                          struct pipe_vertex_buffer *vbuffer,

+                          struct pipe_vertex_element velements[],

+                          unsigned max_index,

+                          unsigned num_instances)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   GLuint attr;

+   const GLubyte *low_addr = NULL;

+

+   /* Find the lowest address. */

+   if(vpv->num_inputs) {

+      low_addr = arrays[vp->index_to_input[0]]->Ptr;

+

+      for (attr = 1; attr < vpv->num_inputs; attr++) {

+         const GLubyte *start = arrays[vp->index_to_input[attr]]->Ptr;

+         low_addr = MIN2(low_addr, start);

+      }

+   }

+

+   for (attr = 0; attr < vpv->num_inputs; attr++) {

+      const GLuint mesaAttr = vp->index_to_input[attr];

+      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;

+      struct st_buffer_object *stobj = st_buffer_object(bufobj);

+      GLsizei stride = arrays[mesaAttr]->StrideB;

+

+      if (attr == 0) {

+         if (bufobj && bufobj->Name) {

+            vbuffer->buffer = NULL;

+            pipe_resource_reference(&vbuffer->buffer, stobj->buffer);

+            vbuffer->buffer_offset = pointer_to_offset(low_addr);

+         } else {

+            uint divisor = arrays[mesaAttr]->InstanceDivisor;

+            uint length = (divisor ? num_instances / divisor : max_index) + 1;

+            vbuffer->buffer =

+               pipe_user_buffer_create(pipe->screen, (void*)low_addr,

+                                       stride * length,

+				       PIPE_BIND_VERTEX_BUFFER);

+            vbuffer->buffer_offset = 0;

+

+            /* Track user vertex buffers. */

+            pipe_resource_reference(&st->user_vb[0], vbuffer->buffer);

+            st->user_vb_stride[0] = stride;

+            st->num_user_vbs = 1;

+         }

+         vbuffer->stride = stride; /* in bytes */

+      }

+

+      velements[attr].src_offset =

+         (unsigned) (arrays[mesaAttr]->Ptr - low_addr);

+      velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;

+      velements[attr].vertex_buffer_index = 0;

+      velements[attr].src_format =

+         st_pipe_vertex_format(arrays[mesaAttr]->Type,

+                               arrays[mesaAttr]->Size,

+                               arrays[mesaAttr]->Format,

+                               arrays[mesaAttr]->Normalized);

+      assert(velements[attr].src_format);

+   }

+}

+

+

+/**

+ * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each

+ * vertex attribute.

+ * \param vbuffer  returns vertex buffer info

+ * \param velements  returns vertex element info

+ */

+static void

+setup_non_interleaved_attribs(struct gl_context *ctx,

+                              const struct st_vertex_program *vp,

+                              const struct st_vp_variant *vpv,

+                              const struct gl_client_array **arrays,

+                              struct pipe_vertex_buffer vbuffer[],

+                              struct pipe_vertex_element velements[],

+                              unsigned max_index,

+                              unsigned num_instances)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   GLuint attr;

+

+   for (attr = 0; attr < vpv->num_inputs; attr++) {

+      const GLuint mesaAttr = vp->index_to_input[attr];

+      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;

+      GLsizei stride = arrays[mesaAttr]->StrideB;

+

+      if (bufobj && bufobj->Name) {

+         /* Attribute data is in a VBO.

+          * Recall that for VBOs, the gl_client_array->Ptr field is

+          * really an offset from the start of the VBO, not a pointer.

+          */

+         struct st_buffer_object *stobj = st_buffer_object(bufobj);

+         assert(stobj->buffer);

+

+         vbuffer[attr].buffer = NULL;

+         pipe_resource_reference(&vbuffer[attr].buffer, stobj->buffer);

+         vbuffer[attr].buffer_offset = pointer_to_offset(arrays[mesaAttr]->Ptr);

+      }

+      else {

+         /* wrap user data */

+         if (arrays[mesaAttr]->Ptr) {

+            uint divisor = arrays[mesaAttr]->InstanceDivisor;

+            uint length = (divisor ? num_instances / divisor : max_index) + 1;

+            vbuffer[attr].buffer =

+	       pipe_user_buffer_create(pipe->screen,

+				       (void *) arrays[mesaAttr]->Ptr,

+				       stride * length,

+				       PIPE_BIND_VERTEX_BUFFER);

+         }

+         else {

+            /* no array, use ctx->Current.Attrib[] value */

+            uint bytes = sizeof(ctx->Current.Attrib[0]);

+            vbuffer[attr].buffer =

+	       pipe_user_buffer_create(pipe->screen,

+				       (void *) ctx->Current.Attrib[mesaAttr],

+				       bytes,

+				       PIPE_BIND_VERTEX_BUFFER);

+            stride = 0;

+         }

+

+         vbuffer[attr].buffer_offset = 0;

+

+         /* Track user vertex buffers. */

+         pipe_resource_reference(&st->user_vb[attr], vbuffer[attr].buffer);

+         st->user_vb_stride[attr] = stride;

+         st->num_user_vbs = MAX2(st->num_user_vbs, attr+1);

+      }

+

+      /* common-case setup */

+      vbuffer[attr].stride = stride; /* in bytes */

+

+      velements[attr].src_offset = 0;

+      velements[attr].instance_divisor = arrays[mesaAttr]->InstanceDivisor;

+      velements[attr].vertex_buffer_index = attr;

+      velements[attr].src_format

+         = st_pipe_vertex_format(arrays[mesaAttr]->Type,

+                                 arrays[mesaAttr]->Size,

+                                 arrays[mesaAttr]->Format,

+                                 arrays[mesaAttr]->Normalized);

+      assert(velements[attr].src_format);

+   }

+}

+

+

+static void

+setup_index_buffer(struct gl_context *ctx,

+                   const struct _mesa_index_buffer *ib,

+                   struct pipe_index_buffer *ibuffer)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+

+   memset(ibuffer, 0, sizeof(*ibuffer));

+   if (ib) {

+      struct gl_buffer_object *bufobj = ib->obj;

+

+      switch (ib->type) {

+      case GL_UNSIGNED_INT:

+         ibuffer->index_size = 4;

+         break;

+      case GL_UNSIGNED_SHORT:

+         ibuffer->index_size = 2;

+         break;

+      case GL_UNSIGNED_BYTE:

+         ibuffer->index_size = 1;

+         break;

+      default:

+         assert(0);

+	 return;

+      }

+

+      /* get/create the index buffer object */

+      if (bufobj && bufobj->Name) {

+         /* elements/indexes are in a real VBO */

+         struct st_buffer_object *stobj = st_buffer_object(bufobj);

+         pipe_resource_reference(&ibuffer->buffer, stobj->buffer);

+         ibuffer->offset = pointer_to_offset(ib->ptr);

+      }

+      else {

+         /* element/indicies are in user space memory */

+         ibuffer->buffer =

+            pipe_user_buffer_create(pipe->screen, (void *) ib->ptr,

+                                    ib->count * ibuffer->index_size,

+                                    PIPE_BIND_INDEX_BUFFER);

+      }

+   }

+}

+

+/**

+ * Prior to drawing, check that any uniforms referenced by the

+ * current shader have been set.  If a uniform has not been set,

+ * issue a warning.

+ */

+static void

+check_uniforms(struct gl_context *ctx)

+{

+   struct gl_shader_program *shProg[3] = {

+      ctx->Shader.CurrentVertexProgram,

+      ctx->Shader.CurrentGeometryProgram,

+      ctx->Shader.CurrentFragmentProgram,

+   };

+   unsigned j;

+

+   for (j = 0; j < 3; j++) {

+      unsigned i;

+

+      if (shProg[j] == NULL || !shProg[j]->LinkStatus)

+	 continue;

+

+      for (i = 0; i < shProg[j]->Uniforms->NumUniforms; i++) {

+         const struct gl_uniform *u = &shProg[j]->Uniforms->Uniforms[i];

+         if (!u->Initialized) {

+            _mesa_warning(ctx,

+                          "Using shader with uninitialized uniform: %s",

+                          u->Name);

+         }

+      }

+   }

+}

+

+

+/**

+ * Translate OpenGL primtive type (GL_POINTS, GL_TRIANGLE_STRIP, etc) to

+ * the corresponding Gallium type.

+ */

+static unsigned

+translate_prim(const struct gl_context *ctx, unsigned prim)

+{

+   /* GL prims should match Gallium prims, spot-check a few */

+   assert(GL_POINTS == PIPE_PRIM_POINTS);

+   assert(GL_QUADS == PIPE_PRIM_QUADS);

+   assert(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);

+

+   /* Avoid quadstrips if it's easy to do so:

+    * Note: it's imporant to do the correct trimming if we change the prim type!

+    * We do that wherever this function is called.

+    */

+   if (prim == GL_QUAD_STRIP &&

+       ctx->Light.ShadeModel != GL_FLAT &&

+       ctx->Polygon.FrontMode == GL_FILL &&

+       ctx->Polygon.BackMode == GL_FILL)

+      prim = GL_TRIANGLE_STRIP;

+

+   return prim;

+}

+

+

+static void

+st_validate_varrays(struct gl_context *ctx,

+                    const struct gl_client_array **arrays,

+                    unsigned max_index,

+                    unsigned num_instances)

+{

+   struct st_context *st = st_context(ctx);

+   const struct st_vertex_program *vp;

+   const struct st_vp_variant *vpv;

+   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];

+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];

+   unsigned num_vbuffers, num_velements;

+   GLuint attr;

+   unsigned i;

+

+   /* must get these after state validation! */

+   vp = st->vp;

+   vpv = st->vp_variant;

+

+   memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);

+

+   /* Unreference any user vertex buffers. */

+   for (i = 0; i < st->num_user_vbs; i++) {

+      pipe_resource_reference(&st->user_vb[i], NULL);

+   }

+   st->num_user_vbs = 0;

+

+   /*

+    * Setup the vbuffer[] and velements[] arrays.

+    */

+   if (is_interleaved_arrays(vp, vpv, arrays)) {

+      setup_interleaved_attribs(ctx, vp, vpv, arrays, vbuffer, velements,

+                                max_index, num_instances);

+

+      num_vbuffers = 1;

+      num_velements = vpv->num_inputs;

+      if (num_velements == 0)

+         num_vbuffers = 0;

+   }

+   else {

+      setup_non_interleaved_attribs(ctx, vp, vpv, arrays,

+                                    vbuffer, velements, max_index, num_instances);

+      num_vbuffers = vpv->num_inputs;

+      num_velements = vpv->num_inputs;

+   }

+

+   cso_set_vertex_buffers(st->cso_context, num_vbuffers, vbuffer);

+   cso_set_vertex_elements(st->cso_context, num_velements, velements);

+

+   /* unreference buffers (frees wrapped user-space buffer objects)

+    * This is OK, because the pipe driver should reference buffers by itself

+    * in set_vertex_buffers. */

+   for (attr = 0; attr < num_vbuffers; attr++) {

+      pipe_resource_reference(&vbuffer[attr].buffer, NULL);

+      assert(!vbuffer[attr].buffer);

+   }

+}

+

+

+/**

+ * This function gets plugged into the VBO module and is called when

+ * we have something to render.

+ * Basically, translate the information into the format expected by gallium.

+ */

+void

+st_draw_vbo(struct gl_context *ctx,

+            const struct gl_client_array **arrays,

+            const struct _mesa_prim *prims,

+            GLuint nr_prims,

+            const struct _mesa_index_buffer *ib,

+	    GLboolean index_bounds_valid,

+            GLuint min_index,

+            GLuint max_index)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_index_buffer ibuffer;

+   struct pipe_draw_info info;

+   unsigned i, num_instances = 1;

+   GLboolean new_array =

+         st->dirty.st && (st->dirty.mesa & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;

+

+   /* Mesa core state should have been validated already */

+   assert(ctx->NewState == 0x0);

+

+   if (ib) {

+      /* Gallium probably doesn't want this in some cases. */

+      if (!index_bounds_valid)

+         if (!vbo_all_varyings_in_vbos(arrays))

+            vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);

+

+      for (i = 0; i < nr_prims; i++) {

+         num_instances = MAX2(num_instances, prims[i].num_instances);

+      }

+   } else {

+      /* Get min/max index for non-indexed drawing. */

+      min_index = ~0;

+      max_index = 0;

+

+      for (i = 0; i < nr_prims; i++) {

+         min_index = MIN2(min_index, prims[i].start);

+         max_index = MAX2(max_index, prims[i].start + prims[i].count - 1);

+         num_instances = MAX2(num_instances, prims[i].num_instances);

+      }

+   }

+

+   /* Validate state. */

+   if (st->dirty.st) {

+      GLboolean vertDataEdgeFlags;

+

+      /* sanity check for pointer arithmetic below */

+      assert(sizeof(arrays[0]->Ptr[0]) == 1);

+

+      vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&

+                          arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;

+      if (vertDataEdgeFlags != st->vertdata_edgeflags) {

+         st->vertdata_edgeflags = vertDataEdgeFlags;

+         st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;

+      }

+

+      st_validate_state(st);

+

+      if (new_array) {

+         st_validate_varrays(ctx, arrays, max_index, num_instances);

+      }

+

+#if 0

+      if (MESA_VERBOSE & VERBOSE_GLSL) {

+         check_uniforms(ctx);

+      }

+#else

+      (void) check_uniforms;

+#endif

+   }

+

+   /* Notify the driver that the content of user buffers may have been

+    * changed. */

+   if (!new_array && st->num_user_vbs) {

+      for (i = 0; i < st->num_user_vbs; i++) {

+         if (st->user_vb[i]) {

+            unsigned stride = st->user_vb_stride[i];

+

+            if (stride) {

+               pipe->redefine_user_buffer(pipe, st->user_vb[i],

+                                          min_index * stride,

+                                          (max_index + 1 - min_index) * stride);

+            } else {

+               /* stride == 0 */

+               pipe->redefine_user_buffer(pipe, st->user_vb[i],

+                                          0, st->user_vb[i]->width0);

+            }

+         }

+      }

+   }

+

+   setup_index_buffer(ctx, ib, &ibuffer);

+   pipe->set_index_buffer(pipe, &ibuffer);

+

+   util_draw_init_info(&info);

+   if (ib) {

+      info.indexed = TRUE;

+      if (min_index != ~0 && max_index != ~0) {

+         info.min_index = min_index;

+         info.max_index = max_index;

+      }

+   }

+

+   info.primitive_restart = st->ctx->Array.PrimitiveRestart;

+   info.restart_index = st->ctx->Array.RestartIndex;

+

+   /* do actual drawing */

+   for (i = 0; i < nr_prims; i++) {

+      info.mode = translate_prim( ctx, prims[i].mode );

+      info.start = prims[i].start;

+      info.count = prims[i].count;

+      info.instance_count = prims[i].num_instances;

+      info.index_bias = prims[i].basevertex;

+      if (!ib) {

+         info.min_index = info.start;

+         info.max_index = info.start + info.count - 1;

+      }

+

+      if (u_trim_pipe_prim(info.mode, &info.count))

+         pipe->draw_vbo(pipe, &info);

+   }

+

+   pipe_resource_reference(&ibuffer.buffer, NULL);

+}

+

+

+void st_init_draw( struct st_context *st )

+{

+   struct gl_context *ctx = st->ctx;

+

+   vbo_set_draw_func(ctx, st_draw_vbo);

+

+#if FEATURE_feedback || FEATURE_rastpos

+   st->draw = draw_create(st->pipe); /* for selection/feedback */

+

+   /* Disable draw options that might convert points/lines to tris, etc.

+    * as that would foul-up feedback/selection mode.

+    */

+   draw_wide_line_threshold(st->draw, 1000.0f);

+   draw_wide_point_threshold(st->draw, 1000.0f);

+   draw_enable_line_stipple(st->draw, FALSE);

+   draw_enable_point_sprites(st->draw, FALSE);

+#endif

+}

+

+

+void st_destroy_draw( struct st_context *st )

+{

+#if FEATURE_feedback || FEATURE_rastpos

+   draw_destroy(st->draw);

+#endif

+}

+

+

diff --git a/mesalib/src/mesa/state_tracker/st_draw_feedback.c b/mesalib/src/mesa/state_tracker/st_draw_feedback.c
index 1e1220bfe..f0734eae0 100644
--- a/mesalib/src/mesa/state_tracker/st_draw_feedback.c
+++ b/mesalib/src/mesa/state_tracker/st_draw_feedback.c
@@ -1,277 +1,277 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-
-#include "vbo/vbo.h"
-
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_cb_bufferobjects.h"
-#include "st_draw.h"
-#include "st_program.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-
-#include "draw/draw_private.h"
-#include "draw/draw_context.h"
-
-
-#if FEATURE_feedback || FEATURE_rastpos
-
-/**
- * Set the (private) draw module's post-transformed vertex format when in
- * GL_SELECT or GL_FEEDBACK mode or for glRasterPos.
- */
-static void
-set_feedback_vertex_format(struct gl_context *ctx)
-{
-#if 0
-   struct st_context *st = st_context(ctx);
-   struct vertex_info vinfo;
-   GLuint i;
-
-   memset(&vinfo, 0, sizeof(vinfo));
-
-   if (ctx->RenderMode == GL_SELECT) {
-      assert(ctx->RenderMode == GL_SELECT);
-      vinfo.num_attribs = 1;
-      vinfo.format[0] = FORMAT_4F;
-      vinfo.interp_mode[0] = INTERP_LINEAR;
-   }
-   else {
-      /* GL_FEEDBACK, or glRasterPos */
-      /* emit all attribs (pos, color, texcoord) as GLfloat[4] */
-      vinfo.num_attribs = st->state.vs->cso->state.num_outputs;
-      for (i = 0; i < vinfo.num_attribs; i++) {
-         vinfo.format[i] = FORMAT_4F;
-         vinfo.interp_mode[i] = INTERP_LINEAR;
-      }
-   }
-
-   draw_set_vertex_info(st->draw, &vinfo);
-#endif
-}
-
-
-/**
- * Called by VBO to draw arrays when in selection or feedback mode and
- * to implement glRasterPos.
- * This is very much like the normal draw_vbo() function above.
- * Look at code refactoring some day.
- * Might move this into the failover module some day.
- */
-void
-st_feedback_draw_vbo(struct gl_context *ctx,
-                     const struct gl_client_array **arrays,
-                     const struct _mesa_prim *prims,
-                     GLuint nr_prims,
-                     const struct _mesa_index_buffer *ib,
-		     GLboolean index_bounds_valid,
-                     GLuint min_index,
-                     GLuint max_index)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct draw_context *draw = st->draw;
-   const struct st_vertex_program *vp;
-   const struct pipe_shader_state *vs;
-   struct pipe_vertex_buffer vbuffers[PIPE_MAX_SHADER_INPUTS];
-   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
-   struct pipe_index_buffer ibuffer;
-   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
-   struct pipe_transfer *ib_transfer = NULL;
-   GLuint attr, i;
-   const void *mapped_indices = NULL;
-
-   assert(draw);
-
-   st_validate_state(st);
-
-   if (!index_bounds_valid)
-      vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);
-
-   /* must get these after state validation! */
-   vp = st->vp;
-   vs = &st->vp_variant->tgsi;
-
-   if (!st->vp_variant->draw_shader) {
-      st->vp_variant->draw_shader = draw_create_vertex_shader(draw, vs);
-   }
-
-   /*
-    * Set up the draw module's state.
-    *
-    * We'd like to do this less frequently, but the normal state-update
-    * code sends state updates to the pipe, not to our private draw module.
-    */
-   assert(draw);
-   draw_set_viewport_state(draw, &st->state.viewport);
-   draw_set_clip_state(draw, &st->state.clip);
-   draw_set_rasterizer_state(draw, &st->state.rasterizer, NULL);
-   draw_bind_vertex_shader(draw, st->vp_variant->draw_shader);
-   set_feedback_vertex_format(ctx);
-
-   /* loop over TGSI shader inputs to determine vertex buffer
-    * and attribute info
-    */
-   for (attr = 0; attr < vp->num_inputs; attr++) {
-      const GLuint mesaAttr = vp->index_to_input[attr];
-      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
-      void *map;
-
-      if (bufobj && bufobj->Name) {
-         /* Attribute data is in a VBO.
-          * Recall that for VBOs, the gl_client_array->Ptr field is
-          * really an offset from the start of the VBO, not a pointer.
-          */
-         struct st_buffer_object *stobj = st_buffer_object(bufobj);
-         assert(stobj->buffer);
-
-         vbuffers[attr].buffer = NULL;
-         pipe_resource_reference(&vbuffers[attr].buffer, stobj->buffer);
-         vbuffers[attr].buffer_offset = pointer_to_offset(arrays[0]->Ptr);
-         velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
-      }
-      else {
-         /* attribute data is in user-space memory, not a VBO */
-         uint bytes = (arrays[mesaAttr]->Size
-                       * _mesa_sizeof_type(arrays[mesaAttr]->Type)
-                       * (max_index + 1));
-
-         /* wrap user data */
-         vbuffers[attr].buffer
-            = pipe_user_buffer_create(pipe->screen, (void *) arrays[mesaAttr]->Ptr,
-                                      bytes,
-				      PIPE_BIND_VERTEX_BUFFER);
-         vbuffers[attr].buffer_offset = 0;
-         velements[attr].src_offset = 0;
-      }
-
-      /* common-case setup */
-      vbuffers[attr].stride = arrays[mesaAttr]->StrideB; /* in bytes */
-      velements[attr].instance_divisor = 0;
-      velements[attr].vertex_buffer_index = attr;
-      velements[attr].src_format = 
-         st_pipe_vertex_format(arrays[mesaAttr]->Type,
-                               arrays[mesaAttr]->Size,
-                               arrays[mesaAttr]->Format,
-                               arrays[mesaAttr]->Normalized);
-      assert(velements[attr].src_format);
-
-      /* tell draw about this attribute */
-#if 0
-      draw_set_vertex_buffer(draw, attr, &vbuffer[attr]);
-#endif
-
-      /* map the attrib buffer */
-      map = pipe_buffer_map(pipe, vbuffers[attr].buffer,
-                            PIPE_TRANSFER_READ,
-			    &vb_transfer[attr]);
-      draw_set_mapped_vertex_buffer(draw, attr, map);
-   }
-
-   draw_set_vertex_buffers(draw, vp->num_inputs, vbuffers);
-   draw_set_vertex_elements(draw, vp->num_inputs, velements);
-
-   memset(&ibuffer, 0, sizeof(ibuffer));
-   if (ib) {
-      struct gl_buffer_object *bufobj = ib->obj;
-
-      switch (ib->type) {
-      case GL_UNSIGNED_INT:
-         ibuffer.index_size = 4;
-         break;
-      case GL_UNSIGNED_SHORT:
-         ibuffer.index_size = 2;
-         break;
-      case GL_UNSIGNED_BYTE:
-         ibuffer.index_size = 1;
-         break;
-      default:
-         assert(0);
-	 goto out_unref_vertex;
-      }
-
-      if (bufobj && bufobj->Name) {
-         struct st_buffer_object *stobj = st_buffer_object(bufobj);
-
-         pipe_resource_reference(&ibuffer.buffer, stobj->buffer);
-         ibuffer.offset = pointer_to_offset(ib->ptr);
-
-         mapped_indices = pipe_buffer_map(pipe, stobj->buffer,
-                                          PIPE_TRANSFER_READ, &ib_transfer);
-      }
-      else {
-         /* skip setting ibuffer.buffer as the draw module does not use it */
-         mapped_indices = ib->ptr;
-      }
-
-      draw_set_index_buffer(draw, &ibuffer);
-      draw_set_mapped_index_buffer(draw, mapped_indices);
-   }
-
-   /* set the constant buffer */
-   draw_set_mapped_constant_buffer(st->draw, PIPE_SHADER_VERTEX, 0,
-                                   st->state.constants[PIPE_SHADER_VERTEX].ptr,
-                                   st->state.constants[PIPE_SHADER_VERTEX].size);
-
-
-   /* draw here */
-   for (i = 0; i < nr_prims; i++) {
-      draw_arrays(draw, prims[i].mode, prims[i].start, prims[i].count);
-   }
-
-
-   /*
-    * unmap vertex/index buffers
-    */
-   if (ib) {
-      draw_set_mapped_index_buffer(draw, NULL);
-      draw_set_index_buffer(draw, NULL);
-
-      if (ib_transfer)
-         pipe_buffer_unmap(pipe, ib_transfer);
-      pipe_resource_reference(&ibuffer.buffer, NULL);
-   }
-
- out_unref_vertex:
-   for (attr = 0; attr < vp->num_inputs; attr++) {
-      pipe_buffer_unmap(pipe, vb_transfer[attr]);
-      draw_set_mapped_vertex_buffer(draw, attr, NULL);
-      pipe_resource_reference(&vbuffers[attr].buffer, NULL);
-   }
-   draw_set_vertex_buffers(draw, 0, NULL);
-}
-
-#endif /* FEATURE_feedback || FEATURE_rastpos */
-
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+

+#include "vbo/vbo.h"

+

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_cb_bufferobjects.h"

+#include "st_draw.h"

+#include "st_program.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+

+#include "draw/draw_private.h"

+#include "draw/draw_context.h"

+

+

+#if FEATURE_feedback || FEATURE_rastpos

+

+/**

+ * Set the (private) draw module's post-transformed vertex format when in

+ * GL_SELECT or GL_FEEDBACK mode or for glRasterPos.

+ */

+static void

+set_feedback_vertex_format(struct gl_context *ctx)

+{

+#if 0

+   struct st_context *st = st_context(ctx);

+   struct vertex_info vinfo;

+   GLuint i;

+

+   memset(&vinfo, 0, sizeof(vinfo));

+

+   if (ctx->RenderMode == GL_SELECT) {

+      assert(ctx->RenderMode == GL_SELECT);

+      vinfo.num_attribs = 1;

+      vinfo.format[0] = FORMAT_4F;

+      vinfo.interp_mode[0] = INTERP_LINEAR;

+   }

+   else {

+      /* GL_FEEDBACK, or glRasterPos */

+      /* emit all attribs (pos, color, texcoord) as GLfloat[4] */

+      vinfo.num_attribs = st->state.vs->cso->state.num_outputs;

+      for (i = 0; i < vinfo.num_attribs; i++) {

+         vinfo.format[i] = FORMAT_4F;

+         vinfo.interp_mode[i] = INTERP_LINEAR;

+      }

+   }

+

+   draw_set_vertex_info(st->draw, &vinfo);

+#endif

+}

+

+

+/**

+ * Called by VBO to draw arrays when in selection or feedback mode and

+ * to implement glRasterPos.

+ * This is very much like the normal draw_vbo() function above.

+ * Look at code refactoring some day.

+ * Might move this into the failover module some day.

+ */

+void

+st_feedback_draw_vbo(struct gl_context *ctx,

+                     const struct gl_client_array **arrays,

+                     const struct _mesa_prim *prims,

+                     GLuint nr_prims,

+                     const struct _mesa_index_buffer *ib,

+		     GLboolean index_bounds_valid,

+                     GLuint min_index,

+                     GLuint max_index)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct draw_context *draw = st->draw;

+   const struct st_vertex_program *vp;

+   const struct pipe_shader_state *vs;

+   struct pipe_vertex_buffer vbuffers[PIPE_MAX_SHADER_INPUTS];

+   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];

+   struct pipe_index_buffer ibuffer;

+   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];

+   struct pipe_transfer *ib_transfer = NULL;

+   GLuint attr, i;

+   const void *mapped_indices = NULL;

+

+   assert(draw);

+

+   st_validate_state(st);

+

+   if (!index_bounds_valid)

+      vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);

+

+   /* must get these after state validation! */

+   vp = st->vp;

+   vs = &st->vp_variant->tgsi;

+

+   if (!st->vp_variant->draw_shader) {

+      st->vp_variant->draw_shader = draw_create_vertex_shader(draw, vs);

+   }

+

+   /*

+    * Set up the draw module's state.

+    *

+    * We'd like to do this less frequently, but the normal state-update

+    * code sends state updates to the pipe, not to our private draw module.

+    */

+   assert(draw);

+   draw_set_viewport_state(draw, &st->state.viewport);

+   draw_set_clip_state(draw, &st->state.clip);

+   draw_set_rasterizer_state(draw, &st->state.rasterizer, NULL);

+   draw_bind_vertex_shader(draw, st->vp_variant->draw_shader);

+   set_feedback_vertex_format(ctx);

+

+   /* loop over TGSI shader inputs to determine vertex buffer

+    * and attribute info

+    */

+   for (attr = 0; attr < vp->num_inputs; attr++) {

+      const GLuint mesaAttr = vp->index_to_input[attr];

+      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;

+      void *map;

+

+      if (bufobj && bufobj->Name) {

+         /* Attribute data is in a VBO.

+          * Recall that for VBOs, the gl_client_array->Ptr field is

+          * really an offset from the start of the VBO, not a pointer.

+          */

+         struct st_buffer_object *stobj = st_buffer_object(bufobj);

+         assert(stobj->buffer);

+

+         vbuffers[attr].buffer = NULL;

+         pipe_resource_reference(&vbuffers[attr].buffer, stobj->buffer);

+         vbuffers[attr].buffer_offset = pointer_to_offset(arrays[0]->Ptr);

+         velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;

+      }

+      else {

+         /* attribute data is in user-space memory, not a VBO */

+         uint bytes = (arrays[mesaAttr]->Size

+                       * _mesa_sizeof_type(arrays[mesaAttr]->Type)

+                       * (max_index + 1));

+

+         /* wrap user data */

+         vbuffers[attr].buffer

+            = pipe_user_buffer_create(pipe->screen, (void *) arrays[mesaAttr]->Ptr,

+                                      bytes,

+				      PIPE_BIND_VERTEX_BUFFER);

+         vbuffers[attr].buffer_offset = 0;

+         velements[attr].src_offset = 0;

+      }

+

+      /* common-case setup */

+      vbuffers[attr].stride = arrays[mesaAttr]->StrideB; /* in bytes */

+      velements[attr].instance_divisor = 0;

+      velements[attr].vertex_buffer_index = attr;

+      velements[attr].src_format = 

+         st_pipe_vertex_format(arrays[mesaAttr]->Type,

+                               arrays[mesaAttr]->Size,

+                               arrays[mesaAttr]->Format,

+                               arrays[mesaAttr]->Normalized);

+      assert(velements[attr].src_format);

+

+      /* tell draw about this attribute */

+#if 0

+      draw_set_vertex_buffer(draw, attr, &vbuffer[attr]);

+#endif

+

+      /* map the attrib buffer */

+      map = pipe_buffer_map(pipe, vbuffers[attr].buffer,

+                            PIPE_TRANSFER_READ,

+			    &vb_transfer[attr]);

+      draw_set_mapped_vertex_buffer(draw, attr, map);

+   }

+

+   draw_set_vertex_buffers(draw, vp->num_inputs, vbuffers);

+   draw_set_vertex_elements(draw, vp->num_inputs, velements);

+

+   memset(&ibuffer, 0, sizeof(ibuffer));

+   if (ib) {

+      struct gl_buffer_object *bufobj = ib->obj;

+

+      switch (ib->type) {

+      case GL_UNSIGNED_INT:

+         ibuffer.index_size = 4;

+         break;

+      case GL_UNSIGNED_SHORT:

+         ibuffer.index_size = 2;

+         break;

+      case GL_UNSIGNED_BYTE:

+         ibuffer.index_size = 1;

+         break;

+      default:

+         assert(0);

+	 goto out_unref_vertex;

+      }

+

+      if (bufobj && bufobj->Name) {

+         struct st_buffer_object *stobj = st_buffer_object(bufobj);

+

+         pipe_resource_reference(&ibuffer.buffer, stobj->buffer);

+         ibuffer.offset = pointer_to_offset(ib->ptr);

+

+         mapped_indices = pipe_buffer_map(pipe, stobj->buffer,

+                                          PIPE_TRANSFER_READ, &ib_transfer);

+      }

+      else {

+         /* skip setting ibuffer.buffer as the draw module does not use it */

+         mapped_indices = ib->ptr;

+      }

+

+      draw_set_index_buffer(draw, &ibuffer);

+      draw_set_mapped_index_buffer(draw, mapped_indices);

+   }

+

+   /* set the constant buffer */

+   draw_set_mapped_constant_buffer(st->draw, PIPE_SHADER_VERTEX, 0,

+                                   st->state.constants[PIPE_SHADER_VERTEX].ptr,

+                                   st->state.constants[PIPE_SHADER_VERTEX].size);

+

+

+   /* draw here */

+   for (i = 0; i < nr_prims; i++) {

+      draw_arrays(draw, prims[i].mode, prims[i].start, prims[i].count);

+   }

+

+

+   /*

+    * unmap vertex/index buffers

+    */

+   if (ib) {

+      draw_set_mapped_index_buffer(draw, NULL);

+      draw_set_index_buffer(draw, NULL);

+

+      if (ib_transfer)

+         pipe_buffer_unmap(pipe, ib_transfer);

+      pipe_resource_reference(&ibuffer.buffer, NULL);

+   }

+

+ out_unref_vertex:

+   for (attr = 0; attr < vp->num_inputs; attr++) {

+      pipe_buffer_unmap(pipe, vb_transfer[attr]);

+      draw_set_mapped_vertex_buffer(draw, attr, NULL);

+      pipe_resource_reference(&vbuffers[attr].buffer, NULL);

+   }

+   draw_set_vertex_buffers(draw, 0, NULL);

+}

+

+#endif /* FEATURE_feedback || FEATURE_rastpos */

+

diff --git a/mesalib/src/mesa/state_tracker/st_extensions.c b/mesalib/src/mesa/state_tracker/st_extensions.c
index aaa1658f4..32cbcaec1 100644
--- a/mesalib/src/mesa/state_tracker/st_extensions.c
+++ b/mesalib/src/mesa/state_tracker/st_extensions.c
@@ -1,525 +1,525 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright (c) 2008 VMware, Inc.
- * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-
-#include "st_context.h"
-#include "st_extensions.h"
-
-
-static int _min(int a, int b)
-{
-   return (a < b) ? a : b;
-}
-
-static float _maxf(float a, float b)
-{
-   return (a > b) ? a : b;
-}
-
-static int _clamp(int a, int min, int max)
-{
-   if (a < min)
-      return min;
-   else if (a > max)
-      return max;
-   else
-      return a;
-}
-
-
-/**
- * Query driver to get implementation limits.
- * Note that we have to limit/clamp against Mesa's internal limits too.
- */
-void st_init_limits(struct st_context *st)
-{
-   struct pipe_screen *screen = st->pipe->screen;
-   struct gl_constants *c = &st->ctx->Const;
-   gl_shader_type sh;
-
-   c->MaxTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
-            MAX_TEXTURE_LEVELS);
-
-   c->Max3DTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
-            MAX_3D_TEXTURE_LEVELS);
-
-   c->MaxCubeTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
-            MAX_CUBE_TEXTURE_LEVELS);
-
-   c->MaxTextureRectSize
-      = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
-
-   c->MaxTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),
-            MAX_TEXTURE_IMAGE_UNITS);
-
-   c->MaxVertexTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS),
-             MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-
-   c->MaxCombinedTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SAMPLERS),
-             MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-
-   c->MaxTextureCoordUnits
-      = _min(c->MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);
-
-   c->MaxTextureUnits = _min(c->MaxTextureImageUnits, c->MaxTextureCoordUnits);
-
-   c->MaxDrawBuffers
-      = _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
-              1, MAX_DRAW_BUFFERS);
-
-   c->MaxLineWidth
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
-   c->MaxLineWidthAA
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
-
-   c->MaxPointSize
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
-   c->MaxPointSizeAA
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
-   /* called after _mesa_create_context/_mesa_init_point, fix default user
-    * settable max point size up
-    */
-   st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA);
-   /* these are not queryable. Note that GL basically mandates a 1.0 minimum
-    * for non-aa sizes, but we can go down to 0.0 for aa points.
-    */
-   c->MinPointSize = 1.0f;
-   c->MinPointSizeAA = 0.0f;
-
-   c->MaxTextureMaxAnisotropy
-      = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
-
-   c->MaxTextureLodBias
-      = screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);
-
-   c->MaxDrawBuffers
-      = CLAMP(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
-              1, MAX_DRAW_BUFFERS);
-
-   /* Quads always follow GL provoking rules. */
-   c->QuadsFollowProvokingVertexConvention = GL_FALSE;
-
-   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) {
-      struct gl_shader_compiler_options *options =
-         &st->ctx->ShaderCompilerOptions[sh];
-      struct gl_program_constants *pc;
-
-      switch (sh) {
-      case PIPE_SHADER_FRAGMENT:
-         pc = &c->FragmentProgram;
-         break;
-      case PIPE_SHADER_VERTEX:
-         pc = &c->VertexProgram;
-         break;
-      case PIPE_SHADER_GEOMETRY:
-         pc = &c->GeometryProgram;
-         break;
-      default:
-         assert(0);
-         continue;
-      }
-
-      pc->MaxNativeInstructions    = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
-      pc->MaxNativeAluInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);
-      pc->MaxNativeTexInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);
-      pc->MaxNativeTexIndirections = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);
-      pc->MaxNativeAttribs         = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);
-      pc->MaxNativeTemps           = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);
-      pc->MaxNativeAddressRegs     = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ADDRS);
-      pc->MaxNativeParameters      = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONSTS);
-      pc->MaxUniformComponents     = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);
-
-      options->EmitNoNoise = TRUE;
-
-      /* TODO: make these more fine-grained if anyone needs it */
-      options->EmitNoIfs = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
-      options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
-      options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
-      options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
-
-      options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);
-
-      options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);
-      options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);
-      options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);
-      options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);
-
-      if(options->EmitNoLoops)
-         options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);
-   }
-
-   /* PIPE_CAP_MAX_FS_INPUTS specifies the number of COLORn + GENERICn inputs
-    * and is set in MaxNativeAttribs. It's always 2 colors + N generic
-    * attributes. The GLSL compiler never uses COLORn for varyings, so we
-    * subtract the 2 colors to get the maximum number of varyings (generic
-    * attributes) supported by a driver. */
-   c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) - 2;
-   c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
-
-   /* XXX we'll need a better query here someday */
-   if (screen->get_param(screen, PIPE_CAP_GLSL)) {
-      c->GLSLVersion = 120;
-   }
-}
-
-
-/**
- * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine
- * which GL extensions are supported.
- * Quite a few extensions are always supported because they are standard
- * features or can be built on top of other gallium features.
- * Some fine tuning may still be needed.
- */
-void st_init_extensions(struct st_context *st)
-{
-   struct pipe_screen *screen = st->pipe->screen;
-   struct gl_context *ctx = st->ctx;
-
-   /*
-    * Extensions that are supported by all Gallium drivers:
-    */
-   ctx->Extensions.ARB_copy_buffer = GL_TRUE;
-   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
-   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
-   ctx->Extensions.ARB_fragment_program = GL_TRUE;
-   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
-   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
-   ctx->Extensions.ARB_multisample = GL_TRUE;
-   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */
-   ctx->Extensions.ARB_texture_compression = GL_TRUE;
-   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;
-   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;
-   ctx->Extensions.ARB_vertex_program = GL_TRUE;
-   ctx->Extensions.ARB_window_pos = GL_TRUE;
-
-   ctx->Extensions.EXT_blend_color = GL_TRUE;
-   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
-   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;
-   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
-   ctx->Extensions.EXT_blend_subtract = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
-   ctx->Extensions.EXT_fog_coord = GL_TRUE;
-   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
-   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;
-   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
-   ctx->Extensions.EXT_point_parameters = GL_TRUE;
-   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
-   ctx->Extensions.EXT_secondary_color = GL_TRUE;
-   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_add = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;
-   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
-   if (ctx->API == API_OPENGLES || ctx->API == API_OPENGLES2)
-	   ctx->Extensions.EXT_texture_format_BGRA8888 = GL_TRUE;
-
-   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;
-
-   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
-
-   ctx->Extensions.MESA_pack_invert = GL_TRUE;
-
-   ctx->Extensions.NV_blend_square = GL_TRUE;
-   ctx->Extensions.NV_texgen_reflection = GL_TRUE;
-   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
-   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
-#if 0
-   /* possibly could support the following two */
-   ctx->Extensions.NV_vertex_program = GL_TRUE;
-   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;
-#endif
-
-#if FEATURE_OES_EGL_image
-   ctx->Extensions.OES_EGL_image = GL_TRUE;
-#endif
-#if FEATURE_OES_draw_texture
-   ctx->Extensions.OES_draw_texture = GL_TRUE;
-#endif
-
-   ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;
-
-   /*
-    * Extensions that depend on the driver/hardware:
-    */
-   if (screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS) > 0) {
-      ctx->Extensions.ARB_draw_buffers = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SWIZZLE) > 0) {
-      ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_GLSL)) {
-      ctx->Extensions.ARB_fragment_shader = GL_TRUE;
-      ctx->Extensions.ARB_vertex_shader = GL_TRUE;
-      ctx->Extensions.ARB_shader_objects = GL_TRUE;
-      ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
-      ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
-      ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_REPEAT) > 0) {
-      ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE)) {
-      ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_CLAMP) > 0) {
-      ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
-      ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
-      ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS) > 1) {
-      ctx->Extensions.ARB_multitexture = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TWO_SIDED_STENCIL)) {
-      ctx->Extensions.ATI_separate_stencil = GL_TRUE;
-      ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_ANISOTROPIC_FILTER)) {
-      ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_POINT_SPRITE)) {
-      ctx->Extensions.ARB_point_sprite = GL_TRUE;
-      /* GL_NV_point_sprite is not supported by gallium because we don't
-       * support the GL_POINT_SPRITE_R_MODE_NV option.
-       */
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY)) {
-      ctx->Extensions.ARB_occlusion_query = GL_TRUE;
-      ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
-   }
-   if (screen->get_param(screen, PIPE_CAP_TIMER_QUERY)) {
-     ctx->Extensions.EXT_timer_query = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SHADOW_MAP)) {
-      ctx->Extensions.ARB_depth_texture = GL_TRUE;
-      ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
-      ctx->Extensions.ARB_shadow = GL_TRUE;
-      ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
-      /*ctx->Extensions.ARB_shadow_ambient = GL_TRUE;*/
-   }
-
-   /* GL_EXT_packed_depth_stencil requires both the ability to render to
-    * a depth/stencil buffer and texture from depth/stencil source.
-    */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_DEPTH_STENCIL, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_DEPTH_STENCIL, 0) &&
-            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
-   }
-
-   /* sRGB support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
-      screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
-      ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_RENDER_TARGET, 0) ||
-          screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_RENDER_TARGET, 0)) {
-         ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;
-         ctx->Const.sRGBCapable = GL_TRUE;
-      }
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.ARB_texture_rg = GL_TRUE;
-   }
-
-   /* s3tc support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       ctx->Mesa_DXTn) {
-      ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
-      ctx->Extensions.S3_s3tc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,
-				   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)
-       ) {
-     ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
-   }
-
-   /* ycbcr support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
-       screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
-   }
-
-   /* GL_EXT_texture_array */
-   if (screen->get_param(screen, PIPE_CAP_ARRAY_TEXTURES)) {
-      ctx->Extensions.EXT_texture_array = GL_TRUE;
-      ctx->Extensions.MESA_texture_array = GL_TRUE;
-   }
-
-   /* GL_ARB_framebuffer_object */
-   if (ctx->Extensions.EXT_packed_depth_stencil) {
-      /* we support always support GL_EXT_framebuffer_blit */
-      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
-   }
-
-   if (st->pipe->render_condition) {
-      ctx->Extensions.NV_conditional_render = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE)) {
-      ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC)) {
-      ctx->Extensions.ARB_draw_buffers_blend = GL_TRUE;
-   }
-
-   /* GL_ARB_half_float_vertex */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,
-                                   PIPE_BUFFER, 0,
-                                   PIPE_BIND_VERTEX_BUFFER, 0)) {
-      ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
-   }
-
-   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
-#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */
-      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
-#endif
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {
-      ctx->Extensions.NV_primitive_restart = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_DEPTH_CLAMP)) {
-      ctx->Extensions.ARB_depth_clamp = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT)) {
-      ctx->Extensions.ARB_shader_stencil_export = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {
-      ctx->Extensions.ARB_draw_instanced = GL_TRUE;
-   }
-   if (screen->get_param(screen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR)) {
-      ctx->Extensions.ARB_instanced_arrays = GL_TRUE;
-   }
-
-   if (screen->fence_finish) {
-      ctx->Extensions.ARB_sync = GL_TRUE;
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright (c) 2008 VMware, Inc.

+ * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+

+#include "st_context.h"

+#include "st_extensions.h"

+

+

+static int _min(int a, int b)

+{

+   return (a < b) ? a : b;

+}

+

+static float _maxf(float a, float b)

+{

+   return (a > b) ? a : b;

+}

+

+static int _clamp(int a, int min, int max)

+{

+   if (a < min)

+      return min;

+   else if (a > max)

+      return max;

+   else

+      return a;

+}

+

+

+/**

+ * Query driver to get implementation limits.

+ * Note that we have to limit/clamp against Mesa's internal limits too.

+ */

+void st_init_limits(struct st_context *st)

+{

+   struct pipe_screen *screen = st->pipe->screen;

+   struct gl_constants *c = &st->ctx->Const;

+   gl_shader_type sh;

+

+   c->MaxTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),

+            MAX_TEXTURE_LEVELS);

+

+   c->Max3DTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),

+            MAX_3D_TEXTURE_LEVELS);

+

+   c->MaxCubeTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),

+            MAX_CUBE_TEXTURE_LEVELS);

+

+   c->MaxTextureRectSize

+      = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);

+

+   c->MaxTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),

+            MAX_TEXTURE_IMAGE_UNITS);

+

+   c->MaxVertexTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS),

+             MAX_VERTEX_TEXTURE_IMAGE_UNITS);

+

+   c->MaxCombinedTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SAMPLERS),

+             MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+

+   c->MaxTextureCoordUnits

+      = _min(c->MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);

+

+   c->MaxTextureUnits = _min(c->MaxTextureImageUnits, c->MaxTextureCoordUnits);

+

+   c->MaxDrawBuffers

+      = _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),

+              1, MAX_DRAW_BUFFERS);

+

+   c->MaxLineWidth

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));

+   c->MaxLineWidthAA

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));

+

+   c->MaxPointSize

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));

+   c->MaxPointSizeAA

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));

+   /* called after _mesa_create_context/_mesa_init_point, fix default user

+    * settable max point size up

+    */

+   st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA);

+   /* these are not queryable. Note that GL basically mandates a 1.0 minimum

+    * for non-aa sizes, but we can go down to 0.0 for aa points.

+    */

+   c->MinPointSize = 1.0f;

+   c->MinPointSizeAA = 0.0f;

+

+   c->MaxTextureMaxAnisotropy

+      = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));

+

+   c->MaxTextureLodBias

+      = screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);

+

+   c->MaxDrawBuffers

+      = CLAMP(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),

+              1, MAX_DRAW_BUFFERS);

+

+   /* Quads always follow GL provoking rules. */

+   c->QuadsFollowProvokingVertexConvention = GL_FALSE;

+

+   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) {

+      struct gl_shader_compiler_options *options =

+         &st->ctx->ShaderCompilerOptions[sh];

+      struct gl_program_constants *pc;

+

+      switch (sh) {

+      case PIPE_SHADER_FRAGMENT:

+         pc = &c->FragmentProgram;

+         break;

+      case PIPE_SHADER_VERTEX:

+         pc = &c->VertexProgram;

+         break;

+      case PIPE_SHADER_GEOMETRY:

+         pc = &c->GeometryProgram;

+         break;

+      default:

+         assert(0);

+         continue;

+      }

+

+      pc->MaxNativeInstructions    = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);

+      pc->MaxNativeAluInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);

+      pc->MaxNativeTexInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);

+      pc->MaxNativeTexIndirections = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);

+      pc->MaxNativeAttribs         = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);

+      pc->MaxNativeTemps           = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);

+      pc->MaxNativeAddressRegs     = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ADDRS);

+      pc->MaxNativeParameters      = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONSTS);

+      pc->MaxUniformComponents     = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);

+

+      options->EmitNoNoise = TRUE;

+

+      /* TODO: make these more fine-grained if anyone needs it */

+      options->EmitNoIfs = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);

+      options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);

+      options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);

+      options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);

+

+      options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);

+

+      options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);

+      options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);

+      options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);

+      options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);

+

+      if(options->EmitNoLoops)

+         options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);

+   }

+

+   /* PIPE_CAP_MAX_FS_INPUTS specifies the number of COLORn + GENERICn inputs

+    * and is set in MaxNativeAttribs. It's always 2 colors + N generic

+    * attributes. The GLSL compiler never uses COLORn for varyings, so we

+    * subtract the 2 colors to get the maximum number of varyings (generic

+    * attributes) supported by a driver. */

+   c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) - 2;

+   c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);

+

+   /* XXX we'll need a better query here someday */

+   if (screen->get_param(screen, PIPE_CAP_GLSL)) {

+      c->GLSLVersion = 120;

+   }

+}

+

+

+/**

+ * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine

+ * which GL extensions are supported.

+ * Quite a few extensions are always supported because they are standard

+ * features or can be built on top of other gallium features.

+ * Some fine tuning may still be needed.

+ */

+void st_init_extensions(struct st_context *st)

+{

+   struct pipe_screen *screen = st->pipe->screen;

+   struct gl_context *ctx = st->ctx;

+

+   /*

+    * Extensions that are supported by all Gallium drivers:

+    */

+   ctx->Extensions.ARB_copy_buffer = GL_TRUE;

+   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;

+   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;

+   ctx->Extensions.ARB_fragment_program = GL_TRUE;

+   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;

+   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;

+   ctx->Extensions.ARB_multisample = GL_TRUE;

+   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */

+   ctx->Extensions.ARB_texture_compression = GL_TRUE;

+   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;

+   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;

+   ctx->Extensions.ARB_vertex_program = GL_TRUE;

+   ctx->Extensions.ARB_window_pos = GL_TRUE;

+

+   ctx->Extensions.EXT_blend_color = GL_TRUE;

+   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;

+   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;

+   ctx->Extensions.EXT_blend_minmax = GL_TRUE;

+   ctx->Extensions.EXT_blend_subtract = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;

+   ctx->Extensions.EXT_fog_coord = GL_TRUE;

+   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;

+   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;

+   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;

+   ctx->Extensions.EXT_point_parameters = GL_TRUE;

+   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;

+   ctx->Extensions.EXT_secondary_color = GL_TRUE;

+   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_add = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;

+   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;

+   if (ctx->API == API_OPENGLES || ctx->API == API_OPENGLES2)

+	   ctx->Extensions.EXT_texture_format_BGRA8888 = GL_TRUE;

+

+   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;

+

+   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;

+

+   ctx->Extensions.MESA_pack_invert = GL_TRUE;

+

+   ctx->Extensions.NV_blend_square = GL_TRUE;

+   ctx->Extensions.NV_texgen_reflection = GL_TRUE;

+   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;

+   ctx->Extensions.NV_texture_rectangle = GL_TRUE;

+#if 0

+   /* possibly could support the following two */

+   ctx->Extensions.NV_vertex_program = GL_TRUE;

+   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;

+#endif

+

+#if FEATURE_OES_EGL_image

+   ctx->Extensions.OES_EGL_image = GL_TRUE;

+#endif

+#if FEATURE_OES_draw_texture

+   ctx->Extensions.OES_draw_texture = GL_TRUE;

+#endif

+

+   ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;

+

+   /*

+    * Extensions that depend on the driver/hardware:

+    */

+   if (screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS) > 0) {

+      ctx->Extensions.ARB_draw_buffers = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SWIZZLE) > 0) {

+      ctx->Extensions.EXT_texture_swizzle = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_GLSL)) {

+      ctx->Extensions.ARB_fragment_shader = GL_TRUE;

+      ctx->Extensions.ARB_vertex_shader = GL_TRUE;

+      ctx->Extensions.ARB_shader_objects = GL_TRUE;

+      ctx->Extensions.ARB_shading_language_100 = GL_TRUE;

+      ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;

+      ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_REPEAT) > 0) {

+      ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE)) {

+      ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_CLAMP) > 0) {

+      ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;

+      ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {

+      ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS) > 1) {

+      ctx->Extensions.ARB_multitexture = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TWO_SIDED_STENCIL)) {

+      ctx->Extensions.ATI_separate_stencil = GL_TRUE;

+      ctx->Extensions.EXT_stencil_two_side = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_ANISOTROPIC_FILTER)) {

+      ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_POINT_SPRITE)) {

+      ctx->Extensions.ARB_point_sprite = GL_TRUE;

+      /* GL_NV_point_sprite is not supported by gallium because we don't

+       * support the GL_POINT_SPRITE_R_MODE_NV option.

+       */

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY)) {

+      ctx->Extensions.ARB_occlusion_query = GL_TRUE;

+      ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;

+   }

+   if (screen->get_param(screen, PIPE_CAP_TIMER_QUERY)) {

+     ctx->Extensions.EXT_timer_query = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SHADOW_MAP)) {

+      ctx->Extensions.ARB_depth_texture = GL_TRUE;

+      ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;

+      ctx->Extensions.ARB_shadow = GL_TRUE;

+      ctx->Extensions.EXT_shadow_funcs = GL_TRUE;

+      /*ctx->Extensions.ARB_shadow_ambient = GL_TRUE;*/

+   }

+

+   /* GL_EXT_packed_depth_stencil requires both the ability to render to

+    * a depth/stencil buffer and texture from depth/stencil source.

+    */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_DEPTH_STENCIL, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_DEPTH_STENCIL, 0) &&

+            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

+   }

+

+   /* sRGB support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) ||

+      screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.EXT_texture_sRGB = GL_TRUE;

+      ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_RENDER_TARGET, 0) ||

+          screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_RENDER_TARGET, 0)) {

+         ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;

+         ctx->Const.sRGBCapable = GL_TRUE;

+      }

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.ARB_texture_rg = GL_TRUE;

+   }

+

+   /* s3tc support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       ctx->Mesa_DXTn) {

+      ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;

+      ctx->Extensions.S3_s3tc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,

+				   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)

+       ) {

+     ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;

+   }

+

+   /* ycbcr support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0) ||

+       screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {

+      ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;

+   }

+

+   /* GL_EXT_texture_array */

+   if (screen->get_param(screen, PIPE_CAP_ARRAY_TEXTURES)) {

+      ctx->Extensions.EXT_texture_array = GL_TRUE;

+      ctx->Extensions.MESA_texture_array = GL_TRUE;

+   }

+

+   /* GL_ARB_framebuffer_object */

+   if (ctx->Extensions.EXT_packed_depth_stencil) {

+      /* we support always support GL_EXT_framebuffer_blit */

+      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;

+   }

+

+   if (st->pipe->render_condition) {

+      ctx->Extensions.NV_conditional_render = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE)) {

+      ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC)) {

+      ctx->Extensions.ARB_draw_buffers_blend = GL_TRUE;

+   }

+

+   /* GL_ARB_half_float_vertex */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,

+                                   PIPE_BUFFER, 0,

+                                   PIPE_BIND_VERTEX_BUFFER, 0)) {

+      ctx->Extensions.ARB_half_float_vertex = GL_TRUE;

+   }

+

+   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {

+#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */

+      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;

+#endif

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {

+      ctx->Extensions.NV_primitive_restart = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_DEPTH_CLAMP)) {

+      ctx->Extensions.ARB_depth_clamp = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT)) {

+      ctx->Extensions.ARB_shader_stencil_export = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {

+      ctx->Extensions.ARB_draw_instanced = GL_TRUE;

+   }

+   if (screen->get_param(screen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR)) {

+      ctx->Extensions.ARB_instanced_arrays = GL_TRUE;

+   }

+

+   if (screen->fence_finish) {

+      ctx->Extensions.ARB_sync = GL_TRUE;

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_format.c b/mesalib/src/mesa/state_tracker/st_format.c
index 6b89bae7d..5ac4b9f25 100644
--- a/mesalib/src/mesa/state_tracker/st_format.c
+++ b/mesalib/src/mesa/state_tracker/st_format.c
@@ -1,1222 +1,1222 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright (c) 2008-2010 VMware, Inc.
- * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-/**
- * Mesa / Gallium format conversion and format selection code.
- * \author Brian Paul
- */
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/texstore.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "util/u_format.h"
-#include "st_context.h"
-#include "st_format.h"
-
-
-static GLuint
-format_max_bits(enum pipe_format format)
-{
-   GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);
-
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));
-   return size;
-}
-
-
-/**
- * Return basic GL datatype for the given gallium format.
- */
-GLenum
-st_format_datatype(enum pipe_format format)
-{
-   const struct util_format_description *desc;
-
-   desc = util_format_description(format);
-   assert(desc);
-
-   if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {
-      if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||
-          format == PIPE_FORMAT_B5G6R5_UNORM) {
-         return GL_UNSIGNED_SHORT;
-      }
-      else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
-               format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
-               format == PIPE_FORMAT_Z24X8_UNORM ||
-               format == PIPE_FORMAT_X8Z24_UNORM) {
-         return GL_UNSIGNED_INT_24_8;
-      }
-      else {
-         const GLuint size = format_max_bits(format);
-         if (size == 8) {
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_BYTE;
-            else
-               return GL_BYTE;
-         }
-         else if (size == 16) {
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_SHORT;
-            else
-               return GL_SHORT;
-         }
-         else {
-            assert( size <= 32 );
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_INT;
-            else
-               return GL_INT;
-         }
-      }
-   }
-   else if (format == PIPE_FORMAT_UYVY) {
-      return GL_UNSIGNED_SHORT;
-   }
-   else if (format == PIPE_FORMAT_YUYV) {
-      return GL_UNSIGNED_SHORT;
-   }
-   else {
-      /* probably a compressed format, unsupported anyway */
-      return GL_NONE;
-   }
-}
-
-
-/**
- * Translate Mesa format to Gallium format.
- */
-enum pipe_format
-st_mesa_format_to_pipe_format(gl_format mesaFormat)
-{
-   switch (mesaFormat) {
-   case MESA_FORMAT_RGBA8888:
-      return PIPE_FORMAT_A8B8G8R8_UNORM;
-   case MESA_FORMAT_RGBA8888_REV:
-      return PIPE_FORMAT_R8G8B8A8_UNORM;
-   case MESA_FORMAT_ARGB8888:
-      return PIPE_FORMAT_B8G8R8A8_UNORM;
-   case MESA_FORMAT_ARGB8888_REV:
-      return PIPE_FORMAT_A8R8G8B8_UNORM;
-   case MESA_FORMAT_XRGB8888:
-      return PIPE_FORMAT_B8G8R8X8_UNORM;
-   case MESA_FORMAT_XRGB8888_REV:
-      return PIPE_FORMAT_X8R8G8B8_UNORM;
-   case MESA_FORMAT_ARGB1555:
-      return PIPE_FORMAT_B5G5R5A1_UNORM;
-   case MESA_FORMAT_ARGB4444:
-      return PIPE_FORMAT_B4G4R4A4_UNORM;
-   case MESA_FORMAT_RGB565:
-      return PIPE_FORMAT_B5G6R5_UNORM;
-   case MESA_FORMAT_RGB332:
-      return PIPE_FORMAT_B2G3R3_UNORM;
-   case MESA_FORMAT_ARGB2101010:
-      return PIPE_FORMAT_B10G10R10A2_UNORM;
-   case MESA_FORMAT_AL44:
-      return PIPE_FORMAT_L4A4_UNORM;
-   case MESA_FORMAT_AL88:
-      return PIPE_FORMAT_L8A8_UNORM;
-   case MESA_FORMAT_AL1616:
-      return PIPE_FORMAT_L16A16_UNORM;
-   case MESA_FORMAT_A8:
-      return PIPE_FORMAT_A8_UNORM;
-   case MESA_FORMAT_A16:
-      return PIPE_FORMAT_A16_UNORM;
-   case MESA_FORMAT_L8:
-      return PIPE_FORMAT_L8_UNORM;
-   case MESA_FORMAT_L16:
-      return PIPE_FORMAT_L16_UNORM;
-   case MESA_FORMAT_I8:
-      return PIPE_FORMAT_I8_UNORM;
-   case MESA_FORMAT_I16:
-      return PIPE_FORMAT_I16_UNORM;
-   case MESA_FORMAT_Z16:
-      return PIPE_FORMAT_Z16_UNORM;
-   case MESA_FORMAT_Z32:
-      return PIPE_FORMAT_Z32_UNORM;
-   case MESA_FORMAT_Z24_S8:
-      return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-   case MESA_FORMAT_S8_Z24:
-      return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-   case MESA_FORMAT_Z24_X8:
-      return PIPE_FORMAT_X8Z24_UNORM;
-   case MESA_FORMAT_X8_Z24:
-      return PIPE_FORMAT_Z24X8_UNORM;
-   case MESA_FORMAT_S8:
-      return PIPE_FORMAT_S8_USCALED;
-   case MESA_FORMAT_YCBCR:
-      return PIPE_FORMAT_UYVY;
-#if FEATURE_texture_s3tc
-   case MESA_FORMAT_RGB_DXT1:
-      return PIPE_FORMAT_DXT1_RGB;
-   case MESA_FORMAT_RGBA_DXT1:
-      return PIPE_FORMAT_DXT1_RGBA;
-   case MESA_FORMAT_RGBA_DXT3:
-      return PIPE_FORMAT_DXT3_RGBA;
-   case MESA_FORMAT_RGBA_DXT5:
-      return PIPE_FORMAT_DXT5_RGBA;
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB_DXT1:
-      return PIPE_FORMAT_DXT1_SRGB;
-   case MESA_FORMAT_SRGBA_DXT1:
-      return PIPE_FORMAT_DXT1_SRGBA;
-   case MESA_FORMAT_SRGBA_DXT3:
-      return PIPE_FORMAT_DXT3_SRGBA;
-   case MESA_FORMAT_SRGBA_DXT5:
-      return PIPE_FORMAT_DXT5_SRGBA;
-#endif
-#endif
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SLA8:
-      return PIPE_FORMAT_L8A8_SRGB;
-   case MESA_FORMAT_SL8:
-      return PIPE_FORMAT_L8_SRGB;
-   case MESA_FORMAT_SRGB8:
-      return PIPE_FORMAT_R8G8B8_SRGB;
-   case MESA_FORMAT_SRGBA8:
-      return PIPE_FORMAT_A8B8G8R8_SRGB;
-   case MESA_FORMAT_SARGB8:
-      return PIPE_FORMAT_B8G8R8A8_SRGB;
-#endif
-   case MESA_FORMAT_R8:
-      return PIPE_FORMAT_R8_UNORM;
-   case MESA_FORMAT_R16:
-      return PIPE_FORMAT_R16_UNORM;
-   case MESA_FORMAT_RG88:
-      return PIPE_FORMAT_R8G8_UNORM;
-   case MESA_FORMAT_RG1616:
-      return PIPE_FORMAT_R16G16_UNORM;
-   case MESA_FORMAT_RGBA_16:
-      return PIPE_FORMAT_R16G16B16A16_UNORM;
-
-   /* signed int formats */
-   case MESA_FORMAT_RGBA_INT8:
-      return PIPE_FORMAT_R8G8B8A8_SSCALED;
-   case MESA_FORMAT_RGBA_INT16:
-      return PIPE_FORMAT_R16G16B16A16_SSCALED;
-   case MESA_FORMAT_RGBA_INT32:
-      return PIPE_FORMAT_R32G32B32A32_SSCALED;
-
-   /* unsigned int formats */
-   case MESA_FORMAT_RGBA_UINT8:
-      return PIPE_FORMAT_R8G8B8A8_USCALED;
-   case MESA_FORMAT_RGBA_UINT16:
-      return PIPE_FORMAT_R16G16B16A16_USCALED;
-   case MESA_FORMAT_RGBA_UINT32:
-      return PIPE_FORMAT_R32G32B32A32_USCALED;
-
-   case MESA_FORMAT_RED_RGTC1:
-      return PIPE_FORMAT_RGTC1_UNORM;
-   case MESA_FORMAT_SIGNED_RED_RGTC1:
-      return PIPE_FORMAT_RGTC1_SNORM;
-   case MESA_FORMAT_RG_RGTC2:
-      return PIPE_FORMAT_RGTC2_UNORM;
-   case MESA_FORMAT_SIGNED_RG_RGTC2:
-      return PIPE_FORMAT_RGTC2_SNORM;
-
-   case MESA_FORMAT_L_LATC1:
-      return PIPE_FORMAT_LATC1_UNORM;
-   case MESA_FORMAT_SIGNED_L_LATC1:
-      return PIPE_FORMAT_LATC1_SNORM;
-   case MESA_FORMAT_LA_LATC2:
-      return PIPE_FORMAT_LATC2_UNORM;
-   case MESA_FORMAT_SIGNED_LA_LATC2:
-      return PIPE_FORMAT_LATC2_SNORM;
-
-   default:
-      assert(0);
-      return PIPE_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Translate Gallium format to Mesa format.
- */
-gl_format
-st_pipe_format_to_mesa_format(enum pipe_format format)
-{
-   switch (format) {
-   case PIPE_FORMAT_A8B8G8R8_UNORM:
-      return MESA_FORMAT_RGBA8888;
-   case PIPE_FORMAT_R8G8B8A8_UNORM:
-      return MESA_FORMAT_RGBA8888_REV;
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-      return MESA_FORMAT_ARGB8888;
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-      return MESA_FORMAT_ARGB8888_REV;
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-      return MESA_FORMAT_XRGB8888;
-   case PIPE_FORMAT_X8R8G8B8_UNORM:
-      return MESA_FORMAT_XRGB8888_REV;
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-      return MESA_FORMAT_ARGB1555;
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-      return MESA_FORMAT_ARGB4444;
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      return MESA_FORMAT_RGB565;
-   case PIPE_FORMAT_B2G3R3_UNORM:
-      return MESA_FORMAT_RGB332;
-   case PIPE_FORMAT_B10G10R10A2_UNORM:
-      return MESA_FORMAT_ARGB2101010;
-   case PIPE_FORMAT_L4A4_UNORM:
-      return MESA_FORMAT_AL44;
-   case PIPE_FORMAT_L8A8_UNORM:
-      return MESA_FORMAT_AL88;
-   case PIPE_FORMAT_L16A16_UNORM:
-      return MESA_FORMAT_AL1616;
-   case PIPE_FORMAT_A8_UNORM:
-      return MESA_FORMAT_A8;
-   case PIPE_FORMAT_A16_UNORM:
-      return MESA_FORMAT_A16;
-   case PIPE_FORMAT_L8_UNORM:
-      return MESA_FORMAT_L8;
-   case PIPE_FORMAT_L16_UNORM:
-      return MESA_FORMAT_L16;
-   case PIPE_FORMAT_I8_UNORM:
-      return MESA_FORMAT_I8;
-   case PIPE_FORMAT_I16_UNORM:
-      return MESA_FORMAT_I16;
-   case PIPE_FORMAT_S8_USCALED:
-      return MESA_FORMAT_S8;
-
-   case PIPE_FORMAT_R16G16B16A16_UNORM:
-      return MESA_FORMAT_RGBA_16;
-   case PIPE_FORMAT_R16G16B16A16_SNORM:
-      return MESA_FORMAT_SIGNED_RGBA_16;
-
-   case PIPE_FORMAT_Z16_UNORM:
-      return MESA_FORMAT_Z16;
-   case PIPE_FORMAT_Z32_UNORM:
-      return MESA_FORMAT_Z32;
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-      return MESA_FORMAT_Z24_S8;
-   case PIPE_FORMAT_X8Z24_UNORM:
-      return MESA_FORMAT_Z24_X8;
-   case PIPE_FORMAT_Z24X8_UNORM:
-      return MESA_FORMAT_X8_Z24;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-      return MESA_FORMAT_S8_Z24;
-
-   case PIPE_FORMAT_UYVY:
-      return MESA_FORMAT_YCBCR;
-   case PIPE_FORMAT_YUYV:
-      return MESA_FORMAT_YCBCR_REV;
-
-#if FEATURE_texture_s3tc
-   case PIPE_FORMAT_DXT1_RGB:
-      return MESA_FORMAT_RGB_DXT1;
-   case PIPE_FORMAT_DXT1_RGBA:
-      return MESA_FORMAT_RGBA_DXT1;
-   case PIPE_FORMAT_DXT3_RGBA:
-      return MESA_FORMAT_RGBA_DXT3;
-   case PIPE_FORMAT_DXT5_RGBA:
-      return MESA_FORMAT_RGBA_DXT5;
-#if FEATURE_EXT_texture_sRGB
-   case PIPE_FORMAT_DXT1_SRGB:
-      return MESA_FORMAT_SRGB_DXT1;
-   case PIPE_FORMAT_DXT1_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT1;
-   case PIPE_FORMAT_DXT3_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT3;
-   case PIPE_FORMAT_DXT5_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT5;
-#endif
-#endif
-
-#if FEATURE_EXT_texture_sRGB
-   case PIPE_FORMAT_L8A8_SRGB:
-      return MESA_FORMAT_SLA8;
-   case PIPE_FORMAT_L8_SRGB:
-      return MESA_FORMAT_SL8;
-   case PIPE_FORMAT_R8G8B8_SRGB:
-      return MESA_FORMAT_SRGB8;
-   case PIPE_FORMAT_A8B8G8R8_SRGB:
-      return MESA_FORMAT_SRGBA8;
-   case PIPE_FORMAT_B8G8R8A8_SRGB:
-      return MESA_FORMAT_SARGB8;
-#endif
-
-   case PIPE_FORMAT_R8_UNORM:
-      return MESA_FORMAT_R8;
-   case PIPE_FORMAT_R16_UNORM:
-      return MESA_FORMAT_R16;
-   case PIPE_FORMAT_R8G8_UNORM:
-      return MESA_FORMAT_RG88;
-   case PIPE_FORMAT_R16G16_UNORM:
-      return MESA_FORMAT_RG1616;
-
-   /* signed int formats */
-   case PIPE_FORMAT_R8G8B8A8_SSCALED:
-      return MESA_FORMAT_RGBA_INT8;
-   case PIPE_FORMAT_R16G16B16A16_SSCALED:
-      return MESA_FORMAT_RGBA_INT16;
-   case PIPE_FORMAT_R32G32B32A32_SSCALED:
-      return MESA_FORMAT_RGBA_INT32;
-
-   /* unsigned int formats */
-   case PIPE_FORMAT_R8G8B8A8_USCALED:
-      return MESA_FORMAT_RGBA_UINT8;
-   case PIPE_FORMAT_R16G16B16A16_USCALED:
-      return MESA_FORMAT_RGBA_UINT16;
-   case PIPE_FORMAT_R32G32B32A32_USCALED:
-      return MESA_FORMAT_RGBA_UINT32;
-
-   case PIPE_FORMAT_RGTC1_UNORM:
-      return MESA_FORMAT_RED_RGTC1;
-   case PIPE_FORMAT_RGTC1_SNORM:
-      return MESA_FORMAT_SIGNED_RED_RGTC1;
-   case PIPE_FORMAT_RGTC2_UNORM:
-      return MESA_FORMAT_RG_RGTC2;
-   case PIPE_FORMAT_RGTC2_SNORM:
-      return MESA_FORMAT_SIGNED_RG_RGTC2;
-
-   case PIPE_FORMAT_LATC1_UNORM:
-      return MESA_FORMAT_L_LATC1;
-   case PIPE_FORMAT_LATC1_SNORM:
-      return MESA_FORMAT_SIGNED_L_LATC1;
-   case PIPE_FORMAT_LATC2_UNORM:
-      return MESA_FORMAT_LA_LATC2;
-   case PIPE_FORMAT_LATC2_SNORM:
-      return MESA_FORMAT_SIGNED_LA_LATC2;
-
-   default:
-      assert(0);
-      return MESA_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Return first supported format from the given list.
- */
-static enum pipe_format
-find_supported_format(struct pipe_screen *screen, 
-                      const enum pipe_format formats[],
-                      uint num_formats,
-                      enum pipe_texture_target target,
-                      unsigned sample_count,
-                      unsigned tex_usage,
-                      unsigned geom_flags)
-{
-   uint i;
-   for (i = 0; i < num_formats; i++) {
-      if (screen->is_format_supported(screen, formats[i], target,
-                                      sample_count, tex_usage, geom_flags)) {
-         return formats[i];
-      }
-   }
-   return PIPE_FORMAT_NONE;
-}
-
-
-/**
- * Find an RGBA format supported by the context/winsys.
- */
-static enum pipe_format
-default_rgba_format(struct pipe_screen *screen, 
-                    enum pipe_texture_target target,
-                    unsigned sample_count,
-                    unsigned tex_usage,
-                    unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8A8_UNORM,
-      PIPE_FORMAT_A8R8G8B8_UNORM,
-      PIPE_FORMAT_A8B8G8R8_UNORM,
-      PIPE_FORMAT_B5G6R5_UNORM
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-
-/**
- * Find an RGB format supported by the context/winsys.
- */
-static enum pipe_format
-default_rgb_format(struct pipe_screen *screen, 
-                   enum pipe_texture_target target,
-                   unsigned sample_count,
-                   unsigned tex_usage,
-                   unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8X8_UNORM,
-      PIPE_FORMAT_X8R8G8B8_UNORM,
-      PIPE_FORMAT_X8B8G8R8_UNORM,
-      PIPE_FORMAT_B8G8R8A8_UNORM,
-      PIPE_FORMAT_A8R8G8B8_UNORM,
-      PIPE_FORMAT_A8B8G8R8_UNORM,
-      PIPE_FORMAT_B5G6R5_UNORM
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-/**
- * Find an sRGBA format supported by the context/winsys.
- */
-static enum pipe_format
-default_srgba_format(struct pipe_screen *screen, 
-                    enum pipe_texture_target target,
-                    unsigned sample_count,
-                    unsigned tex_usage,
-                    unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8A8_SRGB,
-      PIPE_FORMAT_A8R8G8B8_SRGB,
-      PIPE_FORMAT_A8B8G8R8_SRGB,
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-
-/**
- * Given an OpenGL internalFormat value for a texture or surface, return
- * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
- * This is called during glTexImage2D, for example.
- *
- * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
- * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
- * we want render-to-texture ability.
- *
- * \param internalFormat  the user value passed to glTexImage2D
- * \param target  one of PIPE_TEXTURE_x
- * \param bindings  bitmask of PIPE_BIND_x flags.
- */
-enum pipe_format
-st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
-                 enum pipe_texture_target target, unsigned sample_count,
-                 unsigned bindings)
-{
-   unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */
-
-   switch (internalFormat) {
-   case GL_RGB10:
-   case GL_RGB10_A2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B10G10R10A2_UNORM;
-      /* Pass through. */
-   case 4:
-   case GL_RGBA:
-   case GL_RGBA8:
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_BGRA:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B8G8R8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case 3:
-   case GL_RGB:
-   case GL_RGB8:
-      return default_rgb_format( screen, target, sample_count, bindings,
-                                 geom_flags );
-
-   case GL_RGB12:
-   case GL_RGB16:
-   case GL_RGBA12:
-   case GL_RGBA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
-                                             target, sample_count, bindings,
-                                             geom_flags ))
-         return PIPE_FORMAT_R16G16B16A16_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_RGBA4:
-   case GL_RGBA2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B4G4R4A4_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_RGB5_A1:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G5R5A1_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_R3_G3_B2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B2G3R3_UNORM;
-      /* Pass through. */
-   case GL_RGB5:
-   case GL_RGB4:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G6R5_UNORM;
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G5R5A1_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_ALPHA12:
-   case GL_ALPHA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_A16_UNORM;
-      /* Pass through. */
-   case GL_ALPHA:
-   case GL_ALPHA4:
-   case GL_ALPHA8:
-   case GL_COMPRESSED_ALPHA:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE12:
-   case GL_LUMINANCE16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L16_UNORM;
-      /* Pass through. */
-   case 1:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE4:
-   case GL_LUMINANCE8:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE12_ALPHA4:
-   case GL_LUMINANCE12_ALPHA12:
-   case GL_LUMINANCE16_ALPHA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L16A16_UNORM;
-      /* Pass through. */
-   case 2:
-   case GL_LUMINANCE_ALPHA:
-   case GL_LUMINANCE6_ALPHA2:
-   case GL_LUMINANCE8_ALPHA8:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE4_ALPHA4:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L4A4_UNORM;
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_INTENSITY12:
-   case GL_INTENSITY16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_I16_UNORM;
-      /* Pass through. */
-   case GL_INTENSITY:
-   case GL_INTENSITY4:
-   case GL_INTENSITY8:
-   case GL_COMPRESSED_INTENSITY:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_I8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_YCBCR_MESA:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
-                                      sample_count, bindings, geom_flags)) {
-         return PIPE_FORMAT_UYVY;
-      }
-      if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
-                                      sample_count, bindings, geom_flags)) {
-         return PIPE_FORMAT_YUYV;
-      }
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGB:
-      /* can only sample from compressed formats */
-      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
-         return PIPE_FORMAT_NONE;
-      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
-                                           target, sample_count, bindings,
-                                           geom_flags))
-         return PIPE_FORMAT_DXT1_RGB;
-      else
-         return default_rgb_format(screen, target, sample_count, bindings,
-                                   geom_flags);
-
-   case GL_COMPRESSED_RGBA:
-      /* can only sample from compressed formats */
-      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
-         return PIPE_FORMAT_NONE;
-      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
-                                           target, sample_count, bindings,
-                                           geom_flags))
-         return PIPE_FORMAT_DXT3_RGBA;
-      else
-         return default_rgba_format(screen, target, sample_count, bindings,
-                                    geom_flags);
-
-   case GL_RGB_S3TC:
-   case GL_RGB4_S3TC:
-   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT1_RGB;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT1_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_RGBA_S3TC:
-   case GL_RGBA4_S3TC:
-   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT3_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT5_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-#if 0
-   case GL_COMPRESSED_RGB_FXT1_3DFX:
-      return PIPE_FORMAT_RGB_FXT1;
-   case GL_COMPRESSED_RGBA_FXT1_3DFX:
-      return PIPE_FORMAT_RGB_FXT1;
-#endif
-
-   case GL_DEPTH_COMPONENT16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z16_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT24:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                      target, sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                      target, sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT32:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z32_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_Z32_UNORM,
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-            PIPE_FORMAT_Z16_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_STENCIL_INDEX:
-   case GL_STENCIL_INDEX1_EXT:
-   case GL_STENCIL_INDEX4_EXT:
-   case GL_STENCIL_INDEX8_EXT:
-   case GL_STENCIL_INDEX16_EXT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_S8_USCALED,
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_DEPTH_STENCIL_EXT:
-   case GL_DEPTH24_STENCIL8_EXT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_SRGB_EXT:
-   case GL_SRGB8_EXT:
-   case GL_SRGB_ALPHA_EXT:
-   case GL_SRGB8_ALPHA8_EXT:
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_EXT:
-   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_DXT1_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      return PIPE_FORMAT_DXT1_SRGBA;
-
-   case GL_COMPRESSED_SRGB_ALPHA_EXT:
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_DXT3_SRGBA;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      return PIPE_FORMAT_DXT5_SRGBA;
-
-   case GL_SLUMINANCE_ALPHA_EXT:
-   case GL_SLUMINANCE8_ALPHA8_EXT:
-   case GL_COMPRESSED_SLUMINANCE_EXT:
-   case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_L8A8_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_SLUMINANCE_EXT:
-   case GL_SLUMINANCE8_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_L8_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_RED:
-   case GL_R8:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8_UNORM;
-      return PIPE_FORMAT_NONE;
-   case GL_RG:
-   case GL_RG8:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8G8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_R16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R16_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RG16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R16G16_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RED:
-   case GL_COMPRESSED_RED_RGTC1:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC1_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_RED_RGTC1:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC1_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RG:
-   case GL_COMPRESSED_RG_RGTC2:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC2_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8G8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_RG_RGTC2:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC2_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_LUMINANCE:
-   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC1_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_L8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC1_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_LUMINANCE_ALPHA:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC2_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_L8A8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC2_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   /* signed/unsigned integer formats.
-    * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
-    * If/when new formats are added this code should be updated.
-    */
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      /* fall-through */
-   case GL_RGBA8I_EXT:
-   case GL_RGB8I_EXT:
-   case GL_ALPHA8I_EXT:
-   case GL_INTENSITY8I_EXT:
-   case GL_LUMINANCE8I_EXT:
-   case GL_LUMINANCE_ALPHA8I_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R8G8B8A8_SSCALED;
-      return PIPE_FORMAT_NONE;
-   case GL_RGBA16I_EXT:
-   case GL_RGB16I_EXT:
-   case GL_ALPHA16I_EXT:
-   case GL_INTENSITY16I_EXT:
-   case GL_LUMINANCE16I_EXT:
-   case GL_LUMINANCE_ALPHA16I_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R16G16B16A16_SSCALED;
-      return PIPE_FORMAT_NONE;
-   case GL_RGBA32I_EXT:
-   case GL_RGB32I_EXT:
-   case GL_ALPHA32I_EXT:
-   case GL_INTENSITY32I_EXT:
-   case GL_LUMINANCE32I_EXT:
-   case GL_LUMINANCE_ALPHA32I_EXT:
-      /* xxx */
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R32G32B32A32_SSCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA8UI_EXT:
-   case GL_RGB8UI_EXT:
-   case GL_ALPHA8UI_EXT:
-   case GL_INTENSITY8UI_EXT:
-   case GL_LUMINANCE8UI_EXT:
-   case GL_LUMINANCE_ALPHA8UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R8G8B8A8_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA16UI_EXT:
-   case GL_RGB16UI_EXT:
-   case GL_ALPHA16UI_EXT:
-   case GL_INTENSITY16UI_EXT:
-   case GL_LUMINANCE16UI_EXT:
-   case GL_LUMINANCE_ALPHA16UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R16G16B16A16_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA32UI_EXT:
-   case GL_RGB32UI_EXT:
-   case GL_ALPHA32UI_EXT:
-   case GL_INTENSITY32UI_EXT:
-   case GL_LUMINANCE32UI_EXT:
-   case GL_LUMINANCE_ALPHA32UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R32G32B32A32_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   default:
-      return PIPE_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
- */
-enum pipe_format
-st_choose_renderbuffer_format(struct pipe_screen *screen,
-                              GLenum internalFormat, unsigned sample_count)
-{
-   uint usage;
-   if (_mesa_is_depth_or_stencil_format(internalFormat))
-      usage = PIPE_BIND_DEPTH_STENCIL;
-   else
-      usage = PIPE_BIND_RENDER_TARGET;
-   return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
-                           sample_count, usage);
-}
-
-
-/**
- * Called via ctx->Driver.chooseTextureFormat().
- */
-gl_format
-st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
-				  GLenum format, GLenum type, GLboolean renderable)
-{
-   struct pipe_screen *screen = st_context(ctx)->pipe->screen;
-   enum pipe_format pFormat;
-   uint bindings;
-
-   (void) format;
-   (void) type;
-
-   /* GL textures may wind up being render targets, but we don't know
-    * that in advance.  Specify potential render target flags now.
-    */
-   bindings = PIPE_BIND_SAMPLER_VIEW;
-   if (renderable == GL_TRUE) {
-      if (_mesa_is_depth_format(internalFormat) ||
-	  _mesa_is_depth_or_stencil_format(internalFormat))
-	 bindings |= PIPE_BIND_DEPTH_STENCIL;
-      else 
-	 bindings |= PIPE_BIND_RENDER_TARGET;
-   }
-
-   pFormat = st_choose_format(screen, internalFormat,
-                              PIPE_TEXTURE_2D, 0, bindings);
-
-   if (pFormat == PIPE_FORMAT_NONE) {
-      /* try choosing format again, this time without render target bindings */
-      pFormat = st_choose_format(screen, internalFormat,
-                                 PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
-   }
-
-   if (pFormat == PIPE_FORMAT_NONE) {
-      /* no luck at all */
-      return MESA_FORMAT_NONE;
-   }
-
-   return st_pipe_format_to_mesa_format(pFormat);
-}
-
-gl_format
-st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
-                       GLenum format, GLenum type)
-{
-   boolean want_renderable =
-      internalFormat == 3 || internalFormat == 4 ||
-      internalFormat == GL_RGB || internalFormat == GL_RGBA ||
-      internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
-      internalFormat == GL_BGRA;
-
-   return st_ChooseTextureFormat_renderable(ctx, internalFormat,
-					    format, type, want_renderable);
-}
-
-/**
- * Test if a gallium format is equivalent to a GL format/type.
- */
-GLboolean
-st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
-{
-   switch (pFormat) {
-   case PIPE_FORMAT_A8B8G8R8_UNORM:
-      return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-      return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
-   /* XXX more combos... */
-   default:
-      return GL_FALSE;
-   }
-}
-
-GLboolean
-st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
-{
-   if (format1 == format2)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
-       format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
-       format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
-       format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
-       format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
-       format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
-       format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-
-/**
- * This is used for translating texture border color and the clear
- * color.  For example, the clear color is interpreted according to
- * the renderbuffer's base format.  For example, if clearing a
- * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =
- * alpha.  Similarly for texture border colors.
- */
-void
-st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
-                   GLfloat colorOut[4])
-{
-   switch (baseFormat) {
-   case GL_RED:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = 0.0F;
-      colorOut[2] = 0.0F;
-      colorOut[3] = 1.0F;
-      break;
-   case GL_RG:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = colorIn[1];
-      colorOut[2] = 0.0F;
-      colorOut[3] = 1.0F;
-      break;
-   case GL_RGB:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = colorIn[1];
-      colorOut[2] = colorIn[2];
-      colorOut[3] = 1.0F;
-      break;
-   case GL_ALPHA:
-      colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
-      colorOut[3] = colorIn[3];
-      break;
-   case GL_LUMINANCE:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
-      colorOut[3] = 1.0;
-      break;
-   case GL_LUMINANCE_ALPHA:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
-      colorOut[3] = colorIn[3];
-      break;
-   case GL_INTENSITY:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
-      break;
-   default:
-      COPY_4V(colorOut, colorIn);
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright (c) 2008-2010 VMware, Inc.

+ * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * Mesa / Gallium format conversion and format selection code.

+ * \author Brian Paul

+ */

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/texstore.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "util/u_format.h"

+#include "st_context.h"

+#include "st_format.h"

+

+

+static GLuint

+format_max_bits(enum pipe_format format)

+{

+   GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);

+

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));

+   return size;

+}

+

+

+/**

+ * Return basic GL datatype for the given gallium format.

+ */

+GLenum

+st_format_datatype(enum pipe_format format)

+{

+   const struct util_format_description *desc;

+

+   desc = util_format_description(format);

+   assert(desc);

+

+   if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {

+      if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||

+          format == PIPE_FORMAT_B5G6R5_UNORM) {

+         return GL_UNSIGNED_SHORT;

+      }

+      else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||

+               format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||

+               format == PIPE_FORMAT_Z24X8_UNORM ||

+               format == PIPE_FORMAT_X8Z24_UNORM) {

+         return GL_UNSIGNED_INT_24_8;

+      }

+      else {

+         const GLuint size = format_max_bits(format);

+         if (size == 8) {

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_BYTE;

+            else

+               return GL_BYTE;

+         }

+         else if (size == 16) {

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_SHORT;

+            else

+               return GL_SHORT;

+         }

+         else {

+            assert( size <= 32 );

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_INT;

+            else

+               return GL_INT;

+         }

+      }

+   }

+   else if (format == PIPE_FORMAT_UYVY) {

+      return GL_UNSIGNED_SHORT;

+   }

+   else if (format == PIPE_FORMAT_YUYV) {

+      return GL_UNSIGNED_SHORT;

+   }

+   else {

+      /* probably a compressed format, unsupported anyway */

+      return GL_NONE;

+   }

+}

+

+

+/**

+ * Translate Mesa format to Gallium format.

+ */

+enum pipe_format

+st_mesa_format_to_pipe_format(gl_format mesaFormat)

+{

+   switch (mesaFormat) {

+   case MESA_FORMAT_RGBA8888:

+      return PIPE_FORMAT_A8B8G8R8_UNORM;

+   case MESA_FORMAT_RGBA8888_REV:

+      return PIPE_FORMAT_R8G8B8A8_UNORM;

+   case MESA_FORMAT_ARGB8888:

+      return PIPE_FORMAT_B8G8R8A8_UNORM;

+   case MESA_FORMAT_ARGB8888_REV:

+      return PIPE_FORMAT_A8R8G8B8_UNORM;

+   case MESA_FORMAT_XRGB8888:

+      return PIPE_FORMAT_B8G8R8X8_UNORM;

+   case MESA_FORMAT_XRGB8888_REV:

+      return PIPE_FORMAT_X8R8G8B8_UNORM;

+   case MESA_FORMAT_ARGB1555:

+      return PIPE_FORMAT_B5G5R5A1_UNORM;

+   case MESA_FORMAT_ARGB4444:

+      return PIPE_FORMAT_B4G4R4A4_UNORM;

+   case MESA_FORMAT_RGB565:

+      return PIPE_FORMAT_B5G6R5_UNORM;

+   case MESA_FORMAT_RGB332:

+      return PIPE_FORMAT_B2G3R3_UNORM;

+   case MESA_FORMAT_ARGB2101010:

+      return PIPE_FORMAT_B10G10R10A2_UNORM;

+   case MESA_FORMAT_AL44:

+      return PIPE_FORMAT_L4A4_UNORM;

+   case MESA_FORMAT_AL88:

+      return PIPE_FORMAT_L8A8_UNORM;

+   case MESA_FORMAT_AL1616:

+      return PIPE_FORMAT_L16A16_UNORM;

+   case MESA_FORMAT_A8:

+      return PIPE_FORMAT_A8_UNORM;

+   case MESA_FORMAT_A16:

+      return PIPE_FORMAT_A16_UNORM;

+   case MESA_FORMAT_L8:

+      return PIPE_FORMAT_L8_UNORM;

+   case MESA_FORMAT_L16:

+      return PIPE_FORMAT_L16_UNORM;

+   case MESA_FORMAT_I8:

+      return PIPE_FORMAT_I8_UNORM;

+   case MESA_FORMAT_I16:

+      return PIPE_FORMAT_I16_UNORM;

+   case MESA_FORMAT_Z16:

+      return PIPE_FORMAT_Z16_UNORM;

+   case MESA_FORMAT_Z32:

+      return PIPE_FORMAT_Z32_UNORM;

+   case MESA_FORMAT_Z24_S8:

+      return PIPE_FORMAT_S8_USCALED_Z24_UNORM;

+   case MESA_FORMAT_S8_Z24:

+      return PIPE_FORMAT_Z24_UNORM_S8_USCALED;

+   case MESA_FORMAT_Z24_X8:

+      return PIPE_FORMAT_X8Z24_UNORM;

+   case MESA_FORMAT_X8_Z24:

+      return PIPE_FORMAT_Z24X8_UNORM;

+   case MESA_FORMAT_S8:

+      return PIPE_FORMAT_S8_USCALED;

+   case MESA_FORMAT_YCBCR:

+      return PIPE_FORMAT_UYVY;

+#if FEATURE_texture_s3tc

+   case MESA_FORMAT_RGB_DXT1:

+      return PIPE_FORMAT_DXT1_RGB;

+   case MESA_FORMAT_RGBA_DXT1:

+      return PIPE_FORMAT_DXT1_RGBA;

+   case MESA_FORMAT_RGBA_DXT3:

+      return PIPE_FORMAT_DXT3_RGBA;

+   case MESA_FORMAT_RGBA_DXT5:

+      return PIPE_FORMAT_DXT5_RGBA;

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SRGB_DXT1:

+      return PIPE_FORMAT_DXT1_SRGB;

+   case MESA_FORMAT_SRGBA_DXT1:

+      return PIPE_FORMAT_DXT1_SRGBA;

+   case MESA_FORMAT_SRGBA_DXT3:

+      return PIPE_FORMAT_DXT3_SRGBA;

+   case MESA_FORMAT_SRGBA_DXT5:

+      return PIPE_FORMAT_DXT5_SRGBA;

+#endif

+#endif

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SLA8:

+      return PIPE_FORMAT_L8A8_SRGB;

+   case MESA_FORMAT_SL8:

+      return PIPE_FORMAT_L8_SRGB;

+   case MESA_FORMAT_SRGB8:

+      return PIPE_FORMAT_R8G8B8_SRGB;

+   case MESA_FORMAT_SRGBA8:

+      return PIPE_FORMAT_A8B8G8R8_SRGB;

+   case MESA_FORMAT_SARGB8:

+      return PIPE_FORMAT_B8G8R8A8_SRGB;

+#endif

+   case MESA_FORMAT_R8:

+      return PIPE_FORMAT_R8_UNORM;

+   case MESA_FORMAT_R16:

+      return PIPE_FORMAT_R16_UNORM;

+   case MESA_FORMAT_RG88:

+      return PIPE_FORMAT_R8G8_UNORM;

+   case MESA_FORMAT_RG1616:

+      return PIPE_FORMAT_R16G16_UNORM;

+   case MESA_FORMAT_RGBA_16:

+      return PIPE_FORMAT_R16G16B16A16_UNORM;

+

+   /* signed int formats */

+   case MESA_FORMAT_RGBA_INT8:

+      return PIPE_FORMAT_R8G8B8A8_SSCALED;

+   case MESA_FORMAT_RGBA_INT16:

+      return PIPE_FORMAT_R16G16B16A16_SSCALED;

+   case MESA_FORMAT_RGBA_INT32:

+      return PIPE_FORMAT_R32G32B32A32_SSCALED;

+

+   /* unsigned int formats */

+   case MESA_FORMAT_RGBA_UINT8:

+      return PIPE_FORMAT_R8G8B8A8_USCALED;

+   case MESA_FORMAT_RGBA_UINT16:

+      return PIPE_FORMAT_R16G16B16A16_USCALED;

+   case MESA_FORMAT_RGBA_UINT32:

+      return PIPE_FORMAT_R32G32B32A32_USCALED;

+

+   case MESA_FORMAT_RED_RGTC1:

+      return PIPE_FORMAT_RGTC1_UNORM;

+   case MESA_FORMAT_SIGNED_RED_RGTC1:

+      return PIPE_FORMAT_RGTC1_SNORM;

+   case MESA_FORMAT_RG_RGTC2:

+      return PIPE_FORMAT_RGTC2_UNORM;

+   case MESA_FORMAT_SIGNED_RG_RGTC2:

+      return PIPE_FORMAT_RGTC2_SNORM;

+

+   case MESA_FORMAT_L_LATC1:

+      return PIPE_FORMAT_LATC1_UNORM;

+   case MESA_FORMAT_SIGNED_L_LATC1:

+      return PIPE_FORMAT_LATC1_SNORM;

+   case MESA_FORMAT_LA_LATC2:

+      return PIPE_FORMAT_LATC2_UNORM;

+   case MESA_FORMAT_SIGNED_LA_LATC2:

+      return PIPE_FORMAT_LATC2_SNORM;

+

+   default:

+      assert(0);

+      return PIPE_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Translate Gallium format to Mesa format.

+ */

+gl_format

+st_pipe_format_to_mesa_format(enum pipe_format format)

+{

+   switch (format) {

+   case PIPE_FORMAT_A8B8G8R8_UNORM:

+      return MESA_FORMAT_RGBA8888;

+   case PIPE_FORMAT_R8G8B8A8_UNORM:

+      return MESA_FORMAT_RGBA8888_REV;

+   case PIPE_FORMAT_B8G8R8A8_UNORM:

+      return MESA_FORMAT_ARGB8888;

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+      return MESA_FORMAT_ARGB8888_REV;

+   case PIPE_FORMAT_B8G8R8X8_UNORM:

+      return MESA_FORMAT_XRGB8888;

+   case PIPE_FORMAT_X8R8G8B8_UNORM:

+      return MESA_FORMAT_XRGB8888_REV;

+   case PIPE_FORMAT_B5G5R5A1_UNORM:

+      return MESA_FORMAT_ARGB1555;

+   case PIPE_FORMAT_B4G4R4A4_UNORM:

+      return MESA_FORMAT_ARGB4444;

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      return MESA_FORMAT_RGB565;

+   case PIPE_FORMAT_B2G3R3_UNORM:

+      return MESA_FORMAT_RGB332;

+   case PIPE_FORMAT_B10G10R10A2_UNORM:

+      return MESA_FORMAT_ARGB2101010;

+   case PIPE_FORMAT_L4A4_UNORM:

+      return MESA_FORMAT_AL44;

+   case PIPE_FORMAT_L8A8_UNORM:

+      return MESA_FORMAT_AL88;

+   case PIPE_FORMAT_L16A16_UNORM:

+      return MESA_FORMAT_AL1616;

+   case PIPE_FORMAT_A8_UNORM:

+      return MESA_FORMAT_A8;

+   case PIPE_FORMAT_A16_UNORM:

+      return MESA_FORMAT_A16;

+   case PIPE_FORMAT_L8_UNORM:

+      return MESA_FORMAT_L8;

+   case PIPE_FORMAT_L16_UNORM:

+      return MESA_FORMAT_L16;

+   case PIPE_FORMAT_I8_UNORM:

+      return MESA_FORMAT_I8;

+   case PIPE_FORMAT_I16_UNORM:

+      return MESA_FORMAT_I16;

+   case PIPE_FORMAT_S8_USCALED:

+      return MESA_FORMAT_S8;

+

+   case PIPE_FORMAT_R16G16B16A16_UNORM:

+      return MESA_FORMAT_RGBA_16;

+   case PIPE_FORMAT_R16G16B16A16_SNORM:

+      return MESA_FORMAT_SIGNED_RGBA_16;

+

+   case PIPE_FORMAT_Z16_UNORM:

+      return MESA_FORMAT_Z16;

+   case PIPE_FORMAT_Z32_UNORM:

+      return MESA_FORMAT_Z32;

+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+      return MESA_FORMAT_Z24_S8;

+   case PIPE_FORMAT_X8Z24_UNORM:

+      return MESA_FORMAT_Z24_X8;

+   case PIPE_FORMAT_Z24X8_UNORM:

+      return MESA_FORMAT_X8_Z24;

+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+      return MESA_FORMAT_S8_Z24;

+

+   case PIPE_FORMAT_UYVY:

+      return MESA_FORMAT_YCBCR;

+   case PIPE_FORMAT_YUYV:

+      return MESA_FORMAT_YCBCR_REV;

+

+#if FEATURE_texture_s3tc

+   case PIPE_FORMAT_DXT1_RGB:

+      return MESA_FORMAT_RGB_DXT1;

+   case PIPE_FORMAT_DXT1_RGBA:

+      return MESA_FORMAT_RGBA_DXT1;

+   case PIPE_FORMAT_DXT3_RGBA:

+      return MESA_FORMAT_RGBA_DXT3;

+   case PIPE_FORMAT_DXT5_RGBA:

+      return MESA_FORMAT_RGBA_DXT5;

+#if FEATURE_EXT_texture_sRGB

+   case PIPE_FORMAT_DXT1_SRGB:

+      return MESA_FORMAT_SRGB_DXT1;

+   case PIPE_FORMAT_DXT1_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT1;

+   case PIPE_FORMAT_DXT3_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT3;

+   case PIPE_FORMAT_DXT5_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT5;

+#endif

+#endif

+

+#if FEATURE_EXT_texture_sRGB

+   case PIPE_FORMAT_L8A8_SRGB:

+      return MESA_FORMAT_SLA8;

+   case PIPE_FORMAT_L8_SRGB:

+      return MESA_FORMAT_SL8;

+   case PIPE_FORMAT_R8G8B8_SRGB:

+      return MESA_FORMAT_SRGB8;

+   case PIPE_FORMAT_A8B8G8R8_SRGB:

+      return MESA_FORMAT_SRGBA8;

+   case PIPE_FORMAT_B8G8R8A8_SRGB:

+      return MESA_FORMAT_SARGB8;

+#endif

+

+   case PIPE_FORMAT_R8_UNORM:

+      return MESA_FORMAT_R8;

+   case PIPE_FORMAT_R16_UNORM:

+      return MESA_FORMAT_R16;

+   case PIPE_FORMAT_R8G8_UNORM:

+      return MESA_FORMAT_RG88;

+   case PIPE_FORMAT_R16G16_UNORM:

+      return MESA_FORMAT_RG1616;

+

+   /* signed int formats */

+   case PIPE_FORMAT_R8G8B8A8_SSCALED:

+      return MESA_FORMAT_RGBA_INT8;

+   case PIPE_FORMAT_R16G16B16A16_SSCALED:

+      return MESA_FORMAT_RGBA_INT16;

+   case PIPE_FORMAT_R32G32B32A32_SSCALED:

+      return MESA_FORMAT_RGBA_INT32;

+

+   /* unsigned int formats */

+   case PIPE_FORMAT_R8G8B8A8_USCALED:

+      return MESA_FORMAT_RGBA_UINT8;

+   case PIPE_FORMAT_R16G16B16A16_USCALED:

+      return MESA_FORMAT_RGBA_UINT16;

+   case PIPE_FORMAT_R32G32B32A32_USCALED:

+      return MESA_FORMAT_RGBA_UINT32;

+

+   case PIPE_FORMAT_RGTC1_UNORM:

+      return MESA_FORMAT_RED_RGTC1;

+   case PIPE_FORMAT_RGTC1_SNORM:

+      return MESA_FORMAT_SIGNED_RED_RGTC1;

+   case PIPE_FORMAT_RGTC2_UNORM:

+      return MESA_FORMAT_RG_RGTC2;

+   case PIPE_FORMAT_RGTC2_SNORM:

+      return MESA_FORMAT_SIGNED_RG_RGTC2;

+

+   case PIPE_FORMAT_LATC1_UNORM:

+      return MESA_FORMAT_L_LATC1;

+   case PIPE_FORMAT_LATC1_SNORM:

+      return MESA_FORMAT_SIGNED_L_LATC1;

+   case PIPE_FORMAT_LATC2_UNORM:

+      return MESA_FORMAT_LA_LATC2;

+   case PIPE_FORMAT_LATC2_SNORM:

+      return MESA_FORMAT_SIGNED_LA_LATC2;

+

+   default:

+      assert(0);

+      return MESA_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Return first supported format from the given list.

+ */

+static enum pipe_format

+find_supported_format(struct pipe_screen *screen, 

+                      const enum pipe_format formats[],

+                      uint num_formats,

+                      enum pipe_texture_target target,

+                      unsigned sample_count,

+                      unsigned tex_usage,

+                      unsigned geom_flags)

+{

+   uint i;

+   for (i = 0; i < num_formats; i++) {

+      if (screen->is_format_supported(screen, formats[i], target,

+                                      sample_count, tex_usage, geom_flags)) {

+         return formats[i];

+      }

+   }

+   return PIPE_FORMAT_NONE;

+}

+

+

+/**

+ * Find an RGBA format supported by the context/winsys.

+ */

+static enum pipe_format

+default_rgba_format(struct pipe_screen *screen, 

+                    enum pipe_texture_target target,

+                    unsigned sample_count,

+                    unsigned tex_usage,

+                    unsigned geom_flags)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8A8_UNORM,

+      PIPE_FORMAT_A8R8G8B8_UNORM,

+      PIPE_FORMAT_A8B8G8R8_UNORM,

+      PIPE_FORMAT_B5G6R5_UNORM

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage, geom_flags);

+}

+

+

+/**

+ * Find an RGB format supported by the context/winsys.

+ */

+static enum pipe_format

+default_rgb_format(struct pipe_screen *screen, 

+                   enum pipe_texture_target target,

+                   unsigned sample_count,

+                   unsigned tex_usage,

+                   unsigned geom_flags)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8X8_UNORM,

+      PIPE_FORMAT_X8R8G8B8_UNORM,

+      PIPE_FORMAT_X8B8G8R8_UNORM,

+      PIPE_FORMAT_B8G8R8A8_UNORM,

+      PIPE_FORMAT_A8R8G8B8_UNORM,

+      PIPE_FORMAT_A8B8G8R8_UNORM,

+      PIPE_FORMAT_B5G6R5_UNORM

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage, geom_flags);

+}

+

+/**

+ * Find an sRGBA format supported by the context/winsys.

+ */

+static enum pipe_format

+default_srgba_format(struct pipe_screen *screen, 

+                    enum pipe_texture_target target,

+                    unsigned sample_count,

+                    unsigned tex_usage,

+                    unsigned geom_flags)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8A8_SRGB,

+      PIPE_FORMAT_A8R8G8B8_SRGB,

+      PIPE_FORMAT_A8B8G8R8_SRGB,

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage, geom_flags);

+}

+

+

+/**

+ * Given an OpenGL internalFormat value for a texture or surface, return

+ * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.

+ * This is called during glTexImage2D, for example.

+ *

+ * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus

+ * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if

+ * we want render-to-texture ability.

+ *

+ * \param internalFormat  the user value passed to glTexImage2D

+ * \param target  one of PIPE_TEXTURE_x

+ * \param bindings  bitmask of PIPE_BIND_x flags.

+ */

+enum pipe_format

+st_choose_format(struct pipe_screen *screen, GLenum internalFormat,

+                 enum pipe_texture_target target, unsigned sample_count,

+                 unsigned bindings)

+{

+   unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */

+

+   switch (internalFormat) {

+   case GL_RGB10:

+   case GL_RGB10_A2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B10G10R10A2_UNORM;

+      /* Pass through. */

+   case 4:

+   case GL_RGBA:

+   case GL_RGBA8:

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_BGRA:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B8G8R8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case 3:

+   case GL_RGB:

+   case GL_RGB8:

+      return default_rgb_format( screen, target, sample_count, bindings,

+                                 geom_flags );

+

+   case GL_RGB12:

+   case GL_RGB16:

+   case GL_RGBA12:

+   case GL_RGBA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,

+                                             target, sample_count, bindings,

+                                             geom_flags ))

+         return PIPE_FORMAT_R16G16B16A16_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_RGBA4:

+   case GL_RGBA2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B4G4R4A4_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_RGB5_A1:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B5G5R5A1_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_R3_G3_B2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B2G3R3_UNORM;

+      /* Pass through. */

+   case GL_RGB5:

+   case GL_RGB4:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B5G6R5_UNORM;

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,

+                                       target, sample_count, bindings,

+                                       geom_flags ))

+         return PIPE_FORMAT_B5G5R5A1_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_ALPHA12:

+   case GL_ALPHA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_A16_UNORM;

+      /* Pass through. */

+   case GL_ALPHA:

+   case GL_ALPHA4:

+   case GL_ALPHA8:

+   case GL_COMPRESSED_ALPHA:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_LUMINANCE12:

+   case GL_LUMINANCE16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L16_UNORM;

+      /* Pass through. */

+   case 1:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE4:

+   case GL_LUMINANCE8:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_LUMINANCE12_ALPHA4:

+   case GL_LUMINANCE12_ALPHA12:

+   case GL_LUMINANCE16_ALPHA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L16A16_UNORM;

+      /* Pass through. */

+   case 2:

+   case GL_LUMINANCE_ALPHA:

+   case GL_LUMINANCE6_ALPHA2:

+   case GL_LUMINANCE8_ALPHA8:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_LUMINANCE4_ALPHA4:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L4A4_UNORM;

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_L8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_INTENSITY12:

+   case GL_INTENSITY16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_I16_UNORM;

+      /* Pass through. */

+   case GL_INTENSITY:

+   case GL_INTENSITY4:

+   case GL_INTENSITY8:

+   case GL_COMPRESSED_INTENSITY:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,

+                                       sample_count, bindings, geom_flags ))

+         return PIPE_FORMAT_I8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings,

+                                  geom_flags );

+

+   case GL_YCBCR_MESA:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,

+                                      sample_count, bindings, geom_flags)) {

+         return PIPE_FORMAT_UYVY;

+      }

+      if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,

+                                      sample_count, bindings, geom_flags)) {

+         return PIPE_FORMAT_YUYV;

+      }

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGB:

+      /* can only sample from compressed formats */

+      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)

+         return PIPE_FORMAT_NONE;

+      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,

+                                           target, sample_count, bindings,

+                                           geom_flags))

+         return PIPE_FORMAT_DXT1_RGB;

+      else

+         return default_rgb_format(screen, target, sample_count, bindings,

+                                   geom_flags);

+

+   case GL_COMPRESSED_RGBA:

+      /* can only sample from compressed formats */

+      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)

+         return PIPE_FORMAT_NONE;

+      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,

+                                           target, sample_count, bindings,

+                                           geom_flags))

+         return PIPE_FORMAT_DXT3_RGBA;

+      else

+         return default_rgba_format(screen, target, sample_count, bindings,

+                                    geom_flags);

+

+   case GL_RGB_S3TC:

+   case GL_RGB4_S3TC:

+   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,

+                                      target, sample_count, bindings,

+                                      geom_flags))

+         return PIPE_FORMAT_DXT1_RGB;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,

+                                      target, sample_count, bindings,

+                                      geom_flags))

+         return PIPE_FORMAT_DXT1_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_RGBA_S3TC:

+   case GL_RGBA4_S3TC:

+   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,

+                                      target, sample_count, bindings,

+                                      geom_flags))

+         return PIPE_FORMAT_DXT3_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,

+                                      target, sample_count, bindings,

+                                      geom_flags))

+         return PIPE_FORMAT_DXT5_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+#if 0

+   case GL_COMPRESSED_RGB_FXT1_3DFX:

+      return PIPE_FORMAT_RGB_FXT1;

+   case GL_COMPRESSED_RGBA_FXT1_3DFX:

+      return PIPE_FORMAT_RGB_FXT1;

+#endif

+

+   case GL_DEPTH_COMPONENT16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_Z16_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT24:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                      target, sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_Z24_UNORM_S8_USCALED;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                      target, sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_S8_USCALED_Z24_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT32:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_Z32_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_Z32_UNORM,

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+            PIPE_FORMAT_Z16_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings, geom_flags);

+      }

+

+   case GL_STENCIL_INDEX:

+   case GL_STENCIL_INDEX1_EXT:

+   case GL_STENCIL_INDEX4_EXT:

+   case GL_STENCIL_INDEX8_EXT:

+   case GL_STENCIL_INDEX16_EXT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_S8_USCALED,

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings, geom_flags);

+      }

+

+   case GL_DEPTH_STENCIL_EXT:

+   case GL_DEPTH24_STENCIL8_EXT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings, geom_flags);

+      }

+

+   case GL_SRGB_EXT:

+   case GL_SRGB8_EXT:

+   case GL_SRGB_ALPHA_EXT:

+   case GL_SRGB8_ALPHA8_EXT:

+      return default_srgba_format( screen, target, sample_count, bindings,

+                                   geom_flags );

+

+   case GL_COMPRESSED_SRGB_EXT:

+   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_DXT1_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings,

+                                   geom_flags );

+

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      return PIPE_FORMAT_DXT1_SRGBA;

+

+   case GL_COMPRESSED_SRGB_ALPHA_EXT:

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_DXT3_SRGBA;

+      return default_srgba_format( screen, target, sample_count, bindings,

+                                   geom_flags );

+

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+      return PIPE_FORMAT_DXT5_SRGBA;

+

+   case GL_SLUMINANCE_ALPHA_EXT:

+   case GL_SLUMINANCE8_ALPHA8_EXT:

+   case GL_COMPRESSED_SLUMINANCE_EXT:

+   case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_L8A8_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings,

+                                   geom_flags );

+

+   case GL_SLUMINANCE_EXT:

+   case GL_SLUMINANCE8_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,

+                                      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_L8_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings,

+                                   geom_flags );

+

+   case GL_RED:

+   case GL_R8:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R8_UNORM;

+      return PIPE_FORMAT_NONE;

+   case GL_RG:

+   case GL_RG8:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R8G8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_R16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R16_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RG16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R16G16_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RED:

+   case GL_COMPRESSED_RED_RGTC1:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_RGTC1_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_RED_RGTC1:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_RGTC1_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RG:

+   case GL_COMPRESSED_RG_RGTC2:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_RGTC2_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_R8G8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_RG_RGTC2:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,

+				      sample_count, bindings, geom_flags))

+	      return PIPE_FORMAT_RGTC2_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_LUMINANCE:

+   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_LATC1_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_L8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_LATC1_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_LUMINANCE_ALPHA:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_LATC2_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_L8A8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,

+                                      sample_count, bindings, geom_flags))

+              return PIPE_FORMAT_LATC2_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   /* signed/unsigned integer formats.

+    * XXX Mesa only has formats for RGBA signed/unsigned integer formats.

+    * If/when new formats are added this code should be updated.

+    */

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      /* fall-through */

+   case GL_RGBA8I_EXT:

+   case GL_RGB8I_EXT:

+   case GL_ALPHA8I_EXT:

+   case GL_INTENSITY8I_EXT:

+   case GL_LUMINANCE8I_EXT:

+   case GL_LUMINANCE_ALPHA8I_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R8G8B8A8_SSCALED;

+      return PIPE_FORMAT_NONE;

+   case GL_RGBA16I_EXT:

+   case GL_RGB16I_EXT:

+   case GL_ALPHA16I_EXT:

+   case GL_INTENSITY16I_EXT:

+   case GL_LUMINANCE16I_EXT:

+   case GL_LUMINANCE_ALPHA16I_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R16G16B16A16_SSCALED;

+      return PIPE_FORMAT_NONE;

+   case GL_RGBA32I_EXT:

+   case GL_RGB32I_EXT:

+   case GL_ALPHA32I_EXT:

+   case GL_INTENSITY32I_EXT:

+   case GL_LUMINANCE32I_EXT:

+   case GL_LUMINANCE_ALPHA32I_EXT:

+      /* xxx */

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R32G32B32A32_SSCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA8UI_EXT:

+   case GL_RGB8UI_EXT:

+   case GL_ALPHA8UI_EXT:

+   case GL_INTENSITY8UI_EXT:

+   case GL_LUMINANCE8UI_EXT:

+   case GL_LUMINANCE_ALPHA8UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R8G8B8A8_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA16UI_EXT:

+   case GL_RGB16UI_EXT:

+   case GL_ALPHA16UI_EXT:

+   case GL_INTENSITY16UI_EXT:

+   case GL_LUMINANCE16UI_EXT:

+   case GL_LUMINANCE_ALPHA16UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R16G16B16A16_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA32UI_EXT:

+   case GL_RGB32UI_EXT:

+   case GL_ALPHA32UI_EXT:

+   case GL_INTENSITY32UI_EXT:

+   case GL_LUMINANCE32UI_EXT:

+   case GL_LUMINANCE_ALPHA32UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,

+                                      target,

+				      sample_count, bindings, geom_flags))

+         return PIPE_FORMAT_R32G32B32A32_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   default:

+      return PIPE_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.

+ */

+enum pipe_format

+st_choose_renderbuffer_format(struct pipe_screen *screen,

+                              GLenum internalFormat, unsigned sample_count)

+{

+   uint usage;

+   if (_mesa_is_depth_or_stencil_format(internalFormat))

+      usage = PIPE_BIND_DEPTH_STENCIL;

+   else

+      usage = PIPE_BIND_RENDER_TARGET;

+   return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,

+                           sample_count, usage);

+}

+

+

+/**

+ * Called via ctx->Driver.chooseTextureFormat().

+ */

+gl_format

+st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,

+				  GLenum format, GLenum type, GLboolean renderable)

+{

+   struct pipe_screen *screen = st_context(ctx)->pipe->screen;

+   enum pipe_format pFormat;

+   uint bindings;

+

+   (void) format;

+   (void) type;

+

+   /* GL textures may wind up being render targets, but we don't know

+    * that in advance.  Specify potential render target flags now.

+    */

+   bindings = PIPE_BIND_SAMPLER_VIEW;

+   if (renderable == GL_TRUE) {

+      if (_mesa_is_depth_format(internalFormat) ||

+	  _mesa_is_depth_or_stencil_format(internalFormat))

+	 bindings |= PIPE_BIND_DEPTH_STENCIL;

+      else 

+	 bindings |= PIPE_BIND_RENDER_TARGET;

+   }

+

+   pFormat = st_choose_format(screen, internalFormat,

+                              PIPE_TEXTURE_2D, 0, bindings);

+

+   if (pFormat == PIPE_FORMAT_NONE) {

+      /* try choosing format again, this time without render target bindings */

+      pFormat = st_choose_format(screen, internalFormat,

+                                 PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);

+   }

+

+   if (pFormat == PIPE_FORMAT_NONE) {

+      /* no luck at all */

+      return MESA_FORMAT_NONE;

+   }

+

+   return st_pipe_format_to_mesa_format(pFormat);

+}

+

+gl_format

+st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,

+                       GLenum format, GLenum type)

+{

+   boolean want_renderable =

+      internalFormat == 3 || internalFormat == 4 ||

+      internalFormat == GL_RGB || internalFormat == GL_RGBA ||

+      internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||

+      internalFormat == GL_BGRA;

+

+   return st_ChooseTextureFormat_renderable(ctx, internalFormat,

+					    format, type, want_renderable);

+}

+

+/**

+ * Test if a gallium format is equivalent to a GL format/type.

+ */

+GLboolean

+st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)

+{

+   switch (pFormat) {

+   case PIPE_FORMAT_A8B8G8R8_UNORM:

+      return format == GL_RGBA && type == GL_UNSIGNED_BYTE;

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+      return format == GL_BGRA && type == GL_UNSIGNED_BYTE;

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;

+   /* XXX more combos... */

+   default:

+      return GL_FALSE;

+   }

+}

+

+GLboolean

+st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)

+{

+   if (format1 == format2)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&

+       format2 == PIPE_FORMAT_B8G8R8X8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&

+       format2 == PIPE_FORMAT_B8G8R8A8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&

+       format2 == PIPE_FORMAT_X8B8G8R8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&

+       format2 == PIPE_FORMAT_A8B8G8R8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&

+       format2 == PIPE_FORMAT_X8R8G8B8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&

+       format2 == PIPE_FORMAT_A8R8G8B8_UNORM)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+

+/**

+ * This is used for translating texture border color and the clear

+ * color.  For example, the clear color is interpreted according to

+ * the renderbuffer's base format.  For example, if clearing a

+ * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =

+ * alpha.  Similarly for texture border colors.

+ */

+void

+st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,

+                   GLfloat colorOut[4])

+{

+   switch (baseFormat) {

+   case GL_RED:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = 0.0F;

+      colorOut[2] = 0.0F;

+      colorOut[3] = 1.0F;

+      break;

+   case GL_RG:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = colorIn[1];

+      colorOut[2] = 0.0F;

+      colorOut[3] = 1.0F;

+      break;

+   case GL_RGB:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = colorIn[1];

+      colorOut[2] = colorIn[2];

+      colorOut[3] = 1.0F;

+      break;

+   case GL_ALPHA:

+      colorOut[0] = colorOut[1] = colorOut[2] = 0.0;

+      colorOut[3] = colorIn[3];

+      break;

+   case GL_LUMINANCE:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];

+      colorOut[3] = 1.0;

+      break;

+   case GL_LUMINANCE_ALPHA:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];

+      colorOut[3] = colorIn[3];

+      break;

+   case GL_INTENSITY:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];

+      break;

+   default:

+      COPY_4V(colorOut, colorIn);

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_format.h b/mesalib/src/mesa/state_tracker/st_format.h
index 0fb570f6e..d31e60711 100644
--- a/mesalib/src/mesa/state_tracker/st_format.h
+++ b/mesalib/src/mesa/state_tracker/st_format.h
@@ -1,86 +1,86 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright (c) 2010 VMware, Inc.
- * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-#ifndef ST_FORMAT_H
-#define ST_FORMAT_H
-
-#include "main/formats.h"
-#include "main/glheader.h"
-
-#include "pipe/p_defines.h"
-#include "pipe/p_format.h"
-
-struct gl_context;
-struct pipe_screen;
-
-extern GLenum
-st_format_datatype(enum pipe_format format);
-
-
-extern enum pipe_format
-st_mesa_format_to_pipe_format(gl_format mesaFormat);
-
-extern gl_format
-st_pipe_format_to_mesa_format(enum pipe_format pipeFormat);
-
-
-extern enum pipe_format
-st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
-                 enum pipe_texture_target target, unsigned sample_count,
-                 unsigned tex_usage);
-
-extern enum pipe_format
-st_choose_renderbuffer_format(struct pipe_screen *screen,
-                              GLenum internalFormat, unsigned sample_count);
-
-
-gl_format
-st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
-				  GLenum format, GLenum type, GLboolean renderable);
-
-extern gl_format
-st_ChooseTextureFormat(struct gl_context * ctx, GLint internalFormat,
-                       GLenum format, GLenum type);
-
-
-extern GLboolean
-st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type);
-
-/* can we use a sampler view to translate these formats
-   only used to make TFP so far */
-extern GLboolean
-st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2);
-
-
-extern void
-st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
-                   GLfloat colorOut[4]);
-
-
-#endif /* ST_FORMAT_H */
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright (c) 2010 VMware, Inc.

+ * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+#ifndef ST_FORMAT_H

+#define ST_FORMAT_H

+

+#include "main/formats.h"

+#include "main/glheader.h"

+

+#include "pipe/p_defines.h"

+#include "pipe/p_format.h"

+

+struct gl_context;

+struct pipe_screen;

+

+extern GLenum

+st_format_datatype(enum pipe_format format);

+

+

+extern enum pipe_format

+st_mesa_format_to_pipe_format(gl_format mesaFormat);

+

+extern gl_format

+st_pipe_format_to_mesa_format(enum pipe_format pipeFormat);

+

+

+extern enum pipe_format

+st_choose_format(struct pipe_screen *screen, GLenum internalFormat,

+                 enum pipe_texture_target target, unsigned sample_count,

+                 unsigned tex_usage);

+

+extern enum pipe_format

+st_choose_renderbuffer_format(struct pipe_screen *screen,

+                              GLenum internalFormat, unsigned sample_count);

+

+

+gl_format

+st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,

+				  GLenum format, GLenum type, GLboolean renderable);

+

+extern gl_format

+st_ChooseTextureFormat(struct gl_context * ctx, GLint internalFormat,

+                       GLenum format, GLenum type);

+

+

+extern GLboolean

+st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type);

+

+/* can we use a sampler view to translate these formats

+   only used to make TFP so far */

+extern GLboolean

+st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2);

+

+

+extern void

+st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,

+                   GLfloat colorOut[4]);

+

+

+#endif /* ST_FORMAT_H */

diff --git a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
index 899161e78..34a2e9ebd 100644
--- a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
@@ -1,451 +1,451 @@
-/**************************************************************************
- * 
- * Copyright 2008 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-
-#include "main/imports.h"
-#include "main/mipmap.h"
-#include "main/teximage.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_gen_mipmap.h"
-
-#include "st_debug.h"
-#include "st_context.h"
-#include "st_texture.h"
-#include "st_gen_mipmap.h"
-#include "st_cb_texture.h"
-
-
-/**
- * one-time init for generate mipmap
- * XXX Note: there may be other times we need no-op/simple state like this.
- * In that case, some code refactoring would be good.
- */
-void
-st_init_generate_mipmap(struct st_context *st)
-{
-   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);
-}
-
-
-void
-st_destroy_generate_mipmap(struct st_context *st)
-{
-   util_destroy_gen_mipmap(st->gen_mipmap);
-   st->gen_mipmap = NULL;
-}
-
-
-/**
- * Generate mipmap levels using hardware rendering.
- * \return TRUE if successful, FALSE if not possible
- */
-static boolean
-st_render_mipmap(struct st_context *st,
-                 GLenum target,
-                 struct st_texture_object *stObj,
-                 uint baseLevel, uint lastLevel)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);
-   const uint face = _mesa_tex_target_to_face(target);
-
-   assert(psv->texture == stObj->pt);
-#if 0
-   assert(target != GL_TEXTURE_3D); /* implemented but untested */
-#endif
-
-   /* check if we can render in the texture's format */
-   /* XXX should probably kill this and always use util_gen_mipmap
-      since this implements a sw fallback as well */
-   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
-                                    0, PIPE_BIND_RENDER_TARGET, 0)) {
-      return FALSE;
-   }
-
-   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,
-                   PIPE_TEX_FILTER_LINEAR);
-
-   return TRUE;
-}
-
-
-/**
- * Helper function to decompress an image.  The result is a 32-bpp RGBA
- * image with stride==width.
- */
-static void
-decompress_image(enum pipe_format format, int datatype,
-                 const uint8_t *src, void *dst,
-                 unsigned width, unsigned height, unsigned src_stride)
-{
-   const struct util_format_description *desc = util_format_description(format);
-   const uint bw = util_format_get_blockwidth(format);
-   const uint bh = util_format_get_blockheight(format);
-   uint dst_stride = 4 * MAX2(width, bw);
-
-   if (datatype == GL_FLOAT) {
-      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);
-      if (width < bw || height < bh) {
-	 float *dst_p = (float *)dst;
-	 /* We're decompressing an image smaller than the compression
-	  * block size.  We don't want garbage pixel values in the region
-	  * outside (width x height) so replicate pixels from the (width
-	  * x height) region to fill out the (bw x bh) block size.
-	  */
-	 uint x, y;
-	 for (y = 0; y < bh; y++) {
-	    for (x = 0; x < bw; x++) {
-	       if (x >= width || y >= height) {
-		  uint p = (y * bw + x) * 4;
-		  dst_p[p + 0] = dst_p[0];
-		  dst_p[p + 1] = dst_p[1];
-		  dst_p[p + 2] = dst_p[2];
-		  dst_p[p + 3] = dst_p[3];
-	       }
-	    }
-	 }
-      }
-   } else {
-      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);
-      if (width < bw || height < bh) {
-	 uint8_t *dst_p = (uint8_t *)dst;
-	 /* We're decompressing an image smaller than the compression
-	  * block size.  We don't want garbage pixel values in the region
-	  * outside (width x height) so replicate pixels from the (width
-	  * x height) region to fill out the (bw x bh) block size.
-	  */
-	 uint x, y;
-	 for (y = 0; y < bh; y++) {
-	    for (x = 0; x < bw; x++) {
-	       if (x >= width || y >= height) {
-		  uint p = (y * bw + x) * 4;
-		  dst_p[p + 0] = dst_p[0];
-		  dst_p[p + 1] = dst_p[1];
-		  dst_p[p + 2] = dst_p[2];
-		  dst_p[p + 3] = dst_p[3];
-	       }
-	    }
-	 }
-      }
-   }
-}
-
-/**
- * Helper function to compress an image.  The source is a 32-bpp RGBA image
- * with stride==width.
- */
-static void
-compress_image(enum pipe_format format, int datatype,
-               const void *src, uint8_t *dst,
-               unsigned width, unsigned height, unsigned dst_stride)
-{
-   const struct util_format_description *desc = util_format_description(format);
-   const uint src_stride = 4 * width;
-
-   if (datatype == GL_FLOAT)
-      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);
-   else
-      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);
-}
-
-
-/**
- * Software fallback for generate mipmap levels.
- */
-static void
-fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
-                         struct gl_texture_object *texObj)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct pipe_resource *pt = st_get_texobj_resource(texObj);
-   const uint baseLevel = texObj->BaseLevel;
-   const uint lastLevel = pt->last_level;
-   const uint face = _mesa_tex_target_to_face(target);
-   uint dstLevel;
-   GLenum datatype;
-   GLuint comps;
-   GLboolean compressed;
-
-   if (ST_DEBUG & DEBUG_FALLBACK)
-      debug_printf("%s: fallback processing\n", __FUNCTION__);
-
-   assert(target != GL_TEXTURE_3D); /* not done yet */
-
-   compressed =
-      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);
-
-   if (compressed) {
-      GLenum type =
-         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);
-
-      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;
-      comps = 4;
-   }
-   else {
-      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
-                                     &datatype, &comps);
-      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");
-   }
-
-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
-      const uint srcLevel = dstLevel - 1;
-      const uint srcWidth = u_minify(pt->width0, srcLevel);
-      const uint srcHeight = u_minify(pt->height0, srcLevel);
-      const uint srcDepth = u_minify(pt->depth0, srcLevel);
-      const uint dstWidth = u_minify(pt->width0, dstLevel);
-      const uint dstHeight = u_minify(pt->height0, dstLevel);
-      const uint dstDepth = u_minify(pt->depth0, dstLevel);
-      struct pipe_transfer *srcTrans, *dstTrans;
-      const ubyte *srcData;
-      ubyte *dstData;
-      int srcStride, dstStride;
-
-      srcTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, srcLevel,
-                                   face,
-                                   PIPE_TRANSFER_READ, 0, 0,
-                                   srcWidth, srcHeight);
-
-      dstTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, dstLevel,
-                                   face,
-                                   PIPE_TRANSFER_WRITE, 0, 0,
-                                   dstWidth, dstHeight);
-
-      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);
-      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);
-
-      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);
-      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);
-
-     /* this cannot work correctly for 3d since it does
-        not respect layerStride. */
-      if (compressed) {
-         const enum pipe_format format = pt->format;
-         const uint bw = util_format_get_blockwidth(format);
-         const uint bh = util_format_get_blockheight(format);
-         const uint srcWidth2 = align(srcWidth, bw);
-         const uint srcHeight2 = align(srcHeight, bh);
-         const uint dstWidth2 = align(dstWidth, bw);
-         const uint dstHeight2 = align(dstHeight, bh);
-         uint8_t *srcTemp, *dstTemp;
-
-         assert(comps == 4);
-
-         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
-         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
-
-         /* decompress the src image: srcData -> srcTemp */
-         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);
-
-         _mesa_generate_mipmap_level(target, datatype, comps,
-                                     0 /*border*/,
-                                     srcWidth2, srcHeight2, srcDepth,
-                                     srcTemp,
-                                     srcWidth2, /* stride in texels */
-                                     dstWidth2, dstHeight2, dstDepth,
-                                     dstTemp,
-                                     dstWidth2); /* stride in texels */
-
-         /* compress the new image: dstTemp -> dstData */
-         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);
-
-         free(srcTemp);
-         free(dstTemp);
-      }
-      else {
-         _mesa_generate_mipmap_level(target, datatype, comps,
-                                     0 /*border*/,
-                                     srcWidth, srcHeight, srcDepth,
-                                     srcData,
-                                     srcStride, /* stride in texels */
-                                     dstWidth, dstHeight, dstDepth,
-                                     dstData,
-                                     dstStride); /* stride in texels */
-      }
-
-      pipe_transfer_unmap(pipe, srcTrans);
-      pipe_transfer_unmap(pipe, dstTrans);
-
-      pipe->transfer_destroy(pipe, srcTrans);
-      pipe->transfer_destroy(pipe, dstTrans);
-   }
-}
-
-
-/**
- * Compute the expected number of mipmap levels in the texture given
- * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/
- * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap
- * levels should be generated.
- */
-static GLuint
-compute_num_levels(struct gl_context *ctx,
-                   struct gl_texture_object *texObj,
-                   GLenum target)
-{
-   if (target == GL_TEXTURE_RECTANGLE_ARB) {
-      return 1;
-   }
-   else {
-      const struct gl_texture_image *baseImage = 
-         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);
-      GLuint size, numLevels;
-
-      size = MAX2(baseImage->Width2, baseImage->Height2);
-      size = MAX2(size, baseImage->Depth2);
-
-      numLevels = texObj->BaseLevel;
-
-      while (size > 0) {
-         numLevels++;
-         size >>= 1;
-      }
-
-      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);
-
-      assert(numLevels >= 1);
-
-      return numLevels;
-   }
-}
-
-
-/**
- * Called via ctx->Driver.GenerateMipmap().
- */
-void
-st_generate_mipmap(struct gl_context *ctx, GLenum target,
-                   struct gl_texture_object *texObj)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_texture_object *stObj = st_texture_object(texObj);
-   struct pipe_resource *pt = st_get_texobj_resource(texObj);
-   const uint baseLevel = texObj->BaseLevel;
-   uint lastLevel;
-   uint dstLevel;
-
-   if (!pt)
-      return;
-
-   /* not sure if this ultimately actually should work,
-      but we're not supporting multisampled textures yet. */
-   assert(pt->nr_samples < 2);
-
-   /* find expected last mipmap level to generate*/
-   lastLevel = compute_num_levels(ctx, texObj, target) - 1;
-
-   if (lastLevel == 0)
-      return;
-
-   /* The texture isn't in a "complete" state yet so set the expected
-    * lastLevel here, since it won't get done in st_finalize_texture().
-    */
-   stObj->lastLevel = lastLevel;
-
-   if (pt->last_level < lastLevel) {
-      /* The current gallium texture doesn't have space for all the
-       * mipmap levels we need to generate.  So allocate a new texture.
-       */
-      struct pipe_resource *oldTex = stObj->pt;
-
-      /* create new texture with space for more levels */
-      stObj->pt = st_texture_create(st,
-                                    oldTex->target,
-                                    oldTex->format,
-                                    lastLevel,
-                                    oldTex->width0,
-                                    oldTex->height0,
-                                    oldTex->depth0,
-                                    oldTex->array_size,
-                                    oldTex->bind);
-
-      /* This will copy the old texture's base image into the new texture
-       * which we just allocated.
-       */
-      st_finalize_texture(ctx, st->pipe, texObj);
-
-      /* release the old tex (will likely be freed too) */
-      pipe_resource_reference(&oldTex, NULL);
-      pipe_sampler_view_reference(&stObj->sampler_view, NULL);
-   }
-   else {
-      /* Make sure that the base texture image data is present in the
-       * texture buffer.
-       */
-      st_finalize_texture(ctx, st->pipe, texObj);
-   }
-
-   pt = stObj->pt;
-
-   assert(pt->last_level >= lastLevel);
-
-   /* Try to generate the mipmap by rendering/texturing.  If that fails,
-    * use the software fallback.
-    */
-   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {
-      /* since the util code actually also has a fallback, should
-         probably make it never fail and kill this */
-      fallback_generate_mipmap(ctx, target, texObj);
-   }
-
-   /* Fill in the Mesa gl_texture_image fields */
-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
-      const uint srcLevel = dstLevel - 1;
-      const struct gl_texture_image *srcImage
-         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);
-      struct gl_texture_image *dstImage;
-      struct st_texture_image *stImage;
-      uint dstWidth = u_minify(pt->width0, dstLevel);
-      uint dstHeight = u_minify(pt->height0, dstLevel);
-      uint dstDepth = u_minify(pt->depth0, dstLevel); 
-      uint border = srcImage->Border;
-
-      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
-      if (!dstImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
-         return;
-      }
-
-      /* Free old image data */
-      if (dstImage->Data)
-         ctx->Driver.FreeTexImageData(ctx, dstImage);
-
-      /* initialize new image */
-      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
-                                 dstDepth, border, srcImage->InternalFormat,
-                                 srcImage->TexFormat);
-
-      stImage = st_texture_image(dstImage);
-      stImage->level = dstLevel;
-
-      pipe_resource_reference(&stImage->pt, pt);
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2008 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+

+#include "main/imports.h"

+#include "main/mipmap.h"

+#include "main/teximage.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+#include "util/u_format.h"

+#include "util/u_gen_mipmap.h"

+

+#include "st_debug.h"

+#include "st_context.h"

+#include "st_texture.h"

+#include "st_gen_mipmap.h"

+#include "st_cb_texture.h"

+

+

+/**

+ * one-time init for generate mipmap

+ * XXX Note: there may be other times we need no-op/simple state like this.

+ * In that case, some code refactoring would be good.

+ */

+void

+st_init_generate_mipmap(struct st_context *st)

+{

+   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);

+}

+

+

+void

+st_destroy_generate_mipmap(struct st_context *st)

+{

+   util_destroy_gen_mipmap(st->gen_mipmap);

+   st->gen_mipmap = NULL;

+}

+

+

+/**

+ * Generate mipmap levels using hardware rendering.

+ * \return TRUE if successful, FALSE if not possible

+ */

+static boolean

+st_render_mipmap(struct st_context *st,

+                 GLenum target,

+                 struct st_texture_object *stObj,

+                 uint baseLevel, uint lastLevel)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);

+   const uint face = _mesa_tex_target_to_face(target);

+

+   assert(psv->texture == stObj->pt);

+#if 0

+   assert(target != GL_TEXTURE_3D); /* implemented but untested */

+#endif

+

+   /* check if we can render in the texture's format */

+   /* XXX should probably kill this and always use util_gen_mipmap

+      since this implements a sw fallback as well */

+   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,

+                                    0, PIPE_BIND_RENDER_TARGET, 0)) {

+      return FALSE;

+   }

+

+   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,

+                   PIPE_TEX_FILTER_LINEAR);

+

+   return TRUE;

+}

+

+

+/**

+ * Helper function to decompress an image.  The result is a 32-bpp RGBA

+ * image with stride==width.

+ */

+static void

+decompress_image(enum pipe_format format, int datatype,

+                 const uint8_t *src, void *dst,

+                 unsigned width, unsigned height, unsigned src_stride)

+{

+   const struct util_format_description *desc = util_format_description(format);

+   const uint bw = util_format_get_blockwidth(format);

+   const uint bh = util_format_get_blockheight(format);

+   uint dst_stride = 4 * MAX2(width, bw);

+

+   if (datatype == GL_FLOAT) {

+      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);

+      if (width < bw || height < bh) {

+	 float *dst_p = (float *)dst;

+	 /* We're decompressing an image smaller than the compression

+	  * block size.  We don't want garbage pixel values in the region

+	  * outside (width x height) so replicate pixels from the (width

+	  * x height) region to fill out the (bw x bh) block size.

+	  */

+	 uint x, y;

+	 for (y = 0; y < bh; y++) {

+	    for (x = 0; x < bw; x++) {

+	       if (x >= width || y >= height) {

+		  uint p = (y * bw + x) * 4;

+		  dst_p[p + 0] = dst_p[0];

+		  dst_p[p + 1] = dst_p[1];

+		  dst_p[p + 2] = dst_p[2];

+		  dst_p[p + 3] = dst_p[3];

+	       }

+	    }

+	 }

+      }

+   } else {

+      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);

+      if (width < bw || height < bh) {

+	 uint8_t *dst_p = (uint8_t *)dst;

+	 /* We're decompressing an image smaller than the compression

+	  * block size.  We don't want garbage pixel values in the region

+	  * outside (width x height) so replicate pixels from the (width

+	  * x height) region to fill out the (bw x bh) block size.

+	  */

+	 uint x, y;

+	 for (y = 0; y < bh; y++) {

+	    for (x = 0; x < bw; x++) {

+	       if (x >= width || y >= height) {

+		  uint p = (y * bw + x) * 4;

+		  dst_p[p + 0] = dst_p[0];

+		  dst_p[p + 1] = dst_p[1];

+		  dst_p[p + 2] = dst_p[2];

+		  dst_p[p + 3] = dst_p[3];

+	       }

+	    }

+	 }

+      }

+   }

+}

+

+/**

+ * Helper function to compress an image.  The source is a 32-bpp RGBA image

+ * with stride==width.

+ */

+static void

+compress_image(enum pipe_format format, int datatype,

+               const void *src, uint8_t *dst,

+               unsigned width, unsigned height, unsigned dst_stride)

+{

+   const struct util_format_description *desc = util_format_description(format);

+   const uint src_stride = 4 * width;

+

+   if (datatype == GL_FLOAT)

+      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);

+   else

+      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);

+}

+

+

+/**

+ * Software fallback for generate mipmap levels.

+ */

+static void

+fallback_generate_mipmap(struct gl_context *ctx, GLenum target,

+                         struct gl_texture_object *texObj)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct pipe_resource *pt = st_get_texobj_resource(texObj);

+   const uint baseLevel = texObj->BaseLevel;

+   const uint lastLevel = pt->last_level;

+   const uint face = _mesa_tex_target_to_face(target);

+   uint dstLevel;

+   GLenum datatype;

+   GLuint comps;

+   GLboolean compressed;

+

+   if (ST_DEBUG & DEBUG_FALLBACK)

+      debug_printf("%s: fallback processing\n", __FUNCTION__);

+

+   assert(target != GL_TEXTURE_3D); /* not done yet */

+

+   compressed =

+      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);

+

+   if (compressed) {

+      GLenum type =

+         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);

+

+      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;

+      comps = 4;

+   }

+   else {

+      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,

+                                     &datatype, &comps);

+      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");

+   }

+

+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

+      const uint srcLevel = dstLevel - 1;

+      const uint srcWidth = u_minify(pt->width0, srcLevel);

+      const uint srcHeight = u_minify(pt->height0, srcLevel);

+      const uint srcDepth = u_minify(pt->depth0, srcLevel);

+      const uint dstWidth = u_minify(pt->width0, dstLevel);

+      const uint dstHeight = u_minify(pt->height0, dstLevel);

+      const uint dstDepth = u_minify(pt->depth0, dstLevel);

+      struct pipe_transfer *srcTrans, *dstTrans;

+      const ubyte *srcData;

+      ubyte *dstData;

+      int srcStride, dstStride;

+

+      srcTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, srcLevel,

+                                   face,

+                                   PIPE_TRANSFER_READ, 0, 0,

+                                   srcWidth, srcHeight);

+

+      dstTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, dstLevel,

+                                   face,

+                                   PIPE_TRANSFER_WRITE, 0, 0,

+                                   dstWidth, dstHeight);

+

+      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);

+      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);

+

+      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);

+      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);

+

+     /* this cannot work correctly for 3d since it does

+        not respect layerStride. */

+      if (compressed) {

+         const enum pipe_format format = pt->format;

+         const uint bw = util_format_get_blockwidth(format);

+         const uint bh = util_format_get_blockheight(format);

+         const uint srcWidth2 = align(srcWidth, bw);

+         const uint srcHeight2 = align(srcHeight, bh);

+         const uint dstWidth2 = align(dstWidth, bw);

+         const uint dstHeight2 = align(dstHeight, bh);

+         uint8_t *srcTemp, *dstTemp;

+

+         assert(comps == 4);

+

+         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

+         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

+

+         /* decompress the src image: srcData -> srcTemp */

+         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);

+

+         _mesa_generate_mipmap_level(target, datatype, comps,

+                                     0 /*border*/,

+                                     srcWidth2, srcHeight2, srcDepth,

+                                     srcTemp,

+                                     srcWidth2, /* stride in texels */

+                                     dstWidth2, dstHeight2, dstDepth,

+                                     dstTemp,

+                                     dstWidth2); /* stride in texels */

+

+         /* compress the new image: dstTemp -> dstData */

+         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);

+

+         free(srcTemp);

+         free(dstTemp);

+      }

+      else {

+         _mesa_generate_mipmap_level(target, datatype, comps,

+                                     0 /*border*/,

+                                     srcWidth, srcHeight, srcDepth,

+                                     srcData,

+                                     srcStride, /* stride in texels */

+                                     dstWidth, dstHeight, dstDepth,

+                                     dstData,

+                                     dstStride); /* stride in texels */

+      }

+

+      pipe_transfer_unmap(pipe, srcTrans);

+      pipe_transfer_unmap(pipe, dstTrans);

+

+      pipe->transfer_destroy(pipe, srcTrans);

+      pipe->transfer_destroy(pipe, dstTrans);

+   }

+}

+

+

+/**

+ * Compute the expected number of mipmap levels in the texture given

+ * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/

+ * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap

+ * levels should be generated.

+ */

+static GLuint

+compute_num_levels(struct gl_context *ctx,

+                   struct gl_texture_object *texObj,

+                   GLenum target)

+{

+   if (target == GL_TEXTURE_RECTANGLE_ARB) {

+      return 1;

+   }

+   else {

+      const struct gl_texture_image *baseImage = 

+         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);

+      GLuint size, numLevels;

+

+      size = MAX2(baseImage->Width2, baseImage->Height2);

+      size = MAX2(size, baseImage->Depth2);

+

+      numLevels = texObj->BaseLevel;

+

+      while (size > 0) {

+         numLevels++;

+         size >>= 1;

+      }

+

+      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);

+

+      assert(numLevels >= 1);

+

+      return numLevels;

+   }

+}

+

+

+/**

+ * Called via ctx->Driver.GenerateMipmap().

+ */

+void

+st_generate_mipmap(struct gl_context *ctx, GLenum target,

+                   struct gl_texture_object *texObj)

+{

+   struct st_context *st = st_context(ctx);

+   struct st_texture_object *stObj = st_texture_object(texObj);

+   struct pipe_resource *pt = st_get_texobj_resource(texObj);

+   const uint baseLevel = texObj->BaseLevel;

+   uint lastLevel;

+   uint dstLevel;

+

+   if (!pt)

+      return;

+

+   /* not sure if this ultimately actually should work,

+      but we're not supporting multisampled textures yet. */

+   assert(pt->nr_samples < 2);

+

+   /* find expected last mipmap level to generate*/

+   lastLevel = compute_num_levels(ctx, texObj, target) - 1;

+

+   if (lastLevel == 0)

+      return;

+

+   /* The texture isn't in a "complete" state yet so set the expected

+    * lastLevel here, since it won't get done in st_finalize_texture().

+    */

+   stObj->lastLevel = lastLevel;

+

+   if (pt->last_level < lastLevel) {

+      /* The current gallium texture doesn't have space for all the

+       * mipmap levels we need to generate.  So allocate a new texture.

+       */

+      struct pipe_resource *oldTex = stObj->pt;

+

+      /* create new texture with space for more levels */

+      stObj->pt = st_texture_create(st,

+                                    oldTex->target,

+                                    oldTex->format,

+                                    lastLevel,

+                                    oldTex->width0,

+                                    oldTex->height0,

+                                    oldTex->depth0,

+                                    oldTex->array_size,

+                                    oldTex->bind);

+

+      /* This will copy the old texture's base image into the new texture

+       * which we just allocated.

+       */

+      st_finalize_texture(ctx, st->pipe, texObj);

+

+      /* release the old tex (will likely be freed too) */

+      pipe_resource_reference(&oldTex, NULL);

+      pipe_sampler_view_reference(&stObj->sampler_view, NULL);

+   }

+   else {

+      /* Make sure that the base texture image data is present in the

+       * texture buffer.

+       */

+      st_finalize_texture(ctx, st->pipe, texObj);

+   }

+

+   pt = stObj->pt;

+

+   assert(pt->last_level >= lastLevel);

+

+   /* Try to generate the mipmap by rendering/texturing.  If that fails,

+    * use the software fallback.

+    */

+   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {

+      /* since the util code actually also has a fallback, should

+         probably make it never fail and kill this */

+      fallback_generate_mipmap(ctx, target, texObj);

+   }

+

+   /* Fill in the Mesa gl_texture_image fields */

+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

+      const uint srcLevel = dstLevel - 1;

+      const struct gl_texture_image *srcImage

+         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);

+      struct gl_texture_image *dstImage;

+      struct st_texture_image *stImage;

+      uint dstWidth = u_minify(pt->width0, dstLevel);

+      uint dstHeight = u_minify(pt->height0, dstLevel);

+      uint dstDepth = u_minify(pt->depth0, dstLevel); 

+      uint border = srcImage->Border;

+

+      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);

+      if (!dstImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");

+         return;

+      }

+

+      /* Free old image data */

+      if (dstImage->Data)

+         ctx->Driver.FreeTexImageData(ctx, dstImage);

+

+      /* initialize new image */

+      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,

+                                 dstDepth, border, srcImage->InternalFormat,

+                                 srcImage->TexFormat);

+

+      stImage = st_texture_image(dstImage);

+      stImage->level = dstLevel;

+

+      pipe_resource_reference(&stImage->pt, pt);

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_manager.c b/mesalib/src/mesa/state_tracker/st_manager.c
index d85bcd4f7..ed668d248 100644
--- a/mesalib/src/mesa/state_tracker/st_manager.c
+++ b/mesalib/src/mesa/state_tracker/st_manager.c
@@ -1,923 +1,923 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.9
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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:
- *    Chia-I Wu <olv@lunarg.com>
- */
-
-#include "state_tracker/st_gl_api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_format.h"
-#include "util/u_pointer.h"
-#include "util/u_inlines.h"
-#include "util/u_atomic.h"
-#include "util/u_surface.h"
-
-#include "main/mtypes.h"
-#include "main/context.h"
-#include "main/mfeatures.h"
-#include "main/texobj.h"
-#include "main/teximage.h"
-#include "main/texstate.h"
-#include "main/framebuffer.h"
-#include "main/fbobject.h"
-#include "main/renderbuffer.h"
-#include "main/version.h"
-#include "st_texture.h"
-
-#include "st_context.h"
-#include "st_format.h"
-#include "st_cb_fbo.h"
-#include "st_cb_flush.h"
-#include "st_manager.h"
-
-/**
- * Cast wrapper to convert a struct gl_framebuffer to an st_framebuffer.
- * Return NULL if the struct gl_framebuffer is a user-created framebuffer.
- * We'll only return non-null for window system framebuffers.
- * Note that this function may fail.
- */
-static INLINE struct st_framebuffer *
-st_ws_framebuffer(struct gl_framebuffer *fb)
-{
-   /* FBO cannot be casted.  See st_new_framebuffer */
-   return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL);
-}
-
-/**
- * Map an attachment to a buffer index.
- */
-static INLINE gl_buffer_index
-attachment_to_buffer_index(enum st_attachment_type statt)
-{
-   gl_buffer_index index;
-
-   switch (statt) {
-   case ST_ATTACHMENT_FRONT_LEFT:
-      index = BUFFER_FRONT_LEFT;
-      break;
-   case ST_ATTACHMENT_BACK_LEFT:
-      index = BUFFER_BACK_LEFT;
-      break;
-   case ST_ATTACHMENT_FRONT_RIGHT:
-      index = BUFFER_FRONT_RIGHT;
-      break;
-   case ST_ATTACHMENT_BACK_RIGHT:
-      index = BUFFER_BACK_RIGHT;
-      break;
-   case ST_ATTACHMENT_DEPTH_STENCIL:
-      index = BUFFER_DEPTH;
-      break;
-   case ST_ATTACHMENT_ACCUM:
-      index = BUFFER_ACCUM;
-      break;
-   case ST_ATTACHMENT_SAMPLE:
-   default:
-      index = BUFFER_COUNT;
-      break;
-   }
-
-   return index;
-}
-
-/**
- * Map a buffer index to an attachment.
- */
-static INLINE enum st_attachment_type
-buffer_index_to_attachment(gl_buffer_index index)
-{
-   enum st_attachment_type statt;
-
-   switch (index) {
-   case BUFFER_FRONT_LEFT:
-      statt = ST_ATTACHMENT_FRONT_LEFT;
-      break;
-   case BUFFER_BACK_LEFT:
-      statt = ST_ATTACHMENT_BACK_LEFT;
-      break;
-   case BUFFER_FRONT_RIGHT:
-      statt = ST_ATTACHMENT_FRONT_RIGHT;
-      break;
-   case BUFFER_BACK_RIGHT:
-      statt = ST_ATTACHMENT_BACK_RIGHT;
-      break;
-   case BUFFER_DEPTH:
-      statt = ST_ATTACHMENT_DEPTH_STENCIL;
-      break;
-   case BUFFER_ACCUM:
-      statt = ST_ATTACHMENT_ACCUM;
-      break;
-   default:
-      statt = ST_ATTACHMENT_INVALID;
-      break;
-   }
-
-   return statt;
-}
-
-/**
- * Validate a framebuffer to make sure up-to-date pipe_textures are used.
- */
-static void
-st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
-   uint width, height;
-   unsigned i;
-   boolean changed = FALSE;
-
-   if (!p_atomic_read(&stfb->revalidate))
-      return;
-
-   /* validate the fb */
-   if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))
-      return;
-
-   width = stfb->Base.Width;
-   height = stfb->Base.Height;
-
-   for (i = 0; i < stfb->num_statts; i++) {
-      struct st_renderbuffer *strb;
-      struct pipe_surface *ps, surf_tmpl;
-      gl_buffer_index idx;
-
-      if (!textures[i])
-         continue;
-
-      idx = attachment_to_buffer_index(stfb->statts[i]);
-      if (idx >= BUFFER_COUNT) {
-         pipe_resource_reference(&textures[i], NULL);
-         continue;
-      }
-
-      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
-      assert(strb);
-      if (strb->texture == textures[i]) {
-         pipe_resource_reference(&textures[i], NULL);
-         continue;
-      }
-
-      memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-      u_surface_default_template(&surf_tmpl, textures[i],
-                                 PIPE_BIND_RENDER_TARGET);
-      ps = pipe->create_surface(pipe, textures[i], &surf_tmpl);
-      if (ps) {
-         pipe_surface_reference(&strb->surface, ps);
-         pipe_resource_reference(&strb->texture, ps->texture);
-         /* ownership transfered */
-         pipe_surface_reference(&ps, NULL);
-
-         changed = TRUE;
-
-         strb->Base.Width = strb->surface->width;
-         strb->Base.Height = strb->surface->height;
-
-         width = strb->Base.Width;
-         height = strb->Base.Height;
-      }
-
-      pipe_resource_reference(&textures[i], NULL);
-   }
-
-   if (changed) {
-      st->dirty.st |= ST_NEW_FRAMEBUFFER;
-      _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);
-
-      assert(stfb->Base.Width == width);
-      assert(stfb->Base.Height == height);
-   }
-
-   p_atomic_set(&stfb->revalidate, FALSE);
-}
-
-/**
- * Update the attachments to validate by looping the existing renderbuffers.
- */
-static void
-st_framebuffer_update_attachments(struct st_framebuffer *stfb)
-{
-   gl_buffer_index idx;
-
-   stfb->num_statts = 0;
-   for (idx = 0; idx < BUFFER_COUNT; idx++) {
-      struct st_renderbuffer *strb;
-      enum st_attachment_type statt;
-
-      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
-      if (!strb || strb->software)
-         continue;
-
-      statt = buffer_index_to_attachment(idx);
-      if (statt != ST_ATTACHMENT_INVALID &&
-          st_visual_have_buffers(stfb->iface->visual, 1 << statt))
-         stfb->statts[stfb->num_statts++] = statt;
-   }
-
-   p_atomic_set(&stfb->revalidate, TRUE);
-}
-
-/**
- * Add a renderbuffer to the framebuffer.
- */
-static boolean
-st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,
-                                gl_buffer_index idx)
-{
-   struct gl_renderbuffer *rb;
-   enum pipe_format format;
-   int samples;
-   boolean sw;
-
-   if (!stfb->iface)
-      return FALSE;
-
-   /* do not distinguish depth/stencil buffers */
-   if (idx == BUFFER_STENCIL)
-      idx = BUFFER_DEPTH;
-
-   switch (idx) {
-   case BUFFER_DEPTH:
-      format = stfb->iface->visual->depth_stencil_format;
-      sw = FALSE;
-      break;
-   case BUFFER_ACCUM:
-      format = stfb->iface->visual->accum_format;
-      sw = TRUE;
-      break;
-   default:
-      format = stfb->iface->visual->color_format;
-      sw = FALSE;
-      break;
-   }
-
-   if (format == PIPE_FORMAT_NONE)
-      return FALSE;
-
-   samples = stfb->iface->visual->samples;
-   if (!samples)
-      samples = st_get_msaa();
-
-   rb = st_new_renderbuffer_fb(format, samples, sw);
-   if (!rb)
-      return FALSE;
-
-   if (idx != BUFFER_DEPTH) {
-      _mesa_add_renderbuffer(&stfb->Base, idx, rb);
-   }
-   else {
-      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0))
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);
-      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1))
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);
-   }
-
-   return TRUE;
-}
-
-/**
- * Intialize a struct gl_config from a visual.
- */
-static void
-st_visual_to_context_mode(const struct st_visual *visual,
-                          struct gl_config *mode)
-{
-   memset(mode, 0, sizeof(*mode));
-
-   if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))
-      mode->doubleBufferMode = GL_TRUE;
-   if (st_visual_have_buffers(visual,
-            ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))
-      mode->stereoMode = GL_TRUE;
-
-   if (visual->color_format != PIPE_FORMAT_NONE) {
-      mode->rgbMode = GL_TRUE;
-
-      mode->redBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 0);
-      mode->greenBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 1);
-      mode->blueBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 2);
-      mode->alphaBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3);
-
-      mode->rgbBits = mode->redBits +
-         mode->greenBits + mode->blueBits + mode->alphaBits;
-   }
-
-   if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {
-      mode->depthBits =
-         util_format_get_component_bits(visual->depth_stencil_format,
-               UTIL_FORMAT_COLORSPACE_ZS, 0);
-      mode->stencilBits =
-         util_format_get_component_bits(visual->depth_stencil_format,
-               UTIL_FORMAT_COLORSPACE_ZS, 1);
-
-      mode->haveDepthBuffer = mode->depthBits > 0;
-      mode->haveStencilBuffer = mode->stencilBits > 0;
-   }
-
-   if (visual->accum_format != PIPE_FORMAT_NONE) {
-      mode->haveAccumBuffer = GL_TRUE;
-
-      mode->accumRedBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 0);
-      mode->accumGreenBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 1);
-      mode->accumBlueBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 2);
-      mode->accumAlphaBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3);
-   }
-
-   if (visual->samples) {
-      mode->sampleBuffers = 1;
-      mode->samples = visual->samples;
-   }
-}
-
-/**
- * Determine the default draw or read buffer from a visual.
- */
-static void
-st_visual_to_default_buffer(const struct st_visual *visual,
-                            GLenum *buffer, GLint *index)
-{
-   enum st_attachment_type statt;
-   GLenum buf;
-   gl_buffer_index idx;
-
-   statt = visual->render_buffer;
-   /* do nothing if an invalid render buffer is specified */
-   if (statt == ST_ATTACHMENT_INVALID ||
-       !st_visual_have_buffers(visual, 1 << statt))
-      return;
-
-   switch (statt) {
-   case ST_ATTACHMENT_FRONT_LEFT:
-      buf = GL_FRONT_LEFT;
-      idx = BUFFER_FRONT_LEFT;
-      break;
-   case ST_ATTACHMENT_BACK_LEFT:
-      buf = GL_BACK_LEFT;
-      idx = BUFFER_BACK_LEFT;
-      break;
-   case ST_ATTACHMENT_FRONT_RIGHT:
-      buf = GL_FRONT_RIGHT;
-      idx = BUFFER_FRONT_RIGHT;
-      break;
-   case ST_ATTACHMENT_BACK_RIGHT:
-      buf = GL_BACK_RIGHT;
-      idx = BUFFER_BACK_RIGHT;
-      break;
-   default:
-      buf = GL_NONE;
-      idx = BUFFER_COUNT;
-      break;
-   }
-
-   if (buf != GL_NONE) {
-      if (buffer)
-         *buffer = buf;
-      if (index)
-         *index = idx;
-   }
-}
-
-/**
- * Create a framebuffer from a manager interface.
- */
-static struct st_framebuffer *
-st_framebuffer_create(struct st_framebuffer_iface *stfbi)
-{
-   struct st_framebuffer *stfb;
-   struct gl_config mode;
-   gl_buffer_index idx;
-
-   if (!stfbi)
-      return NULL;
-
-   stfb = CALLOC_STRUCT(st_framebuffer);
-   if (!stfb)
-      return NULL;
-
-   st_visual_to_context_mode(stfbi->visual, &mode);
-   _mesa_initialize_window_framebuffer(&stfb->Base, &mode);
-
-   /* modify the draw/read buffers of the fb */
-   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorDrawBuffer[0],
-         &stfb->Base._ColorDrawBufferIndexes[0]);
-   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorReadBuffer,
-         &stfb->Base._ColorReadBufferIndex);
-
-   stfb->iface = stfbi;
-
-   /* add the color buffer */
-   idx = stfb->Base._ColorDrawBufferIndexes[0];
-   if (!st_framebuffer_add_renderbuffer(stfb, idx)) {
-      FREE(stfb);
-      return NULL;
-   }
-
-   st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);
-   st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);
-
-   st_framebuffer_update_attachments(stfb);
-
-   stfb->Base.Initialized = GL_TRUE;
-
-   return stfb;
-}
-
-/**
- * Reference a framebuffer.
- */
-static void
-st_framebuffer_reference(struct st_framebuffer **ptr,
-                         struct st_framebuffer *stfb)
-{
-   struct gl_framebuffer *fb = &stfb->Base;
-   _mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);
-}
-
-static void
-st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,
-                                      struct st_framebuffer_iface *stfbi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_framebuffer *stfb;
-
-   /* either draw or read winsys fb */
-   stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
-   if (!stfb || stfb->iface != stfbi)
-      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
-
-   if (stfb && stfb->iface == stfbi) {
-      p_atomic_set(&stfb->revalidate, TRUE);
-   }
-   else {
-      /* This function is probably getting called when we've detected a
-       * change in a window's size but the currently bound context is
-       * not bound to that window.
-       * If the st_framebuffer_iface structure had a pointer to the
-       * corresponding st_framebuffer we'd be able to handle this.
-       */
-   }
-}
-
-static void
-st_context_flush(struct st_context_iface *stctxi, unsigned flags,
-                 struct pipe_fence_handle **fence)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   st_flush(st, flags, fence);
-   if (flags & PIPE_FLUSH_RENDER_CACHE)
-      st_manager_flush_frontbuffer(st);
-}
-
-static boolean
-st_context_teximage(struct st_context_iface *stctxi,
-                    enum st_texture_type target,
-                    int level, enum pipe_format internal_format,
-                    struct pipe_resource *tex, boolean mipmap)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct gl_context *ctx = st->ctx;
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   struct st_texture_object *stObj;
-   struct st_texture_image *stImage;
-   GLenum internalFormat;
-   GLuint width, height, depth;
-
-   switch (target) {
-   case ST_TEXTURE_1D:
-      target = GL_TEXTURE_1D;
-      break;
-   case ST_TEXTURE_2D:
-      target = GL_TEXTURE_2D;
-      break;
-   case ST_TEXTURE_3D:
-      target = GL_TEXTURE_3D;
-      break;
-   case ST_TEXTURE_RECT:
-      target = GL_TEXTURE_RECTANGLE_ARB;
-      break;
-   default:
-      return FALSE;
-      break;
-   }
-
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   _mesa_lock_texture(ctx, texObj);
-
-   stObj = st_texture_object(texObj);
-   /* switch to surface based */
-   if (!stObj->surface_based) {
-      _mesa_clear_texture_object(ctx, texObj);
-      stObj->surface_based = GL_TRUE;
-   }
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-   stImage = st_texture_image(texImage);
-   if (tex) {
-      gl_format texFormat;
-
-      /*
-       * XXX When internal_format and tex->format differ, st_finalize_texture
-       * needs to allocate a new texture with internal_format and copy the
-       * texture here into the new one.  It will result in surface_copy being
-       * called on surfaces whose formats differ.
-       *
-       * To avoid that, internal_format is (wrongly) ignored here.  A sane fix
-       * is to use a sampler view.
-       */
-      if (!st_sampler_compat_formats(tex->format, internal_format))
-	 internal_format = tex->format;
-     
-      if (util_format_get_component_bits(internal_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
-         internalFormat = GL_RGBA;
-      else
-         internalFormat = GL_RGB;
-
-      texFormat = st_ChooseTextureFormat(ctx, internalFormat,
-                                         GL_RGBA, GL_UNSIGNED_BYTE);
-
-      _mesa_init_teximage_fields(ctx, target, texImage,
-                                 tex->width0, tex->height0, 1, 0,
-                                 internalFormat, texFormat);
-
-      width = tex->width0;
-      height = tex->height0;
-      depth = tex->depth0;
-
-      /* grow the image size until we hit level = 0 */
-      while (level > 0) {
-         if (width != 1)
-            width <<= 1;
-         if (height != 1)
-            height <<= 1;
-         if (depth != 1)
-            depth <<= 1;
-         level--;
-      }
-   }
-   else {
-      _mesa_clear_texture_image(ctx, texImage);
-      width = height = depth = 0;
-   }
-
-   pipe_resource_reference(&stImage->pt, tex);
-   stObj->width0 = width;
-   stObj->height0 = height;
-   stObj->depth0 = depth;
-
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
-   _mesa_unlock_texture(ctx, texObj);
-   
-   return TRUE;
-}
-
-static void
-st_context_copy(struct st_context_iface *stctxi,
-                struct st_context_iface *stsrci, unsigned mask)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_context *src = (struct st_context *) stsrci;
-
-   _mesa_copy_context(src->ctx, st->ctx, mask);
-}
-
-static boolean
-st_context_share(struct st_context_iface *stctxi,
-                 struct st_context_iface *stsrci)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_context *src = (struct st_context *) stsrci;
-
-   return _mesa_share_state(st->ctx, src->ctx);
-}
-
-static void
-st_context_destroy(struct st_context_iface *stctxi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   st_destroy_context(st);
-}
-
-static struct st_context_iface *
-st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
-                      const struct st_context_attribs *attribs,
-                      struct st_context_iface *shared_stctxi)
-{
-   struct st_context *shared_ctx = (struct st_context *) shared_stctxi;
-   struct st_context *st;
-   struct pipe_context *pipe;
-   struct gl_config mode;
-   gl_api api;
-
-   if (!(stapi->profile_mask & (1 << attribs->profile)))
-      return NULL;
-
-   switch (attribs->profile) {
-   case ST_PROFILE_DEFAULT:
-      api = API_OPENGL;
-      break;
-   case ST_PROFILE_OPENGL_ES1:
-      api = API_OPENGLES;
-      break;
-   case ST_PROFILE_OPENGL_ES2:
-      api = API_OPENGLES2;
-      break;
-   case ST_PROFILE_OPENGL_CORE:
-   default:
-      return NULL;
-      break;
-   }
-
-   pipe = smapi->screen->context_create(smapi->screen, NULL);
-   if (!pipe)
-      return NULL;
-
-   st_visual_to_context_mode(&attribs->visual, &mode);
-   st = st_create_context(api, pipe, &mode, shared_ctx);
-   if (!st) {
-      pipe->destroy(pipe);
-      return NULL;
-   }
-
-   /* need to perform version check */
-   if (attribs->major > 1 || attribs->minor > 0) {
-      _mesa_compute_version(st->ctx);
-
-      /* is the actual version less than the requested version? */
-      if (st->ctx->VersionMajor * 10 + st->ctx->VersionMinor <
-          attribs->major * 10 + attribs->minor) {
-         st_destroy_context(st);
-         return NULL;
-      }
-   }
-
-   st->invalidate_on_gl_viewport =
-      smapi->get_param(smapi, ST_MANAGER_BROKEN_INVALIDATE);
-
-   st->iface.destroy = st_context_destroy;
-   st->iface.notify_invalid_framebuffer =
-      st_context_notify_invalid_framebuffer;
-   st->iface.flush = st_context_flush;
-   st->iface.teximage = st_context_teximage;
-   st->iface.copy = st_context_copy;
-   st->iface.share = st_context_share;
-   st->iface.st_context_private = (void *) smapi;
-
-   return &st->iface;
-}
-
-static boolean
-st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
-                    struct st_framebuffer_iface *stdrawi,
-                    struct st_framebuffer_iface *streadi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_framebuffer *stdraw, *stread, *stfb;
-   boolean ret;
-
-   _glapi_check_multithread();
-
-   if (st) {
-      /* reuse/create the draw fb */
-      stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
-      if (stfb && stfb->iface == stdrawi) {
-         stdraw = NULL;
-         st_framebuffer_reference(&stdraw, stfb);
-      }
-      else {
-         stdraw = st_framebuffer_create(stdrawi);
-      }
-
-      /* reuse/create the read fb */
-      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
-      if (!stfb || stfb->iface != streadi)
-         stfb = stdraw;
-      if (stfb && stfb->iface == streadi) {
-         stread = NULL;
-         st_framebuffer_reference(&stread, stfb);
-      }
-      else {
-         stread = st_framebuffer_create(streadi);
-      }
-
-      if (stdraw && stread) {
-         st_framebuffer_validate(stdraw, st);
-         if (stread != stdraw)
-            st_framebuffer_validate(stread, st);
-
-         /* modify the draw/read buffers of the context */
-         if (stdraw->iface) {
-            st_visual_to_default_buffer(stdraw->iface->visual,
-                  &st->ctx->Color.DrawBuffer[0], NULL);
-         }
-         if (stread->iface) {
-            st_visual_to_default_buffer(stread->iface->visual,
-                  &st->ctx->Pixel.ReadBuffer, NULL);
-         }
-
-         ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);
-      }
-      else {
-         struct gl_framebuffer *incomplete = _mesa_get_incomplete_framebuffer();
-         ret = _mesa_make_current(st->ctx, incomplete, incomplete);
-      }
-
-      st_framebuffer_reference(&stdraw, NULL);
-      st_framebuffer_reference(&stread, NULL);
-   }
-   else {
-      ret = _mesa_make_current(NULL, NULL, NULL);
-   }
-
-   return ret;
-}
-
-static struct st_context_iface *
-st_api_get_current(struct st_api *stapi)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct st_context *st = (ctx) ? ctx->st : NULL;
-
-   return (st) ? &st->iface : NULL;
-}
-
-static st_proc_t
-st_api_get_proc_address(struct st_api *stapi, const char *procname)
-{
-   return (st_proc_t) _glapi_get_proc_address(procname);
-}
-
-static void
-st_api_destroy(struct st_api *stapi)
-{
-}
-
-/**
- * Flush the front buffer if the current context renders to the front buffer.
- */
-void
-st_manager_flush_frontbuffer(struct st_context *st)
-{
-   struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);
-   struct st_renderbuffer *strb = NULL;
-
-   if (stfb)
-      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-   if (!strb)
-      return;
-
-   /* never a dummy fb */
-   assert(stfb->iface);
-   stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
-}
-
-/**
- * Return the surface of an EGLImage.
- * FIXME: I think this should operate on resources, not surfaces
- */
-struct pipe_surface *
-st_manager_get_egl_image_surface(struct st_context *st,
-                                 void *eglimg, unsigned usage)
-{
-   struct st_manager *smapi =
-      (struct st_manager *) st->iface.st_context_private;
-   struct st_egl_image stimg;
-   struct pipe_surface *ps, surf_tmpl;
-
-   if (!smapi || !smapi->get_egl_image)
-      return NULL;
-
-   memset(&stimg, 0, sizeof(stimg));
-   if (!smapi->get_egl_image(smapi, eglimg, &stimg))
-      return NULL;
-
-   memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-   surf_tmpl.format = stimg.texture->format;
-   surf_tmpl.usage = usage;
-   surf_tmpl.u.tex.level = stimg.level;
-   surf_tmpl.u.tex.first_layer = stimg.layer;
-   surf_tmpl.u.tex.last_layer = stimg.layer;
-   ps = st->pipe->create_surface(st->pipe, stimg.texture, &surf_tmpl);
-   pipe_resource_reference(&stimg.texture, NULL);
-
-   return ps;
-}
-
-/**
- * Re-validate the framebuffers.
- */
-void
-st_manager_validate_framebuffers(struct st_context *st)
-{
-   struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);
-   struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);
-
-   if (stdraw)
-      st_framebuffer_validate(stdraw, st);
-   if (stread && stread != stdraw)
-      st_framebuffer_validate(stread, st);
-}
-
-/**
- * Add a color renderbuffer on demand.
- */
-boolean
-st_manager_add_color_renderbuffer(struct st_context *st,
-                                  struct gl_framebuffer *fb,
-                                  gl_buffer_index idx)
-{
-   struct st_framebuffer *stfb = st_ws_framebuffer(fb);
-
-   /* FBO */
-   if (!stfb)
-      return FALSE;
-
-   if (stfb->Base.Attachment[idx].Renderbuffer)
-      return TRUE;
-
-   switch (idx) {
-   case BUFFER_FRONT_LEFT:
-   case BUFFER_BACK_LEFT:
-   case BUFFER_FRONT_RIGHT:
-   case BUFFER_BACK_RIGHT:
-      break;
-   default:
-      return FALSE;
-      break;
-   }
-
-   if (!st_framebuffer_add_renderbuffer(stfb, idx))
-      return FALSE;
-
-   st_framebuffer_update_attachments(stfb);
-   st_invalidate_state(st->ctx, _NEW_BUFFERS);
-
-   return TRUE;
-}
-
-static const struct st_api st_gl_api = {
-   "Mesa " MESA_VERSION_STRING,
-   ST_API_OPENGL,
-#if FEATURE_GL
-   ST_PROFILE_DEFAULT_MASK |
-#endif
-#if FEATURE_ES1
-   ST_PROFILE_OPENGL_ES1_MASK |
-#endif
-#if FEATURE_ES2
-   ST_PROFILE_OPENGL_ES2_MASK |
-#endif
-   0,
-   st_api_destroy,
-   st_api_get_proc_address,
-   st_api_create_context,
-   st_api_make_current,
-   st_api_get_current,
-};
-
-struct st_api *
-st_gl_api_create(void)
-{
-   return (struct st_api *) &st_gl_api;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.9

+ *

+ * Copyright (C) 2010 LunarG Inc.

+ *

+ * 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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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:

+ *    Chia-I Wu <olv@lunarg.com>

+ */

+

+#include "state_tracker/st_gl_api.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_screen.h"

+#include "util/u_format.h"

+#include "util/u_pointer.h"

+#include "util/u_inlines.h"

+#include "util/u_atomic.h"

+#include "util/u_surface.h"

+

+#include "main/mtypes.h"

+#include "main/context.h"

+#include "main/mfeatures.h"

+#include "main/texobj.h"

+#include "main/teximage.h"

+#include "main/texstate.h"

+#include "main/framebuffer.h"

+#include "main/fbobject.h"

+#include "main/renderbuffer.h"

+#include "main/version.h"

+#include "st_texture.h"

+

+#include "st_context.h"

+#include "st_format.h"

+#include "st_cb_fbo.h"

+#include "st_cb_flush.h"

+#include "st_manager.h"

+

+/**

+ * Cast wrapper to convert a struct gl_framebuffer to an st_framebuffer.

+ * Return NULL if the struct gl_framebuffer is a user-created framebuffer.

+ * We'll only return non-null for window system framebuffers.

+ * Note that this function may fail.

+ */

+static INLINE struct st_framebuffer *

+st_ws_framebuffer(struct gl_framebuffer *fb)

+{

+   /* FBO cannot be casted.  See st_new_framebuffer */

+   return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL);

+}

+

+/**

+ * Map an attachment to a buffer index.

+ */

+static INLINE gl_buffer_index

+attachment_to_buffer_index(enum st_attachment_type statt)

+{

+   gl_buffer_index index;

+

+   switch (statt) {

+   case ST_ATTACHMENT_FRONT_LEFT:

+      index = BUFFER_FRONT_LEFT;

+      break;

+   case ST_ATTACHMENT_BACK_LEFT:

+      index = BUFFER_BACK_LEFT;

+      break;

+   case ST_ATTACHMENT_FRONT_RIGHT:

+      index = BUFFER_FRONT_RIGHT;

+      break;

+   case ST_ATTACHMENT_BACK_RIGHT:

+      index = BUFFER_BACK_RIGHT;

+      break;

+   case ST_ATTACHMENT_DEPTH_STENCIL:

+      index = BUFFER_DEPTH;

+      break;

+   case ST_ATTACHMENT_ACCUM:

+      index = BUFFER_ACCUM;

+      break;

+   case ST_ATTACHMENT_SAMPLE:

+   default:

+      index = BUFFER_COUNT;

+      break;

+   }

+

+   return index;

+}

+

+/**

+ * Map a buffer index to an attachment.

+ */

+static INLINE enum st_attachment_type

+buffer_index_to_attachment(gl_buffer_index index)

+{

+   enum st_attachment_type statt;

+

+   switch (index) {

+   case BUFFER_FRONT_LEFT:

+      statt = ST_ATTACHMENT_FRONT_LEFT;

+      break;

+   case BUFFER_BACK_LEFT:

+      statt = ST_ATTACHMENT_BACK_LEFT;

+      break;

+   case BUFFER_FRONT_RIGHT:

+      statt = ST_ATTACHMENT_FRONT_RIGHT;

+      break;

+   case BUFFER_BACK_RIGHT:

+      statt = ST_ATTACHMENT_BACK_RIGHT;

+      break;

+   case BUFFER_DEPTH:

+      statt = ST_ATTACHMENT_DEPTH_STENCIL;

+      break;

+   case BUFFER_ACCUM:

+      statt = ST_ATTACHMENT_ACCUM;

+      break;

+   default:

+      statt = ST_ATTACHMENT_INVALID;

+      break;

+   }

+

+   return statt;

+}

+

+/**

+ * Validate a framebuffer to make sure up-to-date pipe_textures are used.

+ */

+static void

+st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];

+   uint width, height;

+   unsigned i;

+   boolean changed = FALSE;

+

+   if (!p_atomic_read(&stfb->revalidate))

+      return;

+

+   /* validate the fb */

+   if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))

+      return;

+

+   width = stfb->Base.Width;

+   height = stfb->Base.Height;

+

+   for (i = 0; i < stfb->num_statts; i++) {

+      struct st_renderbuffer *strb;

+      struct pipe_surface *ps, surf_tmpl;

+      gl_buffer_index idx;

+

+      if (!textures[i])

+         continue;

+

+      idx = attachment_to_buffer_index(stfb->statts[i]);

+      if (idx >= BUFFER_COUNT) {

+         pipe_resource_reference(&textures[i], NULL);

+         continue;

+      }

+

+      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);

+      assert(strb);

+      if (strb->texture == textures[i]) {

+         pipe_resource_reference(&textures[i], NULL);

+         continue;

+      }

+

+      memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+      u_surface_default_template(&surf_tmpl, textures[i],

+                                 PIPE_BIND_RENDER_TARGET);

+      ps = pipe->create_surface(pipe, textures[i], &surf_tmpl);

+      if (ps) {

+         pipe_surface_reference(&strb->surface, ps);

+         pipe_resource_reference(&strb->texture, ps->texture);

+         /* ownership transfered */

+         pipe_surface_reference(&ps, NULL);

+

+         changed = TRUE;

+

+         strb->Base.Width = strb->surface->width;

+         strb->Base.Height = strb->surface->height;

+

+         width = strb->Base.Width;

+         height = strb->Base.Height;

+      }

+

+      pipe_resource_reference(&textures[i], NULL);

+   }

+

+   if (changed) {

+      st->dirty.st |= ST_NEW_FRAMEBUFFER;

+      _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);

+

+      assert(stfb->Base.Width == width);

+      assert(stfb->Base.Height == height);

+   }

+

+   p_atomic_set(&stfb->revalidate, FALSE);

+}

+

+/**

+ * Update the attachments to validate by looping the existing renderbuffers.

+ */

+static void

+st_framebuffer_update_attachments(struct st_framebuffer *stfb)

+{

+   gl_buffer_index idx;

+

+   stfb->num_statts = 0;

+   for (idx = 0; idx < BUFFER_COUNT; idx++) {

+      struct st_renderbuffer *strb;

+      enum st_attachment_type statt;

+

+      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);

+      if (!strb || strb->software)

+         continue;

+

+      statt = buffer_index_to_attachment(idx);

+      if (statt != ST_ATTACHMENT_INVALID &&

+          st_visual_have_buffers(stfb->iface->visual, 1 << statt))

+         stfb->statts[stfb->num_statts++] = statt;

+   }

+

+   p_atomic_set(&stfb->revalidate, TRUE);

+}

+

+/**

+ * Add a renderbuffer to the framebuffer.

+ */

+static boolean

+st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,

+                                gl_buffer_index idx)

+{

+   struct gl_renderbuffer *rb;

+   enum pipe_format format;

+   int samples;

+   boolean sw;

+

+   if (!stfb->iface)

+      return FALSE;

+

+   /* do not distinguish depth/stencil buffers */

+   if (idx == BUFFER_STENCIL)

+      idx = BUFFER_DEPTH;

+

+   switch (idx) {

+   case BUFFER_DEPTH:

+      format = stfb->iface->visual->depth_stencil_format;

+      sw = FALSE;

+      break;

+   case BUFFER_ACCUM:

+      format = stfb->iface->visual->accum_format;

+      sw = TRUE;

+      break;

+   default:

+      format = stfb->iface->visual->color_format;

+      sw = FALSE;

+      break;

+   }

+

+   if (format == PIPE_FORMAT_NONE)

+      return FALSE;

+

+   samples = stfb->iface->visual->samples;

+   if (!samples)

+      samples = st_get_msaa();

+

+   rb = st_new_renderbuffer_fb(format, samples, sw);

+   if (!rb)

+      return FALSE;

+

+   if (idx != BUFFER_DEPTH) {

+      _mesa_add_renderbuffer(&stfb->Base, idx, rb);

+   }

+   else {

+      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0))

+         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);

+      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1))

+         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);

+   }

+

+   return TRUE;

+}

+

+/**

+ * Intialize a struct gl_config from a visual.

+ */

+static void

+st_visual_to_context_mode(const struct st_visual *visual,

+                          struct gl_config *mode)

+{

+   memset(mode, 0, sizeof(*mode));

+

+   if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))

+      mode->doubleBufferMode = GL_TRUE;

+   if (st_visual_have_buffers(visual,

+            ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))

+      mode->stereoMode = GL_TRUE;

+

+   if (visual->color_format != PIPE_FORMAT_NONE) {

+      mode->rgbMode = GL_TRUE;

+

+      mode->redBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 0);

+      mode->greenBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 1);

+      mode->blueBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 2);

+      mode->alphaBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3);

+

+      mode->rgbBits = mode->redBits +

+         mode->greenBits + mode->blueBits + mode->alphaBits;

+   }

+

+   if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {

+      mode->depthBits =

+         util_format_get_component_bits(visual->depth_stencil_format,

+               UTIL_FORMAT_COLORSPACE_ZS, 0);

+      mode->stencilBits =

+         util_format_get_component_bits(visual->depth_stencil_format,

+               UTIL_FORMAT_COLORSPACE_ZS, 1);

+

+      mode->haveDepthBuffer = mode->depthBits > 0;

+      mode->haveStencilBuffer = mode->stencilBits > 0;

+   }

+

+   if (visual->accum_format != PIPE_FORMAT_NONE) {

+      mode->haveAccumBuffer = GL_TRUE;

+

+      mode->accumRedBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 0);

+      mode->accumGreenBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 1);

+      mode->accumBlueBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 2);

+      mode->accumAlphaBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3);

+   }

+

+   if (visual->samples) {

+      mode->sampleBuffers = 1;

+      mode->samples = visual->samples;

+   }

+}

+

+/**

+ * Determine the default draw or read buffer from a visual.

+ */

+static void

+st_visual_to_default_buffer(const struct st_visual *visual,

+                            GLenum *buffer, GLint *index)

+{

+   enum st_attachment_type statt;

+   GLenum buf;

+   gl_buffer_index idx;

+

+   statt = visual->render_buffer;

+   /* do nothing if an invalid render buffer is specified */

+   if (statt == ST_ATTACHMENT_INVALID ||

+       !st_visual_have_buffers(visual, 1 << statt))

+      return;

+

+   switch (statt) {

+   case ST_ATTACHMENT_FRONT_LEFT:

+      buf = GL_FRONT_LEFT;

+      idx = BUFFER_FRONT_LEFT;

+      break;

+   case ST_ATTACHMENT_BACK_LEFT:

+      buf = GL_BACK_LEFT;

+      idx = BUFFER_BACK_LEFT;

+      break;

+   case ST_ATTACHMENT_FRONT_RIGHT:

+      buf = GL_FRONT_RIGHT;

+      idx = BUFFER_FRONT_RIGHT;

+      break;

+   case ST_ATTACHMENT_BACK_RIGHT:

+      buf = GL_BACK_RIGHT;

+      idx = BUFFER_BACK_RIGHT;

+      break;

+   default:

+      buf = GL_NONE;

+      idx = BUFFER_COUNT;

+      break;

+   }

+

+   if (buf != GL_NONE) {

+      if (buffer)

+         *buffer = buf;

+      if (index)

+         *index = idx;

+   }

+}

+

+/**

+ * Create a framebuffer from a manager interface.

+ */

+static struct st_framebuffer *

+st_framebuffer_create(struct st_framebuffer_iface *stfbi)

+{

+   struct st_framebuffer *stfb;

+   struct gl_config mode;

+   gl_buffer_index idx;

+

+   if (!stfbi)

+      return NULL;

+

+   stfb = CALLOC_STRUCT(st_framebuffer);

+   if (!stfb)

+      return NULL;

+

+   st_visual_to_context_mode(stfbi->visual, &mode);

+   _mesa_initialize_window_framebuffer(&stfb->Base, &mode);

+

+   /* modify the draw/read buffers of the fb */

+   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorDrawBuffer[0],

+         &stfb->Base._ColorDrawBufferIndexes[0]);

+   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorReadBuffer,

+         &stfb->Base._ColorReadBufferIndex);

+

+   stfb->iface = stfbi;

+

+   /* add the color buffer */

+   idx = stfb->Base._ColorDrawBufferIndexes[0];

+   if (!st_framebuffer_add_renderbuffer(stfb, idx)) {

+      FREE(stfb);

+      return NULL;

+   }

+

+   st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);

+   st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);

+

+   st_framebuffer_update_attachments(stfb);

+

+   stfb->Base.Initialized = GL_TRUE;

+

+   return stfb;

+}

+

+/**

+ * Reference a framebuffer.

+ */

+static void

+st_framebuffer_reference(struct st_framebuffer **ptr,

+                         struct st_framebuffer *stfb)

+{

+   struct gl_framebuffer *fb = &stfb->Base;

+   _mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);

+}

+

+static void

+st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,

+                                      struct st_framebuffer_iface *stfbi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_framebuffer *stfb;

+

+   /* either draw or read winsys fb */

+   stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);

+   if (!stfb || stfb->iface != stfbi)

+      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);

+

+   if (stfb && stfb->iface == stfbi) {

+      p_atomic_set(&stfb->revalidate, TRUE);

+   }

+   else {

+      /* This function is probably getting called when we've detected a

+       * change in a window's size but the currently bound context is

+       * not bound to that window.

+       * If the st_framebuffer_iface structure had a pointer to the

+       * corresponding st_framebuffer we'd be able to handle this.

+       */

+   }

+}

+

+static void

+st_context_flush(struct st_context_iface *stctxi, unsigned flags,

+                 struct pipe_fence_handle **fence)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   st_flush(st, flags, fence);

+   if (flags & PIPE_FLUSH_RENDER_CACHE)

+      st_manager_flush_frontbuffer(st);

+}

+

+static boolean

+st_context_teximage(struct st_context_iface *stctxi,

+                    enum st_texture_type target,

+                    int level, enum pipe_format internal_format,

+                    struct pipe_resource *tex, boolean mipmap)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct gl_context *ctx = st->ctx;

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   struct st_texture_object *stObj;

+   struct st_texture_image *stImage;

+   GLenum internalFormat;

+   GLuint width, height, depth;

+

+   switch (target) {

+   case ST_TEXTURE_1D:

+      target = GL_TEXTURE_1D;

+      break;

+   case ST_TEXTURE_2D:

+      target = GL_TEXTURE_2D;

+      break;

+   case ST_TEXTURE_3D:

+      target = GL_TEXTURE_3D;

+      break;

+   case ST_TEXTURE_RECT:

+      target = GL_TEXTURE_RECTANGLE_ARB;

+      break;

+   default:

+      return FALSE;

+      break;

+   }

+

+   texObj = _mesa_select_tex_object(ctx, texUnit, target);

+   _mesa_lock_texture(ctx, texObj);

+

+   stObj = st_texture_object(texObj);

+   /* switch to surface based */

+   if (!stObj->surface_based) {

+      _mesa_clear_texture_object(ctx, texObj);

+      stObj->surface_based = GL_TRUE;

+   }

+

+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+   stImage = st_texture_image(texImage);

+   if (tex) {

+      gl_format texFormat;

+

+      /*

+       * XXX When internal_format and tex->format differ, st_finalize_texture

+       * needs to allocate a new texture with internal_format and copy the

+       * texture here into the new one.  It will result in surface_copy being

+       * called on surfaces whose formats differ.

+       *

+       * To avoid that, internal_format is (wrongly) ignored here.  A sane fix

+       * is to use a sampler view.

+       */

+      if (!st_sampler_compat_formats(tex->format, internal_format))

+	 internal_format = tex->format;

+     

+      if (util_format_get_component_bits(internal_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)

+         internalFormat = GL_RGBA;

+      else

+         internalFormat = GL_RGB;

+

+      texFormat = st_ChooseTextureFormat(ctx, internalFormat,

+                                         GL_RGBA, GL_UNSIGNED_BYTE);

+

+      _mesa_init_teximage_fields(ctx, target, texImage,

+                                 tex->width0, tex->height0, 1, 0,

+                                 internalFormat, texFormat);

+

+      width = tex->width0;

+      height = tex->height0;

+      depth = tex->depth0;

+

+      /* grow the image size until we hit level = 0 */

+      while (level > 0) {

+         if (width != 1)

+            width <<= 1;

+         if (height != 1)

+            height <<= 1;

+         if (depth != 1)

+            depth <<= 1;

+         level--;

+      }

+   }

+   else {

+      _mesa_clear_texture_image(ctx, texImage);

+      width = height = depth = 0;

+   }

+

+   pipe_resource_reference(&stImage->pt, tex);

+   stObj->width0 = width;

+   stObj->height0 = height;

+   stObj->depth0 = depth;

+

+   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);

+   _mesa_unlock_texture(ctx, texObj);

+   

+   return TRUE;

+}

+

+static void

+st_context_copy(struct st_context_iface *stctxi,

+                struct st_context_iface *stsrci, unsigned mask)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_context *src = (struct st_context *) stsrci;

+

+   _mesa_copy_context(src->ctx, st->ctx, mask);

+}

+

+static boolean

+st_context_share(struct st_context_iface *stctxi,

+                 struct st_context_iface *stsrci)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_context *src = (struct st_context *) stsrci;

+

+   return _mesa_share_state(st->ctx, src->ctx);

+}

+

+static void

+st_context_destroy(struct st_context_iface *stctxi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   st_destroy_context(st);

+}

+

+static struct st_context_iface *

+st_api_create_context(struct st_api *stapi, struct st_manager *smapi,

+                      const struct st_context_attribs *attribs,

+                      struct st_context_iface *shared_stctxi)

+{

+   struct st_context *shared_ctx = (struct st_context *) shared_stctxi;

+   struct st_context *st;

+   struct pipe_context *pipe;

+   struct gl_config mode;

+   gl_api api;

+

+   if (!(stapi->profile_mask & (1 << attribs->profile)))

+      return NULL;

+

+   switch (attribs->profile) {

+   case ST_PROFILE_DEFAULT:

+      api = API_OPENGL;

+      break;

+   case ST_PROFILE_OPENGL_ES1:

+      api = API_OPENGLES;

+      break;

+   case ST_PROFILE_OPENGL_ES2:

+      api = API_OPENGLES2;

+      break;

+   case ST_PROFILE_OPENGL_CORE:

+   default:

+      return NULL;

+      break;

+   }

+

+   pipe = smapi->screen->context_create(smapi->screen, NULL);

+   if (!pipe)

+      return NULL;

+

+   st_visual_to_context_mode(&attribs->visual, &mode);

+   st = st_create_context(api, pipe, &mode, shared_ctx);

+   if (!st) {

+      pipe->destroy(pipe);

+      return NULL;

+   }

+

+   /* need to perform version check */

+   if (attribs->major > 1 || attribs->minor > 0) {

+      _mesa_compute_version(st->ctx);

+

+      /* is the actual version less than the requested version? */

+      if (st->ctx->VersionMajor * 10 + st->ctx->VersionMinor <

+          attribs->major * 10 + attribs->minor) {

+         st_destroy_context(st);

+         return NULL;

+      }

+   }

+

+   st->invalidate_on_gl_viewport =

+      smapi->get_param(smapi, ST_MANAGER_BROKEN_INVALIDATE);

+

+   st->iface.destroy = st_context_destroy;

+   st->iface.notify_invalid_framebuffer =

+      st_context_notify_invalid_framebuffer;

+   st->iface.flush = st_context_flush;

+   st->iface.teximage = st_context_teximage;

+   st->iface.copy = st_context_copy;

+   st->iface.share = st_context_share;

+   st->iface.st_context_private = (void *) smapi;

+

+   return &st->iface;

+}

+

+static boolean

+st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,

+                    struct st_framebuffer_iface *stdrawi,

+                    struct st_framebuffer_iface *streadi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_framebuffer *stdraw, *stread, *stfb;

+   boolean ret;

+

+   _glapi_check_multithread();

+

+   if (st) {

+      /* reuse/create the draw fb */

+      stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);

+      if (stfb && stfb->iface == stdrawi) {

+         stdraw = NULL;

+         st_framebuffer_reference(&stdraw, stfb);

+      }

+      else {

+         stdraw = st_framebuffer_create(stdrawi);

+      }

+

+      /* reuse/create the read fb */

+      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);

+      if (!stfb || stfb->iface != streadi)

+         stfb = stdraw;

+      if (stfb && stfb->iface == streadi) {

+         stread = NULL;

+         st_framebuffer_reference(&stread, stfb);

+      }

+      else {

+         stread = st_framebuffer_create(streadi);

+      }

+

+      if (stdraw && stread) {

+         st_framebuffer_validate(stdraw, st);

+         if (stread != stdraw)

+            st_framebuffer_validate(stread, st);

+

+         /* modify the draw/read buffers of the context */

+         if (stdraw->iface) {

+            st_visual_to_default_buffer(stdraw->iface->visual,

+                  &st->ctx->Color.DrawBuffer[0], NULL);

+         }

+         if (stread->iface) {

+            st_visual_to_default_buffer(stread->iface->visual,

+                  &st->ctx->Pixel.ReadBuffer, NULL);

+         }

+

+         ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);

+      }

+      else {

+         struct gl_framebuffer *incomplete = _mesa_get_incomplete_framebuffer();

+         ret = _mesa_make_current(st->ctx, incomplete, incomplete);

+      }

+

+      st_framebuffer_reference(&stdraw, NULL);

+      st_framebuffer_reference(&stread, NULL);

+   }

+   else {

+      ret = _mesa_make_current(NULL, NULL, NULL);

+   }

+

+   return ret;

+}

+

+static struct st_context_iface *

+st_api_get_current(struct st_api *stapi)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct st_context *st = (ctx) ? ctx->st : NULL;

+

+   return (st) ? &st->iface : NULL;

+}

+

+static st_proc_t

+st_api_get_proc_address(struct st_api *stapi, const char *procname)

+{

+   return (st_proc_t) _glapi_get_proc_address(procname);

+}

+

+static void

+st_api_destroy(struct st_api *stapi)

+{

+}

+

+/**

+ * Flush the front buffer if the current context renders to the front buffer.

+ */

+void

+st_manager_flush_frontbuffer(struct st_context *st)

+{

+   struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);

+   struct st_renderbuffer *strb = NULL;

+

+   if (stfb)

+      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+   if (!strb)

+      return;

+

+   /* never a dummy fb */

+   assert(stfb->iface);

+   stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);

+}

+

+/**

+ * Return the surface of an EGLImage.

+ * FIXME: I think this should operate on resources, not surfaces

+ */

+struct pipe_surface *

+st_manager_get_egl_image_surface(struct st_context *st,

+                                 void *eglimg, unsigned usage)

+{

+   struct st_manager *smapi =

+      (struct st_manager *) st->iface.st_context_private;

+   struct st_egl_image stimg;

+   struct pipe_surface *ps, surf_tmpl;

+

+   if (!smapi || !smapi->get_egl_image)

+      return NULL;

+

+   memset(&stimg, 0, sizeof(stimg));

+   if (!smapi->get_egl_image(smapi, eglimg, &stimg))

+      return NULL;

+

+   memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+   surf_tmpl.format = stimg.texture->format;

+   surf_tmpl.usage = usage;

+   surf_tmpl.u.tex.level = stimg.level;

+   surf_tmpl.u.tex.first_layer = stimg.layer;

+   surf_tmpl.u.tex.last_layer = stimg.layer;

+   ps = st->pipe->create_surface(st->pipe, stimg.texture, &surf_tmpl);

+   pipe_resource_reference(&stimg.texture, NULL);

+

+   return ps;

+}

+

+/**

+ * Re-validate the framebuffers.

+ */

+void

+st_manager_validate_framebuffers(struct st_context *st)

+{

+   struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);

+   struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);

+

+   if (stdraw)

+      st_framebuffer_validate(stdraw, st);

+   if (stread && stread != stdraw)

+      st_framebuffer_validate(stread, st);

+}

+

+/**

+ * Add a color renderbuffer on demand.

+ */

+boolean

+st_manager_add_color_renderbuffer(struct st_context *st,

+                                  struct gl_framebuffer *fb,

+                                  gl_buffer_index idx)

+{

+   struct st_framebuffer *stfb = st_ws_framebuffer(fb);

+

+   /* FBO */

+   if (!stfb)

+      return FALSE;

+

+   if (stfb->Base.Attachment[idx].Renderbuffer)

+      return TRUE;

+

+   switch (idx) {

+   case BUFFER_FRONT_LEFT:

+   case BUFFER_BACK_LEFT:

+   case BUFFER_FRONT_RIGHT:

+   case BUFFER_BACK_RIGHT:

+      break;

+   default:

+      return FALSE;

+      break;

+   }

+

+   if (!st_framebuffer_add_renderbuffer(stfb, idx))

+      return FALSE;

+

+   st_framebuffer_update_attachments(stfb);

+   st_invalidate_state(st->ctx, _NEW_BUFFERS);

+

+   return TRUE;

+}

+

+static const struct st_api st_gl_api = {

+   "Mesa " MESA_VERSION_STRING,

+   ST_API_OPENGL,

+#if FEATURE_GL

+   ST_PROFILE_DEFAULT_MASK |

+#endif

+#if FEATURE_ES1

+   ST_PROFILE_OPENGL_ES1_MASK |

+#endif

+#if FEATURE_ES2

+   ST_PROFILE_OPENGL_ES2_MASK |

+#endif

+   0,

+   st_api_destroy,

+   st_api_get_proc_address,

+   st_api_create_context,

+   st_api_make_current,

+   st_api_get_current,

+};

+

+struct st_api *

+st_gl_api_create(void)

+{

+   return (struct st_api *) &st_gl_api;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c b/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c
index c07739f9d..bf0bfd6df 100644
--- a/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/mesalib/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -1,1249 +1,1249 @@
-/**************************************************************************
- * 
- * Copyright 2007-2008 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-/*
- * \author
- * Michal Krol,
- * Keith Whitwell
- */
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "pipe/p_shader_tokens.h"
-#include "pipe/p_state.h"
-#include "tgsi/tgsi_ureg.h"
-#include "st_mesa_to_tgsi.h"
-#include "st_context.h"
-#include "program/prog_instruction.h"
-#include "program/prog_parameter.h"
-#include "util/u_debug.h"
-#include "util/u_math.h"
-#include "util/u_memory.h"
-
-
-#define PROGRAM_ANY_CONST ((1 << PROGRAM_LOCAL_PARAM) |  \
-                           (1 << PROGRAM_ENV_PARAM) |    \
-                           (1 << PROGRAM_STATE_VAR) |    \
-                           (1 << PROGRAM_NAMED_PARAM) |  \
-                           (1 << PROGRAM_CONSTANT) |     \
-                           (1 << PROGRAM_UNIFORM))
-
-
-struct label {
-   unsigned branch_target;
-   unsigned token;
-};
-
-
-/**
- * Intermediate state used during shader translation.
- */
-struct st_translate {
-   struct ureg_program *ureg;
-
-   struct ureg_dst temps[MAX_PROGRAM_TEMPS];
-   struct ureg_src *constants;
-   struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS];
-   struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS];
-   struct ureg_dst address[1];
-   struct ureg_src samplers[PIPE_MAX_SAMPLERS];
-   struct ureg_src systemValues[SYSTEM_VALUE_MAX];
-
-   /* Extra info for handling point size clamping in vertex shader */
-   struct ureg_dst pointSizeResult; /**< Actual point size output register */
-   struct ureg_src pointSizeConst;  /**< Point size range constant register */
-   GLint pointSizeOutIndex;         /**< Temp point size output register */
-   GLboolean prevInstWrotePointSize;
-
-   const GLuint *inputMapping;
-   const GLuint *outputMapping;
-
-   /* For every instruction that contains a label (eg CALL), keep
-    * details so that we can go back afterwards and emit the correct
-    * tgsi instruction number for each label.
-    */
-   struct label *labels;
-   unsigned labels_size;
-   unsigned labels_count;
-
-   /* Keep a record of the tgsi instruction number that each mesa
-    * instruction starts at, will be used to fix up labels after
-    * translation.
-    */
-   unsigned *insn;
-   unsigned insn_size;
-   unsigned insn_count;
-
-   unsigned procType;  /**< TGSI_PROCESSOR_VERTEX/FRAGMENT */
-
-   boolean error;
-};
-
-
-/** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */
-static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = {
-   TGSI_SEMANTIC_FACE,
-   TGSI_SEMANTIC_INSTANCEID
-};
-
-
-/**
- * Make note of a branch to a label in the TGSI code.
- * After we've emitted all instructions, we'll go over the list
- * of labels built here and patch the TGSI code with the actual
- * location of each label.
- */
-static unsigned *get_label( struct st_translate *t,
-                            unsigned branch_target )
-{
-   unsigned i;
-
-   if (t->labels_count + 1 >= t->labels_size) {
-      unsigned old_size = t->labels_size;
-      t->labels_size = 1 << (util_logbase2(t->labels_size) + 1);
-      t->labels = REALLOC( t->labels, 
-                           old_size * sizeof t->labels[0], 
-                           t->labels_size * sizeof t->labels[0] );
-      if (t->labels == NULL) {
-         static unsigned dummy;
-         t->error = TRUE;
-         return &dummy;
-      }
-   }
-
-   i = t->labels_count++;
-   t->labels[i].branch_target = branch_target;
-   return &t->labels[i].token;
-}
-
-
-/**
- * Called prior to emitting the TGSI code for each Mesa instruction.
- * Allocate additional space for instructions if needed.
- * Update the insn[] array so the next Mesa instruction points to
- * the next TGSI instruction.
- */
-static void set_insn_start( struct st_translate *t,
-                            unsigned start )
-{
-   if (t->insn_count + 1 >= t->insn_size) {
-      unsigned old_size = t->insn_size;
-      t->insn_size = 1 << (util_logbase2(t->insn_size) + 1);
-      t->insn = REALLOC( t->insn, 
-                         old_size * sizeof t->insn[0], 
-                         t->insn_size * sizeof t->insn[0] );
-      if (t->insn == NULL) {
-         t->error = TRUE;
-         return;
-      }
-   }
-
-   t->insn[t->insn_count++] = start;
-}
-
-
-/**
- * Map a Mesa dst register to a TGSI ureg_dst register.
- */
-static struct ureg_dst
-dst_register( struct st_translate *t,
-              gl_register_file file,
-              GLuint index )
-{
-   switch( file ) {
-   case PROGRAM_UNDEFINED:
-      return ureg_dst_undef();
-
-   case PROGRAM_TEMPORARY:
-      if (ureg_dst_is_undef(t->temps[index]))
-         t->temps[index] = ureg_DECL_temporary( t->ureg );
-
-      return t->temps[index];
-
-   case PROGRAM_OUTPUT:
-      if (t->procType == TGSI_PROCESSOR_VERTEX && index == VERT_RESULT_PSIZ)
-         t->prevInstWrotePointSize = GL_TRUE;
-
-      if (t->procType == TGSI_PROCESSOR_VERTEX)
-         assert(index < VERT_RESULT_MAX);
-      else if (t->procType == TGSI_PROCESSOR_FRAGMENT)
-         assert(index < FRAG_RESULT_MAX);
-      else
-         assert(index < GEOM_RESULT_MAX);
-
-      assert(t->outputMapping[index] < Elements(t->outputs));
-
-      return t->outputs[t->outputMapping[index]];
-
-   case PROGRAM_ADDRESS:
-      return t->address[index];
-
-   default:
-      debug_assert( 0 );
-      return ureg_dst_undef();
-   }
-}
-
-
-/**
- * Map a Mesa src register to a TGSI ureg_src register.
- */
-static struct ureg_src
-src_register( struct st_translate *t,
-              gl_register_file file,
-              GLint index )
-{
-   switch( file ) {
-   case PROGRAM_UNDEFINED:
-      return ureg_src_undef();
-
-   case PROGRAM_TEMPORARY:
-      assert(index >= 0);
-      assert(index < Elements(t->temps));
-      if (ureg_dst_is_undef(t->temps[index]))
-         t->temps[index] = ureg_DECL_temporary( t->ureg );
-      return ureg_src(t->temps[index]);
-
-   case PROGRAM_NAMED_PARAM:
-   case PROGRAM_ENV_PARAM:
-   case PROGRAM_LOCAL_PARAM:
-   case PROGRAM_UNIFORM:
-      assert(index >= 0);
-      return t->constants[index];
-   case PROGRAM_STATE_VAR:
-   case PROGRAM_CONSTANT:       /* ie, immediate */
-      if (index < 0)
-         return ureg_DECL_constant( t->ureg, 0 );
-      else
-         return t->constants[index];
-
-   case PROGRAM_INPUT:
-      assert(t->inputMapping[index] < Elements(t->inputs));
-      return t->inputs[t->inputMapping[index]];
-
-   case PROGRAM_OUTPUT:
-      assert(t->outputMapping[index] < Elements(t->outputs));
-      return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */
-
-   case PROGRAM_ADDRESS:
-      return ureg_src(t->address[index]);
-
-   case PROGRAM_SYSTEM_VALUE:
-      assert(index < Elements(t->systemValues));
-      return t->systemValues[index];
-
-   default:
-      debug_assert( 0 );
-      return ureg_src_undef();
-   }
-}
-
-
-/**
- * Map mesa texture target to TGSI texture target.
- */
-static unsigned
-translate_texture_target( GLuint textarget,
-                          GLboolean shadow )
-{
-   if (shadow) {
-      switch( textarget ) {
-      case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_SHADOW1D;
-      case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_SHADOW2D;
-      case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_SHADOWRECT;
-      default: break;
-      }
-   }
-
-   switch( textarget ) {
-   case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_1D;
-   case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_2D;
-   case TEXTURE_3D_INDEX:   return TGSI_TEXTURE_3D;
-   case TEXTURE_CUBE_INDEX: return TGSI_TEXTURE_CUBE;
-   case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_RECT;
-   case TEXTURE_1D_ARRAY_INDEX:   return TGSI_TEXTURE_1D_ARRAY;
-   case TEXTURE_2D_ARRAY_INDEX:   return TGSI_TEXTURE_2D_ARRAY;
-   default:
-      debug_assert( 0 );
-      return TGSI_TEXTURE_1D;
-   }
-}
-
-
-/**
- * Create a TGSI ureg_dst register from a Mesa dest register.
- */
-static struct ureg_dst
-translate_dst( struct st_translate *t,
-               const struct prog_dst_register *DstReg,
-               boolean saturate )
-{
-   struct ureg_dst dst = dst_register( t, 
-                                       DstReg->File,
-                                       DstReg->Index );
-
-   dst = ureg_writemask( dst, 
-                         DstReg->WriteMask );
-   
-   if (saturate)
-      dst = ureg_saturate( dst );
-
-   if (DstReg->RelAddr)
-      dst = ureg_dst_indirect( dst, ureg_src(t->address[0]) );
-
-   return dst;
-}
-
-
-/**
- * Create a TGSI ureg_src register from a Mesa src register.
- */
-static struct ureg_src
-translate_src( struct st_translate *t,
-               const struct prog_src_register *SrcReg )
-{
-   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );
-
-   if (t->procType == TGSI_PROCESSOR_GEOMETRY && SrcReg->HasIndex2) {
-      src = src_register( t, SrcReg->File, SrcReg->Index2 );
-      if (SrcReg->RelAddr2)
-         src = ureg_src_dimension_indirect( src, ureg_src(t->address[0]),
-                                            SrcReg->Index);
-      else
-         src = ureg_src_dimension( src, SrcReg->Index);
-   }
-
-   src = ureg_swizzle( src,
-                       GET_SWZ( SrcReg->Swizzle, 0 ) & 0x3,
-                       GET_SWZ( SrcReg->Swizzle, 1 ) & 0x3,
-                       GET_SWZ( SrcReg->Swizzle, 2 ) & 0x3,
-                       GET_SWZ( SrcReg->Swizzle, 3 ) & 0x3);
-
-   if (SrcReg->Negate == NEGATE_XYZW)
-      src = ureg_negate(src);
-
-   if (SrcReg->Abs) 
-      src = ureg_abs(src);
-
-   if (SrcReg->RelAddr) {
-      src = ureg_src_indirect( src, ureg_src(t->address[0]));
-      if (SrcReg->File != PROGRAM_INPUT &&
-          SrcReg->File != PROGRAM_OUTPUT) {
-         /* If SrcReg->Index was negative, it was set to zero in
-          * src_register().  Reassign it now.  But don't do this
-          * for input/output regs since they get remapped while
-          * const buffers don't.
-          */
-         src.Index = SrcReg->Index;
-      }
-   }
-
-   return src;
-}
-
-
-static struct ureg_src swizzle_4v( struct ureg_src src,
-                                   const unsigned *swz )
-{
-   return ureg_swizzle( src, swz[0], swz[1], swz[2], swz[3] );
-}
-
-
-/**
- * Translate a SWZ instruction into a MOV, MUL or MAD instruction.  EG:
- *
- *   SWZ dst, src.x-y10 
- * 
- * becomes:
- *
- *   MAD dst {1,-1,0,0}, src.xyxx, {0,0,1,0}
- */
-static void emit_swz( struct st_translate *t,
-                      struct ureg_dst dst,
-                      const struct prog_src_register *SrcReg )
-{
-   struct ureg_program *ureg = t->ureg;
-   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );
-
-   unsigned negate_mask =  SrcReg->Negate;
-
-   unsigned one_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ONE) << 0 |
-                        (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ONE) << 1 |
-                        (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ONE) << 2 |
-                        (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ONE) << 3);
-
-   unsigned zero_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ZERO) << 0 |
-                         (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ZERO) << 1 |
-                         (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ZERO) << 2 |
-                         (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ZERO) << 3);
-
-   unsigned negative_one_mask = one_mask & negate_mask;
-   unsigned positive_one_mask = one_mask & ~negate_mask;
-   
-   struct ureg_src imm;
-   unsigned i;
-   unsigned mul_swizzle[4] = {0,0,0,0};
-   unsigned add_swizzle[4] = {0,0,0,0};
-   unsigned src_swizzle[4] = {0,0,0,0};
-   boolean need_add = FALSE;
-   boolean need_mul = FALSE;
-
-   if (dst.WriteMask == 0)
-      return;
-
-   /* Is this just a MOV?
-    */
-   if (zero_mask == 0 &&
-       one_mask == 0 &&
-       (negate_mask == 0 || negate_mask == TGSI_WRITEMASK_XYZW)) 
-   {
-      ureg_MOV( ureg, dst, translate_src( t, SrcReg ));
-      return;
-   }
-
-#define IMM_ZERO    0
-#define IMM_ONE     1
-#define IMM_NEG_ONE 2
-
-   imm = ureg_imm3f( ureg, 0, 1, -1 );
-
-   for (i = 0; i < 4; i++) {
-      unsigned bit = 1 << i;
-
-      if (dst.WriteMask & bit) {
-         if (positive_one_mask & bit) {
-            mul_swizzle[i] = IMM_ZERO;
-            add_swizzle[i] = IMM_ONE;
-            need_add = TRUE;
-         }
-         else if (negative_one_mask & bit) {
-            mul_swizzle[i] = IMM_ZERO;
-            add_swizzle[i] = IMM_NEG_ONE;
-            need_add = TRUE;
-         }
-         else if (zero_mask & bit) {
-            mul_swizzle[i] = IMM_ZERO;
-            add_swizzle[i] = IMM_ZERO;
-            need_add = TRUE;
-         }
-         else {
-            add_swizzle[i] = IMM_ZERO;
-            src_swizzle[i] = GET_SWZ(SrcReg->Swizzle, i);
-            need_mul = TRUE;
-            if (negate_mask & bit) {
-               mul_swizzle[i] = IMM_NEG_ONE;
-            }
-            else {
-               mul_swizzle[i] = IMM_ONE;
-            }
-         }
-      }
-   }
-
-   if (need_mul && need_add) {
-      ureg_MAD( ureg, 
-                dst,
-                swizzle_4v( src, src_swizzle ),
-                swizzle_4v( imm, mul_swizzle ),
-                swizzle_4v( imm, add_swizzle ) );
-   }
-   else if (need_mul) {
-      ureg_MUL( ureg, 
-                dst,
-                swizzle_4v( src, src_swizzle ),
-                swizzle_4v( imm, mul_swizzle ) );
-   }
-   else if (need_add) {
-      ureg_MOV( ureg, 
-                dst,
-                swizzle_4v( imm, add_swizzle ) );
-   }
-   else {
-      debug_assert(0);
-   }
-
-#undef IMM_ZERO
-#undef IMM_ONE
-#undef IMM_NEG_ONE
-}
-
-
-/**
- * Negate the value of DDY to match GL semantics where (0,0) is the
- * lower-left corner of the window.
- * Note that the GL_ARB_fragment_coord_conventions extension will
- * effect this someday.
- */
-static void emit_ddy( struct st_translate *t,
-                      struct ureg_dst dst,
-                      const struct prog_src_register *SrcReg )
-{
-   struct ureg_program *ureg = t->ureg;
-   struct ureg_src src = translate_src( t, SrcReg );
-   src = ureg_negate( src );
-   ureg_DDY( ureg, dst, src );
-}
-
-
-
-static unsigned
-translate_opcode( unsigned op )
-{
-   switch( op ) {
-   case OPCODE_ARL:
-      return TGSI_OPCODE_ARL;
-   case OPCODE_ABS:
-      return TGSI_OPCODE_ABS;
-   case OPCODE_ADD:
-      return TGSI_OPCODE_ADD;
-   case OPCODE_BGNLOOP:
-      return TGSI_OPCODE_BGNLOOP;
-   case OPCODE_BGNSUB:
-      return TGSI_OPCODE_BGNSUB;
-   case OPCODE_BRA:
-      return TGSI_OPCODE_BRA;
-   case OPCODE_BRK:
-      return TGSI_OPCODE_BRK;
-   case OPCODE_CAL:
-      return TGSI_OPCODE_CAL;
-   case OPCODE_CMP:
-      return TGSI_OPCODE_CMP;
-   case OPCODE_CONT:
-      return TGSI_OPCODE_CONT;
-   case OPCODE_COS:
-      return TGSI_OPCODE_COS;
-   case OPCODE_DDX:
-      return TGSI_OPCODE_DDX;
-   case OPCODE_DDY:
-      return TGSI_OPCODE_DDY;
-   case OPCODE_DP2:
-      return TGSI_OPCODE_DP2;
-   case OPCODE_DP2A:
-      return TGSI_OPCODE_DP2A;
-   case OPCODE_DP3:
-      return TGSI_OPCODE_DP3;
-   case OPCODE_DP4:
-      return TGSI_OPCODE_DP4;
-   case OPCODE_DPH:
-      return TGSI_OPCODE_DPH;
-   case OPCODE_DST:
-      return TGSI_OPCODE_DST;
-   case OPCODE_ELSE:
-      return TGSI_OPCODE_ELSE;
-   case OPCODE_EMIT_VERTEX:
-      return TGSI_OPCODE_EMIT;
-   case OPCODE_END_PRIMITIVE:
-      return TGSI_OPCODE_ENDPRIM;
-   case OPCODE_ENDIF:
-      return TGSI_OPCODE_ENDIF;
-   case OPCODE_ENDLOOP:
-      return TGSI_OPCODE_ENDLOOP;
-   case OPCODE_ENDSUB:
-      return TGSI_OPCODE_ENDSUB;
-   case OPCODE_EX2:
-      return TGSI_OPCODE_EX2;
-   case OPCODE_EXP:
-      return TGSI_OPCODE_EXP;
-   case OPCODE_FLR:
-      return TGSI_OPCODE_FLR;
-   case OPCODE_FRC:
-      return TGSI_OPCODE_FRC;
-   case OPCODE_IF:
-      return TGSI_OPCODE_IF;
-   case OPCODE_TRUNC:
-      return TGSI_OPCODE_TRUNC;
-   case OPCODE_KIL:
-      return TGSI_OPCODE_KIL;
-   case OPCODE_KIL_NV:
-      return TGSI_OPCODE_KILP;
-   case OPCODE_LG2:
-      return TGSI_OPCODE_LG2;
-   case OPCODE_LOG:
-      return TGSI_OPCODE_LOG;
-   case OPCODE_LIT:
-      return TGSI_OPCODE_LIT;
-   case OPCODE_LRP:
-      return TGSI_OPCODE_LRP;
-   case OPCODE_MAD:
-      return TGSI_OPCODE_MAD;
-   case OPCODE_MAX:
-      return TGSI_OPCODE_MAX;
-   case OPCODE_MIN:
-      return TGSI_OPCODE_MIN;
-   case OPCODE_MOV:
-      return TGSI_OPCODE_MOV;
-   case OPCODE_MUL:
-      return TGSI_OPCODE_MUL;
-   case OPCODE_NOP:
-      return TGSI_OPCODE_NOP;
-   case OPCODE_NRM3:
-      return TGSI_OPCODE_NRM;
-   case OPCODE_NRM4:
-      return TGSI_OPCODE_NRM4;
-   case OPCODE_POW:
-      return TGSI_OPCODE_POW;
-   case OPCODE_RCP:
-      return TGSI_OPCODE_RCP;
-   case OPCODE_RET:
-      return TGSI_OPCODE_RET;
-   case OPCODE_RSQ:
-      return TGSI_OPCODE_RSQ;
-   case OPCODE_SCS:
-      return TGSI_OPCODE_SCS;
-   case OPCODE_SEQ:
-      return TGSI_OPCODE_SEQ;
-   case OPCODE_SGE:
-      return TGSI_OPCODE_SGE;
-   case OPCODE_SGT:
-      return TGSI_OPCODE_SGT;
-   case OPCODE_SIN:
-      return TGSI_OPCODE_SIN;
-   case OPCODE_SLE:
-      return TGSI_OPCODE_SLE;
-   case OPCODE_SLT:
-      return TGSI_OPCODE_SLT;
-   case OPCODE_SNE:
-      return TGSI_OPCODE_SNE;
-   case OPCODE_SSG:
-      return TGSI_OPCODE_SSG;
-   case OPCODE_SUB:
-      return TGSI_OPCODE_SUB;
-   case OPCODE_TEX:
-      return TGSI_OPCODE_TEX;
-   case OPCODE_TXB:
-      return TGSI_OPCODE_TXB;
-   case OPCODE_TXD:
-      return TGSI_OPCODE_TXD;
-   case OPCODE_TXL:
-      return TGSI_OPCODE_TXL;
-   case OPCODE_TXP:
-      return TGSI_OPCODE_TXP;
-   case OPCODE_XPD:
-      return TGSI_OPCODE_XPD;
-   case OPCODE_END:
-      return TGSI_OPCODE_END;
-   default:
-      debug_assert( 0 );
-      return TGSI_OPCODE_NOP;
-   }
-}
-
-
-static void
-compile_instruction(
-   struct st_translate *t,
-   const struct prog_instruction *inst )
-{
-   struct ureg_program *ureg = t->ureg;
-   GLuint i;
-   struct ureg_dst dst[1];
-   struct ureg_src src[4];
-   unsigned num_dst;
-   unsigned num_src;
-
-   num_dst = _mesa_num_inst_dst_regs( inst->Opcode );
-   num_src = _mesa_num_inst_src_regs( inst->Opcode );
-
-   if (num_dst) 
-      dst[0] = translate_dst( t, 
-                              &inst->DstReg,
-                              inst->SaturateMode );
-
-   for (i = 0; i < num_src; i++) 
-      src[i] = translate_src( t, &inst->SrcReg[i] );
-
-   switch( inst->Opcode ) {
-   case OPCODE_SWZ:
-      emit_swz( t, dst[0], &inst->SrcReg[0] );
-      return;
-
-   case OPCODE_BGNLOOP:
-   case OPCODE_CAL:
-   case OPCODE_ELSE:
-   case OPCODE_ENDLOOP:
-   case OPCODE_IF:
-      debug_assert(num_dst == 0);
-      ureg_label_insn( ureg,
-                       translate_opcode( inst->Opcode ),
-                       src, num_src,
-                       get_label( t, inst->BranchTarget ));
-      return;
-
-   case OPCODE_TEX:
-   case OPCODE_TXB:
-   case OPCODE_TXD:
-   case OPCODE_TXL:
-   case OPCODE_TXP:
-      src[num_src++] = t->samplers[inst->TexSrcUnit];
-      ureg_tex_insn( ureg,
-                     translate_opcode( inst->Opcode ),
-                     dst, num_dst, 
-                     translate_texture_target( inst->TexSrcTarget,
-                                               inst->TexShadow ),
-                     src, num_src );
-      return;
-
-   case OPCODE_SCS:
-      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XY );
-      ureg_insn( ureg, 
-                 translate_opcode( inst->Opcode ), 
-                 dst, num_dst, 
-                 src, num_src );
-      break;
-
-   case OPCODE_XPD:
-      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XYZ );
-      ureg_insn( ureg, 
-                 translate_opcode( inst->Opcode ), 
-                 dst, num_dst, 
-                 src, num_src );
-      break;
-
-   case OPCODE_NOISE1:
-   case OPCODE_NOISE2:
-   case OPCODE_NOISE3:
-   case OPCODE_NOISE4:
-      /* At some point, a motivated person could add a better
-       * implementation of noise.  Currently not even the nvidia
-       * binary drivers do anything more than this.  In any case, the
-       * place to do this is in the GL state tracker, not the poor
-       * driver.
-       */
-      ureg_MOV( ureg, dst[0], ureg_imm1f(ureg, 0.5) );
-      break;
-		 
-   case OPCODE_DDY:
-      emit_ddy( t, dst[0], &inst->SrcReg[0] );
-      break;
-
-   default:
-      ureg_insn( ureg, 
-                 translate_opcode( inst->Opcode ), 
-                 dst, num_dst, 
-                 src, num_src );
-      break;
-   }
-}
-
-
-/**
- * Emit the TGSI instructions to adjust the WPOS pixel center convention
- * Basically, add (adjX, adjY) to the fragment position.
- */
-static void
-emit_adjusted_wpos( struct st_translate *t,
-                    const struct gl_program *program,
-                    GLfloat adjX, GLfloat adjY)
-{
-   struct ureg_program *ureg = t->ureg;
-   struct ureg_dst wpos_temp = ureg_DECL_temporary(ureg);
-   struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];
-
-   /* Note that we bias X and Y and pass Z and W through unchanged.
-    * The shader might also use gl_FragCoord.w and .z.
-    */
-   ureg_ADD(ureg, wpos_temp, wpos_input,
-            ureg_imm4f(ureg, adjX, adjY, 0.0f, 0.0f));
-
-   t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);
-}
-
-
-/**
- * Emit the TGSI instructions for inverting the WPOS y coordinate.
- * This code is unavoidable because it also depends on whether
- * a FBO is bound (STATE_FB_WPOS_Y_TRANSFORM).
- */
-static void
-emit_wpos_inversion( struct st_translate *t,
-                     const struct gl_program *program,
-                     boolean invert)
-{
-   struct ureg_program *ureg = t->ureg;
-
-   /* Fragment program uses fragment position input.
-    * Need to replace instances of INPUT[WPOS] with temp T
-    * where T = INPUT[WPOS] by y is inverted.
-    */
-   static const gl_state_index wposTransformState[STATE_LENGTH]
-      = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM, 0, 0, 0 };
-   
-   /* XXX: note we are modifying the incoming shader here!  Need to
-    * do this before emitting the constant decls below, or this
-    * will be missed:
-    */
-   unsigned wposTransConst = _mesa_add_state_reference(program->Parameters,
-                                                       wposTransformState);
-
-   struct ureg_src wpostrans = ureg_DECL_constant( ureg, wposTransConst );
-   struct ureg_dst wpos_temp;
-   struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];
-
-   /* MOV wpos_temp, input[wpos]
-    */
-   if (wpos_input.File == TGSI_FILE_TEMPORARY)
-      wpos_temp = ureg_dst(wpos_input);
-   else {
-      wpos_temp = ureg_DECL_temporary( ureg );
-      ureg_MOV( ureg, wpos_temp, wpos_input );
-   }
-
-   if (invert) {
-      /* MAD wpos_temp.y, wpos_input, wpostrans.xxxx, wpostrans.yyyy
-       */
-      ureg_MAD( ureg,
-                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),
-                wpos_input,
-                ureg_scalar(wpostrans, 0),
-                ureg_scalar(wpostrans, 1));
-   } else {
-      /* MAD wpos_temp.y, wpos_input, wpostrans.zzzz, wpostrans.wwww
-       */
-      ureg_MAD( ureg,
-                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),
-                wpos_input,
-                ureg_scalar(wpostrans, 2),
-                ureg_scalar(wpostrans, 3));
-   }
-
-   /* Use wpos_temp as position input from here on:
-    */
-   t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);
-}
-
-
-/**
- * Emit fragment position/ooordinate code.
- */
-static void
-emit_wpos(struct st_context *st,
-          struct st_translate *t,
-          const struct gl_program *program,
-          struct ureg_program *ureg)
-{
-   const struct gl_fragment_program *fp =
-      (const struct gl_fragment_program *) program;
-   struct pipe_screen *pscreen = st->pipe->screen;
-   boolean invert = FALSE;
-
-   if (fp->OriginUpperLeft) {
-      /* Fragment shader wants origin in upper-left */
-      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
-         /* the driver supports upper-left origin */
-      }
-      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) {
-         /* the driver supports lower-left origin, need to invert Y */
-         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
-         invert = TRUE;
-      }
-      else
-         assert(0);
-   }
-   else {
-      /* Fragment shader wants origin in lower-left */
-      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT))
-         /* the driver supports lower-left origin */
-         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
-      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT))
-         /* the driver supports upper-left origin, need to invert Y */
-         invert = TRUE;
-      else
-         assert(0);
-   }
-   
-   if (fp->PixelCenterInteger) {
-      /* Fragment shader wants pixel center integer */
-      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER))
-         /* the driver supports pixel center integer */
-         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
-      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER))
-         /* the driver supports pixel center half integer, need to bias X,Y */
-         emit_adjusted_wpos(t, program, 0.5f, invert ? 0.5f : -0.5f);
-      else
-         assert(0);
-   }
-   else {
-      /* Fragment shader wants pixel center half integer */
-      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {
-         /* the driver supports pixel center half integer */
-      }
-      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
-         /* the driver supports pixel center integer, need to bias X,Y */
-         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
-         emit_adjusted_wpos(t, program, 0.5f, invert ? -0.5f : 0.5f);
-      }
-      else
-         assert(0);
-   }
-
-   /* we invert after adjustment so that we avoid the MOV to temporary,
-    * and reuse the adjustment ADD instead */
-   emit_wpos_inversion(t, program, invert);
-}
-
-
-/**
- * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back.
- * TGSI uses +1 for front, -1 for back.
- * This function converts the TGSI value to the GL value.  Simply clamping/
- * saturating the value to [0,1] does the job.
- */
-static void
-emit_face_var( struct st_translate *t,
-               const struct gl_program *program )
-{
-   struct ureg_program *ureg = t->ureg;
-   struct ureg_dst face_temp = ureg_DECL_temporary( ureg );
-   struct ureg_src face_input = t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]];
-
-   /* MOV_SAT face_temp, input[face]
-    */
-   face_temp = ureg_saturate( face_temp );
-   ureg_MOV( ureg, face_temp, face_input );
-
-   /* Use face_temp as face input from here on:
-    */
-   t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]] = ureg_src(face_temp);
-}
-
-
-static void
-emit_edgeflags( struct st_translate *t,
-                 const struct gl_program *program )
-{
-   struct ureg_program *ureg = t->ureg;
-   struct ureg_dst edge_dst = t->outputs[t->outputMapping[VERT_RESULT_EDGE]];
-   struct ureg_src edge_src = t->inputs[t->inputMapping[VERT_ATTRIB_EDGEFLAG]];
-
-   ureg_MOV( ureg, edge_dst, edge_src );
-}
-
-
-/**
- * Translate Mesa program to TGSI format.
- * \param program  the program to translate
- * \param numInputs  number of input registers used
- * \param inputMapping  maps Mesa fragment program inputs to TGSI generic
- *                      input indexes
- * \param inputSemanticName  the TGSI_SEMANTIC flag for each input
- * \param inputSemanticIndex  the semantic index (ex: which texcoord) for
- *                            each input
- * \param interpMode  the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input
- * \param numOutputs  number of output registers used
- * \param outputMapping  maps Mesa fragment program outputs to TGSI
- *                       generic outputs
- * \param outputSemanticName  the TGSI_SEMANTIC flag for each output
- * \param outputSemanticIndex  the semantic index (ex: which texcoord) for
- *                             each output
- *
- * \return  PIPE_OK or PIPE_ERROR_OUT_OF_MEMORY
- */
-enum pipe_error
-st_translate_mesa_program(
-   struct gl_context *ctx,
-   uint procType,
-   struct ureg_program *ureg,
-   const struct gl_program *program,
-   GLuint numInputs,
-   const GLuint inputMapping[],
-   const ubyte inputSemanticName[],
-   const ubyte inputSemanticIndex[],
-   const GLuint interpMode[],
-   GLuint numOutputs,
-   const GLuint outputMapping[],
-   const ubyte outputSemanticName[],
-   const ubyte outputSemanticIndex[],
-   boolean passthrough_edgeflags )
-{
-   struct st_translate translate, *t;
-   unsigned i;
-   enum pipe_error ret = PIPE_OK;
-
-   assert(numInputs <= Elements(t->inputs));
-   assert(numOutputs <= Elements(t->outputs));
-
-   t = &translate;
-   memset(t, 0, sizeof *t);
-
-   t->procType = procType;
-   t->inputMapping = inputMapping;
-   t->outputMapping = outputMapping;
-   t->ureg = ureg;
-   t->pointSizeOutIndex = -1;
-   t->prevInstWrotePointSize = GL_FALSE;
-
-   /*_mesa_print_program(program);*/
-
-   /*
-    * Declare input attributes.
-    */
-   if (procType == TGSI_PROCESSOR_FRAGMENT) {
-      for (i = 0; i < numInputs; i++) {
-         if (program->InputFlags[0] & PROG_PARAM_BIT_CYL_WRAP) {
-            t->inputs[i] = ureg_DECL_fs_input_cyl(ureg,
-                                                  inputSemanticName[i],
-                                                  inputSemanticIndex[i],
-                                                  interpMode[i],
-                                                  TGSI_CYLINDRICAL_WRAP_X);
-         }
-         else {
-            t->inputs[i] = ureg_DECL_fs_input(ureg,
-                                              inputSemanticName[i],
-                                              inputSemanticIndex[i],
-                                              interpMode[i]);
-         }
-      }
-
-      if (program->InputsRead & FRAG_BIT_WPOS) {
-         /* Must do this after setting up t->inputs, and before
-          * emitting constant references, below:
-          */
-         emit_wpos(st_context(ctx), t, program, ureg);
-      }
-
-      if (program->InputsRead & FRAG_BIT_FACE) {
-         emit_face_var( t, program );
-      }
-
-      /*
-       * Declare output attributes.
-       */
-      for (i = 0; i < numOutputs; i++) {
-         switch (outputSemanticName[i]) {
-         case TGSI_SEMANTIC_POSITION:
-            t->outputs[i] = ureg_DECL_output( ureg,
-                                              TGSI_SEMANTIC_POSITION, /* Z / Depth */
-                                              outputSemanticIndex[i] );
-
-            t->outputs[i] = ureg_writemask( t->outputs[i],
-                                            TGSI_WRITEMASK_Z );
-            break;
-         case TGSI_SEMANTIC_STENCIL:
-            t->outputs[i] = ureg_DECL_output( ureg,
-                                              TGSI_SEMANTIC_STENCIL, /* Stencil */
-                                              outputSemanticIndex[i] );
-            t->outputs[i] = ureg_writemask( t->outputs[i],
-                                            TGSI_WRITEMASK_Y );
-            break;
-         case TGSI_SEMANTIC_COLOR:
-            t->outputs[i] = ureg_DECL_output( ureg,
-                                              TGSI_SEMANTIC_COLOR,
-                                              outputSemanticIndex[i] );
-            break;
-         default:
-            debug_assert(0);
-            return 0;
-         }
-      }
-   }
-   else if (procType == TGSI_PROCESSOR_GEOMETRY) {
-      for (i = 0; i < numInputs; i++) {
-         t->inputs[i] = ureg_DECL_gs_input(ureg,
-                                           i,
-                                           inputSemanticName[i],
-                                           inputSemanticIndex[i]);
-      }
-
-      for (i = 0; i < numOutputs; i++) {
-         t->outputs[i] = ureg_DECL_output( ureg,
-                                           outputSemanticName[i],
-                                           outputSemanticIndex[i] );
-      }
-   }
-   else {
-      assert(procType == TGSI_PROCESSOR_VERTEX);
-
-      for (i = 0; i < numInputs; i++) {
-         t->inputs[i] = ureg_DECL_vs_input(ureg, i);
-      }
-
-      for (i = 0; i < numOutputs; i++) {
-         t->outputs[i] = ureg_DECL_output( ureg,
-                                           outputSemanticName[i],
-                                           outputSemanticIndex[i] );
-         if ((outputSemanticName[i] == TGSI_SEMANTIC_PSIZE) && program->Id) {
-            /* Writing to the point size result register requires special
-             * handling to implement clamping.
-             */
-            static const gl_state_index pointSizeClampState[STATE_LENGTH]
-               = { STATE_INTERNAL, STATE_POINT_SIZE_IMPL_CLAMP, 0, 0, 0 };
-               /* XXX: note we are modifying the incoming shader here!  Need to
-               * do this before emitting the constant decls below, or this
-               * will be missed:
-               */
-            unsigned pointSizeClampConst =
-               _mesa_add_state_reference(program->Parameters,
-                                         pointSizeClampState);
-            struct ureg_dst psizregtemp = ureg_DECL_temporary( ureg );
-            t->pointSizeConst = ureg_DECL_constant( ureg, pointSizeClampConst );
-            t->pointSizeResult = t->outputs[i];
-            t->pointSizeOutIndex = i;
-            t->outputs[i] = psizregtemp;
-         }
-      }
-      if (passthrough_edgeflags)
-         emit_edgeflags( t, program );
-   }
-
-   /* Declare address register.
-    */
-   if (program->NumAddressRegs > 0) {
-      debug_assert( program->NumAddressRegs == 1 );
-      t->address[0] = ureg_DECL_address( ureg );
-   }
-
-   /* Declare misc input registers
-    */
-   {
-      GLbitfield sysInputs = program->SystemValuesRead;
-      unsigned numSys = 0;
-      for (i = 0; sysInputs; i++) {
-         if (sysInputs & (1 << i)) {
-            unsigned semName = mesa_sysval_to_semantic[i];
-            t->systemValues[i] = ureg_DECL_system_value(ureg, numSys, semName, 0);
-            numSys++;
-            sysInputs &= ~(1 << i);
-         }
-      }
-   }
-
-   if (program->IndirectRegisterFiles & (1 << PROGRAM_TEMPORARY)) {
-      /* If temps are accessed with indirect addressing, declare temporaries
-       * in sequential order.  Else, we declare them on demand elsewhere.
-       */
-      for (i = 0; i < program->NumTemporaries; i++) {
-         /* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */
-         t->temps[i] = ureg_DECL_temporary( t->ureg );
-      }
-   }
-
-   /* Emit constants and immediates.  Mesa uses a single index space
-    * for these, so we put all the translated regs in t->constants.
-    */
-   if (program->Parameters) {
-      t->constants = CALLOC( program->Parameters->NumParameters,
-                             sizeof t->constants[0] );
-      if (t->constants == NULL) {
-         ret = PIPE_ERROR_OUT_OF_MEMORY;
-         goto out;
-      }
-
-      for (i = 0; i < program->Parameters->NumParameters; i++) {
-         switch (program->Parameters->Parameters[i].Type) {
-         case PROGRAM_ENV_PARAM:
-         case PROGRAM_LOCAL_PARAM:
-         case PROGRAM_STATE_VAR:
-         case PROGRAM_NAMED_PARAM:
-         case PROGRAM_UNIFORM:
-            t->constants[i] = ureg_DECL_constant( ureg, i );
-            break;
-
-            /* Emit immediates only when there's no indirect addressing of
-             * the const buffer.
-             * FIXME: Be smarter and recognize param arrays:
-             * indirect addressing is only valid within the referenced
-             * array.
-             */
-         case PROGRAM_CONSTANT:
-            if (program->IndirectRegisterFiles & PROGRAM_ANY_CONST)
-               t->constants[i] = ureg_DECL_constant( ureg, i );
-            else
-               t->constants[i] = 
-                  ureg_DECL_immediate( ureg,
-                                       program->Parameters->ParameterValues[i],
-                                       4 );
-            break;
-         default:
-            break;
-         }
-      }
-   }
-
-   /* texture samplers */
-   for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
-      if (program->SamplersUsed & (1 << i)) {
-         t->samplers[i] = ureg_DECL_sampler( ureg, i );
-      }
-   }
-
-   /* Emit each instruction in turn:
-    */
-   for (i = 0; i < program->NumInstructions; i++) {
-      set_insn_start( t, ureg_get_instruction_number( ureg ));
-      compile_instruction( t, &program->Instructions[i] );
-
-      if (t->prevInstWrotePointSize && program->Id) {
-         /* The previous instruction wrote to the (fake) vertex point size
-          * result register.  Now we need to clamp that value to the min/max
-          * point size range, putting the result into the real point size
-          * register.
-          * Note that we can't do this easily at the end of program due to
-          * possible early return.
-          */
-         set_insn_start( t, ureg_get_instruction_number( ureg ));
-         ureg_MAX( t->ureg,
-                   ureg_writemask(t->outputs[t->pointSizeOutIndex], WRITEMASK_X),
-                   ureg_src(t->outputs[t->pointSizeOutIndex]),
-                   ureg_swizzle(t->pointSizeConst, 1,1,1,1));
-         ureg_MIN( t->ureg, ureg_writemask(t->pointSizeResult, WRITEMASK_X),
-                   ureg_src(t->outputs[t->pointSizeOutIndex]),
-                   ureg_swizzle(t->pointSizeConst, 2,2,2,2));
-      }
-      t->prevInstWrotePointSize = GL_FALSE;
-   }
-
-   /* Fix up all emitted labels:
-    */
-   for (i = 0; i < t->labels_count; i++) {
-      ureg_fixup_label( ureg,
-                        t->labels[i].token,
-                        t->insn[t->labels[i].branch_target] );
-   }
-
-out:
-   FREE(t->insn);
-   FREE(t->labels);
-   FREE(t->constants);
-
-   if (t->error) {
-      debug_printf("%s: translate error flag set\n", __FUNCTION__);
-   }
-
-   return ret;
-}
-
-
-/**
- * Tokens cannot be free with free otherwise the builtin gallium
- * malloc debugging will get confused.
- */
-void
-st_free_tokens(const struct tgsi_token *tokens)
-{
-   FREE((void *)tokens);
-}
+/**************************************************************************

+ * 

+ * Copyright 2007-2008 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+/*

+ * \author

+ * Michal Krol,

+ * Keith Whitwell

+ */

+

+#include "pipe/p_compiler.h"

+#include "pipe/p_context.h"

+#include "pipe/p_screen.h"

+#include "pipe/p_shader_tokens.h"

+#include "pipe/p_state.h"

+#include "tgsi/tgsi_ureg.h"

+#include "st_mesa_to_tgsi.h"

+#include "st_context.h"

+#include "program/prog_instruction.h"

+#include "program/prog_parameter.h"

+#include "util/u_debug.h"

+#include "util/u_math.h"

+#include "util/u_memory.h"

+

+

+#define PROGRAM_ANY_CONST ((1 << PROGRAM_LOCAL_PARAM) |  \

+                           (1 << PROGRAM_ENV_PARAM) |    \

+                           (1 << PROGRAM_STATE_VAR) |    \

+                           (1 << PROGRAM_NAMED_PARAM) |  \

+                           (1 << PROGRAM_CONSTANT) |     \

+                           (1 << PROGRAM_UNIFORM))

+

+

+struct label {

+   unsigned branch_target;

+   unsigned token;

+};

+

+

+/**

+ * Intermediate state used during shader translation.

+ */

+struct st_translate {

+   struct ureg_program *ureg;

+

+   struct ureg_dst temps[MAX_PROGRAM_TEMPS];

+   struct ureg_src *constants;

+   struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS];

+   struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS];

+   struct ureg_dst address[1];

+   struct ureg_src samplers[PIPE_MAX_SAMPLERS];

+   struct ureg_src systemValues[SYSTEM_VALUE_MAX];

+

+   /* Extra info for handling point size clamping in vertex shader */

+   struct ureg_dst pointSizeResult; /**< Actual point size output register */

+   struct ureg_src pointSizeConst;  /**< Point size range constant register */

+   GLint pointSizeOutIndex;         /**< Temp point size output register */

+   GLboolean prevInstWrotePointSize;

+

+   const GLuint *inputMapping;

+   const GLuint *outputMapping;

+

+   /* For every instruction that contains a label (eg CALL), keep

+    * details so that we can go back afterwards and emit the correct

+    * tgsi instruction number for each label.

+    */

+   struct label *labels;

+   unsigned labels_size;

+   unsigned labels_count;

+

+   /* Keep a record of the tgsi instruction number that each mesa

+    * instruction starts at, will be used to fix up labels after

+    * translation.

+    */

+   unsigned *insn;

+   unsigned insn_size;

+   unsigned insn_count;

+

+   unsigned procType;  /**< TGSI_PROCESSOR_VERTEX/FRAGMENT */

+

+   boolean error;

+};

+

+

+/** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */

+static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = {

+   TGSI_SEMANTIC_FACE,

+   TGSI_SEMANTIC_INSTANCEID

+};

+

+

+/**

+ * Make note of a branch to a label in the TGSI code.

+ * After we've emitted all instructions, we'll go over the list

+ * of labels built here and patch the TGSI code with the actual

+ * location of each label.

+ */

+static unsigned *get_label( struct st_translate *t,

+                            unsigned branch_target )

+{

+   unsigned i;

+

+   if (t->labels_count + 1 >= t->labels_size) {

+      unsigned old_size = t->labels_size;

+      t->labels_size = 1 << (util_logbase2(t->labels_size) + 1);

+      t->labels = REALLOC( t->labels, 

+                           old_size * sizeof t->labels[0], 

+                           t->labels_size * sizeof t->labels[0] );

+      if (t->labels == NULL) {

+         static unsigned dummy;

+         t->error = TRUE;

+         return &dummy;

+      }

+   }

+

+   i = t->labels_count++;

+   t->labels[i].branch_target = branch_target;

+   return &t->labels[i].token;

+}

+

+

+/**

+ * Called prior to emitting the TGSI code for each Mesa instruction.

+ * Allocate additional space for instructions if needed.

+ * Update the insn[] array so the next Mesa instruction points to

+ * the next TGSI instruction.

+ */

+static void set_insn_start( struct st_translate *t,

+                            unsigned start )

+{

+   if (t->insn_count + 1 >= t->insn_size) {

+      unsigned old_size = t->insn_size;

+      t->insn_size = 1 << (util_logbase2(t->insn_size) + 1);

+      t->insn = REALLOC( t->insn, 

+                         old_size * sizeof t->insn[0], 

+                         t->insn_size * sizeof t->insn[0] );

+      if (t->insn == NULL) {

+         t->error = TRUE;

+         return;

+      }

+   }

+

+   t->insn[t->insn_count++] = start;

+}

+

+

+/**

+ * Map a Mesa dst register to a TGSI ureg_dst register.

+ */

+static struct ureg_dst

+dst_register( struct st_translate *t,

+              gl_register_file file,

+              GLuint index )

+{

+   switch( file ) {

+   case PROGRAM_UNDEFINED:

+      return ureg_dst_undef();

+

+   case PROGRAM_TEMPORARY:

+      if (ureg_dst_is_undef(t->temps[index]))

+         t->temps[index] = ureg_DECL_temporary( t->ureg );

+

+      return t->temps[index];

+

+   case PROGRAM_OUTPUT:

+      if (t->procType == TGSI_PROCESSOR_VERTEX && index == VERT_RESULT_PSIZ)

+         t->prevInstWrotePointSize = GL_TRUE;

+

+      if (t->procType == TGSI_PROCESSOR_VERTEX)

+         assert(index < VERT_RESULT_MAX);

+      else if (t->procType == TGSI_PROCESSOR_FRAGMENT)

+         assert(index < FRAG_RESULT_MAX);

+      else

+         assert(index < GEOM_RESULT_MAX);

+

+      assert(t->outputMapping[index] < Elements(t->outputs));

+

+      return t->outputs[t->outputMapping[index]];

+

+   case PROGRAM_ADDRESS:

+      return t->address[index];

+

+   default:

+      debug_assert( 0 );

+      return ureg_dst_undef();

+   }

+}

+

+

+/**

+ * Map a Mesa src register to a TGSI ureg_src register.

+ */

+static struct ureg_src

+src_register( struct st_translate *t,

+              gl_register_file file,

+              GLint index )

+{

+   switch( file ) {

+   case PROGRAM_UNDEFINED:

+      return ureg_src_undef();

+

+   case PROGRAM_TEMPORARY:

+      assert(index >= 0);

+      assert(index < Elements(t->temps));

+      if (ureg_dst_is_undef(t->temps[index]))

+         t->temps[index] = ureg_DECL_temporary( t->ureg );

+      return ureg_src(t->temps[index]);

+

+   case PROGRAM_NAMED_PARAM:

+   case PROGRAM_ENV_PARAM:

+   case PROGRAM_LOCAL_PARAM:

+   case PROGRAM_UNIFORM:

+      assert(index >= 0);

+      return t->constants[index];

+   case PROGRAM_STATE_VAR:

+   case PROGRAM_CONSTANT:       /* ie, immediate */

+      if (index < 0)

+         return ureg_DECL_constant( t->ureg, 0 );

+      else

+         return t->constants[index];

+

+   case PROGRAM_INPUT:

+      assert(t->inputMapping[index] < Elements(t->inputs));

+      return t->inputs[t->inputMapping[index]];

+

+   case PROGRAM_OUTPUT:

+      assert(t->outputMapping[index] < Elements(t->outputs));

+      return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */

+

+   case PROGRAM_ADDRESS:

+      return ureg_src(t->address[index]);

+

+   case PROGRAM_SYSTEM_VALUE:

+      assert(index < Elements(t->systemValues));

+      return t->systemValues[index];

+

+   default:

+      debug_assert( 0 );

+      return ureg_src_undef();

+   }

+}

+

+

+/**

+ * Map mesa texture target to TGSI texture target.

+ */

+static unsigned

+translate_texture_target( GLuint textarget,

+                          GLboolean shadow )

+{

+   if (shadow) {

+      switch( textarget ) {

+      case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_SHADOW1D;

+      case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_SHADOW2D;

+      case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_SHADOWRECT;

+      default: break;

+      }

+   }

+

+   switch( textarget ) {

+   case TEXTURE_1D_INDEX:   return TGSI_TEXTURE_1D;

+   case TEXTURE_2D_INDEX:   return TGSI_TEXTURE_2D;

+   case TEXTURE_3D_INDEX:   return TGSI_TEXTURE_3D;

+   case TEXTURE_CUBE_INDEX: return TGSI_TEXTURE_CUBE;

+   case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_RECT;

+   case TEXTURE_1D_ARRAY_INDEX:   return TGSI_TEXTURE_1D_ARRAY;

+   case TEXTURE_2D_ARRAY_INDEX:   return TGSI_TEXTURE_2D_ARRAY;

+   default:

+      debug_assert( 0 );

+      return TGSI_TEXTURE_1D;

+   }

+}

+

+

+/**

+ * Create a TGSI ureg_dst register from a Mesa dest register.

+ */

+static struct ureg_dst

+translate_dst( struct st_translate *t,

+               const struct prog_dst_register *DstReg,

+               boolean saturate )

+{

+   struct ureg_dst dst = dst_register( t, 

+                                       DstReg->File,

+                                       DstReg->Index );

+

+   dst = ureg_writemask( dst, 

+                         DstReg->WriteMask );

+   

+   if (saturate)

+      dst = ureg_saturate( dst );

+

+   if (DstReg->RelAddr)

+      dst = ureg_dst_indirect( dst, ureg_src(t->address[0]) );

+

+   return dst;

+}

+

+

+/**

+ * Create a TGSI ureg_src register from a Mesa src register.

+ */

+static struct ureg_src

+translate_src( struct st_translate *t,

+               const struct prog_src_register *SrcReg )

+{

+   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );

+

+   if (t->procType == TGSI_PROCESSOR_GEOMETRY && SrcReg->HasIndex2) {

+      src = src_register( t, SrcReg->File, SrcReg->Index2 );

+      if (SrcReg->RelAddr2)

+         src = ureg_src_dimension_indirect( src, ureg_src(t->address[0]),

+                                            SrcReg->Index);

+      else

+         src = ureg_src_dimension( src, SrcReg->Index);

+   }

+

+   src = ureg_swizzle( src,

+                       GET_SWZ( SrcReg->Swizzle, 0 ) & 0x3,

+                       GET_SWZ( SrcReg->Swizzle, 1 ) & 0x3,

+                       GET_SWZ( SrcReg->Swizzle, 2 ) & 0x3,

+                       GET_SWZ( SrcReg->Swizzle, 3 ) & 0x3);

+

+   if (SrcReg->Negate == NEGATE_XYZW)

+      src = ureg_negate(src);

+

+   if (SrcReg->Abs) 

+      src = ureg_abs(src);

+

+   if (SrcReg->RelAddr) {

+      src = ureg_src_indirect( src, ureg_src(t->address[0]));

+      if (SrcReg->File != PROGRAM_INPUT &&

+          SrcReg->File != PROGRAM_OUTPUT) {

+         /* If SrcReg->Index was negative, it was set to zero in

+          * src_register().  Reassign it now.  But don't do this

+          * for input/output regs since they get remapped while

+          * const buffers don't.

+          */

+         src.Index = SrcReg->Index;

+      }

+   }

+

+   return src;

+}

+

+

+static struct ureg_src swizzle_4v( struct ureg_src src,

+                                   const unsigned *swz )

+{

+   return ureg_swizzle( src, swz[0], swz[1], swz[2], swz[3] );

+}

+

+

+/**

+ * Translate a SWZ instruction into a MOV, MUL or MAD instruction.  EG:

+ *

+ *   SWZ dst, src.x-y10 

+ * 

+ * becomes:

+ *

+ *   MAD dst {1,-1,0,0}, src.xyxx, {0,0,1,0}

+ */

+static void emit_swz( struct st_translate *t,

+                      struct ureg_dst dst,

+                      const struct prog_src_register *SrcReg )

+{

+   struct ureg_program *ureg = t->ureg;

+   struct ureg_src src = src_register( t, SrcReg->File, SrcReg->Index );

+

+   unsigned negate_mask =  SrcReg->Negate;

+

+   unsigned one_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ONE) << 0 |

+                        (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ONE) << 1 |

+                        (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ONE) << 2 |

+                        (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ONE) << 3);

+

+   unsigned zero_mask = ((GET_SWZ(SrcReg->Swizzle, 0) == SWIZZLE_ZERO) << 0 |

+                         (GET_SWZ(SrcReg->Swizzle, 1) == SWIZZLE_ZERO) << 1 |

+                         (GET_SWZ(SrcReg->Swizzle, 2) == SWIZZLE_ZERO) << 2 |

+                         (GET_SWZ(SrcReg->Swizzle, 3) == SWIZZLE_ZERO) << 3);

+

+   unsigned negative_one_mask = one_mask & negate_mask;

+   unsigned positive_one_mask = one_mask & ~negate_mask;

+   

+   struct ureg_src imm;

+   unsigned i;

+   unsigned mul_swizzle[4] = {0,0,0,0};

+   unsigned add_swizzle[4] = {0,0,0,0};

+   unsigned src_swizzle[4] = {0,0,0,0};

+   boolean need_add = FALSE;

+   boolean need_mul = FALSE;

+

+   if (dst.WriteMask == 0)

+      return;

+

+   /* Is this just a MOV?

+    */

+   if (zero_mask == 0 &&

+       one_mask == 0 &&

+       (negate_mask == 0 || negate_mask == TGSI_WRITEMASK_XYZW)) 

+   {

+      ureg_MOV( ureg, dst, translate_src( t, SrcReg ));

+      return;

+   }

+

+#define IMM_ZERO    0

+#define IMM_ONE     1

+#define IMM_NEG_ONE 2

+

+   imm = ureg_imm3f( ureg, 0, 1, -1 );

+

+   for (i = 0; i < 4; i++) {

+      unsigned bit = 1 << i;

+

+      if (dst.WriteMask & bit) {

+         if (positive_one_mask & bit) {

+            mul_swizzle[i] = IMM_ZERO;

+            add_swizzle[i] = IMM_ONE;

+            need_add = TRUE;

+         }

+         else if (negative_one_mask & bit) {

+            mul_swizzle[i] = IMM_ZERO;

+            add_swizzle[i] = IMM_NEG_ONE;

+            need_add = TRUE;

+         }

+         else if (zero_mask & bit) {

+            mul_swizzle[i] = IMM_ZERO;

+            add_swizzle[i] = IMM_ZERO;

+            need_add = TRUE;

+         }

+         else {

+            add_swizzle[i] = IMM_ZERO;

+            src_swizzle[i] = GET_SWZ(SrcReg->Swizzle, i);

+            need_mul = TRUE;

+            if (negate_mask & bit) {

+               mul_swizzle[i] = IMM_NEG_ONE;

+            }

+            else {

+               mul_swizzle[i] = IMM_ONE;

+            }

+         }

+      }

+   }

+

+   if (need_mul && need_add) {

+      ureg_MAD( ureg, 

+                dst,

+                swizzle_4v( src, src_swizzle ),

+                swizzle_4v( imm, mul_swizzle ),

+                swizzle_4v( imm, add_swizzle ) );

+   }

+   else if (need_mul) {

+      ureg_MUL( ureg, 

+                dst,

+                swizzle_4v( src, src_swizzle ),

+                swizzle_4v( imm, mul_swizzle ) );

+   }

+   else if (need_add) {

+      ureg_MOV( ureg, 

+                dst,

+                swizzle_4v( imm, add_swizzle ) );

+   }

+   else {

+      debug_assert(0);

+   }

+

+#undef IMM_ZERO

+#undef IMM_ONE

+#undef IMM_NEG_ONE

+}

+

+

+/**

+ * Negate the value of DDY to match GL semantics where (0,0) is the

+ * lower-left corner of the window.

+ * Note that the GL_ARB_fragment_coord_conventions extension will

+ * effect this someday.

+ */

+static void emit_ddy( struct st_translate *t,

+                      struct ureg_dst dst,

+                      const struct prog_src_register *SrcReg )

+{

+   struct ureg_program *ureg = t->ureg;

+   struct ureg_src src = translate_src( t, SrcReg );

+   src = ureg_negate( src );

+   ureg_DDY( ureg, dst, src );

+}

+

+

+

+static unsigned

+translate_opcode( unsigned op )

+{

+   switch( op ) {

+   case OPCODE_ARL:

+      return TGSI_OPCODE_ARL;

+   case OPCODE_ABS:

+      return TGSI_OPCODE_ABS;

+   case OPCODE_ADD:

+      return TGSI_OPCODE_ADD;

+   case OPCODE_BGNLOOP:

+      return TGSI_OPCODE_BGNLOOP;

+   case OPCODE_BGNSUB:

+      return TGSI_OPCODE_BGNSUB;

+   case OPCODE_BRA:

+      return TGSI_OPCODE_BRA;

+   case OPCODE_BRK:

+      return TGSI_OPCODE_BRK;

+   case OPCODE_CAL:

+      return TGSI_OPCODE_CAL;

+   case OPCODE_CMP:

+      return TGSI_OPCODE_CMP;

+   case OPCODE_CONT:

+      return TGSI_OPCODE_CONT;

+   case OPCODE_COS:

+      return TGSI_OPCODE_COS;

+   case OPCODE_DDX:

+      return TGSI_OPCODE_DDX;

+   case OPCODE_DDY:

+      return TGSI_OPCODE_DDY;

+   case OPCODE_DP2:

+      return TGSI_OPCODE_DP2;

+   case OPCODE_DP2A:

+      return TGSI_OPCODE_DP2A;

+   case OPCODE_DP3:

+      return TGSI_OPCODE_DP3;

+   case OPCODE_DP4:

+      return TGSI_OPCODE_DP4;

+   case OPCODE_DPH:

+      return TGSI_OPCODE_DPH;

+   case OPCODE_DST:

+      return TGSI_OPCODE_DST;

+   case OPCODE_ELSE:

+      return TGSI_OPCODE_ELSE;

+   case OPCODE_EMIT_VERTEX:

+      return TGSI_OPCODE_EMIT;

+   case OPCODE_END_PRIMITIVE:

+      return TGSI_OPCODE_ENDPRIM;

+   case OPCODE_ENDIF:

+      return TGSI_OPCODE_ENDIF;

+   case OPCODE_ENDLOOP:

+      return TGSI_OPCODE_ENDLOOP;

+   case OPCODE_ENDSUB:

+      return TGSI_OPCODE_ENDSUB;

+   case OPCODE_EX2:

+      return TGSI_OPCODE_EX2;

+   case OPCODE_EXP:

+      return TGSI_OPCODE_EXP;

+   case OPCODE_FLR:

+      return TGSI_OPCODE_FLR;

+   case OPCODE_FRC:

+      return TGSI_OPCODE_FRC;

+   case OPCODE_IF:

+      return TGSI_OPCODE_IF;

+   case OPCODE_TRUNC:

+      return TGSI_OPCODE_TRUNC;

+   case OPCODE_KIL:

+      return TGSI_OPCODE_KIL;

+   case OPCODE_KIL_NV:

+      return TGSI_OPCODE_KILP;

+   case OPCODE_LG2:

+      return TGSI_OPCODE_LG2;

+   case OPCODE_LOG:

+      return TGSI_OPCODE_LOG;

+   case OPCODE_LIT:

+      return TGSI_OPCODE_LIT;

+   case OPCODE_LRP:

+      return TGSI_OPCODE_LRP;

+   case OPCODE_MAD:

+      return TGSI_OPCODE_MAD;

+   case OPCODE_MAX:

+      return TGSI_OPCODE_MAX;

+   case OPCODE_MIN:

+      return TGSI_OPCODE_MIN;

+   case OPCODE_MOV:

+      return TGSI_OPCODE_MOV;

+   case OPCODE_MUL:

+      return TGSI_OPCODE_MUL;

+   case OPCODE_NOP:

+      return TGSI_OPCODE_NOP;

+   case OPCODE_NRM3:

+      return TGSI_OPCODE_NRM;

+   case OPCODE_NRM4:

+      return TGSI_OPCODE_NRM4;

+   case OPCODE_POW:

+      return TGSI_OPCODE_POW;

+   case OPCODE_RCP:

+      return TGSI_OPCODE_RCP;

+   case OPCODE_RET:

+      return TGSI_OPCODE_RET;

+   case OPCODE_RSQ:

+      return TGSI_OPCODE_RSQ;

+   case OPCODE_SCS:

+      return TGSI_OPCODE_SCS;

+   case OPCODE_SEQ:

+      return TGSI_OPCODE_SEQ;

+   case OPCODE_SGE:

+      return TGSI_OPCODE_SGE;

+   case OPCODE_SGT:

+      return TGSI_OPCODE_SGT;

+   case OPCODE_SIN:

+      return TGSI_OPCODE_SIN;

+   case OPCODE_SLE:

+      return TGSI_OPCODE_SLE;

+   case OPCODE_SLT:

+      return TGSI_OPCODE_SLT;

+   case OPCODE_SNE:

+      return TGSI_OPCODE_SNE;

+   case OPCODE_SSG:

+      return TGSI_OPCODE_SSG;

+   case OPCODE_SUB:

+      return TGSI_OPCODE_SUB;

+   case OPCODE_TEX:

+      return TGSI_OPCODE_TEX;

+   case OPCODE_TXB:

+      return TGSI_OPCODE_TXB;

+   case OPCODE_TXD:

+      return TGSI_OPCODE_TXD;

+   case OPCODE_TXL:

+      return TGSI_OPCODE_TXL;

+   case OPCODE_TXP:

+      return TGSI_OPCODE_TXP;

+   case OPCODE_XPD:

+      return TGSI_OPCODE_XPD;

+   case OPCODE_END:

+      return TGSI_OPCODE_END;

+   default:

+      debug_assert( 0 );

+      return TGSI_OPCODE_NOP;

+   }

+}

+

+

+static void

+compile_instruction(

+   struct st_translate *t,

+   const struct prog_instruction *inst )

+{

+   struct ureg_program *ureg = t->ureg;

+   GLuint i;

+   struct ureg_dst dst[1];

+   struct ureg_src src[4];

+   unsigned num_dst;

+   unsigned num_src;

+

+   num_dst = _mesa_num_inst_dst_regs( inst->Opcode );

+   num_src = _mesa_num_inst_src_regs( inst->Opcode );

+

+   if (num_dst) 

+      dst[0] = translate_dst( t, 

+                              &inst->DstReg,

+                              inst->SaturateMode );

+

+   for (i = 0; i < num_src; i++) 

+      src[i] = translate_src( t, &inst->SrcReg[i] );

+

+   switch( inst->Opcode ) {

+   case OPCODE_SWZ:

+      emit_swz( t, dst[0], &inst->SrcReg[0] );

+      return;

+

+   case OPCODE_BGNLOOP:

+   case OPCODE_CAL:

+   case OPCODE_ELSE:

+   case OPCODE_ENDLOOP:

+   case OPCODE_IF:

+      debug_assert(num_dst == 0);

+      ureg_label_insn( ureg,

+                       translate_opcode( inst->Opcode ),

+                       src, num_src,

+                       get_label( t, inst->BranchTarget ));

+      return;

+

+   case OPCODE_TEX:

+   case OPCODE_TXB:

+   case OPCODE_TXD:

+   case OPCODE_TXL:

+   case OPCODE_TXP:

+      src[num_src++] = t->samplers[inst->TexSrcUnit];

+      ureg_tex_insn( ureg,

+                     translate_opcode( inst->Opcode ),

+                     dst, num_dst, 

+                     translate_texture_target( inst->TexSrcTarget,

+                                               inst->TexShadow ),

+                     src, num_src );

+      return;

+

+   case OPCODE_SCS:

+      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XY );

+      ureg_insn( ureg, 

+                 translate_opcode( inst->Opcode ), 

+                 dst, num_dst, 

+                 src, num_src );

+      break;

+

+   case OPCODE_XPD:

+      dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XYZ );

+      ureg_insn( ureg, 

+                 translate_opcode( inst->Opcode ), 

+                 dst, num_dst, 

+                 src, num_src );

+      break;

+

+   case OPCODE_NOISE1:

+   case OPCODE_NOISE2:

+   case OPCODE_NOISE3:

+   case OPCODE_NOISE4:

+      /* At some point, a motivated person could add a better

+       * implementation of noise.  Currently not even the nvidia

+       * binary drivers do anything more than this.  In any case, the

+       * place to do this is in the GL state tracker, not the poor

+       * driver.

+       */

+      ureg_MOV( ureg, dst[0], ureg_imm1f(ureg, 0.5) );

+      break;

+		 

+   case OPCODE_DDY:

+      emit_ddy( t, dst[0], &inst->SrcReg[0] );

+      break;

+

+   default:

+      ureg_insn( ureg, 

+                 translate_opcode( inst->Opcode ), 

+                 dst, num_dst, 

+                 src, num_src );

+      break;

+   }

+}

+

+

+/**

+ * Emit the TGSI instructions to adjust the WPOS pixel center convention

+ * Basically, add (adjX, adjY) to the fragment position.

+ */

+static void

+emit_adjusted_wpos( struct st_translate *t,

+                    const struct gl_program *program,

+                    GLfloat adjX, GLfloat adjY)

+{

+   struct ureg_program *ureg = t->ureg;

+   struct ureg_dst wpos_temp = ureg_DECL_temporary(ureg);

+   struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];

+

+   /* Note that we bias X and Y and pass Z and W through unchanged.

+    * The shader might also use gl_FragCoord.w and .z.

+    */

+   ureg_ADD(ureg, wpos_temp, wpos_input,

+            ureg_imm4f(ureg, adjX, adjY, 0.0f, 0.0f));

+

+   t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);

+}

+

+

+/**

+ * Emit the TGSI instructions for inverting the WPOS y coordinate.

+ * This code is unavoidable because it also depends on whether

+ * a FBO is bound (STATE_FB_WPOS_Y_TRANSFORM).

+ */

+static void

+emit_wpos_inversion( struct st_translate *t,

+                     const struct gl_program *program,

+                     boolean invert)

+{

+   struct ureg_program *ureg = t->ureg;

+

+   /* Fragment program uses fragment position input.

+    * Need to replace instances of INPUT[WPOS] with temp T

+    * where T = INPUT[WPOS] by y is inverted.

+    */

+   static const gl_state_index wposTransformState[STATE_LENGTH]

+      = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM, 0, 0, 0 };

+   

+   /* XXX: note we are modifying the incoming shader here!  Need to

+    * do this before emitting the constant decls below, or this

+    * will be missed:

+    */

+   unsigned wposTransConst = _mesa_add_state_reference(program->Parameters,

+                                                       wposTransformState);

+

+   struct ureg_src wpostrans = ureg_DECL_constant( ureg, wposTransConst );

+   struct ureg_dst wpos_temp;

+   struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];

+

+   /* MOV wpos_temp, input[wpos]

+    */

+   if (wpos_input.File == TGSI_FILE_TEMPORARY)

+      wpos_temp = ureg_dst(wpos_input);

+   else {

+      wpos_temp = ureg_DECL_temporary( ureg );

+      ureg_MOV( ureg, wpos_temp, wpos_input );

+   }

+

+   if (invert) {

+      /* MAD wpos_temp.y, wpos_input, wpostrans.xxxx, wpostrans.yyyy

+       */

+      ureg_MAD( ureg,

+                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),

+                wpos_input,

+                ureg_scalar(wpostrans, 0),

+                ureg_scalar(wpostrans, 1));

+   } else {

+      /* MAD wpos_temp.y, wpos_input, wpostrans.zzzz, wpostrans.wwww

+       */

+      ureg_MAD( ureg,

+                ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),

+                wpos_input,

+                ureg_scalar(wpostrans, 2),

+                ureg_scalar(wpostrans, 3));

+   }

+

+   /* Use wpos_temp as position input from here on:

+    */

+   t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);

+}

+

+

+/**

+ * Emit fragment position/ooordinate code.

+ */

+static void

+emit_wpos(struct st_context *st,

+          struct st_translate *t,

+          const struct gl_program *program,

+          struct ureg_program *ureg)

+{

+   const struct gl_fragment_program *fp =

+      (const struct gl_fragment_program *) program;

+   struct pipe_screen *pscreen = st->pipe->screen;

+   boolean invert = FALSE;

+

+   if (fp->OriginUpperLeft) {

+      /* Fragment shader wants origin in upper-left */

+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {

+         /* the driver supports upper-left origin */

+      }

+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) {

+         /* the driver supports lower-left origin, need to invert Y */

+         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);

+         invert = TRUE;

+      }

+      else

+         assert(0);

+   }

+   else {

+      /* Fragment shader wants origin in lower-left */

+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT))

+         /* the driver supports lower-left origin */

+         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);

+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT))

+         /* the driver supports upper-left origin, need to invert Y */

+         invert = TRUE;

+      else

+         assert(0);

+   }

+   

+   if (fp->PixelCenterInteger) {

+      /* Fragment shader wants pixel center integer */

+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER))

+         /* the driver supports pixel center integer */

+         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);

+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER))

+         /* the driver supports pixel center half integer, need to bias X,Y */

+         emit_adjusted_wpos(t, program, 0.5f, invert ? 0.5f : -0.5f);

+      else

+         assert(0);

+   }

+   else {

+      /* Fragment shader wants pixel center half integer */

+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {

+         /* the driver supports pixel center half integer */

+      }

+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {

+         /* the driver supports pixel center integer, need to bias X,Y */

+         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);

+         emit_adjusted_wpos(t, program, 0.5f, invert ? -0.5f : 0.5f);

+      }

+      else

+         assert(0);

+   }

+

+   /* we invert after adjustment so that we avoid the MOV to temporary,

+    * and reuse the adjustment ADD instead */

+   emit_wpos_inversion(t, program, invert);

+}

+

+

+/**

+ * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back.

+ * TGSI uses +1 for front, -1 for back.

+ * This function converts the TGSI value to the GL value.  Simply clamping/

+ * saturating the value to [0,1] does the job.

+ */

+static void

+emit_face_var( struct st_translate *t,

+               const struct gl_program *program )

+{

+   struct ureg_program *ureg = t->ureg;

+   struct ureg_dst face_temp = ureg_DECL_temporary( ureg );

+   struct ureg_src face_input = t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]];

+

+   /* MOV_SAT face_temp, input[face]

+    */

+   face_temp = ureg_saturate( face_temp );

+   ureg_MOV( ureg, face_temp, face_input );

+

+   /* Use face_temp as face input from here on:

+    */

+   t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]] = ureg_src(face_temp);

+}

+

+

+static void

+emit_edgeflags( struct st_translate *t,

+                 const struct gl_program *program )

+{

+   struct ureg_program *ureg = t->ureg;

+   struct ureg_dst edge_dst = t->outputs[t->outputMapping[VERT_RESULT_EDGE]];

+   struct ureg_src edge_src = t->inputs[t->inputMapping[VERT_ATTRIB_EDGEFLAG]];

+

+   ureg_MOV( ureg, edge_dst, edge_src );

+}

+

+

+/**

+ * Translate Mesa program to TGSI format.

+ * \param program  the program to translate

+ * \param numInputs  number of input registers used

+ * \param inputMapping  maps Mesa fragment program inputs to TGSI generic

+ *                      input indexes

+ * \param inputSemanticName  the TGSI_SEMANTIC flag for each input

+ * \param inputSemanticIndex  the semantic index (ex: which texcoord) for

+ *                            each input

+ * \param interpMode  the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input

+ * \param numOutputs  number of output registers used

+ * \param outputMapping  maps Mesa fragment program outputs to TGSI

+ *                       generic outputs

+ * \param outputSemanticName  the TGSI_SEMANTIC flag for each output

+ * \param outputSemanticIndex  the semantic index (ex: which texcoord) for

+ *                             each output

+ *

+ * \return  PIPE_OK or PIPE_ERROR_OUT_OF_MEMORY

+ */

+enum pipe_error

+st_translate_mesa_program(

+   struct gl_context *ctx,

+   uint procType,

+   struct ureg_program *ureg,

+   const struct gl_program *program,

+   GLuint numInputs,

+   const GLuint inputMapping[],

+   const ubyte inputSemanticName[],

+   const ubyte inputSemanticIndex[],

+   const GLuint interpMode[],

+   GLuint numOutputs,

+   const GLuint outputMapping[],

+   const ubyte outputSemanticName[],

+   const ubyte outputSemanticIndex[],

+   boolean passthrough_edgeflags )

+{

+   struct st_translate translate, *t;

+   unsigned i;

+   enum pipe_error ret = PIPE_OK;

+

+   assert(numInputs <= Elements(t->inputs));

+   assert(numOutputs <= Elements(t->outputs));

+

+   t = &translate;

+   memset(t, 0, sizeof *t);

+

+   t->procType = procType;

+   t->inputMapping = inputMapping;

+   t->outputMapping = outputMapping;

+   t->ureg = ureg;

+   t->pointSizeOutIndex = -1;

+   t->prevInstWrotePointSize = GL_FALSE;

+

+   /*_mesa_print_program(program);*/

+

+   /*

+    * Declare input attributes.

+    */

+   if (procType == TGSI_PROCESSOR_FRAGMENT) {

+      for (i = 0; i < numInputs; i++) {

+         if (program->InputFlags[0] & PROG_PARAM_BIT_CYL_WRAP) {

+            t->inputs[i] = ureg_DECL_fs_input_cyl(ureg,

+                                                  inputSemanticName[i],

+                                                  inputSemanticIndex[i],

+                                                  interpMode[i],

+                                                  TGSI_CYLINDRICAL_WRAP_X);

+         }

+         else {

+            t->inputs[i] = ureg_DECL_fs_input(ureg,

+                                              inputSemanticName[i],

+                                              inputSemanticIndex[i],

+                                              interpMode[i]);

+         }

+      }

+

+      if (program->InputsRead & FRAG_BIT_WPOS) {

+         /* Must do this after setting up t->inputs, and before

+          * emitting constant references, below:

+          */

+         emit_wpos(st_context(ctx), t, program, ureg);

+      }

+

+      if (program->InputsRead & FRAG_BIT_FACE) {

+         emit_face_var( t, program );

+      }

+

+      /*

+       * Declare output attributes.

+       */

+      for (i = 0; i < numOutputs; i++) {

+         switch (outputSemanticName[i]) {

+         case TGSI_SEMANTIC_POSITION:

+            t->outputs[i] = ureg_DECL_output( ureg,

+                                              TGSI_SEMANTIC_POSITION, /* Z / Depth */

+                                              outputSemanticIndex[i] );

+

+            t->outputs[i] = ureg_writemask( t->outputs[i],

+                                            TGSI_WRITEMASK_Z );

+            break;

+         case TGSI_SEMANTIC_STENCIL:

+            t->outputs[i] = ureg_DECL_output( ureg,

+                                              TGSI_SEMANTIC_STENCIL, /* Stencil */

+                                              outputSemanticIndex[i] );

+            t->outputs[i] = ureg_writemask( t->outputs[i],

+                                            TGSI_WRITEMASK_Y );

+            break;

+         case TGSI_SEMANTIC_COLOR:

+            t->outputs[i] = ureg_DECL_output( ureg,

+                                              TGSI_SEMANTIC_COLOR,

+                                              outputSemanticIndex[i] );

+            break;

+         default:

+            debug_assert(0);

+            return 0;

+         }

+      }

+   }

+   else if (procType == TGSI_PROCESSOR_GEOMETRY) {

+      for (i = 0; i < numInputs; i++) {

+         t->inputs[i] = ureg_DECL_gs_input(ureg,

+                                           i,

+                                           inputSemanticName[i],

+                                           inputSemanticIndex[i]);

+      }

+

+      for (i = 0; i < numOutputs; i++) {

+         t->outputs[i] = ureg_DECL_output( ureg,

+                                           outputSemanticName[i],

+                                           outputSemanticIndex[i] );

+      }

+   }

+   else {

+      assert(procType == TGSI_PROCESSOR_VERTEX);

+

+      for (i = 0; i < numInputs; i++) {

+         t->inputs[i] = ureg_DECL_vs_input(ureg, i);

+      }

+

+      for (i = 0; i < numOutputs; i++) {

+         t->outputs[i] = ureg_DECL_output( ureg,

+                                           outputSemanticName[i],

+                                           outputSemanticIndex[i] );

+         if ((outputSemanticName[i] == TGSI_SEMANTIC_PSIZE) && program->Id) {

+            /* Writing to the point size result register requires special

+             * handling to implement clamping.

+             */

+            static const gl_state_index pointSizeClampState[STATE_LENGTH]

+               = { STATE_INTERNAL, STATE_POINT_SIZE_IMPL_CLAMP, 0, 0, 0 };

+               /* XXX: note we are modifying the incoming shader here!  Need to

+               * do this before emitting the constant decls below, or this

+               * will be missed:

+               */

+            unsigned pointSizeClampConst =

+               _mesa_add_state_reference(program->Parameters,

+                                         pointSizeClampState);

+            struct ureg_dst psizregtemp = ureg_DECL_temporary( ureg );

+            t->pointSizeConst = ureg_DECL_constant( ureg, pointSizeClampConst );

+            t->pointSizeResult = t->outputs[i];

+            t->pointSizeOutIndex = i;

+            t->outputs[i] = psizregtemp;

+         }

+      }

+      if (passthrough_edgeflags)

+         emit_edgeflags( t, program );

+   }

+

+   /* Declare address register.

+    */

+   if (program->NumAddressRegs > 0) {

+      debug_assert( program->NumAddressRegs == 1 );

+      t->address[0] = ureg_DECL_address( ureg );

+   }

+

+   /* Declare misc input registers

+    */

+   {

+      GLbitfield sysInputs = program->SystemValuesRead;

+      unsigned numSys = 0;

+      for (i = 0; sysInputs; i++) {

+         if (sysInputs & (1 << i)) {

+            unsigned semName = mesa_sysval_to_semantic[i];

+            t->systemValues[i] = ureg_DECL_system_value(ureg, numSys, semName, 0);

+            numSys++;

+            sysInputs &= ~(1 << i);

+         }

+      }

+   }

+

+   if (program->IndirectRegisterFiles & (1 << PROGRAM_TEMPORARY)) {

+      /* If temps are accessed with indirect addressing, declare temporaries

+       * in sequential order.  Else, we declare them on demand elsewhere.

+       */

+      for (i = 0; i < program->NumTemporaries; i++) {

+         /* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */

+         t->temps[i] = ureg_DECL_temporary( t->ureg );

+      }

+   }

+

+   /* Emit constants and immediates.  Mesa uses a single index space

+    * for these, so we put all the translated regs in t->constants.

+    */

+   if (program->Parameters) {

+      t->constants = CALLOC( program->Parameters->NumParameters,

+                             sizeof t->constants[0] );

+      if (t->constants == NULL) {

+         ret = PIPE_ERROR_OUT_OF_MEMORY;

+         goto out;

+      }

+

+      for (i = 0; i < program->Parameters->NumParameters; i++) {

+         switch (program->Parameters->Parameters[i].Type) {

+         case PROGRAM_ENV_PARAM:

+         case PROGRAM_LOCAL_PARAM:

+         case PROGRAM_STATE_VAR:

+         case PROGRAM_NAMED_PARAM:

+         case PROGRAM_UNIFORM:

+            t->constants[i] = ureg_DECL_constant( ureg, i );

+            break;

+

+            /* Emit immediates only when there's no indirect addressing of

+             * the const buffer.

+             * FIXME: Be smarter and recognize param arrays:

+             * indirect addressing is only valid within the referenced

+             * array.

+             */

+         case PROGRAM_CONSTANT:

+            if (program->IndirectRegisterFiles & PROGRAM_ANY_CONST)

+               t->constants[i] = ureg_DECL_constant( ureg, i );

+            else

+               t->constants[i] = 

+                  ureg_DECL_immediate( ureg,

+                                       program->Parameters->ParameterValues[i],

+                                       4 );

+            break;

+         default:

+            break;

+         }

+      }

+   }

+

+   /* texture samplers */

+   for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {

+      if (program->SamplersUsed & (1 << i)) {

+         t->samplers[i] = ureg_DECL_sampler( ureg, i );

+      }

+   }

+

+   /* Emit each instruction in turn:

+    */

+   for (i = 0; i < program->NumInstructions; i++) {

+      set_insn_start( t, ureg_get_instruction_number( ureg ));

+      compile_instruction( t, &program->Instructions[i] );

+

+      if (t->prevInstWrotePointSize && program->Id) {

+         /* The previous instruction wrote to the (fake) vertex point size

+          * result register.  Now we need to clamp that value to the min/max

+          * point size range, putting the result into the real point size

+          * register.

+          * Note that we can't do this easily at the end of program due to

+          * possible early return.

+          */

+         set_insn_start( t, ureg_get_instruction_number( ureg ));

+         ureg_MAX( t->ureg,

+                   ureg_writemask(t->outputs[t->pointSizeOutIndex], WRITEMASK_X),

+                   ureg_src(t->outputs[t->pointSizeOutIndex]),

+                   ureg_swizzle(t->pointSizeConst, 1,1,1,1));

+         ureg_MIN( t->ureg, ureg_writemask(t->pointSizeResult, WRITEMASK_X),

+                   ureg_src(t->outputs[t->pointSizeOutIndex]),

+                   ureg_swizzle(t->pointSizeConst, 2,2,2,2));

+      }

+      t->prevInstWrotePointSize = GL_FALSE;

+   }

+

+   /* Fix up all emitted labels:

+    */

+   for (i = 0; i < t->labels_count; i++) {

+      ureg_fixup_label( ureg,

+                        t->labels[i].token,

+                        t->insn[t->labels[i].branch_target] );

+   }

+

+out:

+   FREE(t->insn);

+   FREE(t->labels);

+   FREE(t->constants);

+

+   if (t->error) {

+      debug_printf("%s: translate error flag set\n", __FUNCTION__);

+   }

+

+   return ret;

+}

+

+

+/**

+ * Tokens cannot be free with free otherwise the builtin gallium

+ * malloc debugging will get confused.

+ */

+void

+st_free_tokens(const struct tgsi_token *tokens)

+{

+   FREE((void *)tokens);

+}

diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c
index fc1dfb3ef..e5c26c563 100644
--- a/mesalib/src/mesa/state_tracker/st_program.c
+++ b/mesalib/src/mesa/state_tracker/st_program.c
@@ -1,1165 +1,1165 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
-
-
-#include "main/imports.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "program/prog_parameter.h"
-#include "program/prog_print.h"
-#include "program/programopt.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-#include "draw/draw_context.h"
-#include "tgsi/tgsi_dump.h"
-#include "tgsi/tgsi_ureg.h"
-
-#include "st_debug.h"
-#include "st_cb_bitmap.h"
-#include "st_cb_drawpixels.h"
-#include "st_context.h"
-#include "st_program.h"
-#include "st_mesa_to_tgsi.h"
-#include "cso_cache/cso_context.h"
-
-
-
-/**
- * Delete a vertex program variant.  Note the caller must unlink
- * the variant from the linked list.
- */
-static void
-delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
-{
-   if (vpv->driver_shader) 
-      cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
-      
-#if FEATURE_feedback || FEATURE_rastpos
-   if (vpv->draw_shader)
-      draw_delete_vertex_shader( st->draw, vpv->draw_shader );
-#endif
-      
-   if (vpv->tgsi.tokens)
-      st_free_tokens(vpv->tgsi.tokens);
-      
-   FREE( vpv );
-}
-
-
-
-/**
- * Clean out any old compilations:
- */
-void
-st_release_vp_variants( struct st_context *st,
-                        struct st_vertex_program *stvp )
-{
-   struct st_vp_variant *vpv;
-
-   for (vpv = stvp->variants; vpv; ) {
-      struct st_vp_variant *next = vpv->next;
-      delete_vp_variant(st, vpv);
-      vpv = next;
-   }
-
-   stvp->variants = NULL;
-}
-
-
-
-/**
- * Delete a fragment program variant.  Note the caller must unlink
- * the variant from the linked list.
- */
-static void
-delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
-{
-   if (fpv->driver_shader) 
-      cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
-   if (fpv->parameters)
-      _mesa_free_parameter_list(fpv->parameters);
-      
-   FREE(fpv);
-}
-
-
-/**
- * Free all variants of a fragment program.
- */
-void
-st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
-{
-   struct st_fp_variant *fpv;
-
-   for (fpv = stfp->variants; fpv; ) {
-      struct st_fp_variant *next = fpv->next;
-      delete_fp_variant(st, fpv);
-      fpv = next;
-   }
-
-   stfp->variants = NULL;
-}
-
-
-/**
- * Delete a geometry program variant.  Note the caller must unlink
- * the variant from the linked list.
- */
-static void
-delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
-{
-   if (gpv->driver_shader) 
-      cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
-      
-   FREE(gpv);
-}
-
-
-/**
- * Free all variants of a geometry program.
- */
-void
-st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
-{
-   struct st_gp_variant *gpv;
-
-   for (gpv = stgp->variants; gpv; ) {
-      struct st_gp_variant *next = gpv->next;
-      delete_gp_variant(st, gpv);
-      gpv = next;
-   }
-
-   stgp->variants = NULL;
-}
-
-
-
-
-/**
- * Translate a Mesa vertex shader into a TGSI shader.
- * \param outputMapping  to map vertex program output registers (VERT_RESULT_x)
- *       to TGSI output slots
- * \param tokensOut  destination for TGSI tokens
- * \return  pointer to cached pipe_shader object.
- */
-static void
-st_prepare_vertex_program(struct st_context *st,
-                            struct st_vertex_program *stvp)
-{
-   GLuint attr;
-
-   stvp->num_inputs = 0;
-   stvp->num_outputs = 0;
-
-   if (stvp->Base.IsPositionInvariant)
-      _mesa_insert_mvp_code(st->ctx, &stvp->Base);
-
-   assert(stvp->Base.Base.NumInstructions > 1);
-
-   /*
-    * Determine number of inputs, the mappings between VERT_ATTRIB_x
-    * and TGSI generic input indexes, plus input attrib semantic info.
-    */
-   for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-      if (stvp->Base.Base.InputsRead & (1 << attr)) {
-         stvp->input_to_index[attr] = stvp->num_inputs;
-         stvp->index_to_input[stvp->num_inputs] = attr;
-         stvp->num_inputs++;
-      }
-   }
-   /* bit of a hack, presetup potentially unused edgeflag input */
-   stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
-   stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
-
-   /* Compute mapping of vertex program outputs to slots.
-    */
-   for (attr = 0; attr < VERT_RESULT_MAX; attr++) {
-      if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
-         stvp->result_to_output[attr] = ~0;
-      }
-      else {
-         unsigned slot = stvp->num_outputs++;
-
-         stvp->result_to_output[attr] = slot;
-
-         switch (attr) {
-         case VERT_RESULT_HPOS:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
-            stvp->output_semantic_index[slot] = 0;
-            break;
-         case VERT_RESULT_COL0:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            stvp->output_semantic_index[slot] = 0;
-            break;
-         case VERT_RESULT_COL1:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            stvp->output_semantic_index[slot] = 1;
-            break;
-         case VERT_RESULT_BFC0:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
-            stvp->output_semantic_index[slot] = 0;
-            break;
-         case VERT_RESULT_BFC1:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
-            stvp->output_semantic_index[slot] = 1;
-            break;
-         case VERT_RESULT_FOGC:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
-            stvp->output_semantic_index[slot] = 0;
-            break;
-         case VERT_RESULT_PSIZ:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
-            stvp->output_semantic_index[slot] = 0;
-            break;
-         case VERT_RESULT_EDGE:
-            assert(0);
-            break;
-
-         case VERT_RESULT_TEX0:
-         case VERT_RESULT_TEX1:
-         case VERT_RESULT_TEX2:
-         case VERT_RESULT_TEX3:
-         case VERT_RESULT_TEX4:
-         case VERT_RESULT_TEX5:
-         case VERT_RESULT_TEX6:
-         case VERT_RESULT_TEX7:
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            stvp->output_semantic_index[slot] = attr - VERT_RESULT_TEX0;
-            break;
-
-         case VERT_RESULT_VAR0:
-         default:
-            assert(attr < VERT_RESULT_MAX);
-            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            stvp->output_semantic_index[slot] = (FRAG_ATTRIB_VAR0 - 
-                                                FRAG_ATTRIB_TEX0 +
-                                                attr - 
-                                                VERT_RESULT_VAR0);
-            break;
-         }
-      }
-   }
-   /* similar hack to above, presetup potentially unused edgeflag output */
-   stvp->result_to_output[VERT_RESULT_EDGE] = stvp->num_outputs;
-   stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
-   stvp->output_semantic_index[stvp->num_outputs] = 0;
-}
-
-
-/**
- * Translate a vertex program to create a new variant.
- */
-static struct st_vp_variant *
-st_translate_vertex_program(struct st_context *st,
-                            struct st_vertex_program *stvp,
-                            const struct st_vp_variant_key *key)
-{
-   struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
-   struct pipe_context *pipe = st->pipe;
-   struct ureg_program *ureg;
-   enum pipe_error error;
-   unsigned num_outputs;
-
-   st_prepare_vertex_program( st, stvp );
-
-   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
-   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
-
-   ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
-   if (ureg == NULL) {
-      FREE(vpv);
-      return NULL;
-   }
-
-   vpv->key = *key;
-
-   vpv->num_inputs = stvp->num_inputs;
-   num_outputs = stvp->num_outputs;
-   if (key->passthrough_edgeflags) {
-      vpv->num_inputs++;
-      num_outputs++;
-   }
-
-   if (ST_DEBUG & DEBUG_MESA) {
-      _mesa_print_program(&stvp->Base.Base);
-      _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
-      debug_printf("\n");
-   }
-
-   error = st_translate_mesa_program(st->ctx,
-                                     TGSI_PROCESSOR_VERTEX,
-                                     ureg,
-                                     &stvp->Base.Base,
-                                     /* inputs */
-                                     vpv->num_inputs,
-                                     stvp->input_to_index,
-                                     NULL, /* input semantic name */
-                                     NULL, /* input semantic index */
-                                     NULL,
-                                     /* outputs */
-                                     num_outputs,
-                                     stvp->result_to_output,
-                                     stvp->output_semantic_name,
-                                     stvp->output_semantic_index,
-                                     key->passthrough_edgeflags );
-
-   if (error)
-      goto fail;
-
-   vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
-   if (!vpv->tgsi.tokens)
-      goto fail;
-
-   ureg_destroy( ureg );
-
-   vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
-
-   if (ST_DEBUG & DEBUG_TGSI) {
-      tgsi_dump( vpv->tgsi.tokens, 0 );
-      debug_printf("\n");
-   }
-
-   return vpv;
-
-fail:
-   debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
-   _mesa_print_program(&stvp->Base.Base);
-   debug_assert(0);
-
-   ureg_destroy( ureg );
-   return NULL;
-}
-
-
-/**
- * Find/create a vertex program variant.
- */
-struct st_vp_variant *
-st_get_vp_variant(struct st_context *st,
-                  struct st_vertex_program *stvp,
-                  const struct st_vp_variant_key *key)
-{
-   struct st_vp_variant *vpv;
-
-   /* Search for existing variant */
-   for (vpv = stvp->variants; vpv; vpv = vpv->next) {
-      if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
-         break;
-      }
-   }
-
-   if (!vpv) {
-      /* create now */
-      vpv = st_translate_vertex_program(st, stvp, key);
-      if (vpv) {
-         /* insert into list */
-         vpv->next = stvp->variants;
-         stvp->variants = vpv;
-      }
-   }
-
-   return vpv;
-}
-
-
-/**
- * Translate a Mesa fragment shader into a TGSI shader using extra info in
- * the key.
- * \return  new fragment program variant
- */
-static struct st_fp_variant *
-st_translate_fragment_program(struct st_context *st,
-                              struct st_fragment_program *stfp,
-                              const struct st_fp_variant_key *key)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
-   GLboolean deleteFP = GL_FALSE;
-
-   if (!variant)
-      return NULL;
-
-   assert(!(key->bitmap && key->drawpixels));
-
-#if FEATURE_drawpix
-   if (key->bitmap) {
-      /* glBitmap drawing */
-      struct gl_fragment_program *fp; /* we free this temp program below */
-
-      st_make_bitmap_fragment_program(st, &stfp->Base,
-                                      &fp, &variant->bitmap_sampler);
-
-      variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
-      stfp = st_fragment_program(fp);
-      deleteFP = GL_TRUE;
-   }
-   else if (key->drawpixels) {
-      /* glDrawPixels drawing */
-      struct gl_fragment_program *fp; /* we free this temp program below */
-
-      if (key->drawpixels_z || key->drawpixels_stencil) {
-         fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
-                                                key->drawpixels_stencil);
-      }
-      else {
-         /* RGBA */
-         st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
-         variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
-         deleteFP = GL_TRUE;
-      }
-      stfp = st_fragment_program(fp);
-   }
-#endif
-
-   if (!stfp->tgsi.tokens) {
-      /* need to translate Mesa instructions to TGSI now */
-      GLuint outputMapping[FRAG_RESULT_MAX];
-      GLuint inputMapping[FRAG_ATTRIB_MAX];
-      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
-      GLuint attr;
-      enum pipe_error error;
-      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
-      struct ureg_program *ureg;
-      GLboolean write_all = GL_FALSE;
-
-      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
-      ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
-      uint fs_num_inputs = 0;
-
-      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
-      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
-      uint fs_num_outputs = 0;
-
-
-      _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
-
-      /*
-       * Convert Mesa program inputs to TGSI input register semantics.
-       */
-      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
-         if (inputsRead & (1 << attr)) {
-            const GLuint slot = fs_num_inputs++;
-
-            inputMapping[attr] = slot;
-
-            switch (attr) {
-            case FRAG_ATTRIB_WPOS:
-               input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
-               input_semantic_index[slot] = 0;
-               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-               break;
-            case FRAG_ATTRIB_COL0:
-               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-               input_semantic_index[slot] = 0;
-               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-               break;
-            case FRAG_ATTRIB_COL1:
-               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-               input_semantic_index[slot] = 1;
-               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-               break;
-            case FRAG_ATTRIB_FOGC:
-               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
-               input_semantic_index[slot] = 0;
-               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
-               break;
-            case FRAG_ATTRIB_FACE:
-               input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
-               input_semantic_index[slot] = 0;
-               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
-               break;
-               /* In most cases, there is nothing special about these
-                * inputs, so adopt a convention to use the generic
-                * semantic name and the mesa FRAG_ATTRIB_ number as the
-                * index. 
-                * 
-                * All that is required is that the vertex shader labels
-                * its own outputs similarly, and that the vertex shader
-                * generates at least every output required by the
-                * fragment shader plus fixed-function hardware (such as
-                * BFC).
-                * 
-                * There is no requirement that semantic indexes start at
-                * zero or be restricted to a particular range -- nobody
-                * should be building tables based on semantic index.
-                */
-            case FRAG_ATTRIB_PNTC:
-            case FRAG_ATTRIB_TEX0:
-            case FRAG_ATTRIB_TEX1:
-            case FRAG_ATTRIB_TEX2:
-            case FRAG_ATTRIB_TEX3:
-            case FRAG_ATTRIB_TEX4:
-            case FRAG_ATTRIB_TEX5:
-            case FRAG_ATTRIB_TEX6:
-            case FRAG_ATTRIB_TEX7:
-            case FRAG_ATTRIB_VAR0:
-            default:
-               /* Actually, let's try and zero-base this just for
-                * readability of the generated TGSI.
-                */
-               assert(attr >= FRAG_ATTRIB_TEX0);
-               input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
-               input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-               if (attr == FRAG_ATTRIB_PNTC)
-                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-               else
-                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
-               break;
-            }
-         }
-         else {
-            inputMapping[attr] = -1;
-         }
-      }
-
-      /*
-       * Semantics and mapping for outputs
-       */
-      {
-         uint numColors = 0;
-         GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
-
-         /* if z is written, emit that first */
-         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
-            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
-            fs_output_semantic_index[fs_num_outputs] = 0;
-            outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
-            fs_num_outputs++;
-            outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
-         }
-
-         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
-            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
-            fs_output_semantic_index[fs_num_outputs] = 0;
-            outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
-            fs_num_outputs++;
-            outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
-         }
-
-         /* handle remaning outputs (color) */
-         for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
-            if (outputsWritten & BITFIELD64_BIT(attr)) {
-               switch (attr) {
-               case FRAG_RESULT_DEPTH:
-               case FRAG_RESULT_STENCIL:
-                  /* handled above */
-                  assert(0);
-                  break;
-               case FRAG_RESULT_COLOR:
-                  write_all = GL_TRUE; /* fallthrough */
-               default:
-                  assert(attr == FRAG_RESULT_COLOR ||
-                         (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
-                  fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
-                  fs_output_semantic_index[fs_num_outputs] = numColors;
-                  outputMapping[attr] = fs_num_outputs;
-                  numColors++;
-                  break;
-               }
-
-               fs_num_outputs++;
-            }
-         }
-      }
-
-      ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
-      if (ureg == NULL)
-         return NULL;
-
-      if (ST_DEBUG & DEBUG_MESA) {
-         _mesa_print_program(&stfp->Base.Base);
-         _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
-         debug_printf("\n");
-      }
-      if (write_all == GL_TRUE)
-         ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
-
-      error = st_translate_mesa_program(st->ctx,
-                                        TGSI_PROCESSOR_FRAGMENT,
-                                        ureg,
-                                        &stfp->Base.Base,
-                                        /* inputs */
-                                        fs_num_inputs,
-                                        inputMapping,
-                                        input_semantic_name,
-                                        input_semantic_index,
-                                        interpMode,
-                                        /* outputs */
-                                        fs_num_outputs,
-                                        outputMapping,
-                                        fs_output_semantic_name,
-                                        fs_output_semantic_index, FALSE );
-
-      stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
-      ureg_destroy( ureg );
-   }
-
-   /* fill in variant */
-   variant->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
-   variant->key = *key;
-
-   if (ST_DEBUG & DEBUG_TGSI) {
-      tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
-      debug_printf("\n");
-   }
-
-   if (deleteFP) {
-      /* Free the temporary program made above */
-      struct gl_fragment_program *fp = &stfp->Base;
-      _mesa_reference_fragprog(st->ctx, &fp, NULL);
-   }
-
-   return variant;
-}
-
-
-/**
- * Translate fragment program if needed.
- */
-struct st_fp_variant *
-st_get_fp_variant(struct st_context *st,
-                  struct st_fragment_program *stfp,
-                  const struct st_fp_variant_key *key)
-{
-   struct st_fp_variant *fpv;
-
-   /* Search for existing variant */
-   for (fpv = stfp->variants; fpv; fpv = fpv->next) {
-      if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
-         break;
-      }
-   }
-
-   if (!fpv) {
-      /* create new */
-      fpv = st_translate_fragment_program(st, stfp, key);
-      if (fpv) {
-         /* insert into list */
-         fpv->next = stfp->variants;
-         stfp->variants = fpv;
-      }
-   }
-
-   return fpv;
-}
-
-
-/**
- * Translate a geometry program to create a new variant.
- */
-static struct st_gp_variant *
-st_translate_geometry_program(struct st_context *st,
-                              struct st_geometry_program *stgp,
-                              const struct st_gp_variant_key *key)
-{
-   GLuint inputMapping[GEOM_ATTRIB_MAX];
-   GLuint outputMapping[GEOM_RESULT_MAX];
-   struct pipe_context *pipe = st->pipe;
-   enum pipe_error error;
-   GLuint attr;
-   const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
-   GLuint vslot = 0;
-   GLuint num_generic = 0;
-
-   uint gs_num_inputs = 0;
-   uint gs_builtin_inputs = 0;
-   uint gs_array_offset = 0;
-
-   ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
-   ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
-   uint gs_num_outputs = 0;
-
-   GLint i;
-   GLuint maxSlot = 0;
-   struct ureg_program *ureg;
-
-   struct st_gp_variant *gpv;
-
-   gpv = CALLOC_STRUCT(st_gp_variant);
-   if (!gpv)
-      return NULL;
-
-   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
-   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
-
-   ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
-   if (ureg == NULL) {
-      FREE(gpv);
-      return NULL;
-   }
-
-   /* which vertex output goes to the first geometry input */
-   vslot = 0;
-
-   memset(inputMapping, 0, sizeof(inputMapping));
-   memset(outputMapping, 0, sizeof(outputMapping));
-
-   /*
-    * Convert Mesa program inputs to TGSI input register semantics.
-    */
-   for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {
-      if (inputsRead & (1 << attr)) {
-         const GLuint slot = gs_num_inputs;
-
-         gs_num_inputs++;
-
-         inputMapping[attr] = slot;
-
-         stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
-         stgp->input_to_index[attr] = vslot;
-         stgp->index_to_input[vslot] = attr;
-         ++vslot;
-
-         if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {
-            gs_array_offset += 2;
-         } else
-            ++gs_builtin_inputs;
-
-#if 0
-         debug_printf("input map at %d = %d\n",
-                      slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
-#endif
-
-         switch (attr) {
-         case GEOM_ATTRIB_PRIMITIVE_ID:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
-            stgp->input_semantic_index[slot] = 0;
-            break;
-         case GEOM_ATTRIB_POSITION:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
-            stgp->input_semantic_index[slot] = 0;
-            break;
-         case GEOM_ATTRIB_COLOR0:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            stgp->input_semantic_index[slot] = 0;
-            break;
-         case GEOM_ATTRIB_COLOR1:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            stgp->input_semantic_index[slot] = 1;
-            break;
-         case GEOM_ATTRIB_FOG_FRAG_COORD:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
-            stgp->input_semantic_index[slot] = 0;
-            break;
-         case GEOM_ATTRIB_TEX_COORD:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            stgp->input_semantic_index[slot] = num_generic++;
-            break;
-         case GEOM_ATTRIB_VAR0:
-            /* fall-through */
-         default:
-            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            stgp->input_semantic_index[slot] = num_generic++;
-         }
-      }
-   }
-
-   /* initialize output semantics to defaults */
-   for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
-      gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
-      gs_output_semantic_index[i] = 0;
-   }
-
-   num_generic = 0;
-   /*
-    * Determine number of outputs, the (default) output register
-    * mapping and the semantic information for each output.
-    */
-   for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
-      if (stgp->Base.Base.OutputsWritten & (1 << attr)) {
-         GLuint slot;
-
-         slot = gs_num_outputs;
-         gs_num_outputs++;
-         outputMapping[attr] = slot;
-
-         switch (attr) {
-         case GEOM_RESULT_POS:
-            assert(slot == 0);
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
-            gs_output_semantic_index[slot] = 0;
-            break;
-         case GEOM_RESULT_COL0:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            gs_output_semantic_index[slot] = 0;
-            break;
-         case GEOM_RESULT_COL1:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            gs_output_semantic_index[slot] = 1;
-            break;
-         case GEOM_RESULT_SCOL0:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
-            gs_output_semantic_index[slot] = 0;
-            break;
-         case GEOM_RESULT_SCOL1:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
-            gs_output_semantic_index[slot] = 1;
-            break;
-         case GEOM_RESULT_FOGC:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
-            gs_output_semantic_index[slot] = 0;
-            break;
-         case GEOM_RESULT_PSIZ:
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
-            gs_output_semantic_index[slot] = 0;
-            break;
-         case GEOM_RESULT_TEX0:
-         case GEOM_RESULT_TEX1:
-         case GEOM_RESULT_TEX2:
-         case GEOM_RESULT_TEX3:
-         case GEOM_RESULT_TEX4:
-         case GEOM_RESULT_TEX5:
-         case GEOM_RESULT_TEX6:
-         case GEOM_RESULT_TEX7:
-            /* fall-through */
-         case GEOM_RESULT_VAR0:
-            /* fall-through */
-         default:
-            assert(slot < Elements(gs_output_semantic_name));
-            /* use default semantic info */
-            gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            gs_output_semantic_index[slot] = num_generic++;
-         }
-      }
-   }
-
-   assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
-
-   /* find max output slot referenced to compute gs_num_outputs */
-   for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {
-      if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
-         maxSlot = outputMapping[attr];
-   }
-   gs_num_outputs = maxSlot + 1;
-
-#if 0 /* debug */
-   {
-      GLuint i;
-      printf("outputMapping? %d\n", outputMapping ? 1 : 0);
-      if (outputMapping) {
-         printf("attr -> slot\n");
-         for (i = 0; i < 16;  i++) {
-            printf(" %2d       %3d\n", i, outputMapping[i]);
-         }
-      }
-      printf("slot    sem_name  sem_index\n");
-      for (i = 0; i < gs_num_outputs; i++) {
-         printf(" %2d         %d         %d\n",
-                i,
-                gs_output_semantic_name[i],
-                gs_output_semantic_index[i]);
-      }
-   }
-#endif
-
-   /* free old shader state, if any */
-   if (stgp->tgsi.tokens) {
-      st_free_tokens(stgp->tgsi.tokens);
-      stgp->tgsi.tokens = NULL;
-   }
-
-   ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
-   ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
-   ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
-
-   error = st_translate_mesa_program(st->ctx,
-                                     TGSI_PROCESSOR_GEOMETRY,
-                                     ureg,
-                                     &stgp->Base.Base,
-                                     /* inputs */
-                                     gs_num_inputs,
-                                     inputMapping,
-                                     stgp->input_semantic_name,
-                                     stgp->input_semantic_index,
-                                     NULL,
-                                     /* outputs */
-                                     gs_num_outputs,
-                                     outputMapping,
-                                     gs_output_semantic_name,
-                                     gs_output_semantic_index,
-                                     FALSE);
-
-   stgp->num_inputs = gs_num_inputs;
-   stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
-   ureg_destroy( ureg );
-
-   /* fill in new variant */
-   gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
-   gpv->key = *key;
-
-   if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
-      _mesa_print_program(&stgp->Base.Base);
-      debug_printf("\n");
-   }
-
-   if (ST_DEBUG & DEBUG_TGSI) {
-      tgsi_dump(stgp->tgsi.tokens, 0);
-      debug_printf("\n");
-   }
-
-   return gpv;
-}
-
-
-/**
- * Get/create geometry program variant.
- */
-struct st_gp_variant *
-st_get_gp_variant(struct st_context *st,
-                  struct st_geometry_program *stgp,
-                  const struct st_gp_variant_key *key)
-{
-   struct st_gp_variant *gpv;
-
-   /* Search for existing variant */
-   for (gpv = stgp->variants; gpv; gpv = gpv->next) {
-      if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
-         break;
-      }
-   }
-
-   if (!gpv) {
-      /* create new */
-      gpv = st_translate_geometry_program(st, stgp, key);
-      if (gpv) {
-         /* insert into list */
-         gpv->next = stgp->variants;
-         stgp->variants = gpv;
-      }
-   }
-
-   return gpv;
-}
-
-
-
-
-/**
- * Debug- print current shader text
- */
-void
-st_print_shaders(struct gl_context *ctx)
-{
-   struct gl_shader_program *shProg[3] = {
-      ctx->Shader.CurrentVertexProgram,
-      ctx->Shader.CurrentGeometryProgram,
-      ctx->Shader.CurrentFragmentProgram,
-   };
-   unsigned j;
-
-   for (j = 0; j < 3; j++) {
-      unsigned i;
-
-      if (shProg[j] == NULL)
-	 continue;
-
-      for (i = 0; i < shProg[j]->NumShaders; i++) {
-	 struct gl_shader *sh;
-
-	 switch (shProg[j]->Shaders[i]->Type) {
-	 case GL_VERTEX_SHADER:
-	    sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
-	    break;
-	 case GL_GEOMETRY_SHADER_ARB:
-	    sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
-	    break;
-	 case GL_FRAGMENT_SHADER:
-	    sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
-	    break;
-	 default:
-	    assert(0);
-	    sh = NULL;
-	    break;
-	 }
-
-	 if (sh != NULL) {
-	    printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
-	    printf("%s\n", sh->Source);
-	 }
-      }
-   }
-}
-
-
-/**
- * Vert/Geom/Frag programs have per-context variants.  Free all the
- * variants attached to the given program which match the given context.
- */
-static void
-destroy_program_variants(struct st_context *st, struct gl_program *program)
-{
-   if (!program)
-      return;
-
-   switch (program->Target) {
-   case GL_VERTEX_PROGRAM_ARB:
-      {
-         struct st_vertex_program *stvp = (struct st_vertex_program *) program;
-         struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
-
-         for (vpv = stvp->variants; vpv; ) {
-            struct st_vp_variant *next = vpv->next;
-            if (vpv->key.st == st) {
-               /* unlink from list */
-               *prevPtr = next;
-               /* destroy this variant */
-               delete_vp_variant(st, vpv);
-            }
-            else {
-               prevPtr = &vpv->next;
-            }
-            vpv = next;
-         }
-      }
-      break;
-   case GL_FRAGMENT_PROGRAM_ARB:
-      {
-         struct st_fragment_program *stfp =
-            (struct st_fragment_program *) program;
-         struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
-
-         for (fpv = stfp->variants; fpv; ) {
-            struct st_fp_variant *next = fpv->next;
-            if (fpv->key.st == st) {
-               /* unlink from list */
-               *prevPtr = next;
-               /* destroy this variant */
-               delete_fp_variant(st, fpv);
-            }
-            else {
-               prevPtr = &fpv->next;
-            }
-            fpv = next;
-         }
-      }
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      {
-         struct st_geometry_program *stgp =
-            (struct st_geometry_program *) program;
-         struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
-
-         for (gpv = stgp->variants; gpv; ) {
-            struct st_gp_variant *next = gpv->next;
-            if (gpv->key.st == st) {
-               /* unlink from list */
-               *prevPtr = next;
-               /* destroy this variant */
-               delete_gp_variant(st, gpv);
-            }
-            else {
-               prevPtr = &gpv->next;
-            }
-            gpv = next;
-         }
-      }
-      break;
-   default:
-      _mesa_problem(NULL, "Unexpected program target in "
-                    "destroy_program_variants_cb()");
-   }
-}
-
-
-/**
- * Callback for _mesa_HashWalk.  Free all the shader's program variants
- * which match the given context.
- */
-static void
-destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
-{
-   struct st_context *st = (struct st_context *) userData;
-   struct gl_shader *shader = (struct gl_shader *) data;
-
-   switch (shader->Type) {
-   case GL_SHADER_PROGRAM_MESA:
-      {
-         struct gl_shader_program *shProg = (struct gl_shader_program *) data;
-         GLuint i;
-
-         for (i = 0; i < shProg->NumShaders; i++) {
-            destroy_program_variants(st, shProg->Shaders[i]->Program);
-         }
-
-         destroy_program_variants(st, (struct gl_program *)
-                                  shProg->VertexProgram);
-         destroy_program_variants(st, (struct gl_program *)
-                                  shProg->FragmentProgram);
-         destroy_program_variants(st, (struct gl_program *)
-                                  shProg->GeometryProgram);
-      }
-      break;
-   case GL_VERTEX_SHADER:
-   case GL_FRAGMENT_SHADER:
-   case GL_GEOMETRY_SHADER:
-      {
-         destroy_program_variants(st, shader->Program);
-      }
-      break;
-   default:
-      assert(0);
-   }
-}
-
-
-/**
- * Callback for _mesa_HashWalk.  Free all the program variants which match
- * the given context.
- */
-static void
-destroy_program_variants_cb(GLuint key, void *data, void *userData)
-{
-   struct st_context *st = (struct st_context *) userData;
-   struct gl_program *program = (struct gl_program *) data;
-   destroy_program_variants(st, program);
-}
-
-
-/**
- * Walk over all shaders and programs to delete any variants which
- * belong to the given context.
- * This is called during context tear-down.
- */
-void
-st_destroy_program_variants(struct st_context *st)
-{
-   /* ARB vert/frag program */
-   _mesa_HashWalk(st->ctx->Shared->Programs,
-                  destroy_program_variants_cb, st);
-
-   /* GLSL vert/frag/geom shaders */
-   _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
-                  destroy_shader_program_variants_cb, st);
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, 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 TUNGSTEN GRAPHICS AND/OR ITS 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:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+

+

+#include "main/imports.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "program/prog_parameter.h"

+#include "program/prog_print.h"

+#include "program/programopt.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_shader_tokens.h"

+#include "draw/draw_context.h"

+#include "tgsi/tgsi_dump.h"

+#include "tgsi/tgsi_ureg.h"

+

+#include "st_debug.h"

+#include "st_cb_bitmap.h"

+#include "st_cb_drawpixels.h"

+#include "st_context.h"

+#include "st_program.h"

+#include "st_mesa_to_tgsi.h"

+#include "cso_cache/cso_context.h"

+

+

+

+/**

+ * Delete a vertex program variant.  Note the caller must unlink

+ * the variant from the linked list.

+ */

+static void

+delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)

+{

+   if (vpv->driver_shader) 

+      cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);

+      

+#if FEATURE_feedback || FEATURE_rastpos

+   if (vpv->draw_shader)

+      draw_delete_vertex_shader( st->draw, vpv->draw_shader );

+#endif

+      

+   if (vpv->tgsi.tokens)

+      st_free_tokens(vpv->tgsi.tokens);

+      

+   FREE( vpv );

+}

+

+

+

+/**

+ * Clean out any old compilations:

+ */

+void

+st_release_vp_variants( struct st_context *st,

+                        struct st_vertex_program *stvp )

+{

+   struct st_vp_variant *vpv;

+

+   for (vpv = stvp->variants; vpv; ) {

+      struct st_vp_variant *next = vpv->next;

+      delete_vp_variant(st, vpv);

+      vpv = next;

+   }

+

+   stvp->variants = NULL;

+}

+

+

+

+/**

+ * Delete a fragment program variant.  Note the caller must unlink

+ * the variant from the linked list.

+ */

+static void

+delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)

+{

+   if (fpv->driver_shader) 

+      cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);

+   if (fpv->parameters)

+      _mesa_free_parameter_list(fpv->parameters);

+      

+   FREE(fpv);

+}

+

+

+/**

+ * Free all variants of a fragment program.

+ */

+void

+st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)

+{

+   struct st_fp_variant *fpv;

+

+   for (fpv = stfp->variants; fpv; ) {

+      struct st_fp_variant *next = fpv->next;

+      delete_fp_variant(st, fpv);

+      fpv = next;

+   }

+

+   stfp->variants = NULL;

+}

+

+

+/**

+ * Delete a geometry program variant.  Note the caller must unlink

+ * the variant from the linked list.

+ */

+static void

+delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)

+{

+   if (gpv->driver_shader) 

+      cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);

+      

+   FREE(gpv);

+}

+

+

+/**

+ * Free all variants of a geometry program.

+ */

+void

+st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)

+{

+   struct st_gp_variant *gpv;

+

+   for (gpv = stgp->variants; gpv; ) {

+      struct st_gp_variant *next = gpv->next;

+      delete_gp_variant(st, gpv);

+      gpv = next;

+   }

+

+   stgp->variants = NULL;

+}

+

+

+

+

+/**

+ * Translate a Mesa vertex shader into a TGSI shader.

+ * \param outputMapping  to map vertex program output registers (VERT_RESULT_x)

+ *       to TGSI output slots

+ * \param tokensOut  destination for TGSI tokens

+ * \return  pointer to cached pipe_shader object.

+ */

+static void

+st_prepare_vertex_program(struct st_context *st,

+                            struct st_vertex_program *stvp)

+{

+   GLuint attr;

+

+   stvp->num_inputs = 0;

+   stvp->num_outputs = 0;

+

+   if (stvp->Base.IsPositionInvariant)

+      _mesa_insert_mvp_code(st->ctx, &stvp->Base);

+

+   assert(stvp->Base.Base.NumInstructions > 1);

+

+   /*

+    * Determine number of inputs, the mappings between VERT_ATTRIB_x

+    * and TGSI generic input indexes, plus input attrib semantic info.

+    */

+   for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {

+      if (stvp->Base.Base.InputsRead & (1 << attr)) {

+         stvp->input_to_index[attr] = stvp->num_inputs;

+         stvp->index_to_input[stvp->num_inputs] = attr;

+         stvp->num_inputs++;

+      }

+   }

+   /* bit of a hack, presetup potentially unused edgeflag input */

+   stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;

+   stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;

+

+   /* Compute mapping of vertex program outputs to slots.

+    */

+   for (attr = 0; attr < VERT_RESULT_MAX; attr++) {

+      if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {

+         stvp->result_to_output[attr] = ~0;

+      }

+      else {

+         unsigned slot = stvp->num_outputs++;

+

+         stvp->result_to_output[attr] = slot;

+

+         switch (attr) {

+         case VERT_RESULT_HPOS:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

+            stvp->output_semantic_index[slot] = 0;

+            break;

+         case VERT_RESULT_COL0:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            stvp->output_semantic_index[slot] = 0;

+            break;

+         case VERT_RESULT_COL1:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            stvp->output_semantic_index[slot] = 1;

+            break;

+         case VERT_RESULT_BFC0:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;

+            stvp->output_semantic_index[slot] = 0;

+            break;

+         case VERT_RESULT_BFC1:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;

+            stvp->output_semantic_index[slot] = 1;

+            break;

+         case VERT_RESULT_FOGC:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;

+            stvp->output_semantic_index[slot] = 0;

+            break;

+         case VERT_RESULT_PSIZ:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;

+            stvp->output_semantic_index[slot] = 0;

+            break;

+         case VERT_RESULT_EDGE:

+            assert(0);

+            break;

+

+         case VERT_RESULT_TEX0:

+         case VERT_RESULT_TEX1:

+         case VERT_RESULT_TEX2:

+         case VERT_RESULT_TEX3:

+         case VERT_RESULT_TEX4:

+         case VERT_RESULT_TEX5:

+         case VERT_RESULT_TEX6:

+         case VERT_RESULT_TEX7:

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+            stvp->output_semantic_index[slot] = attr - VERT_RESULT_TEX0;

+            break;

+

+         case VERT_RESULT_VAR0:

+         default:

+            assert(attr < VERT_RESULT_MAX);

+            stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+            stvp->output_semantic_index[slot] = (FRAG_ATTRIB_VAR0 - 

+                                                FRAG_ATTRIB_TEX0 +

+                                                attr - 

+                                                VERT_RESULT_VAR0);

+            break;

+         }

+      }

+   }

+   /* similar hack to above, presetup potentially unused edgeflag output */

+   stvp->result_to_output[VERT_RESULT_EDGE] = stvp->num_outputs;

+   stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;

+   stvp->output_semantic_index[stvp->num_outputs] = 0;

+}

+

+

+/**

+ * Translate a vertex program to create a new variant.

+ */

+static struct st_vp_variant *

+st_translate_vertex_program(struct st_context *st,

+                            struct st_vertex_program *stvp,

+                            const struct st_vp_variant_key *key)

+{

+   struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);

+   struct pipe_context *pipe = st->pipe;

+   struct ureg_program *ureg;

+   enum pipe_error error;

+   unsigned num_outputs;

+

+   st_prepare_vertex_program( st, stvp );

+

+   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);

+   _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);

+

+   ureg = ureg_create( TGSI_PROCESSOR_VERTEX );

+   if (ureg == NULL) {

+      FREE(vpv);

+      return NULL;

+   }

+

+   vpv->key = *key;

+

+   vpv->num_inputs = stvp->num_inputs;

+   num_outputs = stvp->num_outputs;

+   if (key->passthrough_edgeflags) {

+      vpv->num_inputs++;

+      num_outputs++;

+   }

+

+   if (ST_DEBUG & DEBUG_MESA) {

+      _mesa_print_program(&stvp->Base.Base);

+      _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);

+      debug_printf("\n");

+   }

+

+   error = st_translate_mesa_program(st->ctx,

+                                     TGSI_PROCESSOR_VERTEX,

+                                     ureg,

+                                     &stvp->Base.Base,

+                                     /* inputs */

+                                     vpv->num_inputs,

+                                     stvp->input_to_index,

+                                     NULL, /* input semantic name */

+                                     NULL, /* input semantic index */

+                                     NULL,

+                                     /* outputs */

+                                     num_outputs,

+                                     stvp->result_to_output,

+                                     stvp->output_semantic_name,

+                                     stvp->output_semantic_index,

+                                     key->passthrough_edgeflags );

+

+   if (error)

+      goto fail;

+

+   vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );

+   if (!vpv->tgsi.tokens)

+      goto fail;

+

+   ureg_destroy( ureg );

+

+   vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);

+

+   if (ST_DEBUG & DEBUG_TGSI) {

+      tgsi_dump( vpv->tgsi.tokens, 0 );

+      debug_printf("\n");

+   }

+

+   return vpv;

+

+fail:

+   debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);

+   _mesa_print_program(&stvp->Base.Base);

+   debug_assert(0);

+

+   ureg_destroy( ureg );

+   return NULL;

+}

+

+

+/**

+ * Find/create a vertex program variant.

+ */

+struct st_vp_variant *

+st_get_vp_variant(struct st_context *st,

+                  struct st_vertex_program *stvp,

+                  const struct st_vp_variant_key *key)

+{

+   struct st_vp_variant *vpv;

+

+   /* Search for existing variant */

+   for (vpv = stvp->variants; vpv; vpv = vpv->next) {

+      if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {

+         break;

+      }

+   }

+

+   if (!vpv) {

+      /* create now */

+      vpv = st_translate_vertex_program(st, stvp, key);

+      if (vpv) {

+         /* insert into list */

+         vpv->next = stvp->variants;

+         stvp->variants = vpv;

+      }

+   }

+

+   return vpv;

+}

+

+

+/**

+ * Translate a Mesa fragment shader into a TGSI shader using extra info in

+ * the key.

+ * \return  new fragment program variant

+ */

+static struct st_fp_variant *

+st_translate_fragment_program(struct st_context *st,

+                              struct st_fragment_program *stfp,

+                              const struct st_fp_variant_key *key)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);

+   GLboolean deleteFP = GL_FALSE;

+

+   if (!variant)

+      return NULL;

+

+   assert(!(key->bitmap && key->drawpixels));

+

+#if FEATURE_drawpix

+   if (key->bitmap) {

+      /* glBitmap drawing */

+      struct gl_fragment_program *fp; /* we free this temp program below */

+

+      st_make_bitmap_fragment_program(st, &stfp->Base,

+                                      &fp, &variant->bitmap_sampler);

+

+      variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);

+      stfp = st_fragment_program(fp);

+      deleteFP = GL_TRUE;

+   }

+   else if (key->drawpixels) {

+      /* glDrawPixels drawing */

+      struct gl_fragment_program *fp; /* we free this temp program below */

+

+      if (key->drawpixels_z || key->drawpixels_stencil) {

+         fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,

+                                                key->drawpixels_stencil);

+      }

+      else {

+         /* RGBA */

+         st_make_drawpix_fragment_program(st, &stfp->Base, &fp);

+         variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);

+         deleteFP = GL_TRUE;

+      }

+      stfp = st_fragment_program(fp);

+   }

+#endif

+

+   if (!stfp->tgsi.tokens) {

+      /* need to translate Mesa instructions to TGSI now */

+      GLuint outputMapping[FRAG_RESULT_MAX];

+      GLuint inputMapping[FRAG_ATTRIB_MAX];

+      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */

+      GLuint attr;

+      enum pipe_error error;

+      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;

+      struct ureg_program *ureg;

+      GLboolean write_all = GL_FALSE;

+

+      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];

+      ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];

+      uint fs_num_inputs = 0;

+

+      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];

+      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];

+      uint fs_num_outputs = 0;

+

+

+      _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);

+

+      /*

+       * Convert Mesa program inputs to TGSI input register semantics.

+       */

+      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {

+         if (inputsRead & (1 << attr)) {

+            const GLuint slot = fs_num_inputs++;

+

+            inputMapping[attr] = slot;

+

+            switch (attr) {

+            case FRAG_ATTRIB_WPOS:

+               input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_COL0:

+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_COL1:

+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+               input_semantic_index[slot] = 1;

+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               break;

+            case FRAG_ATTRIB_FOGC:

+               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

+               break;

+            case FRAG_ATTRIB_FACE:

+               input_semantic_name[slot] = TGSI_SEMANTIC_FACE;

+               input_semantic_index[slot] = 0;

+               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;

+               break;

+               /* In most cases, there is nothing special about these

+                * inputs, so adopt a convention to use the generic

+                * semantic name and the mesa FRAG_ATTRIB_ number as the

+                * index. 

+                * 

+                * All that is required is that the vertex shader labels

+                * its own outputs similarly, and that the vertex shader

+                * generates at least every output required by the

+                * fragment shader plus fixed-function hardware (such as

+                * BFC).

+                * 

+                * There is no requirement that semantic indexes start at

+                * zero or be restricted to a particular range -- nobody

+                * should be building tables based on semantic index.

+                */

+            case FRAG_ATTRIB_PNTC:

+            case FRAG_ATTRIB_TEX0:

+            case FRAG_ATTRIB_TEX1:

+            case FRAG_ATTRIB_TEX2:

+            case FRAG_ATTRIB_TEX3:

+            case FRAG_ATTRIB_TEX4:

+            case FRAG_ATTRIB_TEX5:

+            case FRAG_ATTRIB_TEX6:

+            case FRAG_ATTRIB_TEX7:

+            case FRAG_ATTRIB_VAR0:

+            default:

+               /* Actually, let's try and zero-base this just for

+                * readability of the generated TGSI.

+                */

+               assert(attr >= FRAG_ATTRIB_TEX0);

+               input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);

+               input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+               if (attr == FRAG_ATTRIB_PNTC)

+                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;

+               else

+                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;

+               break;

+            }

+         }

+         else {

+            inputMapping[attr] = -1;

+         }

+      }

+

+      /*

+       * Semantics and mapping for outputs

+       */

+      {

+         uint numColors = 0;

+         GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;

+

+         /* if z is written, emit that first */

+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {

+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;

+            fs_output_semantic_index[fs_num_outputs] = 0;

+            outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;

+            fs_num_outputs++;

+            outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);

+         }

+

+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {

+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;

+            fs_output_semantic_index[fs_num_outputs] = 0;

+            outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;

+            fs_num_outputs++;

+            outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);

+         }

+

+         /* handle remaning outputs (color) */

+         for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {

+            if (outputsWritten & BITFIELD64_BIT(attr)) {

+               switch (attr) {

+               case FRAG_RESULT_DEPTH:

+               case FRAG_RESULT_STENCIL:

+                  /* handled above */

+                  assert(0);

+                  break;

+               case FRAG_RESULT_COLOR:

+                  write_all = GL_TRUE; /* fallthrough */

+               default:

+                  assert(attr == FRAG_RESULT_COLOR ||

+                         (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));

+                  fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;

+                  fs_output_semantic_index[fs_num_outputs] = numColors;

+                  outputMapping[attr] = fs_num_outputs;

+                  numColors++;

+                  break;

+               }

+

+               fs_num_outputs++;

+            }

+         }

+      }

+

+      ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );

+      if (ureg == NULL)

+         return NULL;

+

+      if (ST_DEBUG & DEBUG_MESA) {

+         _mesa_print_program(&stfp->Base.Base);

+         _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);

+         debug_printf("\n");

+      }

+      if (write_all == GL_TRUE)

+         ureg_property_fs_color0_writes_all_cbufs(ureg, 1);

+

+      error = st_translate_mesa_program(st->ctx,

+                                        TGSI_PROCESSOR_FRAGMENT,

+                                        ureg,

+                                        &stfp->Base.Base,

+                                        /* inputs */

+                                        fs_num_inputs,

+                                        inputMapping,

+                                        input_semantic_name,

+                                        input_semantic_index,

+                                        interpMode,

+                                        /* outputs */

+                                        fs_num_outputs,

+                                        outputMapping,

+                                        fs_output_semantic_name,

+                                        fs_output_semantic_index, FALSE );

+

+      stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );

+      ureg_destroy( ureg );

+   }

+

+   /* fill in variant */

+   variant->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);

+   variant->key = *key;

+

+   if (ST_DEBUG & DEBUG_TGSI) {

+      tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );

+      debug_printf("\n");

+   }

+

+   if (deleteFP) {

+      /* Free the temporary program made above */

+      struct gl_fragment_program *fp = &stfp->Base;

+      _mesa_reference_fragprog(st->ctx, &fp, NULL);

+   }

+

+   return variant;

+}

+

+

+/**

+ * Translate fragment program if needed.

+ */

+struct st_fp_variant *

+st_get_fp_variant(struct st_context *st,

+                  struct st_fragment_program *stfp,

+                  const struct st_fp_variant_key *key)

+{

+   struct st_fp_variant *fpv;

+

+   /* Search for existing variant */

+   for (fpv = stfp->variants; fpv; fpv = fpv->next) {

+      if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {

+         break;

+      }

+   }

+

+   if (!fpv) {

+      /* create new */

+      fpv = st_translate_fragment_program(st, stfp, key);

+      if (fpv) {

+         /* insert into list */

+         fpv->next = stfp->variants;

+         stfp->variants = fpv;

+      }

+   }

+

+   return fpv;

+}

+

+

+/**

+ * Translate a geometry program to create a new variant.

+ */

+static struct st_gp_variant *

+st_translate_geometry_program(struct st_context *st,

+                              struct st_geometry_program *stgp,

+                              const struct st_gp_variant_key *key)

+{

+   GLuint inputMapping[GEOM_ATTRIB_MAX];

+   GLuint outputMapping[GEOM_RESULT_MAX];

+   struct pipe_context *pipe = st->pipe;

+   enum pipe_error error;

+   GLuint attr;

+   const GLbitfield inputsRead = stgp->Base.Base.InputsRead;

+   GLuint vslot = 0;

+   GLuint num_generic = 0;

+

+   uint gs_num_inputs = 0;

+   uint gs_builtin_inputs = 0;

+   uint gs_array_offset = 0;

+

+   ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];

+   ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];

+   uint gs_num_outputs = 0;

+

+   GLint i;

+   GLuint maxSlot = 0;

+   struct ureg_program *ureg;

+

+   struct st_gp_variant *gpv;

+

+   gpv = CALLOC_STRUCT(st_gp_variant);

+   if (!gpv)

+      return NULL;

+

+   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);

+   _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);

+

+   ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );

+   if (ureg == NULL) {

+      FREE(gpv);

+      return NULL;

+   }

+

+   /* which vertex output goes to the first geometry input */

+   vslot = 0;

+

+   memset(inputMapping, 0, sizeof(inputMapping));

+   memset(outputMapping, 0, sizeof(outputMapping));

+

+   /*

+    * Convert Mesa program inputs to TGSI input register semantics.

+    */

+   for (attr = 0; attr < GEOM_ATTRIB_MAX; attr++) {

+      if (inputsRead & (1 << attr)) {

+         const GLuint slot = gs_num_inputs;

+

+         gs_num_inputs++;

+

+         inputMapping[attr] = slot;

+

+         stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;

+         stgp->input_to_index[attr] = vslot;

+         stgp->index_to_input[vslot] = attr;

+         ++vslot;

+

+         if (attr != GEOM_ATTRIB_PRIMITIVE_ID) {

+            gs_array_offset += 2;

+         } else

+            ++gs_builtin_inputs;

+

+#if 0

+         debug_printf("input map at %d = %d\n",

+                      slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);

+#endif

+

+         switch (attr) {

+         case GEOM_ATTRIB_PRIMITIVE_ID:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;

+            stgp->input_semantic_index[slot] = 0;

+            break;

+         case GEOM_ATTRIB_POSITION:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

+            stgp->input_semantic_index[slot] = 0;

+            break;

+         case GEOM_ATTRIB_COLOR0:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            stgp->input_semantic_index[slot] = 0;

+            break;

+         case GEOM_ATTRIB_COLOR1:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            stgp->input_semantic_index[slot] = 1;

+            break;

+         case GEOM_ATTRIB_FOG_FRAG_COORD:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;

+            stgp->input_semantic_index[slot] = 0;

+            break;

+         case GEOM_ATTRIB_TEX_COORD:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+            stgp->input_semantic_index[slot] = num_generic++;

+            break;

+         case GEOM_ATTRIB_VAR0:

+            /* fall-through */

+         default:

+            stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+            stgp->input_semantic_index[slot] = num_generic++;

+         }

+      }

+   }

+

+   /* initialize output semantics to defaults */

+   for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {

+      gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;

+      gs_output_semantic_index[i] = 0;

+   }

+

+   num_generic = 0;

+   /*

+    * Determine number of outputs, the (default) output register

+    * mapping and the semantic information for each output.

+    */

+   for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {

+      if (stgp->Base.Base.OutputsWritten & (1 << attr)) {

+         GLuint slot;

+

+         slot = gs_num_outputs;

+         gs_num_outputs++;

+         outputMapping[attr] = slot;

+

+         switch (attr) {

+         case GEOM_RESULT_POS:

+            assert(slot == 0);

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;

+            gs_output_semantic_index[slot] = 0;

+            break;

+         case GEOM_RESULT_COL0:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            gs_output_semantic_index[slot] = 0;

+            break;

+         case GEOM_RESULT_COL1:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;

+            gs_output_semantic_index[slot] = 1;

+            break;

+         case GEOM_RESULT_SCOL0:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;

+            gs_output_semantic_index[slot] = 0;

+            break;

+         case GEOM_RESULT_SCOL1:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;

+            gs_output_semantic_index[slot] = 1;

+            break;

+         case GEOM_RESULT_FOGC:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;

+            gs_output_semantic_index[slot] = 0;

+            break;

+         case GEOM_RESULT_PSIZ:

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;

+            gs_output_semantic_index[slot] = 0;

+            break;

+         case GEOM_RESULT_TEX0:

+         case GEOM_RESULT_TEX1:

+         case GEOM_RESULT_TEX2:

+         case GEOM_RESULT_TEX3:

+         case GEOM_RESULT_TEX4:

+         case GEOM_RESULT_TEX5:

+         case GEOM_RESULT_TEX6:

+         case GEOM_RESULT_TEX7:

+            /* fall-through */

+         case GEOM_RESULT_VAR0:

+            /* fall-through */

+         default:

+            assert(slot < Elements(gs_output_semantic_name));

+            /* use default semantic info */

+            gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;

+            gs_output_semantic_index[slot] = num_generic++;

+         }

+      }

+   }

+

+   assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);

+

+   /* find max output slot referenced to compute gs_num_outputs */

+   for (attr = 0; attr < GEOM_RESULT_MAX; attr++) {

+      if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)

+         maxSlot = outputMapping[attr];

+   }

+   gs_num_outputs = maxSlot + 1;

+

+#if 0 /* debug */

+   {

+      GLuint i;

+      printf("outputMapping? %d\n", outputMapping ? 1 : 0);

+      if (outputMapping) {

+         printf("attr -> slot\n");

+         for (i = 0; i < 16;  i++) {

+            printf(" %2d       %3d\n", i, outputMapping[i]);

+         }

+      }

+      printf("slot    sem_name  sem_index\n");

+      for (i = 0; i < gs_num_outputs; i++) {

+         printf(" %2d         %d         %d\n",

+                i,

+                gs_output_semantic_name[i],

+                gs_output_semantic_index[i]);

+      }

+   }

+#endif

+

+   /* free old shader state, if any */

+   if (stgp->tgsi.tokens) {

+      st_free_tokens(stgp->tgsi.tokens);

+      stgp->tgsi.tokens = NULL;

+   }

+

+   ureg_property_gs_input_prim(ureg, stgp->Base.InputType);

+   ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);

+   ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);

+

+   error = st_translate_mesa_program(st->ctx,

+                                     TGSI_PROCESSOR_GEOMETRY,

+                                     ureg,

+                                     &stgp->Base.Base,

+                                     /* inputs */

+                                     gs_num_inputs,

+                                     inputMapping,

+                                     stgp->input_semantic_name,

+                                     stgp->input_semantic_index,

+                                     NULL,

+                                     /* outputs */

+                                     gs_num_outputs,

+                                     outputMapping,

+                                     gs_output_semantic_name,

+                                     gs_output_semantic_index,

+                                     FALSE);

+

+   stgp->num_inputs = gs_num_inputs;

+   stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );

+   ureg_destroy( ureg );

+

+   /* fill in new variant */

+   gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);

+   gpv->key = *key;

+

+   if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {

+      _mesa_print_program(&stgp->Base.Base);

+      debug_printf("\n");

+   }

+

+   if (ST_DEBUG & DEBUG_TGSI) {

+      tgsi_dump(stgp->tgsi.tokens, 0);

+      debug_printf("\n");

+   }

+

+   return gpv;

+}

+

+

+/**

+ * Get/create geometry program variant.

+ */

+struct st_gp_variant *

+st_get_gp_variant(struct st_context *st,

+                  struct st_geometry_program *stgp,

+                  const struct st_gp_variant_key *key)

+{

+   struct st_gp_variant *gpv;

+

+   /* Search for existing variant */

+   for (gpv = stgp->variants; gpv; gpv = gpv->next) {

+      if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {

+         break;

+      }

+   }

+

+   if (!gpv) {

+      /* create new */

+      gpv = st_translate_geometry_program(st, stgp, key);

+      if (gpv) {

+         /* insert into list */

+         gpv->next = stgp->variants;

+         stgp->variants = gpv;

+      }

+   }

+

+   return gpv;

+}

+

+

+

+

+/**

+ * Debug- print current shader text

+ */

+void

+st_print_shaders(struct gl_context *ctx)

+{

+   struct gl_shader_program *shProg[3] = {

+      ctx->Shader.CurrentVertexProgram,

+      ctx->Shader.CurrentGeometryProgram,

+      ctx->Shader.CurrentFragmentProgram,

+   };

+   unsigned j;

+

+   for (j = 0; j < 3; j++) {

+      unsigned i;

+

+      if (shProg[j] == NULL)

+	 continue;

+

+      for (i = 0; i < shProg[j]->NumShaders; i++) {

+	 struct gl_shader *sh;

+

+	 switch (shProg[j]->Shaders[i]->Type) {

+	 case GL_VERTEX_SHADER:

+	    sh = (i != 0) ? NULL : shProg[j]->Shaders[i];

+	    break;

+	 case GL_GEOMETRY_SHADER_ARB:

+	    sh = (i != 1) ? NULL : shProg[j]->Shaders[i];

+	    break;

+	 case GL_FRAGMENT_SHADER:

+	    sh = (i != 2) ? NULL : shProg[j]->Shaders[i];

+	    break;

+	 default:

+	    assert(0);

+	    sh = NULL;

+	    break;

+	 }

+

+	 if (sh != NULL) {

+	    printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);

+	    printf("%s\n", sh->Source);

+	 }

+      }

+   }

+}

+

+

+/**

+ * Vert/Geom/Frag programs have per-context variants.  Free all the

+ * variants attached to the given program which match the given context.

+ */

+static void

+destroy_program_variants(struct st_context *st, struct gl_program *program)

+{

+   if (!program)

+      return;

+

+   switch (program->Target) {

+   case GL_VERTEX_PROGRAM_ARB:

+      {

+         struct st_vertex_program *stvp = (struct st_vertex_program *) program;

+         struct st_vp_variant *vpv, **prevPtr = &stvp->variants;

+

+         for (vpv = stvp->variants; vpv; ) {

+            struct st_vp_variant *next = vpv->next;

+            if (vpv->key.st == st) {

+               /* unlink from list */

+               *prevPtr = next;

+               /* destroy this variant */

+               delete_vp_variant(st, vpv);

+            }

+            else {

+               prevPtr = &vpv->next;

+            }

+            vpv = next;

+         }

+      }

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      {

+         struct st_fragment_program *stfp =

+            (struct st_fragment_program *) program;

+         struct st_fp_variant *fpv, **prevPtr = &stfp->variants;

+

+         for (fpv = stfp->variants; fpv; ) {

+            struct st_fp_variant *next = fpv->next;

+            if (fpv->key.st == st) {

+               /* unlink from list */

+               *prevPtr = next;

+               /* destroy this variant */

+               delete_fp_variant(st, fpv);

+            }

+            else {

+               prevPtr = &fpv->next;

+            }

+            fpv = next;

+         }

+      }

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      {

+         struct st_geometry_program *stgp =

+            (struct st_geometry_program *) program;

+         struct st_gp_variant *gpv, **prevPtr = &stgp->variants;

+

+         for (gpv = stgp->variants; gpv; ) {

+            struct st_gp_variant *next = gpv->next;

+            if (gpv->key.st == st) {

+               /* unlink from list */

+               *prevPtr = next;

+               /* destroy this variant */

+               delete_gp_variant(st, gpv);

+            }

+            else {

+               prevPtr = &gpv->next;

+            }

+            gpv = next;

+         }

+      }

+      break;

+   default:

+      _mesa_problem(NULL, "Unexpected program target in "

+                    "destroy_program_variants_cb()");

+   }

+}

+

+

+/**

+ * Callback for _mesa_HashWalk.  Free all the shader's program variants

+ * which match the given context.

+ */

+static void

+destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)

+{

+   struct st_context *st = (struct st_context *) userData;

+   struct gl_shader *shader = (struct gl_shader *) data;

+

+   switch (shader->Type) {

+   case GL_SHADER_PROGRAM_MESA:

+      {

+         struct gl_shader_program *shProg = (struct gl_shader_program *) data;

+         GLuint i;

+

+         for (i = 0; i < shProg->NumShaders; i++) {

+            destroy_program_variants(st, shProg->Shaders[i]->Program);

+         }

+

+         destroy_program_variants(st, (struct gl_program *)

+                                  shProg->VertexProgram);

+         destroy_program_variants(st, (struct gl_program *)

+                                  shProg->FragmentProgram);

+         destroy_program_variants(st, (struct gl_program *)

+                                  shProg->GeometryProgram);

+      }

+      break;

+   case GL_VERTEX_SHADER:

+   case GL_FRAGMENT_SHADER:

+   case GL_GEOMETRY_SHADER:

+      {

+         destroy_program_variants(st, shader->Program);

+      }

+      break;

+   default:

+      assert(0);

+   }

+}

+

+

+/**

+ * Callback for _mesa_HashWalk.  Free all the program variants which match

+ * the given context.

+ */

+static void

+destroy_program_variants_cb(GLuint key, void *data, void *userData)

+{

+   struct st_context *st = (struct st_context *) userData;

+   struct gl_program *program = (struct gl_program *) data;

+   destroy_program_variants(st, program);

+}

+

+

+/**

+ * Walk over all shaders and programs to delete any variants which

+ * belong to the given context.

+ * This is called during context tear-down.

+ */

+void

+st_destroy_program_variants(struct st_context *st)

+{

+   /* ARB vert/frag program */

+   _mesa_HashWalk(st->ctx->Shared->Programs,

+                  destroy_program_variants_cb, st);

+

+   /* GLSL vert/frag/geom shaders */

+   _mesa_HashWalk(st->ctx->Shared->ShaderObjects,

+                  destroy_shader_program_variants_cb, st);

+}

diff --git a/mesalib/src/mesa/swrast/s_bitmap.c b/mesalib/src/mesa/swrast/s_bitmap.c
index 18f1c1866..af65874fd 100644
--- a/mesalib/src/mesa/swrast/s_bitmap.c
+++ b/mesalib/src/mesa/swrast/s_bitmap.c
@@ -1,223 +1,223 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file swrast/s_bitmap.c
- * \brief glBitmap rendering.
- * \author Brian Paul
- */
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/condrender.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/pbo.h"
-
-#include "s_context.h"
-#include "s_span.h"
-
-
-
-/**
- * Render a bitmap.
- * Called via ctx->Driver.Bitmap()
- * All parameter error checking will have been done before this is called.
- */
-void
-_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,
-		GLsizei width, GLsizei height,
-		const struct gl_pixelstore_attrib *unpack,
-		const GLubyte *bitmap )
-{
-   GLint row, col;
-   GLuint count = 0;
-   SWspan span;
-
-   ASSERT(ctx->RenderMode == GL_RENDER);
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't draw */
-
-   bitmap = (const GLubyte *) _mesa_map_pbo_source(ctx, unpack, bitmap);
-   if (!bitmap)
-      return;
-
-   swrast_render_start(ctx);
-
-   if (SWRAST_CONTEXT(ctx)->NewState)
-      _swrast_validate_derived( ctx );
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.end = width;
-   span.arrayMask = SPAN_XY;
-   _swrast_span_default_attribs(ctx, &span);
-
-   for (row = 0; row < height; row++) {
-      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
-                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-            if (*src & mask) {
-               span.array->x[count] = px + col;
-               span.array->y[count] = py + row;
-               count++;
-            }
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col = 0; col < width; col++) {
-            if (*src & mask) {
-               span.array->x[count] = px + col;
-               span.array->y[count] = py + row;
-               count++;
-            }
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-
-      if (count + width >= MAX_WIDTH || row + 1 == height) {
-         /* flush the span */
-         span.end = count;
-         _swrast_write_rgba_span(ctx, &span);
-         span.end = 0;
-         count = 0;
-      }
-   }
-
-   swrast_render_finish(ctx);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-}
-
-
-#if 0
-/*
- * XXX this is another way to implement Bitmap.  Use horizontal runs of
- * fragments, initializing the mask array to indicate which fragments to
- * draw or skip.
- */
-void
-_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,
-		GLsizei width, GLsizei height,
-		const struct gl_pixelstore_attrib *unpack,
-		const GLubyte *bitmap )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLint row, col;
-   SWspan span;
-
-   ASSERT(ctx->RenderMode == GL_RENDER);
-   ASSERT(bitmap);
-
-   swrast_render_start(ctx);
-
-   if (SWRAST_CONTEXT(ctx)->NewState)
-      _swrast_validate_derived( ctx );
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.end = width;
-   span.arrayMask = SPAN_MASK;
-   _swrast_span_default_attribs(ctx, &span);
-
-   /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */
-   span.x = px;
-   span.y = py;
-   /*span.end = width;*/
-
-   for (row=0; row<height; row++, span.y++) {
-      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
-                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         _swrast_write_rgba_span(ctx, &span);
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         _swrast_write_rgba_span(ctx, &span);
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
-#endif
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file swrast/s_bitmap.c

+ * \brief glBitmap rendering.

+ * \author Brian Paul

+ */

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/condrender.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/pbo.h"

+

+#include "s_context.h"

+#include "s_span.h"

+

+

+

+/**

+ * Render a bitmap.

+ * Called via ctx->Driver.Bitmap()

+ * All parameter error checking will have been done before this is called.

+ */

+void

+_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,

+		GLsizei width, GLsizei height,

+		const struct gl_pixelstore_attrib *unpack,

+		const GLubyte *bitmap )

+{

+   GLint row, col;

+   GLuint count = 0;

+   SWspan span;

+

+   ASSERT(ctx->RenderMode == GL_RENDER);

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't draw */

+

+   bitmap = (const GLubyte *) _mesa_map_pbo_source(ctx, unpack, bitmap);

+   if (!bitmap)

+      return;

+

+   swrast_render_start(ctx);

+

+   if (SWRAST_CONTEXT(ctx)->NewState)

+      _swrast_validate_derived( ctx );

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.end = width;

+   span.arrayMask = SPAN_XY;

+   _swrast_span_default_attribs(ctx, &span);

+

+   for (row = 0; row < height; row++) {

+      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,

+                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);

+

+      if (unpack->LsbFirst) {

+         /* Lsb first */

+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+            if (*src & mask) {

+               span.array->x[count] = px + col;

+               span.array->y[count] = py + row;

+               count++;

+            }

+            if (mask == 128U) {

+               src++;

+               mask = 1U;

+            }

+            else {

+               mask = mask << 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 1)

+            src++;

+      }

+      else {

+         /* Msb first */

+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);

+         for (col = 0; col < width; col++) {

+            if (*src & mask) {

+               span.array->x[count] = px + col;

+               span.array->y[count] = py + row;

+               count++;

+            }

+            if (mask == 1U) {

+               src++;

+               mask = 128U;

+            }

+            else {

+               mask = mask >> 1;

+            }

+         }

+

+         /* get ready for next row */

+         if (mask != 128)

+            src++;

+      }

+

+      if (count + width >= MAX_WIDTH || row + 1 == height) {

+         /* flush the span */

+         span.end = count;

+         _swrast_write_rgba_span(ctx, &span);

+         span.end = 0;

+         count = 0;

+      }

+   }

+

+   swrast_render_finish(ctx);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+}

+

+

+#if 0

+/*

+ * XXX this is another way to implement Bitmap.  Use horizontal runs of

+ * fragments, initializing the mask array to indicate which fragments to

+ * draw or skip.

+ */

+void

+_swrast_Bitmap( struct gl_context *ctx, GLint px, GLint py,

+		GLsizei width, GLsizei height,

+		const struct gl_pixelstore_attrib *unpack,

+		const GLubyte *bitmap )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLint row, col;

+   SWspan span;

+

+   ASSERT(ctx->RenderMode == GL_RENDER);

+   ASSERT(bitmap);

+

+   swrast_render_start(ctx);

+

+   if (SWRAST_CONTEXT(ctx)->NewState)

+      _swrast_validate_derived( ctx );

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.end = width;

+   span.arrayMask = SPAN_MASK;

+   _swrast_span_default_attribs(ctx, &span);

+

+   /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */

+   span.x = px;

+   span.y = py;

+   /*span.end = width;*/

+

+   for (row=0; row<height; row++, span.y++) {

+      const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,

+                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);

+

+      if (unpack->LsbFirst) {

+         /* Lsb first */

+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);

+         for (col=0; col<width; col++) {

+            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;

+            if (mask == 128U) {

+               src++;

+               mask = 1U;

+            }

+            else {

+               mask = mask << 1;

+            }

+         }

+

+         _swrast_write_rgba_span(ctx, &span);

+

+         /* get ready for next row */

+         if (mask != 1)

+            src++;

+      }

+      else {

+         /* Msb first */

+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);

+         for (col=0; col<width; col++) {

+            span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;

+            if (mask == 1U) {

+               src++;

+               mask = 128U;

+            }

+            else {

+               mask = mask >> 1;

+            }

+         }

+

+         _swrast_write_rgba_span(ctx, &span);

+

+         /* get ready for next row */

+         if (mask != 128)

+            src++;

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

+#endif

diff --git a/mesalib/src/mesa/swrast/s_drawpix.c b/mesalib/src/mesa/swrast/s_drawpix.c
index 11c63457f..71f998324 100644
--- a/mesalib/src/mesa/swrast/s_drawpix.c
+++ b/mesalib/src/mesa/swrast/s_drawpix.c
@@ -1,753 +1,753 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/condrender.h"
-#include "main/context.h"
-#include "main/image.h"
-#include "main/imports.h"
-#include "main/macros.h"
-#include "main/pack.h"
-#include "main/pbo.h"
-#include "main/pixeltransfer.h"
-#include "main/state.h"
-
-#include "s_context.h"
-#include "s_span.h"
-#include "s_stencil.h"
-#include "s_zoom.h"
-
-
-
-/**
- * Try to do a fast and simple RGB(a) glDrawPixels.
- * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead
- */
-static GLboolean
-fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,
-                      GLsizei width, GLsizei height,
-                      GLenum format, GLenum type,
-                      const struct gl_pixelstore_attrib *userUnpack,
-                      const GLvoid *pixels)
-{
-   const GLint imgX = x, imgY = y;
-   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];
-   GLenum rbType;
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   SWspan span;
-   GLboolean simpleZoom;
-   GLint yStep;  /* +1 or -1 */
-   struct gl_pixelstore_attrib unpack;
-   GLint destX, destY, drawWidth, drawHeight; /* post clipping */
-
-   if (!rb)
-      return GL_TRUE; /* no-op */
-
-   rbType = rb->DataType;
-
-   if ((swrast->_RasterMask & ~CLIP_BIT) ||
-       ctx->Texture._EnabledCoordUnits ||
-       userUnpack->SwapBytes ||
-       ctx->_ImageTransferState) {
-      /* can't handle any of those conditions */
-      return GL_FALSE;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0;
-   _swrast_span_default_attribs(ctx, &span);
-
-   /* copy input params since clipping may change them */
-   unpack = *userUnpack;
-   destX = x;
-   destY = y;
-   drawWidth = width;
-   drawHeight = height;
-
-   /* check for simple zooming and clipping */
-   if (ctx->Pixel.ZoomX == 1.0F &&
-       (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {
-      if (!_mesa_clip_drawpixels(ctx, &destX, &destY,
-                                 &drawWidth, &drawHeight, &unpack)) {
-         /* image was completely clipped: no-op, all done */
-         return GL_TRUE;
-      }
-      simpleZoom = GL_TRUE;
-      yStep = (GLint) ctx->Pixel.ZoomY;
-      ASSERT(yStep == 1 || yStep == -1);
-   }
-   else {
-      /* non-simple zooming */
-      simpleZoom = GL_FALSE;
-      yStep = 1;
-      if (unpack.RowLength == 0)
-         unpack.RowLength = width;
-   }
-
-   /*
-    * Ready to draw!
-    */
-
-   if (format == GL_RGBA && type == rbType) {
-      const GLubyte *src
-         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
-                                                   height, format, type, 0, 0);
-      const GLint srcStride = _mesa_image_row_stride(&unpack, width,
-                                                     format, type);
-      if (simpleZoom) {
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);
-            src += srcStride;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            span.x = destX;
-            span.y = destY + row;
-            span.end = drawWidth;
-            span.array->ChanType = rbType;
-            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);
-            src += srcStride;
-         }
-         span.array->ChanType = CHAN_TYPE;
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_RGB && type == rbType) {
-      const GLubyte *src
-         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,
-                                                   height, format, type, 0, 0);
-      const GLint srcStride = _mesa_image_row_stride(&unpack, width,
-                                                     format, type);
-      if (simpleZoom) {
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);
-            src += srcStride;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         for (row = 0; row < drawHeight; row++) {
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            span.array->ChanType = rbType;
-            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);
-            src += srcStride;
-            destY++;
-         }
-         span.array->ChanType = CHAN_TYPE;
-      }
-      return GL_TRUE;
-   }
-
-   /* Remaining cases haven't been tested with alignment != 1 */
-   if (userUnpack->Alignment != 1)
-      return GL_FALSE;
-
-   if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {
-      const GLchan *src = (const GLchan *) pixels
-         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);
-      if (simpleZoom) {
-         /* no zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLchan rgb[MAX_WIDTH][3];
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               rgb[i][0] = src[i];
-               rgb[i][1] = src[i];
-               rgb[i][2] = src[i];
-            }
-            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);
-            src += unpack.RowLength;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLchan rgb[MAX_WIDTH][3];
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               rgb[i][0] = src[i];
-               rgb[i][1] = src[i];
-               rgb[i][2] = src[i];
-            }
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);
-            src += unpack.RowLength;
-            destY++;
-         }
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {
-      const GLchan *src = (const GLchan *) pixels
-         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;
-      if (simpleZoom) {
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            GLint i;
-            const GLchan *ptr = src;
-            for (i = 0;i<drawWidth;i++) {
-               span.array->rgba[i][0] = *ptr;
-               span.array->rgba[i][1] = *ptr;
-               span.array->rgba[i][2] = *ptr++;
-               span.array->rgba[i][3] = *ptr++;
-            }
-            rb->PutRow(ctx, rb, drawWidth, destX, destY,
-                       span.array->rgba, NULL);
-            src += unpack.RowLength*2;
-            destY += yStep;
-         }
-      }
-      else {
-         /* with zooming */
-         GLint row;
-         ASSERT(drawWidth <= MAX_WIDTH);
-         for (row = 0; row < drawHeight; row++) {
-            const GLchan *ptr = src;
-            GLint i;
-            for (i = 0;i<drawWidth;i++) {
-               span.array->rgba[i][0] = *ptr;
-               span.array->rgba[i][1] = *ptr;
-               span.array->rgba[i][2] = *ptr++;
-               span.array->rgba[i][3] = *ptr++;
-            }
-            span.x = destX;
-            span.y = destY;
-            span.end = drawWidth;
-            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
-                                           span.array->rgba);
-            src += unpack.RowLength*2;
-            destY++;
-         }
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {
-      const GLubyte *src = (const GLubyte *) pixels
-         + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;
-      if (rbType == GL_UNSIGNED_BYTE) {
-         /* convert ubyte/CI data to ubyte/RGBA */
-         if (simpleZoom) {
-            GLint row;
-            for (row = 0; row < drawHeight; row++) {
-               ASSERT(drawWidth <= MAX_WIDTH);
-               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
-                                      span.array->rgba8);
-               rb->PutRow(ctx, rb, drawWidth, destX, destY,
-                          span.array->rgba8, NULL);
-               src += unpack.RowLength;
-               destY += yStep;
-            }
-         }
-         else {
-            /* ubyte/CI to ubyte/RGBA with zooming */
-            GLint row;
-            for (row = 0; row < drawHeight; row++) {
-               ASSERT(drawWidth <= MAX_WIDTH);
-               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,
-                                      span.array->rgba8);
-               span.x = destX;
-               span.y = destY;
-               span.end = drawWidth;
-               _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,
-                                              span.array->rgba8);
-               src += unpack.RowLength;
-               destY++;
-            }
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* can't handle this pixel format and/or data type */
-   return GL_FALSE;
-}
-
-
-
-/*
- * Draw stencil image.
- */
-static void
-draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,
-                     GLsizei width, GLsizei height,
-                     GLenum type,
-                     const struct gl_pixelstore_attrib *unpack,
-                     const GLvoid *pixels )
-{
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   GLint skipPixels;
-
-   /* if width > MAX_WIDTH, have to process image in chunks */
-   skipPixels = 0;
-   while (skipPixels < width) {
-      const GLint spanX = x + skipPixels;
-      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLint spanY = y + row;
-         GLstencil values[MAX_WIDTH];
-         GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
-                         ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
-         const GLvoid *source = _mesa_image_address2d(unpack, pixels,
-                                                      width, height,
-                                                      GL_COLOR_INDEX, type,
-                                                      row, skipPixels);
-         _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,
-                                   type, source, unpack,
-                                   ctx->_ImageTransferState);
-         if (zoom) {
-            _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,
-                                              spanX, spanY, values);
-         }
-         else {
-            _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);
-         }
-      }
-      skipPixels += spanWidth;
-   }
-}
-
-
-/*
- * Draw depth image.
- */
-static void
-draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type,
-                   const struct gl_pixelstore_attrib *unpack,
-                   const GLvoid *pixels )
-{
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   SWspan span;
-
-   INIT_SPAN(span, GL_BITMAP);
-   span.arrayMask = SPAN_Z;
-   _swrast_span_default_attribs(ctx, &span);
-
-   if (type == GL_UNSIGNED_SHORT
-       && ctx->DrawBuffer->Visual.depthBits == 16
-       && !scaleOrBias
-       && !zoom
-       && width <= MAX_WIDTH
-       && !unpack->SwapBytes) {
-      /* Special case: directly write 16-bit depth values */
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLushort *zSrc = (const GLushort *)
-            _mesa_image_address2d(unpack, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, row, 0);
-         GLint i;
-         for (i = 0; i < width; i++)
-            span.array->z[i] = zSrc[i];
-         span.x = x;
-         span.y = y + row;
-         span.end = width;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-   else if (type == GL_UNSIGNED_INT
-            && !scaleOrBias
-            && !zoom
-            && width <= MAX_WIDTH
-            && !unpack->SwapBytes) {
-      /* Special case: shift 32-bit values down to Visual.depthBits */
-      const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;
-      GLint row;
-      for (row = 0; row < height; row++) {
-         const GLuint *zSrc = (const GLuint *)
-            _mesa_image_address2d(unpack, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, row, 0);
-         if (shift == 0) {
-            memcpy(span.array->z, zSrc, width * sizeof(GLuint));
-         }
-         else {
-            GLint col;
-            for (col = 0; col < width; col++)
-               span.array->z[col] = zSrc[col] >> shift;
-         }
-         span.x = x;
-         span.y = y + row;
-         span.end = width;
-         _swrast_write_rgba_span(ctx, &span);
-      }
-   }
-   else {
-      /* General case */
-      const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-      GLint skipPixels = 0;
-
-      /* in case width > MAX_WIDTH do the copy in chunks */
-      while (skipPixels < width) {
-         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-         GLint row;
-         ASSERT(span.end <= MAX_WIDTH);
-         for (row = 0; row < height; row++) {
-            const GLvoid *zSrc = _mesa_image_address2d(unpack,
-                                                      pixels, width, height,
-                                                      GL_DEPTH_COMPONENT, type,
-                                                      row, skipPixels);
-
-            /* Set these for each row since the _swrast_write_* function may
-             * change them while clipping.
-             */
-            span.x = x + skipPixels;
-            span.y = y + row;
-            span.end = spanWidth;
-
-            _mesa_unpack_depth_span(ctx, spanWidth,
-                                    GL_UNSIGNED_INT, span.array->z, depthMax,
-                                    type, zSrc, unpack);
-            if (zoom) {
-               _swrast_write_zoomed_depth_span(ctx, x, y, &span);
-            }
-            else {
-               _swrast_write_rgba_span(ctx, &span);
-            }
-         }
-         skipPixels += spanWidth;
-      }
-   }
-}
-
-
-
-/**
- * Draw RGBA image.
- */
-static void
-draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,
-                  GLsizei width, GLsizei height,
-                  GLenum format, GLenum type,
-                  const struct gl_pixelstore_attrib *unpack,
-                  const GLvoid *pixels )
-{
-   const GLint imgX = x, imgY = y;
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   GLfloat *convImage = NULL;
-   GLbitfield transferOps = ctx->_ImageTransferState;
-   SWspan span;
-
-   /* Try an optimized glDrawPixels first */
-   if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,
-                             unpack, pixels)) {
-      return;
-   }
-
-   INIT_SPAN(span, GL_BITMAP);
-   _swrast_span_default_attribs(ctx, &span);
-   span.arrayMask = SPAN_RGBA;
-   span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */
-
-   if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&
-       ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&
-       ctx->Color.ClampFragmentColor != GL_FALSE) {
-      /* need to clamp colors before applying fragment ops */
-      transferOps |= IMAGE_CLAMP_BIT;
-   }
-
-   /*
-    * General solution
-    */
-   {
-      const GLbitfield interpMask = span.interpMask;
-      const GLbitfield arrayMask = span.arrayMask;
-      const GLint srcStride
-         = _mesa_image_row_stride(unpack, width, format, type);
-      GLint skipPixels = 0;
-      /* use span array for temp color storage */
-      GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];
-
-      /* if the span is wider than MAX_WIDTH we have to do it in chunks */
-      while (skipPixels < width) {
-         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-         const GLubyte *source
-            = (const GLubyte *) _mesa_image_address2d(unpack, pixels,
-                                                      width, height, format,
-                                                      type, 0, skipPixels);
-         GLint row;
-
-         for (row = 0; row < height; row++) {
-            /* get image row as float/RGBA */
-            _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,
-                                     format, type, source, unpack,
-                                     transferOps);
-	    /* Set these for each row since the _swrast_write_* functions
-	     * may change them while clipping/rendering.
-	     */
-	    span.array->ChanType = GL_FLOAT;
-	    span.x = x + skipPixels;
-	    span.y = y + row;
-	    span.end = spanWidth;
-	    span.arrayMask = arrayMask;
-	    span.interpMask = interpMask;
-	    if (zoom) {
-	       _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);
-	    }
-	    else {
-	       _swrast_write_rgba_span(ctx, &span);
-	    }
-
-            source += srcStride;
-         } /* for row */
-
-         skipPixels += spanWidth;
-      } /* while skipPixels < width */
-
-      /* XXX this is ugly/temporary, to undo above change */
-      span.array->ChanType = CHAN_TYPE;
-   }
-
-   if (convImage) {
-      free(convImage);
-   }
-}
-
-
-/**
- * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.
- * The only per-pixel operations that apply are depth scale/bias,
- * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,
- * and pixel zoom.
- * Also, only the depth buffer and stencil buffers are touched, not the
- * color buffer(s).
- */
-static void
-draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
-                          GLsizei width, GLsizei height, GLenum type,
-                          const struct gl_pixelstore_attrib *unpack,
-                          const GLvoid *pixels)
-{
-   const GLint imgX = x, imgY = y;
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;
-   const GLuint stencilMask = ctx->Stencil.WriteMask[0];
-   const GLuint stencilType = (STENCIL_BITS == 8) ? 
-      GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   struct gl_renderbuffer *depthRb, *stencilRb;
-   struct gl_pixelstore_attrib clippedUnpack = *unpack;
-
-   if (!zoom) {
-      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
-                                 &clippedUnpack)) {
-         /* totally clipped */
-         return;
-      }
-   }
-   
-   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-   ASSERT(depthRb);
-   ASSERT(stencilRb);
-
-   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       depthRb == stencilRb &&
-       !scaleOrBias &&
-       !zoom &&
-       ctx->Depth.Mask &&
-       (stencilMask & 0xff) == 0xff) {
-      /* This is the ideal case.
-       * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.
-       * Plus, no pixel transfer ops, zooming, or masking needed.
-       */
-      GLint i;
-      for (i = 0; i < height; i++) {
-         const GLuint *src = (const GLuint *) 
-            _mesa_image_address2d(&clippedUnpack, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-         depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);
-      }
-   }
-   else {
-      /* sub-optimal cases:
-       * Separate depth/stencil buffers, or pixel transfer ops required.
-       */
-      /* XXX need to handle very wide images (skippixels) */
-      GLint i;
-
-      depthRb = ctx->DrawBuffer->_DepthBuffer;
-      stencilRb = ctx->DrawBuffer->_StencilBuffer;
-
-      for (i = 0; i < height; i++) {
-         const GLuint *depthStencilSrc = (const GLuint *)
-            _mesa_image_address2d(&clippedUnpack, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-
-         if (ctx->Depth.Mask) {
-            if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {
-               /* fast path 24-bit zbuffer */
-               GLuint zValues[MAX_WIDTH];
-               GLint j;
-               ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
-               for (j = 0; j < width; j++) {
-                  zValues[j] = depthStencilSrc[j] >> 8;
-               }
-               if (zoom)
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
-                                              x, y + i, zValues);
-               else
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-            }
-            else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {
-               /* fast path 16-bit zbuffer */
-               GLushort zValues[MAX_WIDTH];
-               GLint j;
-               ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);
-               for (j = 0; j < width; j++) {
-                  zValues[j] = depthStencilSrc[j] >> 16;
-               }
-               if (zoom)
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,
-                                              x, y + i, zValues);
-               else
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-            }
-            else {
-               /* general case */
-               GLuint zValues[MAX_WIDTH];  /* 16 or 32-bit Z value storage */
-               _mesa_unpack_depth_span(ctx, width,
-                                       depthRb->DataType, zValues, depthMax,
-                                       type, depthStencilSrc, &clippedUnpack);
-               if (zoom) {
-                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,
-                                              y + i, zValues);
-               }
-               else {
-                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);
-               }
-            }
-         }
-
-         if (stencilMask != 0x0) {
-            GLstencil stencilValues[MAX_WIDTH];
-            /* get stencil values, with shift/offset/mapping */
-            _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,
-                                      type, depthStencilSrc, &clippedUnpack,
-                                      ctx->_ImageTransferState);
-            if (zoom)
-               _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,
-                                                  x, y + i, stencilValues);
-            else
-               _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);
-         }
-      }
-   }
-}
-
-
-/**
- * Execute software-based glDrawPixels.
- * By time we get here, all error checking will have been done.
- */
-void
-_swrast_DrawPixels( struct gl_context *ctx,
-		    GLint x, GLint y,
-		    GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *unpack,
-		    const GLvoid *pixels )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLboolean save_vp_override = ctx->VertexProgram._Overriden;
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't draw */
-
-   /* We are creating fragments directly, without going through vertex
-    * programs.
-    *
-    * This override flag tells the fragment processing code that its input
-    * comes from a non-standard source, and it may therefore not rely on
-    * optimizations that assume e.g. constant color if there is no color
-    * vertex array.
-    */
-   _mesa_set_vp_override(ctx, GL_TRUE);
-
-   swrast_render_start(ctx);
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
-   if (!pixels) {
-      swrast_render_finish(ctx);
-      _mesa_set_vp_override(ctx, save_vp_override);
-      return;
-   }
-
-   /*
-    * By time we get here, all error checking should have been done.
-    */
-   switch (format) {
-   case GL_STENCIL_INDEX:
-      draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );
-      break;
-   case GL_DEPTH_COMPONENT:
-      draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );
-      break;
-   case GL_DEPTH_STENCIL_EXT:
-      draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);
-      break;
-   default:
-      /* all other formats should be color formats */
-      draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);
-   }
-
-   swrast_render_finish(ctx);
-   _mesa_set_vp_override(ctx, save_vp_override);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/condrender.h"

+#include "main/context.h"

+#include "main/image.h"

+#include "main/imports.h"

+#include "main/macros.h"

+#include "main/pack.h"

+#include "main/pbo.h"

+#include "main/pixeltransfer.h"

+#include "main/state.h"

+

+#include "s_context.h"

+#include "s_span.h"

+#include "s_stencil.h"

+#include "s_zoom.h"

+

+

+

+/**

+ * Try to do a fast and simple RGB(a) glDrawPixels.

+ * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead

+ */

+static GLboolean

+fast_draw_rgba_pixels(struct gl_context *ctx, GLint x, GLint y,

+                      GLsizei width, GLsizei height,

+                      GLenum format, GLenum type,

+                      const struct gl_pixelstore_attrib *userUnpack,

+                      const GLvoid *pixels)

+{

+   const GLint imgX = x, imgY = y;

+   struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0];

+   GLenum rbType;

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   SWspan span;

+   GLboolean simpleZoom;

+   GLint yStep;  /* +1 or -1 */

+   struct gl_pixelstore_attrib unpack;

+   GLint destX, destY, drawWidth, drawHeight; /* post clipping */

+

+   if (!rb)

+      return GL_TRUE; /* no-op */

+

+   rbType = rb->DataType;

+

+   if ((swrast->_RasterMask & ~CLIP_BIT) ||

+       ctx->Texture._EnabledCoordUnits ||

+       userUnpack->SwapBytes ||

+       ctx->_ImageTransferState) {

+      /* can't handle any of those conditions */

+      return GL_FALSE;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0;

+   _swrast_span_default_attribs(ctx, &span);

+

+   /* copy input params since clipping may change them */

+   unpack = *userUnpack;

+   destX = x;

+   destY = y;

+   drawWidth = width;

+   drawHeight = height;

+

+   /* check for simple zooming and clipping */

+   if (ctx->Pixel.ZoomX == 1.0F &&

+       (ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F)) {

+      if (!_mesa_clip_drawpixels(ctx, &destX, &destY,

+                                 &drawWidth, &drawHeight, &unpack)) {

+         /* image was completely clipped: no-op, all done */

+         return GL_TRUE;

+      }

+      simpleZoom = GL_TRUE;

+      yStep = (GLint) ctx->Pixel.ZoomY;

+      ASSERT(yStep == 1 || yStep == -1);

+   }

+   else {

+      /* non-simple zooming */

+      simpleZoom = GL_FALSE;

+      yStep = 1;

+      if (unpack.RowLength == 0)

+         unpack.RowLength = width;

+   }

+

+   /*

+    * Ready to draw!

+    */

+

+   if (format == GL_RGBA && type == rbType) {

+      const GLubyte *src

+         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,

+                                                   height, format, type, 0, 0);

+      const GLint srcStride = _mesa_image_row_stride(&unpack, width,

+                                                     format, type);

+      if (simpleZoom) {

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            rb->PutRow(ctx, rb, drawWidth, destX, destY, src, NULL);

+            src += srcStride;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            span.x = destX;

+            span.y = destY + row;

+            span.end = drawWidth;

+            span.array->ChanType = rbType;

+            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, src);

+            src += srcStride;

+         }

+         span.array->ChanType = CHAN_TYPE;

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_RGB && type == rbType) {

+      const GLubyte *src

+         = (const GLubyte *) _mesa_image_address2d(&unpack, pixels, width,

+                                                   height, format, type, 0, 0);

+      const GLint srcStride = _mesa_image_row_stride(&unpack, width,

+                                                     format, type);

+      if (simpleZoom) {

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, src, NULL);

+            src += srcStride;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         for (row = 0; row < drawHeight; row++) {

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            span.array->ChanType = rbType;

+            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, src);

+            src += srcStride;

+            destY++;

+         }

+         span.array->ChanType = CHAN_TYPE;

+      }

+      return GL_TRUE;

+   }

+

+   /* Remaining cases haven't been tested with alignment != 1 */

+   if (userUnpack->Alignment != 1)

+      return GL_FALSE;

+

+   if (format == GL_LUMINANCE && type == CHAN_TYPE && rbType == CHAN_TYPE) {

+      const GLchan *src = (const GLchan *) pixels

+         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels);

+      if (simpleZoom) {

+         /* no zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLchan rgb[MAX_WIDTH][3];

+            GLint i;

+            for (i = 0;i<drawWidth;i++) {

+               rgb[i][0] = src[i];

+               rgb[i][1] = src[i];

+               rgb[i][2] = src[i];

+            }

+            rb->PutRowRGB(ctx, rb, drawWidth, destX, destY, rgb, NULL);

+            src += unpack.RowLength;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLchan rgb[MAX_WIDTH][3];

+            GLint i;

+            for (i = 0;i<drawWidth;i++) {

+               rgb[i][0] = src[i];

+               rgb[i][1] = src[i];

+               rgb[i][2] = src[i];

+            }

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            _swrast_write_zoomed_rgb_span(ctx, imgX, imgY, &span, rgb);

+            src += unpack.RowLength;

+            destY++;

+         }

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE && rbType == CHAN_TYPE) {

+      const GLchan *src = (const GLchan *) pixels

+         + (unpack.SkipRows * unpack.RowLength + unpack.SkipPixels)*2;

+      if (simpleZoom) {

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            GLint i;

+            const GLchan *ptr = src;

+            for (i = 0;i<drawWidth;i++) {

+               span.array->rgba[i][0] = *ptr;

+               span.array->rgba[i][1] = *ptr;

+               span.array->rgba[i][2] = *ptr++;

+               span.array->rgba[i][3] = *ptr++;

+            }

+            rb->PutRow(ctx, rb, drawWidth, destX, destY,

+                       span.array->rgba, NULL);

+            src += unpack.RowLength*2;

+            destY += yStep;

+         }

+      }

+      else {

+         /* with zooming */

+         GLint row;

+         ASSERT(drawWidth <= MAX_WIDTH);

+         for (row = 0; row < drawHeight; row++) {

+            const GLchan *ptr = src;

+            GLint i;

+            for (i = 0;i<drawWidth;i++) {

+               span.array->rgba[i][0] = *ptr;

+               span.array->rgba[i][1] = *ptr;

+               span.array->rgba[i][2] = *ptr++;

+               span.array->rgba[i][3] = *ptr++;

+            }

+            span.x = destX;

+            span.y = destY;

+            span.end = drawWidth;

+            _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,

+                                           span.array->rgba);

+            src += unpack.RowLength*2;

+            destY++;

+         }

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_COLOR_INDEX && type == GL_UNSIGNED_BYTE) {

+      const GLubyte *src = (const GLubyte *) pixels

+         + unpack.SkipRows * unpack.RowLength + unpack.SkipPixels;

+      if (rbType == GL_UNSIGNED_BYTE) {

+         /* convert ubyte/CI data to ubyte/RGBA */

+         if (simpleZoom) {

+            GLint row;

+            for (row = 0; row < drawHeight; row++) {

+               ASSERT(drawWidth <= MAX_WIDTH);

+               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,

+                                      span.array->rgba8);

+               rb->PutRow(ctx, rb, drawWidth, destX, destY,

+                          span.array->rgba8, NULL);

+               src += unpack.RowLength;

+               destY += yStep;

+            }

+         }

+         else {

+            /* ubyte/CI to ubyte/RGBA with zooming */

+            GLint row;

+            for (row = 0; row < drawHeight; row++) {

+               ASSERT(drawWidth <= MAX_WIDTH);

+               _mesa_map_ci8_to_rgba8(ctx, drawWidth, src,

+                                      span.array->rgba8);

+               span.x = destX;

+               span.y = destY;

+               span.end = drawWidth;

+               _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span,

+                                              span.array->rgba8);

+               src += unpack.RowLength;

+               destY++;

+            }

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* can't handle this pixel format and/or data type */

+   return GL_FALSE;

+}

+

+

+

+/*

+ * Draw stencil image.

+ */

+static void

+draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,

+                     GLsizei width, GLsizei height,

+                     GLenum type,

+                     const struct gl_pixelstore_attrib *unpack,

+                     const GLvoid *pixels )

+{

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   GLint skipPixels;

+

+   /* if width > MAX_WIDTH, have to process image in chunks */

+   skipPixels = 0;

+   while (skipPixels < width) {

+      const GLint spanX = x + skipPixels;

+      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLint spanY = y + row;

+         GLstencil values[MAX_WIDTH];

+         GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))

+                         ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;

+         const GLvoid *source = _mesa_image_address2d(unpack, pixels,

+                                                      width, height,

+                                                      GL_COLOR_INDEX, type,

+                                                      row, skipPixels);

+         _mesa_unpack_stencil_span(ctx, spanWidth, destType, values,

+                                   type, source, unpack,

+                                   ctx->_ImageTransferState);

+         if (zoom) {

+            _swrast_write_zoomed_stencil_span(ctx, x, y, spanWidth,

+                                              spanX, spanY, values);

+         }

+         else {

+            _swrast_write_stencil_span(ctx, spanWidth, spanX, spanY, values);

+         }

+      }

+      skipPixels += spanWidth;

+   }

+}

+

+

+/*

+ * Draw depth image.

+ */

+static void

+draw_depth_pixels( struct gl_context *ctx, GLint x, GLint y,

+                   GLsizei width, GLsizei height,

+                   GLenum type,

+                   const struct gl_pixelstore_attrib *unpack,

+                   const GLvoid *pixels )

+{

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   SWspan span;

+

+   INIT_SPAN(span, GL_BITMAP);

+   span.arrayMask = SPAN_Z;

+   _swrast_span_default_attribs(ctx, &span);

+

+   if (type == GL_UNSIGNED_SHORT

+       && ctx->DrawBuffer->Visual.depthBits == 16

+       && !scaleOrBias

+       && !zoom

+       && width <= MAX_WIDTH

+       && !unpack->SwapBytes) {

+      /* Special case: directly write 16-bit depth values */

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLushort *zSrc = (const GLushort *)

+            _mesa_image_address2d(unpack, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, row, 0);

+         GLint i;

+         for (i = 0; i < width; i++)

+            span.array->z[i] = zSrc[i];

+         span.x = x;

+         span.y = y + row;

+         span.end = width;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+   else if (type == GL_UNSIGNED_INT

+            && !scaleOrBias

+            && !zoom

+            && width <= MAX_WIDTH

+            && !unpack->SwapBytes) {

+      /* Special case: shift 32-bit values down to Visual.depthBits */

+      const GLint shift = 32 - ctx->DrawBuffer->Visual.depthBits;

+      GLint row;

+      for (row = 0; row < height; row++) {

+         const GLuint *zSrc = (const GLuint *)

+            _mesa_image_address2d(unpack, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, row, 0);

+         if (shift == 0) {

+            memcpy(span.array->z, zSrc, width * sizeof(GLuint));

+         }

+         else {

+            GLint col;

+            for (col = 0; col < width; col++)

+               span.array->z[col] = zSrc[col] >> shift;

+         }

+         span.x = x;

+         span.y = y + row;

+         span.end = width;

+         _swrast_write_rgba_span(ctx, &span);

+      }

+   }

+   else {

+      /* General case */

+      const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+      GLint skipPixels = 0;

+

+      /* in case width > MAX_WIDTH do the copy in chunks */

+      while (skipPixels < width) {

+         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+         GLint row;

+         ASSERT(span.end <= MAX_WIDTH);

+         for (row = 0; row < height; row++) {

+            const GLvoid *zSrc = _mesa_image_address2d(unpack,

+                                                      pixels, width, height,

+                                                      GL_DEPTH_COMPONENT, type,

+                                                      row, skipPixels);

+

+            /* Set these for each row since the _swrast_write_* function may

+             * change them while clipping.

+             */

+            span.x = x + skipPixels;

+            span.y = y + row;

+            span.end = spanWidth;

+

+            _mesa_unpack_depth_span(ctx, spanWidth,

+                                    GL_UNSIGNED_INT, span.array->z, depthMax,

+                                    type, zSrc, unpack);

+            if (zoom) {

+               _swrast_write_zoomed_depth_span(ctx, x, y, &span);

+            }

+            else {

+               _swrast_write_rgba_span(ctx, &span);

+            }

+         }

+         skipPixels += spanWidth;

+      }

+   }

+}

+

+

+

+/**

+ * Draw RGBA image.

+ */

+static void

+draw_rgba_pixels( struct gl_context *ctx, GLint x, GLint y,

+                  GLsizei width, GLsizei height,

+                  GLenum format, GLenum type,

+                  const struct gl_pixelstore_attrib *unpack,

+                  const GLvoid *pixels )

+{

+   const GLint imgX = x, imgY = y;

+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;

+   GLfloat *convImage = NULL;

+   GLbitfield transferOps = ctx->_ImageTransferState;

+   SWspan span;

+

+   /* Try an optimized glDrawPixels first */

+   if (fast_draw_rgba_pixels(ctx, x, y, width, height, format, type,

+                             unpack, pixels)) {

+      return;

+   }

+

+   INIT_SPAN(span, GL_BITMAP);

+   _swrast_span_default_attribs(ctx, &span);

+   span.arrayMask = SPAN_RGBA;

+   span.arrayAttribs = FRAG_BIT_COL0; /* we're fill in COL0 attrib values */

+

+   if (ctx->DrawBuffer->_NumColorDrawBuffers > 0 &&

+       ctx->DrawBuffer->_ColorDrawBuffers[0]->DataType != GL_FLOAT &&

+       ctx->Color.ClampFragmentColor != GL_FALSE) {

+      /* need to clamp colors before applying fragment ops */

+      transferOps |= IMAGE_CLAMP_BIT;

+   }

+

+   /*

+    * General solution

+    */

+   {

+      const GLbitfield interpMask = span.interpMask;

+      const GLbitfield arrayMask = span.arrayMask;

+      const GLint srcStride

+         = _mesa_image_row_stride(unpack, width, format, type);

+      GLint skipPixels = 0;

+      /* use span array for temp color storage */

+      GLfloat *rgba = (GLfloat *) span.array->attribs[FRAG_ATTRIB_COL0];

+

+      /* if the span is wider than MAX_WIDTH we have to do it in chunks */

+      while (skipPixels < width) {

+         const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+         const GLubyte *source

+            = (const GLubyte *) _mesa_image_address2d(unpack, pixels,

+                                                      width, height, format,

+                                                      type, 0, skipPixels);

+         GLint row;

+

+         for (row = 0; row < height; row++) {

+            /* get image row as float/RGBA */

+            _mesa_unpack_color_span_float(ctx, spanWidth, GL_RGBA, rgba,

+                                     format, type, source, unpack,

+                                     transferOps);

+	    /* Set these for each row since the _swrast_write_* functions

+	     * may change them while clipping/rendering.

+	     */

+	    span.array->ChanType = GL_FLOAT;

+	    span.x = x + skipPixels;

+	    span.y = y + row;

+	    span.end = spanWidth;

+	    span.arrayMask = arrayMask;

+	    span.interpMask = interpMask;

+	    if (zoom) {

+	       _swrast_write_zoomed_rgba_span(ctx, imgX, imgY, &span, rgba);

+	    }

+	    else {

+	       _swrast_write_rgba_span(ctx, &span);

+	    }

+

+            source += srcStride;

+         } /* for row */

+

+         skipPixels += spanWidth;

+      } /* while skipPixels < width */

+

+      /* XXX this is ugly/temporary, to undo above change */

+      span.array->ChanType = CHAN_TYPE;

+   }

+

+   if (convImage) {

+      free(convImage);

+   }

+}

+

+

+/**

+ * This is a bit different from drawing GL_DEPTH_COMPONENT pixels.

+ * The only per-pixel operations that apply are depth scale/bias,

+ * stencil offset/shift, GL_DEPTH_WRITEMASK and GL_STENCIL_WRITEMASK,

+ * and pixel zoom.

+ * Also, only the depth buffer and stencil buffers are touched, not the

+ * color buffer(s).

+ */

+static void

+draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,

+                          GLsizei width, GLsizei height, GLenum type,

+                          const struct gl_pixelstore_attrib *unpack,

+                          const GLvoid *pixels)

+{

+   const GLint imgX = x, imgY = y;

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLuint depthMax = ctx->DrawBuffer->_DepthMax;

+   const GLuint stencilMask = ctx->Stencil.WriteMask[0];

+   const GLuint stencilType = (STENCIL_BITS == 8) ? 

+      GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   struct gl_renderbuffer *depthRb, *stencilRb;

+   struct gl_pixelstore_attrib clippedUnpack = *unpack;

+

+   if (!zoom) {

+      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,

+                                 &clippedUnpack)) {

+         /* totally clipped */

+         return;

+      }

+   }

+   

+   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;

+   ASSERT(depthRb);

+   ASSERT(stencilRb);

+

+   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       depthRb == stencilRb &&

+       !scaleOrBias &&

+       !zoom &&

+       ctx->Depth.Mask &&

+       (stencilMask & 0xff) == 0xff) {

+      /* This is the ideal case.

+       * Drawing GL_DEPTH_STENCIL pixels into a combined depth/stencil buffer.

+       * Plus, no pixel transfer ops, zooming, or masking needed.

+       */

+      GLint i;

+      for (i = 0; i < height; i++) {

+         const GLuint *src = (const GLuint *) 

+            _mesa_image_address2d(&clippedUnpack, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+         depthRb->PutRow(ctx, depthRb, width, x, y + i, src, NULL);

+      }

+   }

+   else {

+      /* sub-optimal cases:

+       * Separate depth/stencil buffers, or pixel transfer ops required.

+       */

+      /* XXX need to handle very wide images (skippixels) */

+      GLint i;

+

+      depthRb = ctx->DrawBuffer->_DepthBuffer;

+      stencilRb = ctx->DrawBuffer->_StencilBuffer;

+

+      for (i = 0; i < height; i++) {

+         const GLuint *depthStencilSrc = (const GLuint *)

+            _mesa_image_address2d(&clippedUnpack, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+

+         if (ctx->Depth.Mask) {

+            if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 24) {

+               /* fast path 24-bit zbuffer */

+               GLuint zValues[MAX_WIDTH];

+               GLint j;

+               ASSERT(depthRb->DataType == GL_UNSIGNED_INT);

+               for (j = 0; j < width; j++) {

+                  zValues[j] = depthStencilSrc[j] >> 8;

+               }

+               if (zoom)

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,

+                                              x, y + i, zValues);

+               else

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+            }

+            else if (!scaleOrBias && ctx->DrawBuffer->Visual.depthBits == 16) {

+               /* fast path 16-bit zbuffer */

+               GLushort zValues[MAX_WIDTH];

+               GLint j;

+               ASSERT(depthRb->DataType == GL_UNSIGNED_SHORT);

+               for (j = 0; j < width; j++) {

+                  zValues[j] = depthStencilSrc[j] >> 16;

+               }

+               if (zoom)

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width,

+                                              x, y + i, zValues);

+               else

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+            }

+            else {

+               /* general case */

+               GLuint zValues[MAX_WIDTH];  /* 16 or 32-bit Z value storage */

+               _mesa_unpack_depth_span(ctx, width,

+                                       depthRb->DataType, zValues, depthMax,

+                                       type, depthStencilSrc, &clippedUnpack);

+               if (zoom) {

+                  _swrast_write_zoomed_z_span(ctx, imgX, imgY, width, x,

+                                              y + i, zValues);

+               }

+               else {

+                  depthRb->PutRow(ctx, depthRb, width, x, y + i, zValues,NULL);

+               }

+            }

+         }

+

+         if (stencilMask != 0x0) {

+            GLstencil stencilValues[MAX_WIDTH];

+            /* get stencil values, with shift/offset/mapping */

+            _mesa_unpack_stencil_span(ctx, width, stencilType, stencilValues,

+                                      type, depthStencilSrc, &clippedUnpack,

+                                      ctx->_ImageTransferState);

+            if (zoom)

+               _swrast_write_zoomed_stencil_span(ctx, imgX, imgY, width,

+                                                  x, y + i, stencilValues);

+            else

+               _swrast_write_stencil_span(ctx, width, x, y + i, stencilValues);

+         }

+      }

+   }

+}

+

+

+/**

+ * Execute software-based glDrawPixels.

+ * By time we get here, all error checking will have been done.

+ */

+void

+_swrast_DrawPixels( struct gl_context *ctx,

+		    GLint x, GLint y,

+		    GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *unpack,

+		    const GLvoid *pixels )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLboolean save_vp_override = ctx->VertexProgram._Overriden;

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't draw */

+

+   /* We are creating fragments directly, without going through vertex

+    * programs.

+    *

+    * This override flag tells the fragment processing code that its input

+    * comes from a non-standard source, and it may therefore not rely on

+    * optimizations that assume e.g. constant color if there is no color

+    * vertex array.

+    */

+   _mesa_set_vp_override(ctx, GL_TRUE);

+

+   swrast_render_start(ctx);

+

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);

+   if (!pixels) {

+      swrast_render_finish(ctx);

+      _mesa_set_vp_override(ctx, save_vp_override);

+      return;

+   }

+

+   /*

+    * By time we get here, all error checking should have been done.

+    */

+   switch (format) {

+   case GL_STENCIL_INDEX:

+      draw_stencil_pixels( ctx, x, y, width, height, type, unpack, pixels );

+      break;

+   case GL_DEPTH_COMPONENT:

+      draw_depth_pixels( ctx, x, y, width, height, type, unpack, pixels );

+      break;

+   case GL_DEPTH_STENCIL_EXT:

+      draw_depth_stencil_pixels(ctx, x, y, width, height, type, unpack, pixels);

+      break;

+   default:

+      /* all other formats should be color formats */

+      draw_rgba_pixels(ctx, x, y, width, height, format, type, unpack, pixels);

+   }

+

+   swrast_render_finish(ctx);

+   _mesa_set_vp_override(ctx, save_vp_override);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+}

diff --git a/mesalib/src/mesa/swrast/s_readpix.c b/mesalib/src/mesa/swrast/s_readpix.c
index 5c8d7e9c5..23da10dab 100644
--- a/mesalib/src/mesa/swrast/s_readpix.c
+++ b/mesalib/src/mesa/swrast/s_readpix.c
@@ -1,508 +1,508 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.0.3
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "main/glheader.h"
-#include "main/colormac.h"
-#include "main/feedback.h"
-#include "main/formats.h"
-#include "main/image.h"
-#include "main/imports.h"
-#include "main/macros.h"
-#include "main/pack.h"
-#include "main/pbo.h"
-#include "main/state.h"
-
-#include "s_context.h"
-#include "s_depth.h"
-#include "s_span.h"
-#include "s_stencil.h"
-
-
-/**
- * Read pixels for format=GL_DEPTH_COMPONENT.
- */
-static void
-read_depth_pixels( struct gl_context *ctx,
-                   GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type, GLvoid *pixels,
-                   const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_DepthBuffer;
-   const GLboolean biasOrScale
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-
-   if (!rb)
-      return;
-
-   /* clipping should have been done already */
-   ASSERT(x >= 0);
-   ASSERT(y >= 0);
-   ASSERT(x + width <= (GLint) rb->Width);
-   ASSERT(y + height <= (GLint) rb->Height);
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   if (type == GL_UNSIGNED_SHORT && fb->Visual.depthBits == 16
-       && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 16-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_Z16);
-      ASSERT(rb->DataType == GL_UNSIGNED_SHORT);
-      for (j = 0; j < height; j++, y++) {
-         void *dest =_mesa_image_address2d(packing, pixels, width, height,
-                                           GL_DEPTH_COMPONENT, type, j, 0);
-         rb->GetRow(ctx, rb, width, x, y, dest);
-      }
-   }
-   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 24
-            && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 24-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_X8_Z24 ||
-             rb->Format == MESA_FORMAT_S8_Z24 ||
-             rb->Format == MESA_FORMAT_Z24_X8 ||
-             rb->Format == MESA_FORMAT_Z24_S8);
-      ASSERT(rb->DataType == GL_UNSIGNED_INT ||
-             rb->DataType == GL_UNSIGNED_INT_24_8);
-      for (j = 0; j < height; j++, y++) {
-         GLuint *dest = (GLuint *)
-            _mesa_image_address2d(packing, pixels, width, height,
-                                  GL_DEPTH_COMPONENT, type, j, 0);
-         GLint k;
-         rb->GetRow(ctx, rb, width, x, y, dest);
-         /* convert range from 24-bit to 32-bit */
-         if (rb->Format == MESA_FORMAT_X8_Z24 ||
-             rb->Format == MESA_FORMAT_S8_Z24) {
-            for (k = 0; k < width; k++) {
-               /* Note: put MSByte of 24-bit value into LSByte */
-               dest[k] = (dest[k] << 8) | ((dest[k] >> 16) & 0xff);
-            }
-         }
-         else {
-            for (k = 0; k < width; k++) {
-               /* Note: fill in LSByte by replication */
-               dest[k] = dest[k] | ((dest[k] >> 8) & 0xff);
-            }
-         }
-      }
-   }
-   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 32
-            && !biasOrScale && !packing->SwapBytes) {
-      /* Special case: directly read 32-bit unsigned depth values. */
-      GLint j;
-      ASSERT(rb->Format == MESA_FORMAT_Z32);
-      ASSERT(rb->DataType == GL_UNSIGNED_INT);
-      for (j = 0; j < height; j++, y++) {
-         void *dest = _mesa_image_address2d(packing, pixels, width, height,
-                                            GL_DEPTH_COMPONENT, type, j, 0);
-         rb->GetRow(ctx, rb, width, x, y, dest);
-      }
-   }
-   else {
-      /* General case (slower) */
-      GLint j;
-      for (j = 0; j < height; j++, y++) {
-         GLfloat depthValues[MAX_WIDTH];
-         GLvoid *dest = _mesa_image_address2d(packing, pixels, width, height,
-                                              GL_DEPTH_COMPONENT, type, j, 0);
-         _swrast_read_depth_span_float(ctx, rb, width, x, y, depthValues);
-         _mesa_pack_depth_span(ctx, width, dest, type, depthValues, packing);
-      }
-   }
-}
-
-
-/**
- * Read pixels for format=GL_STENCIL_INDEX.
- */
-static void
-read_stencil_pixels( struct gl_context *ctx,
-                     GLint x, GLint y,
-                     GLsizei width, GLsizei height,
-                     GLenum type, GLvoid *pixels,
-                     const struct gl_pixelstore_attrib *packing )
-{
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_StencilBuffer;
-   GLint j;
-
-   if (!rb)
-      return;
-
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   /* process image row by row */
-   for (j=0;j<height;j++,y++) {
-      GLvoid *dest;
-      GLstencil stencil[MAX_WIDTH];
-
-      _swrast_read_stencil_span(ctx, rb, width, x, y, stencil);
-
-      dest = _mesa_image_address2d(packing, pixels, width, height,
-                                   GL_STENCIL_INDEX, type, j, 0);
-
-      _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing);
-   }
-}
-
-
-
-/**
- * Optimized glReadPixels for particular pixel formats when pixel
- * scaling, biasing, mapping, etc. are disabled.
- * \return GL_TRUE if success, GL_FALSE if unable to do the readpixels
- */
-static GLboolean
-fast_read_rgba_pixels( struct gl_context *ctx,
-                       GLint x, GLint y,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing,
-                       GLbitfield transferOps)
-{
-   struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-
-   if (!rb)
-      return GL_FALSE;
-
-   ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||
-	  rb->_BaseFormat == GL_ALPHA);
-
-   /* clipping should have already been done */
-   ASSERT(x + width <= (GLint) rb->Width);
-   ASSERT(y + height <= (GLint) rb->Height);
-
-   /* check for things we can't handle here */
-   if (transferOps ||
-       packing->SwapBytes ||
-       packing->LsbFirst) {
-      return GL_FALSE;
-   }
-
-   if (format == GL_RGBA && rb->DataType == type) {
-      const GLint dstStride = _mesa_image_row_stride(packing, width,
-                                                     format, type);
-      GLubyte *dest
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-      GLint row;
-      ASSERT(rb->GetRow);
-      for (row = 0; row < height; row++) {
-         rb->GetRow(ctx, rb, width, x, y + row, dest);
-         dest += dstStride;
-      }
-      return GL_TRUE;
-   }
-
-   if (format == GL_RGB &&
-       rb->DataType == GL_UNSIGNED_BYTE &&
-       type == GL_UNSIGNED_BYTE) {
-      const GLint dstStride = _mesa_image_row_stride(packing, width,
-                                                     format, type);
-      GLubyte *dest
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-      GLint row;
-      ASSERT(rb->GetRow);
-      for (row = 0; row < height; row++) {
-         GLubyte tempRow[MAX_WIDTH][4];
-         GLint col;
-         rb->GetRow(ctx, rb, width, x, y + row, tempRow);
-         /* convert RGBA to RGB */
-         for (col = 0; col < width; col++) {
-            dest[col * 3 + 0] = tempRow[col][0];
-            dest[col * 3 + 1] = tempRow[col][1];
-            dest[col * 3 + 2] = tempRow[col][2];
-         }
-         dest += dstStride;
-      }
-      return GL_TRUE;
-   }
-
-   /* not handled */
-   return GL_FALSE;
-}
-
-
-/**
- * When we're using a low-precision color buffer (like 16-bit 5/6/5)
- * we have to adjust our color values a bit to pass conformance.
- * The problem is when a 5 or 6-bit color value is converted to an 8-bit
- * value and then a floating point value, the floating point values don't
- * increment uniformly as the 5 or 6-bit value is incremented.
- *
- * This function adjusts floating point values to compensate.
- */
-static void
-adjust_colors(const struct gl_framebuffer *fb, GLuint n, GLfloat rgba[][4])
-{
-   const GLuint rShift = 8 - fb->Visual.redBits;
-   const GLuint gShift = 8 - fb->Visual.greenBits;
-   const GLuint bShift = 8 - fb->Visual.blueBits;
-   GLfloat rScale = 1.0F / (GLfloat) ((1 << fb->Visual.redBits  ) - 1);
-   GLfloat gScale = 1.0F / (GLfloat) ((1 << fb->Visual.greenBits) - 1);
-   GLfloat bScale = 1.0F / (GLfloat) ((1 << fb->Visual.blueBits ) - 1);
-   GLuint i;
-
-   if (fb->Visual.redBits == 0)
-      rScale = 0;
-   if (fb->Visual.greenBits == 0)
-      gScale = 0;
-   if (fb->Visual.blueBits == 0)
-      bScale = 0;
-
-   for (i = 0; i < n; i++) {
-      GLint r, g, b;
-      /* convert float back to ubyte */
-      CLAMPED_FLOAT_TO_UBYTE(r, rgba[i][RCOMP]);
-      CLAMPED_FLOAT_TO_UBYTE(g, rgba[i][GCOMP]);
-      CLAMPED_FLOAT_TO_UBYTE(b, rgba[i][BCOMP]);
-      /* using only the N most significant bits of the ubyte value, convert to
-       * float in [0,1].
-       */
-      rgba[i][RCOMP] = (GLfloat) (r >> rShift) * rScale;
-      rgba[i][GCOMP] = (GLfloat) (g >> gShift) * gScale;
-      rgba[i][BCOMP] = (GLfloat) (b >> bShift) * bScale;
-   }
-}
-
-
-
-/*
- * Read R, G, B, A, RGB, L, or LA pixels.
- */
-static void
-read_rgba_pixels( struct gl_context *ctx,
-                  GLint x, GLint y,
-                  GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, GLvoid *pixels,
-                  const struct gl_pixelstore_attrib *packing )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   GLbitfield transferOps = ctx->_ImageTransferState;
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-   struct gl_renderbuffer *rb = fb->_ColorReadBuffer;
-
-   if (!rb)
-      return;
-
-   if (type == GL_FLOAT && ((ctx->Color.ClampReadColor == GL_TRUE) ||
-                            (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB &&
-                             rb->DataType != GL_FLOAT)))
-      transferOps |= IMAGE_CLAMP_BIT;
-
-   /* Try optimized path first */
-   if (fast_read_rgba_pixels(ctx, x, y, width, height,
-                             format, type, pixels, packing, transferOps)) {
-      return; /* done! */
-   }
-
-   /* width should never be > MAX_WIDTH since we did clipping earlier */
-   ASSERT(width <= MAX_WIDTH);
-
-   do {
-      const GLint dstStride
-         = _mesa_image_row_stride(packing, width, format, type);
-      GLfloat (*rgba)[4] = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];
-      GLint row;
-      GLubyte *dst
-         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,
-                                             format, type, 0, 0);
-
-      for (row = 0; row < height; row++, y++) {
-
-         /* Get float rgba pixels */
-         _swrast_read_rgba_span(ctx, rb, width, x, y, GL_FLOAT, rgba);
-
-         /* apply fudge factor for shallow color buffers */
-         if (fb->Visual.redBits < 8 ||
-             fb->Visual.greenBits < 8 ||
-             fb->Visual.blueBits < 8) {
-            adjust_colors(fb, width, rgba);
-         }
-
-         /* pack the row of RGBA pixels into user's buffer */
-         _mesa_pack_rgba_span_float(ctx, width, rgba, format, type, dst,
-                                    packing, transferOps);
-
-         dst += dstStride;
-      }
-   } while (0);
-}
-
-
-/**
- * Read combined depth/stencil values.
- * We'll have already done error checking to be sure the expected
- * depth and stencil buffers really exist.
- */
-static void
-read_depth_stencil_pixels(struct gl_context *ctx,
-                          GLint x, GLint y,
-                          GLsizei width, GLsizei height,
-                          GLenum type, GLvoid *pixels,
-                          const struct gl_pixelstore_attrib *packing )
-{
-   const GLboolean scaleOrBias
-      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;
-   const GLboolean stencilTransfer = ctx->Pixel.IndexShift
-      || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag;
-   struct gl_renderbuffer *depthRb, *stencilRb;
-
-   depthRb = ctx->ReadBuffer->_DepthBuffer;
-   stencilRb = ctx->ReadBuffer->_StencilBuffer;
-
-   if (!depthRb || !stencilRb)
-      return;
-
-   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
-   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;
-
-   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&
-       depthRb == stencilRb &&
-       !scaleOrBias &&
-       !stencilTransfer) {
-      /* This is the ideal case.
-       * Reading GL_DEPTH_STENCIL pixels from combined depth/stencil buffer.
-       * Plus, no pixel transfer ops to worry about!
-       */
-      GLint i;
-      GLint dstStride = _mesa_image_row_stride(packing, width,
-                                               GL_DEPTH_STENCIL_EXT, type);
-      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, pixels,
-                                                       width, height,
-                                                       GL_DEPTH_STENCIL_EXT,
-                                                       type, 0, 0);
-      for (i = 0; i < height; i++) {
-         depthRb->GetRow(ctx, depthRb, width, x, y + i, dst);
-         dst += dstStride;
-      }
-   }
-   else {
-      /* Reading GL_DEPTH_STENCIL pixels from separate depth/stencil buffers,
-       * or we need pixel transfer.
-       */
-      GLint i;
-      depthRb = ctx->ReadBuffer->_DepthBuffer;
-      stencilRb = ctx->ReadBuffer->_StencilBuffer;
-
-      for (i = 0; i < height; i++) {
-         GLstencil stencilVals[MAX_WIDTH];
-
-         GLuint *depthStencilDst = (GLuint *)
-            _mesa_image_address2d(packing, pixels, width, height,
-                                  GL_DEPTH_STENCIL_EXT, type, i, 0);
-
-         _swrast_read_stencil_span(ctx, stencilRb, width,
-                                   x, y + i, stencilVals);
-
-         if (!scaleOrBias && !stencilTransfer
-             && ctx->ReadBuffer->Visual.depthBits == 24) {
-            /* ideal case */
-            GLuint zVals[MAX_WIDTH]; /* 24-bit values! */
-            GLint j;
-            ASSERT(depthRb->DataType == GL_UNSIGNED_INT);
-            /* note, we've already been clipped */
-            depthRb->GetRow(ctx, depthRb, width, x, y + i, zVals);
-            for (j = 0; j < width; j++) {
-               depthStencilDst[j] = (zVals[j] << 8) | (stencilVals[j] & 0xff);
-            }
-         }
-         else {
-            /* general case */
-            GLfloat depthVals[MAX_WIDTH];
-            _swrast_read_depth_span_float(ctx, depthRb, width, x, y + i,
-                                          depthVals);
-            _mesa_pack_depth_stencil_span(ctx, width, depthStencilDst,
-                                          depthVals, stencilVals, packing);
-         }
-      }
-   }
-}
-
-
-
-/**
- * Software fallback routine for ctx->Driver.ReadPixels().
- * By time we get here, all error checking will have been done.
- */
-void
-_swrast_ReadPixels( struct gl_context *ctx,
-		    GLint x, GLint y, GLsizei width, GLsizei height,
-		    GLenum format, GLenum type,
-		    const struct gl_pixelstore_attrib *packing,
-		    GLvoid *pixels )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   struct gl_pixelstore_attrib clippedPacking = *packing;
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   /* Need to do swrast_render_start() before clipping or anything else
-    * since this is where a driver may grab the hw lock and get an updated
-    * window size.
-    */
-   swrast_render_start(ctx);
-
-   if (swrast->NewState)
-      _swrast_validate_derived( ctx );
-
-   /* Do all needed clipping here, so that we can forget about it later */
-   if (_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {
-
-      pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels);
-
-      if (pixels) {
-         switch (format) {
-         case GL_STENCIL_INDEX:
-            read_stencil_pixels(ctx, x, y, width, height, type, pixels,
-                                &clippedPacking);
-            break;
-         case GL_DEPTH_COMPONENT:
-            read_depth_pixels(ctx, x, y, width, height, type, pixels,
-                              &clippedPacking);
-            break;
-         case GL_DEPTH_STENCIL_EXT:
-            read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels,
-                                      &clippedPacking);
-            break;
-         default:
-            /* all other formats should be color formats */
-            read_rgba_pixels(ctx, x, y, width, height, format, type, pixels,
-                             &clippedPacking);
-         }
-
-         _mesa_unmap_pbo_dest(ctx, &clippedPacking);
-      }
-   }
-
-   swrast_render_finish(ctx);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.0.3

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "main/glheader.h"

+#include "main/colormac.h"

+#include "main/feedback.h"

+#include "main/formats.h"

+#include "main/image.h"

+#include "main/imports.h"

+#include "main/macros.h"

+#include "main/pack.h"

+#include "main/pbo.h"

+#include "main/state.h"

+

+#include "s_context.h"

+#include "s_depth.h"

+#include "s_span.h"

+#include "s_stencil.h"

+

+

+/**

+ * Read pixels for format=GL_DEPTH_COMPONENT.

+ */

+static void

+read_depth_pixels( struct gl_context *ctx,

+                   GLint x, GLint y,

+                   GLsizei width, GLsizei height,

+                   GLenum type, GLvoid *pixels,

+                   const struct gl_pixelstore_attrib *packing )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_DepthBuffer;

+   const GLboolean biasOrScale

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+

+   if (!rb)

+      return;

+

+   /* clipping should have been done already */

+   ASSERT(x >= 0);

+   ASSERT(y >= 0);

+   ASSERT(x + width <= (GLint) rb->Width);

+   ASSERT(y + height <= (GLint) rb->Height);

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   if (type == GL_UNSIGNED_SHORT && fb->Visual.depthBits == 16

+       && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 16-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_Z16);

+      ASSERT(rb->DataType == GL_UNSIGNED_SHORT);

+      for (j = 0; j < height; j++, y++) {

+         void *dest =_mesa_image_address2d(packing, pixels, width, height,

+                                           GL_DEPTH_COMPONENT, type, j, 0);

+         rb->GetRow(ctx, rb, width, x, y, dest);

+      }

+   }

+   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 24

+            && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 24-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_X8_Z24 ||

+             rb->Format == MESA_FORMAT_S8_Z24 ||

+             rb->Format == MESA_FORMAT_Z24_X8 ||

+             rb->Format == MESA_FORMAT_Z24_S8);

+      ASSERT(rb->DataType == GL_UNSIGNED_INT ||

+             rb->DataType == GL_UNSIGNED_INT_24_8);

+      for (j = 0; j < height; j++, y++) {

+         GLuint *dest = (GLuint *)

+            _mesa_image_address2d(packing, pixels, width, height,

+                                  GL_DEPTH_COMPONENT, type, j, 0);

+         GLint k;

+         rb->GetRow(ctx, rb, width, x, y, dest);

+         /* convert range from 24-bit to 32-bit */

+         if (rb->Format == MESA_FORMAT_X8_Z24 ||

+             rb->Format == MESA_FORMAT_S8_Z24) {

+            for (k = 0; k < width; k++) {

+               /* Note: put MSByte of 24-bit value into LSByte */

+               dest[k] = (dest[k] << 8) | ((dest[k] >> 16) & 0xff);

+            }

+         }

+         else {

+            for (k = 0; k < width; k++) {

+               /* Note: fill in LSByte by replication */

+               dest[k] = dest[k] | ((dest[k] >> 8) & 0xff);

+            }

+         }

+      }

+   }

+   else if (type == GL_UNSIGNED_INT && fb->Visual.depthBits == 32

+            && !biasOrScale && !packing->SwapBytes) {

+      /* Special case: directly read 32-bit unsigned depth values. */

+      GLint j;

+      ASSERT(rb->Format == MESA_FORMAT_Z32);

+      ASSERT(rb->DataType == GL_UNSIGNED_INT);

+      for (j = 0; j < height; j++, y++) {

+         void *dest = _mesa_image_address2d(packing, pixels, width, height,

+                                            GL_DEPTH_COMPONENT, type, j, 0);

+         rb->GetRow(ctx, rb, width, x, y, dest);

+      }

+   }

+   else {

+      /* General case (slower) */

+      GLint j;

+      for (j = 0; j < height; j++, y++) {

+         GLfloat depthValues[MAX_WIDTH];

+         GLvoid *dest = _mesa_image_address2d(packing, pixels, width, height,

+                                              GL_DEPTH_COMPONENT, type, j, 0);

+         _swrast_read_depth_span_float(ctx, rb, width, x, y, depthValues);

+         _mesa_pack_depth_span(ctx, width, dest, type, depthValues, packing);

+      }

+   }

+}

+

+

+/**

+ * Read pixels for format=GL_STENCIL_INDEX.

+ */

+static void

+read_stencil_pixels( struct gl_context *ctx,

+                     GLint x, GLint y,

+                     GLsizei width, GLsizei height,

+                     GLenum type, GLvoid *pixels,

+                     const struct gl_pixelstore_attrib *packing )

+{

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_StencilBuffer;

+   GLint j;

+

+   if (!rb)

+      return;

+

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   /* process image row by row */

+   for (j=0;j<height;j++,y++) {

+      GLvoid *dest;

+      GLstencil stencil[MAX_WIDTH];

+

+      _swrast_read_stencil_span(ctx, rb, width, x, y, stencil);

+

+      dest = _mesa_image_address2d(packing, pixels, width, height,

+                                   GL_STENCIL_INDEX, type, j, 0);

+

+      _mesa_pack_stencil_span(ctx, width, type, dest, stencil, packing);

+   }

+}

+

+

+

+/**

+ * Optimized glReadPixels for particular pixel formats when pixel

+ * scaling, biasing, mapping, etc. are disabled.

+ * \return GL_TRUE if success, GL_FALSE if unable to do the readpixels

+ */

+static GLboolean

+fast_read_rgba_pixels( struct gl_context *ctx,

+                       GLint x, GLint y,

+                       GLsizei width, GLsizei height,

+                       GLenum format, GLenum type,

+                       GLvoid *pixels,

+                       const struct gl_pixelstore_attrib *packing,

+                       GLbitfield transferOps)

+{

+   struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;

+

+   if (!rb)

+      return GL_FALSE;

+

+   ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||

+	  rb->_BaseFormat == GL_ALPHA);

+

+   /* clipping should have already been done */

+   ASSERT(x + width <= (GLint) rb->Width);

+   ASSERT(y + height <= (GLint) rb->Height);

+

+   /* check for things we can't handle here */

+   if (transferOps ||

+       packing->SwapBytes ||

+       packing->LsbFirst) {

+      return GL_FALSE;

+   }

+

+   if (format == GL_RGBA && rb->DataType == type) {

+      const GLint dstStride = _mesa_image_row_stride(packing, width,

+                                                     format, type);

+      GLubyte *dest

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+      GLint row;

+      ASSERT(rb->GetRow);

+      for (row = 0; row < height; row++) {

+         rb->GetRow(ctx, rb, width, x, y + row, dest);

+         dest += dstStride;

+      }

+      return GL_TRUE;

+   }

+

+   if (format == GL_RGB &&

+       rb->DataType == GL_UNSIGNED_BYTE &&

+       type == GL_UNSIGNED_BYTE) {

+      const GLint dstStride = _mesa_image_row_stride(packing, width,

+                                                     format, type);

+      GLubyte *dest

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+      GLint row;

+      ASSERT(rb->GetRow);

+      for (row = 0; row < height; row++) {

+         GLubyte tempRow[MAX_WIDTH][4];

+         GLint col;

+         rb->GetRow(ctx, rb, width, x, y + row, tempRow);

+         /* convert RGBA to RGB */

+         for (col = 0; col < width; col++) {

+            dest[col * 3 + 0] = tempRow[col][0];

+            dest[col * 3 + 1] = tempRow[col][1];

+            dest[col * 3 + 2] = tempRow[col][2];

+         }

+         dest += dstStride;

+      }

+      return GL_TRUE;

+   }

+

+   /* not handled */

+   return GL_FALSE;

+}

+

+

+/**

+ * When we're using a low-precision color buffer (like 16-bit 5/6/5)

+ * we have to adjust our color values a bit to pass conformance.

+ * The problem is when a 5 or 6-bit color value is converted to an 8-bit

+ * value and then a floating point value, the floating point values don't

+ * increment uniformly as the 5 or 6-bit value is incremented.

+ *

+ * This function adjusts floating point values to compensate.

+ */

+static void

+adjust_colors(const struct gl_framebuffer *fb, GLuint n, GLfloat rgba[][4])

+{

+   const GLuint rShift = 8 - fb->Visual.redBits;

+   const GLuint gShift = 8 - fb->Visual.greenBits;

+   const GLuint bShift = 8 - fb->Visual.blueBits;

+   GLfloat rScale = 1.0F / (GLfloat) ((1 << fb->Visual.redBits  ) - 1);

+   GLfloat gScale = 1.0F / (GLfloat) ((1 << fb->Visual.greenBits) - 1);

+   GLfloat bScale = 1.0F / (GLfloat) ((1 << fb->Visual.blueBits ) - 1);

+   GLuint i;

+

+   if (fb->Visual.redBits == 0)

+      rScale = 0;

+   if (fb->Visual.greenBits == 0)

+      gScale = 0;

+   if (fb->Visual.blueBits == 0)

+      bScale = 0;

+

+   for (i = 0; i < n; i++) {

+      GLint r, g, b;

+      /* convert float back to ubyte */

+      CLAMPED_FLOAT_TO_UBYTE(r, rgba[i][RCOMP]);

+      CLAMPED_FLOAT_TO_UBYTE(g, rgba[i][GCOMP]);

+      CLAMPED_FLOAT_TO_UBYTE(b, rgba[i][BCOMP]);

+      /* using only the N most significant bits of the ubyte value, convert to

+       * float in [0,1].

+       */

+      rgba[i][RCOMP] = (GLfloat) (r >> rShift) * rScale;

+      rgba[i][GCOMP] = (GLfloat) (g >> gShift) * gScale;

+      rgba[i][BCOMP] = (GLfloat) (b >> bShift) * bScale;

+   }

+}

+

+

+

+/*

+ * Read R, G, B, A, RGB, L, or LA pixels.

+ */

+static void

+read_rgba_pixels( struct gl_context *ctx,

+                  GLint x, GLint y,

+                  GLsizei width, GLsizei height,

+                  GLenum format, GLenum type, GLvoid *pixels,

+                  const struct gl_pixelstore_attrib *packing )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   GLbitfield transferOps = ctx->_ImageTransferState;

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+   struct gl_renderbuffer *rb = fb->_ColorReadBuffer;

+

+   if (!rb)

+      return;

+

+   if (type == GL_FLOAT && ((ctx->Color.ClampReadColor == GL_TRUE) ||

+                            (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB &&

+                             rb->DataType != GL_FLOAT)))

+      transferOps |= IMAGE_CLAMP_BIT;

+

+   /* Try optimized path first */

+   if (fast_read_rgba_pixels(ctx, x, y, width, height,

+                             format, type, pixels, packing, transferOps)) {

+      return; /* done! */

+   }

+

+   /* width should never be > MAX_WIDTH since we did clipping earlier */

+   ASSERT(width <= MAX_WIDTH);

+

+   do {

+      const GLint dstStride

+         = _mesa_image_row_stride(packing, width, format, type);

+      GLfloat (*rgba)[4] = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];

+      GLint row;

+      GLubyte *dst

+         = (GLubyte *) _mesa_image_address2d(packing, pixels, width, height,

+                                             format, type, 0, 0);

+

+      for (row = 0; row < height; row++, y++) {

+

+         /* Get float rgba pixels */

+         _swrast_read_rgba_span(ctx, rb, width, x, y, GL_FLOAT, rgba);

+

+         /* apply fudge factor for shallow color buffers */

+         if (fb->Visual.redBits < 8 ||

+             fb->Visual.greenBits < 8 ||

+             fb->Visual.blueBits < 8) {

+            adjust_colors(fb, width, rgba);

+         }

+

+         /* pack the row of RGBA pixels into user's buffer */

+         _mesa_pack_rgba_span_float(ctx, width, rgba, format, type, dst,

+                                    packing, transferOps);

+

+         dst += dstStride;

+      }

+   } while (0);

+}

+

+

+/**

+ * Read combined depth/stencil values.

+ * We'll have already done error checking to be sure the expected

+ * depth and stencil buffers really exist.

+ */

+static void

+read_depth_stencil_pixels(struct gl_context *ctx,

+                          GLint x, GLint y,

+                          GLsizei width, GLsizei height,

+                          GLenum type, GLvoid *pixels,

+                          const struct gl_pixelstore_attrib *packing )

+{

+   const GLboolean scaleOrBias

+      = ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0;

+   const GLboolean stencilTransfer = ctx->Pixel.IndexShift

+      || ctx->Pixel.IndexOffset || ctx->Pixel.MapStencilFlag;

+   struct gl_renderbuffer *depthRb, *stencilRb;

+

+   depthRb = ctx->ReadBuffer->_DepthBuffer;

+   stencilRb = ctx->ReadBuffer->_StencilBuffer;

+

+   if (!depthRb || !stencilRb)

+      return;

+

+   depthRb = ctx->ReadBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

+   stencilRb = ctx->ReadBuffer->Attachment[BUFFER_STENCIL].Renderbuffer;

+

+   if (depthRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       stencilRb->_BaseFormat == GL_DEPTH_STENCIL_EXT &&

+       depthRb == stencilRb &&

+       !scaleOrBias &&

+       !stencilTransfer) {

+      /* This is the ideal case.

+       * Reading GL_DEPTH_STENCIL pixels from combined depth/stencil buffer.

+       * Plus, no pixel transfer ops to worry about!

+       */

+      GLint i;

+      GLint dstStride = _mesa_image_row_stride(packing, width,

+                                               GL_DEPTH_STENCIL_EXT, type);

+      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, pixels,

+                                                       width, height,

+                                                       GL_DEPTH_STENCIL_EXT,

+                                                       type, 0, 0);

+      for (i = 0; i < height; i++) {

+         depthRb->GetRow(ctx, depthRb, width, x, y + i, dst);

+         dst += dstStride;

+      }

+   }

+   else {

+      /* Reading GL_DEPTH_STENCIL pixels from separate depth/stencil buffers,

+       * or we need pixel transfer.

+       */

+      GLint i;

+      depthRb = ctx->ReadBuffer->_DepthBuffer;

+      stencilRb = ctx->ReadBuffer->_StencilBuffer;

+

+      for (i = 0; i < height; i++) {

+         GLstencil stencilVals[MAX_WIDTH];

+

+         GLuint *depthStencilDst = (GLuint *)

+            _mesa_image_address2d(packing, pixels, width, height,

+                                  GL_DEPTH_STENCIL_EXT, type, i, 0);

+

+         _swrast_read_stencil_span(ctx, stencilRb, width,

+                                   x, y + i, stencilVals);

+

+         if (!scaleOrBias && !stencilTransfer

+             && ctx->ReadBuffer->Visual.depthBits == 24) {

+            /* ideal case */

+            GLuint zVals[MAX_WIDTH]; /* 24-bit values! */

+            GLint j;

+            ASSERT(depthRb->DataType == GL_UNSIGNED_INT);

+            /* note, we've already been clipped */

+            depthRb->GetRow(ctx, depthRb, width, x, y + i, zVals);

+            for (j = 0; j < width; j++) {

+               depthStencilDst[j] = (zVals[j] << 8) | (stencilVals[j] & 0xff);

+            }

+         }

+         else {

+            /* general case */

+            GLfloat depthVals[MAX_WIDTH];

+            _swrast_read_depth_span_float(ctx, depthRb, width, x, y + i,

+                                          depthVals);

+            _mesa_pack_depth_stencil_span(ctx, width, depthStencilDst,

+                                          depthVals, stencilVals, packing);

+         }

+      }

+   }

+}

+

+

+

+/**

+ * Software fallback routine for ctx->Driver.ReadPixels().

+ * By time we get here, all error checking will have been done.

+ */

+void

+_swrast_ReadPixels( struct gl_context *ctx,

+		    GLint x, GLint y, GLsizei width, GLsizei height,

+		    GLenum format, GLenum type,

+		    const struct gl_pixelstore_attrib *packing,

+		    GLvoid *pixels )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   struct gl_pixelstore_attrib clippedPacking = *packing;

+

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   /* Need to do swrast_render_start() before clipping or anything else

+    * since this is where a driver may grab the hw lock and get an updated

+    * window size.

+    */

+   swrast_render_start(ctx);

+

+   if (swrast->NewState)

+      _swrast_validate_derived( ctx );

+

+   /* Do all needed clipping here, so that we can forget about it later */

+   if (_mesa_clip_readpixels(ctx, &x, &y, &width, &height, &clippedPacking)) {

+

+      pixels = _mesa_map_pbo_dest(ctx, &clippedPacking, pixels);

+

+      if (pixels) {

+         switch (format) {

+         case GL_STENCIL_INDEX:

+            read_stencil_pixels(ctx, x, y, width, height, type, pixels,

+                                &clippedPacking);

+            break;

+         case GL_DEPTH_COMPONENT:

+            read_depth_pixels(ctx, x, y, width, height, type, pixels,

+                              &clippedPacking);

+            break;

+         case GL_DEPTH_STENCIL_EXT:

+            read_depth_stencil_pixels(ctx, x, y, width, height, type, pixels,

+                                      &clippedPacking);

+            break;

+         default:

+            /* all other formats should be color formats */

+            read_rgba_pixels(ctx, x, y, width, height, format, type, pixels,

+                             &clippedPacking);

+         }

+

+         _mesa_unmap_pbo_dest(ctx, &clippedPacking);

+      }

+   }

+

+   swrast_render_finish(ctx);

+}

diff --git a/mesalib/src/mesa/swrast/s_texcombine.c b/mesalib/src/mesa/swrast/s_texcombine.c
index 0c8cc9ff3..a7f4fe67d 100644
--- a/mesalib/src/mesa/swrast/s_texcombine.c
+++ b/mesalib/src/mesa/swrast/s_texcombine.c
@@ -1,737 +1,737 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.5
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/imports.h"
-#include "main/pixeltransfer.h"
-#include "program/prog_instruction.h"
-
-#include "s_context.h"
-#include "s_texcombine.h"
-
-
-/**
- * Pointer to array of float[4]
- * This type makes the code below more concise and avoids a lot of casting.
- */
-typedef float (*float4_array)[4];
-
-
-/**
- * Return array of texels for given unit.
- */
-static INLINE float4_array
-get_texel_array(SWcontext *swrast, GLuint unit)
-{
-   return (float4_array) (swrast->TexelBuffer + unit * MAX_WIDTH * 4);
-}
-
-
-
-/**
- * Do texture application for:
- *  GL_EXT_texture_env_combine
- *  GL_ARB_texture_env_combine
- *  GL_EXT_texture_env_dot3
- *  GL_ARB_texture_env_dot3
- *  GL_ATI_texture_env_combine3
- *  GL_NV_texture_env_combine4
- *  conventional GL texture env modes
- *
- * \param ctx          rendering context
- * \param unit         the texture combiner unit
- * \param n            number of fragments to process (span width)
- * \param primary_rgba incoming fragment color array
- * \param texelBuffer  pointer to texel colors for all texture units
- * 
- * \param rgba         incoming/result fragment colors
- */
-static void
-texture_combine( struct gl_context *ctx, GLuint unit, GLuint n,
-                 const float4_array primary_rgba,
-                 const GLfloat *texelBuffer,
-                 GLchan (*rgbaChan)[4] )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);
-   const struct gl_tex_env_combine_state *combine = textureUnit->_CurrentCombine;
-   float4_array argRGB[MAX_COMBINER_TERMS];
-   float4_array argA[MAX_COMBINER_TERMS];
-   const GLfloat scaleRGB = (GLfloat) (1 << combine->ScaleShiftRGB);
-   const GLfloat scaleA = (GLfloat) (1 << combine->ScaleShiftA);
-   const GLuint numArgsRGB = combine->_NumArgsRGB;
-   const GLuint numArgsA = combine->_NumArgsA;
-   float4_array ccolor[4], rgba;
-   GLuint i, term;
-
-   /* alloc temp pixel buffers */
-   rgba = (float4_array) malloc(4 * n * sizeof(GLfloat));
-   if (!rgba) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");
-      return;
-   }
-
-   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {
-      ccolor[i] = (float4_array) malloc(4 * n * sizeof(GLfloat));
-      if (!ccolor[i]) {
-         while (i) {
-            free(ccolor[i]);
-            i--;
-         }
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");
-         return;
-      }
-   }
-
-   for (i = 0; i < n; i++) {
-      rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);
-      rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);
-      rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);
-      rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);
-   }
-
-   /*
-   printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",
-          combine->ModeRGB,
-          combine->ModeA,
-          combine->SourceRGB[0],
-          combine->SourceA[0],
-          combine->SourceRGB[1],
-          combine->SourceA[1]);
-   */
-
-   /*
-    * Do operand setup for up to 4 operands.  Loop over the terms.
-    */
-   for (term = 0; term < numArgsRGB; term++) {
-      const GLenum srcRGB = combine->SourceRGB[term];
-      const GLenum operandRGB = combine->OperandRGB[term];
-
-      switch (srcRGB) {
-         case GL_TEXTURE:
-            argRGB[term] = get_texel_array(swrast, unit);
-            break;
-         case GL_PRIMARY_COLOR:
-            argRGB[term] = primary_rgba;
-            break;
-         case GL_PREVIOUS:
-            argRGB[term] = rgba;
-            break;
-         case GL_CONSTANT:
-            {
-               float4_array c = ccolor[term];
-               GLfloat red   = textureUnit->EnvColor[0];
-               GLfloat green = textureUnit->EnvColor[1];
-               GLfloat blue  = textureUnit->EnvColor[2];
-               GLfloat alpha = textureUnit->EnvColor[3];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], red, green, blue, alpha);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
-	  */
-	 case GL_ZERO:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], 0.0F, 0.0F, 0.0F, 0.0F);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-	 case GL_ONE:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++) {
-                  ASSIGN_4V(c[i], 1.0F, 1.0F, 1.0F, 1.0F);
-               }
-               argRGB[term] = ccolor[term];
-            }
-            break;
-         default:
-            /* ARB_texture_env_crossbar source */
-            {
-               const GLuint srcUnit = srcRGB - GL_TEXTURE0;
-               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
-               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
-                  goto end;
-               argRGB[term] = get_texel_array(swrast, srcUnit);
-            }
-      }
-
-      if (operandRGB != GL_SRC_COLOR) {
-         float4_array src = argRGB[term];
-         float4_array dst = ccolor[term];
-
-         /* point to new arg[term] storage */
-         argRGB[term] = ccolor[term];
-
-         switch (operandRGB) {
-         case GL_ONE_MINUS_SRC_COLOR:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = 1.0F - src[i][RCOMP];
-               dst[i][GCOMP] = 1.0F - src[i][GCOMP];
-               dst[i][BCOMP] = 1.0F - src[i][BCOMP];
-            }
-            break;
-         case GL_SRC_ALPHA:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] =
-               dst[i][GCOMP] =
-               dst[i][BCOMP] = src[i][ACOMP];
-            }
-            break;
-         case GL_ONE_MINUS_SRC_ALPHA:
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] =
-               dst[i][GCOMP] =
-               dst[i][BCOMP] = 1.0F - src[i][ACOMP];
-            }
-            break;
-         default:
-            _mesa_problem(ctx, "Bad operandRGB");
-         }
-      }
-   }
-
-   /*
-    * Set up the argA[term] pointers
-    */
-   for (term = 0; term < numArgsA; term++) {
-      const GLenum srcA = combine->SourceA[term];
-      const GLenum operandA = combine->OperandA[term];
-
-      switch (srcA) {
-         case GL_TEXTURE:
-            argA[term] = get_texel_array(swrast, unit);
-            break;
-         case GL_PRIMARY_COLOR:
-            argA[term] = primary_rgba;
-            break;
-         case GL_PREVIOUS:
-            argA[term] = rgba;
-            break;
-         case GL_CONSTANT:
-            {
-               float4_array c = ccolor[term];
-               GLfloat alpha = textureUnit->EnvColor[3];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = alpha;
-               argA[term] = ccolor[term];
-            }
-            break;
-	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
-	  */
-	 case GL_ZERO:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = 0.0F;
-               argA[term] = ccolor[term];
-            }
-            break;
-	 case GL_ONE:
-            {
-               float4_array c = ccolor[term];
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = 1.0F;
-               argA[term] = ccolor[term];
-            }
-            break;
-         default:
-            /* ARB_texture_env_crossbar source */
-            {
-               const GLuint srcUnit = srcA - GL_TEXTURE0;
-               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
-               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
-                  goto end;
-               argA[term] = get_texel_array(swrast, srcUnit);
-            }
-      }
-
-      if (operandA == GL_ONE_MINUS_SRC_ALPHA) {
-         float4_array src = argA[term];
-         float4_array dst = ccolor[term];
-         argA[term] = ccolor[term];
-         for (i = 0; i < n; i++) {
-            dst[i][ACOMP] = 1.0F - src[i][ACOMP];
-         }
-      }
-   }
-
-   /* RGB channel combine */
-   {
-      float4_array arg0 = argRGB[0];
-      float4_array arg1 = argRGB[1];
-      float4_array arg2 = argRGB[2];
-      float4_array arg3 = argRGB[3];
-
-      switch (combine->ModeRGB) {
-      case GL_REPLACE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = arg0[i][RCOMP] * scaleRGB;
-            rgba[i][GCOMP] = arg0[i][GCOMP] * scaleRGB;
-            rgba[i][BCOMP] = arg0[i][BCOMP] * scaleRGB;
-         }
-         break;
-      case GL_MODULATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * scaleRGB;
-            rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * scaleRGB;
-            rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * scaleRGB;
-         }
-         break;
-      case GL_ADD:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
-                                 arg2[i][RCOMP] * arg3[i][RCOMP]) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
-                                 arg2[i][GCOMP] * arg3[i][GCOMP]) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
-                                 arg2[i][BCOMP] * arg3[i][BCOMP]) * scaleRGB;
-            }
-         }
-         else {
-            /* 2-term addition */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * scaleRGB;
-            }
-         }
-         break;
-      case GL_ADD_SIGNED:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
-                                 arg2[i][RCOMP] * arg3[i][RCOMP] - 0.5F) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
-                                 arg2[i][GCOMP] * arg3[i][GCOMP] - 0.5F) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
-                                 arg2[i][BCOMP] * arg3[i][BCOMP] - 0.5F) * scaleRGB;
-            }
-         }
-         else {
-            for (i = 0; i < n; i++) {
-               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5F) * scaleRGB;
-               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5F) * scaleRGB;
-               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5F) * scaleRGB;
-            }
-         }
-         break;
-      case GL_INTERPOLATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
-                          arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * scaleRGB;
-            rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
-                          arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * scaleRGB;
-            rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
-                          arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * scaleRGB;
-         }
-         break;
-      case GL_SUBTRACT:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * scaleRGB;
-         }
-         break;
-      case GL_DOT3_RGB_EXT:
-      case GL_DOT3_RGBA_EXT:
-         /* Do not scale the result by 1 2 or 4 */
-         for (i = 0; i < n; i++) {
-            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +
-                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +
-                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))
-               * 4.0F;
-            dot = CLAMP(dot, 0.0F, 1.0F);
-            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;
-         }
-         break;
-      case GL_DOT3_RGB:
-      case GL_DOT3_RGBA:
-         /* DO scale the result by 1 2 or 4 */
-         for (i = 0; i < n; i++) {
-            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +
-                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +
-                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))
-               * 4.0F * scaleRGB;
-            dot = CLAMP(dot, 0.0F, 1.0F);
-            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;
-         }
-         break;
-      case GL_MODULATE_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
-                              arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
-                              arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
-                              arg1[i][BCOMP]) * scaleRGB;
-	 }
-         break;
-      case GL_MODULATE_SIGNED_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +
-                              arg1[i][RCOMP] - 0.5F) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +
-                              arg1[i][GCOMP] - 0.5F) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +
-                              arg1[i][BCOMP] - 0.5F) * scaleRGB;
-	 }
-         break;
-      case GL_MODULATE_SUBTRACT_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) -
-                              arg1[i][RCOMP]) * scaleRGB;
-            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) -
-                              arg1[i][GCOMP]) * scaleRGB;
-            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) -
-                              arg1[i][BCOMP]) * scaleRGB;
-	 }
-         break;
-      case GL_BUMP_ENVMAP_ATI:
-         /* this produces a fixed rgba color, and the coord calc is done elsewhere */
-         for (i = 0; i < n; i++) {
-            /* rgba result is 0,0,0,1 */
-            rgba[i][RCOMP] = 0.0;
-            rgba[i][GCOMP] = 0.0;
-            rgba[i][BCOMP] = 0.0;
-            rgba[i][ACOMP] = 1.0;
-	 }
-         goto end; /* no alpha processing */
-      default:
-         _mesa_problem(ctx, "invalid combine mode");
-      }
-   }
-
-   /* Alpha channel combine */
-   {
-      float4_array arg0 = argA[0];
-      float4_array arg1 = argA[1];
-      float4_array arg2 = argA[2];
-      float4_array arg3 = argA[3];
-
-      switch (combine->ModeA) {
-      case GL_REPLACE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = arg0[i][ACOMP] * scaleA;
-         }
-         break;
-      case GL_MODULATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * scaleA;
-         }
-         break;
-      case GL_ADD:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
-                                 arg2[i][ACOMP] * arg3[i][ACOMP]) * scaleA;
-            }
-         }
-         else {
-            /* two-term add */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * scaleA;
-            }
-         }
-         break;
-      case GL_ADD_SIGNED:
-         if (textureUnit->EnvMode == GL_COMBINE4_NV) {
-            /* (a * b) + (c * d) - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
-                                 arg2[i][ACOMP] * arg3[i][ACOMP] -
-                                 0.5F) * scaleA;
-            }
-         }
-         else {
-            /* a + b - 0.5 */
-            for (i = 0; i < n; i++) {
-               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * scaleA;
-            }
-         }
-         break;
-      case GL_INTERPOLATE:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
-                              arg1[i][ACOMP] * (1.0F - arg2[i][ACOMP]))
-               * scaleA;
-         }
-         break;
-      case GL_SUBTRACT:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      case GL_MODULATE_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
-                              + arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      case GL_MODULATE_SIGNED_ADD_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) +
-                              arg1[i][ACOMP] - 0.5F) * scaleA;
-         }
-         break;
-      case GL_MODULATE_SUBTRACT_ATI:
-         for (i = 0; i < n; i++) {
-            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])
-                              - arg1[i][ACOMP]) * scaleA;
-         }
-         break;
-      default:
-         _mesa_problem(ctx, "invalid combine mode");
-      }
-   }
-
-   /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.
-    * This is kind of a kludge.  It would have been better if the spec
-    * were written such that the GL_COMBINE_ALPHA value could be set to
-    * GL_DOT3.
-    */
-   if (combine->ModeRGB == GL_DOT3_RGBA_EXT ||
-       combine->ModeRGB == GL_DOT3_RGBA) {
-      for (i = 0; i < n; i++) {
-	 rgba[i][ACOMP] = rgba[i][RCOMP];
-      }
-   }
-
-   for (i = 0; i < n; i++) {
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);
-      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);
-   }
-
-end:
-   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {
-      free(ccolor[i]);
-   }
-   free(rgba);
-}
-
-
-/**
- * Apply X/Y/Z/W/0/1 swizzle to an array of colors/texels.
- * See GL_EXT_texture_swizzle.
- */
-static void
-swizzle_texels(GLuint swizzle, GLuint count, float4_array texels)
-{
-   const GLuint swzR = GET_SWZ(swizzle, 0);
-   const GLuint swzG = GET_SWZ(swizzle, 1);
-   const GLuint swzB = GET_SWZ(swizzle, 2);
-   const GLuint swzA = GET_SWZ(swizzle, 3);
-   GLfloat vector[6];
-   GLuint i;
-
-   vector[SWIZZLE_ZERO] = 0;
-   vector[SWIZZLE_ONE] = 1.0F;
-
-   for (i = 0; i < count; i++) {
-      vector[SWIZZLE_X] = texels[i][0];
-      vector[SWIZZLE_Y] = texels[i][1];
-      vector[SWIZZLE_Z] = texels[i][2];
-      vector[SWIZZLE_W] = texels[i][3];
-      texels[i][RCOMP] = vector[swzR];
-      texels[i][GCOMP] = vector[swzG];
-      texels[i][BCOMP] = vector[swzB];
-      texels[i][ACOMP] = vector[swzA];
-   }
-}
-
-
-/**
- * Apply texture mapping to a span of fragments.
- */
-void
-_swrast_texture_span( struct gl_context *ctx, SWspan *span )
-{
-   SWcontext *swrast = SWRAST_CONTEXT(ctx);
-   float4_array primary_rgba;
-   GLuint unit;
-
-   primary_rgba = (float4_array) malloc(span->end * 4 * sizeof(GLfloat));
-
-   if (!primary_rgba) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_span");
-      return;
-   }
-
-   ASSERT(span->end <= MAX_WIDTH);
-
-   /*
-    * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)
-    */
-   if (swrast->_TextureCombinePrimary) {
-      GLuint i;
-      for (i = 0; i < span->end; i++) {
-         primary_rgba[i][RCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);
-         primary_rgba[i][GCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);
-         primary_rgba[i][BCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);
-         primary_rgba[i][ACOMP] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);
-      }
-   }
-
-   /* First must sample all bump maps */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-
-      if (texUnit->_ReallyEnabled &&
-         texUnit->_CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) {
-         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])
-            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
-         float4_array targetcoords =
-            span->array->attribs[FRAG_ATTRIB_TEX0 +
-               ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0];
-
-         const struct gl_texture_object *curObj = texUnit->_Current;
-         GLfloat *lambda = span->array->lambda[unit];
-         float4_array texels = get_texel_array(swrast, unit);
-         GLuint i;
-         GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0];
-         GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1];
-         GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2];
-         GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3];
-
-         /* adjust texture lod (lambda) */
-         if (span->arrayMask & SPAN_LAMBDA) {
-            if (texUnit->LodBias + curObj->LodBias != 0.0F) {
-               /* apply LOD bias, but don't clamp yet */
-               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
-                                          -ctx->Const.MaxTextureLodBias,
-                                          ctx->Const.MaxTextureLodBias);
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  lambda[i] += bias;
-               }
-            }
-
-            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
-               /* apply LOD clamping to lambda */
-               const GLfloat min = curObj->MinLod;
-               const GLfloat max = curObj->MaxLod;
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  GLfloat l = lambda[i];
-                  lambda[i] = CLAMP(l, min, max);
-               }
-            }
-         }
-
-         /* Sample the texture (span->end = number of fragments) */
-         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
-                                      texcoords, lambda, texels );
-
-         /* manipulate the span values of the bump target
-            not sure this can work correctly even ignoring
-            the problem that channel is unsigned */
-         for (i = 0; i < span->end; i++) {
-            targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] *
-                                  rotMatrix01) / targetcoords[i][3];
-            targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] *
-                                  rotMatrix11) / targetcoords[i][3];
-         }
-      }
-   }
-
-   /*
-    * Must do all texture sampling before combining in order to
-    * accomodate GL_ARB_texture_env_crossbar.
-    */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      if (texUnit->_ReallyEnabled &&
-          texUnit->_CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) {
-         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])
-            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
-         const struct gl_texture_object *curObj = texUnit->_Current;
-         GLfloat *lambda = span->array->lambda[unit];
-         float4_array texels = get_texel_array(swrast, unit);
-
-         /* adjust texture lod (lambda) */
-         if (span->arrayMask & SPAN_LAMBDA) {
-            if (texUnit->LodBias + curObj->LodBias != 0.0F) {
-               /* apply LOD bias, but don't clamp yet */
-               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
-                                          -ctx->Const.MaxTextureLodBias,
-                                          ctx->Const.MaxTextureLodBias);
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  lambda[i] += bias;
-               }
-            }
-
-            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
-               /* apply LOD clamping to lambda */
-               const GLfloat min = curObj->MinLod;
-               const GLfloat max = curObj->MaxLod;
-               GLuint i;
-               for (i = 0; i < span->end; i++) {
-                  GLfloat l = lambda[i];
-                  lambda[i] = CLAMP(l, min, max);
-               }
-            }
-         }
-
-         /* Sample the texture (span->end = number of fragments) */
-         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
-                                      texcoords, lambda, texels );
-
-         /* GL_EXT_texture_swizzle */
-         if (curObj->_Swizzle != SWIZZLE_NOOP) {
-            swizzle_texels(curObj->_Swizzle, span->end, texels);
-         }
-      }
-   }
-
-   /*
-    * OK, now apply the texture (aka texture combine/blend).
-    * We modify the span->color.rgba values.
-    */
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
-      if (ctx->Texture.Unit[unit]._ReallyEnabled) {
-         texture_combine( ctx, unit, span->end,
-                          primary_rgba,
-                          swrast->TexelBuffer,
-                          span->array->rgba );
-      }
-   }
-
-   free(primary_rgba);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.5

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/imports.h"

+#include "main/pixeltransfer.h"

+#include "program/prog_instruction.h"

+

+#include "s_context.h"

+#include "s_texcombine.h"

+

+

+/**

+ * Pointer to array of float[4]

+ * This type makes the code below more concise and avoids a lot of casting.

+ */

+typedef float (*float4_array)[4];

+

+

+/**

+ * Return array of texels for given unit.

+ */

+static INLINE float4_array

+get_texel_array(SWcontext *swrast, GLuint unit)

+{

+   return (float4_array) (swrast->TexelBuffer + unit * MAX_WIDTH * 4);

+}

+

+

+

+/**

+ * Do texture application for:

+ *  GL_EXT_texture_env_combine

+ *  GL_ARB_texture_env_combine

+ *  GL_EXT_texture_env_dot3

+ *  GL_ARB_texture_env_dot3

+ *  GL_ATI_texture_env_combine3

+ *  GL_NV_texture_env_combine4

+ *  conventional GL texture env modes

+ *

+ * \param ctx          rendering context

+ * \param unit         the texture combiner unit

+ * \param n            number of fragments to process (span width)

+ * \param primary_rgba incoming fragment color array

+ * \param texelBuffer  pointer to texel colors for all texture units

+ * 

+ * \param rgba         incoming/result fragment colors

+ */

+static void

+texture_combine( struct gl_context *ctx, GLuint unit, GLuint n,

+                 const float4_array primary_rgba,

+                 const GLfloat *texelBuffer,

+                 GLchan (*rgbaChan)[4] )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);

+   const struct gl_tex_env_combine_state *combine = textureUnit->_CurrentCombine;

+   float4_array argRGB[MAX_COMBINER_TERMS];

+   float4_array argA[MAX_COMBINER_TERMS];

+   const GLfloat scaleRGB = (GLfloat) (1 << combine->ScaleShiftRGB);

+   const GLfloat scaleA = (GLfloat) (1 << combine->ScaleShiftA);

+   const GLuint numArgsRGB = combine->_NumArgsRGB;

+   const GLuint numArgsA = combine->_NumArgsA;

+   float4_array ccolor[4], rgba;

+   GLuint i, term;

+

+   /* alloc temp pixel buffers */

+   rgba = (float4_array) malloc(4 * n * sizeof(GLfloat));

+   if (!rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");

+      return;

+   }

+

+   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {

+      ccolor[i] = (float4_array) malloc(4 * n * sizeof(GLfloat));

+      if (!ccolor[i]) {

+         while (i) {

+            free(ccolor[i]);

+            i--;

+         }

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");

+         return;

+      }

+   }

+

+   for (i = 0; i < n; i++) {

+      rgba[i][RCOMP] = CHAN_TO_FLOAT(rgbaChan[i][RCOMP]);

+      rgba[i][GCOMP] = CHAN_TO_FLOAT(rgbaChan[i][GCOMP]);

+      rgba[i][BCOMP] = CHAN_TO_FLOAT(rgbaChan[i][BCOMP]);

+      rgba[i][ACOMP] = CHAN_TO_FLOAT(rgbaChan[i][ACOMP]);

+   }

+

+   /*

+   printf("modeRGB 0x%x  modeA 0x%x  srcRGB1 0x%x  srcA1 0x%x  srcRGB2 0x%x  srcA2 0x%x\n",

+          combine->ModeRGB,

+          combine->ModeA,

+          combine->SourceRGB[0],

+          combine->SourceA[0],

+          combine->SourceRGB[1],

+          combine->SourceA[1]);

+   */

+

+   /*

+    * Do operand setup for up to 4 operands.  Loop over the terms.

+    */

+   for (term = 0; term < numArgsRGB; term++) {

+      const GLenum srcRGB = combine->SourceRGB[term];

+      const GLenum operandRGB = combine->OperandRGB[term];

+

+      switch (srcRGB) {

+         case GL_TEXTURE:

+            argRGB[term] = get_texel_array(swrast, unit);

+            break;

+         case GL_PRIMARY_COLOR:

+            argRGB[term] = primary_rgba;

+            break;

+         case GL_PREVIOUS:

+            argRGB[term] = rgba;

+            break;

+         case GL_CONSTANT:

+            {

+               float4_array c = ccolor[term];

+               GLfloat red   = textureUnit->EnvColor[0];

+               GLfloat green = textureUnit->EnvColor[1];

+               GLfloat blue  = textureUnit->EnvColor[2];

+               GLfloat alpha = textureUnit->EnvColor[3];

+               for (i = 0; i < n; i++) {

+                  ASSIGN_4V(c[i], red, green, blue, alpha);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.

+	  */

+	 case GL_ZERO:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++) {

+                  ASSIGN_4V(c[i], 0.0F, 0.0F, 0.0F, 0.0F);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+	 case GL_ONE:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++) {

+                  ASSIGN_4V(c[i], 1.0F, 1.0F, 1.0F, 1.0F);

+               }

+               argRGB[term] = ccolor[term];

+            }

+            break;

+         default:

+            /* ARB_texture_env_crossbar source */

+            {

+               const GLuint srcUnit = srcRGB - GL_TEXTURE0;

+               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);

+               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)

+                  goto end;

+               argRGB[term] = get_texel_array(swrast, srcUnit);

+            }

+      }

+

+      if (operandRGB != GL_SRC_COLOR) {

+         float4_array src = argRGB[term];

+         float4_array dst = ccolor[term];

+

+         /* point to new arg[term] storage */

+         argRGB[term] = ccolor[term];

+

+         switch (operandRGB) {

+         case GL_ONE_MINUS_SRC_COLOR:

+            for (i = 0; i < n; i++) {

+               dst[i][RCOMP] = 1.0F - src[i][RCOMP];

+               dst[i][GCOMP] = 1.0F - src[i][GCOMP];

+               dst[i][BCOMP] = 1.0F - src[i][BCOMP];

+            }

+            break;

+         case GL_SRC_ALPHA:

+            for (i = 0; i < n; i++) {

+               dst[i][RCOMP] =

+               dst[i][GCOMP] =

+               dst[i][BCOMP] = src[i][ACOMP];

+            }

+            break;

+         case GL_ONE_MINUS_SRC_ALPHA:

+            for (i = 0; i < n; i++) {

+               dst[i][RCOMP] =

+               dst[i][GCOMP] =

+               dst[i][BCOMP] = 1.0F - src[i][ACOMP];

+            }

+            break;

+         default:

+            _mesa_problem(ctx, "Bad operandRGB");

+         }

+      }

+   }

+

+   /*

+    * Set up the argA[term] pointers

+    */

+   for (term = 0; term < numArgsA; term++) {

+      const GLenum srcA = combine->SourceA[term];

+      const GLenum operandA = combine->OperandA[term];

+

+      switch (srcA) {

+         case GL_TEXTURE:

+            argA[term] = get_texel_array(swrast, unit);

+            break;

+         case GL_PRIMARY_COLOR:

+            argA[term] = primary_rgba;

+            break;

+         case GL_PREVIOUS:

+            argA[term] = rgba;

+            break;

+         case GL_CONSTANT:

+            {

+               float4_array c = ccolor[term];

+               GLfloat alpha = textureUnit->EnvColor[3];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = alpha;

+               argA[term] = ccolor[term];

+            }

+            break;

+	 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.

+	  */

+	 case GL_ZERO:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = 0.0F;

+               argA[term] = ccolor[term];

+            }

+            break;

+	 case GL_ONE:

+            {

+               float4_array c = ccolor[term];

+               for (i = 0; i < n; i++)

+                  c[i][ACOMP] = 1.0F;

+               argA[term] = ccolor[term];

+            }

+            break;

+         default:

+            /* ARB_texture_env_crossbar source */

+            {

+               const GLuint srcUnit = srcA - GL_TEXTURE0;

+               ASSERT(srcUnit < ctx->Const.MaxTextureUnits);

+               if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)

+                  goto end;

+               argA[term] = get_texel_array(swrast, srcUnit);

+            }

+      }

+

+      if (operandA == GL_ONE_MINUS_SRC_ALPHA) {

+         float4_array src = argA[term];

+         float4_array dst = ccolor[term];

+         argA[term] = ccolor[term];

+         for (i = 0; i < n; i++) {

+            dst[i][ACOMP] = 1.0F - src[i][ACOMP];

+         }

+      }

+   }

+

+   /* RGB channel combine */

+   {

+      float4_array arg0 = argRGB[0];

+      float4_array arg1 = argRGB[1];

+      float4_array arg2 = argRGB[2];

+      float4_array arg3 = argRGB[3];

+

+      switch (combine->ModeRGB) {

+      case GL_REPLACE:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = arg0[i][RCOMP] * scaleRGB;

+            rgba[i][GCOMP] = arg0[i][GCOMP] * scaleRGB;

+            rgba[i][BCOMP] = arg0[i][BCOMP] * scaleRGB;

+         }

+         break;

+      case GL_MODULATE:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * scaleRGB;

+            rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * scaleRGB;

+            rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * scaleRGB;

+         }

+         break;

+      case GL_ADD:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) */

+            for (i = 0; i < n; i++) {

+               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +

+                                 arg2[i][RCOMP] * arg3[i][RCOMP]) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +

+                                 arg2[i][GCOMP] * arg3[i][GCOMP]) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +

+                                 arg2[i][BCOMP] * arg3[i][BCOMP]) * scaleRGB;

+            }

+         }

+         else {

+            /* 2-term addition */

+            for (i = 0; i < n; i++) {

+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * scaleRGB;

+            }

+         }

+         break;

+      case GL_ADD_SIGNED:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) - 0.5 */

+            for (i = 0; i < n; i++) {

+               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +

+                                 arg2[i][RCOMP] * arg3[i][RCOMP] - 0.5F) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +

+                                 arg2[i][GCOMP] * arg3[i][GCOMP] - 0.5F) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +

+                                 arg2[i][BCOMP] * arg3[i][BCOMP] - 0.5F) * scaleRGB;

+            }

+         }

+         else {

+            for (i = 0; i < n; i++) {

+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5F) * scaleRGB;

+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5F) * scaleRGB;

+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5F) * scaleRGB;

+            }

+         }

+         break;

+      case GL_INTERPOLATE:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +

+                          arg1[i][RCOMP] * (1.0F - arg2[i][RCOMP])) * scaleRGB;

+            rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +

+                          arg1[i][GCOMP] * (1.0F - arg2[i][GCOMP])) * scaleRGB;

+            rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +

+                          arg1[i][BCOMP] * (1.0F - arg2[i][BCOMP])) * scaleRGB;

+         }

+         break;

+      case GL_SUBTRACT:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * scaleRGB;

+         }

+         break;

+      case GL_DOT3_RGB_EXT:

+      case GL_DOT3_RGBA_EXT:

+         /* Do not scale the result by 1 2 or 4 */

+         for (i = 0; i < n; i++) {

+            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +

+                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +

+                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))

+               * 4.0F;

+            dot = CLAMP(dot, 0.0F, 1.0F);

+            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;

+         }

+         break;

+      case GL_DOT3_RGB:

+      case GL_DOT3_RGBA:

+         /* DO scale the result by 1 2 or 4 */

+         for (i = 0; i < n; i++) {

+            GLfloat dot = ((arg0[i][RCOMP] - 0.5F) * (arg1[i][RCOMP] - 0.5F) +

+                           (arg0[i][GCOMP] - 0.5F) * (arg1[i][GCOMP] - 0.5F) +

+                           (arg0[i][BCOMP] - 0.5F) * (arg1[i][BCOMP] - 0.5F))

+               * 4.0F * scaleRGB;

+            dot = CLAMP(dot, 0.0F, 1.0F);

+            rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = dot;

+         }

+         break;

+      case GL_MODULATE_ADD_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +

+                              arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +

+                              arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +

+                              arg1[i][BCOMP]) * scaleRGB;

+	 }

+         break;

+      case GL_MODULATE_SIGNED_ADD_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) +

+                              arg1[i][RCOMP] - 0.5F) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) +

+                              arg1[i][GCOMP] - 0.5F) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) +

+                              arg1[i][BCOMP] - 0.5F) * scaleRGB;

+	 }

+         break;

+      case GL_MODULATE_SUBTRACT_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) -

+                              arg1[i][RCOMP]) * scaleRGB;

+            rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) -

+                              arg1[i][GCOMP]) * scaleRGB;

+            rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) -

+                              arg1[i][BCOMP]) * scaleRGB;

+	 }

+         break;

+      case GL_BUMP_ENVMAP_ATI:

+         /* this produces a fixed rgba color, and the coord calc is done elsewhere */

+         for (i = 0; i < n; i++) {

+            /* rgba result is 0,0,0,1 */

+            rgba[i][RCOMP] = 0.0;

+            rgba[i][GCOMP] = 0.0;

+            rgba[i][BCOMP] = 0.0;

+            rgba[i][ACOMP] = 1.0;

+	 }

+         goto end; /* no alpha processing */

+      default:

+         _mesa_problem(ctx, "invalid combine mode");

+      }

+   }

+

+   /* Alpha channel combine */

+   {

+      float4_array arg0 = argA[0];

+      float4_array arg1 = argA[1];

+      float4_array arg2 = argA[2];

+      float4_array arg3 = argA[3];

+

+      switch (combine->ModeA) {

+      case GL_REPLACE:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = arg0[i][ACOMP] * scaleA;

+         }

+         break;

+      case GL_MODULATE:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * scaleA;

+         }

+         break;

+      case GL_ADD:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) */

+            for (i = 0; i < n; i++) {

+               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +

+                                 arg2[i][ACOMP] * arg3[i][ACOMP]) * scaleA;

+            }

+         }

+         else {

+            /* two-term add */

+            for (i = 0; i < n; i++) {

+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * scaleA;

+            }

+         }

+         break;

+      case GL_ADD_SIGNED:

+         if (textureUnit->EnvMode == GL_COMBINE4_NV) {

+            /* (a * b) + (c * d) - 0.5 */

+            for (i = 0; i < n; i++) {

+               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +

+                                 arg2[i][ACOMP] * arg3[i][ACOMP] -

+                                 0.5F) * scaleA;

+            }

+         }

+         else {

+            /* a + b - 0.5 */

+            for (i = 0; i < n; i++) {

+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * scaleA;

+            }

+         }

+         break;

+      case GL_INTERPOLATE:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +

+                              arg1[i][ACOMP] * (1.0F - arg2[i][ACOMP]))

+               * scaleA;

+         }

+         break;

+      case GL_SUBTRACT:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      case GL_MODULATE_ADD_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])

+                              + arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      case GL_MODULATE_SIGNED_ADD_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) +

+                              arg1[i][ACOMP] - 0.5F) * scaleA;

+         }

+         break;

+      case GL_MODULATE_SUBTRACT_ATI:

+         for (i = 0; i < n; i++) {

+            rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP])

+                              - arg1[i][ACOMP]) * scaleA;

+         }

+         break;

+      default:

+         _mesa_problem(ctx, "invalid combine mode");

+      }

+   }

+

+   /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.

+    * This is kind of a kludge.  It would have been better if the spec

+    * were written such that the GL_COMBINE_ALPHA value could be set to

+    * GL_DOT3.

+    */

+   if (combine->ModeRGB == GL_DOT3_RGBA_EXT ||

+       combine->ModeRGB == GL_DOT3_RGBA) {

+      for (i = 0; i < n; i++) {

+	 rgba[i][ACOMP] = rgba[i][RCOMP];

+      }

+   }

+

+   for (i = 0; i < n; i++) {

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][RCOMP], rgba[i][RCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][GCOMP], rgba[i][GCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][BCOMP], rgba[i][BCOMP]);

+      UNCLAMPED_FLOAT_TO_CHAN(rgbaChan[i][ACOMP], rgba[i][ACOMP]);

+   }

+

+end:

+   for (i = 0; i < numArgsRGB || i < numArgsA; i++) {

+      free(ccolor[i]);

+   }

+   free(rgba);

+}

+

+

+/**

+ * Apply X/Y/Z/W/0/1 swizzle to an array of colors/texels.

+ * See GL_EXT_texture_swizzle.

+ */

+static void

+swizzle_texels(GLuint swizzle, GLuint count, float4_array texels)

+{

+   const GLuint swzR = GET_SWZ(swizzle, 0);

+   const GLuint swzG = GET_SWZ(swizzle, 1);

+   const GLuint swzB = GET_SWZ(swizzle, 2);

+   const GLuint swzA = GET_SWZ(swizzle, 3);

+   GLfloat vector[6];

+   GLuint i;

+

+   vector[SWIZZLE_ZERO] = 0;

+   vector[SWIZZLE_ONE] = 1.0F;

+

+   for (i = 0; i < count; i++) {

+      vector[SWIZZLE_X] = texels[i][0];

+      vector[SWIZZLE_Y] = texels[i][1];

+      vector[SWIZZLE_Z] = texels[i][2];

+      vector[SWIZZLE_W] = texels[i][3];

+      texels[i][RCOMP] = vector[swzR];

+      texels[i][GCOMP] = vector[swzG];

+      texels[i][BCOMP] = vector[swzB];

+      texels[i][ACOMP] = vector[swzA];

+   }

+}

+

+

+/**

+ * Apply texture mapping to a span of fragments.

+ */

+void

+_swrast_texture_span( struct gl_context *ctx, SWspan *span )

+{

+   SWcontext *swrast = SWRAST_CONTEXT(ctx);

+   float4_array primary_rgba;

+   GLuint unit;

+

+   primary_rgba = (float4_array) malloc(span->end * 4 * sizeof(GLfloat));

+

+   if (!primary_rgba) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_span");

+      return;

+   }

+

+   ASSERT(span->end <= MAX_WIDTH);

+

+   /*

+    * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)

+    */

+   if (swrast->_TextureCombinePrimary) {

+      GLuint i;

+      for (i = 0; i < span->end; i++) {

+         primary_rgba[i][RCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);

+         primary_rgba[i][GCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);

+         primary_rgba[i][BCOMP] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);

+         primary_rgba[i][ACOMP] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);

+      }

+   }

+

+   /* First must sample all bump maps */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+

+      if (texUnit->_ReallyEnabled &&

+         texUnit->_CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) {

+         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])

+            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];

+         float4_array targetcoords =

+            span->array->attribs[FRAG_ATTRIB_TEX0 +

+               ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0];

+

+         const struct gl_texture_object *curObj = texUnit->_Current;

+         GLfloat *lambda = span->array->lambda[unit];

+         float4_array texels = get_texel_array(swrast, unit);

+         GLuint i;

+         GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0];

+         GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1];

+         GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2];

+         GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3];

+

+         /* adjust texture lod (lambda) */

+         if (span->arrayMask & SPAN_LAMBDA) {

+            if (texUnit->LodBias + curObj->LodBias != 0.0F) {

+               /* apply LOD bias, but don't clamp yet */

+               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,

+                                          -ctx->Const.MaxTextureLodBias,

+                                          ctx->Const.MaxTextureLodBias);

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  lambda[i] += bias;

+               }

+            }

+

+            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {

+               /* apply LOD clamping to lambda */

+               const GLfloat min = curObj->MinLod;

+               const GLfloat max = curObj->MaxLod;

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  GLfloat l = lambda[i];

+                  lambda[i] = CLAMP(l, min, max);

+               }

+            }

+         }

+

+         /* Sample the texture (span->end = number of fragments) */

+         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,

+                                      texcoords, lambda, texels );

+

+         /* manipulate the span values of the bump target

+            not sure this can work correctly even ignoring

+            the problem that channel is unsigned */

+         for (i = 0; i < span->end; i++) {

+            targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] *

+                                  rotMatrix01) / targetcoords[i][3];

+            targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] *

+                                  rotMatrix11) / targetcoords[i][3];

+         }

+      }

+   }

+

+   /*

+    * Must do all texture sampling before combining in order to

+    * accomodate GL_ARB_texture_env_crossbar.

+    */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];

+      if (texUnit->_ReallyEnabled &&

+          texUnit->_CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) {

+         const GLfloat (*texcoords)[4] = (const GLfloat (*)[4])

+            span->array->attribs[FRAG_ATTRIB_TEX0 + unit];

+         const struct gl_texture_object *curObj = texUnit->_Current;

+         GLfloat *lambda = span->array->lambda[unit];

+         float4_array texels = get_texel_array(swrast, unit);

+

+         /* adjust texture lod (lambda) */

+         if (span->arrayMask & SPAN_LAMBDA) {

+            if (texUnit->LodBias + curObj->LodBias != 0.0F) {

+               /* apply LOD bias, but don't clamp yet */

+               const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,

+                                          -ctx->Const.MaxTextureLodBias,

+                                          ctx->Const.MaxTextureLodBias);

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  lambda[i] += bias;

+               }

+            }

+

+            if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {

+               /* apply LOD clamping to lambda */

+               const GLfloat min = curObj->MinLod;

+               const GLfloat max = curObj->MaxLod;

+               GLuint i;

+               for (i = 0; i < span->end; i++) {

+                  GLfloat l = lambda[i];

+                  lambda[i] = CLAMP(l, min, max);

+               }

+            }

+         }

+

+         /* Sample the texture (span->end = number of fragments) */

+         swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,

+                                      texcoords, lambda, texels );

+

+         /* GL_EXT_texture_swizzle */

+         if (curObj->_Swizzle != SWIZZLE_NOOP) {

+            swizzle_texels(curObj->_Swizzle, span->end, texels);

+         }

+      }

+   }

+

+   /*

+    * OK, now apply the texture (aka texture combine/blend).

+    * We modify the span->color.rgba values.

+    */

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      if (ctx->Texture.Unit[unit]._ReallyEnabled) {

+         texture_combine( ctx, unit, span->end,

+                          primary_rgba,

+                          swrast->TexelBuffer,

+                          span->array->rgba );

+      }

+   }

+

+   free(primary_rgba);

+}

diff --git a/mesalib/src/mesa/swrast/s_texfilter.c b/mesalib/src/mesa/swrast/s_texfilter.c
index 42785400c..1d2b635e7 100644
--- a/mesalib/src/mesa/swrast/s_texfilter.c
+++ b/mesalib/src/mesa/swrast/s_texfilter.c
@@ -1,3314 +1,3314 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/colormac.h"
-#include "main/imports.h"
-
-#include "s_context.h"
-#include "s_texfilter.h"
-
-
-/*
- * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes
- * see 1-pixel bands of improperly weighted linear-filtered textures.
- * The tests/texwrap.c demo is a good test.
- * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
- * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
- */
-#define FRAC(f)  ((f) - IFLOOR(f))
-
-
-
-/**
- * Linear interpolation macro
- */
-#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )
-
-
-/**
- * Do 2D/biliner interpolation of float values.
- * v00, v10, v01 and v11 are typically four texture samples in a square/box.
- * a and b are the horizontal and vertical interpolants.
- * It's important that this function is inlined when compiled with
- * optimization!  If we find that's not true on some systems, convert
- * to a macro.
- */
-static INLINE GLfloat
-lerp_2d(GLfloat a, GLfloat b,
-        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)
-{
-   const GLfloat temp0 = LERP(a, v00, v10);
-   const GLfloat temp1 = LERP(a, v01, v11);
-   return LERP(b, temp0, temp1);
-}
-
-
-/**
- * Do 3D/trilinear interpolation of float values.
- * \sa lerp_2d
- */
-static INLINE GLfloat
-lerp_3d(GLfloat a, GLfloat b, GLfloat c,
-        GLfloat v000, GLfloat v100, GLfloat v010, GLfloat v110,
-        GLfloat v001, GLfloat v101, GLfloat v011, GLfloat v111)
-{
-   const GLfloat temp00 = LERP(a, v000, v100);
-   const GLfloat temp10 = LERP(a, v010, v110);
-   const GLfloat temp01 = LERP(a, v001, v101);
-   const GLfloat temp11 = LERP(a, v011, v111);
-   const GLfloat temp0 = LERP(b, temp00, temp10);
-   const GLfloat temp1 = LERP(b, temp01, temp11);
-   return LERP(c, temp0, temp1);
-}
-
-
-/**
- * Do linear interpolation of colors.
- */
-static INLINE void
-lerp_rgba(GLfloat result[4], GLfloat t, const GLfloat a[4], const GLfloat b[4])
-{
-   result[0] = LERP(t, a[0], b[0]);
-   result[1] = LERP(t, a[1], b[1]);
-   result[2] = LERP(t, a[2], b[2]);
-   result[3] = LERP(t, a[3], b[3]);
-}
-
-
-/**
- * Do bilinear interpolation of colors.
- */
-static INLINE void
-lerp_rgba_2d(GLfloat result[4], GLfloat a, GLfloat b,
-             const GLfloat t00[4], const GLfloat t10[4],
-             const GLfloat t01[4], const GLfloat t11[4])
-{
-   result[0] = lerp_2d(a, b, t00[0], t10[0], t01[0], t11[0]);
-   result[1] = lerp_2d(a, b, t00[1], t10[1], t01[1], t11[1]);
-   result[2] = lerp_2d(a, b, t00[2], t10[2], t01[2], t11[2]);
-   result[3] = lerp_2d(a, b, t00[3], t10[3], t01[3], t11[3]);
-}
-
-
-/**
- * Do trilinear interpolation of colors.
- */
-static INLINE void
-lerp_rgba_3d(GLfloat result[4], GLfloat a, GLfloat b, GLfloat c,
-             const GLfloat t000[4], const GLfloat t100[4],
-             const GLfloat t010[4], const GLfloat t110[4],
-             const GLfloat t001[4], const GLfloat t101[4],
-             const GLfloat t011[4], const GLfloat t111[4])
-{
-   GLuint k;
-   /* compiler should unroll these short loops */
-   for (k = 0; k < 4; k++) {
-      result[k] = lerp_3d(a, b, c, t000[k], t100[k], t010[k], t110[k],
-                                   t001[k], t101[k], t011[k], t111[k]);
-   }
-}
-
-
-/**
- * Used for GL_REPEAT wrap mode.  Using A % B doesn't produce the
- * right results for A<0.  Casting to A to be unsigned only works if B
- * is a power of two.  Adding a bias to A (which is a multiple of B)
- * avoids the problems with A < 0 (for reasonable A) without using a
- * conditional.
- */
-#define REMAINDER(A, B) (((A) + (B) * 1024) % (B))
-
-
-/**
- * Used to compute texel locations for linear sampling.
- * Input:
- *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER
- *    s = texcoord in [0,1]
- *    size = width (or height or depth) of texture
- * Output:
- *    i0, i1 = returns two nearest texel indexes
- *    weight = returns blend factor between texels
- */
-static INLINE void
-linear_texel_locations(GLenum wrapMode,
-                       const struct gl_texture_image *img,
-                       GLint size, GLfloat s,
-                       GLint *i0, GLint *i1, GLfloat *weight)
-{
-   GLfloat u;
-   switch (wrapMode) {
-   case GL_REPEAT:
-      u = s * size - 0.5F;
-      if (img->_IsPowerOfTwo) {
-         *i0 = IFLOOR(u) & (size - 1);
-         *i1 = (*i0 + 1) & (size - 1);
-      }
-      else {
-         *i0 = REMAINDER(IFLOOR(u), size);
-         *i1 = REMAINDER(*i0 + 1, size);
-      }
-      break;
-   case GL_CLAMP_TO_EDGE:
-      if (s <= 0.0F)
-         u = 0.0F;
-      else if (s >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u = s * size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      if (*i0 < 0)
-         *i0 = 0;
-      if (*i1 >= (GLint) size)
-         *i1 = size - 1;
-      break;
-   case GL_CLAMP_TO_BORDER:
-      {
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s <= min)
-            u = min * size;
-         else if (s >= max)
-            u = max * size;
-         else
-            u = s * size;
-         u -= 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-      }
-      break;
-   case GL_MIRRORED_REPEAT:
-      {
-         const GLint flr = IFLOOR(s);
-         if (flr & 1)
-            u = 1.0F - (s - (GLfloat) flr);
-         else
-            u = s - (GLfloat) flr;
-         u = (u * size) - 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-         if (*i0 < 0)
-            *i0 = 0;
-         if (*i1 >= (GLint) size)
-            *i1 = size - 1;
-      }
-      break;
-   case GL_MIRROR_CLAMP_EXT:
-      u = FABSF(s);
-      if (u >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u *= size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      break;
-   case GL_MIRROR_CLAMP_TO_EDGE_EXT:
-      u = FABSF(s);
-      if (u >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u *= size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      if (*i0 < 0)
-         *i0 = 0;
-      if (*i1 >= (GLint) size)
-         *i1 = size - 1;
-      break;
-   case GL_MIRROR_CLAMP_TO_BORDER_EXT:
-      {
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         u = FABSF(s);
-         if (u <= min)
-            u = min * size;
-         else if (u >= max)
-            u = max * size;
-         else
-            u *= size;
-         u -= 0.5F;
-         *i0 = IFLOOR(u);
-         *i1 = *i0 + 1;
-      }
-      break;
-   case GL_CLAMP:
-      if (s <= 0.0F)
-         u = 0.0F;
-      else if (s >= 1.0F)
-         u = (GLfloat) size;
-      else
-         u = s * size;
-      u -= 0.5F;
-      *i0 = IFLOOR(u);
-      *i1 = *i0 + 1;
-      break;
-   default:
-      _mesa_problem(NULL, "Bad wrap mode");
-      u = 0.0F;
-   }
-   *weight = FRAC(u);
-}
-
-
-/**
- * Used to compute texel location for nearest sampling.
- */
-static INLINE GLint
-nearest_texel_location(GLenum wrapMode,
-                       const struct gl_texture_image *img,
-                       GLint size, GLfloat s)
-{
-   GLint i;
-
-   switch (wrapMode) {
-   case GL_REPEAT:
-      /* s limited to [0,1) */
-      /* i limited to [0,size-1] */
-      i = IFLOOR(s * size);
-      if (img->_IsPowerOfTwo)
-         i &= (size - 1);
-      else
-         i = REMAINDER(i, size);
-      return i;
-   case GL_CLAMP_TO_EDGE:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s < min)
-            i = 0;
-         else if (s > max)
-            i = size - 1;
-         else
-            i = IFLOOR(s * size);
-      }
-      return i;
-   case GL_CLAMP_TO_BORDER:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [-1, size] */
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         if (s <= min)
-            i = -1;
-         else if (s >= max)
-            i = size;
-         else
-            i = IFLOOR(s * size);
-      }
-      return i;
-   case GL_MIRRORED_REPEAT:
-      {
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLint flr = IFLOOR(s);
-         GLfloat u;
-         if (flr & 1)
-            u = 1.0F - (s - (GLfloat) flr);
-         else
-            u = s - (GLfloat) flr;
-         if (u < min)
-            i = 0;
-         else if (u > max)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_EXT:
-      {
-         /* s limited to [0,1] */
-         /* i limited to [0,size-1] */
-         const GLfloat u = FABSF(s);
-         if (u <= 0.0F)
-            i = 0;
-         else if (u >= 1.0F)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_TO_EDGE_EXT:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = 1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLfloat u = FABSF(s);
-         if (u < min)
-            i = 0;
-         else if (u > max)
-            i = size - 1;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_MIRROR_CLAMP_TO_BORDER_EXT:
-      {
-         /* s limited to [min,max] */
-         /* i limited to [0, size-1] */
-         const GLfloat min = -1.0F / (2.0F * size);
-         const GLfloat max = 1.0F - min;
-         const GLfloat u = FABSF(s);
-         if (u < min)
-            i = -1;
-         else if (u > max)
-            i = size;
-         else
-            i = IFLOOR(u * size);
-      }
-      return i;
-   case GL_CLAMP:
-      /* s limited to [0,1] */
-      /* i limited to [0,size-1] */
-      if (s <= 0.0F)
-         i = 0;
-      else if (s >= 1.0F)
-         i = size - 1;
-      else
-         i = IFLOOR(s * size);
-      return i;
-   default:
-      _mesa_problem(NULL, "Bad wrap mode");
-      return 0;
-   }
-}
-
-
-/* Power of two image sizes only */
-static INLINE void
-linear_repeat_texel_location(GLuint size, GLfloat s,
-                             GLint *i0, GLint *i1, GLfloat *weight)
-{
-   GLfloat u = s * size - 0.5F;
-   *i0 = IFLOOR(u) & (size - 1);
-   *i1 = (*i0 + 1) & (size - 1);
-   *weight = FRAC(u);
-}
-
-
-/**
- * Do clamp/wrap for a texture rectangle coord, GL_NEAREST filter mode.
- */
-static INLINE GLint
-clamp_rect_coord_nearest(GLenum wrapMode, GLfloat coord, GLint max)
-{
-   switch (wrapMode) {
-   case GL_CLAMP:
-      return IFLOOR( CLAMP(coord, 0.0F, max - 1) );
-   case GL_CLAMP_TO_EDGE:
-      return IFLOOR( CLAMP(coord, 0.5F, max - 0.5F) );
-   case GL_CLAMP_TO_BORDER:
-      return IFLOOR( CLAMP(coord, -0.5F, max + 0.5F) );
-   default:
-      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_nearest");
-      return 0;
-   }
-}
-
-
-/**
- * As above, but GL_LINEAR filtering.
- */
-static INLINE void
-clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max,
-                        GLint *i0out, GLint *i1out, GLfloat *weight)
-{
-   GLfloat fcol;
-   GLint i0, i1;
-   switch (wrapMode) {
-   case GL_CLAMP:
-      /* Not exactly what the spec says, but it matches NVIDIA output */
-      fcol = CLAMP(coord - 0.5F, 0.0F, max - 1);
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      break;
-   case GL_CLAMP_TO_EDGE:
-      fcol = CLAMP(coord, 0.5F, max - 0.5F);
-      fcol -= 0.5F;
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      if (i1 > max - 1)
-         i1 = max - 1;
-      break;
-   case GL_CLAMP_TO_BORDER:
-      fcol = CLAMP(coord, -0.5F, max + 0.5F);
-      fcol -= 0.5F;
-      i0 = IFLOOR(fcol);
-      i1 = i0 + 1;
-      break;
-   default:
-      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_linear");
-      i0 = i1 = 0;
-      fcol = 0.0F;
-   }
-   *i0out = i0;
-   *i1out = i1;
-   *weight = FRAC(fcol);
-}
-
-
-/**
- * Compute slice/image to use for 1D or 2D array texture.
- */
-static INLINE GLint
-tex_array_slice(GLfloat coord, GLsizei size)
-{
-   GLint slice = IFLOOR(coord + 0.5f);
-   slice = CLAMP(slice, 0, size - 1);
-   return slice;
-}
-
-
-/**
- * Compute nearest integer texcoords for given texobj and coordinate.
- * NOTE: only used for depth texture sampling.
- */
-static INLINE void
-nearest_texcoord(const struct gl_texture_object *texObj,
-                 GLuint level,
-                 const GLfloat texcoord[4],
-                 GLint *i, GLint *j, GLint *k)
-{
-   const struct gl_texture_image *img = texObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-
-   switch (texObj->Target) {
-   case GL_TEXTURE_RECTANGLE_ARB:
-      *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width);
-      *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height);
-      *k = 0;
-      break;
-   case GL_TEXTURE_1D:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = 0;
-      *k = 0;
-      break;
-   case GL_TEXTURE_2D:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
-      *k = 0;
-      break;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = tex_array_slice(texcoord[1], height);
-      *k = 0;
-      break;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
-      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
-      *k = tex_array_slice(texcoord[2], depth);
-      break;
-   default:
-      *i = *j = *k = 0;
-   }
-}
-
-
-/**
- * Compute linear integer texcoords for given texobj and coordinate.
- * NOTE: only used for depth texture sampling.
- */
-static INLINE void
-linear_texcoord(const struct gl_texture_object *texObj,
-                GLuint level,
-                const GLfloat texcoord[4],
-                GLint *i0, GLint *i1, GLint *j0, GLint *j1, GLint *slice,
-                GLfloat *wi, GLfloat *wj)
-{
-   const struct gl_texture_image *img = texObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-
-   switch (texObj->Target) {
-   case GL_TEXTURE_RECTANGLE_ARB:
-      clamp_rect_coord_linear(texObj->WrapS, texcoord[0],
-                              width, i0, i1, wi);
-      clamp_rect_coord_linear(texObj->WrapT, texcoord[1],
-                              height, j0, j1, wj);
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      linear_texel_locations(texObj->WrapT, img, height,
-                             texcoord[1], j0, j1, wj);
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      *j0 = tex_array_slice(texcoord[1], height);
-      *j1 = *j0;
-      *slice = 0;
-      break;
-
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      linear_texel_locations(texObj->WrapS, img, width,
-                             texcoord[0], i0, i1, wi);
-      linear_texel_locations(texObj->WrapT, img, height,
-                             texcoord[1], j0, j1, wj);
-      *slice = tex_array_slice(texcoord[2], depth);
-      break;
-
-   default:
-      *slice = 0;
-   }
-}
-
-
-
-/**
- * For linear interpolation between mipmap levels N and N+1, this function
- * computes N.
- */
-static INLINE GLint
-linear_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   if (lambda < 0.0F)
-      return tObj->BaseLevel;
-   else if (lambda > tObj->_MaxLambda)
-      return (GLint) (tObj->BaseLevel + tObj->_MaxLambda);
-   else
-      return (GLint) (tObj->BaseLevel + lambda);
-}
-
-
-/**
- * Compute the nearest mipmap level to take texels from.
- */
-static INLINE GLint
-nearest_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   GLfloat l;
-   GLint level;
-   if (lambda <= 0.5F)
-      l = 0.0F;
-   else if (lambda > tObj->_MaxLambda + 0.4999F)
-      l = tObj->_MaxLambda + 0.4999F;
-   else
-      l = lambda;
-   level = (GLint) (tObj->BaseLevel + l + 0.5F);
-   if (level > tObj->_MaxLevel)
-      level = tObj->_MaxLevel;
-   return level;
-}
-
-
-
-/*
- * Bitflags for texture border color sampling.
- */
-#define I0BIT   1
-#define I1BIT   2
-#define J0BIT   4
-#define J1BIT   8
-#define K0BIT  16
-#define K1BIT  32
-
-
-
-/**
- * The lambda[] array values are always monotonic.  Either the whole span
- * will be minified, magnified, or split between the two.  This function
- * determines the subranges in [0, n-1] that are to be minified or magnified.
- */
-static INLINE void
-compute_min_mag_ranges(const struct gl_texture_object *tObj,
-                       GLuint n, const GLfloat lambda[],
-                       GLuint *minStart, GLuint *minEnd,
-                       GLuint *magStart, GLuint *magEnd)
-{
-   GLfloat minMagThresh;
-
-   /* we shouldn't be here if minfilter == magfilter */
-   ASSERT(tObj->MinFilter != tObj->MagFilter);
-
-   /* This bit comes from the OpenGL spec: */
-   if (tObj->MagFilter == GL_LINEAR
-       && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
-           tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
-      minMagThresh = 0.5F;
-   }
-   else {
-      minMagThresh = 0.0F;
-   }
-
-#if 0
-   /* DEBUG CODE: Verify that lambda[] is monotonic.
-    * We can't really use this because the inaccuracy in the LOG2 function
-    * causes this test to fail, yet the resulting texturing is correct.
-    */
-   if (n > 1) {
-      GLuint i;
-      printf("lambda delta = %g\n", lambda[0] - lambda[n-1]);
-      if (lambda[0] >= lambda[n-1]) { /* decreasing */
-         for (i = 0; i < n - 1; i++) {
-            ASSERT((GLint) (lambda[i] * 10) >= (GLint) (lambda[i+1] * 10));
-         }
-      }
-      else { /* increasing */
-         for (i = 0; i < n - 1; i++) {
-            ASSERT((GLint) (lambda[i] * 10) <= (GLint) (lambda[i+1] * 10));
-         }
-      }
-   }
-#endif /* DEBUG */
-
-   if (lambda[0] <= minMagThresh && (n <= 1 || lambda[n-1] <= minMagThresh)) {
-      /* magnification for whole span */
-      *magStart = 0;
-      *magEnd = n;
-      *minStart = *minEnd = 0;
-   }
-   else if (lambda[0] > minMagThresh && (n <=1 || lambda[n-1] > minMagThresh)) {
-      /* minification for whole span */
-      *minStart = 0;
-      *minEnd = n;
-      *magStart = *magEnd = 0;
-   }
-   else {
-      /* a mix of minification and magnification */
-      GLuint i;
-      if (lambda[0] > minMagThresh) {
-         /* start with minification */
-         for (i = 1; i < n; i++) {
-            if (lambda[i] <= minMagThresh)
-               break;
-         }
-         *minStart = 0;
-         *minEnd = i;
-         *magStart = i;
-         *magEnd = n;
-      }
-      else {
-         /* start with magnification */
-         for (i = 1; i < n; i++) {
-            if (lambda[i] > minMagThresh)
-               break;
-         }
-         *magStart = 0;
-         *magEnd = i;
-         *minStart = i;
-         *minEnd = n;
-      }
-   }
-
-#if 0
-   /* Verify the min/mag Start/End values
-    * We don't use this either (see above)
-    */
-   {
-      GLint i;
-      for (i = 0; i < n; i++) {
-         if (lambda[i] > minMagThresh) {
-            /* minification */
-            ASSERT(i >= *minStart);
-            ASSERT(i < *minEnd);
-         }
-         else {
-            /* magnification */
-            ASSERT(i >= *magStart);
-            ASSERT(i < *magEnd);
-         }
-      }
-   }
-#endif
-}
-
-
-/**
- * When we sample the border color, it must be interpreted according to
- * the base texture format.  Ex: if the texture base format it GL_ALPHA,
- * we return (0,0,0,BorderAlpha).
- */
-static INLINE void
-get_border_color(const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 GLfloat rgba[4])
-{
-   switch (img->_BaseFormat) {
-   case GL_RGB:
-      rgba[0] = tObj->BorderColor.f[0];
-      rgba[1] = tObj->BorderColor.f[1];
-      rgba[2] = tObj->BorderColor.f[2];
-      rgba[3] = 1.0F;
-      break;
-   case GL_ALPHA:
-      rgba[0] = rgba[1] = rgba[2] = 0.0;
-      rgba[3] = tObj->BorderColor.f[3];
-      break;
-   case GL_LUMINANCE:
-      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
-      rgba[3] = 1.0;
-      break;
-   case GL_LUMINANCE_ALPHA:
-      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
-      rgba[3] = tObj->BorderColor.f[3];
-      break;
-   case GL_INTENSITY:
-      rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor.f[0];
-      break;
-   default:
-      COPY_4V(rgba, tObj->BorderColor.f);
-   }
-}
-
-
-/**********************************************************************/
-/*                    1-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s) using GL_NEAREST filter.
- */
-static INLINE void
-sample_1d_nearest(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4], GLfloat rgba[4])
-{
-   const GLint width = img->Width2;  /* without border, power of two */
-   GLint i;
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   /* skip over the border, if any */
-   i += img->Border;
-   if (i < 0 || i >= (GLint) img->Width) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, 0, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s) using GL_LINEAR filter.
- */
-static INLINE void
-sample_1d_linear(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4], GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   GLint i0, i1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a;
-   GLfloat t0[4], t1[4];  /* texels */
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-   }
-
-   /* fetch texel colors */
-   if (useBorderColor & I0BIT) {
-      get_border_color(tObj, img, t0);
-   }
-   else {
-      img->FetchTexelf(img, i0, 0, 0, t0);
-   }
-   if (useBorderColor & I1BIT) {
-      get_border_color(tObj, img, t1);
-   }
-   else {
-      img->FetchTexelf(img, i1, 0, 0, t1);
-   }
-
-   lerp_rgba(rgba, a, t0, t1);
-}
-
-
-static void
-sample_1d_nearest_mipmap_nearest(struct gl_context *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_linear_mipmap_nearest(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_nearest_mipmap_linear(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_1d_linear_mipmap_linear(struct gl_context *ctx,
-                               const struct gl_texture_object *tObj,
-                               GLuint n, const GLfloat texcoord[][4],
-                               const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 1D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_1d( struct gl_context *ctx,
-                   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4], const GLfloat lambda[],
-                   GLfloat rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D texture, linear filtering for both min/magnification */
-static void
-sample_linear_1d( struct gl_context *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4], const GLfloat lambda[],
-                  GLfloat rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_1d( struct gl_context *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_1d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_1d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_1d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_1d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_1d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_1d_texture");
-         return;
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                    2-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-
-/**
- * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
- */
-static INLINE void
-sample_2d_nearest(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4],
-                  GLfloat rgba[])
-{
-   const GLint width = img->Width2;    /* without border, power of two */
-   const GLint height = img->Height2;  /* without border, power of two */
-   GLint i, j;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-
-   /* skip over the border, if any */
-   i += img->Border;
-   j += img->Border;
-
-   if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
- * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
- */
-static INLINE void
-sample_2d_linear(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4],
-                 GLfloat rgba[])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   GLint i0, j0, i1, j1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b;
-   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-   }
-
-   /* fetch four texel colors */
-   if (useBorderColor & (I0BIT | J0BIT)) {
-      get_border_color(tObj, img, t00);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, 0, t00);
-   }
-   if (useBorderColor & (I1BIT | J0BIT)) {
-      get_border_color(tObj, img, t10);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, 0, t10);
-   }
-   if (useBorderColor & (I0BIT | J1BIT)) {
-      get_border_color(tObj, img, t01);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, 0, t01);
-   }
-   if (useBorderColor & (I1BIT | J1BIT)) {
-      get_border_color(tObj, img, t11);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, 0, t11);
-   }
-
-   lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);
-}
-
-
-/**
- * As above, but we know WRAP_S == REPEAT and WRAP_T == REPEAT.
- * We don't have to worry about the texture border.
- */
-static INLINE void
-sample_2d_linear_repeat(struct gl_context *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   GLint i0, j0, i1, j1;
-   GLfloat wi, wj;
-   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */
-
-   (void) ctx;
-
-   ASSERT(tObj->WrapS == GL_REPEAT);
-   ASSERT(tObj->WrapT == GL_REPEAT);
-   ASSERT(img->Border == 0);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-   ASSERT(img->_IsPowerOfTwo);
-
-   linear_repeat_texel_location(width,  texcoord[0], &i0, &i1, &wi);
-   linear_repeat_texel_location(height, texcoord[1], &j0, &j1, &wj);
-
-   img->FetchTexelf(img, i0, j0, 0, t00);
-   img->FetchTexelf(img, i1, j0, 0, t10);
-   img->FetchTexelf(img, i0, j1, 0, t01);
-   img->FetchTexelf(img, i1, j1, 0, t11);
-
-   lerp_rgba_2d(rgba, wi, wj, t00, t10, t01, t11);
-}
-
-
-static void
-sample_2d_nearest_mipmap_nearest(struct gl_context *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_nearest(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_nearest_mipmap_linear(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_2d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_linear( struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_2d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_linear_mipmap_linear_repeat(struct gl_context *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   ASSERT(tObj->WrapS == GL_REPEAT);
-   ASSERT(tObj->WrapT == GL_REPEAT);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level  ],
-                                 texcoord[i], t0);
-         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level+1],
-                                 texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 2D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_2d(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 2D texture, linear filtering for both min/magnification */
-static void
-sample_linear_2d(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4],
-                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   if (tObj->WrapS == GL_REPEAT &&
-       tObj->WrapT == GL_REPEAT &&
-       image->_IsPowerOfTwo &&
-       image->Border == 0) {
-      for (i = 0; i < n; i++) {
-         sample_2d_linear_repeat(ctx, tObj, image, texcoords[i], rgba[i]);
-      }
-   }
-   else {
-      for (i = 0; i < n; i++) {
-         sample_2d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-      }
-   }
-}
-
-
-/**
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border, 
- *    RowStride == Width,
- *    Format = GL_RGB
- */
-static void
-opt_sample_rgb_2d(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj,
-                  GLuint n, const GLfloat texcoords[][4],
-                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint k;
-   (void) ctx;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(img->Border==0);
-   ASSERT(img->TexFormat == MESA_FORMAT_RGB888);
-   ASSERT(img->_IsPowerOfTwo);
-
-   for (k=0; k<n; k++) {
-      GLint i = IFLOOR(texcoords[k][0] * width) & colMask;
-      GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;
-      GLint pos = (j << shift) | i;
-      GLubyte *texel = ((GLubyte *) img->Data) + 3*pos;
-      rgba[k][RCOMP] = UBYTE_TO_FLOAT(texel[2]);
-      rgba[k][GCOMP] = UBYTE_TO_FLOAT(texel[1]);
-      rgba[k][BCOMP] = UBYTE_TO_FLOAT(texel[0]);
-      rgba[k][ACOMP] = 1.0F;
-   }
-}
-
-
-/**
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border
- *    RowStride == Width,
- *    Format = GL_RGBA
- */
-static void
-opt_sample_rgba_2d(struct gl_context *ctx,
-                   const struct gl_texture_object *tObj,
-                   GLuint n, const GLfloat texcoords[][4],
-                   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint i;
-   (void) ctx;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(img->Border==0);
-   ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888);
-   ASSERT(img->_IsPowerOfTwo);
-
-   for (i = 0; i < n; i++) {
-      const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;
-      const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;
-      const GLint pos = (row << shift) | col;
-      const GLuint texel = *((GLuint *) img->Data + pos);
-      rgba[i][RCOMP] = UBYTE_TO_FLOAT( (texel >> 24)        );
-      rgba[i][GCOMP] = UBYTE_TO_FLOAT( (texel >> 16) & 0xff );
-      rgba[i][BCOMP] = UBYTE_TO_FLOAT( (texel >>  8) & 0xff );
-      rgba[i][ACOMP] = UBYTE_TO_FLOAT( (texel      ) & 0xff );
-   }
-}
-
-
-/** Sample 2D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_2d(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj,
-                 GLuint n, const GLfloat texcoords[][4],
-                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *tImg = tObj->Image[0][tObj->BaseLevel];
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-
-   const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT)
-      && (tObj->WrapT == GL_REPEAT)
-      && (tImg->Border == 0 && (tImg->Width == tImg->RowStride))
-      && (tImg->_BaseFormat != GL_COLOR_INDEX)
-      && tImg->_IsPowerOfTwo;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         if (repeatNoBorderPOT) {
-            switch (tImg->TexFormat) {
-            case MESA_FORMAT_RGB888:
-               opt_sample_rgb_2d(ctx, tObj, m, texcoords + minStart,
-                                 NULL, rgba + minStart);
-               break;
-            case MESA_FORMAT_RGBA8888:
-	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + minStart,
-                                  NULL, rgba + minStart);
-               break;
-            default:
-               sample_nearest_2d(ctx, tObj, m, texcoords + minStart,
-                                 NULL, rgba + minStart );
-            }
-         }
-         else {
-            sample_nearest_2d(ctx, tObj, m, texcoords + minStart,
-                              NULL, rgba + minStart);
-         }
-         break;
-      case GL_LINEAR:
-	 sample_linear_2d(ctx, tObj, m, texcoords + minStart,
-			  NULL, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_2d_nearest_mipmap_nearest(ctx, tObj, m,
-                                          texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_2d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_2d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         if (repeatNoBorderPOT)
-            sample_2d_linear_mipmap_linear_repeat(ctx, tObj, m,
-                  texcoords + minStart, lambda + minStart, rgba + minStart);
-         else
-            sample_2d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_2d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      const GLuint m = magEnd - magStart;
-
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         if (repeatNoBorderPOT) {
-            switch (tImg->TexFormat) {
-            case MESA_FORMAT_RGB888:
-               opt_sample_rgb_2d(ctx, tObj, m, texcoords + magStart,
-                                 NULL, rgba + magStart);
-               break;
-            case MESA_FORMAT_RGBA8888:
-	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + magStart,
-                                  NULL, rgba + magStart);
-               break;
-            default:
-               sample_nearest_2d(ctx, tObj, m, texcoords + magStart,
-                                 NULL, rgba + magStart );
-            }
-         }
-         else {
-            sample_nearest_2d(ctx, tObj, m, texcoords + magStart,
-                              NULL, rgba + magStart);
-         }
-         break;
-      case GL_LINEAR:
-	 sample_linear_2d(ctx, tObj, m, texcoords + magStart,
-			  NULL, rgba + magStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_lambda_2d");
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*                    3-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static INLINE void
-sample_3d_nearest(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj,
-                  const struct gl_texture_image *img,
-                  const GLfloat texcoord[4],
-                  GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height2;   /* without border, power of two */
-   const GLint depth = img->Depth2;     /* without border, power of two */
-   GLint i, j, k;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-   k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       j < 0 || j >= (GLint) img->Height ||
-       k < 0 || k >= (GLint) img->Depth) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, k, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_3d_linear(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj,
-                 const struct gl_texture_image *img,
-                 const GLfloat texcoord[4],
-                 GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   const GLint depth = img->Depth2;
-   GLint i0, j0, k0, i1, j1, k1;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b, c;
-   GLfloat t000[4], t010[4], t001[4], t011[4];
-   GLfloat t100[4], t110[4], t101[4], t111[4];
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-   linear_texel_locations(tObj->WrapR, img, depth, texcoord[2],  &k0, &k1, &c);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-      k0 += img->Border;
-      k1 += img->Border;
-   }
-   else {
-      /* check if sampling texture border color */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;
-      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;
-   }
-
-   /* Fetch texels */
-   if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
-      get_border_color(tObj, img, t000);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, k0, t000);
-   }
-   if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
-      get_border_color(tObj, img, t100);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, k0, t100);
-   }
-   if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
-      get_border_color(tObj, img, t010);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, k0, t010);
-   }
-   if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
-      get_border_color(tObj, img, t110);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, k0, t110);
-   }
-
-   if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
-      get_border_color(tObj, img, t001);
-   }
-   else {
-      img->FetchTexelf(img, i0, j0, k1, t001);
-   }
-   if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
-      get_border_color(tObj, img, t101);
-   }
-   else {
-      img->FetchTexelf(img, i1, j0, k1, t101);
-   }
-   if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
-      get_border_color(tObj, img, t011);
-   }
-   else {
-      img->FetchTexelf(img, i0, j1, k1, t011);
-   }
-   if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
-      get_border_color(tObj, img, t111);
-   }
-   else {
-      img->FetchTexelf(img, i1, j1, k1, t111);
-   }
-
-   /* trilinear interpolation of samples */
-   lerp_rgba_3d(rgba, a, b, c, t000, t100, t010, t110, t001, t101, t011, t111);
-}
-
-
-static void
-sample_3d_nearest_mipmap_nearest(struct gl_context *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4] )
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_3d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_3d_linear_mipmap_nearest(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_3d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_3d_nearest_mipmap_linear(struct gl_context *ctx,
-                                const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat texcoord[][4],
-                                const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                           texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_3d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_3d_linear_mipmap_linear(struct gl_context *ctx,
-                               const struct gl_texture_object *tObj,
-                               GLuint n, const GLfloat texcoord[][4],
-                               const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_3d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_3d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 3D texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_3d(struct gl_context *ctx,
-                  const struct gl_texture_object *tObj, GLuint n,
-                  const GLfloat texcoords[][4], const GLfloat lambda[],
-                  GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_3d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 3D texture, linear filtering for both min/magnification */
-static void
-sample_linear_3d(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4],
-		 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_3d_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 3D texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_3d(struct gl_context *ctx,
-                 const struct gl_texture_object *tObj, GLuint n,
-                 const GLfloat texcoords[][4], const GLfloat lambda[],
-                 GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_3d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_3d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_3d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                         lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_3d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                        lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_3d_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                             texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_3d_texture");
-         return;
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                Texture Cube Map Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Choose one of six sides of a texture cube map given the texture
- * coord (rx,ry,rz).  Return pointer to corresponding array of texture
- * images.
- */
-static const struct gl_texture_image **
-choose_cube_face(const struct gl_texture_object *texObj,
-                 const GLfloat texcoord[4], GLfloat newCoord[4])
-{
-   /*
-      major axis
-      direction     target                             sc     tc    ma
-      ----------    -------------------------------    ---    ---   ---
-       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx
-       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx
-       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry
-       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry
-       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz
-       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
-   */
-   const GLfloat rx = texcoord[0];
-   const GLfloat ry = texcoord[1];
-   const GLfloat rz = texcoord[2];
-   const GLfloat arx = FABSF(rx), ary = FABSF(ry), arz = FABSF(rz);
-   GLuint face;
-   GLfloat sc, tc, ma;
-
-   if (arx >= ary && arx >= arz) {
-      if (rx >= 0.0F) {
-         face = FACE_POS_X;
-         sc = -rz;
-         tc = -ry;
-         ma = arx;
-      }
-      else {
-         face = FACE_NEG_X;
-         sc = rz;
-         tc = -ry;
-         ma = arx;
-      }
-   }
-   else if (ary >= arx && ary >= arz) {
-      if (ry >= 0.0F) {
-         face = FACE_POS_Y;
-         sc = rx;
-         tc = rz;
-         ma = ary;
-      }
-      else {
-         face = FACE_NEG_Y;
-         sc = rx;
-         tc = -rz;
-         ma = ary;
-      }
-   }
-   else {
-      if (rz > 0.0F) {
-         face = FACE_POS_Z;
-         sc = rx;
-         tc = -ry;
-         ma = arz;
-      }
-      else {
-         face = FACE_NEG_Z;
-         sc = -rx;
-         tc = -ry;
-         ma = arz;
-      }
-   }
-
-   { 
-      const float ima = 1.0F / ma;
-      newCoord[0] = ( sc * ima + 1.0F ) * 0.5F;
-      newCoord[1] = ( tc * ima + 1.0F ) * 0.5F;
-   }
-
-   return (const struct gl_texture_image **) texObj->Image[face];
-}
-
-
-static void
-sample_nearest_cube(struct gl_context *ctx,
-		    const struct gl_texture_object *tObj, GLuint n,
-                    const GLfloat texcoords[][4], const GLfloat lambda[],
-                    GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      images = choose_cube_face(tObj, texcoords[i], newCoord);
-      sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
-                        newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_linear_cube(struct gl_context *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4],
-		   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      images = choose_cube_face(tObj, texcoords[i], newCoord);
-      sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
-                       newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_nearest_mipmap_nearest(struct gl_context *ctx,
-                                   const struct gl_texture_object *tObj,
-                                   GLuint n, const GLfloat texcoord[][4],
-                                   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level;
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-
-      /* XXX we actually need to recompute lambda here based on the newCoords.
-       * But we would need the texcoords of adjacent fragments to compute that
-       * properly, and we don't have those here.
-       * For now, do an approximation:  subtracting 1 from the chosen mipmap
-       * level seems to work in some test cases.
-       * The same adjustment is done in the next few functions.
-      */
-      level = nearest_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0);
-
-      sample_2d_nearest(ctx, tObj, images[level], newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_linear_mipmap_nearest(struct gl_context *ctx,
-                                  const struct gl_texture_object *tObj,
-                                  GLuint n, const GLfloat texcoord[][4],
-                                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      sample_2d_linear(ctx, tObj, images[level], newCoord, rgba[i]);
-   }
-}
-
-
-static void
-sample_cube_nearest_mipmap_linear(struct gl_context *ctx,
-                                  const struct gl_texture_object *tObj,
-                                  GLuint n, const GLfloat texcoord[][4],
-                                  const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel],
-                           newCoord, rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_nearest(ctx, tObj, images[level  ], newCoord, t0);
-         sample_2d_nearest(ctx, tObj, images[level+1], newCoord, t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_cube_linear_mipmap_linear(struct gl_context *ctx,
-                                 const struct gl_texture_object *tObj,
-                                 GLuint n, const GLfloat texcoord[][4],
-                                 const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newCoord[4];
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      level = MAX2(level - 1, 0); /* see comment above */
-      images = choose_cube_face(tObj, texcoord[i], newCoord);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel],
-                          newCoord, rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_linear(ctx, tObj, images[level  ], newCoord, t0);
-         sample_2d_linear(ctx, tObj, images[level+1], newCoord, t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample cube texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_cube(struct gl_context *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-		   const GLfloat texcoords[][4], const GLfloat lambda[],
-		   GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      const GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         sample_nearest_cube(ctx, tObj, m, texcoords + minStart,
-                             lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR:
-         sample_linear_cube(ctx, tObj, m, texcoords + minStart,
-                            lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_cube_nearest_mipmap_nearest(ctx, tObj, m,
-                                            texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_cube_linear_mipmap_nearest(ctx, tObj, m,
-                                           texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_cube_nearest_mipmap_linear(ctx, tObj, m,
-                                           texcoords + minStart,
-                                           lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_cube_linear_mipmap_linear(ctx, tObj, m,
-                                          texcoords + minStart,
-                                          lambda + minStart, rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_lambda_cube");
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      const GLuint m = magEnd - magStart;
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         sample_nearest_cube(ctx, tObj, m, texcoords + magStart,
-                             lambda + magStart, rgba + magStart);
-         break;
-      case GL_LINEAR:
-         sample_linear_cube(ctx, tObj, m, texcoords + magStart,
-                            lambda + magStart, rgba + magStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_lambda_cube");
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*               Texture Rectangle Sampling Functions                 */
-/**********************************************************************/
-
-
-static void
-sample_nearest_rect(struct gl_context *ctx,
-		    const struct gl_texture_object *tObj, GLuint n,
-                    const GLfloat texcoords[][4], const GLfloat lambda[],
-                    GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][0];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   GLuint i;
-
-   (void) ctx;
-   (void) lambda;
-
-   ASSERT(tObj->WrapS == GL_CLAMP ||
-          tObj->WrapS == GL_CLAMP_TO_EDGE ||
-          tObj->WrapS == GL_CLAMP_TO_BORDER);
-   ASSERT(tObj->WrapT == GL_CLAMP ||
-          tObj->WrapT == GL_CLAMP_TO_EDGE ||
-          tObj->WrapT == GL_CLAMP_TO_BORDER);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-
-   for (i = 0; i < n; i++) {
-      GLint row, col;
-      col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width);
-      row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height);
-      if (col < 0 || col >= width || row < 0 || row >= height)
-         get_border_color(tObj, img, rgba[i]);
-      else
-         img->FetchTexelf(img, col, row, 0, rgba[i]);
-   }
-}
-
-
-static void
-sample_linear_rect(struct gl_context *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat texcoords[][4],
-		   const GLfloat lambda[], GLfloat rgba[][4])
-{
-   const struct gl_texture_image *img = tObj->Image[0][0];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   GLuint i;
-
-   (void) ctx;
-   (void) lambda;
-
-   ASSERT(tObj->WrapS == GL_CLAMP ||
-          tObj->WrapS == GL_CLAMP_TO_EDGE ||
-          tObj->WrapS == GL_CLAMP_TO_BORDER);
-   ASSERT(tObj->WrapT == GL_CLAMP ||
-          tObj->WrapT == GL_CLAMP_TO_EDGE ||
-          tObj->WrapT == GL_CLAMP_TO_BORDER);
-   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
-
-   for (i = 0; i < n; i++) {
-      GLint i0, j0, i1, j1;
-      GLfloat t00[4], t01[4], t10[4], t11[4];
-      GLfloat a, b;
-      GLbitfield useBorderColor = 0x0;
-
-      clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width,
-                              &i0, &i1, &a);
-      clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height,
-                              &j0, &j1, &b);
-
-      /* compute integer rows/columns */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-
-      /* get four texel samples */
-      if (useBorderColor & (I0BIT | J0BIT))
-         get_border_color(tObj, img, t00);
-      else
-         img->FetchTexelf(img, i0, j0, 0, t00);
-
-      if (useBorderColor & (I1BIT | J0BIT))
-         get_border_color(tObj, img, t10);
-      else
-         img->FetchTexelf(img, i1, j0, 0, t10);
-
-      if (useBorderColor & (I0BIT | J1BIT))
-         get_border_color(tObj, img, t01);
-      else
-         img->FetchTexelf(img, i0, j1, 0, t01);
-
-      if (useBorderColor & (I1BIT | J1BIT))
-         get_border_color(tObj, img, t11);
-      else
-         img->FetchTexelf(img, i1, j1, 0, t11);
-
-      lerp_rgba_2d(rgba[i], a, b, t00, t10, t01, t11);
-   }
-}
-
-
-/** Sample Rect texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_rect(struct gl_context *ctx,
-		   const struct gl_texture_object *tObj, GLuint n,
-		   const GLfloat texcoords[][4], const GLfloat lambda[],
-		   GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd, magStart, magEnd;
-
-   /* We only need lambda to decide between minification and magnification.
-    * There is no mipmapping with rectangular textures.
-    */
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      if (tObj->MinFilter == GL_NEAREST) {
-         sample_nearest_rect(ctx, tObj, minEnd - minStart,
-                             texcoords + minStart, NULL, rgba + minStart);
-      }
-      else {
-         sample_linear_rect(ctx, tObj, minEnd - minStart,
-                            texcoords + minStart, NULL, rgba + minStart);
-      }
-   }
-   if (magStart < magEnd) {
-      if (tObj->MagFilter == GL_NEAREST) {
-         sample_nearest_rect(ctx, tObj, magEnd - magStart,
-                             texcoords + magStart, NULL, rgba + magStart);
-      }
-      else {
-         sample_linear_rect(ctx, tObj, magEnd - magStart,
-                            texcoords + magStart, NULL, rgba + magStart);
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                2D Texture Array Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static void
-sample_2d_array_nearest(struct gl_context *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height2;   /* without border, power of two */
-   const GLint depth = img->Depth;
-   GLint i, j;
-   GLint array;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
-   array = tex_array_slice(texcoord[2], depth);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       j < 0 || j >= (GLint) img->Height ||
-       array < 0 || array >= (GLint) img->Depth) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, j, array, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_2d_array_linear(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj,
-                       const struct gl_texture_image *img,
-                       const GLfloat texcoord[4],
-                       GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   const GLint depth = img->Depth;
-   GLint i0, j0, i1, j1;
-   GLint array;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a, b;
-   GLfloat t00[4], t01[4], t10[4], t11[4];
-
-   linear_texel_locations(tObj->WrapS, img, width,  texcoord[0], &i0, &i1, &a);
-   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
-   array = tex_array_slice(texcoord[2], depth);
-
-   if (array < 0 || array >= depth) {
-      COPY_4V(rgba, tObj->BorderColor.f);
-   }
-   else {
-      if (img->Border) {
-	 i0 += img->Border;
-	 i1 += img->Border;
-	 j0 += img->Border;
-	 j1 += img->Border;
-      }
-      else {
-	 /* check if sampling texture border color */
-	 if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-	 if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-	 if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-	 if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-      }
-
-      /* Fetch texels */
-      if (useBorderColor & (I0BIT | J0BIT)) {
-         get_border_color(tObj, img, t00);
-      }
-      else {
-	 img->FetchTexelf(img, i0, j0, array, t00);
-      }
-      if (useBorderColor & (I1BIT | J0BIT)) {
-         get_border_color(tObj, img, t10);
-      }
-      else {
-	 img->FetchTexelf(img, i1, j0, array, t10);
-      }
-      if (useBorderColor & (I0BIT | J1BIT)) {
-         get_border_color(tObj, img, t01);
-      }
-      else {
-	 img->FetchTexelf(img, i0, j1, array, t01);
-      }
-      if (useBorderColor & (I1BIT | J1BIT)) {
-         get_border_color(tObj, img, t11);
-      }
-      else {
-	 img->FetchTexelf(img, i1, j1, array, t11);
-      }
-      
-      /* trilinear interpolation of samples */
-      lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);
-   }
-}
-
-
-static void
-sample_2d_array_nearest_mipmap_nearest(struct gl_context *ctx,
-                                       const struct gl_texture_object *tObj,
-                                       GLuint n, const GLfloat texcoord[][4],
-                                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],
-                              rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_array_linear_mipmap_nearest(struct gl_context *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_2d_array_linear(ctx, tObj, tObj->Image[0][level],
-                             texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_2d_array_nearest_mipmap_linear(struct gl_context *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level  ],
-                                 texcoord[i], t0);
-         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level+1],
-                                 texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_2d_array_linear_mipmap_linear(struct gl_context *ctx,
-                                     const struct gl_texture_object *tObj,
-                                     GLuint n, const GLfloat texcoord[][4],
-                                     const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level  ],
-                                texcoord[i], t0);
-         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level+1],
-                                texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 2D Array texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_2d_array(struct gl_context *ctx,
-                        const struct gl_texture_object *tObj, GLuint n,
-                        const GLfloat texcoords[][4], const GLfloat lambda[],
-                        GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-
-/** Sample 2D Array texture, linear filtering for both min/magnification */
-static void
-sample_linear_2d_array(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4],
-                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_2d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 2D Array texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_2d_array(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4], const GLfloat lambda[],
-                       GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                    texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_2d_array_nearest_mipmap_nearest(ctx, tObj, m,
-                                                texcoords + minStart,
-                                                lambda + minStart,
-                                                rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_2d_array_linear_mipmap_nearest(ctx, tObj, m, 
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_2d_array_nearest_mipmap_linear(ctx, tObj, m,
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_2d_array_linear_mipmap_linear(ctx, tObj, m, 
-                                              texcoords + minStart,
-                                              lambda + minStart, 
-                                              rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_2d_array_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_2d_array_texture");
-         return;
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*                1D Texture Array Sampling Functions                 */
-/**********************************************************************/
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static void
-sample_1d_array_nearest(struct gl_context *ctx,
-                        const struct gl_texture_object *tObj,
-                        const struct gl_texture_image *img,
-                        const GLfloat texcoord[4],
-                        GLfloat rgba[4])
-{
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height;
-   GLint i;
-   GLint array;
-   (void) ctx;
-
-   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
-   array = tex_array_slice(texcoord[1], height);
-
-   if (i < 0 || i >= (GLint) img->Width ||
-       array < 0 || array >= (GLint) img->Height) {
-      /* Need this test for GL_CLAMP_TO_BORDER mode */
-      get_border_color(tObj, img, rgba);
-   }
-   else {
-      img->FetchTexelf(img, i, array, 0, rgba);
-   }
-}
-
-
-/**
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void
-sample_1d_array_linear(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj,
-                       const struct gl_texture_image *img,
-                       const GLfloat texcoord[4],
-                       GLfloat rgba[4])
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height;
-   GLint i0, i1;
-   GLint array;
-   GLbitfield useBorderColor = 0x0;
-   GLfloat a;
-   GLfloat t0[4], t1[4];
-
-   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
-   array = tex_array_slice(texcoord[1], height);
-
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-   }
-   else {
-      /* check if sampling texture border color */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-   }
-
-   if (array < 0 || array >= height)   useBorderColor |= K0BIT;
-
-   /* Fetch texels */
-   if (useBorderColor & (I0BIT | K0BIT)) {
-      get_border_color(tObj, img, t0);
-   }
-   else {
-      img->FetchTexelf(img, i0, array, 0, t0);
-   }
-   if (useBorderColor & (I1BIT | K0BIT)) {
-      get_border_color(tObj, img, t1);
-   }
-   else {
-      img->FetchTexelf(img, i1, array, 0, t1);
-   }
-
-   /* bilinear interpolation of samples */
-   lerp_rgba(rgba, a, t0, t1);
-}
-
-
-static void
-sample_1d_array_nearest_mipmap_nearest(struct gl_context *ctx,
-                                       const struct gl_texture_object *tObj,
-                                       GLuint n, const GLfloat texcoord[][4],
-                                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],
-                              rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_array_linear_mipmap_nearest(struct gl_context *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = nearest_mipmap_level(tObj, lambda[i]);
-      sample_1d_array_linear(ctx, tObj, tObj->Image[0][level],
-                             texcoord[i], rgba[i]);
-   }
-}
-
-
-static void
-sample_1d_array_nearest_mipmap_linear(struct gl_context *ctx,
-                                      const struct gl_texture_object *tObj,
-                                      GLuint n, const GLfloat texcoord[][4],
-                                      const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                                 texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-static void
-sample_1d_array_linear_mipmap_linear(struct gl_context *ctx,
-                                     const struct gl_texture_object *tObj,
-                                     GLuint n, const GLfloat texcoord[][4],
-                                     const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   ASSERT(lambda != NULL);
-   for (i = 0; i < n; i++) {
-      GLint level = linear_mipmap_level(tObj, lambda[i]);
-      if (level >= tObj->_MaxLevel) {
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],
-                          texcoord[i], rgba[i]);
-      }
-      else {
-         GLfloat t0[4], t1[4];  /* texels */
-         const GLfloat f = FRAC(lambda[i]);
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);
-         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);
-         lerp_rgba(rgba[i], f, t0, t1);
-      }
-   }
-}
-
-
-/** Sample 1D Array texture, nearest filtering for both min/magnification */
-static void
-sample_nearest_1d_array(struct gl_context *ctx,
-                        const struct gl_texture_object *tObj, GLuint n,
-                        const GLfloat texcoords[][4], const GLfloat lambda[],
-                        GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D Array texture, linear filtering for both min/magnification */
-static void
-sample_linear_1d_array(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4],
-                       const GLfloat lambda[], GLfloat rgba[][4])
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      sample_1d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);
-   }
-}
-
-
-/** Sample 1D Array texture, using lambda to choose between min/magnification */
-static void
-sample_lambda_1d_array(struct gl_context *ctx,
-                       const struct gl_texture_object *tObj, GLuint n,
-                       const GLfloat texcoords[][4], const GLfloat lambda[],
-                       GLfloat rgba[][4])
-{
-   GLuint minStart, minEnd;  /* texels with minification */
-   GLuint magStart, magEnd;  /* texels with magnification */
-   GLuint i;
-
-   ASSERT(lambda != NULL);
-   compute_min_mag_ranges(tObj, n, lambda,
-                          &minStart, &minEnd, &magStart, &magEnd);
-
-   if (minStart < minEnd) {
-      /* do the minified texels */
-      GLuint m = minEnd - minStart;
-      switch (tObj->MinFilter) {
-      case GL_NEAREST:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                    texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = minStart; i < minEnd; i++)
-            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      case GL_NEAREST_MIPMAP_NEAREST:
-         sample_1d_array_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,
-                                                lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_NEAREST:
-         sample_1d_array_linear_mipmap_nearest(ctx, tObj, m, 
-                                               texcoords + minStart,
-                                               lambda + minStart,
-                                               rgba + minStart);
-         break;
-      case GL_NEAREST_MIPMAP_LINEAR:
-         sample_1d_array_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,
-                                               lambda + minStart, rgba + minStart);
-         break;
-      case GL_LINEAR_MIPMAP_LINEAR:
-         sample_1d_array_linear_mipmap_linear(ctx, tObj, m, 
-                                              texcoords + minStart,
-                                              lambda + minStart, 
-                                              rgba + minStart);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad min filter in sample_1d_array_texture");
-         return;
-      }
-   }
-
-   if (magStart < magEnd) {
-      /* do the magnified texels */
-      switch (tObj->MagFilter) {
-      case GL_NEAREST:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                              texcoords[i], rgba[i]);
-         break;
-      case GL_LINEAR:
-         for (i = magStart; i < magEnd; i++)
-            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
-                                   texcoords[i], rgba[i]);
-         break;
-      default:
-         _mesa_problem(ctx, "Bad mag filter in sample_1d_array_texture");
-         return;
-      }
-   }
-}
-
-
-/**
- * Compare texcoord against depth sample.  Return 1.0 or the ambient value.
- */
-static INLINE GLfloat
-shadow_compare(GLenum function, GLfloat coord, GLfloat depthSample,
-               GLfloat ambient)
-{
-   switch (function) {
-   case GL_LEQUAL:
-      return (coord <= depthSample) ? 1.0F : ambient;
-   case GL_GEQUAL:
-      return (coord >= depthSample) ? 1.0F : ambient;
-   case GL_LESS:
-      return (coord < depthSample) ? 1.0F : ambient;
-   case GL_GREATER:
-      return (coord > depthSample) ? 1.0F : ambient;
-   case GL_EQUAL:
-      return (coord == depthSample) ? 1.0F : ambient;
-   case GL_NOTEQUAL:
-      return (coord != depthSample) ? 1.0F : ambient;
-   case GL_ALWAYS:
-      return 1.0F;
-   case GL_NEVER:
-      return ambient;
-   case GL_NONE:
-      return depthSample;
-   default:
-      _mesa_problem(NULL, "Bad compare func in shadow_compare");
-      return ambient;
-   }
-}
-
-
-/**
- * Compare texcoord against four depth samples.
- */
-static INLINE GLfloat
-shadow_compare4(GLenum function, GLfloat coord,
-                GLfloat depth00, GLfloat depth01,
-                GLfloat depth10, GLfloat depth11,
-                GLfloat ambient, GLfloat wi, GLfloat wj)
-{
-   const GLfloat d = (1.0F - (GLfloat) ambient) * 0.25F;
-   GLfloat luminance = 1.0F;
-
-   switch (function) {
-   case GL_LEQUAL:
-      if (coord > depth00)  luminance -= d;
-      if (coord > depth01)  luminance -= d;
-      if (coord > depth10)  luminance -= d;
-      if (coord > depth11)  luminance -= d;
-      return luminance;
-   case GL_GEQUAL:
-      if (coord < depth00)  luminance -= d;
-      if (coord < depth01)  luminance -= d;
-      if (coord < depth10)  luminance -= d;
-      if (coord < depth11)  luminance -= d;
-      return luminance;
-   case GL_LESS:
-      if (coord >= depth00)  luminance -= d;
-      if (coord >= depth01)  luminance -= d;
-      if (coord >= depth10)  luminance -= d;
-      if (coord >= depth11)  luminance -= d;
-      return luminance;
-   case GL_GREATER:
-      if (coord <= depth00)  luminance -= d;
-      if (coord <= depth01)  luminance -= d;
-      if (coord <= depth10)  luminance -= d;
-      if (coord <= depth11)  luminance -= d;
-      return luminance;
-   case GL_EQUAL:
-      if (coord != depth00)  luminance -= d;
-      if (coord != depth01)  luminance -= d;
-      if (coord != depth10)  luminance -= d;
-      if (coord != depth11)  luminance -= d;
-      return luminance;
-   case GL_NOTEQUAL:
-      if (coord == depth00)  luminance -= d;
-      if (coord == depth01)  luminance -= d;
-      if (coord == depth10)  luminance -= d;
-      if (coord == depth11)  luminance -= d;
-      return luminance;
-   case GL_ALWAYS:
-      return 1.0F;
-   case GL_NEVER:
-      return ambient;
-   case GL_NONE:
-      /* ordinary bilinear filtering */
-      return lerp_2d(wi, wj, depth00, depth10, depth01, depth11);
-   default:
-      _mesa_problem(NULL, "Bad compare func in sample_compare4");
-      return ambient;
-   }
-}
-
-
-/**
- * Choose the mipmap level to use when sampling from a depth texture.
- */
-static int
-choose_depth_texture_level(const struct gl_texture_object *tObj, GLfloat lambda)
-{
-   GLint level;
-
-   if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
-      /* no mipmapping - use base level */
-      level = tObj->BaseLevel;
-   }
-   else {
-      /* choose mipmap level */
-      lambda = CLAMP(lambda, tObj->MinLod, tObj->MaxLod);
-      level = (GLint) lambda;
-      level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel);
-   }
-
-   return level;
-}
-
-
-/**
- * Sample a shadow/depth texture.  This function is incomplete.  It doesn't
- * check for minification vs. magnification, etc.
- */
-static void
-sample_depth_texture( struct gl_context *ctx,
-                      const struct gl_texture_object *tObj, GLuint n,
-                      const GLfloat texcoords[][4], const GLfloat lambda[],
-                      GLfloat texel[][4] )
-{
-   const GLint level = choose_depth_texture_level(tObj, lambda[0]);
-   const struct gl_texture_image *img = tObj->Image[0][level];
-   const GLint width = img->Width;
-   const GLint height = img->Height;
-   const GLint depth = img->Depth;
-   const GLuint compare_coord = (tObj->Target == GL_TEXTURE_2D_ARRAY_EXT)
-       ? 3 : 2;
-   GLfloat ambient;
-   GLenum function;
-   GLfloat result;
-
-   ASSERT(img->_BaseFormat == GL_DEPTH_COMPONENT ||
-          img->_BaseFormat == GL_DEPTH_STENCIL_EXT);
-
-   ASSERT(tObj->Target == GL_TEXTURE_1D ||
-          tObj->Target == GL_TEXTURE_2D ||
-          tObj->Target == GL_TEXTURE_RECTANGLE_NV ||
-          tObj->Target == GL_TEXTURE_1D_ARRAY_EXT ||
-          tObj->Target == GL_TEXTURE_2D_ARRAY_EXT);
-
-   ambient = tObj->CompareFailValue;
-
-   /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */
-
-   function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?
-      tObj->CompareFunc : GL_NONE;
-
-   if (tObj->MagFilter == GL_NEAREST) {
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         GLfloat depthSample, depthRef;
-         GLint col, row, slice;
-
-         nearest_texcoord(tObj, level, texcoords[i], &col, &row, &slice);
-
-         if (col >= 0 && row >= 0 && col < width && row < height && 
-             slice >= 0 && slice < depth) {
-            img->FetchTexelf(img, col, row, slice, &depthSample);
-         }
-         else {
-            depthSample = tObj->BorderColor.f[0];
-         }
-
-         depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F);
-
-         result = shadow_compare(function, depthRef, depthSample, ambient);
-
-         switch (tObj->DepthMode) {
-         case GL_LUMINANCE:
-            ASSIGN_4V(texel[i], result, result, result, 1.0F);
-            break;
-         case GL_INTENSITY:
-            ASSIGN_4V(texel[i], result, result, result, result);
-            break;
-         case GL_ALPHA:
-            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);
-            break;
-         case GL_RED:
-            ASSIGN_4V(texel[i], result, 0.0F, 0.0F, 1.0F);
-            break;
-         default:
-            _mesa_problem(ctx, "Bad depth texture mode");
-         }
-      }
-   }
-   else {
-      GLuint i;
-      ASSERT(tObj->MagFilter == GL_LINEAR);
-      for (i = 0; i < n; i++) {
-         GLfloat depth00, depth01, depth10, depth11, depthRef;
-         GLint i0, i1, j0, j1;
-         GLint slice;
-         GLfloat wi, wj;
-         GLuint useBorderTexel;
-
-         linear_texcoord(tObj, level, texcoords[i], &i0, &i1, &j0, &j1, &slice,
-                         &wi, &wj);
-
-         useBorderTexel = 0;
-         if (img->Border) {
-            i0 += img->Border;
-            i1 += img->Border;
-            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {
-               j0 += img->Border;
-               j1 += img->Border;
-            }
-         }
-         else {
-            if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;
-            if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;
-            if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;
-            if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;
-         }
-
-         if (slice < 0 || slice >= (GLint) depth) {
-            depth00 = tObj->BorderColor.f[0];
-            depth01 = tObj->BorderColor.f[0];
-            depth10 = tObj->BorderColor.f[0];
-            depth11 = tObj->BorderColor.f[0];
-         }
-         else {
-            /* get four depth samples from the texture */
-            if (useBorderTexel & (I0BIT | J0BIT)) {
-               depth00 = tObj->BorderColor.f[0];
-            }
-            else {
-               img->FetchTexelf(img, i0, j0, slice, &depth00);
-            }
-            if (useBorderTexel & (I1BIT | J0BIT)) {
-               depth10 = tObj->BorderColor.f[0];
-            }
-            else {
-               img->FetchTexelf(img, i1, j0, slice, &depth10);
-            }
-
-            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {
-               if (useBorderTexel & (I0BIT | J1BIT)) {
-                  depth01 = tObj->BorderColor.f[0];
-               }
-               else {
-                  img->FetchTexelf(img, i0, j1, slice, &depth01);
-               }
-               if (useBorderTexel & (I1BIT | J1BIT)) {
-                  depth11 = tObj->BorderColor.f[0];
-               }
-               else {
-                  img->FetchTexelf(img, i1, j1, slice, &depth11);
-               }
-            }
-            else {
-               depth01 = depth00;
-               depth11 = depth10;
-            }
-         }
-
-         depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F);
-
-         result = shadow_compare4(function, depthRef,
-                                  depth00, depth01, depth10, depth11,
-                                  ambient, wi, wj);
-
-         switch (tObj->DepthMode) {
-         case GL_LUMINANCE:
-            ASSIGN_4V(texel[i], result, result, result, 1.0F);
-            break;
-         case GL_INTENSITY:
-            ASSIGN_4V(texel[i], result, result, result, result);
-            break;
-         case GL_ALPHA:
-            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);
-            break;
-         default:
-            _mesa_problem(ctx, "Bad depth texture mode");
-         }
-
-      }  /* for */
-   }  /* if filter */
-}
-
-
-/**
- * We use this function when a texture object is in an "incomplete" state.
- * When a fragment program attempts to sample an incomplete texture we
- * return black (see issue 23 in GL_ARB_fragment_program spec).
- * Note: fragment programs don't observe the texture enable/disable flags.
- */
-static void
-null_sample_func( struct gl_context *ctx,
-		  const struct gl_texture_object *tObj, GLuint n,
-		  const GLfloat texcoords[][4], const GLfloat lambda[],
-		  GLfloat rgba[][4])
-{
-   GLuint i;
-   (void) ctx;
-   (void) tObj;
-   (void) texcoords;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      rgba[i][RCOMP] = 0;
-      rgba[i][GCOMP] = 0;
-      rgba[i][BCOMP] = 0;
-      rgba[i][ACOMP] = 1.0;
-   }
-}
-
-
-/**
- * Choose the texture sampling function for the given texture object.
- */
-texture_sample_func
-_swrast_choose_texture_sample_func( struct gl_context *ctx,
-				    const struct gl_texture_object *t )
-{
-   if (!t || !t->_Complete) {
-      return &null_sample_func;
-   }
-   else {
-      const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
-      const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat;
-
-      switch (t->Target) {
-      case GL_TEXTURE_1D:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_1d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_1d;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_1d;
-         }
-      case GL_TEXTURE_2D:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_2d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_2d;
-         }
-         else {
-            /* check for a few optimized cases */
-            const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
-            ASSERT(t->MinFilter == GL_NEAREST);
-            if (t->WrapS == GL_REPEAT &&
-                t->WrapT == GL_REPEAT &&
-                img->_IsPowerOfTwo &&
-                img->Border == 0 &&
-                img->TexFormat == MESA_FORMAT_RGB888) {
-               return &opt_sample_rgb_2d;
-            }
-            else if (t->WrapS == GL_REPEAT &&
-                     t->WrapT == GL_REPEAT &&
-                     img->_IsPowerOfTwo &&
-                     img->Border == 0 &&
-                     img->TexFormat == MESA_FORMAT_RGBA8888) {
-               return &opt_sample_rgba_2d;
-            }
-            else {
-               return &sample_nearest_2d;
-            }
-         }
-      case GL_TEXTURE_3D:
-         if (needLambda) {
-            return &sample_lambda_3d;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_3d;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_3d;
-         }
-      case GL_TEXTURE_CUBE_MAP:
-         if (needLambda) {
-            return &sample_lambda_cube;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_cube;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_cube;
-         }
-      case GL_TEXTURE_RECTANGLE_NV:
-         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
-            return &sample_depth_texture;
-         }
-         else if (needLambda) {
-            return &sample_lambda_rect;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_rect;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_rect;
-         }
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         if (needLambda) {
-            return &sample_lambda_1d_array;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_1d_array;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_1d_array;
-         }
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         if (needLambda) {
-            return &sample_lambda_2d_array;
-         }
-         else if (t->MinFilter == GL_LINEAR) {
-            return &sample_linear_2d_array;
-         }
-         else {
-            ASSERT(t->MinFilter == GL_NEAREST);
-            return &sample_nearest_2d_array;
-         }
-      default:
-         _mesa_problem(ctx,
-                       "invalid target in _swrast_choose_texture_sample_func");
-         return &null_sample_func;
-      }
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/colormac.h"

+#include "main/imports.h"

+

+#include "s_context.h"

+#include "s_texfilter.h"

+

+

+/*

+ * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes

+ * see 1-pixel bands of improperly weighted linear-filtered textures.

+ * The tests/texwrap.c demo is a good test.

+ * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.

+ * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).

+ */

+#define FRAC(f)  ((f) - IFLOOR(f))

+

+

+

+/**

+ * Linear interpolation macro

+ */

+#define LERP(T, A, B)  ( (A) + (T) * ((B) - (A)) )

+

+

+/**

+ * Do 2D/biliner interpolation of float values.

+ * v00, v10, v01 and v11 are typically four texture samples in a square/box.

+ * a and b are the horizontal and vertical interpolants.

+ * It's important that this function is inlined when compiled with

+ * optimization!  If we find that's not true on some systems, convert

+ * to a macro.

+ */

+static INLINE GLfloat

+lerp_2d(GLfloat a, GLfloat b,

+        GLfloat v00, GLfloat v10, GLfloat v01, GLfloat v11)

+{

+   const GLfloat temp0 = LERP(a, v00, v10);

+   const GLfloat temp1 = LERP(a, v01, v11);

+   return LERP(b, temp0, temp1);

+}

+

+

+/**

+ * Do 3D/trilinear interpolation of float values.

+ * \sa lerp_2d

+ */

+static INLINE GLfloat

+lerp_3d(GLfloat a, GLfloat b, GLfloat c,

+        GLfloat v000, GLfloat v100, GLfloat v010, GLfloat v110,

+        GLfloat v001, GLfloat v101, GLfloat v011, GLfloat v111)

+{

+   const GLfloat temp00 = LERP(a, v000, v100);

+   const GLfloat temp10 = LERP(a, v010, v110);

+   const GLfloat temp01 = LERP(a, v001, v101);

+   const GLfloat temp11 = LERP(a, v011, v111);

+   const GLfloat temp0 = LERP(b, temp00, temp10);

+   const GLfloat temp1 = LERP(b, temp01, temp11);

+   return LERP(c, temp0, temp1);

+}

+

+

+/**

+ * Do linear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba(GLfloat result[4], GLfloat t, const GLfloat a[4], const GLfloat b[4])

+{

+   result[0] = LERP(t, a[0], b[0]);

+   result[1] = LERP(t, a[1], b[1]);

+   result[2] = LERP(t, a[2], b[2]);

+   result[3] = LERP(t, a[3], b[3]);

+}

+

+

+/**

+ * Do bilinear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba_2d(GLfloat result[4], GLfloat a, GLfloat b,

+             const GLfloat t00[4], const GLfloat t10[4],

+             const GLfloat t01[4], const GLfloat t11[4])

+{

+   result[0] = lerp_2d(a, b, t00[0], t10[0], t01[0], t11[0]);

+   result[1] = lerp_2d(a, b, t00[1], t10[1], t01[1], t11[1]);

+   result[2] = lerp_2d(a, b, t00[2], t10[2], t01[2], t11[2]);

+   result[3] = lerp_2d(a, b, t00[3], t10[3], t01[3], t11[3]);

+}

+

+

+/**

+ * Do trilinear interpolation of colors.

+ */

+static INLINE void

+lerp_rgba_3d(GLfloat result[4], GLfloat a, GLfloat b, GLfloat c,

+             const GLfloat t000[4], const GLfloat t100[4],

+             const GLfloat t010[4], const GLfloat t110[4],

+             const GLfloat t001[4], const GLfloat t101[4],

+             const GLfloat t011[4], const GLfloat t111[4])

+{

+   GLuint k;

+   /* compiler should unroll these short loops */

+   for (k = 0; k < 4; k++) {

+      result[k] = lerp_3d(a, b, c, t000[k], t100[k], t010[k], t110[k],

+                                   t001[k], t101[k], t011[k], t111[k]);

+   }

+}

+

+

+/**

+ * Used for GL_REPEAT wrap mode.  Using A % B doesn't produce the

+ * right results for A<0.  Casting to A to be unsigned only works if B

+ * is a power of two.  Adding a bias to A (which is a multiple of B)

+ * avoids the problems with A < 0 (for reasonable A) without using a

+ * conditional.

+ */

+#define REMAINDER(A, B) (((A) + (B) * 1024) % (B))

+

+

+/**

+ * Used to compute texel locations for linear sampling.

+ * Input:

+ *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER

+ *    s = texcoord in [0,1]

+ *    size = width (or height or depth) of texture

+ * Output:

+ *    i0, i1 = returns two nearest texel indexes

+ *    weight = returns blend factor between texels

+ */

+static INLINE void

+linear_texel_locations(GLenum wrapMode,

+                       const struct gl_texture_image *img,

+                       GLint size, GLfloat s,

+                       GLint *i0, GLint *i1, GLfloat *weight)

+{

+   GLfloat u;

+   switch (wrapMode) {

+   case GL_REPEAT:

+      u = s * size - 0.5F;

+      if (img->_IsPowerOfTwo) {

+         *i0 = IFLOOR(u) & (size - 1);

+         *i1 = (*i0 + 1) & (size - 1);

+      }

+      else {

+         *i0 = REMAINDER(IFLOOR(u), size);

+         *i1 = REMAINDER(*i0 + 1, size);

+      }

+      break;

+   case GL_CLAMP_TO_EDGE:

+      if (s <= 0.0F)

+         u = 0.0F;

+      else if (s >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u = s * size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      if (*i0 < 0)

+         *i0 = 0;

+      if (*i1 >= (GLint) size)

+         *i1 = size - 1;

+      break;

+   case GL_CLAMP_TO_BORDER:

+      {

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s <= min)

+            u = min * size;

+         else if (s >= max)

+            u = max * size;

+         else

+            u = s * size;

+         u -= 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+      }

+      break;

+   case GL_MIRRORED_REPEAT:

+      {

+         const GLint flr = IFLOOR(s);

+         if (flr & 1)

+            u = 1.0F - (s - (GLfloat) flr);

+         else

+            u = s - (GLfloat) flr;

+         u = (u * size) - 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+         if (*i0 < 0)

+            *i0 = 0;

+         if (*i1 >= (GLint) size)

+            *i1 = size - 1;

+      }

+      break;

+   case GL_MIRROR_CLAMP_EXT:

+      u = FABSF(s);

+      if (u >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u *= size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      break;

+   case GL_MIRROR_CLAMP_TO_EDGE_EXT:

+      u = FABSF(s);

+      if (u >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u *= size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      if (*i0 < 0)

+         *i0 = 0;

+      if (*i1 >= (GLint) size)

+         *i1 = size - 1;

+      break;

+   case GL_MIRROR_CLAMP_TO_BORDER_EXT:

+      {

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         u = FABSF(s);

+         if (u <= min)

+            u = min * size;

+         else if (u >= max)

+            u = max * size;

+         else

+            u *= size;

+         u -= 0.5F;

+         *i0 = IFLOOR(u);

+         *i1 = *i0 + 1;

+      }

+      break;

+   case GL_CLAMP:

+      if (s <= 0.0F)

+         u = 0.0F;

+      else if (s >= 1.0F)

+         u = (GLfloat) size;

+      else

+         u = s * size;

+      u -= 0.5F;

+      *i0 = IFLOOR(u);

+      *i1 = *i0 + 1;

+      break;

+   default:

+      _mesa_problem(NULL, "Bad wrap mode");

+      u = 0.0F;

+   }

+   *weight = FRAC(u);

+}

+

+

+/**

+ * Used to compute texel location for nearest sampling.

+ */

+static INLINE GLint

+nearest_texel_location(GLenum wrapMode,

+                       const struct gl_texture_image *img,

+                       GLint size, GLfloat s)

+{

+   GLint i;

+

+   switch (wrapMode) {

+   case GL_REPEAT:

+      /* s limited to [0,1) */

+      /* i limited to [0,size-1] */

+      i = IFLOOR(s * size);

+      if (img->_IsPowerOfTwo)

+         i &= (size - 1);

+      else

+         i = REMAINDER(i, size);

+      return i;

+   case GL_CLAMP_TO_EDGE:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s < min)

+            i = 0;

+         else if (s > max)

+            i = size - 1;

+         else

+            i = IFLOOR(s * size);

+      }

+      return i;

+   case GL_CLAMP_TO_BORDER:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [-1, size] */

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         if (s <= min)

+            i = -1;

+         else if (s >= max)

+            i = size;

+         else

+            i = IFLOOR(s * size);

+      }

+      return i;

+   case GL_MIRRORED_REPEAT:

+      {

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLint flr = IFLOOR(s);

+         GLfloat u;

+         if (flr & 1)

+            u = 1.0F - (s - (GLfloat) flr);

+         else

+            u = s - (GLfloat) flr;

+         if (u < min)

+            i = 0;

+         else if (u > max)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_EXT:

+      {

+         /* s limited to [0,1] */

+         /* i limited to [0,size-1] */

+         const GLfloat u = FABSF(s);

+         if (u <= 0.0F)

+            i = 0;

+         else if (u >= 1.0F)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_TO_EDGE_EXT:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = 1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLfloat u = FABSF(s);

+         if (u < min)

+            i = 0;

+         else if (u > max)

+            i = size - 1;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_MIRROR_CLAMP_TO_BORDER_EXT:

+      {

+         /* s limited to [min,max] */

+         /* i limited to [0, size-1] */

+         const GLfloat min = -1.0F / (2.0F * size);

+         const GLfloat max = 1.0F - min;

+         const GLfloat u = FABSF(s);

+         if (u < min)

+            i = -1;

+         else if (u > max)

+            i = size;

+         else

+            i = IFLOOR(u * size);

+      }

+      return i;

+   case GL_CLAMP:

+      /* s limited to [0,1] */

+      /* i limited to [0,size-1] */

+      if (s <= 0.0F)

+         i = 0;

+      else if (s >= 1.0F)

+         i = size - 1;

+      else

+         i = IFLOOR(s * size);

+      return i;

+   default:

+      _mesa_problem(NULL, "Bad wrap mode");

+      return 0;

+   }

+}

+

+

+/* Power of two image sizes only */

+static INLINE void

+linear_repeat_texel_location(GLuint size, GLfloat s,

+                             GLint *i0, GLint *i1, GLfloat *weight)

+{

+   GLfloat u = s * size - 0.5F;

+   *i0 = IFLOOR(u) & (size - 1);

+   *i1 = (*i0 + 1) & (size - 1);

+   *weight = FRAC(u);

+}

+

+

+/**

+ * Do clamp/wrap for a texture rectangle coord, GL_NEAREST filter mode.

+ */

+static INLINE GLint

+clamp_rect_coord_nearest(GLenum wrapMode, GLfloat coord, GLint max)

+{

+   switch (wrapMode) {

+   case GL_CLAMP:

+      return IFLOOR( CLAMP(coord, 0.0F, max - 1) );

+   case GL_CLAMP_TO_EDGE:

+      return IFLOOR( CLAMP(coord, 0.5F, max - 0.5F) );

+   case GL_CLAMP_TO_BORDER:

+      return IFLOOR( CLAMP(coord, -0.5F, max + 0.5F) );

+   default:

+      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_nearest");

+      return 0;

+   }

+}

+

+

+/**

+ * As above, but GL_LINEAR filtering.

+ */

+static INLINE void

+clamp_rect_coord_linear(GLenum wrapMode, GLfloat coord, GLint max,

+                        GLint *i0out, GLint *i1out, GLfloat *weight)

+{

+   GLfloat fcol;

+   GLint i0, i1;

+   switch (wrapMode) {

+   case GL_CLAMP:

+      /* Not exactly what the spec says, but it matches NVIDIA output */

+      fcol = CLAMP(coord - 0.5F, 0.0F, max - 1);

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      break;

+   case GL_CLAMP_TO_EDGE:

+      fcol = CLAMP(coord, 0.5F, max - 0.5F);

+      fcol -= 0.5F;

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      if (i1 > max - 1)

+         i1 = max - 1;

+      break;

+   case GL_CLAMP_TO_BORDER:

+      fcol = CLAMP(coord, -0.5F, max + 0.5F);

+      fcol -= 0.5F;

+      i0 = IFLOOR(fcol);

+      i1 = i0 + 1;

+      break;

+   default:

+      _mesa_problem(NULL, "bad wrapMode in clamp_rect_coord_linear");

+      i0 = i1 = 0;

+      fcol = 0.0F;

+   }

+   *i0out = i0;

+   *i1out = i1;

+   *weight = FRAC(fcol);

+}

+

+

+/**

+ * Compute slice/image to use for 1D or 2D array texture.

+ */

+static INLINE GLint

+tex_array_slice(GLfloat coord, GLsizei size)

+{

+   GLint slice = IFLOOR(coord + 0.5f);

+   slice = CLAMP(slice, 0, size - 1);

+   return slice;

+}

+

+

+/**

+ * Compute nearest integer texcoords for given texobj and coordinate.

+ * NOTE: only used for depth texture sampling.

+ */

+static INLINE void

+nearest_texcoord(const struct gl_texture_object *texObj,

+                 GLuint level,

+                 const GLfloat texcoord[4],

+                 GLint *i, GLint *j, GLint *k)

+{

+   const struct gl_texture_image *img = texObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+

+   switch (texObj->Target) {

+   case GL_TEXTURE_RECTANGLE_ARB:

+      *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width);

+      *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height);

+      *k = 0;

+      break;

+   case GL_TEXTURE_1D:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = 0;

+      *k = 0;

+      break;

+   case GL_TEXTURE_2D:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);

+      *k = 0;

+      break;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = tex_array_slice(texcoord[1], height);

+      *k = 0;

+      break;

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);

+      *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);

+      *k = tex_array_slice(texcoord[2], depth);

+      break;

+   default:

+      *i = *j = *k = 0;

+   }

+}

+

+

+/**

+ * Compute linear integer texcoords for given texobj and coordinate.

+ * NOTE: only used for depth texture sampling.

+ */

+static INLINE void

+linear_texcoord(const struct gl_texture_object *texObj,

+                GLuint level,

+                const GLfloat texcoord[4],

+                GLint *i0, GLint *i1, GLint *j0, GLint *j1, GLint *slice,

+                GLfloat *wi, GLfloat *wj)

+{

+   const struct gl_texture_image *img = texObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+

+   switch (texObj->Target) {

+   case GL_TEXTURE_RECTANGLE_ARB:

+      clamp_rect_coord_linear(texObj->WrapS, texcoord[0],

+                              width, i0, i1, wi);

+      clamp_rect_coord_linear(texObj->WrapT, texcoord[1],

+                              height, j0, j1, wj);

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      linear_texel_locations(texObj->WrapT, img, height,

+                             texcoord[1], j0, j1, wj);

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_1D_ARRAY_EXT:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      *j0 = tex_array_slice(texcoord[1], height);

+      *j1 = *j0;

+      *slice = 0;

+      break;

+

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      linear_texel_locations(texObj->WrapS, img, width,

+                             texcoord[0], i0, i1, wi);

+      linear_texel_locations(texObj->WrapT, img, height,

+                             texcoord[1], j0, j1, wj);

+      *slice = tex_array_slice(texcoord[2], depth);

+      break;

+

+   default:

+      *slice = 0;

+   }

+}

+

+

+

+/**

+ * For linear interpolation between mipmap levels N and N+1, this function

+ * computes N.

+ */

+static INLINE GLint

+linear_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   if (lambda < 0.0F)

+      return tObj->BaseLevel;

+   else if (lambda > tObj->_MaxLambda)

+      return (GLint) (tObj->BaseLevel + tObj->_MaxLambda);

+   else

+      return (GLint) (tObj->BaseLevel + lambda);

+}

+

+

+/**

+ * Compute the nearest mipmap level to take texels from.

+ */

+static INLINE GLint

+nearest_mipmap_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   GLfloat l;

+   GLint level;

+   if (lambda <= 0.5F)

+      l = 0.0F;

+   else if (lambda > tObj->_MaxLambda + 0.4999F)

+      l = tObj->_MaxLambda + 0.4999F;

+   else

+      l = lambda;

+   level = (GLint) (tObj->BaseLevel + l + 0.5F);

+   if (level > tObj->_MaxLevel)

+      level = tObj->_MaxLevel;

+   return level;

+}

+

+

+

+/*

+ * Bitflags for texture border color sampling.

+ */

+#define I0BIT   1

+#define I1BIT   2

+#define J0BIT   4

+#define J1BIT   8

+#define K0BIT  16

+#define K1BIT  32

+

+

+

+/**

+ * The lambda[] array values are always monotonic.  Either the whole span

+ * will be minified, magnified, or split between the two.  This function

+ * determines the subranges in [0, n-1] that are to be minified or magnified.

+ */

+static INLINE void

+compute_min_mag_ranges(const struct gl_texture_object *tObj,

+                       GLuint n, const GLfloat lambda[],

+                       GLuint *minStart, GLuint *minEnd,

+                       GLuint *magStart, GLuint *magEnd)

+{

+   GLfloat minMagThresh;

+

+   /* we shouldn't be here if minfilter == magfilter */

+   ASSERT(tObj->MinFilter != tObj->MagFilter);

+

+   /* This bit comes from the OpenGL spec: */

+   if (tObj->MagFilter == GL_LINEAR

+       && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||

+           tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {

+      minMagThresh = 0.5F;

+   }

+   else {

+      minMagThresh = 0.0F;

+   }

+

+#if 0

+   /* DEBUG CODE: Verify that lambda[] is monotonic.

+    * We can't really use this because the inaccuracy in the LOG2 function

+    * causes this test to fail, yet the resulting texturing is correct.

+    */

+   if (n > 1) {

+      GLuint i;

+      printf("lambda delta = %g\n", lambda[0] - lambda[n-1]);

+      if (lambda[0] >= lambda[n-1]) { /* decreasing */

+         for (i = 0; i < n - 1; i++) {

+            ASSERT((GLint) (lambda[i] * 10) >= (GLint) (lambda[i+1] * 10));

+         }

+      }

+      else { /* increasing */

+         for (i = 0; i < n - 1; i++) {

+            ASSERT((GLint) (lambda[i] * 10) <= (GLint) (lambda[i+1] * 10));

+         }

+      }

+   }

+#endif /* DEBUG */

+

+   if (lambda[0] <= minMagThresh && (n <= 1 || lambda[n-1] <= minMagThresh)) {

+      /* magnification for whole span */

+      *magStart = 0;

+      *magEnd = n;

+      *minStart = *minEnd = 0;

+   }

+   else if (lambda[0] > minMagThresh && (n <=1 || lambda[n-1] > minMagThresh)) {

+      /* minification for whole span */

+      *minStart = 0;

+      *minEnd = n;

+      *magStart = *magEnd = 0;

+   }

+   else {

+      /* a mix of minification and magnification */

+      GLuint i;

+      if (lambda[0] > minMagThresh) {

+         /* start with minification */

+         for (i = 1; i < n; i++) {

+            if (lambda[i] <= minMagThresh)

+               break;

+         }

+         *minStart = 0;

+         *minEnd = i;

+         *magStart = i;

+         *magEnd = n;

+      }

+      else {

+         /* start with magnification */

+         for (i = 1; i < n; i++) {

+            if (lambda[i] > minMagThresh)

+               break;

+         }

+         *magStart = 0;

+         *magEnd = i;

+         *minStart = i;

+         *minEnd = n;

+      }

+   }

+

+#if 0

+   /* Verify the min/mag Start/End values

+    * We don't use this either (see above)

+    */

+   {

+      GLint i;

+      for (i = 0; i < n; i++) {

+         if (lambda[i] > minMagThresh) {

+            /* minification */

+            ASSERT(i >= *minStart);

+            ASSERT(i < *minEnd);

+         }

+         else {

+            /* magnification */

+            ASSERT(i >= *magStart);

+            ASSERT(i < *magEnd);

+         }

+      }

+   }

+#endif

+}

+

+

+/**

+ * When we sample the border color, it must be interpreted according to

+ * the base texture format.  Ex: if the texture base format it GL_ALPHA,

+ * we return (0,0,0,BorderAlpha).

+ */

+static INLINE void

+get_border_color(const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 GLfloat rgba[4])

+{

+   switch (img->_BaseFormat) {

+   case GL_RGB:

+      rgba[0] = tObj->BorderColor.f[0];

+      rgba[1] = tObj->BorderColor.f[1];

+      rgba[2] = tObj->BorderColor.f[2];

+      rgba[3] = 1.0F;

+      break;

+   case GL_ALPHA:

+      rgba[0] = rgba[1] = rgba[2] = 0.0;

+      rgba[3] = tObj->BorderColor.f[3];

+      break;

+   case GL_LUMINANCE:

+      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];

+      rgba[3] = 1.0;

+      break;

+   case GL_LUMINANCE_ALPHA:

+      rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];

+      rgba[3] = tObj->BorderColor.f[3];

+      break;

+   case GL_INTENSITY:

+      rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor.f[0];

+      break;

+   default:

+      COPY_4V(rgba, tObj->BorderColor.f);

+   }

+}

+

+

+/**********************************************************************/

+/*                    1-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_1d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4], GLfloat rgba[4])

+{

+   const GLint width = img->Width2;  /* without border, power of two */

+   GLint i;

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   /* skip over the border, if any */

+   i += img->Border;

+   if (i < 0 || i >= (GLint) img->Width) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, 0, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s) using GL_LINEAR filter.

+ */

+static INLINE void

+sample_1d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4], GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   GLint i0, i1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a;

+   GLfloat t0[4], t1[4];  /* texels */

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+   }

+   else {

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+   }

+

+   /* fetch texel colors */

+   if (useBorderColor & I0BIT) {

+      get_border_color(tObj, img, t0);

+   }

+   else {

+      img->FetchTexelf(img, i0, 0, 0, t0);

+   }

+   if (useBorderColor & I1BIT) {

+      get_border_color(tObj, img, t1);

+   }

+   else {

+      img->FetchTexelf(img, i1, 0, 0, t1);

+   }

+

+   lerp_rgba(rgba, a, t0, t1);

+}

+

+

+static void

+sample_1d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_1d_linear_mipmap_linear(struct gl_context *ctx,

+                               const struct gl_texture_object *tObj,

+                               GLuint n, const GLfloat texcoord[][4],

+                               const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 1D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_1d( struct gl_context *ctx,

+                   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4], const GLfloat lambda[],

+                   GLfloat rgba[][4] )

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_1d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D texture, linear filtering for both min/magnification */

+static void

+sample_linear_1d( struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4], const GLfloat lambda[],

+                  GLfloat rgba[][4] )

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_1d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_1d( struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_1d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_1d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_1d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_1d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_1d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_1d_texture");

+         return;

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                    2-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+

+/**

+ * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_2d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4],

+                  GLfloat rgba[])

+{

+   const GLint width = img->Width2;    /* without border, power of two */

+   const GLint height = img->Height2;  /* without border, power of two */

+   GLint i, j;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+

+   /* skip over the border, if any */

+   i += img->Border;

+   j += img->Border;

+

+   if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.

+ * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.

+ */

+static INLINE void

+sample_2d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4],

+                 GLfloat rgba[])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   GLint i0, j0, i1, j1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b;

+   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+      j0 += img->Border;

+      j1 += img->Border;

+   }

+   else {

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+   }

+

+   /* fetch four texel colors */

+   if (useBorderColor & (I0BIT | J0BIT)) {

+      get_border_color(tObj, img, t00);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, 0, t00);

+   }

+   if (useBorderColor & (I1BIT | J0BIT)) {

+      get_border_color(tObj, img, t10);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, 0, t10);

+   }

+   if (useBorderColor & (I0BIT | J1BIT)) {

+      get_border_color(tObj, img, t01);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, 0, t01);

+   }

+   if (useBorderColor & (I1BIT | J1BIT)) {

+      get_border_color(tObj, img, t11);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, 0, t11);

+   }

+

+   lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);

+}

+

+

+/**

+ * As above, but we know WRAP_S == REPEAT and WRAP_T == REPEAT.

+ * We don't have to worry about the texture border.

+ */

+static INLINE void

+sample_2d_linear_repeat(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   GLint i0, j0, i1, j1;

+   GLfloat wi, wj;

+   GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */

+

+   (void) ctx;

+

+   ASSERT(tObj->WrapS == GL_REPEAT);

+   ASSERT(tObj->WrapT == GL_REPEAT);

+   ASSERT(img->Border == 0);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+   ASSERT(img->_IsPowerOfTwo);

+

+   linear_repeat_texel_location(width,  texcoord[0], &i0, &i1, &wi);

+   linear_repeat_texel_location(height, texcoord[1], &j0, &j1, &wj);

+

+   img->FetchTexelf(img, i0, j0, 0, t00);

+   img->FetchTexelf(img, i1, j0, 0, t10);

+   img->FetchTexelf(img, i0, j1, 0, t01);

+   img->FetchTexelf(img, i1, j1, 0, t11);

+

+   lerp_rgba_2d(rgba, wi, wj, t00, t10, t01, t11);

+}

+

+

+static void

+sample_2d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_2d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_linear( struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_2d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_linear_mipmap_linear_repeat(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   ASSERT(tObj->WrapS == GL_REPEAT);

+   ASSERT(tObj->WrapT == GL_REPEAT);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level  ],

+                                 texcoord[i], t0);

+         sample_2d_linear_repeat(ctx, tObj, tObj->Image[0][level+1],

+                                 texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 2D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_2d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_2d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 2D texture, linear filtering for both min/magnification */

+static void

+sample_linear_2d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4],

+                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   if (tObj->WrapS == GL_REPEAT &&

+       tObj->WrapT == GL_REPEAT &&

+       image->_IsPowerOfTwo &&

+       image->Border == 0) {

+      for (i = 0; i < n; i++) {

+         sample_2d_linear_repeat(ctx, tObj, image, texcoords[i], rgba[i]);

+      }

+   }

+   else {

+      for (i = 0; i < n; i++) {

+         sample_2d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+      }

+   }

+}

+

+

+/**

+ * Optimized 2-D texture sampling:

+ *    S and T wrap mode == GL_REPEAT

+ *    GL_NEAREST min/mag filter

+ *    No border, 

+ *    RowStride == Width,

+ *    Format = GL_RGB

+ */

+static void

+opt_sample_rgb_2d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  GLuint n, const GLfloat texcoords[][4],

+                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];

+   const GLfloat width = (GLfloat) img->Width;

+   const GLfloat height = (GLfloat) img->Height;

+   const GLint colMask = img->Width - 1;

+   const GLint rowMask = img->Height - 1;

+   const GLint shift = img->WidthLog2;

+   GLuint k;

+   (void) ctx;

+   (void) lambda;

+   ASSERT(tObj->WrapS==GL_REPEAT);

+   ASSERT(tObj->WrapT==GL_REPEAT);

+   ASSERT(img->Border==0);

+   ASSERT(img->TexFormat == MESA_FORMAT_RGB888);

+   ASSERT(img->_IsPowerOfTwo);

+

+   for (k=0; k<n; k++) {

+      GLint i = IFLOOR(texcoords[k][0] * width) & colMask;

+      GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;

+      GLint pos = (j << shift) | i;

+      GLubyte *texel = ((GLubyte *) img->Data) + 3*pos;

+      rgba[k][RCOMP] = UBYTE_TO_FLOAT(texel[2]);

+      rgba[k][GCOMP] = UBYTE_TO_FLOAT(texel[1]);

+      rgba[k][BCOMP] = UBYTE_TO_FLOAT(texel[0]);

+      rgba[k][ACOMP] = 1.0F;

+   }

+}

+

+

+/**

+ * Optimized 2-D texture sampling:

+ *    S and T wrap mode == GL_REPEAT

+ *    GL_NEAREST min/mag filter

+ *    No border

+ *    RowStride == Width,

+ *    Format = GL_RGBA

+ */

+static void

+opt_sample_rgba_2d(struct gl_context *ctx,

+                   const struct gl_texture_object *tObj,

+                   GLuint n, const GLfloat texcoords[][4],

+                   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][tObj->BaseLevel];

+   const GLfloat width = (GLfloat) img->Width;

+   const GLfloat height = (GLfloat) img->Height;

+   const GLint colMask = img->Width - 1;

+   const GLint rowMask = img->Height - 1;

+   const GLint shift = img->WidthLog2;

+   GLuint i;

+   (void) ctx;

+   (void) lambda;

+   ASSERT(tObj->WrapS==GL_REPEAT);

+   ASSERT(tObj->WrapT==GL_REPEAT);

+   ASSERT(img->Border==0);

+   ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888);

+   ASSERT(img->_IsPowerOfTwo);

+

+   for (i = 0; i < n; i++) {

+      const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;

+      const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;

+      const GLint pos = (row << shift) | col;

+      const GLuint texel = *((GLuint *) img->Data + pos);

+      rgba[i][RCOMP] = UBYTE_TO_FLOAT( (texel >> 24)        );

+      rgba[i][GCOMP] = UBYTE_TO_FLOAT( (texel >> 16) & 0xff );

+      rgba[i][BCOMP] = UBYTE_TO_FLOAT( (texel >>  8) & 0xff );

+      rgba[i][ACOMP] = UBYTE_TO_FLOAT( (texel      ) & 0xff );

+   }

+}

+

+

+/** Sample 2D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_2d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 GLuint n, const GLfloat texcoords[][4],

+                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *tImg = tObj->Image[0][tObj->BaseLevel];

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+

+   const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT)

+      && (tObj->WrapT == GL_REPEAT)

+      && (tImg->Border == 0 && (tImg->Width == tImg->RowStride))

+      && (tImg->_BaseFormat != GL_COLOR_INDEX)

+      && tImg->_IsPowerOfTwo;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         if (repeatNoBorderPOT) {

+            switch (tImg->TexFormat) {

+            case MESA_FORMAT_RGB888:

+               opt_sample_rgb_2d(ctx, tObj, m, texcoords + minStart,

+                                 NULL, rgba + minStart);

+               break;

+            case MESA_FORMAT_RGBA8888:

+	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + minStart,

+                                  NULL, rgba + minStart);

+               break;

+            default:

+               sample_nearest_2d(ctx, tObj, m, texcoords + minStart,

+                                 NULL, rgba + minStart );

+            }

+         }

+         else {

+            sample_nearest_2d(ctx, tObj, m, texcoords + minStart,

+                              NULL, rgba + minStart);

+         }

+         break;

+      case GL_LINEAR:

+	 sample_linear_2d(ctx, tObj, m, texcoords + minStart,

+			  NULL, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_2d_nearest_mipmap_nearest(ctx, tObj, m,

+                                          texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_2d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_2d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         if (repeatNoBorderPOT)

+            sample_2d_linear_mipmap_linear_repeat(ctx, tObj, m,

+                  texcoords + minStart, lambda + minStart, rgba + minStart);

+         else

+            sample_2d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_2d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      const GLuint m = magEnd - magStart;

+

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         if (repeatNoBorderPOT) {

+            switch (tImg->TexFormat) {

+            case MESA_FORMAT_RGB888:

+               opt_sample_rgb_2d(ctx, tObj, m, texcoords + magStart,

+                                 NULL, rgba + magStart);

+               break;

+            case MESA_FORMAT_RGBA8888:

+	       opt_sample_rgba_2d(ctx, tObj, m, texcoords + magStart,

+                                  NULL, rgba + magStart);

+               break;

+            default:

+               sample_nearest_2d(ctx, tObj, m, texcoords + magStart,

+                                 NULL, rgba + magStart );

+            }

+         }

+         else {

+            sample_nearest_2d(ctx, tObj, m, texcoords + magStart,

+                              NULL, rgba + magStart);

+         }

+         break;

+      case GL_LINEAR:

+	 sample_linear_2d(ctx, tObj, m, texcoords + magStart,

+			  NULL, rgba + magStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_lambda_2d");

+      }

+   }

+}

+

+

+

+/**********************************************************************/

+/*                    3-D Texture Sampling Functions                  */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static INLINE void

+sample_3d_nearest(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj,

+                  const struct gl_texture_image *img,

+                  const GLfloat texcoord[4],

+                  GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height2;   /* without border, power of two */

+   const GLint depth = img->Depth2;     /* without border, power of two */

+   GLint i, j, k;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+   k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       j < 0 || j >= (GLint) img->Height ||

+       k < 0 || k >= (GLint) img->Depth) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, k, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_3d_linear(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj,

+                 const struct gl_texture_image *img,

+                 const GLfloat texcoord[4],

+                 GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   const GLint depth = img->Depth2;

+   GLint i0, j0, k0, i1, j1, k1;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b, c;

+   GLfloat t000[4], t010[4], t001[4], t011[4];

+   GLfloat t100[4], t110[4], t101[4], t111[4];

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0],  &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+   linear_texel_locations(tObj->WrapR, img, depth, texcoord[2],  &k0, &k1, &c);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+      j0 += img->Border;

+      j1 += img->Border;

+      k0 += img->Border;

+      k1 += img->Border;

+   }

+   else {

+      /* check if sampling texture border color */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;

+      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;

+   }

+

+   /* Fetch texels */

+   if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {

+      get_border_color(tObj, img, t000);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, k0, t000);

+   }

+   if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {

+      get_border_color(tObj, img, t100);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, k0, t100);

+   }

+   if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {

+      get_border_color(tObj, img, t010);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, k0, t010);

+   }

+   if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {

+      get_border_color(tObj, img, t110);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, k0, t110);

+   }

+

+   if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {

+      get_border_color(tObj, img, t001);

+   }

+   else {

+      img->FetchTexelf(img, i0, j0, k1, t001);

+   }

+   if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {

+      get_border_color(tObj, img, t101);

+   }

+   else {

+      img->FetchTexelf(img, i1, j0, k1, t101);

+   }

+   if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {

+      get_border_color(tObj, img, t011);

+   }

+   else {

+      img->FetchTexelf(img, i0, j1, k1, t011);

+   }

+   if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {

+      get_border_color(tObj, img, t111);

+   }

+   else {

+      img->FetchTexelf(img, i1, j1, k1, t111);

+   }

+

+   /* trilinear interpolation of samples */

+   lerp_rgba_3d(rgba, a, b, c, t000, t100, t010, t110, t001, t101, t011, t111);

+}

+

+

+static void

+sample_3d_nearest_mipmap_nearest(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4] )

+{

+   GLuint i;

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_3d_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_3d_linear_mipmap_nearest(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_3d_linear(ctx, tObj, tObj->Image[0][level], texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_3d_nearest_mipmap_linear(struct gl_context *ctx,

+                                const struct gl_texture_object *tObj,

+                                GLuint n, const GLfloat texcoord[][4],

+                                const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                           texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_3d_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_3d_linear_mipmap_linear(struct gl_context *ctx,

+                               const struct gl_texture_object *tObj,

+                               GLuint n, const GLfloat texcoord[][4],

+                               const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_3d_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_3d_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 3D texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_3d(struct gl_context *ctx,

+                  const struct gl_texture_object *tObj, GLuint n,

+                  const GLfloat texcoords[][4], const GLfloat lambda[],

+                  GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_3d_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 3D texture, linear filtering for both min/magnification */

+static void

+sample_linear_3d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4],

+		 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_3d_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 3D texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_3d(struct gl_context *ctx,

+                 const struct gl_texture_object *tObj, GLuint n,

+                 const GLfloat texcoords[][4], const GLfloat lambda[],

+                 GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_3d_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_3d_linear_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_3d_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                         lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_3d_linear_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                        lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_3d_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_3d_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                             texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_3d_texture");

+         return;

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                Texture Cube Map Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Choose one of six sides of a texture cube map given the texture

+ * coord (rx,ry,rz).  Return pointer to corresponding array of texture

+ * images.

+ */

+static const struct gl_texture_image **

+choose_cube_face(const struct gl_texture_object *texObj,

+                 const GLfloat texcoord[4], GLfloat newCoord[4])

+{

+   /*

+      major axis

+      direction     target                             sc     tc    ma

+      ----------    -------------------------------    ---    ---   ---

+       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx

+       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx

+       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry

+       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry

+       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz

+       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz

+   */

+   const GLfloat rx = texcoord[0];

+   const GLfloat ry = texcoord[1];

+   const GLfloat rz = texcoord[2];

+   const GLfloat arx = FABSF(rx), ary = FABSF(ry), arz = FABSF(rz);

+   GLuint face;

+   GLfloat sc, tc, ma;

+

+   if (arx >= ary && arx >= arz) {

+      if (rx >= 0.0F) {

+         face = FACE_POS_X;

+         sc = -rz;

+         tc = -ry;

+         ma = arx;

+      }

+      else {

+         face = FACE_NEG_X;

+         sc = rz;

+         tc = -ry;

+         ma = arx;

+      }

+   }

+   else if (ary >= arx && ary >= arz) {

+      if (ry >= 0.0F) {

+         face = FACE_POS_Y;

+         sc = rx;

+         tc = rz;

+         ma = ary;

+      }

+      else {

+         face = FACE_NEG_Y;

+         sc = rx;

+         tc = -rz;

+         ma = ary;

+      }

+   }

+   else {

+      if (rz > 0.0F) {

+         face = FACE_POS_Z;

+         sc = rx;

+         tc = -ry;

+         ma = arz;

+      }

+      else {

+         face = FACE_NEG_Z;

+         sc = -rx;

+         tc = -ry;

+         ma = arz;

+      }

+   }

+

+   { 

+      const float ima = 1.0F / ma;

+      newCoord[0] = ( sc * ima + 1.0F ) * 0.5F;

+      newCoord[1] = ( tc * ima + 1.0F ) * 0.5F;

+   }

+

+   return (const struct gl_texture_image **) texObj->Image[face];

+}

+

+

+static void

+sample_nearest_cube(struct gl_context *ctx,

+		    const struct gl_texture_object *tObj, GLuint n,

+                    const GLfloat texcoords[][4], const GLfloat lambda[],

+                    GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      images = choose_cube_face(tObj, texcoords[i], newCoord);

+      sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],

+                        newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_linear_cube(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4],

+		   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      images = choose_cube_face(tObj, texcoords[i], newCoord);

+      sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],

+                       newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_nearest_mipmap_nearest(struct gl_context *ctx,

+                                   const struct gl_texture_object *tObj,

+                                   GLuint n, const GLfloat texcoord[][4],

+                                   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level;

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+

+      /* XXX we actually need to recompute lambda here based on the newCoords.

+       * But we would need the texcoords of adjacent fragments to compute that

+       * properly, and we don't have those here.

+       * For now, do an approximation:  subtracting 1 from the chosen mipmap

+       * level seems to work in some test cases.

+       * The same adjustment is done in the next few functions.

+      */

+      level = nearest_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0);

+

+      sample_2d_nearest(ctx, tObj, images[level], newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_linear_mipmap_nearest(struct gl_context *ctx,

+                                  const struct gl_texture_object *tObj,

+                                  GLuint n, const GLfloat texcoord[][4],

+                                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      sample_2d_linear(ctx, tObj, images[level], newCoord, rgba[i]);

+   }

+}

+

+

+static void

+sample_cube_nearest_mipmap_linear(struct gl_context *ctx,

+                                  const struct gl_texture_object *tObj,

+                                  GLuint n, const GLfloat texcoord[][4],

+                                  const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel],

+                           newCoord, rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_nearest(ctx, tObj, images[level  ], newCoord, t0);

+         sample_2d_nearest(ctx, tObj, images[level+1], newCoord, t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_cube_linear_mipmap_linear(struct gl_context *ctx,

+                                 const struct gl_texture_object *tObj,

+                                 GLuint n, const GLfloat texcoord[][4],

+                                 const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      const struct gl_texture_image **images;

+      GLfloat newCoord[4];

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      level = MAX2(level - 1, 0); /* see comment above */

+      images = choose_cube_face(tObj, texcoord[i], newCoord);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel],

+                          newCoord, rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_linear(ctx, tObj, images[level  ], newCoord, t0);

+         sample_2d_linear(ctx, tObj, images[level+1], newCoord, t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample cube texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_cube(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+		   const GLfloat texcoords[][4], const GLfloat lambda[],

+		   GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      const GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         sample_nearest_cube(ctx, tObj, m, texcoords + minStart,

+                             lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR:

+         sample_linear_cube(ctx, tObj, m, texcoords + minStart,

+                            lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_cube_nearest_mipmap_nearest(ctx, tObj, m,

+                                            texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_cube_linear_mipmap_nearest(ctx, tObj, m,

+                                           texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_cube_nearest_mipmap_linear(ctx, tObj, m,

+                                           texcoords + minStart,

+                                           lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_cube_linear_mipmap_linear(ctx, tObj, m,

+                                          texcoords + minStart,

+                                          lambda + minStart, rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_lambda_cube");

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      const GLuint m = magEnd - magStart;

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         sample_nearest_cube(ctx, tObj, m, texcoords + magStart,

+                             lambda + magStart, rgba + magStart);

+         break;

+      case GL_LINEAR:

+         sample_linear_cube(ctx, tObj, m, texcoords + magStart,

+                            lambda + magStart, rgba + magStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_lambda_cube");

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*               Texture Rectangle Sampling Functions                 */

+/**********************************************************************/

+

+

+static void

+sample_nearest_rect(struct gl_context *ctx,

+		    const struct gl_texture_object *tObj, GLuint n,

+                    const GLfloat texcoords[][4], const GLfloat lambda[],

+                    GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][0];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   GLuint i;

+

+   (void) ctx;

+   (void) lambda;

+

+   ASSERT(tObj->WrapS == GL_CLAMP ||

+          tObj->WrapS == GL_CLAMP_TO_EDGE ||

+          tObj->WrapS == GL_CLAMP_TO_BORDER);

+   ASSERT(tObj->WrapT == GL_CLAMP ||

+          tObj->WrapT == GL_CLAMP_TO_EDGE ||

+          tObj->WrapT == GL_CLAMP_TO_BORDER);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+

+   for (i = 0; i < n; i++) {

+      GLint row, col;

+      col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width);

+      row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height);

+      if (col < 0 || col >= width || row < 0 || row >= height)

+         get_border_color(tObj, img, rgba[i]);

+      else

+         img->FetchTexelf(img, col, row, 0, rgba[i]);

+   }

+}

+

+

+static void

+sample_linear_rect(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+                   const GLfloat texcoords[][4],

+		   const GLfloat lambda[], GLfloat rgba[][4])

+{

+   const struct gl_texture_image *img = tObj->Image[0][0];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   GLuint i;

+

+   (void) ctx;

+   (void) lambda;

+

+   ASSERT(tObj->WrapS == GL_CLAMP ||

+          tObj->WrapS == GL_CLAMP_TO_EDGE ||

+          tObj->WrapS == GL_CLAMP_TO_BORDER);

+   ASSERT(tObj->WrapT == GL_CLAMP ||

+          tObj->WrapT == GL_CLAMP_TO_EDGE ||

+          tObj->WrapT == GL_CLAMP_TO_BORDER);

+   ASSERT(img->_BaseFormat != GL_COLOR_INDEX);

+

+   for (i = 0; i < n; i++) {

+      GLint i0, j0, i1, j1;

+      GLfloat t00[4], t01[4], t10[4], t11[4];

+      GLfloat a, b;

+      GLbitfield useBorderColor = 0x0;

+

+      clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width,

+                              &i0, &i1, &a);

+      clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height,

+                              &j0, &j1, &b);

+

+      /* compute integer rows/columns */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+

+      /* get four texel samples */

+      if (useBorderColor & (I0BIT | J0BIT))

+         get_border_color(tObj, img, t00);

+      else

+         img->FetchTexelf(img, i0, j0, 0, t00);

+

+      if (useBorderColor & (I1BIT | J0BIT))

+         get_border_color(tObj, img, t10);

+      else

+         img->FetchTexelf(img, i1, j0, 0, t10);

+

+      if (useBorderColor & (I0BIT | J1BIT))

+         get_border_color(tObj, img, t01);

+      else

+         img->FetchTexelf(img, i0, j1, 0, t01);

+

+      if (useBorderColor & (I1BIT | J1BIT))

+         get_border_color(tObj, img, t11);

+      else

+         img->FetchTexelf(img, i1, j1, 0, t11);

+

+      lerp_rgba_2d(rgba[i], a, b, t00, t10, t01, t11);

+   }

+}

+

+

+/** Sample Rect texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_rect(struct gl_context *ctx,

+		   const struct gl_texture_object *tObj, GLuint n,

+		   const GLfloat texcoords[][4], const GLfloat lambda[],

+		   GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd, magStart, magEnd;

+

+   /* We only need lambda to decide between minification and magnification.

+    * There is no mipmapping with rectangular textures.

+    */

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      if (tObj->MinFilter == GL_NEAREST) {

+         sample_nearest_rect(ctx, tObj, minEnd - minStart,

+                             texcoords + minStart, NULL, rgba + minStart);

+      }

+      else {

+         sample_linear_rect(ctx, tObj, minEnd - minStart,

+                            texcoords + minStart, NULL, rgba + minStart);

+      }

+   }

+   if (magStart < magEnd) {

+      if (tObj->MagFilter == GL_NEAREST) {

+         sample_nearest_rect(ctx, tObj, magEnd - magStart,

+                             texcoords + magStart, NULL, rgba + magStart);

+      }

+      else {

+         sample_linear_rect(ctx, tObj, magEnd - magStart,

+                            texcoords + magStart, NULL, rgba + magStart);

+      }

+   }

+}

+

+

+/**********************************************************************/

+/*                2D Texture Array Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static void

+sample_2d_array_nearest(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height2;   /* without border, power of two */

+   const GLint depth = img->Depth;

+   GLint i, j;

+   GLint array;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);

+   array = tex_array_slice(texcoord[2], depth);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       j < 0 || j >= (GLint) img->Height ||

+       array < 0 || array >= (GLint) img->Depth) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, j, array, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_2d_array_linear(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj,

+                       const struct gl_texture_image *img,

+                       const GLfloat texcoord[4],

+                       GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height2;

+   const GLint depth = img->Depth;

+   GLint i0, j0, i1, j1;

+   GLint array;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a, b;

+   GLfloat t00[4], t01[4], t10[4], t11[4];

+

+   linear_texel_locations(tObj->WrapS, img, width,  texcoord[0], &i0, &i1, &a);

+   linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);

+   array = tex_array_slice(texcoord[2], depth);

+

+   if (array < 0 || array >= depth) {

+      COPY_4V(rgba, tObj->BorderColor.f);

+   }

+   else {

+      if (img->Border) {

+	 i0 += img->Border;

+	 i1 += img->Border;

+	 j0 += img->Border;

+	 j1 += img->Border;

+      }

+      else {

+	 /* check if sampling texture border color */

+	 if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+	 if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+	 if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;

+	 if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;

+      }

+

+      /* Fetch texels */

+      if (useBorderColor & (I0BIT | J0BIT)) {

+         get_border_color(tObj, img, t00);

+      }

+      else {

+	 img->FetchTexelf(img, i0, j0, array, t00);

+      }

+      if (useBorderColor & (I1BIT | J0BIT)) {

+         get_border_color(tObj, img, t10);

+      }

+      else {

+	 img->FetchTexelf(img, i1, j0, array, t10);

+      }

+      if (useBorderColor & (I0BIT | J1BIT)) {

+         get_border_color(tObj, img, t01);

+      }

+      else {

+	 img->FetchTexelf(img, i0, j1, array, t01);

+      }

+      if (useBorderColor & (I1BIT | J1BIT)) {

+         get_border_color(tObj, img, t11);

+      }

+      else {

+	 img->FetchTexelf(img, i1, j1, array, t11);

+      }

+      

+      /* trilinear interpolation of samples */

+      lerp_rgba_2d(rgba, a, b, t00, t10, t01, t11);

+   }

+}

+

+

+static void

+sample_2d_array_nearest_mipmap_nearest(struct gl_context *ctx,

+                                       const struct gl_texture_object *tObj,

+                                       GLuint n, const GLfloat texcoord[][4],

+                                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],

+                              rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_array_linear_mipmap_nearest(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_2d_array_linear(ctx, tObj, tObj->Image[0][level],

+                             texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_2d_array_nearest_mipmap_linear(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level  ],

+                                 texcoord[i], t0);

+         sample_2d_array_nearest(ctx, tObj, tObj->Image[0][level+1],

+                                 texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_2d_array_linear_mipmap_linear(struct gl_context *ctx,

+                                     const struct gl_texture_object *tObj,

+                                     GLuint n, const GLfloat texcoord[][4],

+                                     const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level  ],

+                                texcoord[i], t0);

+         sample_2d_array_linear(ctx, tObj, tObj->Image[0][level+1],

+                                texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 2D Array texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_2d_array(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj, GLuint n,

+                        const GLfloat texcoords[][4], const GLfloat lambda[],

+                        GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_2d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+

+/** Sample 2D Array texture, linear filtering for both min/magnification */

+static void

+sample_linear_2d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4],

+                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_2d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 2D Array texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_2d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4], const GLfloat lambda[],

+                       GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                    texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_2d_array_nearest_mipmap_nearest(ctx, tObj, m,

+                                                texcoords + minStart,

+                                                lambda + minStart,

+                                                rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_2d_array_linear_mipmap_nearest(ctx, tObj, m, 

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_2d_array_nearest_mipmap_linear(ctx, tObj, m,

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_2d_array_linear_mipmap_linear(ctx, tObj, m, 

+                                              texcoords + minStart,

+                                              lambda + minStart, 

+                                              rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_2d_array_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_2d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_2d_array_texture");

+         return;

+      }

+   }

+}

+

+

+

+

+/**********************************************************************/

+/*                1D Texture Array Sampling Functions                 */

+/**********************************************************************/

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.

+ */

+static void

+sample_1d_array_nearest(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj,

+                        const struct gl_texture_image *img,

+                        const GLfloat texcoord[4],

+                        GLfloat rgba[4])

+{

+   const GLint width = img->Width2;     /* without border, power of two */

+   const GLint height = img->Height;

+   GLint i;

+   GLint array;

+   (void) ctx;

+

+   i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);

+   array = tex_array_slice(texcoord[1], height);

+

+   if (i < 0 || i >= (GLint) img->Width ||

+       array < 0 || array >= (GLint) img->Height) {

+      /* Need this test for GL_CLAMP_TO_BORDER mode */

+      get_border_color(tObj, img, rgba);

+   }

+   else {

+      img->FetchTexelf(img, i, array, 0, rgba);

+   }

+}

+

+

+/**

+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.

+ */

+static void

+sample_1d_array_linear(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj,

+                       const struct gl_texture_image *img,

+                       const GLfloat texcoord[4],

+                       GLfloat rgba[4])

+{

+   const GLint width = img->Width2;

+   const GLint height = img->Height;

+   GLint i0, i1;

+   GLint array;

+   GLbitfield useBorderColor = 0x0;

+   GLfloat a;

+   GLfloat t0[4], t1[4];

+

+   linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);

+   array = tex_array_slice(texcoord[1], height);

+

+   if (img->Border) {

+      i0 += img->Border;

+      i1 += img->Border;

+   }

+   else {

+      /* check if sampling texture border color */

+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;

+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;

+   }

+

+   if (array < 0 || array >= height)   useBorderColor |= K0BIT;

+

+   /* Fetch texels */

+   if (useBorderColor & (I0BIT | K0BIT)) {

+      get_border_color(tObj, img, t0);

+   }

+   else {

+      img->FetchTexelf(img, i0, array, 0, t0);

+   }

+   if (useBorderColor & (I1BIT | K0BIT)) {

+      get_border_color(tObj, img, t1);

+   }

+   else {

+      img->FetchTexelf(img, i1, array, 0, t1);

+   }

+

+   /* bilinear interpolation of samples */

+   lerp_rgba(rgba, a, t0, t1);

+}

+

+

+static void

+sample_1d_array_nearest_mipmap_nearest(struct gl_context *ctx,

+                                       const struct gl_texture_object *tObj,

+                                       GLuint n, const GLfloat texcoord[][4],

+                                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level], texcoord[i],

+                              rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_array_linear_mipmap_nearest(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = nearest_mipmap_level(tObj, lambda[i]);

+      sample_1d_array_linear(ctx, tObj, tObj->Image[0][level],

+                             texcoord[i], rgba[i]);

+   }

+}

+

+

+static void

+sample_1d_array_nearest_mipmap_linear(struct gl_context *ctx,

+                                      const struct gl_texture_object *tObj,

+                                      GLuint n, const GLfloat texcoord[][4],

+                                      const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                                 texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_array_nearest(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+static void

+sample_1d_array_linear_mipmap_linear(struct gl_context *ctx,

+                                     const struct gl_texture_object *tObj,

+                                     GLuint n, const GLfloat texcoord[][4],

+                                     const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   ASSERT(lambda != NULL);

+   for (i = 0; i < n; i++) {

+      GLint level = linear_mipmap_level(tObj, lambda[i]);

+      if (level >= tObj->_MaxLevel) {

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->_MaxLevel],

+                          texcoord[i], rgba[i]);

+      }

+      else {

+         GLfloat t0[4], t1[4];  /* texels */

+         const GLfloat f = FRAC(lambda[i]);

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level  ], texcoord[i], t0);

+         sample_1d_array_linear(ctx, tObj, tObj->Image[0][level+1], texcoord[i], t1);

+         lerp_rgba(rgba[i], f, t0, t1);

+      }

+   }

+}

+

+

+/** Sample 1D Array texture, nearest filtering for both min/magnification */

+static void

+sample_nearest_1d_array(struct gl_context *ctx,

+                        const struct gl_texture_object *tObj, GLuint n,

+                        const GLfloat texcoords[][4], const GLfloat lambda[],

+                        GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_1d_array_nearest(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D Array texture, linear filtering for both min/magnification */

+static void

+sample_linear_1d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4],

+                       const GLfloat lambda[], GLfloat rgba[][4])

+{

+   GLuint i;

+   struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      sample_1d_array_linear(ctx, tObj, image, texcoords[i], rgba[i]);

+   }

+}

+

+

+/** Sample 1D Array texture, using lambda to choose between min/magnification */

+static void

+sample_lambda_1d_array(struct gl_context *ctx,

+                       const struct gl_texture_object *tObj, GLuint n,

+                       const GLfloat texcoords[][4], const GLfloat lambda[],

+                       GLfloat rgba[][4])

+{

+   GLuint minStart, minEnd;  /* texels with minification */

+   GLuint magStart, magEnd;  /* texels with magnification */

+   GLuint i;

+

+   ASSERT(lambda != NULL);

+   compute_min_mag_ranges(tObj, n, lambda,

+                          &minStart, &minEnd, &magStart, &magEnd);

+

+   if (minStart < minEnd) {

+      /* do the minified texels */

+      GLuint m = minEnd - minStart;

+      switch (tObj->MinFilter) {

+      case GL_NEAREST:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                    texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = minStart; i < minEnd; i++)

+            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      case GL_NEAREST_MIPMAP_NEAREST:

+         sample_1d_array_nearest_mipmap_nearest(ctx, tObj, m, texcoords + minStart,

+                                                lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_NEAREST:

+         sample_1d_array_linear_mipmap_nearest(ctx, tObj, m, 

+                                               texcoords + minStart,

+                                               lambda + minStart,

+                                               rgba + minStart);

+         break;

+      case GL_NEAREST_MIPMAP_LINEAR:

+         sample_1d_array_nearest_mipmap_linear(ctx, tObj, m, texcoords + minStart,

+                                               lambda + minStart, rgba + minStart);

+         break;

+      case GL_LINEAR_MIPMAP_LINEAR:

+         sample_1d_array_linear_mipmap_linear(ctx, tObj, m, 

+                                              texcoords + minStart,

+                                              lambda + minStart, 

+                                              rgba + minStart);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad min filter in sample_1d_array_texture");

+         return;

+      }

+   }

+

+   if (magStart < magEnd) {

+      /* do the magnified texels */

+      switch (tObj->MagFilter) {

+      case GL_NEAREST:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                              texcoords[i], rgba[i]);

+         break;

+      case GL_LINEAR:

+         for (i = magStart; i < magEnd; i++)

+            sample_1d_array_linear(ctx, tObj, tObj->Image[0][tObj->BaseLevel],

+                                   texcoords[i], rgba[i]);

+         break;

+      default:

+         _mesa_problem(ctx, "Bad mag filter in sample_1d_array_texture");

+         return;

+      }

+   }

+}

+

+

+/**

+ * Compare texcoord against depth sample.  Return 1.0 or the ambient value.

+ */

+static INLINE GLfloat

+shadow_compare(GLenum function, GLfloat coord, GLfloat depthSample,

+               GLfloat ambient)

+{

+   switch (function) {

+   case GL_LEQUAL:

+      return (coord <= depthSample) ? 1.0F : ambient;

+   case GL_GEQUAL:

+      return (coord >= depthSample) ? 1.0F : ambient;

+   case GL_LESS:

+      return (coord < depthSample) ? 1.0F : ambient;

+   case GL_GREATER:

+      return (coord > depthSample) ? 1.0F : ambient;

+   case GL_EQUAL:

+      return (coord == depthSample) ? 1.0F : ambient;

+   case GL_NOTEQUAL:

+      return (coord != depthSample) ? 1.0F : ambient;

+   case GL_ALWAYS:

+      return 1.0F;

+   case GL_NEVER:

+      return ambient;

+   case GL_NONE:

+      return depthSample;

+   default:

+      _mesa_problem(NULL, "Bad compare func in shadow_compare");

+      return ambient;

+   }

+}

+

+

+/**

+ * Compare texcoord against four depth samples.

+ */

+static INLINE GLfloat

+shadow_compare4(GLenum function, GLfloat coord,

+                GLfloat depth00, GLfloat depth01,

+                GLfloat depth10, GLfloat depth11,

+                GLfloat ambient, GLfloat wi, GLfloat wj)

+{

+   const GLfloat d = (1.0F - (GLfloat) ambient) * 0.25F;

+   GLfloat luminance = 1.0F;

+

+   switch (function) {

+   case GL_LEQUAL:

+      if (coord > depth00)  luminance -= d;

+      if (coord > depth01)  luminance -= d;

+      if (coord > depth10)  luminance -= d;

+      if (coord > depth11)  luminance -= d;

+      return luminance;

+   case GL_GEQUAL:

+      if (coord < depth00)  luminance -= d;

+      if (coord < depth01)  luminance -= d;

+      if (coord < depth10)  luminance -= d;

+      if (coord < depth11)  luminance -= d;

+      return luminance;

+   case GL_LESS:

+      if (coord >= depth00)  luminance -= d;

+      if (coord >= depth01)  luminance -= d;

+      if (coord >= depth10)  luminance -= d;

+      if (coord >= depth11)  luminance -= d;

+      return luminance;

+   case GL_GREATER:

+      if (coord <= depth00)  luminance -= d;

+      if (coord <= depth01)  luminance -= d;

+      if (coord <= depth10)  luminance -= d;

+      if (coord <= depth11)  luminance -= d;

+      return luminance;

+   case GL_EQUAL:

+      if (coord != depth00)  luminance -= d;

+      if (coord != depth01)  luminance -= d;

+      if (coord != depth10)  luminance -= d;

+      if (coord != depth11)  luminance -= d;

+      return luminance;

+   case GL_NOTEQUAL:

+      if (coord == depth00)  luminance -= d;

+      if (coord == depth01)  luminance -= d;

+      if (coord == depth10)  luminance -= d;

+      if (coord == depth11)  luminance -= d;

+      return luminance;

+   case GL_ALWAYS:

+      return 1.0F;

+   case GL_NEVER:

+      return ambient;

+   case GL_NONE:

+      /* ordinary bilinear filtering */

+      return lerp_2d(wi, wj, depth00, depth10, depth01, depth11);

+   default:

+      _mesa_problem(NULL, "Bad compare func in sample_compare4");

+      return ambient;

+   }

+}

+

+

+/**

+ * Choose the mipmap level to use when sampling from a depth texture.

+ */

+static int

+choose_depth_texture_level(const struct gl_texture_object *tObj, GLfloat lambda)

+{

+   GLint level;

+

+   if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {

+      /* no mipmapping - use base level */

+      level = tObj->BaseLevel;

+   }

+   else {

+      /* choose mipmap level */

+      lambda = CLAMP(lambda, tObj->MinLod, tObj->MaxLod);

+      level = (GLint) lambda;

+      level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel);

+   }

+

+   return level;

+}

+

+

+/**

+ * Sample a shadow/depth texture.  This function is incomplete.  It doesn't

+ * check for minification vs. magnification, etc.

+ */

+static void

+sample_depth_texture( struct gl_context *ctx,

+                      const struct gl_texture_object *tObj, GLuint n,

+                      const GLfloat texcoords[][4], const GLfloat lambda[],

+                      GLfloat texel[][4] )

+{

+   const GLint level = choose_depth_texture_level(tObj, lambda[0]);

+   const struct gl_texture_image *img = tObj->Image[0][level];

+   const GLint width = img->Width;

+   const GLint height = img->Height;

+   const GLint depth = img->Depth;

+   const GLuint compare_coord = (tObj->Target == GL_TEXTURE_2D_ARRAY_EXT)

+       ? 3 : 2;

+   GLfloat ambient;

+   GLenum function;

+   GLfloat result;

+

+   ASSERT(img->_BaseFormat == GL_DEPTH_COMPONENT ||

+          img->_BaseFormat == GL_DEPTH_STENCIL_EXT);

+

+   ASSERT(tObj->Target == GL_TEXTURE_1D ||

+          tObj->Target == GL_TEXTURE_2D ||

+          tObj->Target == GL_TEXTURE_RECTANGLE_NV ||

+          tObj->Target == GL_TEXTURE_1D_ARRAY_EXT ||

+          tObj->Target == GL_TEXTURE_2D_ARRAY_EXT);

+

+   ambient = tObj->CompareFailValue;

+

+   /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */

+

+   function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?

+      tObj->CompareFunc : GL_NONE;

+

+   if (tObj->MagFilter == GL_NEAREST) {

+      GLuint i;

+      for (i = 0; i < n; i++) {

+         GLfloat depthSample, depthRef;

+         GLint col, row, slice;

+

+         nearest_texcoord(tObj, level, texcoords[i], &col, &row, &slice);

+

+         if (col >= 0 && row >= 0 && col < width && row < height && 

+             slice >= 0 && slice < depth) {

+            img->FetchTexelf(img, col, row, slice, &depthSample);

+         }

+         else {

+            depthSample = tObj->BorderColor.f[0];

+         }

+

+         depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F);

+

+         result = shadow_compare(function, depthRef, depthSample, ambient);

+

+         switch (tObj->DepthMode) {

+         case GL_LUMINANCE:

+            ASSIGN_4V(texel[i], result, result, result, 1.0F);

+            break;

+         case GL_INTENSITY:

+            ASSIGN_4V(texel[i], result, result, result, result);

+            break;

+         case GL_ALPHA:

+            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);

+            break;

+         case GL_RED:

+            ASSIGN_4V(texel[i], result, 0.0F, 0.0F, 1.0F);

+            break;

+         default:

+            _mesa_problem(ctx, "Bad depth texture mode");

+         }

+      }

+   }

+   else {

+      GLuint i;

+      ASSERT(tObj->MagFilter == GL_LINEAR);

+      for (i = 0; i < n; i++) {

+         GLfloat depth00, depth01, depth10, depth11, depthRef;

+         GLint i0, i1, j0, j1;

+         GLint slice;

+         GLfloat wi, wj;

+         GLuint useBorderTexel;

+

+         linear_texcoord(tObj, level, texcoords[i], &i0, &i1, &j0, &j1, &slice,

+                         &wi, &wj);

+

+         useBorderTexel = 0;

+         if (img->Border) {

+            i0 += img->Border;

+            i1 += img->Border;

+            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {

+               j0 += img->Border;

+               j1 += img->Border;

+            }

+         }

+         else {

+            if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;

+            if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;

+            if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;

+            if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;

+         }

+

+         if (slice < 0 || slice >= (GLint) depth) {

+            depth00 = tObj->BorderColor.f[0];

+            depth01 = tObj->BorderColor.f[0];

+            depth10 = tObj->BorderColor.f[0];

+            depth11 = tObj->BorderColor.f[0];

+         }

+         else {

+            /* get four depth samples from the texture */

+            if (useBorderTexel & (I0BIT | J0BIT)) {

+               depth00 = tObj->BorderColor.f[0];

+            }

+            else {

+               img->FetchTexelf(img, i0, j0, slice, &depth00);

+            }

+            if (useBorderTexel & (I1BIT | J0BIT)) {

+               depth10 = tObj->BorderColor.f[0];

+            }

+            else {

+               img->FetchTexelf(img, i1, j0, slice, &depth10);

+            }

+

+            if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {

+               if (useBorderTexel & (I0BIT | J1BIT)) {

+                  depth01 = tObj->BorderColor.f[0];

+               }

+               else {

+                  img->FetchTexelf(img, i0, j1, slice, &depth01);

+               }

+               if (useBorderTexel & (I1BIT | J1BIT)) {

+                  depth11 = tObj->BorderColor.f[0];

+               }

+               else {

+                  img->FetchTexelf(img, i1, j1, slice, &depth11);

+               }

+            }

+            else {

+               depth01 = depth00;

+               depth11 = depth10;

+            }

+         }

+

+         depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F);

+

+         result = shadow_compare4(function, depthRef,

+                                  depth00, depth01, depth10, depth11,

+                                  ambient, wi, wj);

+

+         switch (tObj->DepthMode) {

+         case GL_LUMINANCE:

+            ASSIGN_4V(texel[i], result, result, result, 1.0F);

+            break;

+         case GL_INTENSITY:

+            ASSIGN_4V(texel[i], result, result, result, result);

+            break;

+         case GL_ALPHA:

+            ASSIGN_4V(texel[i], 0.0F, 0.0F, 0.0F, result);

+            break;

+         default:

+            _mesa_problem(ctx, "Bad depth texture mode");

+         }

+

+      }  /* for */

+   }  /* if filter */

+}

+

+

+/**

+ * We use this function when a texture object is in an "incomplete" state.

+ * When a fragment program attempts to sample an incomplete texture we

+ * return black (see issue 23 in GL_ARB_fragment_program spec).

+ * Note: fragment programs don't observe the texture enable/disable flags.

+ */

+static void

+null_sample_func( struct gl_context *ctx,

+		  const struct gl_texture_object *tObj, GLuint n,

+		  const GLfloat texcoords[][4], const GLfloat lambda[],

+		  GLfloat rgba[][4])

+{

+   GLuint i;

+   (void) ctx;

+   (void) tObj;

+   (void) texcoords;

+   (void) lambda;

+   for (i = 0; i < n; i++) {

+      rgba[i][RCOMP] = 0;

+      rgba[i][GCOMP] = 0;

+      rgba[i][BCOMP] = 0;

+      rgba[i][ACOMP] = 1.0;

+   }

+}

+

+

+/**

+ * Choose the texture sampling function for the given texture object.

+ */

+texture_sample_func

+_swrast_choose_texture_sample_func( struct gl_context *ctx,

+				    const struct gl_texture_object *t )

+{

+   if (!t || !t->_Complete) {

+      return &null_sample_func;

+   }

+   else {

+      const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);

+      const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat;

+

+      switch (t->Target) {

+      case GL_TEXTURE_1D:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_1d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_1d;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_1d;

+         }

+      case GL_TEXTURE_2D:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_2d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_2d;

+         }

+         else {

+            /* check for a few optimized cases */

+            const struct gl_texture_image *img = t->Image[0][t->BaseLevel];

+            ASSERT(t->MinFilter == GL_NEAREST);

+            if (t->WrapS == GL_REPEAT &&

+                t->WrapT == GL_REPEAT &&

+                img->_IsPowerOfTwo &&

+                img->Border == 0 &&

+                img->TexFormat == MESA_FORMAT_RGB888) {

+               return &opt_sample_rgb_2d;

+            }

+            else if (t->WrapS == GL_REPEAT &&

+                     t->WrapT == GL_REPEAT &&

+                     img->_IsPowerOfTwo &&

+                     img->Border == 0 &&

+                     img->TexFormat == MESA_FORMAT_RGBA8888) {

+               return &opt_sample_rgba_2d;

+            }

+            else {

+               return &sample_nearest_2d;

+            }

+         }

+      case GL_TEXTURE_3D:

+         if (needLambda) {

+            return &sample_lambda_3d;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_3d;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_3d;

+         }

+      case GL_TEXTURE_CUBE_MAP:

+         if (needLambda) {

+            return &sample_lambda_cube;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_cube;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_cube;

+         }

+      case GL_TEXTURE_RECTANGLE_NV:

+         if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {

+            return &sample_depth_texture;

+         }

+         else if (needLambda) {

+            return &sample_lambda_rect;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_rect;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_rect;

+         }

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         if (needLambda) {

+            return &sample_lambda_1d_array;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_1d_array;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_1d_array;

+         }

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         if (needLambda) {

+            return &sample_lambda_2d_array;

+         }

+         else if (t->MinFilter == GL_LINEAR) {

+            return &sample_linear_2d_array;

+         }

+         else {

+            ASSERT(t->MinFilter == GL_NEAREST);

+            return &sample_nearest_2d_array;

+         }

+      default:

+         _mesa_problem(ctx,

+                       "invalid target in _swrast_choose_texture_sample_func");

+         return &null_sample_func;

+      }

+   }

+}

diff --git a/mesalib/src/mesa/tnl/t_draw.c b/mesalib/src/mesa/tnl/t_draw.c
index b1967e654..a2ca6225b 100644
--- a/mesalib/src/mesa/tnl/t_draw.c
+++ b/mesalib/src/mesa/tnl/t_draw.c
@@ -1,534 +1,534 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-#include "main/glheader.h"
-#include "main/condrender.h"
-#include "main/context.h"
-#include "main/imports.h"
-#include "main/mtypes.h"
-#include "main/macros.h"
-#include "main/enums.h"
-
-#include "t_context.h"
-#include "tnl.h"
-
-
-
-static GLubyte *get_space(struct gl_context *ctx, GLuint bytes)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   GLubyte *space = malloc(bytes);
-   
-   tnl->block[tnl->nr_blocks++] = space;
-   return space;
-}
-
-
-static void free_space(struct gl_context *ctx)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   GLuint i;
-   for (i = 0; i < tnl->nr_blocks; i++)
-      free(tnl->block[i]);
-   tnl->nr_blocks = 0;
-}
-
-
-/* Convert the incoming array to GLfloats.  Understands the
- * array->Normalized flag and selects the correct conversion method.
- */
-#define CONVERT( TYPE, MACRO ) do {		\
-   GLuint i, j;					\
-   if (input->Normalized) {			\
-      for (i = 0; i < count; i++) {		\
-	 const TYPE *in = (TYPE *)ptr;		\
-	 for (j = 0; j < sz; j++) {		\
-	    *fptr++ = MACRO(*in);		\
-	    in++;				\
-	 }					\
-	 ptr += input->StrideB;			\
-      }						\
-   } else {					\
-      for (i = 0; i < count; i++) {		\
-	 const TYPE *in = (TYPE *)ptr;		\
-	 for (j = 0; j < sz; j++) {		\
-	    *fptr++ = (GLfloat)(*in);		\
-	    in++;				\
-	 }					\
-	 ptr += input->StrideB;			\
-      }						\
-   }						\
-} while (0)
-
-
-/**
- * Convert array of BGRA/GLubyte[4] values to RGBA/float[4]
- * \param ptr  input/ubyte array
- * \param fptr  output/float array
- */
-static void
-convert_bgra_to_float(const struct gl_client_array *input,
-                      const GLubyte *ptr, GLfloat *fptr,
-                      GLuint count )
-{
-   GLuint i;
-   assert(input->Normalized);
-   assert(input->Size == 4);
-   for (i = 0; i < count; i++) {
-      const GLubyte *in = (GLubyte *) ptr;  /* in is in BGRA order */
-      *fptr++ = UBYTE_TO_FLOAT(in[2]);  /* red */
-      *fptr++ = UBYTE_TO_FLOAT(in[1]);  /* green */
-      *fptr++ = UBYTE_TO_FLOAT(in[0]);  /* blue */
-      *fptr++ = UBYTE_TO_FLOAT(in[3]);  /* alpha */
-      ptr += input->StrideB;
-   }
-}
-
-static void
-convert_half_to_float(const struct gl_client_array *input,
-		      const GLubyte *ptr, GLfloat *fptr,
-		      GLuint count, GLuint sz)
-{
-   GLuint i, j;
-
-   for (i = 0; i < count; i++) {
-      GLhalfARB *in = (GLhalfARB *)ptr;
-
-      for (j = 0; j < sz; j++) {
-	 *fptr++ = _mesa_half_to_float(in[j]);
-      }
-      ptr += input->StrideB;
-   }
-}
-
-/**
- * \brief Convert fixed-point to floating-point.
- *
- * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled
- * integer" (Table 2.2 of the OpenGL ES 2.0 spec).
- *
- * If the buffer has the \c normalized flag set, the formula
- *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode
- * is used to map the fixed-point numbers into the range [-1, 1].
- */
-static void
-convert_fixed_to_float(const struct gl_client_array *input,
-                       const GLubyte *ptr, GLfloat *fptr,
-                       GLuint count)
-{
-   GLuint i, j;
-   const GLint size = input->Size;
-
-   if (input->Normalized) {
-      for (i = 0; i < count; ++i) {
-         const GLfixed *in = (GLfixed *) ptr;
-         for (j = 0; j < size; ++j) {
-            *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);
-         }
-         ptr += input->StrideB;
-      }
-   } else {
-      for (i = 0; i < count; ++i) {
-         const GLfixed *in = (GLfixed *) ptr;
-         for (j = 0; j < size; ++j) {
-            *fptr++ = in[j] / (GLfloat) (1 << 16);
-         }
-         ptr += input->StrideB;
-      }
-   }
-}
-
-/* Adjust pointer to point at first requested element, convert to
- * floating point, populate VB->AttribPtr[].
- */
-static void _tnl_import_array( struct gl_context *ctx,
-			       GLuint attrib,
-			       GLuint count,
-			       const struct gl_client_array *input,
-			       const GLubyte *ptr )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLuint stride = input->StrideB;
-
-   if (input->Type != GL_FLOAT) {
-      const GLuint sz = input->Size;
-      GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));
-      GLfloat *fptr = (GLfloat *)buf;
-
-      switch (input->Type) {
-      case GL_BYTE: 
-	 CONVERT(GLbyte, BYTE_TO_FLOAT); 
-	 break;
-      case GL_UNSIGNED_BYTE: 
-         if (input->Format == GL_BGRA) {
-            /* See GL_EXT_vertex_array_bgra */
-            convert_bgra_to_float(input, ptr, fptr, count);
-         }
-         else {
-            CONVERT(GLubyte, UBYTE_TO_FLOAT); 
-         }
-	 break;
-      case GL_SHORT: 
-	 CONVERT(GLshort, SHORT_TO_FLOAT); 
-	 break;
-      case GL_UNSIGNED_SHORT: 
-	 CONVERT(GLushort, USHORT_TO_FLOAT); 
-	 break;
-      case GL_INT: 
-	 CONVERT(GLint, INT_TO_FLOAT); 
-	 break;
-      case GL_UNSIGNED_INT: 
-	 CONVERT(GLuint, UINT_TO_FLOAT); 
-	 break;
-      case GL_DOUBLE: 
-	 CONVERT(GLdouble, (GLfloat)); 
-	 break;
-      case GL_HALF_FLOAT:
-	 convert_half_to_float(input, ptr, fptr, count, sz);
-	 break;
-      case GL_FIXED:
-         convert_fixed_to_float(input, ptr, fptr, count);
-         break;
-      default:
-	 assert(0);
-	 break;
-      }
-
-      ptr = buf;
-      stride = sz * sizeof(GLfloat);
-   }
-
-   VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];
-   VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;
-   VB->AttribPtr[attrib]->start = (GLfloat *)ptr;
-   VB->AttribPtr[attrib]->count = count;
-   VB->AttribPtr[attrib]->stride = stride;
-   VB->AttribPtr[attrib]->size = input->Size;
-
-   /* This should die, but so should the whole GLvector4f concept: 
-    */
-   VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) | 
-				   VEC_NOT_WRITEABLE |
-				   (stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));
-   
-   VB->AttribPtr[attrib]->storage = NULL;
-}
-
-#define CLIPVERTS  ((6 + MAX_CLIP_PLANES) * 2)
-
-
-static GLboolean *_tnl_import_edgeflag( struct gl_context *ctx,
-					const GLvector4f *input,
-					GLuint count)
-{
-   const GLubyte *ptr = (const GLubyte *)input->data;
-   const GLuint stride = input->stride;
-   GLboolean *space = (GLboolean *)get_space(ctx, count + CLIPVERTS);
-   GLboolean *bptr = space;
-   GLuint i;
-
-   for (i = 0; i < count; i++) {
-      *bptr++ = ((GLfloat *)ptr)[0] == 1.0;
-      ptr += stride;
-   }
-
-   return space;
-}
-
-
-static void bind_inputs( struct gl_context *ctx, 
-			 const struct gl_client_array *inputs[],
-			 GLint count,
-			 struct gl_buffer_object **bo,
-			 GLuint *nr_bo )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLuint i;
-
-   /* Map all the VBOs
-    */
-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
-      const void *ptr;
-
-      if (inputs[i]->BufferObj->Name) { 
-	 if (!inputs[i]->BufferObj->Pointer) {
-	    bo[*nr_bo] = inputs[i]->BufferObj;
-	    (*nr_bo)++;
-	    ctx->Driver.MapBuffer(ctx, 
-				  GL_ARRAY_BUFFER,
-				  GL_READ_ONLY_ARB,
-				  inputs[i]->BufferObj);
-	    
-	    assert(inputs[i]->BufferObj->Pointer);
-	 }
-	 
-	 ptr = ADD_POINTERS(inputs[i]->BufferObj->Pointer,
-			    inputs[i]->Ptr);
-      }
-      else
-	 ptr = inputs[i]->Ptr;
-
-      /* Just make sure the array is floating point, otherwise convert to
-       * temporary storage.  
-       *
-       * XXX: remove the GLvector4f type at some stage and just use
-       * client arrays.
-       */
-      _tnl_import_array(ctx, i, count, inputs[i], ptr);
-   }
-
-   /* We process only the vertices between min & max index:
-    */
-   VB->Count = count;
-
-   /* These should perhaps be part of _TNL_ATTRIB_* */
-   VB->BackfaceColorPtr = NULL;
-   VB->BackfaceIndexPtr = NULL;
-   VB->BackfaceSecondaryColorPtr = NULL;
-
-   /* Clipping and drawing code still requires this to be a packed
-    * array of ubytes which can be written into.  TODO: Fix and
-    * remove.
-    */
-   if (ctx->Polygon.FrontMode != GL_FILL ||
-       ctx->Polygon.BackMode != GL_FILL)
-   {
-      VB->EdgeFlag = _tnl_import_edgeflag( ctx, 
-					   VB->AttribPtr[_TNL_ATTRIB_EDGEFLAG],
-					   VB->Count );
-   }
-   else {
-      /* the data previously pointed to by EdgeFlag may have been freed */
-      VB->EdgeFlag = NULL;
-   }
-}
-
-
-/* Translate indices to GLuints and store in VB->Elts.
- */
-static void bind_indices( struct gl_context *ctx,
-			  const struct _mesa_index_buffer *ib,
-			  struct gl_buffer_object **bo,
-			  GLuint *nr_bo)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLuint i;
-   void *ptr;
-
-   if (!ib) {
-      VB->Elts = NULL;
-      return;
-   }
-
-   if (ib->obj->Name && !ib->obj->Pointer) {
-      bo[*nr_bo] = ib->obj;
-      (*nr_bo)++;
-      ctx->Driver.MapBuffer(ctx, 
-			    GL_ELEMENT_ARRAY_BUFFER,
-			    GL_READ_ONLY_ARB,
-			    ib->obj);
-
-      assert(ib->obj->Pointer);
-   }
-
-   ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
-
-   if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {
-      VB->Elts = (GLuint *) ptr;
-   }
-   else {
-      GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));
-      VB->Elts = elts;
-
-      if (ib->type == GL_UNSIGNED_INT) {
-	 const GLuint *in = (GLuint *)ptr;
-	 for (i = 0; i < ib->count; i++)
-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
-      }
-      else if (ib->type == GL_UNSIGNED_SHORT) {
-	 const GLushort *in = (GLushort *)ptr;
-	 for (i = 0; i < ib->count; i++) 
-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
-      }
-      else {
-	 const GLubyte *in = (GLubyte *)ptr;
-	 for (i = 0; i < ib->count; i++) 
-	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
-      }
-   }
-}
-
-static void bind_prims( struct gl_context *ctx,
-			const struct _mesa_prim *prim,
-			GLuint nr_prims )
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-
-   VB->Primitive = prim;
-   VB->PrimitiveCount = nr_prims;
-}
-
-static void unmap_vbos( struct gl_context *ctx,
-			struct gl_buffer_object **bo,
-			GLuint nr_bo )
-{
-   GLuint i;
-   for (i = 0; i < nr_bo; i++) { 
-      ctx->Driver.UnmapBuffer(ctx, 
-			      0, /* target -- I don't see why this would be needed */
-			      bo[i]);
-   }
-}
-
-
-void _tnl_vbo_draw_prims(struct gl_context *ctx,
-			 const struct gl_client_array *arrays[],
-			 const struct _mesa_prim *prim,
-			 GLuint nr_prims,
-			 const struct _mesa_index_buffer *ib,
-			 GLboolean index_bounds_valid,
-			 GLuint min_index,
-			 GLuint max_index)
-{
-   if (!index_bounds_valid)
-      vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
-
-   _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
-}
-
-/* This is the main entrypoint into the slimmed-down software tnl
- * module.  In a regular swtnl driver, this can be plugged straight
- * into the vbo->Driver.DrawPrims() callback.
- */
-void _tnl_draw_prims( struct gl_context *ctx,
-		      const struct gl_client_array *arrays[],
-		      const struct _mesa_prim *prim,
-		      GLuint nr_prims,
-		      const struct _mesa_index_buffer *ib,
-		      GLuint min_index,
-		      GLuint max_index)
-{
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   const GLuint TEST_SPLIT = 0;
-   const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;
-   GLint max_basevertex = prim->basevertex;
-   GLuint i;
-
-   /* Mesa core state should have been validated already */
-   assert(ctx->NewState == 0x0);
-
-   if (!_mesa_check_conditional_render(ctx))
-      return; /* don't draw */
-
-   for (i = 1; i < nr_prims; i++)
-      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
-
-   if (0)
-   {
-      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
-      for (i = 0; i < nr_prims; i++)
-	 printf("prim %d: %s start %d count %d\n", i, 
-		_mesa_lookup_enum_by_nr(prim[i].mode),
-		prim[i].start,
-		prim[i].count);
-   }
-
-   if (min_index) {
-      /* We always translate away calls with min_index != 0. 
-       */
-      vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, 
-			min_index, max_index,
-			_tnl_vbo_draw_prims );
-      return;
-   }
-   else if ((GLint)max_index + max_basevertex > max) {
-      /* The software TNL pipeline has a fixed amount of storage for
-       * vertices and it is necessary to split incoming drawing commands
-       * if they exceed that limit.
-       */
-      struct split_limits limits;
-      limits.max_verts = max;
-      limits.max_vb_size = ~0;
-      limits.max_indices = ~0;
-
-      /* This will split the buffers one way or another and
-       * recursively call back into this function.
-       */
-      vbo_split_prims( ctx, arrays, prim, nr_prims, ib, 
-		       0, max_index + prim->basevertex,
-		       _tnl_vbo_draw_prims,
-		       &limits );
-   }
-   else {
-      /* May need to map a vertex buffer object for every attribute plus
-       * one for the index buffer.
-       */
-      struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];
-      GLuint nr_bo = 0;
-      GLuint inst;
-
-      for (i = 0; i < nr_prims;) {
-	 GLuint this_nr_prims;
-
-	 /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
-	  * will rebase the elements to the basevertex, and we'll only
-	  * emit strings of prims with the same basevertex in one draw call.
-	  */
-	 for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
-	      this_nr_prims++) {
-	    if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
-	       break;
-	 }
-
-         assert(prim[i].num_instances > 0);
-
-	 /* Binding inputs may imply mapping some vertex buffer objects.
-	  * They will need to be unmapped below.
-	  */
-         for (inst = 0; inst < prim[i].num_instances; inst++) {
-
-            bind_prims(ctx, &prim[i], this_nr_prims);
-            bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,
-                        bo, &nr_bo);
-            bind_indices(ctx, ib, bo, &nr_bo);
-
-            tnl->CurInstance = inst;
-            TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
-
-            unmap_vbos(ctx, bo, nr_bo);
-            free_space(ctx);
-         }
-
-	 i += this_nr_prims;
-      }
-   }
-}
-
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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:

+ *    Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+#include "main/glheader.h"

+#include "main/condrender.h"

+#include "main/context.h"

+#include "main/imports.h"

+#include "main/mtypes.h"

+#include "main/macros.h"

+#include "main/enums.h"

+

+#include "t_context.h"

+#include "tnl.h"

+

+

+

+static GLubyte *get_space(struct gl_context *ctx, GLuint bytes)

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   GLubyte *space = malloc(bytes);

+   

+   tnl->block[tnl->nr_blocks++] = space;

+   return space;

+}

+

+

+static void free_space(struct gl_context *ctx)

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   GLuint i;

+   for (i = 0; i < tnl->nr_blocks; i++)

+      free(tnl->block[i]);

+   tnl->nr_blocks = 0;

+}

+

+

+/* Convert the incoming array to GLfloats.  Understands the

+ * array->Normalized flag and selects the correct conversion method.

+ */

+#define CONVERT( TYPE, MACRO ) do {		\

+   GLuint i, j;					\

+   if (input->Normalized) {			\

+      for (i = 0; i < count; i++) {		\

+	 const TYPE *in = (TYPE *)ptr;		\

+	 for (j = 0; j < sz; j++) {		\

+	    *fptr++ = MACRO(*in);		\

+	    in++;				\

+	 }					\

+	 ptr += input->StrideB;			\

+      }						\

+   } else {					\

+      for (i = 0; i < count; i++) {		\

+	 const TYPE *in = (TYPE *)ptr;		\

+	 for (j = 0; j < sz; j++) {		\

+	    *fptr++ = (GLfloat)(*in);		\

+	    in++;				\

+	 }					\

+	 ptr += input->StrideB;			\

+      }						\

+   }						\

+} while (0)

+

+

+/**

+ * Convert array of BGRA/GLubyte[4] values to RGBA/float[4]

+ * \param ptr  input/ubyte array

+ * \param fptr  output/float array

+ */

+static void

+convert_bgra_to_float(const struct gl_client_array *input,

+                      const GLubyte *ptr, GLfloat *fptr,

+                      GLuint count )

+{

+   GLuint i;

+   assert(input->Normalized);

+   assert(input->Size == 4);

+   for (i = 0; i < count; i++) {

+      const GLubyte *in = (GLubyte *) ptr;  /* in is in BGRA order */

+      *fptr++ = UBYTE_TO_FLOAT(in[2]);  /* red */

+      *fptr++ = UBYTE_TO_FLOAT(in[1]);  /* green */

+      *fptr++ = UBYTE_TO_FLOAT(in[0]);  /* blue */

+      *fptr++ = UBYTE_TO_FLOAT(in[3]);  /* alpha */

+      ptr += input->StrideB;

+   }

+}

+

+static void

+convert_half_to_float(const struct gl_client_array *input,

+		      const GLubyte *ptr, GLfloat *fptr,

+		      GLuint count, GLuint sz)

+{

+   GLuint i, j;

+

+   for (i = 0; i < count; i++) {

+      GLhalfARB *in = (GLhalfARB *)ptr;

+

+      for (j = 0; j < sz; j++) {

+	 *fptr++ = _mesa_half_to_float(in[j]);

+      }

+      ptr += input->StrideB;

+   }

+}

+

+/**

+ * \brief Convert fixed-point to floating-point.

+ *

+ * In OpenGL, a fixed-point number is a "signed 2's complement 16.16 scaled

+ * integer" (Table 2.2 of the OpenGL ES 2.0 spec).

+ *

+ * If the buffer has the \c normalized flag set, the formula

+ *     \code normalize(x) := (2*x + 1) / (2^16 - 1) \endcode

+ * is used to map the fixed-point numbers into the range [-1, 1].

+ */

+static void

+convert_fixed_to_float(const struct gl_client_array *input,

+                       const GLubyte *ptr, GLfloat *fptr,

+                       GLuint count)

+{

+   GLuint i, j;

+   const GLint size = input->Size;

+

+   if (input->Normalized) {

+      for (i = 0; i < count; ++i) {

+         const GLfixed *in = (GLfixed *) ptr;

+         for (j = 0; j < size; ++j) {

+            *fptr++ = (GLfloat) (2 * in[j] + 1) / (GLfloat) ((1 << 16) - 1);

+         }

+         ptr += input->StrideB;

+      }

+   } else {

+      for (i = 0; i < count; ++i) {

+         const GLfixed *in = (GLfixed *) ptr;

+         for (j = 0; j < size; ++j) {

+            *fptr++ = in[j] / (GLfloat) (1 << 16);

+         }

+         ptr += input->StrideB;

+      }

+   }

+}

+

+/* Adjust pointer to point at first requested element, convert to

+ * floating point, populate VB->AttribPtr[].

+ */

+static void _tnl_import_array( struct gl_context *ctx,

+			       GLuint attrib,

+			       GLuint count,

+			       const struct gl_client_array *input,

+			       const GLubyte *ptr )

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   struct vertex_buffer *VB = &tnl->vb;

+   GLuint stride = input->StrideB;

+

+   if (input->Type != GL_FLOAT) {

+      const GLuint sz = input->Size;

+      GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));

+      GLfloat *fptr = (GLfloat *)buf;

+

+      switch (input->Type) {

+      case GL_BYTE: 

+	 CONVERT(GLbyte, BYTE_TO_FLOAT); 

+	 break;

+      case GL_UNSIGNED_BYTE: 

+         if (input->Format == GL_BGRA) {

+            /* See GL_EXT_vertex_array_bgra */

+            convert_bgra_to_float(input, ptr, fptr, count);

+         }

+         else {

+            CONVERT(GLubyte, UBYTE_TO_FLOAT); 

+         }

+	 break;

+      case GL_SHORT: 

+	 CONVERT(GLshort, SHORT_TO_FLOAT); 

+	 break;

+      case GL_UNSIGNED_SHORT: 

+	 CONVERT(GLushort, USHORT_TO_FLOAT); 

+	 break;

+      case GL_INT: 

+	 CONVERT(GLint, INT_TO_FLOAT); 

+	 break;

+      case GL_UNSIGNED_INT: 

+	 CONVERT(GLuint, UINT_TO_FLOAT); 

+	 break;

+      case GL_DOUBLE: 

+	 CONVERT(GLdouble, (GLfloat)); 

+	 break;

+      case GL_HALF_FLOAT:

+	 convert_half_to_float(input, ptr, fptr, count, sz);

+	 break;

+      case GL_FIXED:

+         convert_fixed_to_float(input, ptr, fptr, count);

+         break;

+      default:

+	 assert(0);

+	 break;

+      }

+

+      ptr = buf;

+      stride = sz * sizeof(GLfloat);

+   }

+

+   VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];

+   VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;

+   VB->AttribPtr[attrib]->start = (GLfloat *)ptr;

+   VB->AttribPtr[attrib]->count = count;

+   VB->AttribPtr[attrib]->stride = stride;

+   VB->AttribPtr[attrib]->size = input->Size;

+

+   /* This should die, but so should the whole GLvector4f concept: 

+    */

+   VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) | 

+				   VEC_NOT_WRITEABLE |

+				   (stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));

+   

+   VB->AttribPtr[attrib]->storage = NULL;

+}

+

+#define CLIPVERTS  ((6 + MAX_CLIP_PLANES) * 2)

+

+

+static GLboolean *_tnl_import_edgeflag( struct gl_context *ctx,

+					const GLvector4f *input,

+					GLuint count)

+{

+   const GLubyte *ptr = (const GLubyte *)input->data;

+   const GLuint stride = input->stride;

+   GLboolean *space = (GLboolean *)get_space(ctx, count + CLIPVERTS);

+   GLboolean *bptr = space;

+   GLuint i;

+

+   for (i = 0; i < count; i++) {

+      *bptr++ = ((GLfloat *)ptr)[0] == 1.0;

+      ptr += stride;

+   }

+

+   return space;

+}

+

+

+static void bind_inputs( struct gl_context *ctx, 

+			 const struct gl_client_array *inputs[],

+			 GLint count,

+			 struct gl_buffer_object **bo,

+			 GLuint *nr_bo )

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   struct vertex_buffer *VB = &tnl->vb;

+   GLuint i;

+

+   /* Map all the VBOs

+    */

+   for (i = 0; i < VERT_ATTRIB_MAX; i++) {

+      const void *ptr;

+

+      if (inputs[i]->BufferObj->Name) { 

+	 if (!inputs[i]->BufferObj->Pointer) {

+	    bo[*nr_bo] = inputs[i]->BufferObj;

+	    (*nr_bo)++;

+	    ctx->Driver.MapBuffer(ctx, 

+				  GL_ARRAY_BUFFER,

+				  GL_READ_ONLY_ARB,

+				  inputs[i]->BufferObj);

+	    

+	    assert(inputs[i]->BufferObj->Pointer);

+	 }

+	 

+	 ptr = ADD_POINTERS(inputs[i]->BufferObj->Pointer,

+			    inputs[i]->Ptr);

+      }

+      else

+	 ptr = inputs[i]->Ptr;

+

+      /* Just make sure the array is floating point, otherwise convert to

+       * temporary storage.  

+       *

+       * XXX: remove the GLvector4f type at some stage and just use

+       * client arrays.

+       */

+      _tnl_import_array(ctx, i, count, inputs[i], ptr);

+   }

+

+   /* We process only the vertices between min & max index:

+    */

+   VB->Count = count;

+

+   /* These should perhaps be part of _TNL_ATTRIB_* */

+   VB->BackfaceColorPtr = NULL;

+   VB->BackfaceIndexPtr = NULL;

+   VB->BackfaceSecondaryColorPtr = NULL;

+

+   /* Clipping and drawing code still requires this to be a packed

+    * array of ubytes which can be written into.  TODO: Fix and

+    * remove.

+    */

+   if (ctx->Polygon.FrontMode != GL_FILL ||

+       ctx->Polygon.BackMode != GL_FILL)

+   {

+      VB->EdgeFlag = _tnl_import_edgeflag( ctx, 

+					   VB->AttribPtr[_TNL_ATTRIB_EDGEFLAG],

+					   VB->Count );

+   }

+   else {

+      /* the data previously pointed to by EdgeFlag may have been freed */

+      VB->EdgeFlag = NULL;

+   }

+}

+

+

+/* Translate indices to GLuints and store in VB->Elts.

+ */

+static void bind_indices( struct gl_context *ctx,

+			  const struct _mesa_index_buffer *ib,

+			  struct gl_buffer_object **bo,

+			  GLuint *nr_bo)

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   struct vertex_buffer *VB = &tnl->vb;

+   GLuint i;

+   void *ptr;

+

+   if (!ib) {

+      VB->Elts = NULL;

+      return;

+   }

+

+   if (ib->obj->Name && !ib->obj->Pointer) {

+      bo[*nr_bo] = ib->obj;

+      (*nr_bo)++;

+      ctx->Driver.MapBuffer(ctx, 

+			    GL_ELEMENT_ARRAY_BUFFER,

+			    GL_READ_ONLY_ARB,

+			    ib->obj);

+

+      assert(ib->obj->Pointer);

+   }

+

+   ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);

+

+   if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {

+      VB->Elts = (GLuint *) ptr;

+   }

+   else {

+      GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));

+      VB->Elts = elts;

+

+      if (ib->type == GL_UNSIGNED_INT) {

+	 const GLuint *in = (GLuint *)ptr;

+	 for (i = 0; i < ib->count; i++)

+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

+      }

+      else if (ib->type == GL_UNSIGNED_SHORT) {

+	 const GLushort *in = (GLushort *)ptr;

+	 for (i = 0; i < ib->count; i++) 

+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

+      }

+      else {

+	 const GLubyte *in = (GLubyte *)ptr;

+	 for (i = 0; i < ib->count; i++) 

+	    *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;

+      }

+   }

+}

+

+static void bind_prims( struct gl_context *ctx,

+			const struct _mesa_prim *prim,

+			GLuint nr_prims )

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   struct vertex_buffer *VB = &tnl->vb;

+

+   VB->Primitive = prim;

+   VB->PrimitiveCount = nr_prims;

+}

+

+static void unmap_vbos( struct gl_context *ctx,

+			struct gl_buffer_object **bo,

+			GLuint nr_bo )

+{

+   GLuint i;

+   for (i = 0; i < nr_bo; i++) { 

+      ctx->Driver.UnmapBuffer(ctx, 

+			      0, /* target -- I don't see why this would be needed */

+			      bo[i]);

+   }

+}

+

+

+void _tnl_vbo_draw_prims(struct gl_context *ctx,

+			 const struct gl_client_array *arrays[],

+			 const struct _mesa_prim *prim,

+			 GLuint nr_prims,

+			 const struct _mesa_index_buffer *ib,

+			 GLboolean index_bounds_valid,

+			 GLuint min_index,

+			 GLuint max_index)

+{

+   if (!index_bounds_valid)

+      vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);

+

+   _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);

+}

+

+/* This is the main entrypoint into the slimmed-down software tnl

+ * module.  In a regular swtnl driver, this can be plugged straight

+ * into the vbo->Driver.DrawPrims() callback.

+ */

+void _tnl_draw_prims( struct gl_context *ctx,

+		      const struct gl_client_array *arrays[],

+		      const struct _mesa_prim *prim,

+		      GLuint nr_prims,

+		      const struct _mesa_index_buffer *ib,

+		      GLuint min_index,

+		      GLuint max_index)

+{

+   TNLcontext *tnl = TNL_CONTEXT(ctx);

+   const GLuint TEST_SPLIT = 0;

+   const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;

+   GLint max_basevertex = prim->basevertex;

+   GLuint i;

+

+   /* Mesa core state should have been validated already */

+   assert(ctx->NewState == 0x0);

+

+   if (!_mesa_check_conditional_render(ctx))

+      return; /* don't draw */

+

+   for (i = 1; i < nr_prims; i++)

+      max_basevertex = MAX2(max_basevertex, prim[i].basevertex);

+

+   if (0)

+   {

+      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);

+      for (i = 0; i < nr_prims; i++)

+	 printf("prim %d: %s start %d count %d\n", i, 

+		_mesa_lookup_enum_by_nr(prim[i].mode),

+		prim[i].start,

+		prim[i].count);

+   }

+

+   if (min_index) {

+      /* We always translate away calls with min_index != 0. 

+       */

+      vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, 

+			min_index, max_index,

+			_tnl_vbo_draw_prims );

+      return;

+   }

+   else if ((GLint)max_index + max_basevertex > max) {

+      /* The software TNL pipeline has a fixed amount of storage for

+       * vertices and it is necessary to split incoming drawing commands

+       * if they exceed that limit.

+       */

+      struct split_limits limits;

+      limits.max_verts = max;

+      limits.max_vb_size = ~0;

+      limits.max_indices = ~0;

+

+      /* This will split the buffers one way or another and

+       * recursively call back into this function.

+       */

+      vbo_split_prims( ctx, arrays, prim, nr_prims, ib, 

+		       0, max_index + prim->basevertex,

+		       _tnl_vbo_draw_prims,

+		       &limits );

+   }

+   else {

+      /* May need to map a vertex buffer object for every attribute plus

+       * one for the index buffer.

+       */

+      struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];

+      GLuint nr_bo = 0;

+      GLuint inst;

+

+      for (i = 0; i < nr_prims;) {

+	 GLuint this_nr_prims;

+

+	 /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices

+	  * will rebase the elements to the basevertex, and we'll only

+	  * emit strings of prims with the same basevertex in one draw call.

+	  */

+	 for (this_nr_prims = 1; i + this_nr_prims < nr_prims;

+	      this_nr_prims++) {

+	    if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)

+	       break;

+	 }

+

+         assert(prim[i].num_instances > 0);

+

+	 /* Binding inputs may imply mapping some vertex buffer objects.

+	  * They will need to be unmapped below.

+	  */

+         for (inst = 0; inst < prim[i].num_instances; inst++) {

+

+            bind_prims(ctx, &prim[i], this_nr_prims);

+            bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,

+                        bo, &nr_bo);

+            bind_indices(ctx, ib, bo, &nr_bo);

+

+            tnl->CurInstance = inst;

+            TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);

+

+            unmap_vbos(ctx, bo, nr_bo);

+            free_space(ctx);

+         }

+

+	 i += this_nr_prims;

+      }

+   }

+}

+

diff --git a/mesalib/src/mesa/vbo/vbo.h b/mesalib/src/mesa/vbo/vbo.h
index 26c3d4e0a..37bdde9a8 100644
--- a/mesalib/src/mesa/vbo/vbo.h
+++ b/mesalib/src/mesa/vbo/vbo.h
@@ -1,176 +1,176 @@
-/*
- * mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/**
- * \file vbo_context.h
- * \brief VBO builder module datatypes and definitions.
- * \author Keith Whitwell
- */
-
-
-#ifndef _VBO_H
-#define _VBO_H
-
-#include "main/glheader.h"
-
-struct gl_client_array;
-struct gl_context;
-
-struct _mesa_prim {
-   GLuint mode:8;    /**< GL_POINTS, GL_LINES, GL_QUAD_STRIP, etc */
-   GLuint indexed:1;
-   GLuint begin:1;
-   GLuint end:1;
-   GLuint weak:1;
-   GLuint no_current_update:1;
-   GLuint pad:19;
-
-   GLuint start;
-   GLuint count;
-   GLint basevertex;
-   GLsizei num_instances;
-};
-
-/* Would like to call this a "vbo_index_buffer", but this would be
- * confusing as the indices are not neccessarily yet in a non-null
- * buffer object.
- */
-struct _mesa_index_buffer {
-   GLuint count;
-   GLenum type;
-   struct gl_buffer_object *obj;
-   const void *ptr;
-};
-
-
-
-GLboolean _vbo_CreateContext( struct gl_context *ctx );
-void _vbo_DestroyContext( struct gl_context *ctx );
-void _vbo_InvalidateState( struct gl_context *ctx, GLuint new_state );
-
-
-typedef void (*vbo_draw_func)( struct gl_context *ctx,
-			       const struct gl_client_array **arrays,
-			       const struct _mesa_prim *prims,
-			       GLuint nr_prims,
-			       const struct _mesa_index_buffer *ib,
-			       GLboolean index_bounds_valid,
-			       GLuint min_index,
-			       GLuint max_index );
-
-
-
-
-/* Utility function to cope with various constraints on tnl modules or
- * hardware.  This can be used to split an incoming set of arrays and
- * primitives against the following constraints:
- *    - Maximum number of indices in index buffer.
- *    - Maximum number of vertices referenced by index buffer.
- *    - Maximum hardware vertex buffer size.
- */
-struct split_limits {
-   GLuint max_verts;
-   GLuint max_indices;
-   GLuint max_vb_size;		/* bytes */
-};
-
-
-void vbo_split_prims( struct gl_context *ctx,
-		      const struct gl_client_array *arrays[],
-		      const struct _mesa_prim *prim,
-		      GLuint nr_prims,
-		      const struct _mesa_index_buffer *ib,
-		      GLuint min_index,
-		      GLuint max_index,
-		      vbo_draw_func draw,
-		      const struct split_limits *limits );
-
-
-/* Helpers for dealing translating away non-zero min_index.
- */
-GLboolean vbo_all_varyings_in_vbos( const struct gl_client_array *arrays[] );
-GLboolean vbo_any_varyings_in_vbos( const struct gl_client_array *arrays[] );
-
-void vbo_rebase_prims( struct gl_context *ctx,
-		       const struct gl_client_array *arrays[],
-		       const struct _mesa_prim *prim,
-		       GLuint nr_prims,
-		       const struct _mesa_index_buffer *ib,
-		       GLuint min_index,
-		       GLuint max_index,
-		       vbo_draw_func draw );
-void
-vbo_get_minmax_index(struct gl_context *ctx, const struct _mesa_prim *prim,
-		     const struct _mesa_index_buffer *ib,
-		     GLuint *min_index, GLuint *max_index);
-
-void vbo_use_buffer_objects(struct gl_context *ctx);
-
-void vbo_always_unmap_buffers(struct gl_context *ctx);
-
-void vbo_set_draw_func(struct gl_context *ctx, vbo_draw_func func);
-
-void vbo_check_buffers_are_unmapped(struct gl_context *ctx);
-
-
-void GLAPIENTRY
-_es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
-
-void GLAPIENTRY
-_es_Normal3f(GLfloat x, GLfloat y, GLfloat z);
-
-void GLAPIENTRY
-_es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-
-void GLAPIENTRY
-_es_Materialfv(GLenum face, GLenum pname, const GLfloat *params);
-
-void GLAPIENTRY
-_es_Materialf(GLenum face, GLenum pname, GLfloat param);
-
-void GLAPIENTRY
-_es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-
-void GLAPIENTRY
-_es_VertexAttrib1f(GLuint indx, GLfloat x);
-
-void GLAPIENTRY
-_es_VertexAttrib1fv(GLuint indx, const GLfloat* values);
-
-void GLAPIENTRY
-_es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);
-
-void GLAPIENTRY
-_es_VertexAttrib2fv(GLuint indx, const GLfloat* values);
-
-void GLAPIENTRY
-_es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-
-void GLAPIENTRY
-_es_VertexAttrib3fv(GLuint indx, const GLfloat* values);
-
-void GLAPIENTRY
-_es_VertexAttrib4fv(GLuint indx, const GLfloat* values);
-
-#endif
+/*

+ * mesa 3-D graphics library

+ * Version:  6.5

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/**

+ * \file vbo_context.h

+ * \brief VBO builder module datatypes and definitions.

+ * \author Keith Whitwell

+ */

+

+

+#ifndef _VBO_H

+#define _VBO_H

+

+#include "main/glheader.h"

+

+struct gl_client_array;

+struct gl_context;

+

+struct _mesa_prim {

+   GLuint mode:8;    /**< GL_POINTS, GL_LINES, GL_QUAD_STRIP, etc */

+   GLuint indexed:1;

+   GLuint begin:1;

+   GLuint end:1;

+   GLuint weak:1;

+   GLuint no_current_update:1;

+   GLuint pad:19;

+

+   GLuint start;

+   GLuint count;

+   GLint basevertex;

+   GLsizei num_instances;

+};

+

+/* Would like to call this a "vbo_index_buffer", but this would be

+ * confusing as the indices are not neccessarily yet in a non-null

+ * buffer object.

+ */

+struct _mesa_index_buffer {

+   GLuint count;

+   GLenum type;

+   struct gl_buffer_object *obj;

+   const void *ptr;

+};

+

+

+

+GLboolean _vbo_CreateContext( struct gl_context *ctx );

+void _vbo_DestroyContext( struct gl_context *ctx );

+void _vbo_InvalidateState( struct gl_context *ctx, GLuint new_state );

+

+

+typedef void (*vbo_draw_func)( struct gl_context *ctx,

+			       const struct gl_client_array **arrays,

+			       const struct _mesa_prim *prims,

+			       GLuint nr_prims,

+			       const struct _mesa_index_buffer *ib,

+			       GLboolean index_bounds_valid,

+			       GLuint min_index,

+			       GLuint max_index );

+

+

+

+

+/* Utility function to cope with various constraints on tnl modules or

+ * hardware.  This can be used to split an incoming set of arrays and

+ * primitives against the following constraints:

+ *    - Maximum number of indices in index buffer.

+ *    - Maximum number of vertices referenced by index buffer.

+ *    - Maximum hardware vertex buffer size.

+ */

+struct split_limits {

+   GLuint max_verts;

+   GLuint max_indices;

+   GLuint max_vb_size;		/* bytes */

+};

+

+

+void vbo_split_prims( struct gl_context *ctx,

+		      const struct gl_client_array *arrays[],

+		      const struct _mesa_prim *prim,

+		      GLuint nr_prims,

+		      const struct _mesa_index_buffer *ib,

+		      GLuint min_index,

+		      GLuint max_index,

+		      vbo_draw_func draw,

+		      const struct split_limits *limits );

+

+

+/* Helpers for dealing translating away non-zero min_index.

+ */

+GLboolean vbo_all_varyings_in_vbos( const struct gl_client_array *arrays[] );

+GLboolean vbo_any_varyings_in_vbos( const struct gl_client_array *arrays[] );

+

+void vbo_rebase_prims( struct gl_context *ctx,

+		       const struct gl_client_array *arrays[],

+		       const struct _mesa_prim *prim,

+		       GLuint nr_prims,

+		       const struct _mesa_index_buffer *ib,

+		       GLuint min_index,

+		       GLuint max_index,

+		       vbo_draw_func draw );

+void

+vbo_get_minmax_index(struct gl_context *ctx, const struct _mesa_prim *prim,

+		     const struct _mesa_index_buffer *ib,

+		     GLuint *min_index, GLuint *max_index);

+

+void vbo_use_buffer_objects(struct gl_context *ctx);

+

+void vbo_always_unmap_buffers(struct gl_context *ctx);

+

+void vbo_set_draw_func(struct gl_context *ctx, vbo_draw_func func);

+

+void vbo_check_buffers_are_unmapped(struct gl_context *ctx);

+

+

+void GLAPIENTRY

+_es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a);

+

+void GLAPIENTRY

+_es_Normal3f(GLfloat x, GLfloat y, GLfloat z);

+

+void GLAPIENTRY

+_es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);

+

+void GLAPIENTRY

+_es_Materialfv(GLenum face, GLenum pname, const GLfloat *params);

+

+void GLAPIENTRY

+_es_Materialf(GLenum face, GLenum pname, GLfloat param);

+

+void GLAPIENTRY

+_es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

+

+void GLAPIENTRY

+_es_VertexAttrib1f(GLuint indx, GLfloat x);

+

+void GLAPIENTRY

+_es_VertexAttrib1fv(GLuint indx, const GLfloat* values);

+

+void GLAPIENTRY

+_es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

+

+void GLAPIENTRY

+_es_VertexAttrib2fv(GLuint indx, const GLfloat* values);

+

+void GLAPIENTRY

+_es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

+

+void GLAPIENTRY

+_es_VertexAttrib3fv(GLuint indx, const GLfloat* values);

+

+void GLAPIENTRY

+_es_VertexAttrib4fv(GLuint indx, const GLfloat* values);

+

+#endif

diff --git a/mesalib/src/mesa/vbo/vbo_attrib_tmp.h b/mesalib/src/mesa/vbo/vbo_attrib_tmp.h
index c793ce0dc..198b2d85f 100644
--- a/mesalib/src/mesa/vbo/vbo_attrib_tmp.h
+++ b/mesalib/src/mesa/vbo/vbo_attrib_tmp.h
@@ -1,740 +1,740 @@
-/**************************************************************************
-
-Copyright 2002 Tungsten Graphics 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
-on 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
-TUNGSTEN GRAPHICS 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.
-
-**************************************************************************/
-
-/* float */
-#define ATTR1FV( A, V ) ATTR( A, 1, (V)[0], 0, 0, 1 )
-#define ATTR2FV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )
-#define ATTR3FV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )
-#define ATTR4FV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
-
-#define ATTR1F( A, X )          ATTR( A, 1, X, 0, 0, 1 )
-#define ATTR2F( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )
-#define ATTR3F( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )
-#define ATTR4F( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )
-
-/* int */
-#define ATTR2IV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )
-#define ATTR3IV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )
-#define ATTR4IV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
-
-#define ATTR1I( A, X )          ATTR( A, 1, X, 0, 0, 1 )
-#define ATTR2I( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )
-#define ATTR3I( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )
-#define ATTR4I( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )
-
-
-/* uint */
-#define ATTR2UIV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )
-#define ATTR3UIV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )
-#define ATTR4UIV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
-
-#define ATTR1UI( A, X )          ATTR( A, 1, X, 0, 0, 1 )
-#define ATTR2UI( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )
-#define ATTR3UI( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )
-#define ATTR4UI( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )
-
-#define MAT_ATTR( A, N, V ) ATTR( A, N, (V)[0], (V)[1], (V)[2], (V)[3] )
-
-
-
-static void GLAPIENTRY
-TAG(Vertex2f)(GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR2F(VBO_ATTRIB_POS, x, y);
-}
-
-static void GLAPIENTRY
-TAG(Vertex2fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR2FV(VBO_ATTRIB_POS, v);
-}
-
-static void GLAPIENTRY
-TAG(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3F(VBO_ATTRIB_POS, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(Vertex3fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3FV(VBO_ATTRIB_POS, v);
-}
-
-static void GLAPIENTRY
-TAG(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4F(VBO_ATTRIB_POS, x, y, z, w);
-}
-
-static void GLAPIENTRY
-TAG(Vertex4fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4FV(VBO_ATTRIB_POS, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(TexCoord1f)(GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1F(VBO_ATTRIB_TEX0, x);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord1fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1FV(VBO_ATTRIB_TEX0, v);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord2f)(GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR2F(VBO_ATTRIB_TEX0, x, y);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord2fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR2FV(VBO_ATTRIB_TEX0, v);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3F(VBO_ATTRIB_TEX0, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord3fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3FV(VBO_ATTRIB_TEX0, v);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);
-}
-
-static void GLAPIENTRY
-TAG(TexCoord4fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4FV(VBO_ATTRIB_TEX0, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(Normal3fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3FV(VBO_ATTRIB_NORMAL, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(FogCoordfEXT)(GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1F(VBO_ATTRIB_FOG, x);
-}
-
-
-
-static void GLAPIENTRY
-TAG(FogCoordfvEXT)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1FV(VBO_ATTRIB_FOG, v);
-}
-
-static void GLAPIENTRY
-TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(Color3fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3FV(VBO_ATTRIB_COLOR0, v);
-}
-
-static void GLAPIENTRY
-TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);
-}
-
-static void GLAPIENTRY
-TAG(Color4fv)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR4FV(VBO_ATTRIB_COLOR0, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(SecondaryColor3fvEXT)(const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR3FV(VBO_ATTRIB_COLOR1, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(EdgeFlag)(GLboolean b)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);
-}
-
-
-
-static void GLAPIENTRY
-TAG(Indexf)(GLfloat f)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1F(VBO_ATTRIB_INDEX, f);
-}
-
-static void GLAPIENTRY
-TAG(Indexfv)(const GLfloat * f)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ATTR1FV(VBO_ATTRIB_INDEX, f);
-}
-
-
-
-static void GLAPIENTRY
-TAG(MultiTexCoord1f)(GLenum target, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR1F(attr, x);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR1FV(attr, v);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord2f)(GLenum target, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR2F(attr, x, y);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR2FV(attr, v);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord3f)(GLenum target, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR3F(attr, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR3FV(attr, v);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord4f)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR4F(attr, x, y, z, w);
-}
-
-static void GLAPIENTRY
-TAG(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;
-   ATTR4FV(attr, v);
-}
-
-
-
-static void GLAPIENTRY
-TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR1F(0, x);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR1F(VBO_ATTRIB_GENERIC0 + index, x);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib1fvARB)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR1FV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR1FV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2F(0, x, y);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2F(VBO_ATTRIB_GENERIC0 + index, x, y);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib2fvARB)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2FV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2FV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3F(0, x, y, z);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3F(VBO_ATTRIB_GENERIC0 + index, x, y, z);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib3fvARB)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3FV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3FV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4F(0, x, y, z, w);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4F(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib4fvARB)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4FV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4FV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-
-
-/* Integer-valued generic attributes.
- * XXX: the integers just get converted to floats at this time
- */
-static void GLAPIENTRY
-TAG(VertexAttribI1i)(GLuint index, GLint x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR1I(0, x);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR1I(VBO_ATTRIB_GENERIC0 + index, x);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI2i)(GLuint index, GLint x, GLint y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2I(0, x, y);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2I(VBO_ATTRIB_GENERIC0 + index, x, y);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3I(0, x, y, z);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3I(VBO_ATTRIB_GENERIC0 + index, x, y, z);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4I(0, x, y, z, w);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4I(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI2iv)(GLuint index, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2IV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2IV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI3iv)(GLuint index, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3IV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3IV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI4iv)(GLuint index, const GLint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4IV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4IV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-
-
-/* Unsigned integer-valued generic attributes.
- * XXX: the integers just get converted to floats at this time
- */
-static void GLAPIENTRY
-TAG(VertexAttribI1ui)(GLuint index, GLuint x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR1UI(0, x);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR1UI(VBO_ATTRIB_GENERIC0 + index, x);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI2ui)(GLuint index, GLuint x, GLuint y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2UI(0, x, y);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2UI(VBO_ATTRIB_GENERIC0 + index, x, y);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3UI(0, x, y, z);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3UI(VBO_ATTRIB_GENERIC0 + index, x, y, z);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4UI(0, x, y, z, w);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI2uiv)(GLuint index, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR2UIV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR2UIV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI3uiv)(GLuint index, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR3UIV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR3UIV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttribI4uiv)(GLuint index, const GLuint *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index == 0)
-      ATTR4UIV(0, v);
-   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR4UIV(VBO_ATTRIB_GENERIC0 + index, v);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-
-
-/* In addition to supporting NV_vertex_program, these entrypoints are
- * used by the display list and other code specifically because of
- * their property of aliasing with other attributes.  (See
- * vbo_save_loopback.c)
- */
-static void GLAPIENTRY
-TAG(VertexAttrib1fNV)(GLuint index, GLfloat x)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR1F(index, x);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR1FV(index, v);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR2F(index, x, y);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR2FV(index, v);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR3F(index, x, y, z);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib3fvNV)(GLuint index,
- const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR3FV(index, v);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR4F(index, x, y, z, w);
-}
-
-static void GLAPIENTRY
-TAG(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < VBO_ATTRIB_MAX)
-      ATTR4FV(index, v);
-}
-
-
-
-#define MAT( ATTR, N, face, params )			\
-do {							\
-   if (face != GL_BACK)					\
-      MAT_ATTR( ATTR, N, params ); /* front */		\
-   if (face != GL_FRONT)				\
-      MAT_ATTR( ATTR + 1, N, params ); /* back */	\
-} while (0)
-
-
-/* Colormaterial conflicts are dealt with later.
- */
-static void GLAPIENTRY
-TAG(Materialfv)(GLenum face, GLenum pname,
-                 const GLfloat * params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   switch (pname) {
-   case GL_EMISSION:
-      MAT(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, face, params);
-      break;
-   case GL_AMBIENT:
-      MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
-      break;
-   case GL_DIFFUSE:
-      MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
-      break;
-   case GL_SPECULAR:
-      MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params);
-      break;
-   case GL_SHININESS:
-      MAT(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, face, params);
-      break;
-   case GL_COLOR_INDEXES:
-      MAT(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, face, params);
-      break;
-   case GL_AMBIENT_AND_DIFFUSE:
-      MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);
-      MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);
-      break;
-   default:
-      ERROR(GL_INVALID_ENUM);
-      return;
-   }
-}
-
-
-#undef ATTR1FV
-#undef ATTR2FV
-#undef ATTR3FV
-#undef ATTR4FV
-
-#undef ATTR1F
-#undef ATTR2F
-#undef ATTR3F
-#undef ATTR4F
-
-#undef MAT
-#undef MAT_ATTR
+/**************************************************************************

+

+Copyright 2002 Tungsten Graphics 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

+on 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

+TUNGSTEN GRAPHICS 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.

+

+**************************************************************************/

+

+/* float */

+#define ATTR1FV( A, V ) ATTR( A, 1, (V)[0], 0, 0, 1 )

+#define ATTR2FV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )

+#define ATTR3FV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )

+#define ATTR4FV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )

+

+#define ATTR1F( A, X )          ATTR( A, 1, X, 0, 0, 1 )

+#define ATTR2F( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )

+#define ATTR3F( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )

+#define ATTR4F( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )

+

+/* int */

+#define ATTR2IV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )

+#define ATTR3IV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )

+#define ATTR4IV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )

+

+#define ATTR1I( A, X )          ATTR( A, 1, X, 0, 0, 1 )

+#define ATTR2I( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )

+#define ATTR3I( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )

+#define ATTR4I( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )

+

+

+/* uint */

+#define ATTR2UIV( A, V ) ATTR( A, 2, (V)[0], (V)[1], 0, 1 )

+#define ATTR3UIV( A, V ) ATTR( A, 3, (V)[0], (V)[1], (V)[2], 1 )

+#define ATTR4UIV( A, V ) ATTR( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )

+

+#define ATTR1UI( A, X )          ATTR( A, 1, X, 0, 0, 1 )

+#define ATTR2UI( A, X, Y )       ATTR( A, 2, X, Y, 0, 1 )

+#define ATTR3UI( A, X, Y, Z )    ATTR( A, 3, X, Y, Z, 1 )

+#define ATTR4UI( A, X, Y, Z, W ) ATTR( A, 4, X, Y, Z, W )

+

+#define MAT_ATTR( A, N, V ) ATTR( A, N, (V)[0], (V)[1], (V)[2], (V)[3] )

+

+

+

+static void GLAPIENTRY

+TAG(Vertex2f)(GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR2F(VBO_ATTRIB_POS, x, y);

+}

+

+static void GLAPIENTRY

+TAG(Vertex2fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR2FV(VBO_ATTRIB_POS, v);

+}

+

+static void GLAPIENTRY

+TAG(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3F(VBO_ATTRIB_POS, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(Vertex3fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3FV(VBO_ATTRIB_POS, v);

+}

+

+static void GLAPIENTRY

+TAG(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4F(VBO_ATTRIB_POS, x, y, z, w);

+}

+

+static void GLAPIENTRY

+TAG(Vertex4fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4FV(VBO_ATTRIB_POS, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(TexCoord1f)(GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1F(VBO_ATTRIB_TEX0, x);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord1fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1FV(VBO_ATTRIB_TEX0, v);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord2f)(GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR2F(VBO_ATTRIB_TEX0, x, y);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord2fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR2FV(VBO_ATTRIB_TEX0, v);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord3f)(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3F(VBO_ATTRIB_TEX0, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord3fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3FV(VBO_ATTRIB_TEX0, v);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4F(VBO_ATTRIB_TEX0, x, y, z, w);

+}

+

+static void GLAPIENTRY

+TAG(TexCoord4fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4FV(VBO_ATTRIB_TEX0, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(Normal3f)(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3F(VBO_ATTRIB_NORMAL, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(Normal3fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3FV(VBO_ATTRIB_NORMAL, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(FogCoordfEXT)(GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1F(VBO_ATTRIB_FOG, x);

+}

+

+

+

+static void GLAPIENTRY

+TAG(FogCoordfvEXT)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1FV(VBO_ATTRIB_FOG, v);

+}

+

+static void GLAPIENTRY

+TAG(Color3f)(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3F(VBO_ATTRIB_COLOR0, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(Color3fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3FV(VBO_ATTRIB_COLOR0, v);

+}

+

+static void GLAPIENTRY

+TAG(Color4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4F(VBO_ATTRIB_COLOR0, x, y, z, w);

+}

+

+static void GLAPIENTRY

+TAG(Color4fv)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR4FV(VBO_ATTRIB_COLOR0, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(SecondaryColor3fEXT)(GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3F(VBO_ATTRIB_COLOR1, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(SecondaryColor3fvEXT)(const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR3FV(VBO_ATTRIB_COLOR1, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(EdgeFlag)(GLboolean b)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1F(VBO_ATTRIB_EDGEFLAG, (GLfloat) b);

+}

+

+

+

+static void GLAPIENTRY

+TAG(Indexf)(GLfloat f)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1F(VBO_ATTRIB_INDEX, f);

+}

+

+static void GLAPIENTRY

+TAG(Indexfv)(const GLfloat * f)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ATTR1FV(VBO_ATTRIB_INDEX, f);

+}

+

+

+

+static void GLAPIENTRY

+TAG(MultiTexCoord1f)(GLenum target, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR1F(attr, x);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord1fv)(GLenum target, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR1FV(attr, v);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord2f)(GLenum target, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR2F(attr, x, y);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord2fv)(GLenum target, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR2FV(attr, v);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord3f)(GLenum target, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR3F(attr, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord3fv)(GLenum target, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR3FV(attr, v);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord4f)(GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR4F(attr, x, y, z, w);

+}

+

+static void GLAPIENTRY

+TAG(MultiTexCoord4fv)(GLenum target, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint attr = (target & 0x7) + VBO_ATTRIB_TEX0;

+   ATTR4FV(attr, v);

+}

+

+

+

+static void GLAPIENTRY

+TAG(VertexAttrib1fARB)(GLuint index, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR1F(0, x);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR1F(VBO_ATTRIB_GENERIC0 + index, x);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib1fvARB)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR1FV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR1FV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2F(0, x, y);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2F(VBO_ATTRIB_GENERIC0 + index, x, y);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib2fvARB)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2FV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2FV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3F(0, x, y, z);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3F(VBO_ATTRIB_GENERIC0 + index, x, y, z);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib3fvARB)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3FV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3FV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4F(0, x, y, z, w);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4F(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib4fvARB)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4FV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4FV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+

+

+/* Integer-valued generic attributes.

+ * XXX: the integers just get converted to floats at this time

+ */

+static void GLAPIENTRY

+TAG(VertexAttribI1i)(GLuint index, GLint x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR1I(0, x);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR1I(VBO_ATTRIB_GENERIC0 + index, x);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI2i)(GLuint index, GLint x, GLint y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2I(0, x, y);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2I(VBO_ATTRIB_GENERIC0 + index, x, y);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3I(0, x, y, z);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3I(VBO_ATTRIB_GENERIC0 + index, x, y, z);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4I(0, x, y, z, w);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4I(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI2iv)(GLuint index, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2IV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2IV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI3iv)(GLuint index, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3IV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3IV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI4iv)(GLuint index, const GLint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4IV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4IV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+

+

+/* Unsigned integer-valued generic attributes.

+ * XXX: the integers just get converted to floats at this time

+ */

+static void GLAPIENTRY

+TAG(VertexAttribI1ui)(GLuint index, GLuint x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR1UI(0, x);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR1UI(VBO_ATTRIB_GENERIC0 + index, x);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI2ui)(GLuint index, GLuint x, GLuint y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2UI(0, x, y);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2UI(VBO_ATTRIB_GENERIC0 + index, x, y);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3UI(0, x, y, z);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3UI(VBO_ATTRIB_GENERIC0 + index, x, y, z);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4UI(0, x, y, z, w);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4UI(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI2uiv)(GLuint index, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR2UIV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR2UIV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI3uiv)(GLuint index, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR3UIV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR3UIV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttribI4uiv)(GLuint index, const GLuint *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index == 0)

+      ATTR4UIV(0, v);

+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR4UIV(VBO_ATTRIB_GENERIC0 + index, v);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+

+

+/* In addition to supporting NV_vertex_program, these entrypoints are

+ * used by the display list and other code specifically because of

+ * their property of aliasing with other attributes.  (See

+ * vbo_save_loopback.c)

+ */

+static void GLAPIENTRY

+TAG(VertexAttrib1fNV)(GLuint index, GLfloat x)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR1F(index, x);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib1fvNV)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR1FV(index, v);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR2F(index, x, y);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib2fvNV)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR2FV(index, v);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR3F(index, x, y, z);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib3fvNV)(GLuint index,

+ const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR3FV(index, v);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR4F(index, x, y, z, w);

+}

+

+static void GLAPIENTRY

+TAG(VertexAttrib4fvNV)(GLuint index, const GLfloat * v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < VBO_ATTRIB_MAX)

+      ATTR4FV(index, v);

+}

+

+

+

+#define MAT( ATTR, N, face, params )			\

+do {							\

+   if (face != GL_BACK)					\

+      MAT_ATTR( ATTR, N, params ); /* front */		\

+   if (face != GL_FRONT)				\

+      MAT_ATTR( ATTR + 1, N, params ); /* back */	\

+} while (0)

+

+

+/* Colormaterial conflicts are dealt with later.

+ */

+static void GLAPIENTRY

+TAG(Materialfv)(GLenum face, GLenum pname,

+                 const GLfloat * params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   switch (pname) {

+   case GL_EMISSION:

+      MAT(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, face, params);

+      break;

+   case GL_AMBIENT:

+      MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);

+      break;

+   case GL_DIFFUSE:

+      MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);

+      break;

+   case GL_SPECULAR:

+      MAT(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params);

+      break;

+   case GL_SHININESS:

+      MAT(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, face, params);

+      break;

+   case GL_COLOR_INDEXES:

+      MAT(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, face, params);

+      break;

+   case GL_AMBIENT_AND_DIFFUSE:

+      MAT(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params);

+      MAT(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params);

+      break;

+   default:

+      ERROR(GL_INVALID_ENUM);

+      return;

+   }

+}

+

+

+#undef ATTR1FV

+#undef ATTR2FV

+#undef ATTR3FV

+#undef ATTR4FV

+

+#undef ATTR1F

+#undef ATTR2F

+#undef ATTR3F

+#undef ATTR4F

+

+#undef MAT

+#undef MAT_ATTR

diff --git a/mesalib/src/mesa/vbo/vbo_exec.h b/mesalib/src/mesa/vbo/vbo_exec.h
index d52a557e0..c8e509285 100644
--- a/mesalib/src/mesa/vbo/vbo_exec.h
+++ b/mesalib/src/mesa/vbo/vbo_exec.h
@@ -1,204 +1,204 @@
-/**************************************************************************
-
-Copyright 2002 Tungsten Graphics 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
-on 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
-TUNGSTEN GRAPHICS 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:
- *   Keith Whitwell <keith@tungstengraphics.com>
- *
- */
-
-#ifndef __VBO_EXEC_H__
-#define __VBO_EXEC_H__
-
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "vbo.h"
-#include "vbo_attrib.h"
-
-
-/**
- * Max number of primitives (number of glBegin/End pairs) per VBO.
- */
-#define VBO_MAX_PRIM 64
-
-
-/**
- * Size of the VBO to use for glBegin/glVertex/glEnd-style rendering.
- */
-#define VBO_VERT_BUFFER_SIZE (1024*64)	/* bytes */
-
-
-/** Current vertex program mode */
-enum vp_mode {
-   VP_NONE,   /**< fixed function */
-   VP_NV,     /**< NV vertex program */
-   VP_ARB     /**< ARB vertex program or GLSL vertex shader */
-};
-
-
-struct vbo_exec_eval1_map {
-   struct gl_1d_map *map;
-   GLuint sz;
-};
-
-struct vbo_exec_eval2_map {
-   struct gl_2d_map *map;
-   GLuint sz;
-};
-
-
-
-struct vbo_exec_copied_vtx {
-   GLfloat buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
-   GLuint nr;
-};
-
-
-typedef void (*vbo_attrfv_func)( const GLfloat * );
-
-
-struct vbo_exec_context
-{
-   struct gl_context *ctx;   
-   GLvertexformat vtxfmt;
-
-   struct {
-      struct gl_buffer_object *bufferobj;
-
-      GLuint vertex_size;       /* in dwords */
-
-      struct _mesa_prim prim[VBO_MAX_PRIM];
-      GLuint prim_count;
-
-      GLfloat *buffer_map;
-      GLfloat *buffer_ptr;              /* cursor, points into buffer */
-      GLuint   buffer_used;             /* in bytes */
-      GLfloat vertex[VBO_ATTRIB_MAX*4]; /* current vertex */
-
-      GLuint vert_count;
-      GLuint max_vert;
-      struct vbo_exec_copied_vtx copied;
-
-      GLubyte attrsz[VBO_ATTRIB_MAX];
-      GLubyte active_sz[VBO_ATTRIB_MAX];
-
-      GLfloat *attrptr[VBO_ATTRIB_MAX]; 
-      struct gl_client_array arrays[VERT_ATTRIB_MAX];
-
-      /* According to program mode, the values above plus current
-       * values are squashed down to the 32 attributes passed to the
-       * vertex program below:
-       */
-      enum vp_mode program_mode;
-      GLuint enabled_flags;
-      const struct gl_client_array *inputs[VERT_ATTRIB_MAX];
-   } vtx;
-
-   
-   struct {
-      GLboolean recalculate_maps;
-      struct vbo_exec_eval1_map map1[VERT_ATTRIB_MAX];
-      struct vbo_exec_eval2_map map2[VERT_ATTRIB_MAX];
-   } eval;
-
-   struct {
-      enum vp_mode program_mode;
-      GLuint enabled_flags;
-      GLuint array_obj;
-
-      /* These just mirror the current arrayobj (todo: make arrayobj
-       * look like this and remove the mirror):
-       */
-      const struct gl_client_array *legacy_array[16];
-      const struct gl_client_array *generic_array[16];
-
-      /* Arrays and current values manipulated according to program
-       * mode, etc.  These are the attributes as seen by vertex
-       * programs:
-       */
-      const struct gl_client_array *inputs[VERT_ATTRIB_MAX];
-   } array;
-
-   /* Which flags to set in vbo_exec_BeginVertices() */
-   GLbitfield begin_vertices_flags;
-
-#ifdef DEBUG
-   GLint flush_call_depth;
-#endif
-};
-
-
-
-/* External API:
- */
-void vbo_exec_init( struct gl_context *ctx );
-void vbo_exec_destroy( struct gl_context *ctx );
-void vbo_exec_invalidate_state( struct gl_context *ctx, GLuint new_state );
-
-void vbo_exec_BeginVertices( struct gl_context *ctx );
-void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags );
-
-
-/* Internal functions:
- */
-void vbo_exec_array_init( struct vbo_exec_context *exec );
-void vbo_exec_array_destroy( struct vbo_exec_context *exec );
-
-
-void vbo_exec_vtx_init( struct vbo_exec_context *exec );
-void vbo_exec_vtx_destroy( struct vbo_exec_context *exec );
-
-#if FEATURE_beginend
-
-void vbo_exec_vtx_flush( struct vbo_exec_context *exec, GLboolean unmap );
-void vbo_exec_vtx_map( struct vbo_exec_context *exec );
-
-#else /* FEATURE_beginend */
-
-static INLINE void
-vbo_exec_vtx_flush( struct vbo_exec_context *exec, GLboolean unmap )
-{
-}
-
-static INLINE void
-vbo_exec_vtx_map( struct vbo_exec_context *exec )
-{
-}
-
-#endif /* FEATURE_beginend */
-
-void vbo_exec_vtx_wrap( struct vbo_exec_context *exec );
-
-void vbo_exec_eval_update( struct vbo_exec_context *exec );
-
-void vbo_exec_do_EvalCoord2f( struct vbo_exec_context *exec, 
-				     GLfloat u, GLfloat v );
-
-void vbo_exec_do_EvalCoord1f( struct vbo_exec_context *exec,
-				     GLfloat u);
-
-#endif
+/**************************************************************************

+

+Copyright 2002 Tungsten Graphics 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

+on 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

+TUNGSTEN GRAPHICS 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:

+ *   Keith Whitwell <keith@tungstengraphics.com>

+ *

+ */

+

+#ifndef __VBO_EXEC_H__

+#define __VBO_EXEC_H__

+

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "vbo.h"

+#include "vbo_attrib.h"

+

+

+/**

+ * Max number of primitives (number of glBegin/End pairs) per VBO.

+ */

+#define VBO_MAX_PRIM 64

+

+

+/**

+ * Size of the VBO to use for glBegin/glVertex/glEnd-style rendering.

+ */

+#define VBO_VERT_BUFFER_SIZE (1024*64)	/* bytes */

+

+

+/** Current vertex program mode */

+enum vp_mode {

+   VP_NONE,   /**< fixed function */

+   VP_NV,     /**< NV vertex program */

+   VP_ARB     /**< ARB vertex program or GLSL vertex shader */

+};

+

+

+struct vbo_exec_eval1_map {

+   struct gl_1d_map *map;

+   GLuint sz;

+};

+

+struct vbo_exec_eval2_map {

+   struct gl_2d_map *map;

+   GLuint sz;

+};

+

+

+

+struct vbo_exec_copied_vtx {

+   GLfloat buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];

+   GLuint nr;

+};

+

+

+typedef void (*vbo_attrfv_func)( const GLfloat * );

+

+

+struct vbo_exec_context

+{

+   struct gl_context *ctx;   

+   GLvertexformat vtxfmt;

+

+   struct {

+      struct gl_buffer_object *bufferobj;

+

+      GLuint vertex_size;       /* in dwords */

+

+      struct _mesa_prim prim[VBO_MAX_PRIM];

+      GLuint prim_count;

+

+      GLfloat *buffer_map;

+      GLfloat *buffer_ptr;              /* cursor, points into buffer */

+      GLuint   buffer_used;             /* in bytes */

+      GLfloat vertex[VBO_ATTRIB_MAX*4]; /* current vertex */

+

+      GLuint vert_count;

+      GLuint max_vert;

+      struct vbo_exec_copied_vtx copied;

+

+      GLubyte attrsz[VBO_ATTRIB_MAX];

+      GLubyte active_sz[VBO_ATTRIB_MAX];

+

+      GLfloat *attrptr[VBO_ATTRIB_MAX]; 

+      struct gl_client_array arrays[VERT_ATTRIB_MAX];

+

+      /* According to program mode, the values above plus current

+       * values are squashed down to the 32 attributes passed to the

+       * vertex program below:

+       */

+      enum vp_mode program_mode;

+      GLuint enabled_flags;

+      const struct gl_client_array *inputs[VERT_ATTRIB_MAX];

+   } vtx;

+

+   

+   struct {

+      GLboolean recalculate_maps;

+      struct vbo_exec_eval1_map map1[VERT_ATTRIB_MAX];

+      struct vbo_exec_eval2_map map2[VERT_ATTRIB_MAX];

+   } eval;

+

+   struct {

+      enum vp_mode program_mode;

+      GLuint enabled_flags;

+      GLuint array_obj;

+

+      /* These just mirror the current arrayobj (todo: make arrayobj

+       * look like this and remove the mirror):

+       */

+      const struct gl_client_array *legacy_array[16];

+      const struct gl_client_array *generic_array[16];

+

+      /* Arrays and current values manipulated according to program

+       * mode, etc.  These are the attributes as seen by vertex

+       * programs:

+       */

+      const struct gl_client_array *inputs[VERT_ATTRIB_MAX];

+   } array;

+

+   /* Which flags to set in vbo_exec_BeginVertices() */

+   GLbitfield begin_vertices_flags;

+

+#ifdef DEBUG

+   GLint flush_call_depth;

+#endif

+};

+

+

+

+/* External API:

+ */

+void vbo_exec_init( struct gl_context *ctx );

+void vbo_exec_destroy( struct gl_context *ctx );

+void vbo_exec_invalidate_state( struct gl_context *ctx, GLuint new_state );

+

+void vbo_exec_BeginVertices( struct gl_context *ctx );

+void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags );

+

+

+/* Internal functions:

+ */

+void vbo_exec_array_init( struct vbo_exec_context *exec );

+void vbo_exec_array_destroy( struct vbo_exec_context *exec );

+

+

+void vbo_exec_vtx_init( struct vbo_exec_context *exec );

+void vbo_exec_vtx_destroy( struct vbo_exec_context *exec );

+

+#if FEATURE_beginend

+

+void vbo_exec_vtx_flush( struct vbo_exec_context *exec, GLboolean unmap );

+void vbo_exec_vtx_map( struct vbo_exec_context *exec );

+

+#else /* FEATURE_beginend */

+

+static INLINE void

+vbo_exec_vtx_flush( struct vbo_exec_context *exec, GLboolean unmap )

+{

+}

+

+static INLINE void

+vbo_exec_vtx_map( struct vbo_exec_context *exec )

+{

+}

+

+#endif /* FEATURE_beginend */

+

+void vbo_exec_vtx_wrap( struct vbo_exec_context *exec );

+

+void vbo_exec_eval_update( struct vbo_exec_context *exec );

+

+void vbo_exec_do_EvalCoord2f( struct vbo_exec_context *exec, 

+				     GLfloat u, GLfloat v );

+

+void vbo_exec_do_EvalCoord1f( struct vbo_exec_context *exec,

+				     GLfloat u);

+

+#endif

diff --git a/mesalib/src/mesa/vbo/vbo_exec_api.c b/mesalib/src/mesa/vbo/vbo_exec_api.c
index fcd544de7..790310903 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_api.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_api.c
@@ -1,1121 +1,1121 @@
-/**************************************************************************
-
-Copyright 2002-2008 Tungsten Graphics 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
-on 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
-TUNGSTEN GRAPHICS 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:
- *   Keith Whitwell <keith@tungstengraphics.com>
- */
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/context.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/vtxfmt.h"
-#include "main/dlist.h"
-#include "main/eval.h"
-#include "main/state.h"
-#include "main/light.h"
-#include "main/api_arrayelt.h"
-#include "main/api_noop.h"
-#include "main/dispatch.h"
-
-#include "vbo_context.h"
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-
-/** ID/name for immediate-mode VBO */
-#define IMM_BUFFER_NAME 0xaabbccdd
-
-
-static void reset_attrfv( struct vbo_exec_context *exec );
-
-
-/**
- * Close off the last primitive, execute the buffer, restart the
- * primitive.  
- */
-static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec )
-{
-   if (exec->vtx.prim_count == 0) {
-      exec->vtx.copied.nr = 0;
-      exec->vtx.vert_count = 0;
-      exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-   }
-   else {
-      GLuint last_begin = exec->vtx.prim[exec->vtx.prim_count-1].begin;
-      GLuint last_count;
-
-      if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
-	 GLint i = exec->vtx.prim_count - 1;
-	 assert(i >= 0);
-	 exec->vtx.prim[i].count = (exec->vtx.vert_count - 
-				    exec->vtx.prim[i].start);
-      }
-
-      last_count = exec->vtx.prim[exec->vtx.prim_count-1].count;
-
-      /* Execute the buffer and save copied vertices.
-       */
-      if (exec->vtx.vert_count)
-	 vbo_exec_vtx_flush( exec, GL_FALSE );
-      else {
-	 exec->vtx.prim_count = 0;
-	 exec->vtx.copied.nr = 0;
-      }
-
-      /* Emit a glBegin to start the new list.
-       */
-      assert(exec->vtx.prim_count == 0);
-
-      if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
-	 exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive;
-	 exec->vtx.prim[0].start = 0;
-	 exec->vtx.prim[0].count = 0;
-	 exec->vtx.prim_count++;
-      
-	 if (exec->vtx.copied.nr == last_count)
-	    exec->vtx.prim[0].begin = last_begin;
-      }
-   }
-}
-
-
-/**
- * Deal with buffer wrapping where provoked by the vertex buffer
- * filling up, as opposed to upgrade_vertex().
- */
-void vbo_exec_vtx_wrap( struct vbo_exec_context *exec )
-{
-   GLfloat *data = exec->vtx.copied.buffer;
-   GLuint i;
-
-   /* Run pipeline on current vertices, copy wrapped vertices
-    * to exec->vtx.copied.
-    */
-   vbo_exec_wrap_buffers( exec );
-   
-   /* Copy stored stored vertices to start of new list. 
-    */
-   assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr);
-
-   for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
-      memcpy( exec->vtx.buffer_ptr, data, 
-	      exec->vtx.vertex_size * sizeof(GLfloat));
-      exec->vtx.buffer_ptr += exec->vtx.vertex_size;
-      data += exec->vtx.vertex_size;
-      exec->vtx.vert_count++;
-   }
-
-   exec->vtx.copied.nr = 0;
-}
-
-
-/**
- * Copy the active vertex's values to the ctx->Current fields.
- */
-static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )
-{
-   struct gl_context *ctx = exec->ctx;
-   struct vbo_context *vbo = vbo_context(ctx);
-   GLuint i;
-
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
-      if (exec->vtx.attrsz[i]) {
-         /* Note: the exec->vtx.current[i] pointers point into the
-          * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
-          */
-	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
-         GLfloat tmp[4];
-
-         COPY_CLEAN_4V(tmp, 
-                       exec->vtx.attrsz[i], 
-                       exec->vtx.attrptr[i]);
-         
-         if (memcmp(current, tmp, sizeof(tmp)) != 0) { 
-            memcpy(current, tmp, sizeof(tmp));
-	 
-            /* Given that we explicitly state size here, there is no need
-             * for the COPY_CLEAN above, could just copy 16 bytes and be
-             * done.  The only problem is when Mesa accesses ctx->Current
-             * directly.
-             */
-            vbo->currval[i].Size = exec->vtx.attrsz[i];
-
-            /* This triggers rather too much recalculation of Mesa state
-             * that doesn't get used (eg light positions).
-             */
-            if (i >= VBO_ATTRIB_MAT_FRONT_AMBIENT &&
-                i <= VBO_ATTRIB_MAT_BACK_INDEXES)
-               ctx->NewState |= _NEW_LIGHT;
-            
-            ctx->NewState |= _NEW_CURRENT_ATTRIB;
-         }
-      }
-   }
-
-   /* Colormaterial -- this kindof sucks.
-    */
-   if (ctx->Light.ColorMaterialEnabled &&
-       exec->vtx.attrsz[VBO_ATTRIB_COLOR0]) {
-      _mesa_update_color_material(ctx, 
-				  ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
-   }
-}
-
-
-/**
- * Copy current vertex attribute values into the current vertex.
- */
-static void
-vbo_exec_copy_from_current(struct vbo_exec_context *exec)
-{
-   struct gl_context *ctx = exec->ctx;
-   struct vbo_context *vbo = vbo_context(ctx);
-   GLint i;
-
-   for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
-      const GLfloat *current = (GLfloat *) vbo->currval[i].Ptr;
-      switch (exec->vtx.attrsz[i]) {
-      case 4: exec->vtx.attrptr[i][3] = current[3];
-      case 3: exec->vtx.attrptr[i][2] = current[2];
-      case 2: exec->vtx.attrptr[i][1] = current[1];
-      case 1: exec->vtx.attrptr[i][0] = current[0];
-	 break;
-      }
-   }
-}
-
-
-/**
- * Flush existing data, set new attrib size, replay copied vertices.
- * This is called when we transition from a small vertex attribute size
- * to a larger one.  Ex: glTexCoord2f -> glTexCoord4f.
- * We need to go back over the previous 2-component texcoords and insert
- * zero and one values.
- */ 
-static void
-vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
-                             GLuint attr, GLuint newSize )
-{
-   struct gl_context *ctx = exec->ctx;
-   struct vbo_context *vbo = vbo_context(ctx);
-   const GLint lastcount = exec->vtx.vert_count;
-   GLfloat *old_attrptr[VBO_ATTRIB_MAX];
-   const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */
-   const GLuint oldSize = exec->vtx.attrsz[attr];
-   GLuint i;
-
-   /* Run pipeline on current vertices, copy wrapped vertices
-    * to exec->vtx.copied.
-    */
-   vbo_exec_wrap_buffers( exec );
-
-   if (unlikely(exec->vtx.copied.nr)) {
-      /* We're in the middle of a primitive, keep the old vertex
-       * format around to be able to translate the copied vertices to
-       * the new format.
-       */
-      memcpy(old_attrptr, exec->vtx.attrptr, sizeof(old_attrptr));
-   }
-
-   if (unlikely(oldSize)) {
-      /* Do a COPY_TO_CURRENT to ensure back-copying works for the
-       * case when the attribute already exists in the vertex and is
-       * having its size increased.
-       */
-      vbo_exec_copy_to_current( exec );
-   }
-
-   /* Heuristic: Attempt to isolate attributes received outside
-    * begin/end so that they don't bloat the vertices.
-    */
-   if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END &&
-       !oldSize && lastcount > 8 && exec->vtx.vertex_size) {
-      vbo_exec_copy_to_current( exec );
-      reset_attrfv( exec );
-   }
-
-   /* Fix up sizes:
-    */
-   exec->vtx.attrsz[attr] = newSize;
-   exec->vtx.vertex_size += newSize - oldSize;
-   exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 
-                         (exec->vtx.vertex_size * sizeof(GLfloat)));
-   exec->vtx.vert_count = 0;
-   exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-
-   if (unlikely(oldSize)) {
-      /* Size changed, recalculate all the attrptr[] values
-       */
-      GLfloat *tmp = exec->vtx.vertex;
-
-      for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
-	 if (exec->vtx.attrsz[i]) {
-	    exec->vtx.attrptr[i] = tmp;
-	    tmp += exec->vtx.attrsz[i];
-	 }
-	 else
-	    exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */
-      }
-
-      /* Copy from current to repopulate the vertex with correct
-       * values.
-       */
-      vbo_exec_copy_from_current( exec );
-   }
-   else {
-      /* Just have to append the new attribute at the end */
-      exec->vtx.attrptr[attr] = exec->vtx.vertex +
-	 exec->vtx.vertex_size - newSize;
-   }
-
-   /* Replay stored vertices to translate them
-    * to new format here.
-    *
-    * -- No need to replay - just copy piecewise
-    */
-   if (unlikely(exec->vtx.copied.nr)) {
-      GLfloat *data = exec->vtx.copied.buffer;
-      GLfloat *dest = exec->vtx.buffer_ptr;
-      GLuint j;
-
-      assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);
-
-      for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
-	 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {
-	    GLuint sz = exec->vtx.attrsz[j];
-
-	    if (sz) {
-	       GLint old_offset = old_attrptr[j] - exec->vtx.vertex;
-	       GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex;
-
-	       if (j == attr) {
-		  if (oldSize) {
-		     GLfloat tmp[4];
-		     COPY_CLEAN_4V(tmp, oldSize, data + old_offset);
-		     COPY_SZ_4V(dest + new_offset, newSize, tmp);
-		  } else {
-		     GLfloat *current = (GLfloat *)vbo->currval[j].Ptr;
-		     COPY_SZ_4V(dest + new_offset, sz, current);
-		  }
-	       }
-	       else {
-		  COPY_SZ_4V(dest + new_offset, sz, data + old_offset);
-	       }
-	    }
-	 }
-
-	 data += old_vtx_size;
-	 dest += exec->vtx.vertex_size;
-      }
-
-      exec->vtx.buffer_ptr = dest;
-      exec->vtx.vert_count += exec->vtx.copied.nr;
-      exec->vtx.copied.nr = 0;
-   }
-}
-
-
-/**
- * This is when a vertex attribute transitions to a different size.
- * For example, we saw a bunch of glTexCoord2f() calls and now we got a
- * glTexCoord4f() call.  We promote the array from size=2 to size=4.
- */
-static void
-vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
-{
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-
-   if (newSize > exec->vtx.attrsz[attr]) {
-      /* New size is larger.  Need to flush existing vertices and get
-       * an enlarged vertex format.
-       */
-      vbo_exec_wrap_upgrade_vertex( exec, attr, newSize );
-   }
-   else if (newSize < exec->vtx.active_sz[attr]) {
-      static const GLfloat id[4] = { 0, 0, 0, 1 };
-      GLuint i;
-
-      /* New size is smaller - just need to fill in some
-       * zeros.  Don't need to flush or wrap.
-       */
-      for (i = newSize; i <= exec->vtx.attrsz[attr]; i++)
-	 exec->vtx.attrptr[attr][i-1] = id[i-1];
-   }
-
-   exec->vtx.active_sz[attr] = newSize;
-
-   /* Does setting NeedFlush belong here?  Necessitates resetting
-    * vtxfmt on each flush (otherwise flags won't get reset
-    * afterwards).
-    */
-   if (attr == 0) 
-      ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
-}
-
-
-/**
- * This macro is used to implement all the glVertex, glColor, glTexCoord,
- * glVertexAttrib, etc functions.
- */
-#define ATTR( A, N, V0, V1, V2, V3 )					\
-do {									\
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;		\
-									\
-   if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)))	\
-      ctx->Driver.BeginVertices( ctx );					\
-   									\
-   if (unlikely(exec->vtx.active_sz[A] != N))				\
-      vbo_exec_fixup_vertex(ctx, A, N);					\
-   									\
-   {									\
-      GLfloat *dest = exec->vtx.attrptr[A];				\
-      if (N>0) dest[0] = V0;						\
-      if (N>1) dest[1] = V1;						\
-      if (N>2) dest[2] = V2;						\
-      if (N>3) dest[3] = V3;						\
-   }									\
-									\
-   if ((A) == 0) {							\
-      /* This is a glVertex call */					\
-      GLuint i;								\
-									\
-      for (i = 0; i < exec->vtx.vertex_size; i++)			\
-	 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i];			\
-									\
-      exec->vtx.buffer_ptr += exec->vtx.vertex_size;			\
-									\
-      /* Set FLUSH_STORED_VERTICES to indicate that there's now */	\
-      /* something to draw (not just updating a color or texcoord).*/	\
-      ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;			\
-									\
-      if (++exec->vtx.vert_count >= exec->vtx.max_vert)			\
-	 vbo_exec_vtx_wrap( exec );					\
-   }									\
-} while (0)
-
-
-#define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )
-#define TAG(x) vbo_##x
-
-#include "vbo_attrib_tmp.h"
-
-
-#if FEATURE_beginend
-
-
-#if FEATURE_evaluators
-
-static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-
-   {
-      GLint i;
-      if (exec->eval.recalculate_maps) 
-	 vbo_exec_eval_update( exec );
-
-      for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
-	 if (exec->eval.map1[i].map) 
-	    if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz)
-	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz );
-      }
-   }
-
-
-   memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, 
-           exec->vtx.vertex_size * sizeof(GLfloat));
-
-   vbo_exec_do_EvalCoord1f( exec, u );
-
-   memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,
-           exec->vtx.vertex_size * sizeof(GLfloat));
-}
-
-static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-
-   {
-      GLint i;
-      if (exec->eval.recalculate_maps) 
-	 vbo_exec_eval_update( exec );
-
-      for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
-	 if (exec->eval.map2[i].map) 
-	    if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz)
-	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz );
-      }
-
-      if (ctx->Eval.AutoNormal) 
-	 if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3)
-	    vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3 );
-   }
-
-   memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, 
-           exec->vtx.vertex_size * sizeof(GLfloat));
-
-   vbo_exec_do_EvalCoord2f( exec, u, v );
-
-   memcpy( exec->vtx.vertex, exec->vtx.copied.buffer, 
-           exec->vtx.vertex_size * sizeof(GLfloat));
-}
-
-static void GLAPIENTRY vbo_exec_EvalCoord1fv( const GLfloat *u )
-{
-   vbo_exec_EvalCoord1f( u[0] );
-}
-
-static void GLAPIENTRY vbo_exec_EvalCoord2fv( const GLfloat *u )
-{
-   vbo_exec_EvalCoord2f( u[0], u[1] );
-}
-
-static void GLAPIENTRY vbo_exec_EvalPoint1( GLint i )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /
-		 (GLfloat) ctx->Eval.MapGrid1un);
-   GLfloat u = i * du + ctx->Eval.MapGrid1u1;
-
-   vbo_exec_EvalCoord1f( u );
-}
-
-
-static void GLAPIENTRY vbo_exec_EvalPoint2( GLint i, GLint j )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / 
-		 (GLfloat) ctx->Eval.MapGrid2un);
-   GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / 
-		 (GLfloat) ctx->Eval.MapGrid2vn);
-   GLfloat u = i * du + ctx->Eval.MapGrid2u1;
-   GLfloat v = j * dv + ctx->Eval.MapGrid2v1;
-
-   vbo_exec_EvalCoord2f( u, v );
-}
-
-/* use noop eval mesh */
-#define vbo_exec_EvalMesh1 _mesa_noop_EvalMesh1
-#define vbo_exec_EvalMesh2 _mesa_noop_EvalMesh2
-
-#endif /* FEATURE_evaluators */
-
-
-/**
- * Flush (draw) vertices.
- * \param  unmap - leave VBO unmapped after flushing?
- */
-static void
-vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec, GLboolean unmap)
-{
-   if (exec->vtx.vert_count || unmap) {
-      vbo_exec_vtx_flush( exec, unmap );
-   }
-
-   if (exec->vtx.vertex_size) {
-      vbo_exec_copy_to_current( exec );
-      reset_attrfv( exec );
-   }
-}
-
-
-/**
- * Called via glBegin.
- */
-static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
-{
-   GET_CURRENT_CONTEXT( ctx ); 
-
-   if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) {
-      struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-      int i;
-
-      if (ctx->NewState) {
-	 _mesa_update_state( ctx );
-
-	 CALL_Begin(ctx->Exec, (mode));
-	 return;
-      }
-
-      if (!_mesa_valid_to_render(ctx, "glBegin")) {
-         return;
-      }
-
-      /* Heuristic: attempt to isolate attributes occuring outside
-       * begin/end pairs.
-       */
-      if (exec->vtx.vertex_size && !exec->vtx.attrsz[0]) 
-	 vbo_exec_FlushVertices_internal(exec, GL_FALSE);
-
-      i = exec->vtx.prim_count++;
-      exec->vtx.prim[i].mode = mode;
-      exec->vtx.prim[i].begin = 1;
-      exec->vtx.prim[i].end = 0;
-      exec->vtx.prim[i].indexed = 0;
-      exec->vtx.prim[i].weak = 0;
-      exec->vtx.prim[i].pad = 0;
-      exec->vtx.prim[i].start = exec->vtx.vert_count;
-      exec->vtx.prim[i].count = 0;
-      exec->vtx.prim[i].num_instances = 1;
-
-      ctx->Driver.CurrentExecPrimitive = mode;
-   }
-   else 
-      _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
-      
-}
-
-
-/**
- * Called via glEnd.
- */
-static void GLAPIENTRY vbo_exec_End( void )
-{
-   GET_CURRENT_CONTEXT( ctx ); 
-
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
-      struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-      int idx = exec->vtx.vert_count;
-      int i = exec->vtx.prim_count - 1;
-
-      exec->vtx.prim[i].end = 1; 
-      exec->vtx.prim[i].count = idx - exec->vtx.prim[i].start;
-
-      ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
-
-      if (exec->vtx.prim_count == VBO_MAX_PRIM)
-	 vbo_exec_vtx_flush( exec, GL_FALSE );
-   }
-   else 
-      _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
-}
-
-
-/**
- * Called via glPrimitiveRestartNV()
- */
-static void GLAPIENTRY
-vbo_exec_PrimitiveRestartNV(void)
-{
-   GLenum curPrim;
-   GET_CURRENT_CONTEXT( ctx ); 
-
-   curPrim = ctx->Driver.CurrentExecPrimitive;
-
-   if (curPrim == PRIM_OUTSIDE_BEGIN_END) {
-      _mesa_error( ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV" );
-   }
-   else {
-      vbo_exec_End();
-      vbo_exec_Begin(curPrim);
-   }
-}
-
-
-
-static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )
-{
-   GLvertexformat *vfmt = &exec->vtxfmt;
-
-   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
-
-   vfmt->Begin = vbo_exec_Begin;
-   vfmt->End = vbo_exec_End;
-   vfmt->PrimitiveRestartNV = vbo_exec_PrimitiveRestartNV;
-
-   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);
-   _MESA_INIT_EVAL_VTXFMT(vfmt, vbo_exec_);
-
-   vfmt->Rectf = _mesa_noop_Rectf;
-
-   /* from attrib_tmp.h:
-    */
-   vfmt->Color3f = vbo_Color3f;
-   vfmt->Color3fv = vbo_Color3fv;
-   vfmt->Color4f = vbo_Color4f;
-   vfmt->Color4fv = vbo_Color4fv;
-   vfmt->FogCoordfEXT = vbo_FogCoordfEXT;
-   vfmt->FogCoordfvEXT = vbo_FogCoordfvEXT;
-   vfmt->MultiTexCoord1fARB = vbo_MultiTexCoord1f;
-   vfmt->MultiTexCoord1fvARB = vbo_MultiTexCoord1fv;
-   vfmt->MultiTexCoord2fARB = vbo_MultiTexCoord2f;
-   vfmt->MultiTexCoord2fvARB = vbo_MultiTexCoord2fv;
-   vfmt->MultiTexCoord3fARB = vbo_MultiTexCoord3f;
-   vfmt->MultiTexCoord3fvARB = vbo_MultiTexCoord3fv;
-   vfmt->MultiTexCoord4fARB = vbo_MultiTexCoord4f;
-   vfmt->MultiTexCoord4fvARB = vbo_MultiTexCoord4fv;
-   vfmt->Normal3f = vbo_Normal3f;
-   vfmt->Normal3fv = vbo_Normal3fv;
-   vfmt->SecondaryColor3fEXT = vbo_SecondaryColor3fEXT;
-   vfmt->SecondaryColor3fvEXT = vbo_SecondaryColor3fvEXT;
-   vfmt->TexCoord1f = vbo_TexCoord1f;
-   vfmt->TexCoord1fv = vbo_TexCoord1fv;
-   vfmt->TexCoord2f = vbo_TexCoord2f;
-   vfmt->TexCoord2fv = vbo_TexCoord2fv;
-   vfmt->TexCoord3f = vbo_TexCoord3f;
-   vfmt->TexCoord3fv = vbo_TexCoord3fv;
-   vfmt->TexCoord4f = vbo_TexCoord4f;
-   vfmt->TexCoord4fv = vbo_TexCoord4fv;
-   vfmt->Vertex2f = vbo_Vertex2f;
-   vfmt->Vertex2fv = vbo_Vertex2fv;
-   vfmt->Vertex3f = vbo_Vertex3f;
-   vfmt->Vertex3fv = vbo_Vertex3fv;
-   vfmt->Vertex4f = vbo_Vertex4f;
-   vfmt->Vertex4fv = vbo_Vertex4fv;
-   
-   vfmt->VertexAttrib1fARB = vbo_VertexAttrib1fARB;
-   vfmt->VertexAttrib1fvARB = vbo_VertexAttrib1fvARB;
-   vfmt->VertexAttrib2fARB = vbo_VertexAttrib2fARB;
-   vfmt->VertexAttrib2fvARB = vbo_VertexAttrib2fvARB;
-   vfmt->VertexAttrib3fARB = vbo_VertexAttrib3fARB;
-   vfmt->VertexAttrib3fvARB = vbo_VertexAttrib3fvARB;
-   vfmt->VertexAttrib4fARB = vbo_VertexAttrib4fARB;
-   vfmt->VertexAttrib4fvARB = vbo_VertexAttrib4fvARB;
-
-   vfmt->VertexAttrib1fNV = vbo_VertexAttrib1fNV;
-   vfmt->VertexAttrib1fvNV = vbo_VertexAttrib1fvNV;
-   vfmt->VertexAttrib2fNV = vbo_VertexAttrib2fNV;
-   vfmt->VertexAttrib2fvNV = vbo_VertexAttrib2fvNV;
-   vfmt->VertexAttrib3fNV = vbo_VertexAttrib3fNV;
-   vfmt->VertexAttrib3fvNV = vbo_VertexAttrib3fvNV;
-   vfmt->VertexAttrib4fNV = vbo_VertexAttrib4fNV;
-   vfmt->VertexAttrib4fvNV = vbo_VertexAttrib4fvNV;
-
-   /* integer-valued */
-   vfmt->VertexAttribI1i = vbo_VertexAttribI1i;
-   vfmt->VertexAttribI2i = vbo_VertexAttribI2i;
-   vfmt->VertexAttribI3i = vbo_VertexAttribI3i;
-   vfmt->VertexAttribI4i = vbo_VertexAttribI4i;
-   vfmt->VertexAttribI2iv = vbo_VertexAttribI2iv;
-   vfmt->VertexAttribI3iv = vbo_VertexAttribI3iv;
-   vfmt->VertexAttribI4iv = vbo_VertexAttribI4iv;
-
-   /* unsigned integer-valued */
-   vfmt->VertexAttribI1ui = vbo_VertexAttribI1ui;
-   vfmt->VertexAttribI2ui = vbo_VertexAttribI2ui;
-   vfmt->VertexAttribI3ui = vbo_VertexAttribI3ui;
-   vfmt->VertexAttribI4ui = vbo_VertexAttribI4ui;
-   vfmt->VertexAttribI2uiv = vbo_VertexAttribI2uiv;
-   vfmt->VertexAttribI3uiv = vbo_VertexAttribI3uiv;
-   vfmt->VertexAttribI4uiv = vbo_VertexAttribI4uiv;
-
-   vfmt->Materialfv = vbo_Materialfv;
-
-   vfmt->EdgeFlag = vbo_EdgeFlag;
-   vfmt->Indexf = vbo_Indexf;
-   vfmt->Indexfv = vbo_Indexfv;
-
-}
-
-
-#else /* FEATURE_beginend */
-
-
-static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )
-{
-   /* silence warnings */
-   (void) vbo_Color3f;
-   (void) vbo_Color3fv;
-   (void) vbo_Color4f;
-   (void) vbo_Color4fv;
-   (void) vbo_FogCoordfEXT;
-   (void) vbo_FogCoordfvEXT;
-   (void) vbo_MultiTexCoord1f;
-   (void) vbo_MultiTexCoord1fv;
-   (void) vbo_MultiTexCoord2f;
-   (void) vbo_MultiTexCoord2fv;
-   (void) vbo_MultiTexCoord3f;
-   (void) vbo_MultiTexCoord3fv;
-   (void) vbo_MultiTexCoord4f;
-   (void) vbo_MultiTexCoord4fv;
-   (void) vbo_Normal3f;
-   (void) vbo_Normal3fv;
-   (void) vbo_SecondaryColor3fEXT;
-   (void) vbo_SecondaryColor3fvEXT;
-   (void) vbo_TexCoord1f;
-   (void) vbo_TexCoord1fv;
-   (void) vbo_TexCoord2f;
-   (void) vbo_TexCoord2fv;
-   (void) vbo_TexCoord3f;
-   (void) vbo_TexCoord3fv;
-   (void) vbo_TexCoord4f;
-   (void) vbo_TexCoord4fv;
-   (void) vbo_Vertex2f;
-   (void) vbo_Vertex2fv;
-   (void) vbo_Vertex3f;
-   (void) vbo_Vertex3fv;
-   (void) vbo_Vertex4f;
-   (void) vbo_Vertex4fv;
-
-   (void) vbo_VertexAttrib1fARB;
-   (void) vbo_VertexAttrib1fvARB;
-   (void) vbo_VertexAttrib2fARB;
-   (void) vbo_VertexAttrib2fvARB;
-   (void) vbo_VertexAttrib3fARB;
-   (void) vbo_VertexAttrib3fvARB;
-   (void) vbo_VertexAttrib4fARB;
-   (void) vbo_VertexAttrib4fvARB;
-
-   (void) vbo_VertexAttrib1fNV;
-   (void) vbo_VertexAttrib1fvNV;
-   (void) vbo_VertexAttrib2fNV;
-   (void) vbo_VertexAttrib2fvNV;
-   (void) vbo_VertexAttrib3fNV;
-   (void) vbo_VertexAttrib3fvNV;
-   (void) vbo_VertexAttrib4fNV;
-   (void) vbo_VertexAttrib4fvNV;
-
-   (void) vbo_Materialfv;
-
-   (void) vbo_EdgeFlag;
-   (void) vbo_Indexf;
-   (void) vbo_Indexfv;
-}
-
-
-#endif /* FEATURE_beginend */
-
-
-/**
- * Tell the VBO module to use a real OpenGL vertex buffer object to
- * store accumulated immediate-mode vertex data.
- * This replaces the malloced buffer which was created in
- * vb_exec_vtx_init() below.
- */
-void vbo_use_buffer_objects(struct gl_context *ctx)
-{
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-   /* Any buffer name but 0 can be used here since this bufferobj won't
-    * go into the bufferobj hashtable.
-    */
-   GLuint bufName = IMM_BUFFER_NAME;
-   GLenum target = GL_ARRAY_BUFFER_ARB;
-   GLenum usage = GL_STREAM_DRAW_ARB;
-   GLsizei size = VBO_VERT_BUFFER_SIZE;
-
-   /* Make sure this func is only used once */
-   assert(exec->vtx.bufferobj == ctx->Shared->NullBufferObj);
-   if (exec->vtx.buffer_map) {
-      _mesa_align_free(exec->vtx.buffer_map);
-      exec->vtx.buffer_map = NULL;
-      exec->vtx.buffer_ptr = NULL;
-   }
-
-   /* Allocate a real buffer object now */
-   _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
-   exec->vtx.bufferobj = ctx->Driver.NewBufferObject(ctx, bufName, target);
-   ctx->Driver.BufferData(ctx, target, size, NULL, usage, exec->vtx.bufferobj);
-}
-
-
-/**
- * If this function is called, all VBO buffers will be unmapped when
- * we flush.
- * Otherwise, if a simple command like glColor3f() is called and we flush,
- * the current VBO may be left mapped.
- */
-void
-vbo_always_unmap_buffers(struct gl_context *ctx)
-{
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-   exec->begin_vertices_flags |= FLUSH_STORED_VERTICES;
-}
-
-
-void vbo_exec_vtx_init( struct vbo_exec_context *exec )
-{
-   struct gl_context *ctx = exec->ctx;
-   struct vbo_context *vbo = vbo_context(ctx);
-   GLuint i;
-
-   /* Allocate a buffer object.  Will just reuse this object
-    * continuously, unless vbo_use_buffer_objects() is called to enable
-    * use of real VBOs.
-    */
-   _mesa_reference_buffer_object(ctx,
-                                 &exec->vtx.bufferobj,
-                                 ctx->Shared->NullBufferObj);
-
-   ASSERT(!exec->vtx.buffer_map);
-   exec->vtx.buffer_map = (GLfloat *)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
-   exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-
-   vbo_exec_vtxfmt_init( exec );
-
-   /* Hook our functions into the dispatch table.
-    */
-   _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt );
-
-   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
-      ASSERT(i < Elements(exec->vtx.attrsz));
-      exec->vtx.attrsz[i] = 0;
-      ASSERT(i < Elements(exec->vtx.active_sz));
-      exec->vtx.active_sz[i] = 0;
-   }
-   for (i = 0 ; i < VERT_ATTRIB_MAX; i++) {
-      ASSERT(i < Elements(exec->vtx.inputs));
-      ASSERT(i < Elements(exec->vtx.arrays));
-      exec->vtx.inputs[i] = &exec->vtx.arrays[i];
-   }
-   
-   {
-      struct gl_client_array *arrays = exec->vtx.arrays;
-      unsigned i;
-
-      memcpy(arrays,      vbo->legacy_currval,  16 * sizeof(arrays[0]));
-      memcpy(arrays + 16, vbo->generic_currval, 16 * sizeof(arrays[0]));
-
-      for (i = 0; i < 16; ++i) {
-         arrays[i     ].BufferObj = NULL;
-         arrays[i + 16].BufferObj = NULL;
-         _mesa_reference_buffer_object(ctx, &arrays[i     ].BufferObj,
-                                       vbo->legacy_currval[i].BufferObj);
-         _mesa_reference_buffer_object(ctx, &arrays[i + 16].BufferObj,
-                                       vbo->generic_currval[i].BufferObj);
-      }
-   }
-
-   exec->vtx.vertex_size = 0;
-
-   exec->begin_vertices_flags = FLUSH_UPDATE_CURRENT;
-}
-
-
-void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )
-{
-   /* using a real VBO for vertex data */
-   struct gl_context *ctx = exec->ctx;
-   unsigned i;
-
-   /* True VBOs should already be unmapped
-    */
-   if (exec->vtx.buffer_map) {
-      ASSERT(exec->vtx.bufferobj->Name == 0 ||
-             exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);
-      if (exec->vtx.bufferobj->Name == 0) {
-         _mesa_align_free(exec->vtx.buffer_map);
-         exec->vtx.buffer_map = NULL;
-         exec->vtx.buffer_ptr = NULL;
-      }
-   }
-
-   /* Drop any outstanding reference to the vertex buffer
-    */
-   for (i = 0; i < Elements(exec->vtx.arrays); i++) {
-      _mesa_reference_buffer_object(ctx,
-                                    &exec->vtx.arrays[i].BufferObj,
-                                    NULL);
-   }
-
-   /* Free the vertex buffer.  Unmap first if needed.
-    */
-   if (_mesa_bufferobj_mapped(exec->vtx.bufferobj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, exec->vtx.bufferobj);
-   }
-   _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
-}
-
-
-/**
- * Called upon first glVertex, glColor, glTexCoord, etc.
- */
-void vbo_exec_BeginVertices( struct gl_context *ctx )
-{
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-
-   vbo_exec_vtx_map( exec );
-
-   assert((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);
-   assert(exec->begin_vertices_flags);
-
-   ctx->Driver.NeedFlush |= exec->begin_vertices_flags;
-}
-
-
-/**
- * Called via ctx->Driver.FlushVertices()
- * \param flags  bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
- */
-void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags )
-{
-   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
-
-#ifdef DEBUG
-   /* debug check: make sure we don't get called recursively */
-   exec->flush_call_depth++;
-   assert(exec->flush_call_depth == 1);
-#endif
-
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
-      /* We've had glBegin but not glEnd! */
-#ifdef DEBUG
-      exec->flush_call_depth--;
-      assert(exec->flush_call_depth == 0);
-#endif
-      return;
-   }
-
-   /* Flush (draw), and make sure VBO is left unmapped when done */
-   vbo_exec_FlushVertices_internal(exec, GL_TRUE);
-
-   /* Need to do this to ensure BeginVertices gets called again:
-    */
-   ctx->Driver.NeedFlush &= ~(FLUSH_UPDATE_CURRENT | flags);
-
-#ifdef DEBUG
-   exec->flush_call_depth--;
-   assert(exec->flush_call_depth == 0);
-#endif
-}
-
-
-static void reset_attrfv( struct vbo_exec_context *exec )
-{   
-   GLuint i;
-
-   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
-      exec->vtx.attrsz[i] = 0;
-      exec->vtx.active_sz[i] = 0;
-   }
-
-   exec->vtx.vertex_size = 0;
-}
-      
-
-void GLAPIENTRY
-_es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
-{
-   vbo_Color4f(r, g, b, a);
-}
-
-
-void GLAPIENTRY
-_es_Normal3f(GLfloat x, GLfloat y, GLfloat z)
-{
-   vbo_Normal3f(x, y, z);
-}
-
-
-void GLAPIENTRY
-_es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-   vbo_MultiTexCoord4f(target, s, t, r, q);
-}
-
-
-void GLAPIENTRY
-_es_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
-{
-   vbo_Materialfv(face, pname, params);
-}
-
-
-void GLAPIENTRY
-_es_Materialf(GLenum face, GLenum pname, GLfloat param)
-{
-   GLfloat p[4];
-   p[0] = param;
-   p[1] = p[2] = p[3] = 0.0F;
-   vbo_Materialfv(face, pname, p);
-}
-
-
-/**
- * A special version of glVertexAttrib4f that does not treat index 0 as
- * VBO_ATTRIB_POS.
- */
-static void
-VertexAttrib4f_nopos(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
-      ATTR(VBO_ATTRIB_GENERIC0 + index, 4, x, y, z, w);
-   else
-      ERROR(GL_INVALID_VALUE);
-}
-
-void GLAPIENTRY
-_es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-   VertexAttrib4f_nopos(index, x, y, z, w);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib1f(GLuint indx, GLfloat x)
-{
-   VertexAttrib4f_nopos(indx, x, 0.0f, 0.0f, 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib1fv(GLuint indx, const GLfloat* values)
-{
-   VertexAttrib4f_nopos(indx, values[0], 0.0f, 0.0f, 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
-{
-   VertexAttrib4f_nopos(indx, x, y, 0.0f, 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib2fv(GLuint indx, const GLfloat* values)
-{
-   VertexAttrib4f_nopos(indx, values[0], values[1], 0.0f, 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
-{
-   VertexAttrib4f_nopos(indx, x, y, z, 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib3fv(GLuint indx, const GLfloat* values)
-{
-   VertexAttrib4f_nopos(indx, values[0], values[1], values[2], 1.0f);
-}
-
-
-void GLAPIENTRY
-_es_VertexAttrib4fv(GLuint indx, const GLfloat* values)
-{
-   VertexAttrib4f_nopos(indx, values[0], values[1], values[2], values[3]);
-}
+/**************************************************************************

+

+Copyright 2002-2008 Tungsten Graphics 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

+on 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

+TUNGSTEN GRAPHICS 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:

+ *   Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/context.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/vtxfmt.h"

+#include "main/dlist.h"

+#include "main/eval.h"

+#include "main/state.h"

+#include "main/light.h"

+#include "main/api_arrayelt.h"

+#include "main/api_noop.h"

+#include "main/dispatch.h"

+

+#include "vbo_context.h"

+

+#ifdef ERROR

+#undef ERROR

+#endif

+

+

+/** ID/name for immediate-mode VBO */

+#define IMM_BUFFER_NAME 0xaabbccdd

+

+

+static void reset_attrfv( struct vbo_exec_context *exec );

+

+

+/**

+ * Close off the last primitive, execute the buffer, restart the

+ * primitive.  

+ */

+static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec )

+{

+   if (exec->vtx.prim_count == 0) {

+      exec->vtx.copied.nr = 0;

+      exec->vtx.vert_count = 0;

+      exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+   }

+   else {

+      GLuint last_begin = exec->vtx.prim[exec->vtx.prim_count-1].begin;

+      GLuint last_count;

+

+      if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {

+	 GLint i = exec->vtx.prim_count - 1;

+	 assert(i >= 0);

+	 exec->vtx.prim[i].count = (exec->vtx.vert_count - 

+				    exec->vtx.prim[i].start);

+      }

+

+      last_count = exec->vtx.prim[exec->vtx.prim_count-1].count;

+

+      /* Execute the buffer and save copied vertices.

+       */

+      if (exec->vtx.vert_count)

+	 vbo_exec_vtx_flush( exec, GL_FALSE );

+      else {

+	 exec->vtx.prim_count = 0;

+	 exec->vtx.copied.nr = 0;

+      }

+

+      /* Emit a glBegin to start the new list.

+       */

+      assert(exec->vtx.prim_count == 0);

+

+      if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {

+	 exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive;

+	 exec->vtx.prim[0].start = 0;

+	 exec->vtx.prim[0].count = 0;

+	 exec->vtx.prim_count++;

+      

+	 if (exec->vtx.copied.nr == last_count)

+	    exec->vtx.prim[0].begin = last_begin;

+      }

+   }

+}

+

+

+/**

+ * Deal with buffer wrapping where provoked by the vertex buffer

+ * filling up, as opposed to upgrade_vertex().

+ */

+void vbo_exec_vtx_wrap( struct vbo_exec_context *exec )

+{

+   GLfloat *data = exec->vtx.copied.buffer;

+   GLuint i;

+

+   /* Run pipeline on current vertices, copy wrapped vertices

+    * to exec->vtx.copied.

+    */

+   vbo_exec_wrap_buffers( exec );

+   

+   /* Copy stored stored vertices to start of new list. 

+    */

+   assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr);

+

+   for (i = 0 ; i < exec->vtx.copied.nr ; i++) {

+      memcpy( exec->vtx.buffer_ptr, data, 

+	      exec->vtx.vertex_size * sizeof(GLfloat));

+      exec->vtx.buffer_ptr += exec->vtx.vertex_size;

+      data += exec->vtx.vertex_size;

+      exec->vtx.vert_count++;

+   }

+

+   exec->vtx.copied.nr = 0;

+}

+

+

+/**

+ * Copy the active vertex's values to the ctx->Current fields.

+ */

+static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )

+{

+   struct gl_context *ctx = exec->ctx;

+   struct vbo_context *vbo = vbo_context(ctx);

+   GLuint i;

+

+   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {

+      if (exec->vtx.attrsz[i]) {

+         /* Note: the exec->vtx.current[i] pointers point into the

+          * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.

+          */

+	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;

+         GLfloat tmp[4];

+

+         COPY_CLEAN_4V(tmp, 

+                       exec->vtx.attrsz[i], 

+                       exec->vtx.attrptr[i]);

+         

+         if (memcmp(current, tmp, sizeof(tmp)) != 0) { 

+            memcpy(current, tmp, sizeof(tmp));

+	 

+            /* Given that we explicitly state size here, there is no need

+             * for the COPY_CLEAN above, could just copy 16 bytes and be

+             * done.  The only problem is when Mesa accesses ctx->Current

+             * directly.

+             */

+            vbo->currval[i].Size = exec->vtx.attrsz[i];

+

+            /* This triggers rather too much recalculation of Mesa state

+             * that doesn't get used (eg light positions).

+             */

+            if (i >= VBO_ATTRIB_MAT_FRONT_AMBIENT &&

+                i <= VBO_ATTRIB_MAT_BACK_INDEXES)

+               ctx->NewState |= _NEW_LIGHT;

+            

+            ctx->NewState |= _NEW_CURRENT_ATTRIB;

+         }

+      }

+   }

+

+   /* Colormaterial -- this kindof sucks.

+    */

+   if (ctx->Light.ColorMaterialEnabled &&

+       exec->vtx.attrsz[VBO_ATTRIB_COLOR0]) {

+      _mesa_update_color_material(ctx, 

+				  ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);

+   }

+}

+

+

+/**

+ * Copy current vertex attribute values into the current vertex.

+ */

+static void

+vbo_exec_copy_from_current(struct vbo_exec_context *exec)

+{

+   struct gl_context *ctx = exec->ctx;

+   struct vbo_context *vbo = vbo_context(ctx);

+   GLint i;

+

+   for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {

+      const GLfloat *current = (GLfloat *) vbo->currval[i].Ptr;

+      switch (exec->vtx.attrsz[i]) {

+      case 4: exec->vtx.attrptr[i][3] = current[3];

+      case 3: exec->vtx.attrptr[i][2] = current[2];

+      case 2: exec->vtx.attrptr[i][1] = current[1];

+      case 1: exec->vtx.attrptr[i][0] = current[0];

+	 break;

+      }

+   }

+}

+

+

+/**

+ * Flush existing data, set new attrib size, replay copied vertices.

+ * This is called when we transition from a small vertex attribute size

+ * to a larger one.  Ex: glTexCoord2f -> glTexCoord4f.

+ * We need to go back over the previous 2-component texcoords and insert

+ * zero and one values.

+ */ 

+static void

+vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,

+                             GLuint attr, GLuint newSize )

+{

+   struct gl_context *ctx = exec->ctx;

+   struct vbo_context *vbo = vbo_context(ctx);

+   const GLint lastcount = exec->vtx.vert_count;

+   GLfloat *old_attrptr[VBO_ATTRIB_MAX];

+   const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */

+   const GLuint oldSize = exec->vtx.attrsz[attr];

+   GLuint i;

+

+   /* Run pipeline on current vertices, copy wrapped vertices

+    * to exec->vtx.copied.

+    */

+   vbo_exec_wrap_buffers( exec );

+

+   if (unlikely(exec->vtx.copied.nr)) {

+      /* We're in the middle of a primitive, keep the old vertex

+       * format around to be able to translate the copied vertices to

+       * the new format.

+       */

+      memcpy(old_attrptr, exec->vtx.attrptr, sizeof(old_attrptr));

+   }

+

+   if (unlikely(oldSize)) {

+      /* Do a COPY_TO_CURRENT to ensure back-copying works for the

+       * case when the attribute already exists in the vertex and is

+       * having its size increased.

+       */

+      vbo_exec_copy_to_current( exec );

+   }

+

+   /* Heuristic: Attempt to isolate attributes received outside

+    * begin/end so that they don't bloat the vertices.

+    */

+   if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END &&

+       !oldSize && lastcount > 8 && exec->vtx.vertex_size) {

+      vbo_exec_copy_to_current( exec );

+      reset_attrfv( exec );

+   }

+

+   /* Fix up sizes:

+    */

+   exec->vtx.attrsz[attr] = newSize;

+   exec->vtx.vertex_size += newSize - oldSize;

+   exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 

+                         (exec->vtx.vertex_size * sizeof(GLfloat)));

+   exec->vtx.vert_count = 0;

+   exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+

+   if (unlikely(oldSize)) {

+      /* Size changed, recalculate all the attrptr[] values

+       */

+      GLfloat *tmp = exec->vtx.vertex;

+

+      for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {

+	 if (exec->vtx.attrsz[i]) {

+	    exec->vtx.attrptr[i] = tmp;

+	    tmp += exec->vtx.attrsz[i];

+	 }

+	 else

+	    exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */

+      }

+

+      /* Copy from current to repopulate the vertex with correct

+       * values.

+       */

+      vbo_exec_copy_from_current( exec );

+   }

+   else {

+      /* Just have to append the new attribute at the end */

+      exec->vtx.attrptr[attr] = exec->vtx.vertex +

+	 exec->vtx.vertex_size - newSize;

+   }

+

+   /* Replay stored vertices to translate them

+    * to new format here.

+    *

+    * -- No need to replay - just copy piecewise

+    */

+   if (unlikely(exec->vtx.copied.nr)) {

+      GLfloat *data = exec->vtx.copied.buffer;

+      GLfloat *dest = exec->vtx.buffer_ptr;

+      GLuint j;

+

+      assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);

+

+      for (i = 0 ; i < exec->vtx.copied.nr ; i++) {

+	 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {

+	    GLuint sz = exec->vtx.attrsz[j];

+

+	    if (sz) {

+	       GLint old_offset = old_attrptr[j] - exec->vtx.vertex;

+	       GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex;

+

+	       if (j == attr) {

+		  if (oldSize) {

+		     GLfloat tmp[4];

+		     COPY_CLEAN_4V(tmp, oldSize, data + old_offset);

+		     COPY_SZ_4V(dest + new_offset, newSize, tmp);

+		  } else {

+		     GLfloat *current = (GLfloat *)vbo->currval[j].Ptr;

+		     COPY_SZ_4V(dest + new_offset, sz, current);

+		  }

+	       }

+	       else {

+		  COPY_SZ_4V(dest + new_offset, sz, data + old_offset);

+	       }

+	    }

+	 }

+

+	 data += old_vtx_size;

+	 dest += exec->vtx.vertex_size;

+      }

+

+      exec->vtx.buffer_ptr = dest;

+      exec->vtx.vert_count += exec->vtx.copied.nr;

+      exec->vtx.copied.nr = 0;

+   }

+}

+

+

+/**

+ * This is when a vertex attribute transitions to a different size.

+ * For example, we saw a bunch of glTexCoord2f() calls and now we got a

+ * glTexCoord4f() call.  We promote the array from size=2 to size=4.

+ */

+static void

+vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)

+{

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+

+   if (newSize > exec->vtx.attrsz[attr]) {

+      /* New size is larger.  Need to flush existing vertices and get

+       * an enlarged vertex format.

+       */

+      vbo_exec_wrap_upgrade_vertex( exec, attr, newSize );

+   }

+   else if (newSize < exec->vtx.active_sz[attr]) {

+      static const GLfloat id[4] = { 0, 0, 0, 1 };

+      GLuint i;

+

+      /* New size is smaller - just need to fill in some

+       * zeros.  Don't need to flush or wrap.

+       */

+      for (i = newSize; i <= exec->vtx.attrsz[attr]; i++)

+	 exec->vtx.attrptr[attr][i-1] = id[i-1];

+   }

+

+   exec->vtx.active_sz[attr] = newSize;

+

+   /* Does setting NeedFlush belong here?  Necessitates resetting

+    * vtxfmt on each flush (otherwise flags won't get reset

+    * afterwards).

+    */

+   if (attr == 0) 

+      ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;

+}

+

+

+/**

+ * This macro is used to implement all the glVertex, glColor, glTexCoord,

+ * glVertexAttrib, etc functions.

+ */

+#define ATTR( A, N, V0, V1, V2, V3 )					\

+do {									\

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;		\

+									\

+   if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)))	\

+      ctx->Driver.BeginVertices( ctx );					\

+   									\

+   if (unlikely(exec->vtx.active_sz[A] != N))				\

+      vbo_exec_fixup_vertex(ctx, A, N);					\

+   									\

+   {									\

+      GLfloat *dest = exec->vtx.attrptr[A];				\

+      if (N>0) dest[0] = V0;						\

+      if (N>1) dest[1] = V1;						\

+      if (N>2) dest[2] = V2;						\

+      if (N>3) dest[3] = V3;						\

+   }									\

+									\

+   if ((A) == 0) {							\

+      /* This is a glVertex call */					\

+      GLuint i;								\

+									\

+      for (i = 0; i < exec->vtx.vertex_size; i++)			\

+	 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i];			\

+									\

+      exec->vtx.buffer_ptr += exec->vtx.vertex_size;			\

+									\

+      /* Set FLUSH_STORED_VERTICES to indicate that there's now */	\

+      /* something to draw (not just updating a color or texcoord).*/	\

+      ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;			\

+									\

+      if (++exec->vtx.vert_count >= exec->vtx.max_vert)			\

+	 vbo_exec_vtx_wrap( exec );					\

+   }									\

+} while (0)

+

+

+#define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )

+#define TAG(x) vbo_##x

+

+#include "vbo_attrib_tmp.h"

+

+

+#if FEATURE_beginend

+

+

+#if FEATURE_evaluators

+

+static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u )

+{

+   GET_CURRENT_CONTEXT( ctx );

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+

+   {

+      GLint i;

+      if (exec->eval.recalculate_maps) 

+	 vbo_exec_eval_update( exec );

+

+      for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {

+	 if (exec->eval.map1[i].map) 

+	    if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz)

+	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz );

+      }

+   }

+

+

+   memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, 

+           exec->vtx.vertex_size * sizeof(GLfloat));

+

+   vbo_exec_do_EvalCoord1f( exec, u );

+

+   memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,

+           exec->vtx.vertex_size * sizeof(GLfloat));

+}

+

+static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v )

+{

+   GET_CURRENT_CONTEXT( ctx );

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+

+   {

+      GLint i;

+      if (exec->eval.recalculate_maps) 

+	 vbo_exec_eval_update( exec );

+

+      for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {

+	 if (exec->eval.map2[i].map) 

+	    if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz)

+	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz );

+      }

+

+      if (ctx->Eval.AutoNormal) 

+	 if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3)

+	    vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3 );

+   }

+

+   memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, 

+           exec->vtx.vertex_size * sizeof(GLfloat));

+

+   vbo_exec_do_EvalCoord2f( exec, u, v );

+

+   memcpy( exec->vtx.vertex, exec->vtx.copied.buffer, 

+           exec->vtx.vertex_size * sizeof(GLfloat));

+}

+

+static void GLAPIENTRY vbo_exec_EvalCoord1fv( const GLfloat *u )

+{

+   vbo_exec_EvalCoord1f( u[0] );

+}

+

+static void GLAPIENTRY vbo_exec_EvalCoord2fv( const GLfloat *u )

+{

+   vbo_exec_EvalCoord2f( u[0], u[1] );

+}

+

+static void GLAPIENTRY vbo_exec_EvalPoint1( GLint i )

+{

+   GET_CURRENT_CONTEXT( ctx );

+   GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /

+		 (GLfloat) ctx->Eval.MapGrid1un);

+   GLfloat u = i * du + ctx->Eval.MapGrid1u1;

+

+   vbo_exec_EvalCoord1f( u );

+}

+

+

+static void GLAPIENTRY vbo_exec_EvalPoint2( GLint i, GLint j )

+{

+   GET_CURRENT_CONTEXT( ctx );

+   GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / 

+		 (GLfloat) ctx->Eval.MapGrid2un);

+   GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / 

+		 (GLfloat) ctx->Eval.MapGrid2vn);

+   GLfloat u = i * du + ctx->Eval.MapGrid2u1;

+   GLfloat v = j * dv + ctx->Eval.MapGrid2v1;

+

+   vbo_exec_EvalCoord2f( u, v );

+}

+

+/* use noop eval mesh */

+#define vbo_exec_EvalMesh1 _mesa_noop_EvalMesh1

+#define vbo_exec_EvalMesh2 _mesa_noop_EvalMesh2

+

+#endif /* FEATURE_evaluators */

+

+

+/**

+ * Flush (draw) vertices.

+ * \param  unmap - leave VBO unmapped after flushing?

+ */

+static void

+vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec, GLboolean unmap)

+{

+   if (exec->vtx.vert_count || unmap) {

+      vbo_exec_vtx_flush( exec, unmap );

+   }

+

+   if (exec->vtx.vertex_size) {

+      vbo_exec_copy_to_current( exec );

+      reset_attrfv( exec );

+   }

+}

+

+

+/**

+ * Called via glBegin.

+ */

+static void GLAPIENTRY vbo_exec_Begin( GLenum mode )

+{

+   GET_CURRENT_CONTEXT( ctx ); 

+

+   if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) {

+      struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+      int i;

+

+      if (ctx->NewState) {

+	 _mesa_update_state( ctx );

+

+	 CALL_Begin(ctx->Exec, (mode));

+	 return;

+      }

+

+      if (!_mesa_valid_to_render(ctx, "glBegin")) {

+         return;

+      }

+

+      /* Heuristic: attempt to isolate attributes occuring outside

+       * begin/end pairs.

+       */

+      if (exec->vtx.vertex_size && !exec->vtx.attrsz[0]) 

+	 vbo_exec_FlushVertices_internal(exec, GL_FALSE);

+

+      i = exec->vtx.prim_count++;

+      exec->vtx.prim[i].mode = mode;

+      exec->vtx.prim[i].begin = 1;

+      exec->vtx.prim[i].end = 0;

+      exec->vtx.prim[i].indexed = 0;

+      exec->vtx.prim[i].weak = 0;

+      exec->vtx.prim[i].pad = 0;

+      exec->vtx.prim[i].start = exec->vtx.vert_count;

+      exec->vtx.prim[i].count = 0;

+      exec->vtx.prim[i].num_instances = 1;

+

+      ctx->Driver.CurrentExecPrimitive = mode;

+   }

+   else 

+      _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );

+      

+}

+

+

+/**

+ * Called via glEnd.

+ */

+static void GLAPIENTRY vbo_exec_End( void )

+{

+   GET_CURRENT_CONTEXT( ctx ); 

+

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {

+      struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+      int idx = exec->vtx.vert_count;

+      int i = exec->vtx.prim_count - 1;

+

+      exec->vtx.prim[i].end = 1; 

+      exec->vtx.prim[i].count = idx - exec->vtx.prim[i].start;

+

+      ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;

+

+      if (exec->vtx.prim_count == VBO_MAX_PRIM)

+	 vbo_exec_vtx_flush( exec, GL_FALSE );

+   }

+   else 

+      _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );

+}

+

+

+/**

+ * Called via glPrimitiveRestartNV()

+ */

+static void GLAPIENTRY

+vbo_exec_PrimitiveRestartNV(void)

+{

+   GLenum curPrim;

+   GET_CURRENT_CONTEXT( ctx ); 

+

+   curPrim = ctx->Driver.CurrentExecPrimitive;

+

+   if (curPrim == PRIM_OUTSIDE_BEGIN_END) {

+      _mesa_error( ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV" );

+   }

+   else {

+      vbo_exec_End();

+      vbo_exec_Begin(curPrim);

+   }

+}

+

+

+

+static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )

+{

+   GLvertexformat *vfmt = &exec->vtxfmt;

+

+   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);

+

+   vfmt->Begin = vbo_exec_Begin;

+   vfmt->End = vbo_exec_End;

+   vfmt->PrimitiveRestartNV = vbo_exec_PrimitiveRestartNV;

+

+   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);

+   _MESA_INIT_EVAL_VTXFMT(vfmt, vbo_exec_);

+

+   vfmt->Rectf = _mesa_noop_Rectf;

+

+   /* from attrib_tmp.h:

+    */

+   vfmt->Color3f = vbo_Color3f;

+   vfmt->Color3fv = vbo_Color3fv;

+   vfmt->Color4f = vbo_Color4f;

+   vfmt->Color4fv = vbo_Color4fv;

+   vfmt->FogCoordfEXT = vbo_FogCoordfEXT;

+   vfmt->FogCoordfvEXT = vbo_FogCoordfvEXT;

+   vfmt->MultiTexCoord1fARB = vbo_MultiTexCoord1f;

+   vfmt->MultiTexCoord1fvARB = vbo_MultiTexCoord1fv;

+   vfmt->MultiTexCoord2fARB = vbo_MultiTexCoord2f;

+   vfmt->MultiTexCoord2fvARB = vbo_MultiTexCoord2fv;

+   vfmt->MultiTexCoord3fARB = vbo_MultiTexCoord3f;

+   vfmt->MultiTexCoord3fvARB = vbo_MultiTexCoord3fv;

+   vfmt->MultiTexCoord4fARB = vbo_MultiTexCoord4f;

+   vfmt->MultiTexCoord4fvARB = vbo_MultiTexCoord4fv;

+   vfmt->Normal3f = vbo_Normal3f;

+   vfmt->Normal3fv = vbo_Normal3fv;

+   vfmt->SecondaryColor3fEXT = vbo_SecondaryColor3fEXT;

+   vfmt->SecondaryColor3fvEXT = vbo_SecondaryColor3fvEXT;

+   vfmt->TexCoord1f = vbo_TexCoord1f;

+   vfmt->TexCoord1fv = vbo_TexCoord1fv;

+   vfmt->TexCoord2f = vbo_TexCoord2f;

+   vfmt->TexCoord2fv = vbo_TexCoord2fv;

+   vfmt->TexCoord3f = vbo_TexCoord3f;

+   vfmt->TexCoord3fv = vbo_TexCoord3fv;

+   vfmt->TexCoord4f = vbo_TexCoord4f;

+   vfmt->TexCoord4fv = vbo_TexCoord4fv;

+   vfmt->Vertex2f = vbo_Vertex2f;

+   vfmt->Vertex2fv = vbo_Vertex2fv;

+   vfmt->Vertex3f = vbo_Vertex3f;

+   vfmt->Vertex3fv = vbo_Vertex3fv;

+   vfmt->Vertex4f = vbo_Vertex4f;

+   vfmt->Vertex4fv = vbo_Vertex4fv;

+   

+   vfmt->VertexAttrib1fARB = vbo_VertexAttrib1fARB;

+   vfmt->VertexAttrib1fvARB = vbo_VertexAttrib1fvARB;

+   vfmt->VertexAttrib2fARB = vbo_VertexAttrib2fARB;

+   vfmt->VertexAttrib2fvARB = vbo_VertexAttrib2fvARB;

+   vfmt->VertexAttrib3fARB = vbo_VertexAttrib3fARB;

+   vfmt->VertexAttrib3fvARB = vbo_VertexAttrib3fvARB;

+   vfmt->VertexAttrib4fARB = vbo_VertexAttrib4fARB;

+   vfmt->VertexAttrib4fvARB = vbo_VertexAttrib4fvARB;

+

+   vfmt->VertexAttrib1fNV = vbo_VertexAttrib1fNV;

+   vfmt->VertexAttrib1fvNV = vbo_VertexAttrib1fvNV;

+   vfmt->VertexAttrib2fNV = vbo_VertexAttrib2fNV;

+   vfmt->VertexAttrib2fvNV = vbo_VertexAttrib2fvNV;

+   vfmt->VertexAttrib3fNV = vbo_VertexAttrib3fNV;

+   vfmt->VertexAttrib3fvNV = vbo_VertexAttrib3fvNV;

+   vfmt->VertexAttrib4fNV = vbo_VertexAttrib4fNV;

+   vfmt->VertexAttrib4fvNV = vbo_VertexAttrib4fvNV;

+

+   /* integer-valued */

+   vfmt->VertexAttribI1i = vbo_VertexAttribI1i;

+   vfmt->VertexAttribI2i = vbo_VertexAttribI2i;

+   vfmt->VertexAttribI3i = vbo_VertexAttribI3i;

+   vfmt->VertexAttribI4i = vbo_VertexAttribI4i;

+   vfmt->VertexAttribI2iv = vbo_VertexAttribI2iv;

+   vfmt->VertexAttribI3iv = vbo_VertexAttribI3iv;

+   vfmt->VertexAttribI4iv = vbo_VertexAttribI4iv;

+

+   /* unsigned integer-valued */

+   vfmt->VertexAttribI1ui = vbo_VertexAttribI1ui;

+   vfmt->VertexAttribI2ui = vbo_VertexAttribI2ui;

+   vfmt->VertexAttribI3ui = vbo_VertexAttribI3ui;

+   vfmt->VertexAttribI4ui = vbo_VertexAttribI4ui;

+   vfmt->VertexAttribI2uiv = vbo_VertexAttribI2uiv;

+   vfmt->VertexAttribI3uiv = vbo_VertexAttribI3uiv;

+   vfmt->VertexAttribI4uiv = vbo_VertexAttribI4uiv;

+

+   vfmt->Materialfv = vbo_Materialfv;

+

+   vfmt->EdgeFlag = vbo_EdgeFlag;

+   vfmt->Indexf = vbo_Indexf;

+   vfmt->Indexfv = vbo_Indexfv;

+

+}

+

+

+#else /* FEATURE_beginend */

+

+

+static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )

+{

+   /* silence warnings */

+   (void) vbo_Color3f;

+   (void) vbo_Color3fv;

+   (void) vbo_Color4f;

+   (void) vbo_Color4fv;

+   (void) vbo_FogCoordfEXT;

+   (void) vbo_FogCoordfvEXT;

+   (void) vbo_MultiTexCoord1f;

+   (void) vbo_MultiTexCoord1fv;

+   (void) vbo_MultiTexCoord2f;

+   (void) vbo_MultiTexCoord2fv;

+   (void) vbo_MultiTexCoord3f;

+   (void) vbo_MultiTexCoord3fv;

+   (void) vbo_MultiTexCoord4f;

+   (void) vbo_MultiTexCoord4fv;

+   (void) vbo_Normal3f;

+   (void) vbo_Normal3fv;

+   (void) vbo_SecondaryColor3fEXT;

+   (void) vbo_SecondaryColor3fvEXT;

+   (void) vbo_TexCoord1f;

+   (void) vbo_TexCoord1fv;

+   (void) vbo_TexCoord2f;

+   (void) vbo_TexCoord2fv;

+   (void) vbo_TexCoord3f;

+   (void) vbo_TexCoord3fv;

+   (void) vbo_TexCoord4f;

+   (void) vbo_TexCoord4fv;

+   (void) vbo_Vertex2f;

+   (void) vbo_Vertex2fv;

+   (void) vbo_Vertex3f;

+   (void) vbo_Vertex3fv;

+   (void) vbo_Vertex4f;

+   (void) vbo_Vertex4fv;

+

+   (void) vbo_VertexAttrib1fARB;

+   (void) vbo_VertexAttrib1fvARB;

+   (void) vbo_VertexAttrib2fARB;

+   (void) vbo_VertexAttrib2fvARB;

+   (void) vbo_VertexAttrib3fARB;

+   (void) vbo_VertexAttrib3fvARB;

+   (void) vbo_VertexAttrib4fARB;

+   (void) vbo_VertexAttrib4fvARB;

+

+   (void) vbo_VertexAttrib1fNV;

+   (void) vbo_VertexAttrib1fvNV;

+   (void) vbo_VertexAttrib2fNV;

+   (void) vbo_VertexAttrib2fvNV;

+   (void) vbo_VertexAttrib3fNV;

+   (void) vbo_VertexAttrib3fvNV;

+   (void) vbo_VertexAttrib4fNV;

+   (void) vbo_VertexAttrib4fvNV;

+

+   (void) vbo_Materialfv;

+

+   (void) vbo_EdgeFlag;

+   (void) vbo_Indexf;

+   (void) vbo_Indexfv;

+}

+

+

+#endif /* FEATURE_beginend */

+

+

+/**

+ * Tell the VBO module to use a real OpenGL vertex buffer object to

+ * store accumulated immediate-mode vertex data.

+ * This replaces the malloced buffer which was created in

+ * vb_exec_vtx_init() below.

+ */

+void vbo_use_buffer_objects(struct gl_context *ctx)

+{

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+   /* Any buffer name but 0 can be used here since this bufferobj won't

+    * go into the bufferobj hashtable.

+    */

+   GLuint bufName = IMM_BUFFER_NAME;

+   GLenum target = GL_ARRAY_BUFFER_ARB;

+   GLenum usage = GL_STREAM_DRAW_ARB;

+   GLsizei size = VBO_VERT_BUFFER_SIZE;

+

+   /* Make sure this func is only used once */

+   assert(exec->vtx.bufferobj == ctx->Shared->NullBufferObj);

+   if (exec->vtx.buffer_map) {

+      _mesa_align_free(exec->vtx.buffer_map);

+      exec->vtx.buffer_map = NULL;

+      exec->vtx.buffer_ptr = NULL;

+   }

+

+   /* Allocate a real buffer object now */

+   _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);

+   exec->vtx.bufferobj = ctx->Driver.NewBufferObject(ctx, bufName, target);

+   ctx->Driver.BufferData(ctx, target, size, NULL, usage, exec->vtx.bufferobj);

+}

+

+

+/**

+ * If this function is called, all VBO buffers will be unmapped when

+ * we flush.

+ * Otherwise, if a simple command like glColor3f() is called and we flush,

+ * the current VBO may be left mapped.

+ */

+void

+vbo_always_unmap_buffers(struct gl_context *ctx)

+{

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+   exec->begin_vertices_flags |= FLUSH_STORED_VERTICES;

+}

+

+

+void vbo_exec_vtx_init( struct vbo_exec_context *exec )

+{

+   struct gl_context *ctx = exec->ctx;

+   struct vbo_context *vbo = vbo_context(ctx);

+   GLuint i;

+

+   /* Allocate a buffer object.  Will just reuse this object

+    * continuously, unless vbo_use_buffer_objects() is called to enable

+    * use of real VBOs.

+    */

+   _mesa_reference_buffer_object(ctx,

+                                 &exec->vtx.bufferobj,

+                                 ctx->Shared->NullBufferObj);

+

+   ASSERT(!exec->vtx.buffer_map);

+   exec->vtx.buffer_map = (GLfloat *)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);

+   exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+

+   vbo_exec_vtxfmt_init( exec );

+

+   /* Hook our functions into the dispatch table.

+    */

+   _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt );

+

+   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {

+      ASSERT(i < Elements(exec->vtx.attrsz));

+      exec->vtx.attrsz[i] = 0;

+      ASSERT(i < Elements(exec->vtx.active_sz));

+      exec->vtx.active_sz[i] = 0;

+   }

+   for (i = 0 ; i < VERT_ATTRIB_MAX; i++) {

+      ASSERT(i < Elements(exec->vtx.inputs));

+      ASSERT(i < Elements(exec->vtx.arrays));

+      exec->vtx.inputs[i] = &exec->vtx.arrays[i];

+   }

+   

+   {

+      struct gl_client_array *arrays = exec->vtx.arrays;

+      unsigned i;

+

+      memcpy(arrays,      vbo->legacy_currval,  16 * sizeof(arrays[0]));

+      memcpy(arrays + 16, vbo->generic_currval, 16 * sizeof(arrays[0]));

+

+      for (i = 0; i < 16; ++i) {

+         arrays[i     ].BufferObj = NULL;

+         arrays[i + 16].BufferObj = NULL;

+         _mesa_reference_buffer_object(ctx, &arrays[i     ].BufferObj,

+                                       vbo->legacy_currval[i].BufferObj);

+         _mesa_reference_buffer_object(ctx, &arrays[i + 16].BufferObj,

+                                       vbo->generic_currval[i].BufferObj);

+      }

+   }

+

+   exec->vtx.vertex_size = 0;

+

+   exec->begin_vertices_flags = FLUSH_UPDATE_CURRENT;

+}

+

+

+void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )

+{

+   /* using a real VBO for vertex data */

+   struct gl_context *ctx = exec->ctx;

+   unsigned i;

+

+   /* True VBOs should already be unmapped

+    */

+   if (exec->vtx.buffer_map) {

+      ASSERT(exec->vtx.bufferobj->Name == 0 ||

+             exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);

+      if (exec->vtx.bufferobj->Name == 0) {

+         _mesa_align_free(exec->vtx.buffer_map);

+         exec->vtx.buffer_map = NULL;

+         exec->vtx.buffer_ptr = NULL;

+      }

+   }

+

+   /* Drop any outstanding reference to the vertex buffer

+    */

+   for (i = 0; i < Elements(exec->vtx.arrays); i++) {

+      _mesa_reference_buffer_object(ctx,

+                                    &exec->vtx.arrays[i].BufferObj,

+                                    NULL);

+   }

+

+   /* Free the vertex buffer.  Unmap first if needed.

+    */

+   if (_mesa_bufferobj_mapped(exec->vtx.bufferobj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, exec->vtx.bufferobj);

+   }

+   _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);

+}

+

+

+/**

+ * Called upon first glVertex, glColor, glTexCoord, etc.

+ */

+void vbo_exec_BeginVertices( struct gl_context *ctx )

+{

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+

+   vbo_exec_vtx_map( exec );

+

+   assert((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);

+   assert(exec->begin_vertices_flags);

+

+   ctx->Driver.NeedFlush |= exec->begin_vertices_flags;

+}

+

+

+/**

+ * Called via ctx->Driver.FlushVertices()

+ * \param flags  bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT

+ */

+void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags )

+{

+   struct vbo_exec_context *exec = &vbo_context(ctx)->exec;

+

+#ifdef DEBUG

+   /* debug check: make sure we don't get called recursively */

+   exec->flush_call_depth++;

+   assert(exec->flush_call_depth == 1);

+#endif

+

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {

+      /* We've had glBegin but not glEnd! */

+#ifdef DEBUG

+      exec->flush_call_depth--;

+      assert(exec->flush_call_depth == 0);

+#endif

+      return;

+   }

+

+   /* Flush (draw), and make sure VBO is left unmapped when done */

+   vbo_exec_FlushVertices_internal(exec, GL_TRUE);

+

+   /* Need to do this to ensure BeginVertices gets called again:

+    */

+   ctx->Driver.NeedFlush &= ~(FLUSH_UPDATE_CURRENT | flags);

+

+#ifdef DEBUG

+   exec->flush_call_depth--;

+   assert(exec->flush_call_depth == 0);

+#endif

+}

+

+

+static void reset_attrfv( struct vbo_exec_context *exec )

+{   

+   GLuint i;

+

+   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {

+      exec->vtx.attrsz[i] = 0;

+      exec->vtx.active_sz[i] = 0;

+   }

+

+   exec->vtx.vertex_size = 0;

+}

+      

+

+void GLAPIENTRY

+_es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)

+{

+   vbo_Color4f(r, g, b, a);

+}

+

+

+void GLAPIENTRY

+_es_Normal3f(GLfloat x, GLfloat y, GLfloat z)

+{

+   vbo_Normal3f(x, y, z);

+}

+

+

+void GLAPIENTRY

+_es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)

+{

+   vbo_MultiTexCoord4f(target, s, t, r, q);

+}

+

+

+void GLAPIENTRY

+_es_Materialfv(GLenum face, GLenum pname, const GLfloat *params)

+{

+   vbo_Materialfv(face, pname, params);

+}

+

+

+void GLAPIENTRY

+_es_Materialf(GLenum face, GLenum pname, GLfloat param)

+{

+   GLfloat p[4];

+   p[0] = param;

+   p[1] = p[2] = p[3] = 0.0F;

+   vbo_Materialfv(face, pname, p);

+}

+

+

+/**

+ * A special version of glVertexAttrib4f that does not treat index 0 as

+ * VBO_ATTRIB_POS.

+ */

+static void

+VertexAttrib4f_nopos(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)

+      ATTR(VBO_ATTRIB_GENERIC0 + index, 4, x, y, z, w);

+   else

+      ERROR(GL_INVALID_VALUE);

+}

+

+void GLAPIENTRY

+_es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

+{

+   VertexAttrib4f_nopos(index, x, y, z, w);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib1f(GLuint indx, GLfloat x)

+{

+   VertexAttrib4f_nopos(indx, x, 0.0f, 0.0f, 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib1fv(GLuint indx, const GLfloat* values)

+{

+   VertexAttrib4f_nopos(indx, values[0], 0.0f, 0.0f, 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)

+{

+   VertexAttrib4f_nopos(indx, x, y, 0.0f, 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib2fv(GLuint indx, const GLfloat* values)

+{

+   VertexAttrib4f_nopos(indx, values[0], values[1], 0.0f, 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)

+{

+   VertexAttrib4f_nopos(indx, x, y, z, 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib3fv(GLuint indx, const GLfloat* values)

+{

+   VertexAttrib4f_nopos(indx, values[0], values[1], values[2], 1.0f);

+}

+

+

+void GLAPIENTRY

+_es_VertexAttrib4fv(GLuint indx, const GLfloat* values)

+{

+   VertexAttrib4f_nopos(indx, values[0], values[1], values[2], values[3]);

+}

diff --git a/mesalib/src/mesa/vbo/vbo_exec_array.c b/mesalib/src/mesa/vbo/vbo_exec_array.c
index 98d6badc4..37656c23a 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_array.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_array.c
@@ -1,1336 +1,1336 @@
-/**************************************************************************
- * 
- * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright 2009 VMware, Inc.
- * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.
- * 
- **************************************************************************/
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/state.h"
-#include "main/api_validate.h"
-#include "main/varray.h"
-#include "main/bufferobj.h"
-#include "main/enums.h"
-#include "main/macros.h"
-
-#include "vbo_context.h"
-
-
-/**
- * All vertex buffers should be in an unmapped state when we're about
- * to draw.  This debug function checks that.
- */
-static void
-check_buffers_are_unmapped(const struct gl_client_array **inputs)
-{
-#ifdef DEBUG
-   GLuint i;
-
-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
-      if (inputs[i]) {
-         struct gl_buffer_object *obj = inputs[i]->BufferObj;
-         assert(!_mesa_bufferobj_mapped(obj));
-         (void) obj;
-      }
-   }
-#endif
-}
-
-
-/**
- * A debug function that may be called from other parts of Mesa as
- * needed during debugging.
- */
-void
-vbo_check_buffers_are_unmapped(struct gl_context *ctx)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   /* check the current vertex arrays */
-   check_buffers_are_unmapped(exec->array.inputs);
-   /* check the current glBegin/glVertex/glEnd-style VBO */
-   assert(!_mesa_bufferobj_mapped(exec->vtx.bufferobj));
-}
-
-
-
-/**
- * Compute min and max elements by scanning the index buffer for
- * glDraw[Range]Elements() calls.
- * If primitive restart is enabled, we need to ignore restart
- * indexes when computing min/max.
- */
-void
-vbo_get_minmax_index(struct gl_context *ctx,
-		     const struct _mesa_prim *prim,
-		     const struct _mesa_index_buffer *ib,
-		     GLuint *min_index, GLuint *max_index)
-{
-   const GLboolean restart = ctx->Array.PrimitiveRestart;
-   const GLuint restartIndex = ctx->Array.RestartIndex;
-   const GLuint count = prim->count;
-   const void *indices;
-   GLuint i;
-
-   if (_mesa_is_bufferobj(ib->obj)) {
-      const GLvoid *map =
-         ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,
-                               GL_READ_ONLY, ib->obj);
-      indices = ADD_POINTERS(map, ib->ptr);
-   } else {
-      indices = ib->ptr;
-   }
-
-   switch (ib->type) {
-   case GL_UNSIGNED_INT: {
-      const GLuint *ui_indices = (const GLuint *)indices;
-      GLuint max_ui = 0;
-      GLuint min_ui = ~0U;
-      if (restart) {
-         for (i = 0; i < count; i++) {
-            if (ui_indices[i] != restartIndex) {
-               if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
-               if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
-            }
-         }
-      }
-      else {
-         for (i = 0; i < count; i++) {
-            if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
-            if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
-         }
-      }
-      *min_index = min_ui;
-      *max_index = max_ui;
-      break;
-   }
-   case GL_UNSIGNED_SHORT: {
-      const GLushort *us_indices = (const GLushort *)indices;
-      GLuint max_us = 0;
-      GLuint min_us = ~0U;
-      if (restart) {
-         for (i = 0; i < count; i++) {
-            if (us_indices[i] != restartIndex) {
-               if (us_indices[i] > max_us) max_us = us_indices[i];
-               if (us_indices[i] < min_us) min_us = us_indices[i];
-            }
-         }
-      }
-      else {
-         for (i = 0; i < count; i++) {
-            if (us_indices[i] > max_us) max_us = us_indices[i];
-            if (us_indices[i] < min_us) min_us = us_indices[i];
-         }
-      }
-      *min_index = min_us;
-      *max_index = max_us;
-      break;
-   }
-   case GL_UNSIGNED_BYTE: {
-      const GLubyte *ub_indices = (const GLubyte *)indices;
-      GLuint max_ub = 0;
-      GLuint min_ub = ~0U;
-      if (restart) {
-         for (i = 0; i < count; i++) {
-            if (ub_indices[i] != restartIndex) {
-               if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
-               if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
-            }
-         }
-      }
-      else {
-         for (i = 0; i < count; i++) {
-            if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
-            if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
-         }
-      }
-      *min_index = min_ub;
-      *max_index = max_ub;
-      break;
-   }
-   default:
-      assert(0);
-      break;
-   }
-
-   if (_mesa_is_bufferobj(ib->obj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, ib->obj);
-   }
-}
-
-
-/**
- * Check that element 'j' of the array has reasonable data.
- * Map VBO if needed.
- * For debugging purposes; not normally used.
- */
-static void
-check_array_data(struct gl_context *ctx, struct gl_client_array *array,
-                 GLuint attrib, GLuint j)
-{
-   if (array->Enabled) {
-      const void *data = array->Ptr;
-      if (_mesa_is_bufferobj(array->BufferObj)) {
-         if (!array->BufferObj->Pointer) {
-            /* need to map now */
-            array->BufferObj->Pointer =
-               ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER_ARB,
-                                     GL_READ_ONLY, array->BufferObj);
-         }
-         data = ADD_POINTERS(data, array->BufferObj->Pointer);
-      }
-      switch (array->Type) {
-      case GL_FLOAT:
-         {
-            GLfloat *f = (GLfloat *) ((GLubyte *) data + array->StrideB * j);
-            GLint k;
-            for (k = 0; k < array->Size; k++) {
-               if (IS_INF_OR_NAN(f[k]) ||
-                   f[k] >= 1.0e20 || f[k] <= -1.0e10) {
-                  printf("Bad array data:\n");
-                  printf("  Element[%u].%u = %f\n", j, k, f[k]);
-                  printf("  Array %u at %p\n", attrib, (void* ) array);
-                  printf("  Type 0x%x, Size %d, Stride %d\n",
-			 array->Type, array->Size, array->Stride);
-                  printf("  Address/offset %p in Buffer Object %u\n",
-			 array->Ptr, array->BufferObj->Name);
-                  f[k] = 1.0; /* XXX replace the bad value! */
-               }
-               /*assert(!IS_INF_OR_NAN(f[k]));*/
-            }
-         }
-         break;
-      default:
-         ;
-      }
-   }
-}
-
-
-/**
- * Unmap the buffer object referenced by given array, if mapped.
- */
-static void
-unmap_array_buffer(struct gl_context *ctx, struct gl_client_array *array)
-{
-   if (array->Enabled &&
-       _mesa_is_bufferobj(array->BufferObj) &&
-       _mesa_bufferobj_mapped(array->BufferObj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, array->BufferObj);
-   }
-}
-
-
-/**
- * Examine the array's data for NaNs, etc.
- * For debug purposes; not normally used.
- */
-static void
-check_draw_elements_data(struct gl_context *ctx, GLsizei count, GLenum elemType,
-                         const void *elements, GLint basevertex)
-{
-   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-   const void *elemMap;
-   GLint i, k;
-
-   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
-      elemMap = ctx->Driver.MapBuffer(ctx,
-                                      GL_ELEMENT_ARRAY_BUFFER_ARB,
-                                      GL_READ_ONLY,
-                                      ctx->Array.ElementArrayBufferObj);
-      elements = ADD_POINTERS(elements, elemMap);
-   }
-
-   for (i = 0; i < count; i++) {
-      GLuint j;
-
-      /* j = element[i] */
-      switch (elemType) {
-      case GL_UNSIGNED_BYTE:
-         j = ((const GLubyte *) elements)[i];
-         break;
-      case GL_UNSIGNED_SHORT:
-         j = ((const GLushort *) elements)[i];
-         break;
-      case GL_UNSIGNED_INT:
-         j = ((const GLuint *) elements)[i];
-         break;
-      default:
-         assert(0);
-      }
-
-      /* check element j of each enabled array */
-      check_array_data(ctx, &arrayObj->Vertex, VERT_ATTRIB_POS, j);
-      check_array_data(ctx, &arrayObj->Normal, VERT_ATTRIB_NORMAL, j);
-      check_array_data(ctx, &arrayObj->Color, VERT_ATTRIB_COLOR0, j);
-      check_array_data(ctx, &arrayObj->SecondaryColor, VERT_ATTRIB_COLOR1, j);
-      for (k = 0; k < Elements(arrayObj->TexCoord); k++) {
-         check_array_data(ctx, &arrayObj->TexCoord[k], VERT_ATTRIB_TEX0 + k, j);
-      }
-      for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {
-         check_array_data(ctx, &arrayObj->VertexAttrib[k],
-                          VERT_ATTRIB_GENERIC0 + k, j);
-      }
-   }
-
-   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
-      ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,
-			      ctx->Array.ElementArrayBufferObj);
-   }
-
-   unmap_array_buffer(ctx, &arrayObj->Vertex);
-   unmap_array_buffer(ctx, &arrayObj->Normal);
-   unmap_array_buffer(ctx, &arrayObj->Color);
-   for (k = 0; k < Elements(arrayObj->TexCoord); k++) {
-      unmap_array_buffer(ctx, &arrayObj->TexCoord[k]);
-   }
-   for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {
-      unmap_array_buffer(ctx, &arrayObj->VertexAttrib[k]);
-   }
-}
-
-
-/**
- * Check array data, looking for NaNs, etc.
- */
-static void
-check_draw_arrays_data(struct gl_context *ctx, GLint start, GLsizei count)
-{
-   /* TO DO */
-}
-
-
-/**
- * Print info/data for glDrawArrays(), for debugging.
- */
-static void
-print_draw_arrays(struct gl_context *ctx,
-                  GLenum mode, GLint start, GLsizei count)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   int i;
-
-   printf("vbo_exec_DrawArrays(mode 0x%x, start %d, count %d):\n",
-	  mode, start, count);
-
-   for (i = 0; i < 32; i++) {
-      GLuint bufName = exec->array.inputs[i]->BufferObj->Name;
-      GLint stride = exec->array.inputs[i]->Stride;
-      printf("attr %2d: size %d stride %d  enabled %d  "
-	     "ptr %p  Bufobj %u\n",
-	     i,
-	     exec->array.inputs[i]->Size,
-	     stride,
-	     /*exec->array.inputs[i]->Enabled,*/
-	     exec->array.legacy_array[i]->Enabled,
-	     exec->array.inputs[i]->Ptr,
-	     bufName);
-
-      if (bufName) {
-         struct gl_buffer_object *buf = _mesa_lookup_bufferobj(ctx, bufName);
-         GLubyte *p = ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER_ARB,
-                                            GL_READ_ONLY_ARB, buf);
-         int offset = (int) (GLintptr) exec->array.inputs[i]->Ptr;
-         float *f = (float *) (p + offset);
-         int *k = (int *) f;
-         int i;
-         int n = (count * stride) / 4;
-         if (n > 32)
-            n = 32;
-         printf("  Data at offset %d:\n", offset);
-         for (i = 0; i < n; i++) {
-            printf("    float[%d] = 0x%08x %f\n", i, k[i], f[i]);
-         }
-         ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, buf);
-      }
-   }
-}
-
-
-/**
- * Bind the VBO executor to the current vertex array object prior
- * to drawing.
- *
- * Just translate the arrayobj into a sane layout.
- */
-static void
-bind_array_obj(struct gl_context *ctx)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-   GLuint i;
-
-   /* TODO: Fix the ArrayObj struct to keep legacy arrays in an array
-    * rather than as individual named arrays.  Then this function can
-    * go away.
-    */
-   exec->array.legacy_array[VERT_ATTRIB_POS] = &arrayObj->Vertex;
-   exec->array.legacy_array[VERT_ATTRIB_WEIGHT] = &arrayObj->Weight;
-   exec->array.legacy_array[VERT_ATTRIB_NORMAL] = &arrayObj->Normal;
-   exec->array.legacy_array[VERT_ATTRIB_COLOR0] = &arrayObj->Color;
-   exec->array.legacy_array[VERT_ATTRIB_COLOR1] = &arrayObj->SecondaryColor;
-   exec->array.legacy_array[VERT_ATTRIB_FOG] = &arrayObj->FogCoord;
-   exec->array.legacy_array[VERT_ATTRIB_COLOR_INDEX] = &arrayObj->Index;
-   if (arrayObj->PointSize.Enabled) {
-      /* this aliases COLOR_INDEX */
-      exec->array.legacy_array[VERT_ATTRIB_POINT_SIZE] = &arrayObj->PointSize;
-   }
-   exec->array.legacy_array[VERT_ATTRIB_EDGEFLAG] = &arrayObj->EdgeFlag;
-
-   for (i = 0; i < Elements(arrayObj->TexCoord); i++)
-      exec->array.legacy_array[VERT_ATTRIB_TEX0 + i] = &arrayObj->TexCoord[i];
-
-   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {
-      assert(i < Elements(exec->array.generic_array));
-      exec->array.generic_array[i] = &arrayObj->VertexAttrib[i];
-   }
-   
-   exec->array.array_obj = arrayObj->Name;
-}
-
-
-/**
- * Set the vbo->exec->inputs[] pointers to point to the enabled
- * vertex arrays.  This depends on the current vertex program/shader
- * being executed because of whether or not generic vertex arrays
- * alias the conventional vertex arrays.
- * For arrays that aren't enabled, we set the input[attrib] pointer
- * to point at a zero-stride current value "array".
- */
-static void
-recalculate_input_bindings(struct gl_context *ctx)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   const struct gl_client_array **inputs = &exec->array.inputs[0];
-   GLbitfield const_inputs = 0x0;
-   GLuint i;
-
-   exec->array.program_mode = get_program_mode(ctx);
-   exec->array.enabled_flags = ctx->Array.ArrayObj->_Enabled;
-
-   switch (exec->array.program_mode) {
-   case VP_NONE:
-      /* When no vertex program is active (or the vertex program is generated
-       * from fixed-function state).  We put the material values into the
-       * generic slots.  This is the only situation where material values
-       * are available as per-vertex attributes.
-       */
-      for (i = 0; i <= VERT_ATTRIB_TEX7; i++) {
-	 if (exec->array.legacy_array[i]->Enabled)
-	    inputs[i] = exec->array.legacy_array[i];
-	 else {
-	    inputs[i] = &vbo->legacy_currval[i];
-            const_inputs |= 1 << i;
-         }
-      }
-
-      for (i = 0; i < MAT_ATTRIB_MAX; i++) {
-	 inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->mat_currval[i];
-         const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);
-      }
-
-      /* Could use just about anything, just to fill in the empty
-       * slots:
-       */
-      for (i = MAT_ATTRIB_MAX; i < VERT_ATTRIB_MAX - VERT_ATTRIB_GENERIC0; i++) {
-	 inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->generic_currval[i];
-         const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);
-      }
-
-      /* There is no need to make _NEW_ARRAY dirty here for the TnL program,
-       * because it already takes care of invalidating the state necessary
-       * to revalidate vertex arrays. Not marking the state as dirty also
-       * improves performance (quite significantly in some apps).
-       */
-      if (!ctx->VertexProgram._MaintainTnlProgram)
-         ctx->NewState |= _NEW_ARRAY;
-      break;
-
-   case VP_NV:
-      /* NV_vertex_program - attribute arrays alias and override
-       * conventional, legacy arrays.  No materials, and the generic
-       * slots are vacant.
-       */
-      for (i = 0; i <= VERT_ATTRIB_TEX7; i++) {
-	 if (exec->array.generic_array[i]->Enabled)
-	    inputs[i] = exec->array.generic_array[i];
-	 else if (exec->array.legacy_array[i]->Enabled)
-	    inputs[i] = exec->array.legacy_array[i];
-	 else {
-	    inputs[i] = &vbo->legacy_currval[i];
-            const_inputs |= 1 << i;
-         }
-      }
-
-      /* Could use just about anything, just to fill in the empty
-       * slots:
-       */
-      for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
-	 inputs[i] = &vbo->generic_currval[i - VERT_ATTRIB_GENERIC0];
-         const_inputs |= 1 << i;
-      }
-
-      ctx->NewState |= _NEW_ARRAY;
-      break;
-
-   case VP_ARB:
-      /* GL_ARB_vertex_program or GLSL vertex shader - Only the generic[0]
-       * attribute array aliases and overrides the legacy position array.  
-       *
-       * Otherwise, legacy attributes available in the legacy slots,
-       * generic attributes in the generic slots and materials are not
-       * available as per-vertex attributes.
-       */
-      if (exec->array.generic_array[0]->Enabled)
-	 inputs[0] = exec->array.generic_array[0];
-      else if (exec->array.legacy_array[0]->Enabled)
-	 inputs[0] = exec->array.legacy_array[0];
-      else {
-	 inputs[0] = &vbo->legacy_currval[0];
-         const_inputs |= 1 << 0;
-      }
-
-      for (i = 1; i <= VERT_ATTRIB_TEX7; i++) {
-	 if (exec->array.legacy_array[i]->Enabled)
-	    inputs[i] = exec->array.legacy_array[i];
-	 else {
-	    inputs[i] = &vbo->legacy_currval[i];
-            const_inputs |= 1 << i;
-         }
-      }
-
-      for (i = 0; i < MAX_VERTEX_GENERIC_ATTRIBS; i++) {
-	 if (exec->array.generic_array[i]->Enabled)
-	    inputs[VERT_ATTRIB_GENERIC0 + i] = exec->array.generic_array[i];
-	 else {
-	    inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->generic_currval[i];
-            const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);
-         }
-      }
-
-      ctx->NewState |= _NEW_ARRAY;
-      break;
-   }
-
-   _mesa_set_varying_vp_inputs( ctx, ~const_inputs );
-}
-
-
-/**
- * Examine the enabled vertex arrays to set the exec->array.inputs[] values.
- * These will point to the arrays to actually use for drawing.  Some will
- * be user-provided arrays, other will be zero-stride const-valued arrays.
- * Note that this might set the _NEW_ARRAY dirty flag so state validation
- * must be done after this call.
- */
-static void
-bind_arrays(struct gl_context *ctx)
-{
-   if (!ctx->Array.RebindArrays) {
-      return;
-   }
-
-   bind_array_obj(ctx);
-   recalculate_input_bindings(ctx);
-   ctx->Array.RebindArrays = GL_FALSE;
-}
-
-
-/**
- * Helper function called by the other DrawArrays() functions below.
- * This is where we handle primitive restart for drawing non-indexed
- * arrays.  If primitive restart is enabled, it typically means
- * splitting one DrawArrays() into two.
- */
-static void
-vbo_draw_arrays(struct gl_context *ctx, GLenum mode, GLint start,
-                GLsizei count, GLuint numInstances)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   struct _mesa_prim prim[2];
-
-   bind_arrays(ctx);
-
-   /* Again... because we may have changed the bitmask of per-vertex varying
-    * attributes.  If we regenerate the fixed-function vertex program now
-    * we may be able to prune down the number of vertex attributes which we
-    * need in the shader.
-    */
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   prim[0].begin = 1;
-   prim[0].end = 1;
-   prim[0].weak = 0;
-   prim[0].pad = 0;
-   prim[0].mode = mode;
-   prim[0].start = 0; /* filled in below */
-   prim[0].count = 0; /* filled in below */
-   prim[0].indexed = 0;
-   prim[0].basevertex = 0;
-   prim[0].num_instances = numInstances;
-
-   /* Implement the primitive restart index */
-   if (ctx->Array.PrimitiveRestart && ctx->Array.RestartIndex < count) {
-      GLuint primCount = 0;
-
-      if (ctx->Array.RestartIndex == start) {
-         /* special case: RestartIndex at beginning */
-         if (count > 1) {
-            prim[0].start = start + 1;
-            prim[0].count = count - 1;
-            primCount = 1;
-         }
-      }
-      else if (ctx->Array.RestartIndex == start + count - 1) {
-         /* special case: RestartIndex at end */
-         if (count > 1) {
-            prim[0].start = start;
-            prim[0].count = count - 1;
-            primCount = 1;
-         }
-      }
-      else {
-         /* general case: RestartIndex in middle, split into two prims */
-         prim[0].start = start;
-         prim[0].count = ctx->Array.RestartIndex - start;
-
-         prim[1] = prim[0];
-         prim[1].start = ctx->Array.RestartIndex + 1;
-         prim[1].count = count - prim[1].start;
-
-         primCount = 2;
-      }
-
-      if (primCount > 0) {
-         /* draw one or two prims */
-         check_buffers_are_unmapped(exec->array.inputs);
-         vbo->draw_prims(ctx, exec->array.inputs, prim, primCount, NULL,
-                         GL_TRUE, start, start + count - 1);
-      }
-   }
-   else {
-      /* no prim restart */
-      prim[0].start = start;
-      prim[0].count = count;
-
-      check_buffers_are_unmapped(exec->array.inputs);
-      vbo->draw_prims(ctx, exec->array.inputs, prim, 1, NULL,
-                      GL_TRUE, start, start + count - 1);
-   }
-}
-
-
-
-/**
- * Called from glDrawArrays when in immediate mode (not display list mode).
- */
-static void GLAPIENTRY
-vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx, "glDrawArrays(%s, %d, %d)\n",
-                  _mesa_lookup_enum_by_nr(mode), start, count);
-
-   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
-      return;
-
-   FLUSH_CURRENT( ctx, 0 );
-
-   if (!_mesa_valid_to_render(ctx, "glDrawArrays")) {
-      return;
-   }
-
-   if (0)
-      check_draw_arrays_data(ctx, start, count);
-
-   vbo_draw_arrays(ctx, mode, start, count, 1);
-
-   if (0)
-      print_draw_arrays(ctx, mode, start, count);
-}
-
-
-/**
- * Called from glDrawArraysInstanced when in immediate mode (not
- * display list mode).
- */
-static void GLAPIENTRY
-vbo_exec_DrawArraysInstanced(GLenum mode, GLint start, GLsizei count,
-                             GLsizei numInstances)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx, "glDrawArraysInstanced(%s, %d, %d, %d)\n",
-                  _mesa_lookup_enum_by_nr(mode), start, count, numInstances);
-
-   if (!_mesa_validate_DrawArraysInstanced(ctx, mode, start, count, numInstances))
-      return;
-
-   FLUSH_CURRENT( ctx, 0 );
-
-   if (!_mesa_valid_to_render(ctx, "glDrawArraysInstanced")) {
-      return;
-   }
-
-   if (0)
-      check_draw_arrays_data(ctx, start, count);
-
-   vbo_draw_arrays(ctx, mode, start, count, numInstances);
-
-   if (0)
-      print_draw_arrays(ctx, mode, start, count);
-}
-
-
-/**
- * Map GL_ELEMENT_ARRAY_BUFFER and print contents.
- * For debugging.
- */
-static void
-dump_element_buffer(struct gl_context *ctx, GLenum type)
-{
-   const GLvoid *map = ctx->Driver.MapBuffer(ctx,
-                                             GL_ELEMENT_ARRAY_BUFFER_ARB,
-                                             GL_READ_ONLY,
-                                             ctx->Array.ElementArrayBufferObj);
-   switch (type) {
-   case GL_UNSIGNED_BYTE:
-      {
-         const GLubyte *us = (const GLubyte *) map;
-         GLint i;
-         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size; i++) {
-            printf("%02x ", us[i]);
-            if (i % 32 == 31)
-               printf("\n");
-         }
-         printf("\n");
-      }
-      break;
-   case GL_UNSIGNED_SHORT:
-      {
-         const GLushort *us = (const GLushort *) map;
-         GLint i;
-         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 2; i++) {
-            printf("%04x ", us[i]);
-            if (i % 16 == 15)
-               printf("\n");
-         }
-         printf("\n");
-      }
-      break;
-   case GL_UNSIGNED_INT:
-      {
-         const GLuint *us = (const GLuint *) map;
-         GLint i;
-         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 4; i++) {
-            printf("%08x ", us[i]);
-            if (i % 8 == 7)
-               printf("\n");
-         }
-         printf("\n");
-      }
-      break;
-   default:
-      ;
-   }
-
-   ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,
-                           ctx->Array.ElementArrayBufferObj);
-}
-
-
-/**
- * Inner support for both _mesa_DrawElements and _mesa_DrawRangeElements.
- * Do the rendering for a glDrawElements or glDrawRangeElements call after
- * we've validated buffer bounds, etc.
- */
-static void
-vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
-				GLboolean index_bounds_valid,
-				GLuint start, GLuint end,
-				GLsizei count, GLenum type,
-				const GLvoid *indices,
-				GLint basevertex, GLint numInstances)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   struct _mesa_index_buffer ib;
-   struct _mesa_prim prim[1];
-
-   FLUSH_CURRENT( ctx, 0 );
-
-   if (!_mesa_valid_to_render(ctx, "glDraw[Range]Elements")) {
-      return;
-   }
-
-   bind_arrays( ctx );
-
-   /* check for dirty state again */
-   if (ctx->NewState)
-      _mesa_update_state( ctx );
-
-   ib.count = count;
-   ib.type = type;
-   ib.obj = ctx->Array.ElementArrayBufferObj;
-   ib.ptr = indices;
-
-   prim[0].begin = 1;
-   prim[0].end = 1;
-   prim[0].weak = 0;
-   prim[0].pad = 0;
-   prim[0].mode = mode;
-   prim[0].start = 0;
-   prim[0].count = count;
-   prim[0].indexed = 1;
-   prim[0].basevertex = basevertex;
-   prim[0].num_instances = numInstances;
-
-   /* Need to give special consideration to rendering a range of
-    * indices starting somewhere above zero.  Typically the
-    * application is issuing multiple DrawRangeElements() to draw
-    * successive primitives layed out linearly in the vertex arrays.
-    * Unless the vertex arrays are all in a VBO (or locked as with
-    * CVA), the OpenGL semantics imply that we need to re-read or
-    * re-upload the vertex data on each draw call.  
-    *
-    * In the case of hardware tnl, we want to avoid starting the
-    * upload at zero, as it will mean every draw call uploads an
-    * increasing amount of not-used vertex data.  Worse - in the
-    * software tnl module, all those vertices might be transformed and
-    * lit but never rendered.
-    *
-    * If we just upload or transform the vertices in start..end,
-    * however, the indices will be incorrect.
-    *
-    * At this level, we don't know exactly what the requirements of
-    * the backend are going to be, though it will likely boil down to
-    * either:
-    *
-    * 1) Do nothing, everything is in a VBO and is processed once
-    *       only.
-    *
-    * 2) Adjust the indices and vertex arrays so that start becomes
-    *    zero.
-    *
-    * Rather than doing anything here, I'll provide a helper function
-    * for the latter case elsewhere.
-    */
-
-   check_buffers_are_unmapped(exec->array.inputs);
-   vbo->draw_prims( ctx, exec->array.inputs, prim, 1, &ib,
-		    index_bounds_valid, start, end );
-}
-
-
-/**
- * Called by glDrawRangeElementsBaseVertex() in immediate mode.
- */
-static void GLAPIENTRY
-vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,
-				     GLuint start, GLuint end,
-				     GLsizei count, GLenum type,
-				     const GLvoid *indices,
-				     GLint basevertex)
-{
-   static GLuint warnCount = 0;
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx,
-                "glDrawRangeElementsBaseVertex(%s, %u, %u, %d, %s, %p, %d)\n",
-                _mesa_lookup_enum_by_nr(mode), start, end, count,
-                _mesa_lookup_enum_by_nr(type), indices, basevertex);
-
-   if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,
-                                          type, indices, basevertex ))
-      return;
-
-   /* NOTE: It's important that 'end' is a reasonable value.
-    * in _tnl_draw_prims(), we use end to determine how many vertices
-    * to transform.  If it's too large, we can unnecessarily split prims
-    * or we can read/write out of memory in several different places!
-    */
-
-   /* Catch/fix some potential user errors */
-   if (type == GL_UNSIGNED_BYTE) {
-      start = MIN2(start, 0xff);
-      end = MIN2(end, 0xff);
-   }
-   else if (type == GL_UNSIGNED_SHORT) {
-      start = MIN2(start, 0xffff);
-      end = MIN2(end, 0xffff);
-   }
-
-   if (end >= ctx->Array.ArrayObj->_MaxElement) {
-      /* the max element is out of bounds of one or more enabled arrays */
-      warnCount++;
-
-      if (warnCount < 10) {
-         _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, count %d, "
-                       "type 0x%x, indices=%p)\n"
-                       "\tend is out of bounds (max=%u)  "
-                       "Element Buffer %u (size %d)\n"
-                       "\tThis should probably be fixed in the application.",
-                       start, end, count, type, indices,
-                       ctx->Array.ArrayObj->_MaxElement - 1,
-                       ctx->Array.ElementArrayBufferObj->Name,
-                       (int) ctx->Array.ElementArrayBufferObj->Size);
-      }
-
-      if (0)
-         dump_element_buffer(ctx, type);
-
-      if (0)
-         _mesa_print_arrays(ctx);
-
-#ifdef DEBUG
-      /* 'end' was out of bounds, but now let's check the actual array
-       * indexes to see if any of them are out of bounds.
-       */
-      {
-         GLuint max = _mesa_max_buffer_index(ctx, count, type, indices,
-                                             ctx->Array.ElementArrayBufferObj);
-         if (max >= ctx->Array.ArrayObj->_MaxElement) {
-            if (warnCount < 10) {
-               _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, "
-                             "count %d, type 0x%x, indices=%p)\n"
-                             "\tindex=%u is out of bounds (max=%u)  "
-                             "Element Buffer %u (size %d)\n"
-                             "\tSkipping the glDrawRangeElements() call",
-                             start, end, count, type, indices, max,
-                             ctx->Array.ArrayObj->_MaxElement - 1,
-                             ctx->Array.ElementArrayBufferObj->Name,
-                             (int) ctx->Array.ElementArrayBufferObj->Size);
-            }
-         }
-         /* XXX we could also find the min index and compare to 'start'
-          * to see if start is correct.  But it's more likely to get the
-          * upper bound wrong.
-          */
-      }
-#endif
-
-      /* Set 'end' to the max possible legal value */
-      assert(ctx->Array.ArrayObj->_MaxElement >= 1);
-      end = ctx->Array.ArrayObj->_MaxElement - 1;
-   }
-   else if (0) {
-      printf("glDraw[Range]Elements{,BaseVertex}"
-	     "(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
-	     "base %d\n",
-	     start, end, type, count,
-	     ctx->Array.ElementArrayBufferObj->Name,
-	     basevertex);
-   }
-
-#if 0
-   check_draw_elements_data(ctx, count, type, indices);
-#else
-   (void) check_draw_elements_data;
-#endif
-
-   vbo_validated_drawrangeelements(ctx, mode, GL_TRUE, start, end,
-				   count, type, indices, basevertex, 1);
-}
-
-
-/**
- * Called by glDrawRangeElements() in immediate mode.
- */
-static void GLAPIENTRY
-vbo_exec_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
-                           GLsizei count, GLenum type, const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx,
-                  "glDrawRangeElements(%s, %u, %u, %d, %s, %p)\n",
-                  _mesa_lookup_enum_by_nr(mode), start, end, count,
-                  _mesa_lookup_enum_by_nr(type), indices);
-
-   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
-					indices, 0);
-}
-
-
-/**
- * Called by glDrawElements() in immediate mode.
- */
-static void GLAPIENTRY
-vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
-                      const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",
-                  _mesa_lookup_enum_by_nr(mode), count,
-                  _mesa_lookup_enum_by_nr(type), indices);
-
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
-      return;
-
-   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices, 0, 1);
-}
-
-
-/**
- * Called by glDrawElementsBaseVertex() in immediate mode.
- */
-static void GLAPIENTRY
-vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
-				const GLvoid *indices, GLint basevertex)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx, "glDrawElementsBaseVertex(%s, %d, %s, %p, %d)\n",
-                  _mesa_lookup_enum_by_nr(mode), count,
-                  _mesa_lookup_enum_by_nr(type), indices, basevertex);
-
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
-				     basevertex ))
-      return;
-
-   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices, basevertex, 1);
-}
-
-
-/**
- * Called by glDrawElementsInstanced() in immediate mode.
- */
-static void GLAPIENTRY
-vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
-                               const GLvoid *indices, GLsizei numInstances)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_DRAW)
-      _mesa_debug(ctx, "glDrawElementsInstanced(%s, %d, %s, %p, %d)\n",
-                  _mesa_lookup_enum_by_nr(mode), count,
-                  _mesa_lookup_enum_by_nr(type), indices, numInstances);
-
-   if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices,
-                                             numInstances))
-      return;
-
-   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices, 0, numInstances);
-}
-
-
-/**
- * Inner support for both _mesa_MultiDrawElements() and
- * _mesa_MultiDrawRangeElements().
- * This does the actual rendering after we've checked array indexes, etc.
- */
-static void
-vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,
-				const GLsizei *count, GLenum type,
-				const GLvoid **indices, GLsizei primcount,
-				const GLint *basevertex)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   struct _mesa_index_buffer ib;
-   struct _mesa_prim *prim;
-   unsigned int index_type_size = 0;
-   uintptr_t min_index_ptr, max_index_ptr;
-   GLboolean fallback = GL_FALSE;
-   int i;
-
-   if (primcount == 0)
-      return;
-
-   FLUSH_CURRENT( ctx, 0 );
-
-   if (!_mesa_valid_to_render(ctx, "glMultiDrawElements")) {
-      return;
-   }
-
-   prim = calloc(1, primcount * sizeof(*prim));
-   if (prim == NULL) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMultiDrawElements");
-      return;
-   }
-
-   /* Decide if we can do this all as one set of primitives sharing the
-    * same index buffer, or if we have to reset the index pointer per
-    * primitive.
-    */
-   bind_arrays( ctx );
-
-   /* check for dirty state again */
-   if (ctx->NewState)
-      _mesa_update_state( ctx );
-
-   switch (type) {
-   case GL_UNSIGNED_INT:
-      index_type_size = 4;
-      break;
-   case GL_UNSIGNED_SHORT:
-      index_type_size = 2;
-      break;
-   case GL_UNSIGNED_BYTE:
-      index_type_size = 1;
-      break;
-   default:
-      assert(0);
-   }
-
-   min_index_ptr = (uintptr_t)indices[0];
-   max_index_ptr = 0;
-   for (i = 0; i < primcount; i++) {
-      min_index_ptr = MIN2(min_index_ptr, (uintptr_t)indices[i]);
-      max_index_ptr = MAX2(max_index_ptr, (uintptr_t)indices[i] +
-			   index_type_size * count[i]);
-   }
-
-   /* Check if we can handle this thing as a bunch of index offsets from the
-    * same index pointer.  If we can't, then we have to fall back to doing
-    * a draw_prims per primitive.
-    * Check that the difference between each prim's indexes is a multiple of
-    * the index/element size.
-    */
-   if (index_type_size != 1) {
-      for (i = 0; i < primcount; i++) {
-	 if ((((uintptr_t)indices[i] - min_index_ptr) % index_type_size) != 0) {
-	    fallback = GL_TRUE;
-	    break;
-	 }
-      }
-   }
-
-   /* If the index buffer isn't in a VBO, then treating the application's
-    * subranges of the index buffer as one large index buffer may lead to
-    * us reading unmapped memory.
-    */
-   if (!_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj))
-      fallback = GL_TRUE;
-
-   if (!fallback) {
-      ib.count = (max_index_ptr - min_index_ptr) / index_type_size;
-      ib.type = type;
-      ib.obj = ctx->Array.ElementArrayBufferObj;
-      ib.ptr = (void *)min_index_ptr;
-
-      for (i = 0; i < primcount; i++) {
-	 prim[i].begin = (i == 0);
-	 prim[i].end = (i == primcount - 1);
-	 prim[i].weak = 0;
-	 prim[i].pad = 0;
-	 prim[i].mode = mode;
-	 prim[i].start = ((uintptr_t)indices[i] - min_index_ptr) / index_type_size;
-	 prim[i].count = count[i];
-	 prim[i].indexed = 1;
-         prim[i].num_instances = 1;
-	 if (basevertex != NULL)
-	    prim[i].basevertex = basevertex[i];
-	 else
-	    prim[i].basevertex = 0;
-      }
-
-      check_buffers_are_unmapped(exec->array.inputs);
-      vbo->draw_prims(ctx, exec->array.inputs, prim, primcount, &ib,
-		      GL_FALSE, ~0, ~0);
-   } else {
-      /* render one prim at a time */
-      for (i = 0; i < primcount; i++) {
-	 ib.count = count[i];
-	 ib.type = type;
-	 ib.obj = ctx->Array.ElementArrayBufferObj;
-	 ib.ptr = indices[i];
-
-	 prim[0].begin = 1;
-	 prim[0].end = 1;
-	 prim[0].weak = 0;
-	 prim[0].pad = 0;
-	 prim[0].mode = mode;
-	 prim[0].start = 0;
-	 prim[0].count = count[i];
-	 prim[0].indexed = 1;
-         prim[0].num_instances = 1;
-	 if (basevertex != NULL)
-	    prim[0].basevertex = basevertex[i];
-	 else
-	    prim[0].basevertex = 0;
-
-         check_buffers_are_unmapped(exec->array.inputs);
-         vbo->draw_prims(ctx, exec->array.inputs, prim, 1, &ib,
-                         GL_FALSE, ~0, ~0);
-      }
-   }
-
-   free(prim);
-}
-
-
-static void GLAPIENTRY
-vbo_exec_MultiDrawElements(GLenum mode,
-			   const GLsizei *count, GLenum type,
-			   const GLvoid **indices,
-			   GLsizei primcount)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   for (i = 0; i < primcount; i++) {
-      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
-				       0))
-	 return;
-   }
-
-   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
-				   NULL);
-}
-
-
-static void GLAPIENTRY
-vbo_exec_MultiDrawElementsBaseVertex(GLenum mode,
-				     const GLsizei *count, GLenum type,
-				     const GLvoid **indices,
-				     GLsizei primcount,
-				     const GLsizei *basevertex)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   for (i = 0; i < primcount; i++) {
-      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
-				       basevertex[i]))
-	 return;
-   }
-
-   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
-				   basevertex);
-}
-
-
-/**
- * Plug in the immediate-mode vertex array drawing commands into the
- * givven vbo_exec_context object.
- */
-void
-vbo_exec_array_init( struct vbo_exec_context *exec )
-{
-   exec->vtxfmt.DrawArrays = vbo_exec_DrawArrays;
-   exec->vtxfmt.DrawElements = vbo_exec_DrawElements;
-   exec->vtxfmt.DrawRangeElements = vbo_exec_DrawRangeElements;
-   exec->vtxfmt.MultiDrawElementsEXT = vbo_exec_MultiDrawElements;
-   exec->vtxfmt.DrawElementsBaseVertex = vbo_exec_DrawElementsBaseVertex;
-   exec->vtxfmt.DrawRangeElementsBaseVertex = vbo_exec_DrawRangeElementsBaseVertex;
-   exec->vtxfmt.MultiDrawElementsBaseVertex = vbo_exec_MultiDrawElementsBaseVertex;
-   exec->vtxfmt.DrawArraysInstanced = vbo_exec_DrawArraysInstanced;
-   exec->vtxfmt.DrawElementsInstanced = vbo_exec_DrawElementsInstanced;
-}
-
-
-void
-vbo_exec_array_destroy( struct vbo_exec_context *exec )
-{
-   /* nothing to do */
-}
-
-
-
-/**
- * The following functions are only used for OpenGL ES 1/2 support.
- * And some aren't even supported (yet) in ES 1/2.
- */
-
-
-void GLAPIENTRY
-_mesa_DrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-   vbo_exec_DrawArrays(mode, first, count);
-}
-
-
-void GLAPIENTRY
-_mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,
-                   const GLvoid *indices)
-{
-   vbo_exec_DrawElements(mode, count, type, indices);
-}
-
-
-void GLAPIENTRY
-_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
-			     const GLvoid *indices, GLint basevertex)
-{
-   vbo_exec_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
-}
-
-
-void GLAPIENTRY
-_mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
-                        GLenum type, const GLvoid *indices)
-{
-   vbo_exec_DrawRangeElements(mode, start, end, count, type, indices);
-}
-
-
-void GLAPIENTRY
-_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
-				  GLsizei count, GLenum type,
-				  const GLvoid *indices, GLint basevertex)
-{
-   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
-					indices, basevertex);
-}
-
-
-void GLAPIENTRY
-_mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
-			   const GLvoid **indices, GLsizei primcount)
-{
-   vbo_exec_MultiDrawElements(mode, count, type, indices, primcount);
-}
-
-
-void GLAPIENTRY
-_mesa_MultiDrawElementsBaseVertex(GLenum mode,
-				  const GLsizei *count, GLenum type,
-				  const GLvoid **indices, GLsizei primcount,
-				  const GLint *basevertex)
-{
-   vbo_exec_MultiDrawElementsBaseVertex(mode, count, type, indices,
-					primcount, basevertex);
-}
+/**************************************************************************

+ * 

+ * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright 2009 VMware, Inc.

+ * 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 TUNGSTEN GRAPHICS AND/OR ITS 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.

+ * 

+ **************************************************************************/

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/state.h"

+#include "main/api_validate.h"

+#include "main/varray.h"

+#include "main/bufferobj.h"

+#include "main/enums.h"

+#include "main/macros.h"

+

+#include "vbo_context.h"

+

+

+/**

+ * All vertex buffers should be in an unmapped state when we're about

+ * to draw.  This debug function checks that.

+ */

+static void

+check_buffers_are_unmapped(const struct gl_client_array **inputs)

+{

+#ifdef DEBUG

+   GLuint i;

+

+   for (i = 0; i < VERT_ATTRIB_MAX; i++) {

+      if (inputs[i]) {

+         struct gl_buffer_object *obj = inputs[i]->BufferObj;

+         assert(!_mesa_bufferobj_mapped(obj));

+         (void) obj;

+      }

+   }

+#endif

+}

+

+

+/**

+ * A debug function that may be called from other parts of Mesa as

+ * needed during debugging.

+ */

+void

+vbo_check_buffers_are_unmapped(struct gl_context *ctx)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   /* check the current vertex arrays */

+   check_buffers_are_unmapped(exec->array.inputs);

+   /* check the current glBegin/glVertex/glEnd-style VBO */

+   assert(!_mesa_bufferobj_mapped(exec->vtx.bufferobj));

+}

+

+

+

+/**

+ * Compute min and max elements by scanning the index buffer for

+ * glDraw[Range]Elements() calls.

+ * If primitive restart is enabled, we need to ignore restart

+ * indexes when computing min/max.

+ */

+void

+vbo_get_minmax_index(struct gl_context *ctx,

+		     const struct _mesa_prim *prim,

+		     const struct _mesa_index_buffer *ib,

+		     GLuint *min_index, GLuint *max_index)

+{

+   const GLboolean restart = ctx->Array.PrimitiveRestart;

+   const GLuint restartIndex = ctx->Array.RestartIndex;

+   const GLuint count = prim->count;

+   const void *indices;

+   GLuint i;

+

+   if (_mesa_is_bufferobj(ib->obj)) {

+      const GLvoid *map =

+         ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,

+                               GL_READ_ONLY, ib->obj);

+      indices = ADD_POINTERS(map, ib->ptr);

+   } else {

+      indices = ib->ptr;

+   }

+

+   switch (ib->type) {

+   case GL_UNSIGNED_INT: {

+      const GLuint *ui_indices = (const GLuint *)indices;

+      GLuint max_ui = 0;

+      GLuint min_ui = ~0U;

+      if (restart) {

+         for (i = 0; i < count; i++) {

+            if (ui_indices[i] != restartIndex) {

+               if (ui_indices[i] > max_ui) max_ui = ui_indices[i];

+               if (ui_indices[i] < min_ui) min_ui = ui_indices[i];

+            }

+         }

+      }

+      else {

+         for (i = 0; i < count; i++) {

+            if (ui_indices[i] > max_ui) max_ui = ui_indices[i];

+            if (ui_indices[i] < min_ui) min_ui = ui_indices[i];

+         }

+      }

+      *min_index = min_ui;

+      *max_index = max_ui;

+      break;

+   }

+   case GL_UNSIGNED_SHORT: {

+      const GLushort *us_indices = (const GLushort *)indices;

+      GLuint max_us = 0;

+      GLuint min_us = ~0U;

+      if (restart) {

+         for (i = 0; i < count; i++) {

+            if (us_indices[i] != restartIndex) {

+               if (us_indices[i] > max_us) max_us = us_indices[i];

+               if (us_indices[i] < min_us) min_us = us_indices[i];

+            }

+         }

+      }

+      else {

+         for (i = 0; i < count; i++) {

+            if (us_indices[i] > max_us) max_us = us_indices[i];

+            if (us_indices[i] < min_us) min_us = us_indices[i];

+         }

+      }

+      *min_index = min_us;

+      *max_index = max_us;

+      break;

+   }

+   case GL_UNSIGNED_BYTE: {

+      const GLubyte *ub_indices = (const GLubyte *)indices;

+      GLuint max_ub = 0;

+      GLuint min_ub = ~0U;

+      if (restart) {

+         for (i = 0; i < count; i++) {

+            if (ub_indices[i] != restartIndex) {

+               if (ub_indices[i] > max_ub) max_ub = ub_indices[i];

+               if (ub_indices[i] < min_ub) min_ub = ub_indices[i];

+            }

+         }

+      }

+      else {

+         for (i = 0; i < count; i++) {

+            if (ub_indices[i] > max_ub) max_ub = ub_indices[i];

+            if (ub_indices[i] < min_ub) min_ub = ub_indices[i];

+         }

+      }

+      *min_index = min_ub;

+      *max_index = max_ub;

+      break;

+   }

+   default:

+      assert(0);

+      break;

+   }

+

+   if (_mesa_is_bufferobj(ib->obj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, ib->obj);

+   }

+}

+

+

+/**

+ * Check that element 'j' of the array has reasonable data.

+ * Map VBO if needed.

+ * For debugging purposes; not normally used.

+ */

+static void

+check_array_data(struct gl_context *ctx, struct gl_client_array *array,

+                 GLuint attrib, GLuint j)

+{

+   if (array->Enabled) {

+      const void *data = array->Ptr;

+      if (_mesa_is_bufferobj(array->BufferObj)) {

+         if (!array->BufferObj->Pointer) {

+            /* need to map now */

+            array->BufferObj->Pointer =

+               ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER_ARB,

+                                     GL_READ_ONLY, array->BufferObj);

+         }

+         data = ADD_POINTERS(data, array->BufferObj->Pointer);

+      }

+      switch (array->Type) {

+      case GL_FLOAT:

+         {

+            GLfloat *f = (GLfloat *) ((GLubyte *) data + array->StrideB * j);

+            GLint k;

+            for (k = 0; k < array->Size; k++) {

+               if (IS_INF_OR_NAN(f[k]) ||

+                   f[k] >= 1.0e20 || f[k] <= -1.0e10) {

+                  printf("Bad array data:\n");

+                  printf("  Element[%u].%u = %f\n", j, k, f[k]);

+                  printf("  Array %u at %p\n", attrib, (void* ) array);

+                  printf("  Type 0x%x, Size %d, Stride %d\n",

+			 array->Type, array->Size, array->Stride);

+                  printf("  Address/offset %p in Buffer Object %u\n",

+			 array->Ptr, array->BufferObj->Name);

+                  f[k] = 1.0; /* XXX replace the bad value! */

+               }

+               /*assert(!IS_INF_OR_NAN(f[k]));*/

+            }

+         }

+         break;

+      default:

+         ;

+      }

+   }

+}

+

+

+/**

+ * Unmap the buffer object referenced by given array, if mapped.

+ */

+static void

+unmap_array_buffer(struct gl_context *ctx, struct gl_client_array *array)

+{

+   if (array->Enabled &&

+       _mesa_is_bufferobj(array->BufferObj) &&

+       _mesa_bufferobj_mapped(array->BufferObj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, array->BufferObj);

+   }

+}

+

+

+/**

+ * Examine the array's data for NaNs, etc.

+ * For debug purposes; not normally used.

+ */

+static void

+check_draw_elements_data(struct gl_context *ctx, GLsizei count, GLenum elemType,

+                         const void *elements, GLint basevertex)

+{

+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+   const void *elemMap;

+   GLint i, k;

+

+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {

+      elemMap = ctx->Driver.MapBuffer(ctx,

+                                      GL_ELEMENT_ARRAY_BUFFER_ARB,

+                                      GL_READ_ONLY,

+                                      ctx->Array.ElementArrayBufferObj);

+      elements = ADD_POINTERS(elements, elemMap);

+   }

+

+   for (i = 0; i < count; i++) {

+      GLuint j;

+

+      /* j = element[i] */

+      switch (elemType) {

+      case GL_UNSIGNED_BYTE:

+         j = ((const GLubyte *) elements)[i];

+         break;

+      case GL_UNSIGNED_SHORT:

+         j = ((const GLushort *) elements)[i];

+         break;

+      case GL_UNSIGNED_INT:

+         j = ((const GLuint *) elements)[i];

+         break;

+      default:

+         assert(0);

+      }

+

+      /* check element j of each enabled array */

+      check_array_data(ctx, &arrayObj->Vertex, VERT_ATTRIB_POS, j);

+      check_array_data(ctx, &arrayObj->Normal, VERT_ATTRIB_NORMAL, j);

+      check_array_data(ctx, &arrayObj->Color, VERT_ATTRIB_COLOR0, j);

+      check_array_data(ctx, &arrayObj->SecondaryColor, VERT_ATTRIB_COLOR1, j);

+      for (k = 0; k < Elements(arrayObj->TexCoord); k++) {

+         check_array_data(ctx, &arrayObj->TexCoord[k], VERT_ATTRIB_TEX0 + k, j);

+      }

+      for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {

+         check_array_data(ctx, &arrayObj->VertexAttrib[k],

+                          VERT_ATTRIB_GENERIC0 + k, j);

+      }

+   }

+

+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {

+      ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,

+			      ctx->Array.ElementArrayBufferObj);

+   }

+

+   unmap_array_buffer(ctx, &arrayObj->Vertex);

+   unmap_array_buffer(ctx, &arrayObj->Normal);

+   unmap_array_buffer(ctx, &arrayObj->Color);

+   for (k = 0; k < Elements(arrayObj->TexCoord); k++) {

+      unmap_array_buffer(ctx, &arrayObj->TexCoord[k]);

+   }

+   for (k = 0; k < Elements(arrayObj->VertexAttrib); k++) {

+      unmap_array_buffer(ctx, &arrayObj->VertexAttrib[k]);

+   }

+}

+

+

+/**

+ * Check array data, looking for NaNs, etc.

+ */

+static void

+check_draw_arrays_data(struct gl_context *ctx, GLint start, GLsizei count)

+{

+   /* TO DO */

+}

+

+

+/**

+ * Print info/data for glDrawArrays(), for debugging.

+ */

+static void

+print_draw_arrays(struct gl_context *ctx,

+                  GLenum mode, GLint start, GLsizei count)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   int i;

+

+   printf("vbo_exec_DrawArrays(mode 0x%x, start %d, count %d):\n",

+	  mode, start, count);

+

+   for (i = 0; i < 32; i++) {

+      GLuint bufName = exec->array.inputs[i]->BufferObj->Name;

+      GLint stride = exec->array.inputs[i]->Stride;

+      printf("attr %2d: size %d stride %d  enabled %d  "

+	     "ptr %p  Bufobj %u\n",

+	     i,

+	     exec->array.inputs[i]->Size,

+	     stride,

+	     /*exec->array.inputs[i]->Enabled,*/

+	     exec->array.legacy_array[i]->Enabled,

+	     exec->array.inputs[i]->Ptr,

+	     bufName);

+

+      if (bufName) {

+         struct gl_buffer_object *buf = _mesa_lookup_bufferobj(ctx, bufName);

+         GLubyte *p = ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER_ARB,

+                                            GL_READ_ONLY_ARB, buf);

+         int offset = (int) (GLintptr) exec->array.inputs[i]->Ptr;

+         float *f = (float *) (p + offset);

+         int *k = (int *) f;

+         int i;

+         int n = (count * stride) / 4;

+         if (n > 32)

+            n = 32;

+         printf("  Data at offset %d:\n", offset);

+         for (i = 0; i < n; i++) {

+            printf("    float[%d] = 0x%08x %f\n", i, k[i], f[i]);

+         }

+         ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, buf);

+      }

+   }

+}

+

+

+/**

+ * Bind the VBO executor to the current vertex array object prior

+ * to drawing.

+ *

+ * Just translate the arrayobj into a sane layout.

+ */

+static void

+bind_array_obj(struct gl_context *ctx)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+   GLuint i;

+

+   /* TODO: Fix the ArrayObj struct to keep legacy arrays in an array

+    * rather than as individual named arrays.  Then this function can

+    * go away.

+    */

+   exec->array.legacy_array[VERT_ATTRIB_POS] = &arrayObj->Vertex;

+   exec->array.legacy_array[VERT_ATTRIB_WEIGHT] = &arrayObj->Weight;

+   exec->array.legacy_array[VERT_ATTRIB_NORMAL] = &arrayObj->Normal;

+   exec->array.legacy_array[VERT_ATTRIB_COLOR0] = &arrayObj->Color;

+   exec->array.legacy_array[VERT_ATTRIB_COLOR1] = &arrayObj->SecondaryColor;

+   exec->array.legacy_array[VERT_ATTRIB_FOG] = &arrayObj->FogCoord;

+   exec->array.legacy_array[VERT_ATTRIB_COLOR_INDEX] = &arrayObj->Index;

+   if (arrayObj->PointSize.Enabled) {

+      /* this aliases COLOR_INDEX */

+      exec->array.legacy_array[VERT_ATTRIB_POINT_SIZE] = &arrayObj->PointSize;

+   }

+   exec->array.legacy_array[VERT_ATTRIB_EDGEFLAG] = &arrayObj->EdgeFlag;

+

+   for (i = 0; i < Elements(arrayObj->TexCoord); i++)

+      exec->array.legacy_array[VERT_ATTRIB_TEX0 + i] = &arrayObj->TexCoord[i];

+

+   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {

+      assert(i < Elements(exec->array.generic_array));

+      exec->array.generic_array[i] = &arrayObj->VertexAttrib[i];

+   }

+   

+   exec->array.array_obj = arrayObj->Name;

+}

+

+

+/**

+ * Set the vbo->exec->inputs[] pointers to point to the enabled

+ * vertex arrays.  This depends on the current vertex program/shader

+ * being executed because of whether or not generic vertex arrays

+ * alias the conventional vertex arrays.

+ * For arrays that aren't enabled, we set the input[attrib] pointer

+ * to point at a zero-stride current value "array".

+ */

+static void

+recalculate_input_bindings(struct gl_context *ctx)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   const struct gl_client_array **inputs = &exec->array.inputs[0];

+   GLbitfield const_inputs = 0x0;

+   GLuint i;

+

+   exec->array.program_mode = get_program_mode(ctx);

+   exec->array.enabled_flags = ctx->Array.ArrayObj->_Enabled;

+

+   switch (exec->array.program_mode) {

+   case VP_NONE:

+      /* When no vertex program is active (or the vertex program is generated

+       * from fixed-function state).  We put the material values into the

+       * generic slots.  This is the only situation where material values

+       * are available as per-vertex attributes.

+       */

+      for (i = 0; i <= VERT_ATTRIB_TEX7; i++) {

+	 if (exec->array.legacy_array[i]->Enabled)

+	    inputs[i] = exec->array.legacy_array[i];

+	 else {

+	    inputs[i] = &vbo->legacy_currval[i];

+            const_inputs |= 1 << i;

+         }

+      }

+

+      for (i = 0; i < MAT_ATTRIB_MAX; i++) {

+	 inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->mat_currval[i];

+         const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);

+      }

+

+      /* Could use just about anything, just to fill in the empty

+       * slots:

+       */

+      for (i = MAT_ATTRIB_MAX; i < VERT_ATTRIB_MAX - VERT_ATTRIB_GENERIC0; i++) {

+	 inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->generic_currval[i];

+         const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);

+      }

+

+      /* There is no need to make _NEW_ARRAY dirty here for the TnL program,

+       * because it already takes care of invalidating the state necessary

+       * to revalidate vertex arrays. Not marking the state as dirty also

+       * improves performance (quite significantly in some apps).

+       */

+      if (!ctx->VertexProgram._MaintainTnlProgram)

+         ctx->NewState |= _NEW_ARRAY;

+      break;

+

+   case VP_NV:

+      /* NV_vertex_program - attribute arrays alias and override

+       * conventional, legacy arrays.  No materials, and the generic

+       * slots are vacant.

+       */

+      for (i = 0; i <= VERT_ATTRIB_TEX7; i++) {

+	 if (exec->array.generic_array[i]->Enabled)

+	    inputs[i] = exec->array.generic_array[i];

+	 else if (exec->array.legacy_array[i]->Enabled)

+	    inputs[i] = exec->array.legacy_array[i];

+	 else {

+	    inputs[i] = &vbo->legacy_currval[i];

+            const_inputs |= 1 << i;

+         }

+      }

+

+      /* Could use just about anything, just to fill in the empty

+       * slots:

+       */

+      for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {

+	 inputs[i] = &vbo->generic_currval[i - VERT_ATTRIB_GENERIC0];

+         const_inputs |= 1 << i;

+      }

+

+      ctx->NewState |= _NEW_ARRAY;

+      break;

+

+   case VP_ARB:

+      /* GL_ARB_vertex_program or GLSL vertex shader - Only the generic[0]

+       * attribute array aliases and overrides the legacy position array.  

+       *

+       * Otherwise, legacy attributes available in the legacy slots,

+       * generic attributes in the generic slots and materials are not

+       * available as per-vertex attributes.

+       */

+      if (exec->array.generic_array[0]->Enabled)

+	 inputs[0] = exec->array.generic_array[0];

+      else if (exec->array.legacy_array[0]->Enabled)

+	 inputs[0] = exec->array.legacy_array[0];

+      else {

+	 inputs[0] = &vbo->legacy_currval[0];

+         const_inputs |= 1 << 0;

+      }

+

+      for (i = 1; i <= VERT_ATTRIB_TEX7; i++) {

+	 if (exec->array.legacy_array[i]->Enabled)

+	    inputs[i] = exec->array.legacy_array[i];

+	 else {

+	    inputs[i] = &vbo->legacy_currval[i];

+            const_inputs |= 1 << i;

+         }

+      }

+

+      for (i = 0; i < MAX_VERTEX_GENERIC_ATTRIBS; i++) {

+	 if (exec->array.generic_array[i]->Enabled)

+	    inputs[VERT_ATTRIB_GENERIC0 + i] = exec->array.generic_array[i];

+	 else {

+	    inputs[VERT_ATTRIB_GENERIC0 + i] = &vbo->generic_currval[i];

+            const_inputs |= 1 << (VERT_ATTRIB_GENERIC0 + i);

+         }

+      }

+

+      ctx->NewState |= _NEW_ARRAY;

+      break;

+   }

+

+   _mesa_set_varying_vp_inputs( ctx, ~const_inputs );

+}

+

+

+/**

+ * Examine the enabled vertex arrays to set the exec->array.inputs[] values.

+ * These will point to the arrays to actually use for drawing.  Some will

+ * be user-provided arrays, other will be zero-stride const-valued arrays.

+ * Note that this might set the _NEW_ARRAY dirty flag so state validation

+ * must be done after this call.

+ */

+static void

+bind_arrays(struct gl_context *ctx)

+{

+   if (!ctx->Array.RebindArrays) {

+      return;

+   }

+

+   bind_array_obj(ctx);

+   recalculate_input_bindings(ctx);

+   ctx->Array.RebindArrays = GL_FALSE;

+}

+

+

+/**

+ * Helper function called by the other DrawArrays() functions below.

+ * This is where we handle primitive restart for drawing non-indexed

+ * arrays.  If primitive restart is enabled, it typically means

+ * splitting one DrawArrays() into two.

+ */

+static void

+vbo_draw_arrays(struct gl_context *ctx, GLenum mode, GLint start,

+                GLsizei count, GLuint numInstances)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   struct _mesa_prim prim[2];

+

+   bind_arrays(ctx);

+

+   /* Again... because we may have changed the bitmask of per-vertex varying

+    * attributes.  If we regenerate the fixed-function vertex program now

+    * we may be able to prune down the number of vertex attributes which we

+    * need in the shader.

+    */

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   prim[0].begin = 1;

+   prim[0].end = 1;

+   prim[0].weak = 0;

+   prim[0].pad = 0;

+   prim[0].mode = mode;

+   prim[0].start = 0; /* filled in below */

+   prim[0].count = 0; /* filled in below */

+   prim[0].indexed = 0;

+   prim[0].basevertex = 0;

+   prim[0].num_instances = numInstances;

+

+   /* Implement the primitive restart index */

+   if (ctx->Array.PrimitiveRestart && ctx->Array.RestartIndex < count) {

+      GLuint primCount = 0;

+

+      if (ctx->Array.RestartIndex == start) {

+         /* special case: RestartIndex at beginning */

+         if (count > 1) {

+            prim[0].start = start + 1;

+            prim[0].count = count - 1;

+            primCount = 1;

+         }

+      }

+      else if (ctx->Array.RestartIndex == start + count - 1) {

+         /* special case: RestartIndex at end */

+         if (count > 1) {

+            prim[0].start = start;

+            prim[0].count = count - 1;

+            primCount = 1;

+         }

+      }

+      else {

+         /* general case: RestartIndex in middle, split into two prims */

+         prim[0].start = start;

+         prim[0].count = ctx->Array.RestartIndex - start;

+

+         prim[1] = prim[0];

+         prim[1].start = ctx->Array.RestartIndex + 1;

+         prim[1].count = count - prim[1].start;

+

+         primCount = 2;

+      }

+

+      if (primCount > 0) {

+         /* draw one or two prims */

+         check_buffers_are_unmapped(exec->array.inputs);

+         vbo->draw_prims(ctx, exec->array.inputs, prim, primCount, NULL,

+                         GL_TRUE, start, start + count - 1);

+      }

+   }

+   else {

+      /* no prim restart */

+      prim[0].start = start;

+      prim[0].count = count;

+

+      check_buffers_are_unmapped(exec->array.inputs);

+      vbo->draw_prims(ctx, exec->array.inputs, prim, 1, NULL,

+                      GL_TRUE, start, start + count - 1);

+   }

+}

+

+

+

+/**

+ * Called from glDrawArrays when in immediate mode (not display list mode).

+ */

+static void GLAPIENTRY

+vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx, "glDrawArrays(%s, %d, %d)\n",

+                  _mesa_lookup_enum_by_nr(mode), start, count);

+

+   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))

+      return;

+

+   FLUSH_CURRENT( ctx, 0 );

+

+   if (!_mesa_valid_to_render(ctx, "glDrawArrays")) {

+      return;

+   }

+

+   if (0)

+      check_draw_arrays_data(ctx, start, count);

+

+   vbo_draw_arrays(ctx, mode, start, count, 1);

+

+   if (0)

+      print_draw_arrays(ctx, mode, start, count);

+}

+

+

+/**

+ * Called from glDrawArraysInstanced when in immediate mode (not

+ * display list mode).

+ */

+static void GLAPIENTRY

+vbo_exec_DrawArraysInstanced(GLenum mode, GLint start, GLsizei count,

+                             GLsizei numInstances)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx, "glDrawArraysInstanced(%s, %d, %d, %d)\n",

+                  _mesa_lookup_enum_by_nr(mode), start, count, numInstances);

+

+   if (!_mesa_validate_DrawArraysInstanced(ctx, mode, start, count, numInstances))

+      return;

+

+   FLUSH_CURRENT( ctx, 0 );

+

+   if (!_mesa_valid_to_render(ctx, "glDrawArraysInstanced")) {

+      return;

+   }

+

+   if (0)

+      check_draw_arrays_data(ctx, start, count);

+

+   vbo_draw_arrays(ctx, mode, start, count, numInstances);

+

+   if (0)

+      print_draw_arrays(ctx, mode, start, count);

+}

+

+

+/**

+ * Map GL_ELEMENT_ARRAY_BUFFER and print contents.

+ * For debugging.

+ */

+static void

+dump_element_buffer(struct gl_context *ctx, GLenum type)

+{

+   const GLvoid *map = ctx->Driver.MapBuffer(ctx,

+                                             GL_ELEMENT_ARRAY_BUFFER_ARB,

+                                             GL_READ_ONLY,

+                                             ctx->Array.ElementArrayBufferObj);

+   switch (type) {

+   case GL_UNSIGNED_BYTE:

+      {

+         const GLubyte *us = (const GLubyte *) map;

+         GLint i;

+         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size; i++) {

+            printf("%02x ", us[i]);

+            if (i % 32 == 31)

+               printf("\n");

+         }

+         printf("\n");

+      }

+      break;

+   case GL_UNSIGNED_SHORT:

+      {

+         const GLushort *us = (const GLushort *) map;

+         GLint i;

+         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 2; i++) {

+            printf("%04x ", us[i]);

+            if (i % 16 == 15)

+               printf("\n");

+         }

+         printf("\n");

+      }

+      break;

+   case GL_UNSIGNED_INT:

+      {

+         const GLuint *us = (const GLuint *) map;

+         GLint i;

+         for (i = 0; i < ctx->Array.ElementArrayBufferObj->Size / 4; i++) {

+            printf("%08x ", us[i]);

+            if (i % 8 == 7)

+               printf("\n");

+         }

+         printf("\n");

+      }

+      break;

+   default:

+      ;

+   }

+

+   ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB,

+                           ctx->Array.ElementArrayBufferObj);

+}

+

+

+/**

+ * Inner support for both _mesa_DrawElements and _mesa_DrawRangeElements.

+ * Do the rendering for a glDrawElements or glDrawRangeElements call after

+ * we've validated buffer bounds, etc.

+ */

+static void

+vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,

+				GLboolean index_bounds_valid,

+				GLuint start, GLuint end,

+				GLsizei count, GLenum type,

+				const GLvoid *indices,

+				GLint basevertex, GLint numInstances)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   struct _mesa_index_buffer ib;

+   struct _mesa_prim prim[1];

+

+   FLUSH_CURRENT( ctx, 0 );

+

+   if (!_mesa_valid_to_render(ctx, "glDraw[Range]Elements")) {

+      return;

+   }

+

+   bind_arrays( ctx );

+

+   /* check for dirty state again */

+   if (ctx->NewState)

+      _mesa_update_state( ctx );

+

+   ib.count = count;

+   ib.type = type;

+   ib.obj = ctx->Array.ElementArrayBufferObj;

+   ib.ptr = indices;

+

+   prim[0].begin = 1;

+   prim[0].end = 1;

+   prim[0].weak = 0;

+   prim[0].pad = 0;

+   prim[0].mode = mode;

+   prim[0].start = 0;

+   prim[0].count = count;

+   prim[0].indexed = 1;

+   prim[0].basevertex = basevertex;

+   prim[0].num_instances = numInstances;

+

+   /* Need to give special consideration to rendering a range of

+    * indices starting somewhere above zero.  Typically the

+    * application is issuing multiple DrawRangeElements() to draw

+    * successive primitives layed out linearly in the vertex arrays.

+    * Unless the vertex arrays are all in a VBO (or locked as with

+    * CVA), the OpenGL semantics imply that we need to re-read or

+    * re-upload the vertex data on each draw call.  

+    *

+    * In the case of hardware tnl, we want to avoid starting the

+    * upload at zero, as it will mean every draw call uploads an

+    * increasing amount of not-used vertex data.  Worse - in the

+    * software tnl module, all those vertices might be transformed and

+    * lit but never rendered.

+    *

+    * If we just upload or transform the vertices in start..end,

+    * however, the indices will be incorrect.

+    *

+    * At this level, we don't know exactly what the requirements of

+    * the backend are going to be, though it will likely boil down to

+    * either:

+    *

+    * 1) Do nothing, everything is in a VBO and is processed once

+    *       only.

+    *

+    * 2) Adjust the indices and vertex arrays so that start becomes

+    *    zero.

+    *

+    * Rather than doing anything here, I'll provide a helper function

+    * for the latter case elsewhere.

+    */

+

+   check_buffers_are_unmapped(exec->array.inputs);

+   vbo->draw_prims( ctx, exec->array.inputs, prim, 1, &ib,

+		    index_bounds_valid, start, end );

+}

+

+

+/**

+ * Called by glDrawRangeElementsBaseVertex() in immediate mode.

+ */

+static void GLAPIENTRY

+vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,

+				     GLuint start, GLuint end,

+				     GLsizei count, GLenum type,

+				     const GLvoid *indices,

+				     GLint basevertex)

+{

+   static GLuint warnCount = 0;

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx,

+                "glDrawRangeElementsBaseVertex(%s, %u, %u, %d, %s, %p, %d)\n",

+                _mesa_lookup_enum_by_nr(mode), start, end, count,

+                _mesa_lookup_enum_by_nr(type), indices, basevertex);

+

+   if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,

+                                          type, indices, basevertex ))

+      return;

+

+   /* NOTE: It's important that 'end' is a reasonable value.

+    * in _tnl_draw_prims(), we use end to determine how many vertices

+    * to transform.  If it's too large, we can unnecessarily split prims

+    * or we can read/write out of memory in several different places!

+    */

+

+   /* Catch/fix some potential user errors */

+   if (type == GL_UNSIGNED_BYTE) {

+      start = MIN2(start, 0xff);

+      end = MIN2(end, 0xff);

+   }

+   else if (type == GL_UNSIGNED_SHORT) {

+      start = MIN2(start, 0xffff);

+      end = MIN2(end, 0xffff);

+   }

+

+   if (end >= ctx->Array.ArrayObj->_MaxElement) {

+      /* the max element is out of bounds of one or more enabled arrays */

+      warnCount++;

+

+      if (warnCount < 10) {

+         _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, count %d, "

+                       "type 0x%x, indices=%p)\n"

+                       "\tend is out of bounds (max=%u)  "

+                       "Element Buffer %u (size %d)\n"

+                       "\tThis should probably be fixed in the application.",

+                       start, end, count, type, indices,

+                       ctx->Array.ArrayObj->_MaxElement - 1,

+                       ctx->Array.ElementArrayBufferObj->Name,

+                       (int) ctx->Array.ElementArrayBufferObj->Size);

+      }

+

+      if (0)

+         dump_element_buffer(ctx, type);

+

+      if (0)

+         _mesa_print_arrays(ctx);

+

+#ifdef DEBUG

+      /* 'end' was out of bounds, but now let's check the actual array

+       * indexes to see if any of them are out of bounds.

+       */

+      {

+         GLuint max = _mesa_max_buffer_index(ctx, count, type, indices,

+                                             ctx->Array.ElementArrayBufferObj);

+         if (max >= ctx->Array.ArrayObj->_MaxElement) {

+            if (warnCount < 10) {

+               _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, "

+                             "count %d, type 0x%x, indices=%p)\n"

+                             "\tindex=%u is out of bounds (max=%u)  "

+                             "Element Buffer %u (size %d)\n"

+                             "\tSkipping the glDrawRangeElements() call",

+                             start, end, count, type, indices, max,

+                             ctx->Array.ArrayObj->_MaxElement - 1,

+                             ctx->Array.ElementArrayBufferObj->Name,

+                             (int) ctx->Array.ElementArrayBufferObj->Size);

+            }

+         }

+         /* XXX we could also find the min index and compare to 'start'

+          * to see if start is correct.  But it's more likely to get the

+          * upper bound wrong.

+          */

+      }

+#endif

+

+      /* Set 'end' to the max possible legal value */

+      assert(ctx->Array.ArrayObj->_MaxElement >= 1);

+      end = ctx->Array.ArrayObj->_MaxElement - 1;

+   }

+   else if (0) {

+      printf("glDraw[Range]Elements{,BaseVertex}"

+	     "(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "

+	     "base %d\n",

+	     start, end, type, count,

+	     ctx->Array.ElementArrayBufferObj->Name,

+	     basevertex);

+   }

+

+#if 0

+   check_draw_elements_data(ctx, count, type, indices);

+#else

+   (void) check_draw_elements_data;

+#endif

+

+   vbo_validated_drawrangeelements(ctx, mode, GL_TRUE, start, end,

+				   count, type, indices, basevertex, 1);

+}

+

+

+/**

+ * Called by glDrawRangeElements() in immediate mode.

+ */

+static void GLAPIENTRY

+vbo_exec_DrawRangeElements(GLenum mode, GLuint start, GLuint end,

+                           GLsizei count, GLenum type, const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx,

+                  "glDrawRangeElements(%s, %u, %u, %d, %s, %p)\n",

+                  _mesa_lookup_enum_by_nr(mode), start, end, count,

+                  _mesa_lookup_enum_by_nr(type), indices);

+

+   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,

+					indices, 0);

+}

+

+

+/**

+ * Called by glDrawElements() in immediate mode.

+ */

+static void GLAPIENTRY

+vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,

+                      const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",

+                  _mesa_lookup_enum_by_nr(mode), count,

+                  _mesa_lookup_enum_by_nr(type), indices);

+

+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))

+      return;

+

+   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,

+				   count, type, indices, 0, 1);

+}

+

+

+/**

+ * Called by glDrawElementsBaseVertex() in immediate mode.

+ */

+static void GLAPIENTRY

+vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,

+				const GLvoid *indices, GLint basevertex)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx, "glDrawElementsBaseVertex(%s, %d, %s, %p, %d)\n",

+                  _mesa_lookup_enum_by_nr(mode), count,

+                  _mesa_lookup_enum_by_nr(type), indices, basevertex);

+

+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,

+				     basevertex ))

+      return;

+

+   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,

+				   count, type, indices, basevertex, 1);

+}

+

+

+/**

+ * Called by glDrawElementsInstanced() in immediate mode.

+ */

+static void GLAPIENTRY

+vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,

+                               const GLvoid *indices, GLsizei numInstances)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_DRAW)

+      _mesa_debug(ctx, "glDrawElementsInstanced(%s, %d, %s, %p, %d)\n",

+                  _mesa_lookup_enum_by_nr(mode), count,

+                  _mesa_lookup_enum_by_nr(type), indices, numInstances);

+

+   if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices,

+                                             numInstances))

+      return;

+

+   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,

+				   count, type, indices, 0, numInstances);

+}

+

+

+/**

+ * Inner support for both _mesa_MultiDrawElements() and

+ * _mesa_MultiDrawRangeElements().

+ * This does the actual rendering after we've checked array indexes, etc.

+ */

+static void

+vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,

+				const GLsizei *count, GLenum type,

+				const GLvoid **indices, GLsizei primcount,

+				const GLint *basevertex)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   struct _mesa_index_buffer ib;

+   struct _mesa_prim *prim;

+   unsigned int index_type_size = 0;

+   uintptr_t min_index_ptr, max_index_ptr;

+   GLboolean fallback = GL_FALSE;

+   int i;

+

+   if (primcount == 0)

+      return;

+

+   FLUSH_CURRENT( ctx, 0 );

+

+   if (!_mesa_valid_to_render(ctx, "glMultiDrawElements")) {

+      return;

+   }

+

+   prim = calloc(1, primcount * sizeof(*prim));

+   if (prim == NULL) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMultiDrawElements");

+      return;

+   }

+

+   /* Decide if we can do this all as one set of primitives sharing the

+    * same index buffer, or if we have to reset the index pointer per

+    * primitive.

+    */

+   bind_arrays( ctx );

+

+   /* check for dirty state again */

+   if (ctx->NewState)

+      _mesa_update_state( ctx );

+

+   switch (type) {

+   case GL_UNSIGNED_INT:

+      index_type_size = 4;

+      break;

+   case GL_UNSIGNED_SHORT:

+      index_type_size = 2;

+      break;

+   case GL_UNSIGNED_BYTE:

+      index_type_size = 1;

+      break;

+   default:

+      assert(0);

+   }

+

+   min_index_ptr = (uintptr_t)indices[0];

+   max_index_ptr = 0;

+   for (i = 0; i < primcount; i++) {

+      min_index_ptr = MIN2(min_index_ptr, (uintptr_t)indices[i]);

+      max_index_ptr = MAX2(max_index_ptr, (uintptr_t)indices[i] +

+			   index_type_size * count[i]);

+   }

+

+   /* Check if we can handle this thing as a bunch of index offsets from the

+    * same index pointer.  If we can't, then we have to fall back to doing

+    * a draw_prims per primitive.

+    * Check that the difference between each prim's indexes is a multiple of

+    * the index/element size.

+    */

+   if (index_type_size != 1) {

+      for (i = 0; i < primcount; i++) {

+	 if ((((uintptr_t)indices[i] - min_index_ptr) % index_type_size) != 0) {

+	    fallback = GL_TRUE;

+	    break;

+	 }

+      }

+   }

+

+   /* If the index buffer isn't in a VBO, then treating the application's

+    * subranges of the index buffer as one large index buffer may lead to

+    * us reading unmapped memory.

+    */

+   if (!_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj))

+      fallback = GL_TRUE;

+

+   if (!fallback) {

+      ib.count = (max_index_ptr - min_index_ptr) / index_type_size;

+      ib.type = type;

+      ib.obj = ctx->Array.ElementArrayBufferObj;

+      ib.ptr = (void *)min_index_ptr;

+

+      for (i = 0; i < primcount; i++) {

+	 prim[i].begin = (i == 0);

+	 prim[i].end = (i == primcount - 1);

+	 prim[i].weak = 0;

+	 prim[i].pad = 0;

+	 prim[i].mode = mode;

+	 prim[i].start = ((uintptr_t)indices[i] - min_index_ptr) / index_type_size;

+	 prim[i].count = count[i];

+	 prim[i].indexed = 1;

+         prim[i].num_instances = 1;

+	 if (basevertex != NULL)

+	    prim[i].basevertex = basevertex[i];

+	 else

+	    prim[i].basevertex = 0;

+      }

+

+      check_buffers_are_unmapped(exec->array.inputs);

+      vbo->draw_prims(ctx, exec->array.inputs, prim, primcount, &ib,

+		      GL_FALSE, ~0, ~0);

+   } else {

+      /* render one prim at a time */

+      for (i = 0; i < primcount; i++) {

+	 ib.count = count[i];

+	 ib.type = type;

+	 ib.obj = ctx->Array.ElementArrayBufferObj;

+	 ib.ptr = indices[i];

+

+	 prim[0].begin = 1;

+	 prim[0].end = 1;

+	 prim[0].weak = 0;

+	 prim[0].pad = 0;

+	 prim[0].mode = mode;

+	 prim[0].start = 0;

+	 prim[0].count = count[i];

+	 prim[0].indexed = 1;

+         prim[0].num_instances = 1;

+	 if (basevertex != NULL)

+	    prim[0].basevertex = basevertex[i];

+	 else

+	    prim[0].basevertex = 0;

+

+         check_buffers_are_unmapped(exec->array.inputs);

+         vbo->draw_prims(ctx, exec->array.inputs, prim, 1, &ib,

+                         GL_FALSE, ~0, ~0);

+      }

+   }

+

+   free(prim);

+}

+

+

+static void GLAPIENTRY

+vbo_exec_MultiDrawElements(GLenum mode,

+			   const GLsizei *count, GLenum type,

+			   const GLvoid **indices,

+			   GLsizei primcount)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   for (i = 0; i < primcount; i++) {

+      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],

+				       0))

+	 return;

+   }

+

+   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,

+				   NULL);

+}

+

+

+static void GLAPIENTRY

+vbo_exec_MultiDrawElementsBaseVertex(GLenum mode,

+				     const GLsizei *count, GLenum type,

+				     const GLvoid **indices,

+				     GLsizei primcount,

+				     const GLsizei *basevertex)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   for (i = 0; i < primcount; i++) {

+      if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],

+				       basevertex[i]))

+	 return;

+   }

+

+   vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,

+				   basevertex);

+}

+

+

+/**

+ * Plug in the immediate-mode vertex array drawing commands into the

+ * givven vbo_exec_context object.

+ */

+void

+vbo_exec_array_init( struct vbo_exec_context *exec )

+{

+   exec->vtxfmt.DrawArrays = vbo_exec_DrawArrays;

+   exec->vtxfmt.DrawElements = vbo_exec_DrawElements;

+   exec->vtxfmt.DrawRangeElements = vbo_exec_DrawRangeElements;

+   exec->vtxfmt.MultiDrawElementsEXT = vbo_exec_MultiDrawElements;

+   exec->vtxfmt.DrawElementsBaseVertex = vbo_exec_DrawElementsBaseVertex;

+   exec->vtxfmt.DrawRangeElementsBaseVertex = vbo_exec_DrawRangeElementsBaseVertex;

+   exec->vtxfmt.MultiDrawElementsBaseVertex = vbo_exec_MultiDrawElementsBaseVertex;

+   exec->vtxfmt.DrawArraysInstanced = vbo_exec_DrawArraysInstanced;

+   exec->vtxfmt.DrawElementsInstanced = vbo_exec_DrawElementsInstanced;

+}

+

+

+void

+vbo_exec_array_destroy( struct vbo_exec_context *exec )

+{

+   /* nothing to do */

+}

+

+

+

+/**

+ * The following functions are only used for OpenGL ES 1/2 support.

+ * And some aren't even supported (yet) in ES 1/2.

+ */

+

+

+void GLAPIENTRY

+_mesa_DrawArrays(GLenum mode, GLint first, GLsizei count)

+{

+   vbo_exec_DrawArrays(mode, first, count);

+}

+

+

+void GLAPIENTRY

+_mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,

+                   const GLvoid *indices)

+{

+   vbo_exec_DrawElements(mode, count, type, indices);

+}

+

+

+void GLAPIENTRY

+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,

+			     const GLvoid *indices, GLint basevertex)

+{

+   vbo_exec_DrawElementsBaseVertex(mode, count, type, indices, basevertex);

+}

+

+

+void GLAPIENTRY

+_mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,

+                        GLenum type, const GLvoid *indices)

+{

+   vbo_exec_DrawRangeElements(mode, start, end, count, type, indices);

+}

+

+

+void GLAPIENTRY

+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,

+				  GLsizei count, GLenum type,

+				  const GLvoid *indices, GLint basevertex)

+{

+   vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,

+					indices, basevertex);

+}

+

+

+void GLAPIENTRY

+_mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,

+			   const GLvoid **indices, GLsizei primcount)

+{

+   vbo_exec_MultiDrawElements(mode, count, type, indices, primcount);

+}

+

+

+void GLAPIENTRY

+_mesa_MultiDrawElementsBaseVertex(GLenum mode,

+				  const GLsizei *count, GLenum type,

+				  const GLvoid **indices, GLsizei primcount,

+				  const GLint *basevertex)

+{

+   vbo_exec_MultiDrawElementsBaseVertex(mode, count, type, indices,

+					primcount, basevertex);

+}

diff --git a/mesalib/src/mesa/vbo/vbo_exec_draw.c b/mesalib/src/mesa/vbo/vbo_exec_draw.c
index 539658021..7cc843779 100644
--- a/mesalib/src/mesa/vbo/vbo_exec_draw.c
+++ b/mesalib/src/mesa/vbo/vbo_exec_draw.c
@@ -1,426 +1,426 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.2
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/compiler.h"
-#include "main/enums.h"
-#include "main/mfeatures.h"
-#include "main/state.h"
-
-#include "vbo_context.h"
-
-
-#if FEATURE_beginend
-
-
-static void
-vbo_exec_debug_verts( struct vbo_exec_context *exec )
-{
-   GLuint count = exec->vtx.vert_count;
-   GLuint i;
-
-   printf("%s: %u vertices %d primitives, %d vertsize\n",
-	  __FUNCTION__,
-	  count,
-	  exec->vtx.prim_count,
-	  exec->vtx.vertex_size);
-
-   for (i = 0 ; i < exec->vtx.prim_count ; i++) {
-      struct _mesa_prim *prim = &exec->vtx.prim[i];
-      printf("   prim %d: %s%s %d..%d %s %s\n",
-	     i, 
-	     _mesa_lookup_prim_by_nr(prim->mode),
-	     prim->weak ? " (weak)" : "",
-	     prim->start, 
-	     prim->start + prim->count,
-	     prim->begin ? "BEGIN" : "(wrap)",
-	     prim->end ? "END" : "(wrap)");
-   }
-}
-
-
-/*
- * NOTE: Need to have calculated primitives by this point -- do it on the fly.
- * NOTE: Old 'parity' issue is gone.
- */
-static GLuint
-vbo_copy_vertices( struct vbo_exec_context *exec )
-{
-   GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count;
-   GLuint ovf, i;
-   GLuint sz = exec->vtx.vertex_size;
-   GLfloat *dst = exec->vtx.copied.buffer;
-   const GLfloat *src = (exec->vtx.buffer_map + 
-                         exec->vtx.prim[exec->vtx.prim_count-1].start * 
-                         exec->vtx.vertex_size);
-
-
-   switch (exec->ctx->Driver.CurrentExecPrimitive) {
-   case GL_POINTS:
-      return 0;
-   case GL_LINES:
-      ovf = nr&1;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
-      return i;
-   case GL_TRIANGLES:
-      ovf = nr%3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
-      return i;
-   case GL_QUADS:
-      ovf = nr&3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
-      return i;
-   case GL_LINE_STRIP:
-      if (nr == 0) {
-	 return 0;
-      }
-      else {
-	 memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) );
-	 return 1;
-      }
-   case GL_LINE_LOOP:
-   case GL_TRIANGLE_FAN:
-   case GL_POLYGON:
-      if (nr == 0) {
-	 return 0;
-      }
-      else if (nr == 1) {
-	 memcpy( dst, src+0, sz * sizeof(GLfloat) );
-	 return 1;
-      }
-      else {
-	 memcpy( dst, src+0, sz * sizeof(GLfloat) );
-	 memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) );
-	 return 2;
-      }
-   case GL_TRIANGLE_STRIP:
-      /* no parity issue, but need to make sure the tri is not drawn twice */
-      if (nr & 1) {
-	 exec->vtx.prim[exec->vtx.prim_count-1].count--;
-      }
-      /* fallthrough */
-   case GL_QUAD_STRIP:
-      switch (nr) {
-      case 0:
-         ovf = 0;
-         break;
-      case 1:
-         ovf = 1;
-         break;
-      default:
-         ovf = 2 + (nr & 1);
-         break;
-      }
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );
-      return i;
-   case PRIM_OUTSIDE_BEGIN_END:
-      return 0;
-   default:
-      assert(0);
-      return 0;
-   }
-}
-
-
-
-/* TODO: populate these as the vertex is defined:
- */
-static void
-vbo_exec_bind_arrays( struct gl_context *ctx )
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   struct gl_client_array *arrays = exec->vtx.arrays;
-   const GLuint count = exec->vtx.vert_count;
-   const GLuint *map;
-   GLuint attr;
-   GLbitfield varying_inputs = 0x0;
-
-   /* Install the default (ie Current) attributes first, then overlay
-    * all active ones.
-    */
-   switch (get_program_mode(exec->ctx)) {
-   case VP_NONE:
-      for (attr = 0; attr < 16; attr++) {
-         exec->vtx.inputs[attr] = &vbo->legacy_currval[attr];
-      }
-      for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {
-         ASSERT(attr + 16 < Elements(exec->vtx.inputs));
-         exec->vtx.inputs[attr + 16] = &vbo->mat_currval[attr];
-      }
-      map = vbo->map_vp_none;
-      break;
-   case VP_NV:
-   case VP_ARB:
-      /* The aliasing of attributes for NV vertex programs has already
-       * occurred.  NV vertex programs cannot access material values,
-       * nor attributes greater than VERT_ATTRIB_TEX7.  
-       */
-      for (attr = 0; attr < 16; attr++) {
-         exec->vtx.inputs[attr] = &vbo->legacy_currval[attr];
-         ASSERT(attr + 16 < Elements(exec->vtx.inputs));
-         exec->vtx.inputs[attr + 16] = &vbo->generic_currval[attr];
-      }
-      map = vbo->map_vp_arb;
-
-      /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.
-       * In that case we effectively need to route the data from
-       * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
-       */
-      if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&
-          (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {
-         exec->vtx.inputs[16] = exec->vtx.inputs[0];
-         exec->vtx.attrsz[16] = exec->vtx.attrsz[0];
-         exec->vtx.attrptr[16] = exec->vtx.attrptr[0];
-         exec->vtx.attrsz[0] = 0;
-      }
-      break;
-   default:
-      assert(0);
-   }
-
-   /* Make all active attributes (including edgeflag) available as
-    * arrays of floats.
-    */
-   for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) {
-      const GLuint src = map[attr];
-
-      if (exec->vtx.attrsz[src]) {
-	 GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] -
-	    (GLbyte *)exec->vtx.vertex;
-
-         /* override the default array set above */
-         ASSERT(attr < Elements(exec->vtx.inputs));
-         ASSERT(attr < Elements(exec->vtx.arrays)); /* arrays[] */
-         exec->vtx.inputs[attr] = &arrays[attr];
-
-         if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
-            /* a real buffer obj: Ptr is an offset, not a pointer*/
-            assert(exec->vtx.bufferobj->Pointer);  /* buf should be mapped */
-            assert(offset >= 0);
-            arrays[attr].Ptr = (GLubyte *)exec->vtx.bufferobj->Offset + offset;
-         }
-         else {
-            /* Ptr into ordinary app memory */
-            arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset;
-         }
-	 arrays[attr].Size = exec->vtx.attrsz[src];
-	 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat);
-	 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat);
-	 arrays[attr].Type = GL_FLOAT;
-         arrays[attr].Format = GL_RGBA;
-	 arrays[attr].Enabled = 1;
-         _mesa_reference_buffer_object(ctx,
-                                       &arrays[attr].BufferObj,
-                                       exec->vtx.bufferobj);
-	 arrays[attr]._MaxElement = count; /* ??? */
-
-         varying_inputs |= 1 << attr;
-         ctx->NewState |= _NEW_ARRAY;
-      }
-   }
-
-   _mesa_set_varying_vp_inputs( ctx, varying_inputs );
-}
-
-
-/**
- * Unmap the VBO.  This is called before drawing.
- */
-static void
-vbo_exec_vtx_unmap( struct vbo_exec_context *exec )
-{
-   GLenum target = GL_ARRAY_BUFFER_ARB;
-
-   if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
-      struct gl_context *ctx = exec->ctx;
-      
-      if (ctx->Driver.FlushMappedBufferRange) {
-         GLintptr offset = exec->vtx.buffer_used - exec->vtx.bufferobj->Offset;
-         GLsizeiptr length = (exec->vtx.buffer_ptr - exec->vtx.buffer_map) * sizeof(float);
-
-         if (length)
-            ctx->Driver.FlushMappedBufferRange(ctx, target,
-                                               offset, length,
-                                               exec->vtx.bufferobj);
-      }
-
-      exec->vtx.buffer_used += (exec->vtx.buffer_ptr -
-                                exec->vtx.buffer_map) * sizeof(float);
-
-      assert(exec->vtx.buffer_used <= VBO_VERT_BUFFER_SIZE);
-      assert(exec->vtx.buffer_ptr != NULL);
-      
-      ctx->Driver.UnmapBuffer(ctx, target, exec->vtx.bufferobj);
-      exec->vtx.buffer_map = NULL;
-      exec->vtx.buffer_ptr = NULL;
-      exec->vtx.max_vert = 0;
-   }
-}
-
-
-/**
- * Map the vertex buffer to begin storing glVertex, glColor, etc data.
- */
-void
-vbo_exec_vtx_map( struct vbo_exec_context *exec )
-{
-   struct gl_context *ctx = exec->ctx;
-   const GLenum target = GL_ARRAY_BUFFER_ARB;
-   const GLenum access = GL_READ_WRITE_ARB; /* for MapBuffer */
-   const GLenum accessRange = GL_MAP_WRITE_BIT |  /* for MapBufferRange */
-                              GL_MAP_INVALIDATE_RANGE_BIT |
-                              GL_MAP_UNSYNCHRONIZED_BIT |
-                              GL_MAP_FLUSH_EXPLICIT_BIT |
-                              MESA_MAP_NOWAIT_BIT;
-   const GLenum usage = GL_STREAM_DRAW_ARB;
-   
-   if (!_mesa_is_bufferobj(exec->vtx.bufferobj))
-      return;
-
-   assert(!exec->vtx.buffer_map);
-   assert(!exec->vtx.buffer_ptr);
-
-   if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024 &&
-       ctx->Driver.MapBufferRange) {
-      /* The VBO exists and there's room for more */
-      exec->vtx.buffer_map = 
-         (GLfloat *)ctx->Driver.MapBufferRange(ctx, 
-                                               target, 
-                                               exec->vtx.buffer_used,
-                                               (VBO_VERT_BUFFER_SIZE - 
-                                                exec->vtx.buffer_used),
-                                               accessRange,
-                                               exec->vtx.bufferobj);
-      exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-   }
-   
-   if (!exec->vtx.buffer_map) {
-      /* Need to allocate a new VBO */
-      exec->vtx.buffer_used = 0;
-
-      ctx->Driver.BufferData(ctx, target, 
-                             VBO_VERT_BUFFER_SIZE, 
-                             NULL, usage, exec->vtx.bufferobj);
-
-
-      if (ctx->Driver.MapBufferRange)
-         exec->vtx.buffer_map = 
-            (GLfloat *)ctx->Driver.MapBufferRange(ctx, target,
-                                                  0, VBO_VERT_BUFFER_SIZE,
-                                                  accessRange,
-                                                  exec->vtx.bufferobj);
-      if (!exec->vtx.buffer_map)
-         exec->vtx.buffer_map =
-            (GLfloat *)ctx->Driver.MapBuffer(ctx, target, access, exec->vtx.bufferobj);
-      assert(exec->vtx.buffer_map);
-      exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-   }
-
-   if (0)
-      printf("map %d..\n", exec->vtx.buffer_used);
-}
-
-
-
-/**
- * Execute the buffer and save copied verts.
- * \param keep_unmapped  if true, leave the VBO unmapped when we're done.
- */
-void
-vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped)
-{
-   if (0)
-      vbo_exec_debug_verts( exec );
-
-   if (exec->vtx.prim_count && 
-       exec->vtx.vert_count) {
-
-      exec->vtx.copied.nr = vbo_copy_vertices( exec ); 
-
-      if (exec->vtx.copied.nr != exec->vtx.vert_count) {
-	 struct gl_context *ctx = exec->ctx;
-	 
-	 /* Before the update_state() as this may raise _NEW_ARRAY
-          * from _mesa_set_varying_vp_inputs().
-	  */
-	 vbo_exec_bind_arrays( ctx );
-
-         if (ctx->NewState)
-            _mesa_update_state( ctx );
-
-         if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {
-            vbo_exec_vtx_unmap( exec );
-         }
-
-         if (0)
-            printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count,
-		   exec->vtx.vert_count);
-
-	 vbo_context(ctx)->draw_prims( ctx, 
-				       exec->vtx.inputs, 
-				       exec->vtx.prim, 
-				       exec->vtx.prim_count,
-				       NULL,
-				       GL_TRUE,
-				       0,
-				       exec->vtx.vert_count - 1);
-
-	 /* If using a real VBO, get new storage -- unless asked not to.
-          */
-         if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) {
-            vbo_exec_vtx_map( exec );
-         }
-      }
-   }
-
-   /* May have to unmap explicitly if we didn't draw:
-    */
-   if (keepUnmapped &&
-       _mesa_is_bufferobj(exec->vtx.bufferobj) &&
-       exec->vtx.buffer_map) {
-      vbo_exec_vtx_unmap( exec );
-   }
-
-   if (keepUnmapped || exec->vtx.vertex_size == 0)
-      exec->vtx.max_vert = 0;
-   else
-      exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 
-                            (exec->vtx.vertex_size * sizeof(GLfloat)));
-
-   exec->vtx.buffer_ptr = exec->vtx.buffer_map;
-   exec->vtx.prim_count = 0;
-   exec->vtx.vert_count = 0;
-}
-
-
-#endif /* FEATURE_beginend */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.2

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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:

+ *    Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/compiler.h"

+#include "main/enums.h"

+#include "main/mfeatures.h"

+#include "main/state.h"

+

+#include "vbo_context.h"

+

+

+#if FEATURE_beginend

+

+

+static void

+vbo_exec_debug_verts( struct vbo_exec_context *exec )

+{

+   GLuint count = exec->vtx.vert_count;

+   GLuint i;

+

+   printf("%s: %u vertices %d primitives, %d vertsize\n",

+	  __FUNCTION__,

+	  count,

+	  exec->vtx.prim_count,

+	  exec->vtx.vertex_size);

+

+   for (i = 0 ; i < exec->vtx.prim_count ; i++) {

+      struct _mesa_prim *prim = &exec->vtx.prim[i];

+      printf("   prim %d: %s%s %d..%d %s %s\n",

+	     i, 

+	     _mesa_lookup_prim_by_nr(prim->mode),

+	     prim->weak ? " (weak)" : "",

+	     prim->start, 

+	     prim->start + prim->count,

+	     prim->begin ? "BEGIN" : "(wrap)",

+	     prim->end ? "END" : "(wrap)");

+   }

+}

+

+

+/*

+ * NOTE: Need to have calculated primitives by this point -- do it on the fly.

+ * NOTE: Old 'parity' issue is gone.

+ */

+static GLuint

+vbo_copy_vertices( struct vbo_exec_context *exec )

+{

+   GLuint nr = exec->vtx.prim[exec->vtx.prim_count-1].count;

+   GLuint ovf, i;

+   GLuint sz = exec->vtx.vertex_size;

+   GLfloat *dst = exec->vtx.copied.buffer;

+   const GLfloat *src = (exec->vtx.buffer_map + 

+                         exec->vtx.prim[exec->vtx.prim_count-1].start * 

+                         exec->vtx.vertex_size);

+

+

+   switch (exec->ctx->Driver.CurrentExecPrimitive) {

+   case GL_POINTS:

+      return 0;

+   case GL_LINES:

+      ovf = nr&1;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );

+      return i;

+   case GL_TRIANGLES:

+      ovf = nr%3;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );

+      return i;

+   case GL_QUADS:

+      ovf = nr&3;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );

+      return i;

+   case GL_LINE_STRIP:

+      if (nr == 0) {

+	 return 0;

+      }

+      else {

+	 memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) );

+	 return 1;

+      }

+   case GL_LINE_LOOP:

+   case GL_TRIANGLE_FAN:

+   case GL_POLYGON:

+      if (nr == 0) {

+	 return 0;

+      }

+      else if (nr == 1) {

+	 memcpy( dst, src+0, sz * sizeof(GLfloat) );

+	 return 1;

+      }

+      else {

+	 memcpy( dst, src+0, sz * sizeof(GLfloat) );

+	 memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) );

+	 return 2;

+      }

+   case GL_TRIANGLE_STRIP:

+      /* no parity issue, but need to make sure the tri is not drawn twice */

+      if (nr & 1) {

+	 exec->vtx.prim[exec->vtx.prim_count-1].count--;

+      }

+      /* fallthrough */

+   case GL_QUAD_STRIP:

+      switch (nr) {

+      case 0:

+         ovf = 0;

+         break;

+      case 1:

+         ovf = 1;

+         break;

+      default:

+         ovf = 2 + (nr & 1);

+         break;

+      }

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) );

+      return i;

+   case PRIM_OUTSIDE_BEGIN_END:

+      return 0;

+   default:

+      assert(0);

+      return 0;

+   }

+}

+

+

+

+/* TODO: populate these as the vertex is defined:

+ */

+static void

+vbo_exec_bind_arrays( struct gl_context *ctx )

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_exec_context *exec = &vbo->exec;

+   struct gl_client_array *arrays = exec->vtx.arrays;

+   const GLuint count = exec->vtx.vert_count;

+   const GLuint *map;

+   GLuint attr;

+   GLbitfield varying_inputs = 0x0;

+

+   /* Install the default (ie Current) attributes first, then overlay

+    * all active ones.

+    */

+   switch (get_program_mode(exec->ctx)) {

+   case VP_NONE:

+      for (attr = 0; attr < 16; attr++) {

+         exec->vtx.inputs[attr] = &vbo->legacy_currval[attr];

+      }

+      for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {

+         ASSERT(attr + 16 < Elements(exec->vtx.inputs));

+         exec->vtx.inputs[attr + 16] = &vbo->mat_currval[attr];

+      }

+      map = vbo->map_vp_none;

+      break;

+   case VP_NV:

+   case VP_ARB:

+      /* The aliasing of attributes for NV vertex programs has already

+       * occurred.  NV vertex programs cannot access material values,

+       * nor attributes greater than VERT_ATTRIB_TEX7.  

+       */

+      for (attr = 0; attr < 16; attr++) {

+         exec->vtx.inputs[attr] = &vbo->legacy_currval[attr];

+         ASSERT(attr + 16 < Elements(exec->vtx.inputs));

+         exec->vtx.inputs[attr + 16] = &vbo->generic_currval[attr];

+      }

+      map = vbo->map_vp_arb;

+

+      /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.

+       * In that case we effectively need to route the data from

+       * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.

+       */

+      if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&

+          (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {

+         exec->vtx.inputs[16] = exec->vtx.inputs[0];

+         exec->vtx.attrsz[16] = exec->vtx.attrsz[0];

+         exec->vtx.attrptr[16] = exec->vtx.attrptr[0];

+         exec->vtx.attrsz[0] = 0;

+      }

+      break;

+   default:

+      assert(0);

+   }

+

+   /* Make all active attributes (including edgeflag) available as

+    * arrays of floats.

+    */

+   for (attr = 0; attr < VERT_ATTRIB_MAX ; attr++) {

+      const GLuint src = map[attr];

+

+      if (exec->vtx.attrsz[src]) {

+	 GLsizeiptr offset = (GLbyte *)exec->vtx.attrptr[src] -

+	    (GLbyte *)exec->vtx.vertex;

+

+         /* override the default array set above */

+         ASSERT(attr < Elements(exec->vtx.inputs));

+         ASSERT(attr < Elements(exec->vtx.arrays)); /* arrays[] */

+         exec->vtx.inputs[attr] = &arrays[attr];

+

+         if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {

+            /* a real buffer obj: Ptr is an offset, not a pointer*/

+            assert(exec->vtx.bufferobj->Pointer);  /* buf should be mapped */

+            assert(offset >= 0);

+            arrays[attr].Ptr = (GLubyte *)exec->vtx.bufferobj->Offset + offset;

+         }

+         else {

+            /* Ptr into ordinary app memory */

+            arrays[attr].Ptr = (GLubyte *)exec->vtx.buffer_map + offset;

+         }

+	 arrays[attr].Size = exec->vtx.attrsz[src];

+	 arrays[attr].StrideB = exec->vtx.vertex_size * sizeof(GLfloat);

+	 arrays[attr].Stride = exec->vtx.vertex_size * sizeof(GLfloat);

+	 arrays[attr].Type = GL_FLOAT;

+         arrays[attr].Format = GL_RGBA;

+	 arrays[attr].Enabled = 1;

+         _mesa_reference_buffer_object(ctx,

+                                       &arrays[attr].BufferObj,

+                                       exec->vtx.bufferobj);

+	 arrays[attr]._MaxElement = count; /* ??? */

+

+         varying_inputs |= 1 << attr;

+         ctx->NewState |= _NEW_ARRAY;

+      }

+   }

+

+   _mesa_set_varying_vp_inputs( ctx, varying_inputs );

+}

+

+

+/**

+ * Unmap the VBO.  This is called before drawing.

+ */

+static void

+vbo_exec_vtx_unmap( struct vbo_exec_context *exec )

+{

+   GLenum target = GL_ARRAY_BUFFER_ARB;

+

+   if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {

+      struct gl_context *ctx = exec->ctx;

+      

+      if (ctx->Driver.FlushMappedBufferRange) {

+         GLintptr offset = exec->vtx.buffer_used - exec->vtx.bufferobj->Offset;

+         GLsizeiptr length = (exec->vtx.buffer_ptr - exec->vtx.buffer_map) * sizeof(float);

+

+         if (length)

+            ctx->Driver.FlushMappedBufferRange(ctx, target,

+                                               offset, length,

+                                               exec->vtx.bufferobj);

+      }

+

+      exec->vtx.buffer_used += (exec->vtx.buffer_ptr -

+                                exec->vtx.buffer_map) * sizeof(float);

+

+      assert(exec->vtx.buffer_used <= VBO_VERT_BUFFER_SIZE);

+      assert(exec->vtx.buffer_ptr != NULL);

+      

+      ctx->Driver.UnmapBuffer(ctx, target, exec->vtx.bufferobj);

+      exec->vtx.buffer_map = NULL;

+      exec->vtx.buffer_ptr = NULL;

+      exec->vtx.max_vert = 0;

+   }

+}

+

+

+/**

+ * Map the vertex buffer to begin storing glVertex, glColor, etc data.

+ */

+void

+vbo_exec_vtx_map( struct vbo_exec_context *exec )

+{

+   struct gl_context *ctx = exec->ctx;

+   const GLenum target = GL_ARRAY_BUFFER_ARB;

+   const GLenum access = GL_READ_WRITE_ARB; /* for MapBuffer */

+   const GLenum accessRange = GL_MAP_WRITE_BIT |  /* for MapBufferRange */

+                              GL_MAP_INVALIDATE_RANGE_BIT |

+                              GL_MAP_UNSYNCHRONIZED_BIT |

+                              GL_MAP_FLUSH_EXPLICIT_BIT |

+                              MESA_MAP_NOWAIT_BIT;

+   const GLenum usage = GL_STREAM_DRAW_ARB;

+   

+   if (!_mesa_is_bufferobj(exec->vtx.bufferobj))

+      return;

+

+   assert(!exec->vtx.buffer_map);

+   assert(!exec->vtx.buffer_ptr);

+

+   if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024 &&

+       ctx->Driver.MapBufferRange) {

+      /* The VBO exists and there's room for more */

+      exec->vtx.buffer_map = 

+         (GLfloat *)ctx->Driver.MapBufferRange(ctx, 

+                                               target, 

+                                               exec->vtx.buffer_used,

+                                               (VBO_VERT_BUFFER_SIZE - 

+                                                exec->vtx.buffer_used),

+                                               accessRange,

+                                               exec->vtx.bufferobj);

+      exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+   }

+   

+   if (!exec->vtx.buffer_map) {

+      /* Need to allocate a new VBO */

+      exec->vtx.buffer_used = 0;

+

+      ctx->Driver.BufferData(ctx, target, 

+                             VBO_VERT_BUFFER_SIZE, 

+                             NULL, usage, exec->vtx.bufferobj);

+

+

+      if (ctx->Driver.MapBufferRange)

+         exec->vtx.buffer_map = 

+            (GLfloat *)ctx->Driver.MapBufferRange(ctx, target,

+                                                  0, VBO_VERT_BUFFER_SIZE,

+                                                  accessRange,

+                                                  exec->vtx.bufferobj);

+      if (!exec->vtx.buffer_map)

+         exec->vtx.buffer_map =

+            (GLfloat *)ctx->Driver.MapBuffer(ctx, target, access, exec->vtx.bufferobj);

+      assert(exec->vtx.buffer_map);

+      exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+   }

+

+   if (0)

+      printf("map %d..\n", exec->vtx.buffer_used);

+}

+

+

+

+/**

+ * Execute the buffer and save copied verts.

+ * \param keep_unmapped  if true, leave the VBO unmapped when we're done.

+ */

+void

+vbo_exec_vtx_flush(struct vbo_exec_context *exec, GLboolean keepUnmapped)

+{

+   if (0)

+      vbo_exec_debug_verts( exec );

+

+   if (exec->vtx.prim_count && 

+       exec->vtx.vert_count) {

+

+      exec->vtx.copied.nr = vbo_copy_vertices( exec ); 

+

+      if (exec->vtx.copied.nr != exec->vtx.vert_count) {

+	 struct gl_context *ctx = exec->ctx;

+	 

+	 /* Before the update_state() as this may raise _NEW_ARRAY

+          * from _mesa_set_varying_vp_inputs().

+	  */

+	 vbo_exec_bind_arrays( ctx );

+

+         if (ctx->NewState)

+            _mesa_update_state( ctx );

+

+         if (_mesa_is_bufferobj(exec->vtx.bufferobj)) {

+            vbo_exec_vtx_unmap( exec );

+         }

+

+         if (0)

+            printf("%s %d %d\n", __FUNCTION__, exec->vtx.prim_count,

+		   exec->vtx.vert_count);

+

+	 vbo_context(ctx)->draw_prims( ctx, 

+				       exec->vtx.inputs, 

+				       exec->vtx.prim, 

+				       exec->vtx.prim_count,

+				       NULL,

+				       GL_TRUE,

+				       0,

+				       exec->vtx.vert_count - 1);

+

+	 /* If using a real VBO, get new storage -- unless asked not to.

+          */

+         if (_mesa_is_bufferobj(exec->vtx.bufferobj) && !keepUnmapped) {

+            vbo_exec_vtx_map( exec );

+         }

+      }

+   }

+

+   /* May have to unmap explicitly if we didn't draw:

+    */

+   if (keepUnmapped &&

+       _mesa_is_bufferobj(exec->vtx.bufferobj) &&

+       exec->vtx.buffer_map) {

+      vbo_exec_vtx_unmap( exec );

+   }

+

+   if (keepUnmapped || exec->vtx.vertex_size == 0)

+      exec->vtx.max_vert = 0;

+   else

+      exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) / 

+                            (exec->vtx.vertex_size * sizeof(GLfloat)));

+

+   exec->vtx.buffer_ptr = exec->vtx.buffer_map;

+   exec->vtx.prim_count = 0;

+   exec->vtx.vert_count = 0;

+}

+

+

+#endif /* FEATURE_beginend */

diff --git a/mesalib/src/mesa/vbo/vbo_save_api.c b/mesalib/src/mesa/vbo/vbo_save_api.c
index 836c76fe8..52418788d 100644
--- a/mesalib/src/mesa/vbo/vbo_save_api.c
+++ b/mesalib/src/mesa/vbo/vbo_save_api.c
@@ -1,1310 +1,1310 @@
-/**************************************************************************
-
-Copyright 2002-2008 Tungsten Graphics 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
-on 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
-TUNGSTEN GRAPHICS 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:
- *   Keith Whitwell <keith@tungstengraphics.com>
- */
-
-
-
-/* Display list compiler attempts to store lists of vertices with the
- * same vertex layout.  Additionally it attempts to minimize the need
- * for execute-time fixup of these vertex lists, allowing them to be
- * cached on hardware.
- *
- * There are still some circumstances where this can be thwarted, for
- * example by building a list that consists of one very long primitive
- * (eg Begin(Triangles), 1000 vertices, End), and calling that list
- * from inside a different begin/end object (Begin(Lines), CallList,
- * End).  
- *
- * In that case the code will have to replay the list as individual
- * commands through the Exec dispatch table, or fix up the copied
- * vertices at execute-time.
- *
- * The other case where fixup is required is when a vertex attribute
- * is introduced in the middle of a primitive.  Eg:
- *  Begin(Lines)
- *  TexCoord1f()           Vertex2f()
- *  TexCoord1f() Color3f() Vertex2f()
- *  End()
- *
- *  If the current value of Color isn't known at compile-time, this
- *  primitive will require fixup.
- *
- *
- * The list compiler currently doesn't attempt to compile lists
- * containing EvalCoord or EvalPoint commands.  On encountering one of
- * these, compilation falls back to opcodes.  
- *
- * This could be improved to fallback only when a mix of EvalCoord and
- * Vertex commands are issued within a single primitive.
- */
-
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/context.h"
-#include "main/dlist.h"
-#include "main/enums.h"
-#include "main/eval.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/api_noop.h"
-#include "main/api_validate.h"
-#include "main/api_arrayelt.h"
-#include "main/vtxfmt.h"
-#include "main/dispatch.h"
-
-#include "vbo_context.h"
-
-
-#if FEATURE_dlist
-
-
-#ifdef ERROR
-#undef ERROR
-#endif
-
-
-/* An interesting VBO number/name to help with debugging */
-#define VBO_BUF_ID  12345
-
-
-/*
- * NOTE: Old 'parity' issue is gone, but copying can still be
- * wrong-footed on replay.
- */
-static GLuint _save_copy_vertices( struct gl_context *ctx, 
-				   const struct vbo_save_vertex_list *node,
-				   const GLfloat *src_buffer)
-{
-   struct vbo_save_context *save = &vbo_context( ctx )->save;
-   const struct _mesa_prim *prim = &node->prim[node->prim_count-1];
-   GLuint nr = prim->count;
-   GLuint sz = save->vertex_size;
-   const GLfloat *src = src_buffer + prim->start * sz;
-   GLfloat *dst = save->copied.buffer;
-   GLuint ovf, i;
-
-   if (prim->end)
-      return 0;
-	 
-   switch( prim->mode )
-   {
-   case GL_POINTS:
-      return 0;
-   case GL_LINES:
-      ovf = nr&1;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
-      return i;
-   case GL_TRIANGLES:
-      ovf = nr%3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
-      return i;
-   case GL_QUADS:
-      ovf = nr&3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
-      return i;
-   case GL_LINE_STRIP:
-      if (nr == 0) 
-	 return 0;
-      else {
-	 memcpy( dst, src+(nr-1)*sz, sz*sizeof(GLfloat) );
-	 return 1;
-      }
-   case GL_LINE_LOOP:
-   case GL_TRIANGLE_FAN:
-   case GL_POLYGON:
-      if (nr == 0) 
-	 return 0;
-      else if (nr == 1) {
-	 memcpy( dst, src+0, sz*sizeof(GLfloat) );
-	 return 1;
-      } else {
-	 memcpy( dst, src+0, sz*sizeof(GLfloat) );
-	 memcpy( dst+sz, src+(nr-1)*sz, sz*sizeof(GLfloat) );
-	 return 2;
-      }
-   case GL_TRIANGLE_STRIP:
-   case GL_QUAD_STRIP:
-      switch (nr) {
-      case 0: ovf = 0; break;
-      case 1: ovf = 1; break;
-      default: ovf = 2 + (nr&1); break;
-      }
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
-      return i;
-   default:
-      assert(0);
-      return 0;
-   }
-}
-
-
-static struct vbo_save_vertex_store *alloc_vertex_store( struct gl_context *ctx )
-{
-   struct vbo_save_vertex_store *vertex_store = CALLOC_STRUCT(vbo_save_vertex_store);
-
-   /* obj->Name needs to be non-zero, but won't ever be examined more
-    * closely than that.  In particular these buffers won't be entered
-    * into the hash and can never be confused with ones visible to the
-    * user.  Perhaps there could be a special number for internal
-    * buffers:
-    */
-   vertex_store->bufferobj = ctx->Driver.NewBufferObject(ctx,
-                                                         VBO_BUF_ID,
-                                                         GL_ARRAY_BUFFER_ARB);
-
-   ctx->Driver.BufferData( ctx, 
-			   GL_ARRAY_BUFFER_ARB, 
-			   VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),
-			   NULL,
-			   GL_STATIC_DRAW_ARB,
-			   vertex_store->bufferobj);
-
-   vertex_store->buffer = NULL;
-   vertex_store->used = 0;
-   vertex_store->refcount = 1;
-
-   return vertex_store;
-}
-
-static void free_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
-{
-   assert(!vertex_store->buffer);
-
-   if (vertex_store->bufferobj) {
-      _mesa_reference_buffer_object(ctx, &vertex_store->bufferobj, NULL);
-   }
-
-   FREE( vertex_store );
-}
-
-static GLfloat *map_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
-{
-   assert(vertex_store->bufferobj);
-   assert(!vertex_store->buffer);
-   vertex_store->buffer = (GLfloat *)ctx->Driver.MapBuffer(ctx, 
-							   GL_ARRAY_BUFFER_ARB,	/* not used */
-							   GL_WRITE_ONLY, /* not used */
-							   vertex_store->bufferobj); 
-
-   assert(vertex_store->buffer);
-   return vertex_store->buffer + vertex_store->used;
-}
-
-static void unmap_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
-{
-   ctx->Driver.UnmapBuffer( ctx, GL_ARRAY_BUFFER_ARB, vertex_store->bufferobj );
-   vertex_store->buffer = NULL;
-}
-
-
-static struct vbo_save_primitive_store *alloc_prim_store( struct gl_context *ctx )
-{
-   struct vbo_save_primitive_store *store = CALLOC_STRUCT(vbo_save_primitive_store);
-   (void) ctx;
-   store->used = 0;
-   store->refcount = 1;
-   return store;
-}
-
-static void _save_reset_counters( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   save->prim = save->prim_store->buffer + save->prim_store->used;
-   save->buffer = (save->vertex_store->buffer + 
-		   save->vertex_store->used);
-
-   assert(save->buffer == save->buffer_ptr);
-
-   if (save->vertex_size)
-      save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 
-			 save->vertex_size);
-   else
-      save->max_vert = 0;
-
-   save->vert_count = 0;
-   save->prim_count = 0;
-   save->prim_max = VBO_SAVE_PRIM_SIZE - save->prim_store->used;
-   save->dangling_attr_ref = 0;
-}
-
-
-/* Insert the active immediate struct onto the display list currently
- * being built.
- */
-static void _save_compile_vertex_list( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   struct vbo_save_vertex_list *node;
-
-   /* Allocate space for this structure in the display list currently
-    * being compiled.
-    */
-   node = (struct vbo_save_vertex_list *)
-      _mesa_dlist_alloc(ctx, save->opcode_vertex_list, sizeof(*node));
-
-   if (!node)
-      return;
-
-   /* Duplicate our template, increment refcounts to the storage structs:
-    */
-   memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));
-   node->vertex_size = save->vertex_size;
-   node->buffer_offset = (save->buffer - save->vertex_store->buffer) * sizeof(GLfloat); 
-   node->count = save->vert_count;
-   node->wrap_count = save->copied.nr;
-   node->dangling_attr_ref = save->dangling_attr_ref;
-   node->prim = save->prim;
-   node->prim_count = save->prim_count;
-   node->vertex_store = save->vertex_store;
-   node->prim_store = save->prim_store;
-
-   node->vertex_store->refcount++;
-   node->prim_store->refcount++;
-
-   if (node->prim[0].no_current_update) {
-      node->current_size = 0;
-      node->current_data = NULL;
-   } else {
-      node->current_size = node->vertex_size - node->attrsz[0];
-      node->current_data = NULL;
-     
-      if (node->current_size) {
-         /* If the malloc fails, we just pull the data out of the VBO
-          * later instead.
-          */
-         node->current_data = MALLOC( node->current_size * sizeof(GLfloat) );
-         if (node->current_data) {
-            const char *buffer = (const char *)save->vertex_store->buffer;
-            unsigned attr_offset = node->attrsz[0] * sizeof(GLfloat);
-            unsigned vertex_offset = 0;
-            
-            if (node->count)
-               vertex_offset = (node->count-1) * node->vertex_size * sizeof(GLfloat);
-         
-            memcpy( node->current_data,
-                    buffer + node->buffer_offset + vertex_offset + attr_offset,
-                    node->current_size * sizeof(GLfloat) );
-         }
-      }
-   }
-
-
-
-   assert(node->attrsz[VBO_ATTRIB_POS] != 0 ||
-	  node->count == 0);
-
-   if (save->dangling_attr_ref)
-      ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;
-
-   save->vertex_store->used += save->vertex_size * node->count;
-   save->prim_store->used += node->prim_count;
-
-
-   /* Copy duplicated vertices 
-    */
-   save->copied.nr = _save_copy_vertices( ctx, node, save->buffer );
-
-
-   /* Deal with GL_COMPILE_AND_EXECUTE:
-    */
-   if (ctx->ExecuteFlag) {
-      struct _glapi_table *dispatch = GET_DISPATCH();
-
-      _glapi_set_dispatch(ctx->Exec);
-
-      vbo_loopback_vertex_list( ctx,
-				(const GLfloat *)((const char *)save->vertex_store->buffer + 
-						  node->buffer_offset),
-				node->attrsz,
-				node->prim,
-				node->prim_count,
-				node->wrap_count,
-				node->vertex_size);
-
-      _glapi_set_dispatch(dispatch);
-   }
-
-
-   /* Decide whether the storage structs are full, or can be used for
-    * the next vertex lists as well.
-    */
-   if (save->vertex_store->used > 
-       VBO_SAVE_BUFFER_SIZE - 16 * (save->vertex_size + 4)) {
-
-      /* Unmap old store:
-       */
-      unmap_vertex_store( ctx, save->vertex_store );
-
-      /* Release old reference:
-       */
-      save->vertex_store->refcount--; 
-      assert(save->vertex_store->refcount != 0);
-      save->vertex_store = NULL;
-
-      /* Allocate and map new store:
-       */
-      save->vertex_store = alloc_vertex_store( ctx );
-      save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );
-   } 
-
-   if (save->prim_store->used > VBO_SAVE_PRIM_SIZE - 6) {
-      save->prim_store->refcount--; 
-      assert(save->prim_store->refcount != 0);
-      save->prim_store = alloc_prim_store( ctx );
-   } 
-
-   /* Reset our structures for the next run of vertices:
-    */
-   _save_reset_counters( ctx );
-}
-
-
-/* TODO -- If no new vertices have been stored, don't bother saving
- * it.
- */
-static void _save_wrap_buffers( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLint i = save->prim_count - 1;
-   GLenum mode;
-   GLboolean weak;
-   GLboolean no_current_update;
-
-   assert(i < (GLint) save->prim_max);
-   assert(i >= 0);
-
-   /* Close off in-progress primitive.
-    */
-   save->prim[i].count = (save->vert_count - 
-			  save->prim[i].start);
-   mode = save->prim[i].mode;
-   weak = save->prim[i].weak;
-   no_current_update = save->prim[i].no_current_update;
-   
-   /* store the copied vertices, and allocate a new list.
-    */
-   _save_compile_vertex_list( ctx );
-
-   /* Restart interrupted primitive
-    */
-   save->prim[0].mode = mode;
-   save->prim[0].weak = weak;
-   save->prim[0].no_current_update = no_current_update;
-   save->prim[0].begin = 0;
-   save->prim[0].end = 0;
-   save->prim[0].pad = 0;
-   save->prim[0].start = 0;
-   save->prim[0].count = 0;
-   save->prim[0].num_instances = 1;
-   save->prim_count = 1;
-}
-
-
-
-/* Called only when buffers are wrapped as the result of filling the
- * vertex_store struct.  
- */
-static void _save_wrap_filled_vertex( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLfloat *data = save->copied.buffer;
-   GLuint i;
-
-   /* Emit a glEnd to close off the last vertex list.
-    */
-   _save_wrap_buffers( ctx );
-   
-    /* Copy stored stored vertices to start of new list.
-    */
-   assert(save->max_vert - save->vert_count > save->copied.nr);
-
-   for (i = 0 ; i < save->copied.nr ; i++) {
-      memcpy( save->buffer_ptr, data, save->vertex_size * sizeof(GLfloat));
-      data += save->vertex_size;
-      save->buffer_ptr += save->vertex_size;
-      save->vert_count++;
-   }
-}
-
-
-static void _save_copy_to_current( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
-   GLuint i;
-
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
-      if (save->attrsz[i]) {
-	 save->currentsz[i][0] = save->attrsz[i];
-	 COPY_CLEAN_4V(save->current[i], 
-		       save->attrsz[i], 
-		       save->attrptr[i]);
-      }
-   }
-}
-
-
-static void _save_copy_from_current( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
-   GLint i;
-
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
-      switch (save->attrsz[i]) {
-      case 4: save->attrptr[i][3] = save->current[i][3];
-      case 3: save->attrptr[i][2] = save->current[i][2];
-      case 2: save->attrptr[i][1] = save->current[i][1];
-      case 1: save->attrptr[i][0] = save->current[i][0];
-      case 0: break;
-      }
-   }
-}
-
-
-
-
-/* Flush existing data, set new attrib size, replay copied vertices.
- */ 
-static void _save_upgrade_vertex( struct gl_context *ctx, 
-				 GLuint attr,
-				 GLuint newsz )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLuint oldsz;
-   GLuint i;
-   GLfloat *tmp;
-
-   /* Store the current run of vertices, and emit a GL_END.  Emit a
-    * BEGIN in the new buffer.
-    */
-   if (save->vert_count) 
-      _save_wrap_buffers( ctx );
-   else
-      assert( save->copied.nr == 0 );
-
-   /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
-    * when the attribute already exists in the vertex and is having
-    * its size increased.  
-    */
-   _save_copy_to_current( ctx );
-
-   /* Fix up sizes:
-    */
-   oldsz = save->attrsz[attr];
-   save->attrsz[attr] = newsz;
-
-   save->vertex_size += newsz - oldsz;
-   save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 
-		      save->vertex_size);
-   save->vert_count = 0;
-
-   /* Recalculate all the attrptr[] values:
-    */
-   for (i = 0, tmp = save->vertex ; i < VBO_ATTRIB_MAX ; i++) {
-      if (save->attrsz[i]) {
-	 save->attrptr[i] = tmp;
-	 tmp += save->attrsz[i];
-      }
-      else 
-	 save->attrptr[i] = NULL; /* will not be dereferenced. */
-   }
-
-   /* Copy from current to repopulate the vertex with correct values.
-    */
-   _save_copy_from_current( ctx );
-
-   /* Replay stored vertices to translate them to new format here.
-    *
-    * If there are copied vertices and the new (upgraded) attribute
-    * has not been defined before, this list is somewhat degenerate,
-    * and will need fixup at runtime.
-    */
-   if (save->copied.nr)
-   {
-      GLfloat *data = save->copied.buffer;
-      GLfloat *dest = save->buffer;
-      GLuint j;
-
-      /* Need to note this and fix up at runtime (or loopback):
-       */
-      if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {
-	 assert(oldsz == 0);
-	 save->dangling_attr_ref = GL_TRUE;
-      }
-
-      for (i = 0 ; i < save->copied.nr ; i++) {
-	 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {
-	    if (save->attrsz[j]) {
-	       if (j == attr) {
-		  if (oldsz) {
-		     COPY_CLEAN_4V( dest, oldsz, data );
-		     data += oldsz;
-		     dest += newsz;
-		  }
-		  else {
-		     COPY_SZ_4V( dest, newsz, save->current[attr] );
-		     dest += newsz;
-		  }
-	       }
-	       else {
-		  GLint sz = save->attrsz[j];
-		  COPY_SZ_4V( dest, sz, data );
-		  data += sz;
-		  dest += sz;
-	       }
-	    }
-	 }
-      }
-
-      save->buffer_ptr = dest;
-      save->vert_count += save->copied.nr;
-   }
-}
-
-static void save_fixup_vertex( struct gl_context *ctx, GLuint attr, GLuint sz )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
-
-   if (sz > save->attrsz[attr]) {
-      /* New size is larger.  Need to flush existing vertices and get
-       * an enlarged vertex format.
-       */
-      _save_upgrade_vertex( ctx, attr, sz );
-   }
-   else if (sz < save->active_sz[attr]) {
-      static GLfloat id[4] = { 0, 0, 0, 1 };
-      GLuint i;
-
-      /* New size is equal or smaller - just need to fill in some
-       * zeros.
-       */
-      for (i = sz ; i <= save->attrsz[attr] ; i++)
-	 save->attrptr[attr][i-1] = id[i-1];
-   }
-
-   save->active_sz[attr] = sz;
-}
-
-static void _save_reset_vertex( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLuint i;
-
-   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
-      save->attrsz[i] = 0;
-      save->active_sz[i] = 0;
-   }
-      
-   save->vertex_size = 0;
-}
-
-
-
-#define ERROR(err)   _mesa_compile_error( ctx, err, __FUNCTION__ );
-
-
-/* Only one size for each attribute may be active at once.  Eg. if
- * Color3f is installed/active, then Color4f may not be, even if the
- * vertex actually contains 4 color coordinates.  This is because the
- * 3f version won't otherwise set color[3] to 1.0 -- this is the job
- * of the chooser function when switching between Color4f and Color3f.
- */
-#define ATTR( A, N, V0, V1, V2, V3 )				\
-do {								\
-   struct vbo_save_context *save = &vbo_context(ctx)->save;	\
-								\
-   if (save->active_sz[A] != N)					\
-      save_fixup_vertex(ctx, A, N);				\
-								\
-   {								\
-      GLfloat *dest = save->attrptr[A];				\
-      if (N>0) dest[0] = V0;					\
-      if (N>1) dest[1] = V1;					\
-      if (N>2) dest[2] = V2;					\
-      if (N>3) dest[3] = V3;					\
-   }								\
-								\
-   if ((A) == 0) {						\
-      GLuint i;							\
-								\
-      for (i = 0; i < save->vertex_size; i++)			\
-	 save->buffer_ptr[i] = save->vertex[i];			\
-								\
-      save->buffer_ptr += save->vertex_size;			\
-								\
-      if (++save->vert_count >= save->max_vert)			\
-	 _save_wrap_filled_vertex( ctx );			\
-   }								\
-} while (0)
-
-#define TAG(x) _save_##x
-
-#include "vbo_attrib_tmp.h"
-
-
-
-
-/* Cope with EvalCoord/CallList called within a begin/end object:
- *     -- Flush current buffer
- *     -- Fallback to opcodes for the rest of the begin/end object.
- */
-static void DO_FALLBACK( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   if (save->vert_count || save->prim_count) {
-      GLint i = save->prim_count - 1;
-
-      /* Close off in-progress primitive.
-       */
-      save->prim[i].count = (save->vert_count - 
-                             save->prim[i].start);
-
-      /* Need to replay this display list with loopback,
-       * unfortunately, otherwise this primitive won't be handled
-       * properly:
-       */
-      save->dangling_attr_ref = 1;
-      
-      _save_compile_vertex_list( ctx );
-   }
-
-   _save_copy_to_current( ctx );
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-   ctx->Driver.SaveNeedFlush = 0;
-}
-
-static void GLAPIENTRY _save_EvalCoord1f( GLfloat u )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalCoord1f(ctx->Save, (u));
-}
-
-static void GLAPIENTRY _save_EvalCoord1fv( const GLfloat *v )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalCoord1fv(ctx->Save, (v));
-}
-
-static void GLAPIENTRY _save_EvalCoord2f( GLfloat u, GLfloat v )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalCoord2f(ctx->Save, (u, v));
-}
-
-static void GLAPIENTRY _save_EvalCoord2fv( const GLfloat *v )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalCoord2fv(ctx->Save, (v));
-}
-
-static void GLAPIENTRY _save_EvalPoint1( GLint i )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalPoint1(ctx->Save, (i));
-}
-
-static void GLAPIENTRY _save_EvalPoint2( GLint i, GLint j )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_EvalPoint2(ctx->Save, (i, j));
-}
-
-static void GLAPIENTRY _save_CallList( GLuint l )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_CallList(ctx->Save, (l));
-}
-
-static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   DO_FALLBACK(ctx);
-   CALL_CallLists(ctx->Save, (n, type, v));
-}
-
-
-
-
-/* This begin is hooked into ...  Updating of
- * ctx->Driver.CurrentSavePrimitive is already taken care of.
- */
-GLboolean vbo_save_NotifyBegin( struct gl_context *ctx, GLenum mode )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
-
-   GLuint i = save->prim_count++;
-
-   assert(i < save->prim_max);
-   save->prim[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;
-   save->prim[i].begin = 1;
-   save->prim[i].end = 0;
-   save->prim[i].weak = (mode & VBO_SAVE_PRIM_WEAK) ? 1 : 0;
-   save->prim[i].no_current_update = (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;
-   save->prim[i].pad = 0;
-   save->prim[i].start = save->vert_count;
-   save->prim[i].count = 0;   
-   save->prim[i].num_instances = 1;   
-
-   _mesa_install_save_vtxfmt( ctx, &save->vtxfmt );      
-   ctx->Driver.SaveNeedFlush = 1;
-   return GL_TRUE;
-}
-
-
-
-static void GLAPIENTRY _save_End( void )
-{
-   GET_CURRENT_CONTEXT( ctx ); 
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
-   GLint i = save->prim_count - 1;
-
-   ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
-   save->prim[i].end = 1;
-   save->prim[i].count = (save->vert_count - 
-			  save->prim[i].start);
-
-   if (i == (GLint) save->prim_max - 1) {
-      _save_compile_vertex_list( ctx );
-      assert(save->copied.nr == 0);
-   }
-
-   /* Swap out this vertex format while outside begin/end.  Any color,
-    * etc. received between here and the next begin will be compiled
-    * as opcodes.
-    */   
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-}
-
-
-/* These are all errors as this vtxfmt is only installed inside
- * begin/end pairs.
- */
-static void GLAPIENTRY _save_DrawElements(GLenum mode, GLsizei count, GLenum type,
-			       const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) count; (void) type; (void) indices;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
-}
-
-
-static void GLAPIENTRY _save_DrawRangeElements(GLenum mode,
-				    GLuint start, GLuint end,
-				    GLsizei count, GLenum type,
-				    const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) end; (void) count; (void) type; (void) indices;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
-}
-
-static void GLAPIENTRY _save_DrawElementsBaseVertex(GLenum mode,
-						    GLsizei count,
-						    GLenum type,
-						    const GLvoid *indices,
-						    GLint basevertex)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) count; (void) type; (void) indices; (void)basevertex;
-
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
-}
-
-static void GLAPIENTRY _save_DrawRangeElementsBaseVertex(GLenum mode,
-							 GLuint start,
-							 GLuint end,
-							 GLsizei count,
-							 GLenum type,
-							 const GLvoid *indices,
-							 GLint basevertex)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) end; (void) count; (void) type;
-   (void) indices; (void)basevertex;
-
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
-}
-
-static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) count;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" );
-}
-
-static void GLAPIENTRY _save_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) x1; (void) y1; (void) x2; (void) y2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glRectf" );
-}
-
-static void GLAPIENTRY _save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) i1; (void) i2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
-}
-
-static void GLAPIENTRY _save_EvalMesh2( GLenum mode, GLint i1, GLint i2,
-				  GLint j1, GLint j2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) i1; (void) i2; (void) j1; (void) j2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
-}
-
-static void GLAPIENTRY _save_Begin( GLenum mode )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   (void) mode;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "Recursive glBegin" );
-}
-
-
-static void GLAPIENTRY _save_PrimitiveRestartNV( void )
-{
-   GLenum curPrim;
-   GET_CURRENT_CONTEXT( ctx ); 
-
-   curPrim = ctx->Driver.CurrentSavePrimitive;
-
-   _save_End();
-   _save_Begin(curPrim);
-}
-
-
-/* Unlike the functions above, these are to be hooked into the vtxfmt
- * maintained in ctx->ListState, active when the list is known or
- * suspected to be outside any begin/end primitive.
- */
-static void GLAPIENTRY _save_OBE_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   vbo_save_NotifyBegin( ctx, GL_QUADS | VBO_SAVE_PRIM_WEAK );
-   CALL_Vertex2f(GET_DISPATCH(), ( x1, y1 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x2, y1 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x2, y2 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x1, y2 ));
-   CALL_End(GET_DISPATCH(), ());
-}
-
-
-static void GLAPIENTRY _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-
-   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
-      return;
-
-   _ae_map_vbos( ctx );
-
-   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE);
-
-   for (i = 0; i < count; i++)
-       CALL_ArrayElement(GET_DISPATCH(), (start + i));
-   CALL_End(GET_DISPATCH(), ());
-
-   _ae_unmap_vbos( ctx );
-}
-
-/* Could do better by copying the arrays and element list intact and
- * then emitting an indexed prim at runtime.
- */
-static void GLAPIENTRY _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
-				   const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
-      return;
-
-   _ae_map_vbos( ctx );
-
-   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj))
-      indices = ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Pointer, indices);
-
-   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE );
-
-   switch (type) {
-   case GL_UNSIGNED_BYTE:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
-      break;
-   case GL_UNSIGNED_SHORT:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
-      break;
-   case GL_UNSIGNED_INT:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
-      break;
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
-      break;
-   }
-
-   CALL_End(GET_DISPATCH(), ());
-
-   _ae_unmap_vbos( ctx );
-}
-
-static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode,
-					GLuint start, GLuint end,
-					GLsizei count, GLenum type,
-					const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (_mesa_validate_DrawRangeElements( ctx, mode,
-					 start, end,
-					 count, type, indices, 0 ))
-      _save_OBE_DrawElements( mode, count, type, indices );
-}
-
-
-
-
-
-static void _save_vtxfmt_init( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLvertexformat *vfmt = &save->vtxfmt;
-
-   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
-
-   vfmt->Begin = _save_Begin;
-   vfmt->Color3f = _save_Color3f;
-   vfmt->Color3fv = _save_Color3fv;
-   vfmt->Color4f = _save_Color4f;
-   vfmt->Color4fv = _save_Color4fv;
-   vfmt->EdgeFlag = _save_EdgeFlag;
-   vfmt->End = _save_End;
-   vfmt->PrimitiveRestartNV = _save_PrimitiveRestartNV;
-   vfmt->FogCoordfEXT = _save_FogCoordfEXT;
-   vfmt->FogCoordfvEXT = _save_FogCoordfvEXT;
-   vfmt->Indexf = _save_Indexf;
-   vfmt->Indexfv = _save_Indexfv;
-   vfmt->Materialfv = _save_Materialfv;
-   vfmt->MultiTexCoord1fARB = _save_MultiTexCoord1f;
-   vfmt->MultiTexCoord1fvARB = _save_MultiTexCoord1fv;
-   vfmt->MultiTexCoord2fARB = _save_MultiTexCoord2f;
-   vfmt->MultiTexCoord2fvARB = _save_MultiTexCoord2fv;
-   vfmt->MultiTexCoord3fARB = _save_MultiTexCoord3f;
-   vfmt->MultiTexCoord3fvARB = _save_MultiTexCoord3fv;
-   vfmt->MultiTexCoord4fARB = _save_MultiTexCoord4f;
-   vfmt->MultiTexCoord4fvARB = _save_MultiTexCoord4fv;
-   vfmt->Normal3f = _save_Normal3f;
-   vfmt->Normal3fv = _save_Normal3fv;
-   vfmt->SecondaryColor3fEXT = _save_SecondaryColor3fEXT;
-   vfmt->SecondaryColor3fvEXT = _save_SecondaryColor3fvEXT;
-   vfmt->TexCoord1f = _save_TexCoord1f;
-   vfmt->TexCoord1fv = _save_TexCoord1fv;
-   vfmt->TexCoord2f = _save_TexCoord2f;
-   vfmt->TexCoord2fv = _save_TexCoord2fv;
-   vfmt->TexCoord3f = _save_TexCoord3f;
-   vfmt->TexCoord3fv = _save_TexCoord3fv;
-   vfmt->TexCoord4f = _save_TexCoord4f;
-   vfmt->TexCoord4fv = _save_TexCoord4fv;
-   vfmt->Vertex2f = _save_Vertex2f;
-   vfmt->Vertex2fv = _save_Vertex2fv;
-   vfmt->Vertex3f = _save_Vertex3f;
-   vfmt->Vertex3fv = _save_Vertex3fv;
-   vfmt->Vertex4f = _save_Vertex4f;
-   vfmt->Vertex4fv = _save_Vertex4fv;
-   vfmt->VertexAttrib1fARB = _save_VertexAttrib1fARB;
-   vfmt->VertexAttrib1fvARB = _save_VertexAttrib1fvARB;
-   vfmt->VertexAttrib2fARB = _save_VertexAttrib2fARB;
-   vfmt->VertexAttrib2fvARB = _save_VertexAttrib2fvARB;
-   vfmt->VertexAttrib3fARB = _save_VertexAttrib3fARB;
-   vfmt->VertexAttrib3fvARB = _save_VertexAttrib3fvARB;
-   vfmt->VertexAttrib4fARB = _save_VertexAttrib4fARB;
-   vfmt->VertexAttrib4fvARB = _save_VertexAttrib4fvARB;
-
-   vfmt->VertexAttrib1fNV = _save_VertexAttrib1fNV;
-   vfmt->VertexAttrib1fvNV = _save_VertexAttrib1fvNV;
-   vfmt->VertexAttrib2fNV = _save_VertexAttrib2fNV;
-   vfmt->VertexAttrib2fvNV = _save_VertexAttrib2fvNV;
-   vfmt->VertexAttrib3fNV = _save_VertexAttrib3fNV;
-   vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV;
-   vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV;
-   vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV;
-   
-   /* integer-valued */
-   vfmt->VertexAttribI1i = _save_VertexAttribI1i;
-   vfmt->VertexAttribI2i = _save_VertexAttribI2i;
-   vfmt->VertexAttribI3i = _save_VertexAttribI3i;
-   vfmt->VertexAttribI4i = _save_VertexAttribI4i;
-   vfmt->VertexAttribI2iv = _save_VertexAttribI2iv;
-   vfmt->VertexAttribI3iv = _save_VertexAttribI3iv;
-   vfmt->VertexAttribI4iv = _save_VertexAttribI4iv;
-
-   /* unsigned integer-valued */
-   vfmt->VertexAttribI1ui = _save_VertexAttribI1ui;
-   vfmt->VertexAttribI2ui = _save_VertexAttribI2ui;
-   vfmt->VertexAttribI3ui = _save_VertexAttribI3ui;
-   vfmt->VertexAttribI4ui = _save_VertexAttribI4ui;
-   vfmt->VertexAttribI2uiv = _save_VertexAttribI2uiv;
-   vfmt->VertexAttribI3uiv = _save_VertexAttribI3uiv;
-   vfmt->VertexAttribI4uiv = _save_VertexAttribI4uiv;
-
-   /* This will all require us to fallback to saving the list as opcodes:
-    */ 
-   _MESA_INIT_DLIST_VTXFMT(vfmt, _save_); /* inside begin/end */
-
-   _MESA_INIT_EVAL_VTXFMT(vfmt, _save_);
-
-   /* These are all errors as we at least know we are in some sort of
-    * begin/end pair:
-    */
-   vfmt->Begin = _save_Begin;
-   vfmt->Rectf = _save_Rectf;
-   vfmt->DrawArrays = _save_DrawArrays;
-   vfmt->DrawElements = _save_DrawElements;
-   vfmt->DrawRangeElements = _save_DrawRangeElements;
-   vfmt->DrawElementsBaseVertex = _save_DrawElementsBaseVertex;
-   vfmt->DrawRangeElementsBaseVertex = _save_DrawRangeElementsBaseVertex;
-   /* Loops back into vfmt->DrawElements */
-   vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
-   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
-}
-
-
-void vbo_save_SaveFlushVertices( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   /* Noop when we are actually active:
-    */
-   if (ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM ||
-       ctx->Driver.CurrentSavePrimitive <= GL_POLYGON)
-      return;
-
-   if (save->vert_count ||
-       save->prim_count) 
-      _save_compile_vertex_list( ctx );
-   
-   _save_copy_to_current( ctx );
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );  
-   ctx->Driver.SaveNeedFlush = 0;
-}
-
-void vbo_save_NewList( struct gl_context *ctx, GLuint list, GLenum mode )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   (void) list; (void) mode;
-
-   if (!save->prim_store)
-      save->prim_store = alloc_prim_store( ctx );
-
-   if (!save->vertex_store) 
-      save->vertex_store = alloc_vertex_store( ctx );
-      
-   save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );
-   
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );  
-   ctx->Driver.SaveNeedFlush = 0;
-}
-
-void vbo_save_EndList( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   /* EndList called inside a (saved) Begin/End pair?
-    */
-   if (ctx->Driver.CurrentSavePrimitive != PRIM_OUTSIDE_BEGIN_END) {
-
-      if (save->prim_count > 0) {
-         GLint i = save->prim_count - 1;
-         ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
-         save->prim[i].end = 0;
-         save->prim[i].count = (save->vert_count - 
-                                save->prim[i].start);
-      }
-
-      /* Make sure this vertex list gets replayed by the "loopback"
-       * mechanism:
-       */
-      save->dangling_attr_ref = 1;
-      vbo_save_SaveFlushVertices( ctx );
-
-      /* Swap out this vertex format while outside begin/end.  Any color,
-       * etc. received between here and the next begin will be compiled
-       * as opcodes.
-       */   
-      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-   }
-
-   unmap_vertex_store( ctx, save->vertex_store );
-
-   assert(save->vertex_size == 0);
-}
- 
-void vbo_save_BeginCallList( struct gl_context *ctx, struct gl_display_list *dlist )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   save->replay_flags |= dlist->Flags;
-}
-
-void vbo_save_EndCallList( struct gl_context *ctx )
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   
-   if (ctx->ListState.CallDepth == 1) {
-      /* This is correct: want to keep only the VBO_SAVE_FALLBACK
-       * flag, if it is set:
-       */
-      save->replay_flags &= VBO_SAVE_FALLBACK;
-   }
-}
-
-
-static void vbo_destroy_vertex_list( struct gl_context *ctx, void *data )
-{
-   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;
-   (void) ctx;
-
-   if ( --node->vertex_store->refcount == 0 ) 
-      free_vertex_store( ctx, node->vertex_store );
-
-   if ( --node->prim_store->refcount == 0 )
-      FREE( node->prim_store );
-
-   if (node->current_data) {
-      FREE(node->current_data);
-      node->current_data = NULL;
-   }
-}
-
-
-static void vbo_print_vertex_list( struct gl_context *ctx, void *data )
-{
-   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;
-   GLuint i;
-   (void) ctx;
-
-   printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
-	  node->count,
-	  node->prim_count,
-	  node->vertex_size);
-
-   for (i = 0 ; i < node->prim_count ; i++) {
-      struct _mesa_prim *prim = &node->prim[i];
-      _mesa_debug(NULL, "   prim %d: %s%s %d..%d %s %s\n",
-		  i, 
-		  _mesa_lookup_prim_by_nr(prim->mode),
-		  prim->weak ? " (weak)" : "",
-		  prim->start, 
-		  prim->start + prim->count,
-		  (prim->begin) ? "BEGIN" : "(wrap)",
-		  (prim->end) ? "END" : "(wrap)");
-   }
-}
-
-
-static void _save_current_init( struct gl_context *ctx ) 
-{
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-   GLint i;
-
-   for (i = VBO_ATTRIB_POS; i <= VBO_ATTRIB_GENERIC15; i++) {
-      const GLuint j = i - VBO_ATTRIB_POS;
-      ASSERT(j < VERT_ATTRIB_MAX);
-      save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];
-      save->current[i] = ctx->ListState.CurrentAttrib[j];
-   }
-
-   for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {
-      const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;
-      ASSERT(j < MAT_ATTRIB_MAX);
-      save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];
-      save->current[i] = ctx->ListState.CurrentMaterial[j];
-   }
-}
-
-/**
- * Initialize the display list compiler
- */
-void vbo_save_api_init( struct vbo_save_context *save )
-{
-   struct gl_context *ctx = save->ctx;
-   GLuint i;
-
-   save->opcode_vertex_list =
-      _mesa_dlist_alloc_opcode( ctx,
-                                sizeof(struct vbo_save_vertex_list),
-                                vbo_save_playback_vertex_list,
-                                vbo_destroy_vertex_list,
-                                vbo_print_vertex_list );
-
-   ctx->Driver.NotifySaveBegin = vbo_save_NotifyBegin;
-
-   _save_vtxfmt_init( ctx );
-   _save_current_init( ctx );
-
-   /* These will actually get set again when binding/drawing */
-   for (i = 0; i < VBO_ATTRIB_MAX; i++)
-      save->inputs[i] = &save->arrays[i];
-
-   /* Hook our array functions into the outside-begin-end vtxfmt in 
-    * ctx->ListState.
-    */
-   ctx->ListState.ListVtxfmt.Rectf = _save_OBE_Rectf;
-   ctx->ListState.ListVtxfmt.DrawArrays = _save_OBE_DrawArrays;
-   ctx->ListState.ListVtxfmt.DrawElements = _save_OBE_DrawElements;
-   ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;
-   /* loops back into _save_OBE_DrawElements */
-   ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
-   ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-}
-
-
-#endif /* FEATURE_dlist */
+/**************************************************************************

+

+Copyright 2002-2008 Tungsten Graphics 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

+on 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

+TUNGSTEN GRAPHICS 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:

+ *   Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+

+

+/* Display list compiler attempts to store lists of vertices with the

+ * same vertex layout.  Additionally it attempts to minimize the need

+ * for execute-time fixup of these vertex lists, allowing them to be

+ * cached on hardware.

+ *

+ * There are still some circumstances where this can be thwarted, for

+ * example by building a list that consists of one very long primitive

+ * (eg Begin(Triangles), 1000 vertices, End), and calling that list

+ * from inside a different begin/end object (Begin(Lines), CallList,

+ * End).  

+ *

+ * In that case the code will have to replay the list as individual

+ * commands through the Exec dispatch table, or fix up the copied

+ * vertices at execute-time.

+ *

+ * The other case where fixup is required is when a vertex attribute

+ * is introduced in the middle of a primitive.  Eg:

+ *  Begin(Lines)

+ *  TexCoord1f()           Vertex2f()

+ *  TexCoord1f() Color3f() Vertex2f()

+ *  End()

+ *

+ *  If the current value of Color isn't known at compile-time, this

+ *  primitive will require fixup.

+ *

+ *

+ * The list compiler currently doesn't attempt to compile lists

+ * containing EvalCoord or EvalPoint commands.  On encountering one of

+ * these, compilation falls back to opcodes.  

+ *

+ * This could be improved to fallback only when a mix of EvalCoord and

+ * Vertex commands are issued within a single primitive.

+ */

+

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/context.h"

+#include "main/dlist.h"

+#include "main/enums.h"

+#include "main/eval.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/api_noop.h"

+#include "main/api_validate.h"

+#include "main/api_arrayelt.h"

+#include "main/vtxfmt.h"

+#include "main/dispatch.h"

+

+#include "vbo_context.h"

+

+

+#if FEATURE_dlist

+

+

+#ifdef ERROR

+#undef ERROR

+#endif

+

+

+/* An interesting VBO number/name to help with debugging */

+#define VBO_BUF_ID  12345

+

+

+/*

+ * NOTE: Old 'parity' issue is gone, but copying can still be

+ * wrong-footed on replay.

+ */

+static GLuint _save_copy_vertices( struct gl_context *ctx, 

+				   const struct vbo_save_vertex_list *node,

+				   const GLfloat *src_buffer)

+{

+   struct vbo_save_context *save = &vbo_context( ctx )->save;

+   const struct _mesa_prim *prim = &node->prim[node->prim_count-1];

+   GLuint nr = prim->count;

+   GLuint sz = save->vertex_size;

+   const GLfloat *src = src_buffer + prim->start * sz;

+   GLfloat *dst = save->copied.buffer;

+   GLuint ovf, i;

+

+   if (prim->end)

+      return 0;

+	 

+   switch( prim->mode )

+   {

+   case GL_POINTS:

+      return 0;

+   case GL_LINES:

+      ovf = nr&1;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );

+      return i;

+   case GL_TRIANGLES:

+      ovf = nr%3;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );

+      return i;

+   case GL_QUADS:

+      ovf = nr&3;

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );

+      return i;

+   case GL_LINE_STRIP:

+      if (nr == 0) 

+	 return 0;

+      else {

+	 memcpy( dst, src+(nr-1)*sz, sz*sizeof(GLfloat) );

+	 return 1;

+      }

+   case GL_LINE_LOOP:

+   case GL_TRIANGLE_FAN:

+   case GL_POLYGON:

+      if (nr == 0) 

+	 return 0;

+      else if (nr == 1) {

+	 memcpy( dst, src+0, sz*sizeof(GLfloat) );

+	 return 1;

+      } else {

+	 memcpy( dst, src+0, sz*sizeof(GLfloat) );

+	 memcpy( dst+sz, src+(nr-1)*sz, sz*sizeof(GLfloat) );

+	 return 2;

+      }

+   case GL_TRIANGLE_STRIP:

+   case GL_QUAD_STRIP:

+      switch (nr) {

+      case 0: ovf = 0; break;

+      case 1: ovf = 1; break;

+      default: ovf = 2 + (nr&1); break;

+      }

+      for (i = 0 ; i < ovf ; i++)

+	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );

+      return i;

+   default:

+      assert(0);

+      return 0;

+   }

+}

+

+

+static struct vbo_save_vertex_store *alloc_vertex_store( struct gl_context *ctx )

+{

+   struct vbo_save_vertex_store *vertex_store = CALLOC_STRUCT(vbo_save_vertex_store);

+

+   /* obj->Name needs to be non-zero, but won't ever be examined more

+    * closely than that.  In particular these buffers won't be entered

+    * into the hash and can never be confused with ones visible to the

+    * user.  Perhaps there could be a special number for internal

+    * buffers:

+    */

+   vertex_store->bufferobj = ctx->Driver.NewBufferObject(ctx,

+                                                         VBO_BUF_ID,

+                                                         GL_ARRAY_BUFFER_ARB);

+

+   ctx->Driver.BufferData( ctx, 

+			   GL_ARRAY_BUFFER_ARB, 

+			   VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),

+			   NULL,

+			   GL_STATIC_DRAW_ARB,

+			   vertex_store->bufferobj);

+

+   vertex_store->buffer = NULL;

+   vertex_store->used = 0;

+   vertex_store->refcount = 1;

+

+   return vertex_store;

+}

+

+static void free_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )

+{

+   assert(!vertex_store->buffer);

+

+   if (vertex_store->bufferobj) {

+      _mesa_reference_buffer_object(ctx, &vertex_store->bufferobj, NULL);

+   }

+

+   FREE( vertex_store );

+}

+

+static GLfloat *map_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )

+{

+   assert(vertex_store->bufferobj);

+   assert(!vertex_store->buffer);

+   vertex_store->buffer = (GLfloat *)ctx->Driver.MapBuffer(ctx, 

+							   GL_ARRAY_BUFFER_ARB,	/* not used */

+							   GL_WRITE_ONLY, /* not used */

+							   vertex_store->bufferobj); 

+

+   assert(vertex_store->buffer);

+   return vertex_store->buffer + vertex_store->used;

+}

+

+static void unmap_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )

+{

+   ctx->Driver.UnmapBuffer( ctx, GL_ARRAY_BUFFER_ARB, vertex_store->bufferobj );

+   vertex_store->buffer = NULL;

+}

+

+

+static struct vbo_save_primitive_store *alloc_prim_store( struct gl_context *ctx )

+{

+   struct vbo_save_primitive_store *store = CALLOC_STRUCT(vbo_save_primitive_store);

+   (void) ctx;

+   store->used = 0;

+   store->refcount = 1;

+   return store;

+}

+

+static void _save_reset_counters( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   save->prim = save->prim_store->buffer + save->prim_store->used;

+   save->buffer = (save->vertex_store->buffer + 

+		   save->vertex_store->used);

+

+   assert(save->buffer == save->buffer_ptr);

+

+   if (save->vertex_size)

+      save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 

+			 save->vertex_size);

+   else

+      save->max_vert = 0;

+

+   save->vert_count = 0;

+   save->prim_count = 0;

+   save->prim_max = VBO_SAVE_PRIM_SIZE - save->prim_store->used;

+   save->dangling_attr_ref = 0;

+}

+

+

+/* Insert the active immediate struct onto the display list currently

+ * being built.

+ */

+static void _save_compile_vertex_list( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   struct vbo_save_vertex_list *node;

+

+   /* Allocate space for this structure in the display list currently

+    * being compiled.

+    */

+   node = (struct vbo_save_vertex_list *)

+      _mesa_dlist_alloc(ctx, save->opcode_vertex_list, sizeof(*node));

+

+   if (!node)

+      return;

+

+   /* Duplicate our template, increment refcounts to the storage structs:

+    */

+   memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));

+   node->vertex_size = save->vertex_size;

+   node->buffer_offset = (save->buffer - save->vertex_store->buffer) * sizeof(GLfloat); 

+   node->count = save->vert_count;

+   node->wrap_count = save->copied.nr;

+   node->dangling_attr_ref = save->dangling_attr_ref;

+   node->prim = save->prim;

+   node->prim_count = save->prim_count;

+   node->vertex_store = save->vertex_store;

+   node->prim_store = save->prim_store;

+

+   node->vertex_store->refcount++;

+   node->prim_store->refcount++;

+

+   if (node->prim[0].no_current_update) {

+      node->current_size = 0;

+      node->current_data = NULL;

+   } else {

+      node->current_size = node->vertex_size - node->attrsz[0];

+      node->current_data = NULL;

+     

+      if (node->current_size) {

+         /* If the malloc fails, we just pull the data out of the VBO

+          * later instead.

+          */

+         node->current_data = MALLOC( node->current_size * sizeof(GLfloat) );

+         if (node->current_data) {

+            const char *buffer = (const char *)save->vertex_store->buffer;

+            unsigned attr_offset = node->attrsz[0] * sizeof(GLfloat);

+            unsigned vertex_offset = 0;

+            

+            if (node->count)

+               vertex_offset = (node->count-1) * node->vertex_size * sizeof(GLfloat);

+         

+            memcpy( node->current_data,

+                    buffer + node->buffer_offset + vertex_offset + attr_offset,

+                    node->current_size * sizeof(GLfloat) );

+         }

+      }

+   }

+

+

+

+   assert(node->attrsz[VBO_ATTRIB_POS] != 0 ||

+	  node->count == 0);

+

+   if (save->dangling_attr_ref)

+      ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;

+

+   save->vertex_store->used += save->vertex_size * node->count;

+   save->prim_store->used += node->prim_count;

+

+

+   /* Copy duplicated vertices 

+    */

+   save->copied.nr = _save_copy_vertices( ctx, node, save->buffer );

+

+

+   /* Deal with GL_COMPILE_AND_EXECUTE:

+    */

+   if (ctx->ExecuteFlag) {

+      struct _glapi_table *dispatch = GET_DISPATCH();

+

+      _glapi_set_dispatch(ctx->Exec);

+

+      vbo_loopback_vertex_list( ctx,

+				(const GLfloat *)((const char *)save->vertex_store->buffer + 

+						  node->buffer_offset),

+				node->attrsz,

+				node->prim,

+				node->prim_count,

+				node->wrap_count,

+				node->vertex_size);

+

+      _glapi_set_dispatch(dispatch);

+   }

+

+

+   /* Decide whether the storage structs are full, or can be used for

+    * the next vertex lists as well.

+    */

+   if (save->vertex_store->used > 

+       VBO_SAVE_BUFFER_SIZE - 16 * (save->vertex_size + 4)) {

+

+      /* Unmap old store:

+       */

+      unmap_vertex_store( ctx, save->vertex_store );

+

+      /* Release old reference:

+       */

+      save->vertex_store->refcount--; 

+      assert(save->vertex_store->refcount != 0);

+      save->vertex_store = NULL;

+

+      /* Allocate and map new store:

+       */

+      save->vertex_store = alloc_vertex_store( ctx );

+      save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );

+   } 

+

+   if (save->prim_store->used > VBO_SAVE_PRIM_SIZE - 6) {

+      save->prim_store->refcount--; 

+      assert(save->prim_store->refcount != 0);

+      save->prim_store = alloc_prim_store( ctx );

+   } 

+

+   /* Reset our structures for the next run of vertices:

+    */

+   _save_reset_counters( ctx );

+}

+

+

+/* TODO -- If no new vertices have been stored, don't bother saving

+ * it.

+ */

+static void _save_wrap_buffers( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLint i = save->prim_count - 1;

+   GLenum mode;

+   GLboolean weak;

+   GLboolean no_current_update;

+

+   assert(i < (GLint) save->prim_max);

+   assert(i >= 0);

+

+   /* Close off in-progress primitive.

+    */

+   save->prim[i].count = (save->vert_count - 

+			  save->prim[i].start);

+   mode = save->prim[i].mode;

+   weak = save->prim[i].weak;

+   no_current_update = save->prim[i].no_current_update;

+   

+   /* store the copied vertices, and allocate a new list.

+    */

+   _save_compile_vertex_list( ctx );

+

+   /* Restart interrupted primitive

+    */

+   save->prim[0].mode = mode;

+   save->prim[0].weak = weak;

+   save->prim[0].no_current_update = no_current_update;

+   save->prim[0].begin = 0;

+   save->prim[0].end = 0;

+   save->prim[0].pad = 0;

+   save->prim[0].start = 0;

+   save->prim[0].count = 0;

+   save->prim[0].num_instances = 1;

+   save->prim_count = 1;

+}

+

+

+

+/* Called only when buffers are wrapped as the result of filling the

+ * vertex_store struct.  

+ */

+static void _save_wrap_filled_vertex( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLfloat *data = save->copied.buffer;

+   GLuint i;

+

+   /* Emit a glEnd to close off the last vertex list.

+    */

+   _save_wrap_buffers( ctx );

+   

+    /* Copy stored stored vertices to start of new list.

+    */

+   assert(save->max_vert - save->vert_count > save->copied.nr);

+

+   for (i = 0 ; i < save->copied.nr ; i++) {

+      memcpy( save->buffer_ptr, data, save->vertex_size * sizeof(GLfloat));

+      data += save->vertex_size;

+      save->buffer_ptr += save->vertex_size;

+      save->vert_count++;

+   }

+}

+

+

+static void _save_copy_to_current( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save; 

+   GLuint i;

+

+   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {

+      if (save->attrsz[i]) {

+	 save->currentsz[i][0] = save->attrsz[i];

+	 COPY_CLEAN_4V(save->current[i], 

+		       save->attrsz[i], 

+		       save->attrptr[i]);

+      }

+   }

+}

+

+

+static void _save_copy_from_current( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save; 

+   GLint i;

+

+   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {

+      switch (save->attrsz[i]) {

+      case 4: save->attrptr[i][3] = save->current[i][3];

+      case 3: save->attrptr[i][2] = save->current[i][2];

+      case 2: save->attrptr[i][1] = save->current[i][1];

+      case 1: save->attrptr[i][0] = save->current[i][0];

+      case 0: break;

+      }

+   }

+}

+

+

+

+

+/* Flush existing data, set new attrib size, replay copied vertices.

+ */ 

+static void _save_upgrade_vertex( struct gl_context *ctx, 

+				 GLuint attr,

+				 GLuint newsz )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLuint oldsz;

+   GLuint i;

+   GLfloat *tmp;

+

+   /* Store the current run of vertices, and emit a GL_END.  Emit a

+    * BEGIN in the new buffer.

+    */

+   if (save->vert_count) 

+      _save_wrap_buffers( ctx );

+   else

+      assert( save->copied.nr == 0 );

+

+   /* Do a COPY_TO_CURRENT to ensure back-copying works for the case

+    * when the attribute already exists in the vertex and is having

+    * its size increased.  

+    */

+   _save_copy_to_current( ctx );

+

+   /* Fix up sizes:

+    */

+   oldsz = save->attrsz[attr];

+   save->attrsz[attr] = newsz;

+

+   save->vertex_size += newsz - oldsz;

+   save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 

+		      save->vertex_size);

+   save->vert_count = 0;

+

+   /* Recalculate all the attrptr[] values:

+    */

+   for (i = 0, tmp = save->vertex ; i < VBO_ATTRIB_MAX ; i++) {

+      if (save->attrsz[i]) {

+	 save->attrptr[i] = tmp;

+	 tmp += save->attrsz[i];

+      }

+      else 

+	 save->attrptr[i] = NULL; /* will not be dereferenced. */

+   }

+

+   /* Copy from current to repopulate the vertex with correct values.

+    */

+   _save_copy_from_current( ctx );

+

+   /* Replay stored vertices to translate them to new format here.

+    *

+    * If there are copied vertices and the new (upgraded) attribute

+    * has not been defined before, this list is somewhat degenerate,

+    * and will need fixup at runtime.

+    */

+   if (save->copied.nr)

+   {

+      GLfloat *data = save->copied.buffer;

+      GLfloat *dest = save->buffer;

+      GLuint j;

+

+      /* Need to note this and fix up at runtime (or loopback):

+       */

+      if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {

+	 assert(oldsz == 0);

+	 save->dangling_attr_ref = GL_TRUE;

+      }

+

+      for (i = 0 ; i < save->copied.nr ; i++) {

+	 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {

+	    if (save->attrsz[j]) {

+	       if (j == attr) {

+		  if (oldsz) {

+		     COPY_CLEAN_4V( dest, oldsz, data );

+		     data += oldsz;

+		     dest += newsz;

+		  }

+		  else {

+		     COPY_SZ_4V( dest, newsz, save->current[attr] );

+		     dest += newsz;

+		  }

+	       }

+	       else {

+		  GLint sz = save->attrsz[j];

+		  COPY_SZ_4V( dest, sz, data );

+		  data += sz;

+		  dest += sz;

+	       }

+	    }

+	 }

+      }

+

+      save->buffer_ptr = dest;

+      save->vert_count += save->copied.nr;

+   }

+}

+

+static void save_fixup_vertex( struct gl_context *ctx, GLuint attr, GLuint sz )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save; 

+

+   if (sz > save->attrsz[attr]) {

+      /* New size is larger.  Need to flush existing vertices and get

+       * an enlarged vertex format.

+       */

+      _save_upgrade_vertex( ctx, attr, sz );

+   }

+   else if (sz < save->active_sz[attr]) {

+      static GLfloat id[4] = { 0, 0, 0, 1 };

+      GLuint i;

+

+      /* New size is equal or smaller - just need to fill in some

+       * zeros.

+       */

+      for (i = sz ; i <= save->attrsz[attr] ; i++)

+	 save->attrptr[attr][i-1] = id[i-1];

+   }

+

+   save->active_sz[attr] = sz;

+}

+

+static void _save_reset_vertex( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLuint i;

+

+   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {

+      save->attrsz[i] = 0;

+      save->active_sz[i] = 0;

+   }

+      

+   save->vertex_size = 0;

+}

+

+

+

+#define ERROR(err)   _mesa_compile_error( ctx, err, __FUNCTION__ );

+

+

+/* Only one size for each attribute may be active at once.  Eg. if

+ * Color3f is installed/active, then Color4f may not be, even if the

+ * vertex actually contains 4 color coordinates.  This is because the

+ * 3f version won't otherwise set color[3] to 1.0 -- this is the job

+ * of the chooser function when switching between Color4f and Color3f.

+ */

+#define ATTR( A, N, V0, V1, V2, V3 )				\

+do {								\

+   struct vbo_save_context *save = &vbo_context(ctx)->save;	\

+								\

+   if (save->active_sz[A] != N)					\

+      save_fixup_vertex(ctx, A, N);				\

+								\

+   {								\

+      GLfloat *dest = save->attrptr[A];				\

+      if (N>0) dest[0] = V0;					\

+      if (N>1) dest[1] = V1;					\

+      if (N>2) dest[2] = V2;					\

+      if (N>3) dest[3] = V3;					\

+   }								\

+								\

+   if ((A) == 0) {						\

+      GLuint i;							\

+								\

+      for (i = 0; i < save->vertex_size; i++)			\

+	 save->buffer_ptr[i] = save->vertex[i];			\

+								\

+      save->buffer_ptr += save->vertex_size;			\

+								\

+      if (++save->vert_count >= save->max_vert)			\

+	 _save_wrap_filled_vertex( ctx );			\

+   }								\

+} while (0)

+

+#define TAG(x) _save_##x

+

+#include "vbo_attrib_tmp.h"

+

+

+

+

+/* Cope with EvalCoord/CallList called within a begin/end object:

+ *     -- Flush current buffer

+ *     -- Fallback to opcodes for the rest of the begin/end object.

+ */

+static void DO_FALLBACK( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   if (save->vert_count || save->prim_count) {

+      GLint i = save->prim_count - 1;

+

+      /* Close off in-progress primitive.

+       */

+      save->prim[i].count = (save->vert_count - 

+                             save->prim[i].start);

+

+      /* Need to replay this display list with loopback,

+       * unfortunately, otherwise this primitive won't be handled

+       * properly:

+       */

+      save->dangling_attr_ref = 1;

+      

+      _save_compile_vertex_list( ctx );

+   }

+

+   _save_copy_to_current( ctx );

+   _save_reset_vertex( ctx );

+   _save_reset_counters( ctx );

+   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+   ctx->Driver.SaveNeedFlush = 0;

+}

+

+static void GLAPIENTRY _save_EvalCoord1f( GLfloat u )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalCoord1f(ctx->Save, (u));

+}

+

+static void GLAPIENTRY _save_EvalCoord1fv( const GLfloat *v )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalCoord1fv(ctx->Save, (v));

+}

+

+static void GLAPIENTRY _save_EvalCoord2f( GLfloat u, GLfloat v )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalCoord2f(ctx->Save, (u, v));

+}

+

+static void GLAPIENTRY _save_EvalCoord2fv( const GLfloat *v )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalCoord2fv(ctx->Save, (v));

+}

+

+static void GLAPIENTRY _save_EvalPoint1( GLint i )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalPoint1(ctx->Save, (i));

+}

+

+static void GLAPIENTRY _save_EvalPoint2( GLint i, GLint j )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_EvalPoint2(ctx->Save, (i, j));

+}

+

+static void GLAPIENTRY _save_CallList( GLuint l )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_CallList(ctx->Save, (l));

+}

+

+static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   DO_FALLBACK(ctx);

+   CALL_CallLists(ctx->Save, (n, type, v));

+}

+

+

+

+

+/* This begin is hooked into ...  Updating of

+ * ctx->Driver.CurrentSavePrimitive is already taken care of.

+ */

+GLboolean vbo_save_NotifyBegin( struct gl_context *ctx, GLenum mode )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save; 

+

+   GLuint i = save->prim_count++;

+

+   assert(i < save->prim_max);

+   save->prim[i].mode = mode & VBO_SAVE_PRIM_MODE_MASK;

+   save->prim[i].begin = 1;

+   save->prim[i].end = 0;

+   save->prim[i].weak = (mode & VBO_SAVE_PRIM_WEAK) ? 1 : 0;

+   save->prim[i].no_current_update = (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;

+   save->prim[i].pad = 0;

+   save->prim[i].start = save->vert_count;

+   save->prim[i].count = 0;   

+   save->prim[i].num_instances = 1;   

+

+   _mesa_install_save_vtxfmt( ctx, &save->vtxfmt );      

+   ctx->Driver.SaveNeedFlush = 1;

+   return GL_TRUE;

+}

+

+

+

+static void GLAPIENTRY _save_End( void )

+{

+   GET_CURRENT_CONTEXT( ctx ); 

+   struct vbo_save_context *save = &vbo_context(ctx)->save; 

+   GLint i = save->prim_count - 1;

+

+   ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;

+   save->prim[i].end = 1;

+   save->prim[i].count = (save->vert_count - 

+			  save->prim[i].start);

+

+   if (i == (GLint) save->prim_max - 1) {

+      _save_compile_vertex_list( ctx );

+      assert(save->copied.nr == 0);

+   }

+

+   /* Swap out this vertex format while outside begin/end.  Any color,

+    * etc. received between here and the next begin will be compiled

+    * as opcodes.

+    */   

+   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+}

+

+

+/* These are all errors as this vtxfmt is only installed inside

+ * begin/end pairs.

+ */

+static void GLAPIENTRY _save_DrawElements(GLenum mode, GLsizei count, GLenum type,

+			       const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) count; (void) type; (void) indices;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );

+}

+

+

+static void GLAPIENTRY _save_DrawRangeElements(GLenum mode,

+				    GLuint start, GLuint end,

+				    GLsizei count, GLenum type,

+				    const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) start; (void) end; (void) count; (void) type; (void) indices;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );

+}

+

+static void GLAPIENTRY _save_DrawElementsBaseVertex(GLenum mode,

+						    GLsizei count,

+						    GLenum type,

+						    const GLvoid *indices,

+						    GLint basevertex)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) count; (void) type; (void) indices; (void)basevertex;

+

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );

+}

+

+static void GLAPIENTRY _save_DrawRangeElementsBaseVertex(GLenum mode,

+							 GLuint start,

+							 GLuint end,

+							 GLsizei count,

+							 GLenum type,

+							 const GLvoid *indices,

+							 GLint basevertex)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) start; (void) end; (void) count; (void) type;

+   (void) indices; (void)basevertex;

+

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );

+}

+

+static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) start; (void) count;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" );

+}

+

+static void GLAPIENTRY _save_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) x1; (void) y1; (void) x2; (void) y2;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glRectf" );

+}

+

+static void GLAPIENTRY _save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) i1; (void) i2;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );

+}

+

+static void GLAPIENTRY _save_EvalMesh2( GLenum mode, GLint i1, GLint i2,

+				  GLint j1, GLint j2 )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) mode; (void) i1; (void) i2; (void) j1; (void) j2;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );

+}

+

+static void GLAPIENTRY _save_Begin( GLenum mode )

+{

+   GET_CURRENT_CONTEXT( ctx );

+   (void) mode;

+   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "Recursive glBegin" );

+}

+

+

+static void GLAPIENTRY _save_PrimitiveRestartNV( void )

+{

+   GLenum curPrim;

+   GET_CURRENT_CONTEXT( ctx ); 

+

+   curPrim = ctx->Driver.CurrentSavePrimitive;

+

+   _save_End();

+   _save_Begin(curPrim);

+}

+

+

+/* Unlike the functions above, these are to be hooked into the vtxfmt

+ * maintained in ctx->ListState, active when the list is known or

+ * suspected to be outside any begin/end primitive.

+ */

+static void GLAPIENTRY _save_OBE_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   vbo_save_NotifyBegin( ctx, GL_QUADS | VBO_SAVE_PRIM_WEAK );

+   CALL_Vertex2f(GET_DISPATCH(), ( x1, y1 ));

+   CALL_Vertex2f(GET_DISPATCH(), ( x2, y1 ));

+   CALL_Vertex2f(GET_DISPATCH(), ( x2, y2 ));

+   CALL_Vertex2f(GET_DISPATCH(), ( x1, y2 ));

+   CALL_End(GET_DISPATCH(), ());

+}

+

+

+static void GLAPIENTRY _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+

+   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))

+      return;

+

+   _ae_map_vbos( ctx );

+

+   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE);

+

+   for (i = 0; i < count; i++)

+       CALL_ArrayElement(GET_DISPATCH(), (start + i));

+   CALL_End(GET_DISPATCH(), ());

+

+   _ae_unmap_vbos( ctx );

+}

+

+/* Could do better by copying the arrays and element list intact and

+ * then emitting an indexed prim at runtime.

+ */

+static void GLAPIENTRY _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,

+				   const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint i;

+

+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))

+      return;

+

+   _ae_map_vbos( ctx );

+

+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj))

+      indices = ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Pointer, indices);

+

+   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE );

+

+   switch (type) {

+   case GL_UNSIGNED_BYTE:

+      for (i = 0 ; i < count ; i++)

+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));

+      break;

+   case GL_UNSIGNED_SHORT:

+      for (i = 0 ; i < count ; i++)

+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));

+      break;

+   case GL_UNSIGNED_INT:

+      for (i = 0 ; i < count ; i++)

+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));

+      break;

+   default:

+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );

+      break;

+   }

+

+   CALL_End(GET_DISPATCH(), ());

+

+   _ae_unmap_vbos( ctx );

+}

+

+static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode,

+					GLuint start, GLuint end,

+					GLsizei count, GLenum type,

+					const GLvoid *indices)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (_mesa_validate_DrawRangeElements( ctx, mode,

+					 start, end,

+					 count, type, indices, 0 ))

+      _save_OBE_DrawElements( mode, count, type, indices );

+}

+

+

+

+

+

+static void _save_vtxfmt_init( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLvertexformat *vfmt = &save->vtxfmt;

+

+   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);

+

+   vfmt->Begin = _save_Begin;

+   vfmt->Color3f = _save_Color3f;

+   vfmt->Color3fv = _save_Color3fv;

+   vfmt->Color4f = _save_Color4f;

+   vfmt->Color4fv = _save_Color4fv;

+   vfmt->EdgeFlag = _save_EdgeFlag;

+   vfmt->End = _save_End;

+   vfmt->PrimitiveRestartNV = _save_PrimitiveRestartNV;

+   vfmt->FogCoordfEXT = _save_FogCoordfEXT;

+   vfmt->FogCoordfvEXT = _save_FogCoordfvEXT;

+   vfmt->Indexf = _save_Indexf;

+   vfmt->Indexfv = _save_Indexfv;

+   vfmt->Materialfv = _save_Materialfv;

+   vfmt->MultiTexCoord1fARB = _save_MultiTexCoord1f;

+   vfmt->MultiTexCoord1fvARB = _save_MultiTexCoord1fv;

+   vfmt->MultiTexCoord2fARB = _save_MultiTexCoord2f;

+   vfmt->MultiTexCoord2fvARB = _save_MultiTexCoord2fv;

+   vfmt->MultiTexCoord3fARB = _save_MultiTexCoord3f;

+   vfmt->MultiTexCoord3fvARB = _save_MultiTexCoord3fv;

+   vfmt->MultiTexCoord4fARB = _save_MultiTexCoord4f;

+   vfmt->MultiTexCoord4fvARB = _save_MultiTexCoord4fv;

+   vfmt->Normal3f = _save_Normal3f;

+   vfmt->Normal3fv = _save_Normal3fv;

+   vfmt->SecondaryColor3fEXT = _save_SecondaryColor3fEXT;

+   vfmt->SecondaryColor3fvEXT = _save_SecondaryColor3fvEXT;

+   vfmt->TexCoord1f = _save_TexCoord1f;

+   vfmt->TexCoord1fv = _save_TexCoord1fv;

+   vfmt->TexCoord2f = _save_TexCoord2f;

+   vfmt->TexCoord2fv = _save_TexCoord2fv;

+   vfmt->TexCoord3f = _save_TexCoord3f;

+   vfmt->TexCoord3fv = _save_TexCoord3fv;

+   vfmt->TexCoord4f = _save_TexCoord4f;

+   vfmt->TexCoord4fv = _save_TexCoord4fv;

+   vfmt->Vertex2f = _save_Vertex2f;

+   vfmt->Vertex2fv = _save_Vertex2fv;

+   vfmt->Vertex3f = _save_Vertex3f;

+   vfmt->Vertex3fv = _save_Vertex3fv;

+   vfmt->Vertex4f = _save_Vertex4f;

+   vfmt->Vertex4fv = _save_Vertex4fv;

+   vfmt->VertexAttrib1fARB = _save_VertexAttrib1fARB;

+   vfmt->VertexAttrib1fvARB = _save_VertexAttrib1fvARB;

+   vfmt->VertexAttrib2fARB = _save_VertexAttrib2fARB;

+   vfmt->VertexAttrib2fvARB = _save_VertexAttrib2fvARB;

+   vfmt->VertexAttrib3fARB = _save_VertexAttrib3fARB;

+   vfmt->VertexAttrib3fvARB = _save_VertexAttrib3fvARB;

+   vfmt->VertexAttrib4fARB = _save_VertexAttrib4fARB;

+   vfmt->VertexAttrib4fvARB = _save_VertexAttrib4fvARB;

+

+   vfmt->VertexAttrib1fNV = _save_VertexAttrib1fNV;

+   vfmt->VertexAttrib1fvNV = _save_VertexAttrib1fvNV;

+   vfmt->VertexAttrib2fNV = _save_VertexAttrib2fNV;

+   vfmt->VertexAttrib2fvNV = _save_VertexAttrib2fvNV;

+   vfmt->VertexAttrib3fNV = _save_VertexAttrib3fNV;

+   vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV;

+   vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV;

+   vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV;

+   

+   /* integer-valued */

+   vfmt->VertexAttribI1i = _save_VertexAttribI1i;

+   vfmt->VertexAttribI2i = _save_VertexAttribI2i;

+   vfmt->VertexAttribI3i = _save_VertexAttribI3i;

+   vfmt->VertexAttribI4i = _save_VertexAttribI4i;

+   vfmt->VertexAttribI2iv = _save_VertexAttribI2iv;

+   vfmt->VertexAttribI3iv = _save_VertexAttribI3iv;

+   vfmt->VertexAttribI4iv = _save_VertexAttribI4iv;

+

+   /* unsigned integer-valued */

+   vfmt->VertexAttribI1ui = _save_VertexAttribI1ui;

+   vfmt->VertexAttribI2ui = _save_VertexAttribI2ui;

+   vfmt->VertexAttribI3ui = _save_VertexAttribI3ui;

+   vfmt->VertexAttribI4ui = _save_VertexAttribI4ui;

+   vfmt->VertexAttribI2uiv = _save_VertexAttribI2uiv;

+   vfmt->VertexAttribI3uiv = _save_VertexAttribI3uiv;

+   vfmt->VertexAttribI4uiv = _save_VertexAttribI4uiv;

+

+   /* This will all require us to fallback to saving the list as opcodes:

+    */ 

+   _MESA_INIT_DLIST_VTXFMT(vfmt, _save_); /* inside begin/end */

+

+   _MESA_INIT_EVAL_VTXFMT(vfmt, _save_);

+

+   /* These are all errors as we at least know we are in some sort of

+    * begin/end pair:

+    */

+   vfmt->Begin = _save_Begin;

+   vfmt->Rectf = _save_Rectf;

+   vfmt->DrawArrays = _save_DrawArrays;

+   vfmt->DrawElements = _save_DrawElements;

+   vfmt->DrawRangeElements = _save_DrawRangeElements;

+   vfmt->DrawElementsBaseVertex = _save_DrawElementsBaseVertex;

+   vfmt->DrawRangeElementsBaseVertex = _save_DrawRangeElementsBaseVertex;

+   /* Loops back into vfmt->DrawElements */

+   vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;

+   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;

+}

+

+

+void vbo_save_SaveFlushVertices( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   /* Noop when we are actually active:

+    */

+   if (ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM ||

+       ctx->Driver.CurrentSavePrimitive <= GL_POLYGON)

+      return;

+

+   if (save->vert_count ||

+       save->prim_count) 

+      _save_compile_vertex_list( ctx );

+   

+   _save_copy_to_current( ctx );

+   _save_reset_vertex( ctx );

+   _save_reset_counters( ctx );  

+   ctx->Driver.SaveNeedFlush = 0;

+}

+

+void vbo_save_NewList( struct gl_context *ctx, GLuint list, GLenum mode )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   (void) list; (void) mode;

+

+   if (!save->prim_store)

+      save->prim_store = alloc_prim_store( ctx );

+

+   if (!save->vertex_store) 

+      save->vertex_store = alloc_vertex_store( ctx );

+      

+   save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );

+   

+   _save_reset_vertex( ctx );

+   _save_reset_counters( ctx );  

+   ctx->Driver.SaveNeedFlush = 0;

+}

+

+void vbo_save_EndList( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   /* EndList called inside a (saved) Begin/End pair?

+    */

+   if (ctx->Driver.CurrentSavePrimitive != PRIM_OUTSIDE_BEGIN_END) {

+

+      if (save->prim_count > 0) {

+         GLint i = save->prim_count - 1;

+         ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;

+         save->prim[i].end = 0;

+         save->prim[i].count = (save->vert_count - 

+                                save->prim[i].start);

+      }

+

+      /* Make sure this vertex list gets replayed by the "loopback"

+       * mechanism:

+       */

+      save->dangling_attr_ref = 1;

+      vbo_save_SaveFlushVertices( ctx );

+

+      /* Swap out this vertex format while outside begin/end.  Any color,

+       * etc. received between here and the next begin will be compiled

+       * as opcodes.

+       */   

+      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+   }

+

+   unmap_vertex_store( ctx, save->vertex_store );

+

+   assert(save->vertex_size == 0);

+}

+ 

+void vbo_save_BeginCallList( struct gl_context *ctx, struct gl_display_list *dlist )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   save->replay_flags |= dlist->Flags;

+}

+

+void vbo_save_EndCallList( struct gl_context *ctx )

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   

+   if (ctx->ListState.CallDepth == 1) {

+      /* This is correct: want to keep only the VBO_SAVE_FALLBACK

+       * flag, if it is set:

+       */

+      save->replay_flags &= VBO_SAVE_FALLBACK;

+   }

+}

+

+

+static void vbo_destroy_vertex_list( struct gl_context *ctx, void *data )

+{

+   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;

+   (void) ctx;

+

+   if ( --node->vertex_store->refcount == 0 ) 

+      free_vertex_store( ctx, node->vertex_store );

+

+   if ( --node->prim_store->refcount == 0 )

+      FREE( node->prim_store );

+

+   if (node->current_data) {

+      FREE(node->current_data);

+      node->current_data = NULL;

+   }

+}

+

+

+static void vbo_print_vertex_list( struct gl_context *ctx, void *data )

+{

+   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;

+   GLuint i;

+   (void) ctx;

+

+   printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",

+	  node->count,

+	  node->prim_count,

+	  node->vertex_size);

+

+   for (i = 0 ; i < node->prim_count ; i++) {

+      struct _mesa_prim *prim = &node->prim[i];

+      _mesa_debug(NULL, "   prim %d: %s%s %d..%d %s %s\n",

+		  i, 

+		  _mesa_lookup_prim_by_nr(prim->mode),

+		  prim->weak ? " (weak)" : "",

+		  prim->start, 

+		  prim->start + prim->count,

+		  (prim->begin) ? "BEGIN" : "(wrap)",

+		  (prim->end) ? "END" : "(wrap)");

+   }

+}

+

+

+static void _save_current_init( struct gl_context *ctx ) 

+{

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+   GLint i;

+

+   for (i = VBO_ATTRIB_POS; i <= VBO_ATTRIB_GENERIC15; i++) {

+      const GLuint j = i - VBO_ATTRIB_POS;

+      ASSERT(j < VERT_ATTRIB_MAX);

+      save->currentsz[i] = &ctx->ListState.ActiveAttribSize[j];

+      save->current[i] = ctx->ListState.CurrentAttrib[j];

+   }

+

+   for (i = VBO_ATTRIB_FIRST_MATERIAL; i <= VBO_ATTRIB_LAST_MATERIAL; i++) {

+      const GLuint j = i - VBO_ATTRIB_FIRST_MATERIAL;

+      ASSERT(j < MAT_ATTRIB_MAX);

+      save->currentsz[i] = &ctx->ListState.ActiveMaterialSize[j];

+      save->current[i] = ctx->ListState.CurrentMaterial[j];

+   }

+}

+

+/**

+ * Initialize the display list compiler

+ */

+void vbo_save_api_init( struct vbo_save_context *save )

+{

+   struct gl_context *ctx = save->ctx;

+   GLuint i;

+

+   save->opcode_vertex_list =

+      _mesa_dlist_alloc_opcode( ctx,

+                                sizeof(struct vbo_save_vertex_list),

+                                vbo_save_playback_vertex_list,

+                                vbo_destroy_vertex_list,

+                                vbo_print_vertex_list );

+

+   ctx->Driver.NotifySaveBegin = vbo_save_NotifyBegin;

+

+   _save_vtxfmt_init( ctx );

+   _save_current_init( ctx );

+

+   /* These will actually get set again when binding/drawing */

+   for (i = 0; i < VBO_ATTRIB_MAX; i++)

+      save->inputs[i] = &save->arrays[i];

+

+   /* Hook our array functions into the outside-begin-end vtxfmt in 

+    * ctx->ListState.

+    */

+   ctx->ListState.ListVtxfmt.Rectf = _save_OBE_Rectf;

+   ctx->ListState.ListVtxfmt.DrawArrays = _save_OBE_DrawArrays;

+   ctx->ListState.ListVtxfmt.DrawElements = _save_OBE_DrawElements;

+   ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;

+   /* loops back into _save_OBE_DrawElements */

+   ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;

+   ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;

+   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+}

+

+

+#endif /* FEATURE_dlist */

diff --git a/mesalib/src/mesa/vbo/vbo_save_draw.c b/mesalib/src/mesa/vbo/vbo_save_draw.c
index 634a6d3f8..5a19b0d62 100644
--- a/mesalib/src/mesa/vbo/vbo_save_draw.c
+++ b/mesalib/src/mesa/vbo/vbo_save_draw.c
@@ -1,305 +1,305 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.2
- *
- * Copyright (C) 1999-2008  Brian Paul   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, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/* Author:
- *    Keith Whitwell <keith@tungstengraphics.com>
- */
-
-#include "main/glheader.h"
-#include "main/bufferobj.h"
-#include "main/context.h"
-#include "main/imports.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/macros.h"
-#include "main/light.h"
-#include "main/state.h"
-
-#include "vbo_context.h"
-
-
-#if FEATURE_dlist
-
-
-/**
- * After playback, copy everything but the position from the
- * last vertex to the saved state
- */
-static void
-_playback_copy_to_current(struct gl_context *ctx,
-                          const struct vbo_save_vertex_list *node)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   GLfloat vertex[VBO_ATTRIB_MAX * 4];
-   GLfloat *data;
-   GLuint i, offset;
-
-   if (node->current_size == 0)
-      return;
-
-   if (node->current_data) {
-      data = node->current_data;
-   }
-   else {
-      data = vertex;
-
-      if (node->count)
-         offset = (node->buffer_offset + 
-                   (node->count-1) * node->vertex_size * sizeof(GLfloat));
-      else
-         offset = node->buffer_offset;
-
-      ctx->Driver.GetBufferSubData( ctx, 0, offset, 
-                                    node->vertex_size * sizeof(GLfloat), 
-                                    data, node->vertex_store->bufferobj );
-
-      data += node->attrsz[0]; /* skip vertex position */
-   }
-
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
-      if (node->attrsz[i]) {
-	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
-         GLfloat tmp[4];
-
-         COPY_CLEAN_4V(tmp, 
-                       node->attrsz[i], 
-                       data);
-         
-         if (memcmp(current, tmp, 4 * sizeof(GLfloat)) != 0) {
-            memcpy(current, tmp, 4 * sizeof(GLfloat));
-
-            vbo->currval[i].Size = node->attrsz[i];
-
-            if (i >= VBO_ATTRIB_FIRST_MATERIAL &&
-                i <= VBO_ATTRIB_LAST_MATERIAL)
-               ctx->NewState |= _NEW_LIGHT;
-
-            ctx->NewState |= _NEW_CURRENT_ATTRIB;
-         }
-
-	 data += node->attrsz[i];
-      }
-   }
-
-   /* Colormaterial -- this kindof sucks.
-    */
-   if (ctx->Light.ColorMaterialEnabled) {
-      _mesa_update_color_material(ctx, ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
-   }
-
-   /* CurrentExecPrimitive
-    */
-   if (node->prim_count) {
-      const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];
-      if (prim->end)
-	 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
-      else
-	 ctx->Driver.CurrentExecPrimitive = prim->mode;
-   }
-}
-
-
-
-/**
- * Treat the vertex storage as a VBO, define vertex arrays pointing
- * into it:
- */
-static void vbo_bind_vertex_list(struct gl_context *ctx,
-                                 const struct vbo_save_vertex_list *node)
-{
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_save_context *save = &vbo->save;
-   struct gl_client_array *arrays = save->arrays;
-   GLuint buffer_offset = node->buffer_offset;
-   const GLuint *map;
-   GLuint attr;
-   GLubyte node_attrsz[VBO_ATTRIB_MAX];  /* copy of node->attrsz[] */
-   GLbitfield varying_inputs = 0x0;
-
-   memcpy(node_attrsz, node->attrsz, sizeof(node->attrsz));
-
-   /* Install the default (ie Current) attributes first, then overlay
-    * all active ones.
-    */
-   switch (get_program_mode(ctx)) {
-   case VP_NONE:
-      for (attr = 0; attr < 16; attr++) {
-         save->inputs[attr] = &vbo->legacy_currval[attr];
-      }
-      for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {
-         save->inputs[attr + 16] = &vbo->mat_currval[attr];
-      }
-      map = vbo->map_vp_none;
-      break;
-   case VP_NV:
-   case VP_ARB:
-      /* The aliasing of attributes for NV vertex programs has already
-       * occurred.  NV vertex programs cannot access material values,
-       * nor attributes greater than VERT_ATTRIB_TEX7.  
-       */
-      for (attr = 0; attr < 16; attr++) {
-         save->inputs[attr] = &vbo->legacy_currval[attr];
-         save->inputs[attr + 16] = &vbo->generic_currval[attr];
-      }
-      map = vbo->map_vp_arb;
-
-      /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.
-       * In that case we effectively need to route the data from
-       * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
-       */
-      if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&
-          (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {
-         save->inputs[16] = save->inputs[0];
-         node_attrsz[16] = node_attrsz[0];
-         node_attrsz[0] = 0;
-      }
-      break;
-   default:
-      assert(0);
-   }
-
-   for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-      const GLuint src = map[attr];
-
-      if (node_attrsz[src]) {
-         /* override the default array set above */
-         save->inputs[attr] = &arrays[attr];
-
-	 arrays[attr].Ptr = (const GLubyte *) NULL + buffer_offset;
-	 arrays[attr].Size = node->attrsz[src];
-	 arrays[attr].StrideB = node->vertex_size * sizeof(GLfloat);
-	 arrays[attr].Stride = node->vertex_size * sizeof(GLfloat);
-	 arrays[attr].Type = GL_FLOAT;
-         arrays[attr].Format = GL_RGBA;
-	 arrays[attr].Enabled = 1;
-         _mesa_reference_buffer_object(ctx,
-                                       &arrays[attr].BufferObj,
-                                       node->vertex_store->bufferobj);
-	 arrays[attr]._MaxElement = node->count; /* ??? */
-	 
-	 assert(arrays[attr].BufferObj->Name);
-
-	 buffer_offset += node->attrsz[src] * sizeof(GLfloat);
-         varying_inputs |= 1<<attr;
-         ctx->NewState |= _NEW_ARRAY;
-      }
-   }
-
-   _mesa_set_varying_vp_inputs( ctx, varying_inputs );
-}
-
-
-static void
-vbo_save_loopback_vertex_list(struct gl_context *ctx,
-                              const struct vbo_save_vertex_list *list)
-{
-   const char *buffer = ctx->Driver.MapBuffer(ctx, 
-					      GL_ARRAY_BUFFER_ARB, 
-					      GL_READ_ONLY, /* ? */
-                                              list->vertex_store->bufferobj);
-
-   vbo_loopback_vertex_list(ctx,
-                            (const GLfloat *)(buffer + list->buffer_offset),
-                            list->attrsz,
-                            list->prim,
-                            list->prim_count,
-                            list->wrap_count,
-                            list->vertex_size);
-
-   ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, 
-			   list->vertex_store->bufferobj);
-}
-
-
-/**
- * Execute the buffer and save copied verts.
- * This is called from the display list code when executing
- * a drawing command.
- */
-void
-vbo_save_playback_vertex_list(struct gl_context *ctx, void *data)
-{
-   const struct vbo_save_vertex_list *node =
-      (const struct vbo_save_vertex_list *) data;
-   struct vbo_save_context *save = &vbo_context(ctx)->save;
-
-   FLUSH_CURRENT(ctx, 0);
-
-   if (node->prim_count > 0 && node->count > 0) {
-
-      if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END &&
-	  node->prim[0].begin) {
-
-	 /* Degenerate case: list is called inside begin/end pair and
-	  * includes operations such as glBegin or glDrawArrays.
-	  */
-	 if (0)
-	    printf("displaylist recursive begin");
-
-	 vbo_save_loopback_vertex_list( ctx, node );
-	 return;
-      }
-      else if (save->replay_flags) {
-	 /* Various degnerate cases: translate into immediate mode
-	  * calls rather than trying to execute in place.
-	  */
-	 vbo_save_loopback_vertex_list( ctx, node );
-	 return;
-      }
-      
-      if (ctx->NewState)
-	 _mesa_update_state( ctx );
-
-      /* XXX also need to check if shader enabled, but invalid */
-      if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) ||
-          (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glBegin (invalid vertex/fragment program)");
-         return;
-      }
-
-      vbo_bind_vertex_list( ctx, node );
-
-      /* Again...
-       */
-      if (ctx->NewState)
-	 _mesa_update_state( ctx );
-
-      vbo_context(ctx)->draw_prims(ctx, 
-                                   save->inputs, 
-                                   node->prim, 
-                                   node->prim_count,
-                                   NULL,
-                                   GL_TRUE,
-                                   0,	/* Node is a VBO, so this is ok */
-                                   node->count - 1);
-   }
-
-   /* Copy to current?
-    */
-   _playback_copy_to_current( ctx, node );
-}
-
-
-#endif /* FEATURE_dlist */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.2

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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.

+ */

+

+/* Author:

+ *    Keith Whitwell <keith@tungstengraphics.com>

+ */

+

+#include "main/glheader.h"

+#include "main/bufferobj.h"

+#include "main/context.h"

+#include "main/imports.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/macros.h"

+#include "main/light.h"

+#include "main/state.h"

+

+#include "vbo_context.h"

+

+

+#if FEATURE_dlist

+

+

+/**

+ * After playback, copy everything but the position from the

+ * last vertex to the saved state

+ */

+static void

+_playback_copy_to_current(struct gl_context *ctx,

+                          const struct vbo_save_vertex_list *node)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   GLfloat vertex[VBO_ATTRIB_MAX * 4];

+   GLfloat *data;

+   GLuint i, offset;

+

+   if (node->current_size == 0)

+      return;

+

+   if (node->current_data) {

+      data = node->current_data;

+   }

+   else {

+      data = vertex;

+

+      if (node->count)

+         offset = (node->buffer_offset + 

+                   (node->count-1) * node->vertex_size * sizeof(GLfloat));

+      else

+         offset = node->buffer_offset;

+

+      ctx->Driver.GetBufferSubData( ctx, 0, offset, 

+                                    node->vertex_size * sizeof(GLfloat), 

+                                    data, node->vertex_store->bufferobj );

+

+      data += node->attrsz[0]; /* skip vertex position */

+   }

+

+   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {

+      if (node->attrsz[i]) {

+	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;

+         GLfloat tmp[4];

+

+         COPY_CLEAN_4V(tmp, 

+                       node->attrsz[i], 

+                       data);

+         

+         if (memcmp(current, tmp, 4 * sizeof(GLfloat)) != 0) {

+            memcpy(current, tmp, 4 * sizeof(GLfloat));

+

+            vbo->currval[i].Size = node->attrsz[i];

+

+            if (i >= VBO_ATTRIB_FIRST_MATERIAL &&

+                i <= VBO_ATTRIB_LAST_MATERIAL)

+               ctx->NewState |= _NEW_LIGHT;

+

+            ctx->NewState |= _NEW_CURRENT_ATTRIB;

+         }

+

+	 data += node->attrsz[i];

+      }

+   }

+

+   /* Colormaterial -- this kindof sucks.

+    */

+   if (ctx->Light.ColorMaterialEnabled) {

+      _mesa_update_color_material(ctx, ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);

+   }

+

+   /* CurrentExecPrimitive

+    */

+   if (node->prim_count) {

+      const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];

+      if (prim->end)

+	 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;

+      else

+	 ctx->Driver.CurrentExecPrimitive = prim->mode;

+   }

+}

+

+

+

+/**

+ * Treat the vertex storage as a VBO, define vertex arrays pointing

+ * into it:

+ */

+static void vbo_bind_vertex_list(struct gl_context *ctx,

+                                 const struct vbo_save_vertex_list *node)

+{

+   struct vbo_context *vbo = vbo_context(ctx);

+   struct vbo_save_context *save = &vbo->save;

+   struct gl_client_array *arrays = save->arrays;

+   GLuint buffer_offset = node->buffer_offset;

+   const GLuint *map;

+   GLuint attr;

+   GLubyte node_attrsz[VBO_ATTRIB_MAX];  /* copy of node->attrsz[] */

+   GLbitfield varying_inputs = 0x0;

+

+   memcpy(node_attrsz, node->attrsz, sizeof(node->attrsz));

+

+   /* Install the default (ie Current) attributes first, then overlay

+    * all active ones.

+    */

+   switch (get_program_mode(ctx)) {

+   case VP_NONE:

+      for (attr = 0; attr < 16; attr++) {

+         save->inputs[attr] = &vbo->legacy_currval[attr];

+      }

+      for (attr = 0; attr < MAT_ATTRIB_MAX; attr++) {

+         save->inputs[attr + 16] = &vbo->mat_currval[attr];

+      }

+      map = vbo->map_vp_none;

+      break;

+   case VP_NV:

+   case VP_ARB:

+      /* The aliasing of attributes for NV vertex programs has already

+       * occurred.  NV vertex programs cannot access material values,

+       * nor attributes greater than VERT_ATTRIB_TEX7.  

+       */

+      for (attr = 0; attr < 16; attr++) {

+         save->inputs[attr] = &vbo->legacy_currval[attr];

+         save->inputs[attr + 16] = &vbo->generic_currval[attr];

+      }

+      map = vbo->map_vp_arb;

+

+      /* check if VERT_ATTRIB_POS is not read but VERT_BIT_GENERIC0 is read.

+       * In that case we effectively need to route the data from

+       * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.

+       */

+      if ((ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_POS) == 0 &&

+          (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_GENERIC0)) {

+         save->inputs[16] = save->inputs[0];

+         node_attrsz[16] = node_attrsz[0];

+         node_attrsz[0] = 0;

+      }

+      break;

+   default:

+      assert(0);

+   }

+

+   for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {

+      const GLuint src = map[attr];

+

+      if (node_attrsz[src]) {

+         /* override the default array set above */

+         save->inputs[attr] = &arrays[attr];

+

+	 arrays[attr].Ptr = (const GLubyte *) NULL + buffer_offset;

+	 arrays[attr].Size = node->attrsz[src];

+	 arrays[attr].StrideB = node->vertex_size * sizeof(GLfloat);

+	 arrays[attr].Stride = node->vertex_size * sizeof(GLfloat);

+	 arrays[attr].Type = GL_FLOAT;

+         arrays[attr].Format = GL_RGBA;

+	 arrays[attr].Enabled = 1;

+         _mesa_reference_buffer_object(ctx,

+                                       &arrays[attr].BufferObj,

+                                       node->vertex_store->bufferobj);

+	 arrays[attr]._MaxElement = node->count; /* ??? */

+	 

+	 assert(arrays[attr].BufferObj->Name);

+

+	 buffer_offset += node->attrsz[src] * sizeof(GLfloat);

+         varying_inputs |= 1<<attr;

+         ctx->NewState |= _NEW_ARRAY;

+      }

+   }

+

+   _mesa_set_varying_vp_inputs( ctx, varying_inputs );

+}

+

+

+static void

+vbo_save_loopback_vertex_list(struct gl_context *ctx,

+                              const struct vbo_save_vertex_list *list)

+{

+   const char *buffer = ctx->Driver.MapBuffer(ctx, 

+					      GL_ARRAY_BUFFER_ARB, 

+					      GL_READ_ONLY, /* ? */

+                                              list->vertex_store->bufferobj);

+

+   vbo_loopback_vertex_list(ctx,

+                            (const GLfloat *)(buffer + list->buffer_offset),

+                            list->attrsz,

+                            list->prim,

+                            list->prim_count,

+                            list->wrap_count,

+                            list->vertex_size);

+

+   ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, 

+			   list->vertex_store->bufferobj);

+}

+

+

+/**

+ * Execute the buffer and save copied verts.

+ * This is called from the display list code when executing

+ * a drawing command.

+ */

+void

+vbo_save_playback_vertex_list(struct gl_context *ctx, void *data)

+{

+   const struct vbo_save_vertex_list *node =

+      (const struct vbo_save_vertex_list *) data;

+   struct vbo_save_context *save = &vbo_context(ctx)->save;

+

+   FLUSH_CURRENT(ctx, 0);

+

+   if (node->prim_count > 0 && node->count > 0) {

+

+      if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END &&

+	  node->prim[0].begin) {

+

+	 /* Degenerate case: list is called inside begin/end pair and

+	  * includes operations such as glBegin or glDrawArrays.

+	  */

+	 if (0)

+	    printf("displaylist recursive begin");

+

+	 vbo_save_loopback_vertex_list( ctx, node );

+	 return;

+      }

+      else if (save->replay_flags) {

+	 /* Various degnerate cases: translate into immediate mode

+	  * calls rather than trying to execute in place.

+	  */

+	 vbo_save_loopback_vertex_list( ctx, node );

+	 return;

+      }

+      

+      if (ctx->NewState)

+	 _mesa_update_state( ctx );

+

+      /* XXX also need to check if shader enabled, but invalid */

+      if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) ||

+          (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glBegin (invalid vertex/fragment program)");

+         return;

+      }

+

+      vbo_bind_vertex_list( ctx, node );

+

+      /* Again...

+       */

+      if (ctx->NewState)

+	 _mesa_update_state( ctx );

+

+      vbo_context(ctx)->draw_prims(ctx, 

+                                   save->inputs, 

+                                   node->prim, 

+                                   node->prim_count,

+                                   NULL,

+                                   GL_TRUE,

+                                   0,	/* Node is a VBO, so this is ok */

+                                   node->count - 1);

+   }

+

+   /* Copy to current?

+    */

+   _playback_copy_to_current( ctx, node );

+}

+

+

+#endif /* FEATURE_dlist */