Add client-side GLX protocol support for GL_ARB_texture_compression. The

extensions are *not* currently enabled.  This is for several reaons.  First,
the server-side does not support texture compression, so there's no
advantage to supporting it (yet) on the client-side.  Second, I tried
testing it with an IHV's closed-source driver (that advertises GL 1.3), but
their server-side driver doesn't support the protocol.  That means this code
is largely untested.

6 files changed, 398 insertions, 2 deletions

diff --git a/xc/lib/GL/glx/Imakefile b/xc/lib/GL/glx/Imakefile
index 0b9d8f022..5051550c9 100644
--- a/xc/lib/GL/glx/Imakefile
+++ b/xc/lib/GL/glx/Imakefile
@@ -73,7 +73,8 @@ LinkSourceFile(glapi_sparc.S, $(MESASRCDIR)/src/mesa/sparc)
 		vertarr.c \
 	        xfont.c \
 		glx_pbuffer.c \
-		glx_query.c
+		glx_query.c \
+		glx_texture_compression.c
 
      GLX_OBJS = \
 	        clientattrib.o \
@@ -99,7 +100,8 @@ LinkSourceFile(glapi_sparc.S, $(MESASRCDIR)/src/mesa/sparc)
 		vertarr.o \
 	        xfont.o \
 		glx_pbuffer.o \
-		glx_query.o
+		glx_query.o \
+		glx_texture_compression.o
 
      GLX_DEFS = GlxDefines VidModeExtensionDefines
 
diff --git a/xc/lib/GL/glx/glx_texture_compression.c b/xc/lib/GL/glx/glx_texture_compression.c
new file mode 100644
index 000000000..a478c194a
--- /dev/null
+++ b/xc/lib/GL/glx/glx_texture_compression.c
@@ -0,0 +1,346 @@
+/*
+ * (C) Copyright IBM Corporation 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
+ * THE COPYRIGHT HOLDERS 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 glx_texture_compression.c
+ * Contains the routines required to implement GLX protocol for
+ * ARB_texture_compression and related extensions.
+ *
+ * \sa http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt
+ *
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include "packrender.h"
+#include "packsingle.h"
+
+#include <assert.h>
+
+
+void
+__indirect_glGetCompressedTexImage( GLenum target, GLint level, 
+				    GLvoid * img )
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    xGLXGetTexImageReply reply;
+    size_t image_bytes;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN( X_GLsop_GetCompressedTexImage, 8 );
+    __GLX_SINGLE_PUT_LONG( 0, target );
+    __GLX_SINGLE_PUT_LONG( 4, level );
+    __GLX_SINGLE_READ_XREPLY();
+
+    image_bytes = reply.width;
+    assert( image_bytes <= ((4 * reply.length) - 0) );
+    assert( image_bytes >= ((4 * reply.length) - 3) );
+    
+    if ( image_bytes != 0 ) {
+	_XRead( dpy, (char *) img, image_bytes );
+	if ( image_bytes < (4 * reply.length) ) {
+	    _XEatData( dpy, (4 * reply.length) - image_bytes );
+	}
+    }
+
+    __GLX_SINGLE_END();
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexImage1D and
+ * \c glCompressedTexImage2D.
+ */
+static void
+CompressedTexImage1D2D( GLenum target, GLint level,
+			GLenum internal_format, 
+			GLsizei width, GLsizei height,
+			GLint border, GLsizei image_size,
+			const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( (target == GL_PROXY_TEXTURE_1D)
+	 || (target == GL_PROXY_TEXTURE_2D)
+	 || (target == GL_PROXY_TEXTURE_CUBE_MAP) ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE 
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, border );
+	__GLX_PUT_LONG( 28, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexSubImage1D and
+ * \c glCompressedTexSubImage2D.
+ */
+static void
+CompressedTexSubImage1D2D( GLenum target, GLint level,
+			   GLsizei xoffset, GLsizei yoffset,
+			   GLsizei width, GLsizei height,
+			   GLenum format, GLsizei image_size,
+			   const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( target == GL_PROXY_TEXTURE_3D ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, format );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE, 
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, format );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexImage1D( GLenum target, GLint level,
+				   GLenum internal_format, GLsizei width,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, 0,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage1D );
+}
+
+
+void
+__indirect_glCompressedTexImage2D( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, height,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage2D );
+}
+
+
+void
+__indirect_glCompressedTexImage3D( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height, GLsizei depth,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, depth );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, depth );
+	__GLX_PUT_LONG( 32, border );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexSubImage1D( GLenum target, GLint level,
+				      GLint xoffset,
+				      GLsizei width,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, 0, width, 0,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage1D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage2D( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset,
+				      GLsizei width, GLsizei height,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, yoffset, width, height,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage2D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage3D( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset, GLint zoffset,
+				      GLsizei width, GLsizei height, GLsizei depth,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexSubImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, zoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, depth );
+	__GLX_PUT_LONG( 36, format );
+	__GLX_PUT_LONG( 40, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexSubImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, zoffset );
+	__GLX_PUT_LONG( 28, width );
+	__GLX_PUT_LONG( 32, height );
+	__GLX_PUT_LONG( 36, depth );
+	__GLX_PUT_LONG( 40, format );
+	__GLX_PUT_LONG( 44, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
diff --git a/xc/lib/GL/glx/glxextensions.c b/xc/lib/GL/glx/glxextensions.c
index c3367addb..1ef7594b5 100644
--- a/xc/lib/GL/glx/glxextensions.c
+++ b/xc/lib/GL/glx/glxextensions.c
@@ -210,6 +210,7 @@ static const struct extension_info known_gl_extensions[] = {
    { GL(NV_multisample_filter_hint),     VER(0,0), Y, N, N, N },
    { GL(NV_point_sprite),                VER(0,0), Y, N, N, N },
    { GL(NV_texgen_reflection),           VER(0,0), Y, N, N, N },
+   { GL(NV_texture_compression_vtc),     VER(0,0), N, N, N, N },
    { GL(NV_texture_env_combine4),        VER(0,0), Y, N, N, N },
    { GL(NV_texture_rectangle),           VER(0,0), Y, N, N, N },
    { GL(SGIS_generate_mipmap),           VER(1,4), Y, N, N, N },
@@ -420,6 +421,10 @@ __glXExtensionsCtr( void )
 	    SET_BIT( client_gl_support, bit );
 	 }
 	 else if ( known_gl_extensions[i].version_major != 0 ) {
+	    /* If an extension that is required for some core GL version is
+	     * not supported, clear the bit for that core GL version as well.
+	     */
+
 	    unsigned ver_bit = (6 * (known_gl_extensions[i].version_major - 1))
 	      + (known_gl_extensions[i].version_minor);
 
@@ -431,12 +436,19 @@ __glXExtensionsCtr( void )
 	 }
       }
       
+      /* Determine the lowest unsupported core GL version.  The version before
+       * that is, therefore, the highest supported core GL version.
+       */
       for ( i = 0 ; (full_support & (1 << i)) != 0 ; i++ )
 	 /* empty */ ;
 
       i--;
       gl_major = major_table[i];
       gl_minor = minor_table[i];
+#if 0
+      fprintf( stderr, "[%s:%u] Maximum client library version: %u.%u\n",
+	       __func__, __LINE__, gl_major, gl_minor );
+#endif
    }
 }
 
