Pixel oriented render functions are now generated by the

glX_proto_send.py script.  This eliminates ~600 lines of non-generated
code.  With proper compiler optimization settings, it also decreases the
size of libGL.so by about 3KB.

4 files changed, 533 insertions, 45 deletions

diff --git a/src/mesa/glapi/glX_XML.py b/src/mesa/glapi/glX_XML.py
index 3534132053..6da454c58c 100644
--- a/src/mesa/glapi/glX_XML.py
+++ b/src/mesa/glapi/glX_XML.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python2
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -400,6 +400,36 @@ class glXFunction(gl_XML.glFunction):
 
 	def command_payload_length(self):
 		size = 0
+
+		if self.image:
+			[dim, junk, junk, junk, junk] = self.dimensions()
+			
+			# The base size is the size of the pixel pack info
+			# header used by images with the specified number
+			# of dimensions.
+
+			if dim <=  2:
+				size = 20
+			elif dim <= 4:
+				size = 36
+			else:
+				raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
+
+			if self.image.img_null_flag:
+				size += 4
+
+			if self.image.img_pad_dimensions:
+				size += 4 * (dim & 1)
+				
+				# If the image has offset parameters, like
+				# TexSubImage1D or TexSubImage3D, they need to
+				# be padded out as well.
+
+				if self.image.img_xoff:
+					size += 4 * (dim & 1)
+					
+
+	
 		size_string = ""
 		for p in gl_XML.glFunction.parameterIterator(self):
 			if p.is_output: continue
@@ -507,6 +537,60 @@ class glXFunction(gl_XML.glFunction):
 		return self.fn_return_type != 'void' or self.output != None
 
 
+	def dimensions(self):
+		"""Determine the dimensions of an image.
+		
+		Returns a tuple representing the number of dimensions and the
+		string name of each of the dimensions of an image,  If the
+		function is not a pixel function, the number of dimensions
+		will be zero."""
+
+		if not self.image:
+			return [0, "0", "0", "0", "0"]
+		else:
+			dim = 1
+			w = self.image.width
+
+			if self.image.height:
+				dim = 2
+				h = self.image.height
+			else:
+				h = "1"
+
+			if self.image.depth:
+				dim = 3
+				d = self.image.depth
+			else:
+				d = "1"
+			
+			if self.image.extent:
+				dim = 4
+				e = self.image.extent
+			else:
+				e = "1"
+
+			return [dim, w, h, d, e]
+
+
+	def pad_after(self, p):
+		"""Returns the name of the field inserted after the
+		specified field to pad out the command header."""
+
+		if self.image and self.image.img_pad_dimensions:
+			if not self.image.height:
+				if p.name == self.image.width:
+					return "height"
+				elif p.name == self.image.img_xoff:
+					return "yoffset"
+			elif not self.image.extent:
+				if p.name == self.image.depth:
+					# Should this be "size4d"?
+					return "extent"
+				elif p.name == self.image.img_zoff:
+					return "woffset"
+		return None
+
+		
 class GlxProto(gl_XML.FilterGLAPISpecBase):
 	name = "glX_proto_send.py (from Mesa)"
 
diff --git a/src/mesa/glapi/glX_proto_send.py b/src/mesa/glapi/glX_proto_send.py
index 7a93ef10b6..e7cda2f779 100644
--- a/src/mesa/glapi/glX_proto_send.py
+++ b/src/mesa/glapi/glX_proto_send.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python2
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -32,15 +32,87 @@ from xml.sax.handler import feature_namespaces
 import gl_XML
 import glX_XML
 import license
