src/glx/indirect_texture_compression.c - platform/external/mesa3d - Gitiles

 /*
  * (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 "indirect.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);
    }
 }
	/*
	* (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 "indirect.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);
	}
	}