diff --git a/xc/lib/GL/glx/glxextensions.h b/xc/lib/GL/glx/glxextensions.h
index 1ee873107..47e3207c0 100644
--- a/xc/lib/GL/glx/glxextensions.h
+++ b/xc/lib/GL/glx/glxextensions.h
@@ -162,6 +162,7 @@ enum {
    GL_NV_multisample_filter_hint_bit,
    GL_NV_point_sprite_bit,
    GL_NV_texgen_reflection_bit,
+   GL_NV_texture_compression_vtc_bit,
    GL_NV_texture_env_combine4_bit,
    GL_SGIS_generate_mipmap_bit,
    GL_SGIS_multisample_bit,
diff --git a/xc/lib/GL/glx/indirect.h b/xc/lib/GL/glx/indirect.h
index d5f72303f..92ca378b2 100644
--- a/xc/lib/GL/glx/indirect.h
+++ b/xc/lib/GL/glx/indirect.h
@@ -570,6 +570,32 @@ void __indirect_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum ty
 void __indirect_glSampleMaskSGIS( GLfloat value, GLboolean invert );
 void __indirect_glSamplePatternSGIS( GLenum pass );
 
+/* ARB 12. GL_ARB_texture_compression / GL 1.3 */
+
+void __indirect_glGetCompressedTexImage( GLenum target, GLint level,
+    GLvoid * img );
+void __indirect_glCompressedTexImage1D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexImage2D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width, GLsizei height,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexImage3D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage1D( GLenum target, GLint level,
+    GLint xoffset,
+    GLsizei width,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage2D( GLenum target, GLint level,
+    GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage3D( GLenum target, GLint level,
+    GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+
 /* 145. GL_EXT_secondary_color / GL 1.4 */
 
 void __indirect_glSecondaryColorPointer (GLint, GLenum, GLsizei, const GLvoid *);
diff --git a/xc/lib/GL/glx/indirect_init.c b/xc/lib/GL/glx/indirect_init.c
index 14d6c75b3..939198269 100644
--- a/xc/lib/GL/glx/indirect_init.c
+++ b/xc/lib/GL/glx/indirect_init.c
@@ -540,6 +540,15 @@ __GLapi *__glXNewIndirectAPI(void)
     /* ARB 5. GL_ARB_multisample */
     glAPI->SampleCoverageARB = __indirect_glSampleCoverageARB;
 
+    /* ARB 12. GL_ARB_texture_compression / 1.3 */
+    glAPI->GetCompressedTexImageARB = __indirect_glGetCompressedTexImage;
+    glAPI->CompressedTexImage1DARB = __indirect_glCompressedTexImage1D;
+    glAPI->CompressedTexImage2DARB = __indirect_glCompressedTexImage2D;
+    glAPI->CompressedTexImage3DARB = __indirect_glCompressedTexImage3D;
+    glAPI->CompressedTexSubImage1DARB = __indirect_glCompressedTexSubImage1D;
+    glAPI->CompressedTexSubImage2DARB = __indirect_glCompressedTexSubImage2D;
+    glAPI->CompressedTexSubImage3DARB = __indirect_glCompressedTexSubImage3D;
+
     /* ARB 14. GL_ARB_point_parameters */
     glAPI->PointParameterfEXT = __indirect_glPointParameterfARB;
     glAPI->PointParameterfvEXT = __indirect_glPointParameterfvARB;