-import sys, getopt
+import sys, getopt, copy
+
+def hash_pixel_function(func):
+	"""Generate a 'unique' key for a pixel function.  The key is based on
+	the parameters written in the command packet.  This includes any
+	padding that might be added for the original function and the 'NULL
+	image' flag."""
+
+	[dim, junk, junk, junk, junk] = func.dimensions()
+
+	d = (dim + 1) & ~1
+	h = "%uD%uD_" % (d - 1, d)
+
+	for p in func.parameterIterator(1, 1):
+		h = "%s%u" % (h, p.size())
+
+		if func.pad_after(p):
+			h += "4"
+
+	if func.image.img_null_flag:
+		h += "_NF"
+
+	n = func.name.replace("%uD" % (dim), "")
+	n = "__glx_%s_%uD%uD" % (n, d - 1, d)
+	return [h, n]
+
+
+class glXPixelFunctionUtility(glX_XML.glXFunction):
+	"""Dummy class used to generate pixel "utility" functions that are
+	shared by multiple dimension image functions.  For example, these
+	objects are used to generate shared functions used to send GLX
+	protocol for TexImage1D and TexImage2D, TexSubImage1D and
+	TexSubImage2D, etc."""
+
+	def __init__(self, func, name):
+		# The parameters to the utility function are the same as the
+		# parameters to the real function except for the added "pad"
+		# parameters.
+
+		self.name = name
+		self.image = copy.copy(func.image)
+		self.fn_parameters = []
+		for p in gl_XML.glFunction.parameterIterator(func):
+			self.fn_parameters.append(p)
+
+			pad_name = func.pad_after(p)
+			if pad_name:
+				pad = copy.copy(p)
+				pad.name = pad_name
+				self.fn_parameters.append(pad)
+				
+
+		if self.image.height == None:
+			self.image.height = "height"
+
+		if self.image.img_yoff == None:
+			self.image.img_yoff = "yoffset"
+
+		if func.image.depth:
+			if self.image.extent == None:
+				self.image.extent = "extent"
+
+			if self.image.img_woff == None:
+				self.image.img_woff = "woffset"
+
+
+		self.set_return_type( func.fn_return_type )
+		self.glx_rop = ~0
+		self.can_be_large = func.can_be_large
+		self.count_parameters = func.count_parameters
+		self.counter = func.counter
+		return
 
 
 class PrintGlxProtoStubs(glX_XML.GlxProto):
 	def __init__(self):
 		glX_XML.GlxProto.__init__(self)
 		self.last_category = ""
-		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004", "IBM")
+		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004, 2005", "IBM")
 		self.generic_sizes = [3, 4, 6, 8, 12, 16, 24, 32]
+		self.pixel_stubs = {}
 		return
 
 	def printRealHeader(self):
@@ -48,7 +120,7 @@ class PrintGlxProtoStubs(glX_XML.GlxProto):
 		print '#include <GL/gl.h>'
 		print '#include "indirect.h"'
 		print '#include "glxclient.h"'
-		print '#include "size.h"'
+		print '#include "indirect_size.h"'
 		print '#include <GL/glxproto.h>'
 		print ''
 		print '#define __GLX_PAD(n) (((n) + 3) & ~3)'
@@ -125,6 +197,19 @@ setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
     req->contextTag = gc->currentContextTag;
     return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
 }
