Import the GLX client side library, formerly from xc/lib/GL/glx. Build it

by adding 'glx/x11' to SRC_DIRS in your build config.

1 files changed, 906 insertions, 0 deletions

diff --git a/src/glx/x11/renderpix.c b/src/glx/x11/renderpix.c
new file mode 100644
index 00000000000..2f5346ad675
--- /dev/null
+++ b/src/glx/x11/renderpix.c
@@ -0,0 +1,906 @@
+/* $XFree86: xc/lib/GL/glx/renderpix.c,v 1.5 2003/09/28 20:15:04 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** This file contains routines that deal with unpacking data from client
+** memory using the pixel store unpack modes and then shipping it to
+** the server.  For all of these routines (except glPolygonStipple) there
+** are two forms of the transport - small and large.  Small commands are
+** the commands that fit into the "rendering" transport buffer.  Large
+** commands are sent to the server in chunks by __glXSendLargeCommand.
+**
+** All of the commands send over a pixel header (see glxproto.h) which
+** describes the pixel store modes that the server must use to properly
+** handle the data.  Any pixel store modes not done by the __glFillImage
+** routine are passed on to the server.
+*/
+
+/*
+** Send a large image to the server.  If necessary, a buffer is allocated
+** to hold the unpacked data that is copied from the clients memory.
+*/
+static void SendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim,
+			   GLint width, GLint height, GLint depth,
+			   GLenum format, GLenum type, const GLvoid *src,
+			   GLubyte *pc, GLubyte *modes)
+{
+    if (!gc->fastImageUnpack) {
+	/* Allocate a temporary holding buffer */
+	GLubyte *buf = (GLubyte *) Xmalloc(compsize);
+	if (!buf) {
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    return;
+	}
+
+	/* Apply pixel store unpack modes to copy data into buf */
+	(*gc->fillImage)(gc, dim, width, height, depth, format, type, src, buf,
+			 modes);
+
+	/* Send large command */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
+
+	/* Free buffer */
+	Xfree((char*) buf);
+    } else {
+	/* Just send the data straight as is */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, pc, compsize);
+    }
+}
+
+/*
+** Send a large null image to the server.  To be backwards compatible,
+** data must be sent to the server even when the application has passed
+** a null pointer into glTexImage1D, glTexImage2D or glTexImage3D.
+*/
+static void SendLargeNULLImage(__GLXcontext *gc, GLint compsize,
+			       GLint width, GLint height, GLint depth,
+			       GLenum format, GLenum type, const GLvoid *src,
+			       GLubyte *pc, GLubyte *modes)
+{
+    GLubyte *buf = (GLubyte *) Xmalloc(compsize);
+
+    /* Allocate a temporary holding buffer */
+    if (!buf) {
+	__glXSetError(gc, GL_OUT_OF_MEMORY);
+	return;
+    }
+
+    /* Send large command */
+    __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
+
+    /* Free buffer */
+    Xfree((char*) buf);
+}
+
+/************************************************************************/
+
+void glPolygonStipple(const GLubyte *mask)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP);
+    cmdlen = __GLX_PAD(__GLX_POLYGONSTIPPLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    __GLX_BEGIN(X_GLrop_PolygonStipple,cmdlen);
+    pc += __GLX_RENDER_HDR_SIZE;
+    pixelHeaderPC = pc;
+    pc += __GLX_PIXEL_HDR_SIZE;
+    (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
+		     mask, pc, pixelHeaderPC);
+    __GLX_END(__GLX_PAD(compsize));
+}
+
+void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
+	      GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP);
+    cmdlen = __GLX_PAD(__GLX_BITMAP_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_FLOAT(8,xorig);
+	__GLX_PUT_FLOAT(12,yorig);
+	__GLX_PUT_FLOAT(16,xmove);
+	__GLX_PUT_FLOAT(20,ymove);
+	pc += __GLX_BITMAP_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX,
+			     GL_BITMAP, bitmap, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen+4);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_FLOAT(8,xorig);
+	__GLX_PUT_FLOAT(12,yorig);
+	__GLX_PUT_FLOAT(16,xmove);
+	__GLX_PUT_FLOAT(20,ymove);
+	pc += __GLX_BITMAP_HDR_SIZE;
+	SendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX,
+		       GL_BITMAP, bitmap, pc, pixelHeaderPC);
+    }
+}
+
+void glTexImage1D(GLenum target, GLint level, GLint components,
+		  GLsizei width, GLint border, GLenum format, GLenum type,
+		  const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (target == GL_PROXY_TEXTURE_1D) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, 1, 1, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,1);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (image != NULL) {
+	    SendLargeImage(gc, compsize, 1, width, 1, 1, format,
+			   type, image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    {
+		GLubyte *pc = pixelHeaderPC;
+		__GLX_PUT_CHAR(0,GL_FALSE);
+		__GLX_PUT_CHAR(1,GL_FALSE);
+		__GLX_PUT_CHAR(2,0);
+		__GLX_PUT_CHAR(3,0);
+		__GLX_PUT_LONG(4,0);
+		__GLX_PUT_LONG(8,0);
+		__GLX_PUT_LONG(12,0);
+		__GLX_PUT_LONG(16,1);
+	    }
+	    SendLargeNULLImage(gc, compsize, width, 1, 1, format,
+			       type, image, pc, pixelHeaderPC);
+	}
+    }
+}
+
+void glTexImage2D(GLenum target, GLint level, GLint components,
+		  GLsizei width, GLsizei height, GLint border, GLenum format,
+		  GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (target == GL_PROXY_TEXTURE_2D ||
+        target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, height, 1, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (image != NULL) {
+	    SendLargeImage(gc, compsize, 2, width, height, 1, format,
+			   type, image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    {
+		GLubyte *pc = pixelHeaderPC;
+		__GLX_PUT_CHAR(0,GL_FALSE);
+		__GLX_PUT_CHAR(1,GL_FALSE);
+		__GLX_PUT_CHAR(2,0);
+		__GLX_PUT_CHAR(3,0);
+		__GLX_PUT_LONG(4,0);
+		__GLX_PUT_LONG(8,0);
+		__GLX_PUT_LONG(12,0);
+		__GLX_PUT_LONG(16,1);
+	    }
+	    SendLargeNULLImage(gc, compsize, width, height, 1, format,
+			       type, image, pc, pixelHeaderPC);
+	}
+    }
+}
+
+void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type,
+		  const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_DRAWPIXELS_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_LONG(8,format);
+	__GLX_PUT_LONG(12,type);
+	pc += __GLX_DRAWPIXELS_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen+4);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_LONG(8,format);
+	__GLX_PUT_LONG(12,type);
+	pc += __GLX_DRAWPIXELS_HDR_SIZE;
+	SendLargeImage(gc, compsize, 2, width, height, 1, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+static void __glx_TexSubImage1D2D(GLshort opcode, GLenum target, GLint level,
+			GLint xoffset, GLint yoffset, GLsizei width, 	
+			GLsizei height, GLenum format, GLenum type, 	
+			const GLvoid *image, GLint dim)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (image == NULL) {
+	compsize = 0;
+    } else {
+        compsize = __glImageSize(width, height, 1, format, type);
+    }
+
+    cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,width);
+	__GLX_PUT_LONG(20,height);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(32,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(32,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, 
+			     pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,width);
+	__GLX_PUT_LONG(20,height);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(32,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(32,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_HDR_SIZE;
+	SendLargeImage(gc, compsize, dim, width, height, 1,
+		       format, type, image, pc, pixelHeaderPC);
+    }
+}
+	
+void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, 
+			GLsizei width, GLenum format, GLenum type,
+		      	const GLvoid *image)
+{
+    __glx_TexSubImage1D2D(X_GLrop_TexSubImage1D, target, level, xoffset, 
+			 0, width, 1, format, type, image, 1);
+}
+
+void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, 
+			GLint yoffset, GLsizei width, GLsizei height, 
+			GLenum format, GLenum type, const GLvoid *image)
+{
+    __glx_TexSubImage1D2D(X_GLrop_TexSubImage2D, target, level, xoffset, 
+			 yoffset, width, height, format, type, image, 2);
+}
+
+void glColorTable(GLenum target, GLenum internalformat, GLsizei width,
+		  GLenum format, GLenum type, const GLvoid *table)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    switch (target) {
+	case GL_PROXY_TEXTURE_1D:
+	case GL_PROXY_TEXTURE_2D:
+	case GL_PROXY_TEXTURE_3D:
+	case GL_PROXY_COLOR_TABLE:
+	case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
+	case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
+	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+	    compsize = 0;
+	    break;
+	default:
+	    compsize = __glImageSize(width, 1, 1, format, type);
+	    break;
+    }
+    cmdlen = __GLX_PAD(__GLX_COLOR_TABLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) {
+	 return;
+    }
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+        /* Use GLXRender protocol to send small command */
+        __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorTable, (short)cmdlen);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, (long)internalformat);
+        __GLX_PUT_LONG(8, width);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_TABLE_HDR_SIZE;
+        if (compsize > 0 && table != NULL) {
+            (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, pc,
+                             pixelHeaderPC);
+        } else {
+            /* Setup default store modes */
+            GLubyte *pc = pixelHeaderPC;
+            __GLX_PUT_CHAR(0, GL_FALSE);
+            __GLX_PUT_CHAR(1, GL_FALSE);
+            __GLX_PUT_CHAR(2, 0);
+            __GLX_PUT_CHAR(3, 0);
+            __GLX_PUT_LONG(4, 0);
+            __GLX_PUT_LONG(8, 0);
+            __GLX_PUT_LONG(12, 0);
+            __GLX_PUT_LONG(16, 1);
+        }
+        __GLX_END(__GLX_PAD(compsize));
+    } else {
+        /* Use GLXRenderLarge protocol to send command */
+        __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorTable, cmdlen+4);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, (long)internalformat);
+        __GLX_PUT_LONG(8, width);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_TABLE_HDR_SIZE;
+        SendLargeImage(gc, compsize, 1, width, 1, 1, format,
+                       type, table, pc, pixelHeaderPC);
+    }
+}
+
+void glColorSubTable(GLenum target, GLsizei start, GLsizei count,
+		     GLenum format, GLenum type, const GLvoid *table)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(count, 1, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_COLOR_SUBTABLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) {
+	 return;
+    }
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+        /* Use GLXRender protocol to send small command */
+        __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorSubTable, (short)cmdlen);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, start);
+        __GLX_PUT_LONG(8, count);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_SUBTABLE_HDR_SIZE;
+        if (compsize > 0 && table != NULL) {
+            (*gc->fillImage)(gc, 1, start+count, 1, 1, format, type, table, pc,
+                             pixelHeaderPC);
+        } else {
+            /* Setup default store modes */
+            GLubyte *pc = pixelHeaderPC;
+            __GLX_PUT_CHAR(0, GL_FALSE);
+            __GLX_PUT_CHAR(1, GL_FALSE);
+            __GLX_PUT_CHAR(2, 0);
+            __GLX_PUT_CHAR(3, 0);
+            __GLX_PUT_LONG(4, 0);
+            __GLX_PUT_LONG(8, 0);
+            __GLX_PUT_LONG(12, 0);
+            __GLX_PUT_LONG(16, 1);
+        }
+        __GLX_END(__GLX_PAD(compsize));
+    } else {
+        /* Use GLXRenderLarge protocol to send command */
+        __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorSubTable, cmdlen+4);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, start);
+        __GLX_PUT_LONG(8, count);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_SUBTABLE_HDR_SIZE;
+        SendLargeImage(gc, compsize, 1, start+count, 1, 1, format,
+                       type, table, pc, pixelHeaderPC);
+    }
+}
+
+static void __glx_ConvolutionFilter1D2D(GLshort opcode, GLint dim,
+			GLenum target,
+			GLenum internalformat,
+			GLsizei width, GLsizei height,
+			GLenum format, GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += __GLX_CONV_FILT_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, dim, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += __GLX_CONV_FILT_HDR_SIZE;
+	SendLargeImage(gc, compsize, dim, width, height, 1, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+void glConvolutionFilter1D(GLenum target, GLenum internalformat,
+				GLsizei width, GLenum format,
+				GLenum type, const GLvoid *image)
+{
+     __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter1D, 1, target, 
+				 internalformat, width, 1, format, type,
+				 image);
+}
+
+void glConvolutionFilter2D(GLenum target, GLenum internalformat,
+				GLsizei width, GLsizei height, GLenum format,
+				GLenum type, const GLvoid *image)
+{
+     __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
+				internalformat, width, height, format, type,
+				image);
+}
+
+void glSeparableFilter2D(GLenum target, GLenum internalformat,
+				GLsizei width, GLsizei height, GLenum format,
+				GLenum type, const GLvoid *row,
+				const GLvoid *column)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLuint compsize2, hdrlen, totalhdrlen, image1len, image2len;
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, 1, 1, format, type);
+    compsize2 = __glImageSize(height, 1, 1, format, type);
+    totalhdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
+    hdrlen = __GLX_PAD(__GLX_CONV_FILT_HDR_SIZE);
+    image1len = __GLX_PAD(compsize);
+    image2len = __GLX_PAD(compsize2);
+    cmdlen = totalhdrlen + image1len + image2len;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_SeparableFilter2D, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type,
+			     row, pc, pixelHeaderPC);
+	    pc += image1len;
+	}
+	if (compsize2 > 0) {
+            (*gc->fillImage)(gc, 1, height, 1, 1, format, type,
+			     column, pc, NULL);
+	    pc += image2len;
+	}
+	if ((compsize == 0) && (compsize2 == 0)) {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(0);
+    } else {
+	GLint bufsize;
+
+	bufsize = image1len + image2len;
+
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_SeparableFilter2D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+
+	if (!gc->fastImageUnpack) {
+	    /* Allocate a temporary holding buffer */
+	    GLubyte *buf = (GLubyte *) Xmalloc(bufsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type, row, buf, pixelHeaderPC);
+
+	    (*gc->fillImage)(gc, 1, height, 1, 1, format, type, column,
+				 buf + image1len, pixelHeaderPC);
+
+	    /* Send large command */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), buf, bufsize);
+	    /* Free buffer */
+	    Xfree((char*) buf);
+	} else {
+	    /* Just send the data straight as is */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), pc, bufsize);
+	}
+    }
+}
+
+void glTexImage3D(GLenum target, GLint level, GLint internalformat,
+		  GLsizei width, GLsizei height, GLsizei depth, GLint border,
+		  GLenum format, GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ((target == GL_PROXY_TEXTURE_3D) || (image == NULL)) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, height, depth, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_3D_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,depth);
+	__GLX_PUT_LONG(24,0);    /* size4d */
+	__GLX_PUT_LONG(28,border);
+	__GLX_PUT_LONG(32,format);
+	__GLX_PUT_LONG(36,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(40,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(40,GL_FALSE);
+	}
+	pc += __GLX_TEXIMAGE_3D_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 3, width, height, depth, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,0);
+	    __GLX_PUT_LONG(20,0);
+	    __GLX_PUT_LONG(24,0);
+	    __GLX_PUT_LONG(28,0);
+	    __GLX_PUT_LONG(32,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,depth);
+	__GLX_PUT_LONG(24,0);    /* size4d */
+	__GLX_PUT_LONG(28,border);
+	__GLX_PUT_LONG(32,format);
+	__GLX_PUT_LONG(36,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(40,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(40,GL_FALSE);
+	}
+	pc += __GLX_TEXIMAGE_3D_HDR_SIZE;
+	SendLargeImage(gc, compsize, 3, width, height, depth, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+		     GLint zoffset, GLsizei width, GLsizei height,
+		     GLsizei depth, GLenum format, GLenum type,
+		     const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (image == NULL) {
+	compsize = 0;
+    } else {
+        compsize = __glImageSize(width, height, depth, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_3D_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,zoffset);
+	__GLX_PUT_LONG(20,0); /* woffset */
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,depth);
+	__GLX_PUT_LONG(36,0);      /* size4d */
+	__GLX_PUT_LONG(40,format);
+	__GLX_PUT_LONG(44,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(48,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(48,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 3, width, height, depth, format, type, image,
+			     pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,0);
+	    __GLX_PUT_LONG(20,0);
+	    __GLX_PUT_LONG(24,0);
+	    __GLX_PUT_LONG(28,0);
+	    __GLX_PUT_LONG(32,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D,
+						 cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,zoffset);
+	__GLX_PUT_LONG(20,0);    /* woffset */
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,depth);
+	__GLX_PUT_LONG(36,0);    /* size4d */
+	__GLX_PUT_LONG(40,format);
+	__GLX_PUT_LONG(44,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(48,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(48,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE;
+	SendLargeImage(gc, compsize, 3, width, height, depth, format, type,
+		       image, pc, pixelHeaderPC);
+    }
+}