glx: indent -br -i3 -npcs --no-tabs indirect_texture_compression.c

diff --git a/src/glx/x11/indirect_texture_compression.c b/src/glx/x11/indirect_texture_compression.c
index e7ede89292d3c0fe6775b67653117f58ffb18672..68837668204fb32441f7cb71172b36ac0cc4ada6 100644 (file)
--- a/src/glx/x11/indirect_texture_compression.c
+++ b/src/glx/x11/indirect_texture_compression.c
@@ -41,31 +41,31 @@
 
 
 void
-__indirect_glGetCompressedTexImageARB( GLenum target, GLint level, 
-                                   GLvoid * img )
+__indirect_glGetCompressedTexImageARB(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();
+   __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();
 }
 
 
@@ -74,60 +74,59 @@ __indirect_glGetCompressedTexImageARB( GLenum target, GLint level,
  * \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 )
+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 );
-    }
+   __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);
+   }
 }
 
 
@@ -136,213 +135,210 @@ CompressedTexImage1D2D( GLenum target, GLint level,
  * \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 )
+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 );
-    }
+   __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_glCompressedTexImage1DARB( GLenum target, GLint level,
-                                  GLenum internal_format, GLsizei width,
-                                  GLint border, GLsizei image_size,
-                                  const GLvoid *data )
+__indirect_glCompressedTexImage1DARB(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 );
+   CompressedTexImage1D2D(target, level, internal_format, width, 0,
+                          border, image_size, data,
+                          X_GLrop_CompressedTexImage1D);
 }
 
 
 void
-__indirect_glCompressedTexImage2DARB( GLenum target, GLint level,
-                                  GLenum internal_format,
-                                  GLsizei width, GLsizei height,
-                                  GLint border, GLsizei image_size,
-                                  const GLvoid *data )
+__indirect_glCompressedTexImage2DARB(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 );
+   CompressedTexImage1D2D(target, level, internal_format, width, height,
+                          border, image_size, data,
+                          X_GLrop_CompressedTexImage2D);
 }
 
 
 void
-__indirect_glCompressedTexImage3DARB( GLenum target, GLint level,
-                                  GLenum internal_format,
-                                  GLsizei width, GLsizei height, GLsizei depth,
-                                  GLint border, GLsizei image_size,
-                                  const GLvoid *data )
+__indirect_glCompressedTexImage3DARB(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 );
-    }
+   __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_glCompressedTexSubImage1DARB( GLenum target, GLint level,
-                                     GLint xoffset,
-                                     GLsizei width,
-                                     GLenum format, GLsizei image_size,
-                                     const GLvoid *data )
+__indirect_glCompressedTexSubImage1DARB(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 );
+   CompressedTexSubImage1D2D(target, level, xoffset, 0, width, 0,
+                             format, image_size, data,
+                             X_GLrop_CompressedTexSubImage1D);
 }
 
 
 void
-__indirect_glCompressedTexSubImage2DARB( GLenum target, GLint level,
-                                     GLint xoffset, GLint yoffset,
-                                     GLsizei width, GLsizei height,
-                                     GLenum format, GLsizei image_size,
-                                     const GLvoid *data )
+__indirect_glCompressedTexSubImage2DARB(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 );
+   CompressedTexSubImage1D2D(target, level, xoffset, yoffset, width, height,
+                             format, image_size, data,
+                             X_GLrop_CompressedTexSubImage2D);
 }
 
 
 void
-__indirect_glCompressedTexSubImage3DARB( GLenum target, GLint level,
-                                     GLint xoffset, GLint yoffset, GLint zoffset,
-                                     GLsizei width, GLsizei height, GLsizei depth,
-                                     GLenum format, GLsizei image_size,
-                                     const GLvoid *data )
+__indirect_glCompressedTexSubImage3DARB(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 );
-    }
+   __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);
+   }
 }