+
+const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+#define zero                        (__glXDefaultPixelStore+0)
+#define one                         (__glXDefaultPixelStore+8)
+#define default_pixel_store_1D      (__glXDefaultPixelStore+4)
+#define default_pixel_store_1D_size 20
+#define default_pixel_store_2D      (__glXDefaultPixelStore+4)
+#define default_pixel_store_2D_size 20
+#define default_pixel_store_3D      (__glXDefaultPixelStore+0)
+#define default_pixel_store_3D_size 36
+#define default_pixel_store_4D      (__glXDefaultPixelStore+0)
+#define default_pixel_store_4D_size 36
 """
 
 		for size in self.generic_sizes:
@@ -135,7 +220,10 @@ setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
 		if f.fn_offset < 0 or f.handcode or f.ignore: return
 
 		if f.glx_rop != 0 or f.vectorequiv != None:
-			self.printRenderFunction(f)
+			if f.image:
+				self.printPixelFunction(f)
+			else:
+				self.printRenderFunction(f)
 		elif f.glx_sop != 0 or f.glx_vendorpriv != 0:
 			self.printSingleFunction(f)
 		else:
@@ -182,8 +270,38 @@ generic_%u_byte( GLint rop, const void * ptr )
 		return offset
 
 
-	def large_emit_begin(self, indent, f):
-		print '%s    const GLint op = %s;' % (indent, f.opcode_real_name())
+	def pixel_emit_args(self, f, pc, indent, adjust, dim, large):
+		"""Emit the arguments for a pixel function.  This differs from
+		common_emit_args in that pixel functions may require padding
+		be inserted (i.e., for the missing width field for
+		TexImage1D), and they may also require a 'NULL image' flag
+		be inserted before the image data."""
+
+		offset = 0
+		for p in f.parameterIterator(1, 1):
+			self.common_emit_one_arg(p, offset, pc, indent, adjust)
+			offset += p.size()
+
+			if f.pad_after(p):
+				print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust)
+				offset += 4
+
+		if f.image.img_null_flag:
+			if large:
+				print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust)
+			else:
+				print '%s    (void) memcpy((void *)(%s + %u), (void *)((%s == NULL) ? one : zero), 4);' % (indent, pc, offset + adjust, f.image.name)
+
+			offset += 4
+
+		return offset
+
+
+	def large_emit_begin(self, indent, f, op_name = None):
+		if not op_name:
+			op_name = f.opcode_real_name()
+
+		print '%s    const GLint op = %s;' % (indent, op_name)
 		print '%s    const GLuint cmdlenLarge = cmdlen + 4;' % (indent)
 		print '%s    GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);' % (indent)
 		print '%s    (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);' % (indent)
@@ -199,9 +317,7 @@ generic_%u_byte( GLint rop, const void * ptr )
 		print '{'
 
 
-	def common_func_print_header(self, f):
-		self.common_func_print_just_header(f)
-
+	def common_func_print_just_start(self, f):
 		print '    __GLXcontext * const gc = __glXGetCurrentContext();'
 		
 		# The only reason that single and vendor private commands need
@@ -224,6 +340,15 @@ generic_%u_byte( GLint rop, const void * ptr )
 
 		if f.count_parameters != None:
 			print '    const GLuint compsize = __gl%s_size(%s);' % (f.name, f.count_parameters)
+		elif f.image:
+			[dim, w, h, d, junk] = f.dimensions()
+			
+			compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, f.image.img_format, f.image.img_type, f.image.img_target)
+			if not f.image.img_send_null:
+				compsize = '(%s != NULL) ? %s : 0' % (f.image.name, compsize)
+
+			print '    const GLuint compsize = %s;' % (compsize)
+
 
 		print '    const GLuint cmdlen = %s;' % (f.command_length())
 
@@ -241,6 +366,12 @@ generic_%u_byte( GLint rop, const void * ptr )
 			return 0
 
 
+	def common_func_print_header(self, f):
+		self.common_func_print_just_header(f)
+		return self.common_func_print_just_start(f)
+
+
+
 	def printSingleFunction(self, f):
 		self.common_func_print_header(f)
 
@@ -284,6 +415,203 @@ generic_%u_byte( GLint rop, const void * ptr )
 		return
 
 
+	def printPixelFunction(self, f):
+		"""This function could use some major refactoring. :("""
+
+		# There is a code-space optimization that we can do here.
+		# Functions that are marked img_pad_dimensions have a version
+		# with an odd number of dimensions and an even number of
+		# dimensions.  TexSubImage1D and TexSubImage2D are examples.
+		# We can emit a single function that does both, and have the
+		# real functions call the utility function with the correct
+		# parameters.
+		#
+		# The only quirk to this is that utility funcitons will be
+		# generated for 3D and 4D functions, but 4D (e.g.,
+		# GL_SGIS_texture4D) isn't typically supported.  This is
+		# probably not an issue.  However, it would be possible to
+		# look at the total set of functions and determine if there
+		# is another function that would actually use the utility
+		# function.  If not, then fallback to the normal way of
+		# generating code.
+
+		if f.image.img_pad_dimensions:
+			# Determine the hash key and the name for the utility
+			# function that is used to implement the real
+			# function.
+
+			[h, n] = hash_pixel_function(f)
+
+			
+			# If the utility function is not yet known, generate
+			# it.
+
+			if not self.pixel_stubs.has_key(h):
+				self.pixel_stubs[h] = n
+				pixel_func = glXPixelFunctionUtility(f, n)
+
+				print 'static void'
+				print '%s( unsigned opcode, unsigned dim, %s )' % (n, pixel_func.get_parameter_string())
+				print '{'
+
+				if self.common_func_print_just_start(pixel_func):
+					indent = "    "
+					trailer = "    }"
+				else:
+					indent = ""
+					trailer = None
+
+
+				if pixel_func.can_be_large:
+					print '%s    if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent)
+					print '%s        if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent)
+					print '%s            (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent)
+					print '%s        }' % (indent)
+					indent += "    "
+
+				[dim, width, height, depth, extent] = pixel_func.dimensions()
+
+				if dim < 3:
+					adjust = 20 + 4
+				else:
+					adjust = 36 + 4
+
+
+				print '%s    emit_header(gc->pc, opcode, cmdlen);' % (indent)
+
+				offset = self.pixel_emit_args(pixel_func, "gc->pc", indent, adjust, dim, 0)
+
+				[s, junk] = pixel_func.command_payload_length()
+
+				pixHeaderPtr = "gc->pc + 4"
+				pcPtr = "gc->pc + %u" % (s + 4)
+
+				if pixel_func.image.img_send_null:
+					condition = '(compsize > 0) && (%s != NULL)' % (pixel_func.image.name)
+				else:
+					condition = 'compsize > 0'
+
+				print '%s    if (%s) {' % (indent, condition)
+				print '%s        (*gc->fillImage)(gc, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, pixel_func.image.img_format, pixel_func.image.img_type, pixel_func.image.name, pcPtr, pixHeaderPtr)
+				print '%s    }' % (indent)
+				print '%s    else {' % (indent)
+				print '%s        (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim)
+				print '%s    }' % (indent)
+
+				print '%s    gc->pc += cmdlen;' % (indent)
+				print '%s    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent)
+
+				if f.can_be_large:
+					adjust += 4
+
+					print '%s}' % (indent)
+					print '%selse {' % (indent)
+
+					self.large_emit_begin(indent, pixel_func, "opcode")
+					offset = self.pixel_emit_args(pixel_func, "pc", indent, adjust, dim, 1)
+
+					pixHeaderPtr = "pc + 8"
+					pcPtr = "pc + %u" % (s + 8)
+
+					print '%s    __glXSendLargeImage(gc, compsize, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
+
+					print '%s}' % (indent)
+
+				if trailer: print trailer
+				print '}'
+				print ''
+
+
+
+			# Generate the real function as a call to the
+			# utility function.
+
+			self.common_func_print_just_header(f)
+
+			[dim, junk, junk, junk, junk] = f.dimensions()
+
+			p_string = ""
+			for p in gl_XML.glFunction.parameterIterator(f):
+				p_string += ", " + p.name
+
+				if f.pad_after(p):
+					p_string += ", 1"
+
+			print '    %s(%s, %u%s );' % (n, f.opcode_name(), dim, p_string)
+			print '}'
+			print ''
+			return
+
+
+		if self.common_func_print_header(f):
+			indent = "    "
+			trailer = "    }"
+		else:
+			indent = ""
+			trailer = None
+
+
+		if f.can_be_large:
+			print '%s    if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent)
+			print '%s        if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent)
+			print '%s            (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent)
+			print '%s        }' % (indent)
+			indent += "    "
+
+		[dim, width, height, depth, extent] = f.dimensions()
+
+		if dim < 3:
+			adjust = 20 + 4
+		else:
+			adjust = 36 + 4
+
+
+		print '%s    emit_header(gc->pc, %s, cmdlen);' % (indent, f.opcode_real_name())
+
+		offset = self.pixel_emit_args(f, "gc->pc", indent, adjust, dim, 0)
+
+		[s, junk] = f.command_payload_length()
+
+		pixHeaderPtr = "gc->pc + 4"
+		pcPtr = "gc->pc + %u" % (s + 4)
+
+		if f.image.img_send_null:
+			condition = '(compsize > 0) && (%s != NULL)' % (f.image.name)
+		else:
+			condition = 'compsize > 0'
+
+		print '%s    if (%s) {' % (indent, condition)
+		print '%s        (*gc->fillImage)(gc, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
+		print '%s    }' % (indent)
+		print '%s    else {' % (indent)
+		print '%s        (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim)
+		print '%s    }' % (indent)
+
+		print '%s    gc->pc += cmdlen;' % (indent)
+		print '%s    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent)
+
+		if f.can_be_large:
+			adjust += 4
+
+			print '%s}' % (indent)
+			print '%selse {' % (indent)
+
+			self.large_emit_begin(indent, f)
+			offset = self.pixel_emit_args(f, "pc", indent, adjust, dim, 1)
+
+			pixHeaderPtr = "pc + 8"
+			pcPtr = "pc + %u" % (s + 8)
+
+			print '%s    __glXSendLargeImage(gc, compsize, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
+
+			print '%s}' % (indent)
+
+		if trailer: print trailer
+		print '}'
+		print ''
+		return
+
+
 	def printRenderFunction(self, f):
 		# There is a class of GL functions that take a single pointer
 		# as a parameter.  This pointer points to a fixed-size chunk
diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml
index d87813600c..b594ca3763 100644
--- a/src/mesa/glapi/gl_API.xml
+++ b/src/mesa/glapi/gl_API.xml
@@ -24,6 +24,20 @@
                    counter  CDATA #IMPLIED
                    count_scale  CDATA #IMPLIED
                    output   CDATA #IMPLIED
+		   img_width     CDATA #IMPLIED
+		   img_height    CDATA #IMPLIED
+		   img_depth     CDATA #IMPLIED
+		   img_extent    CDATA #IMPLIED
+		   img_xoff      CDATA #IMPLIED
+		   img_yoff      CDATA #IMPLIED
+		   img_zoff      CDATA #IMPLIED
+		   img_woff      CDATA #IMPLIED
+		   img_format    CDATA #IMPLIED
+		   img_type      CDATA #IMPLIED
+		   img_target    CDATA #IMPLIED
+		   img_send_null CDATA #IMPLIED
+		   img_null_flag CDATA #IMPLIED
+		   img_pad_dimensions CDATA #IMPLIED
                    variable_param  CDATA #IMPLIED>
 <!ATTLIST return   type     CDATA #REQUIRED>
 <!ATTLIST glx      rop      CDATA #IMPLIED
@@ -58,6 +72,24 @@ param:
          single enum parameter.  Most of the gl*Parameter[if]v functions use
 	 this.  Additionally, the enums that can be passed should be properly
 	 annotated.
+     img_width / img_height / img_depth / img_extent - name of parameters
+         (or hardcoded integer) used for the dimensions of pixel data.
+     img_xoff / img_yoff / img_zoff / img_woff - name of parameters used
+         for x, y, z, and w offsets of pixel data.
+     img_format - name of parameter used as the pixel data format.
+     img_type - name of parameter used as the pixel data type.
+     img_target - name of parameter used as a texture target.  Non-texture
+        pixel data should hardcode 0.
+     img_send_null - boolean flag to determine if blank pixel data should
+        be sent when a NULL pointer is passed.  This is only used by
+	TexImage1D and TexImage2D.
+     img_null_flag - boolean flag to determine if an extra flag is used to
+        determine if a NULL pixel pointer was passed.  This is used by
+	TexSubImage1D, TexSubImage2D, TexImage3D and others.
+     img_pad_dimensions - boolean flag to determine if dimension data and
+        offset data should be padded to the next even number of dimensions.
+	For example, this will insert an empty "height" field after the
+	"width" field in the protocol for TexImage1D.
 
 glx:
      rop - Opcode value for "render" commands
@@ -73,8 +105,8 @@ glx:
          return value data (e.g., glGetLightfv).  Other single commands take
          reply data only as an array (e.g., glGetClipPlane).
      handcode - some functions are just too complicated to generate 
-         (e.g., glTexImage2D) or operate only on client-side data (e.g.,
-         glVertexPointer) and must be handcoded.
+         (e.g., glSeperableFilter2D) or operate only on client-side data
+         (e.g., glVertexPointer) and must be handcoded.
      ignore - some functions have an entry in the dispatch table, but aren't
          suitable for protocol implementation (e.g., glLockArraysEXT).  This
 	 also applies to functions that don't have any GLX protocol specified
@@ -775,8 +807,8 @@ glx:
         <param name="yorig" type="GLfloat"/>
         <param name="xmove" type="GLfloat"/>
         <param name="ymove" type="GLfloat"/>
-        <param name="bitmap" type="const GLubyte *"/>
-        <glx rop="5" handcode="true"/>
+        <param name="bitmap" type="const GLubyte *" img_width="width" img_height="height" img_format="GL_COLOR_INDEX" img_type="GL_BITMAP" img_target="0" img_pad_dimensions="false"/>
+        <glx rop="5" large="true"/>
     </function>
 
     <function name="Color3b" offset="9" vectorequiv="Color3bv">
@@ -1706,8 +1738,8 @@ glx:
     </function>
 
     <function name="PolygonStipple" offset="175">
-        <param name="mask" type="const GLubyte *"/>
-        <glx rop="102" handcode="true"/>
+        <param name="mask" type="const GLubyte *" img_width="32" img_height="32" img_format="GL_COLOR_INDEX" img_type="GL_BITMAP" img_target="0" img_pad_dimensions="false"/>
+        <glx rop="102"/>
     </function>
 
     <function name="Scissor" offset="176">
@@ -1759,8 +1791,8 @@ glx:
         <param name="border" type="GLint"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="109" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_format="format" img_type="type" img_target="target" img_send_null="true" img_pad_dimensions="true"/>
+        <glx rop="109" large="true"/>
     </function>
 
     <function name="TexImage2D" offset="183">
@@ -1772,8 +1804,8 @@ glx:
         <param name="border" type="GLint"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="110" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="target" img_send_null="true" img_pad_dimensions="true"/>
+        <glx rop="110" large="true"/>
     </function>
 
     <function name="TexEnvf" offset="184">
@@ -2249,8 +2281,8 @@ glx:
         <param name="height" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="173" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="0" img_pad_dimensions="false"/>
+        <glx rop="173" large="true"/>
     </function>
 
     <function name="GetBooleanv" offset="258">
@@ -2826,8 +2858,8 @@ glx:
         <param name="width" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="4099" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_xoff="xoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
+        <glx rop="4099" large="true"/>
     </function>
 
     <function name="TexSubImage2D" offset="333">
@@ -2839,8 +2871,8 @@ glx:
         <param name="height" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="4100" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_xoff="xoffset" img_yoff="yoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
+        <glx rop="4100" large="true"/>
     </function>
 
     <function name="AreTexturesResident" offset="322">
@@ -3035,8 +3067,8 @@ glx:
         <param name="width" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="table" type="const GLvoid *"/>
-        <glx rop="2053" handcode="true"/>
+        <param name="table" type="const GLvoid *" img_width="width" img_pad_dimensions="false" img_format="format" img_type="type" img_target="target"/>
+        <glx rop="2053" large="true"/>
     </function>
 
     <function name="ColorTableParameterfv" offset="340">
@@ -3090,8 +3122,8 @@ glx:
         <param name="count" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="data" type="const GLvoid *"/>
-        <glx rop="195" handcode="true"/>
+        <param name="data" type="const GLvoid *" img_width="count" img_pad_dimensions="false" img_format="format" img_type="type" img_target="target"/>
+        <glx rop="195" large="true"/>
     </function>
 
     <function name="CopyColorSubTable" offset="347">
@@ -3109,8 +3141,8 @@ glx:
         <param name="width" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="image" type="const GLvoid *"/>
-        <glx rop="4101" handcode="true"/>
+        <param name="image" type="const GLvoid *" img_width="width" img_format="format" img_type="type" img_target="target" img_pad_dimensions="true"/>
+        <glx rop="4101" large="true"/>
     </function>
 
     <function name="ConvolutionFilter2D" offset="349">
@@ -3120,8 +3152,8 @@ glx:
         <param name="height" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="image" type="const GLvoid *"/>
-        <glx rop="4102" handcode="true"/>
+        <param name="image" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="target" img_pad_dimensions="true"/>
+        <glx rop="4102" large="true"/>
     </function>
 
     <function name="ConvolutionParameterf" offset="350">
@@ -3296,8 +3328,8 @@ glx:
         <param name="border" type="GLint"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="4114" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
+        <glx rop="4114" large="true"/>
     </function>
 
     <function name="TexSubImage3D" offset="372">
@@ -3311,8 +3343,8 @@ glx:
         <param name="depth" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
-        <glx rop="4115" handcode="true"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_xoff="xoffset" img_yoff="yoffset" img_zoff="zoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
+        <glx rop="4115" large="true"/>
     </function>
 
     <function name="CopyTexSubImage3D" offset="373">
@@ -6545,7 +6577,7 @@ glx:
         <param name="border" type="GLint"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_extent="size4d" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
         <glx rop="2057" ignore="true"/>
     </function>
 
@@ -6562,7 +6594,7 @@ glx:
         <param name="size4d" type="GLsizei"/>
         <param name="format" type="GLenum"/>
         <param name="type" type="GLenum"/>
-        <param name="pixels" type="const GLvoid *"/>
+        <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_extent="size4d" img_xoff="xoffset" img_yoff="yoffset" img_zoff="zoffset" img_woff="woffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/>
         <glx rop="2058" ignore="true"/>
     </function>
 </category>
diff --git a/src/mesa/glapi/gl_XML.py b/src/mesa/glapi/gl_XML.py
index a58f285155..f984d5f87f 100644
--- a/src/mesa/glapi/gl_XML.py
+++ b/src/mesa/glapi/gl_XML.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python2
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -154,7 +154,45 @@ class glParameter( glItem ):
 		else:
 			self.is_output = 0
 
-		if self.p_count > 0 or self.counter != None or self.p_count_parameters != None :
+			
+		# Pixel data has special parameters.
+
+		self.width      = attrs.get('img_width',  None)
+		self.height     = attrs.get('img_height', None)
+		self.depth      = attrs.get('img_depth',  None)
+		self.extent     = attrs.get('img_extent', None)
+
+		self.img_xoff   = attrs.get('img_xoff',   None)
+		self.img_yoff   = attrs.get('img_yoff',   None)
+		self.img_zoff   = attrs.get('img_zoff',   None)
+		self.img_woff   = attrs.get('img_woff',   None)
+
+		self.img_format = attrs.get('img_format', None)
+		self.img_type   = attrs.get('img_type',   None)
+		self.img_target = attrs.get('img_target', None)
+
+		pad = attrs.get('img_pad_dimensions', "false")
+		if pad == "true":
+			self.img_pad_dimensions = 1
+		else:
+			self.img_pad_dimensions = 0
+
+
+		null_flag = attrs.get('img_null_flag', "false")
+		if null_flag == "true":
+			self.img_null_flag = 1
+		else:
+			self.img_null_flag = 0
+
+		send_null = attrs.get('img_send_null', "false")
+		if send_null == "true":
+			self.img_send_null = 1
+		else:
+			self.img_send_null = 0
+
+
+
+		if self.p_count > 0 or self.counter or self.p_count_parameters:
 			has_count = 1
 		else:
 			has_count = 0
@@ -193,7 +231,7 @@ class glParameter( glItem ):
 		to glCallLists, are not variable length arrays in this
 		sense."""
 
-		return (self.p_count_parameters != None) or (self.counter != None)
+		return self.p_count_parameters or self.counter or self.width
 
 
 	def is_array(self):
@@ -222,7 +260,7 @@ class glParameter( glItem ):
 
 
 	def size(self):
-		if self.p_count_parameters != None or self.counter != None or self.is_output:
+		if self.p_count_parameters or self.counter or self.width or self.is_output:
 			return 0
 		elif self.p_count == 0:
 			return self.p_type.size
@@ -241,6 +279,8 @@ class glParameter( glItem ):
 				pass
 			elif self.p_count_parameters != None and self.counter != None:
 				b_prod = self.counter
+			elif self.width:
+				return "compsize"
 			else:
 				raise RuntimeError("Parameter '%s' to function '%s' has size 0." % (self.name, self.context.name))
 
@@ -281,6 +321,7 @@ class glFunction( glItem ):
 	def __init__(self, context, name, attrs):
 		self.fn_alias = attrs.get('alias', None)
 		self.fn_parameters = []
+		self.image = None
 
 		temp = attrs.get('offset', None)
 		if temp == None or temp == "?":
@@ -318,6 +359,9 @@ class glFunction( glItem ):
 		if tag_name != "param":
 			raise RuntimeError("Trying to append '%s' to parameter list of function '%s'." % (tag_name, self.name))
 
+		if p.width:
+			self.image = p
+
 		self.fn_parameters.append(p)