pixman mesalib git update 26 jan 2011

8 files changed, 6615 insertions, 6617 deletions

diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 7f630e23c..ddad16a8e 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -1,3500 +1,3500 @@
-/*
- * mesa 3-D graphics library
- * Version:  7.6
- *
- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009  VMware, Inc.  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
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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 teximage.c
- * Texture image-related functions.
- */
-
-
-#include "glheader.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "enums.h"
-#include "fbobject.h"
-#include "framebuffer.h"
-#include "hash.h"
-#include "image.h"
-#include "imports.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "state.h"
-#include "texcompress.h"
-#include "texfetch.h"
-#include "teximage.h"
-#include "texstate.h"
-#include "texpal.h"
-#include "mtypes.h"
-
-
-/**
- * State changes which we care about for glCopyTex[Sub]Image() calls.
- * In particular, we care about pixel transfer state and buffer state
- * (such as glReadBuffer to make sure we read from the right renderbuffer).
- */
-#define NEW_COPY_TEX_STATE (_MESA_NEW_TRANSFER_STATE | \
-                            _NEW_BUFFERS | \
-                            _NEW_PIXEL)
-
-
-
-/**
- * We allocate texture memory on 512-byte boundaries so we can use MMX/SSE
- * elsewhere.
- */
-void *
-_mesa_alloc_texmemory(GLsizei bytes)
-{
-   return _mesa_align_malloc(bytes, 512);
-}
-
-
-/**
- * Free texture memory allocated with _mesa_alloc_texmemory()
- */
-void
-_mesa_free_texmemory(void *m)
-{
-   _mesa_align_free(m);
-}
-
-
-/*
- * Compute floor(log_base_2(n)).
- * If n < 0 return -1.
- */
-static int
-logbase2( int n )
-{
-   GLint i = 1;
-   GLint log2 = 0;
-
-   if (n < 0)
-      return -1;
-
-   if (n == 0)
-      return 0;
-
-   while ( n > i ) {
-      i *= 2;
-      log2++;
-   }
-   if (i != n) {
-      return log2 - 1;
-   }
-   else {
-      return log2;
-   }
-}
-
-
-
-/**
- * Return the simple base format for a given internal texture format.
- * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.
- *
- * \param ctx GL context.
- * \param internalFormat the internal texture format token or 1, 2, 3, or 4.
- *
- * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,
- * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.
- *
- * This is the format which is used during texture application (i.e. the
- * texture format and env mode determine the arithmetic used.
- *
- * XXX this could be static
- */
-GLint
-_mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )
-{
-   switch (internalFormat) {
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-         return GL_ALPHA;
-      case 1:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-         return GL_LUMINANCE;
-      case 2:
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-         return GL_LUMINANCE_ALPHA;
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-         return GL_INTENSITY;
-      case 3:
-      case GL_RGB:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-         return GL_RGB;
-      case 4:
-      case GL_RGBA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-         return GL_RGBA;
-      default:
-         ; /* fallthrough */
-   }
-
-   if (ctx->Extensions.EXT_texture_format_BGRA8888) {
-      switch (internalFormat) {
-         case GL_BGRA_EXT:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_paletted_texture) {
-      switch (internalFormat) {
-         case GL_COLOR_INDEX:
-         case GL_COLOR_INDEX1_EXT:
-         case GL_COLOR_INDEX2_EXT:
-         case GL_COLOR_INDEX4_EXT:
-         case GL_COLOR_INDEX8_EXT:
-         case GL_COLOR_INDEX12_EXT:
-         case GL_COLOR_INDEX16_EXT:
-            return GL_COLOR_INDEX;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_depth_texture) {
-      switch (internalFormat) {
-         case GL_DEPTH_COMPONENT:
-         case GL_DEPTH_COMPONENT16:
-         case GL_DEPTH_COMPONENT24:
-         case GL_DEPTH_COMPONENT32:
-            return GL_DEPTH_COMPONENT;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   switch (internalFormat) {
-   case GL_COMPRESSED_ALPHA:
-      return GL_ALPHA;
-   case GL_COMPRESSED_LUMINANCE:
-      return GL_LUMINANCE;
-   case GL_COMPRESSED_LUMINANCE_ALPHA:
-      return GL_LUMINANCE_ALPHA;
-   case GL_COMPRESSED_INTENSITY:
-      return GL_INTENSITY;
-   case GL_COMPRESSED_RGB:
-      return GL_RGB;
-   case GL_COMPRESSED_RGBA:
-      return GL_RGBA;
-   default:
-      ; /* fallthrough */
-   }
-         
-   if (ctx->Extensions.TDFX_texture_compression_FXT1) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_FXT1_3DFX:
-            return GL_RGB;
-         case GL_COMPRESSED_RGBA_FXT1_3DFX:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_compression_s3tc) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-            return GL_RGB;
-         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.S3_s3tc) {
-      switch (internalFormat) {
-         case GL_RGB_S3TC:
-         case GL_RGB4_S3TC:
-            return GL_RGB;
-         case GL_RGBA_S3TC:
-         case GL_RGBA4_S3TC:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.MESA_ycbcr_texture) {
-      if (internalFormat == GL_YCBCR_MESA)
-         return GL_YCBCR_MESA;
-   }
-
-   if (ctx->Extensions.ARB_texture_float) {
-      switch (internalFormat) {
-         case GL_ALPHA16F_ARB:
-         case GL_ALPHA32F_ARB:
-            return GL_ALPHA;
-         case GL_RGBA16F_ARB:
-         case GL_RGBA32F_ARB:
-            return GL_RGBA;
-         case GL_RGB16F_ARB:
-         case GL_RGB32F_ARB:
-            return GL_RGB;
-         case GL_INTENSITY16F_ARB:
-         case GL_INTENSITY32F_ARB:
-            return GL_INTENSITY;
-         case GL_LUMINANCE16F_ARB:
-         case GL_LUMINANCE32F_ARB:
-            return GL_LUMINANCE;
-         case GL_LUMINANCE_ALPHA16F_ARB:
-         case GL_LUMINANCE_ALPHA32F_ARB:
-            return GL_LUMINANCE_ALPHA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ATI_envmap_bumpmap) {
-      switch (internalFormat) {
-         case GL_DUDV_ATI:
-         case GL_DU8DV8_ATI:
-            return GL_DUDV_ATI;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.MESA_texture_signed_rgba) {
-      switch (internalFormat) {
-         case GL_RGBA_SNORM:
-         case GL_RGBA8_SNORM:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_packed_depth_stencil) {
-      switch (internalFormat) {
-         case GL_DEPTH_STENCIL_EXT:
-         case GL_DEPTH24_STENCIL8_EXT:
-            return GL_DEPTH_STENCIL_EXT;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-#if FEATURE_EXT_texture_sRGB
-   if (ctx->Extensions.EXT_texture_sRGB) {
-      switch (internalFormat) {
-      case GL_SRGB_EXT:
-      case GL_SRGB8_EXT:
-      case GL_COMPRESSED_SRGB_EXT:
-      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-         return GL_RGB;
-      case GL_SRGB_ALPHA_EXT:
-      case GL_SRGB8_ALPHA8_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-         return GL_RGBA;
-      case GL_SLUMINANCE_ALPHA_EXT:
-      case GL_SLUMINANCE8_ALPHA8_EXT:
-      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-         return GL_LUMINANCE_ALPHA;
-      case GL_SLUMINANCE_EXT:
-      case GL_SLUMINANCE8_EXT:
-      case GL_COMPRESSED_SLUMINANCE_EXT:
-         return GL_LUMINANCE;
-      default:
-         ; /* fallthrough */
-      }
-   }
-#endif /* FEATURE_EXT_texture_sRGB */
-
-   if (ctx->Extensions.EXT_texture_integer) {
-      switch (internalFormat) {
-      case GL_RGBA8UI_EXT:
-      case GL_RGBA16UI_EXT:
-      case GL_RGBA32UI_EXT:
-      case GL_RGBA8I_EXT:
-      case GL_RGBA16I_EXT:
-      case GL_RGBA32I_EXT:
-         return GL_RGBA;
-      case GL_RGB8UI_EXT:
-      case GL_RGB16UI_EXT:
-      case GL_RGB32UI_EXT:
-      case GL_RGB8I_EXT:
-      case GL_RGB16I_EXT:
-      case GL_RGB32I_EXT:
-         return GL_RGB;
-      case GL_ALPHA8UI_EXT:
-      case GL_ALPHA16UI_EXT:
-      case GL_ALPHA32UI_EXT:
-      case GL_ALPHA8I_EXT:
-      case GL_ALPHA16I_EXT:
-      case GL_ALPHA32I_EXT:
-         return GL_ALPHA;
-      case GL_INTENSITY8UI_EXT:
-      case GL_INTENSITY16UI_EXT:
-      case GL_INTENSITY32UI_EXT:
-      case GL_INTENSITY8I_EXT:
-      case GL_INTENSITY16I_EXT:
-      case GL_INTENSITY32I_EXT:
-         return GL_INTENSITY;
-      case GL_LUMINANCE8UI_EXT:
-      case GL_LUMINANCE16UI_EXT:
-      case GL_LUMINANCE32UI_EXT:
-      case GL_LUMINANCE8I_EXT:
-      case GL_LUMINANCE16I_EXT:
-      case GL_LUMINANCE32I_EXT:
-         return GL_LUMINANCE;
-      case GL_LUMINANCE_ALPHA8UI_EXT:
-      case GL_LUMINANCE_ALPHA16UI_EXT:
-      case GL_LUMINANCE_ALPHA32UI_EXT:
-      case GL_LUMINANCE_ALPHA8I_EXT:
-      case GL_LUMINANCE_ALPHA16I_EXT:
-      case GL_LUMINANCE_ALPHA32I_EXT:
-         return GL_LUMINANCE_ALPHA;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_rg) {
-      switch (internalFormat) {
-      case GL_R16F:
-	 /* R16F depends on both ARB_half_float_pixel and ARB_texture_float.
-	  */
-	 if (!ctx->Extensions.ARB_half_float_pixel)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_R32F:
-	 if (!ctx->Extensions.ARB_texture_float)
-	    break;
-         return GL_RED;
-      case GL_R8I:
-      case GL_R8UI:
-      case GL_R16I:
-      case GL_R16UI:
-      case GL_R32I:
-      case GL_R32UI:
-	 if (!ctx->Extensions.EXT_texture_integer)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_R8:
-      case GL_R16:
-      case GL_RED:
-      case GL_COMPRESSED_RED:
-         return GL_RED;
-
-      case GL_RG16F:
-	 /* RG16F depends on both ARB_half_float_pixel and ARB_texture_float.
-	  */
-	 if (!ctx->Extensions.ARB_half_float_pixel)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_RG32F:
-	 if (!ctx->Extensions.ARB_texture_float)
-	    break;
-         return GL_RG;
-      case GL_RG8I:
-      case GL_RG8UI:
-      case GL_RG16I:
-      case GL_RG16UI:
-      case GL_RG32I:
-      case GL_RG32UI:
-	 if (!ctx->Extensions.EXT_texture_integer)
-	    break;
-	 /* FALLTHROUGH */
-      case GL_RG:
-      case GL_RG8:
-      case GL_RG16:
-      case GL_COMPRESSED_RG:
-         return GL_RG;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_texture_shared_exponent) {
-      switch (internalFormat) {
-      case GL_RGB9_E5_EXT:
-         return GL_RGB;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.EXT_packed_float) {
-      switch (internalFormat) {
-      case GL_R11F_G11F_B10F_EXT:
-         return GL_RGB;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_depth_buffer_float) {
-      switch (internalFormat) {
-      case GL_DEPTH_COMPONENT32F:
-         return GL_DEPTH_COMPONENT;
-      case GL_DEPTH32F_STENCIL8:
-         return GL_DEPTH_STENCIL;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   if (ctx->Extensions.ARB_texture_compression_rgtc) {
-      switch (internalFormat) {
-      case GL_COMPRESSED_RED_RGTC1:
-      case GL_COMPRESSED_SIGNED_RED_RGTC1:
-         return GL_RED;
-      case GL_COMPRESSED_RG_RGTC2:
-      case GL_COMPRESSED_SIGNED_RG_RGTC2:
-         return GL_RG;
-      default:
-         ; /* fallthrough */
-      }
-   }
-
-   return -1; /* error */
-}
-
-
-/**
- * For cube map faces, return a face index in [0,5].
- * For other targets return 0;
- */
-GLuint
-_mesa_tex_target_to_face(GLenum target)
-{
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)
-      return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
-   else
-      return 0;
-}
-
-
-
-/**
- * Store a gl_texture_image pointer in a gl_texture_object structure
- * according to the target and level parameters.
- * 
- * \param tObj texture object.
- * \param target texture target.
- * \param level image level.
- * \param texImage texture image.
- * 
- * This was basically prompted by the introduction of cube maps.
- */
-void
-_mesa_set_tex_image(struct gl_texture_object *tObj,
-                    GLenum target, GLint level,
-                    struct gl_texture_image *texImage)
-{
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT(tObj);
-   ASSERT(texImage);
-   ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0);
-
-   tObj->Image[face][level] = texImage;
-
-   /* Set the 'back' pointer */
-   texImage->TexObject = tObj;
-}
-
-
-/**
- * Allocate a texture image structure.
- * 
- * Called via ctx->Driver.NewTextureImage() unless overriden by a device
- * driver.
- *
- * \return a pointer to gl_texture_image struct with all fields initialized to
- * zero.
- */
-struct gl_texture_image *
-_mesa_new_texture_image( struct gl_context *ctx )
-{
-   (void) ctx;
-   return CALLOC_STRUCT(gl_texture_image);
-}
-
-
-/**
- * Free texture image data.
- * This function is a fallback called via ctx->Driver.FreeTexImageData().
- *
- * \param texImage texture image.
- *
- * Free the texture image data if it's not marked as client data.
- */
-void
-_mesa_free_texture_image_data(struct gl_context *ctx,
-                              struct gl_texture_image *texImage)
-{
-   (void) ctx;
-
-   if (texImage->Data && !texImage->IsClientData) {
-      /* free the old texture data */
-      _mesa_free_texmemory(texImage->Data);
-   }
-
-   texImage->Data = NULL;
-}
-
-
-/**
- * Free texture image.
- *
- * \param texImage texture image.
- *
- * Free the texture image structure and the associated image data.
- */
-void
-_mesa_delete_texture_image(struct gl_context *ctx,
-                           struct gl_texture_image *texImage)
-{
-   /* Free texImage->Data and/or any other driver-specific texture
-    * image storage.
-    */
-   ASSERT(ctx->Driver.FreeTexImageData);
-   ctx->Driver.FreeTexImageData( ctx, texImage );
-
-   ASSERT(texImage->Data == NULL);
-   if (texImage->ImageOffsets)
-      free(texImage->ImageOffsets);
-   free(texImage);
-}
-
-
-/**
- * Test if a target is a proxy target.
- *
- * \param target texture target.
- *
- * \return GL_TRUE if the target is a proxy target, GL_FALSE otherwise.
- */
-GLboolean
-_mesa_is_proxy_texture(GLenum target)
-{
-   /* NUM_TEXTURE_TARGETS should match number of terms below */
-   assert(NUM_TEXTURE_TARGETS == 7);
-
-   return (target == GL_PROXY_TEXTURE_1D ||
-           target == GL_PROXY_TEXTURE_2D ||
-           target == GL_PROXY_TEXTURE_3D ||
-           target == GL_PROXY_TEXTURE_CUBE_MAP_ARB ||
-           target == GL_PROXY_TEXTURE_RECTANGLE_NV ||
-           target == GL_PROXY_TEXTURE_1D_ARRAY_EXT ||
-           target == GL_PROXY_TEXTURE_2D_ARRAY_EXT);
-}
-
-
-/**
- * Return the proxy target which corresponds to the given texture target
- */
-static GLenum
-get_proxy_target(GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-      return GL_PROXY_TEXTURE_1D;
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return GL_PROXY_TEXTURE_2D;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-      return GL_PROXY_TEXTURE_3D;
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      return GL_PROXY_TEXTURE_CUBE_MAP_ARB;
-   case GL_TEXTURE_RECTANGLE_NV:
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      return GL_PROXY_TEXTURE_RECTANGLE_NV;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      return GL_PROXY_TEXTURE_1D_ARRAY_EXT;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      return GL_PROXY_TEXTURE_2D_ARRAY_EXT;
-   default:
-      _mesa_problem(NULL, "unexpected target in get_proxy_target()");
-      return 0;
-   }
-}
-
-
-/**
- * Get the texture object that corresponds to the target of the given
- * texture unit.
- *
- * \param ctx GL context.
- * \param texUnit texture unit.
- * \param target texture target.
- *
- * \return pointer to the texture object on success, or NULL on failure.
- * 
- * \sa gl_texture_unit.
- */
-struct gl_texture_object *
-_mesa_select_tex_object(struct gl_context *ctx,
-                        const struct gl_texture_unit *texUnit,
-                        GLenum target)
-{
-   const GLboolean arrayTex = (ctx->Extensions.MESA_texture_array ||
-                               ctx->Extensions.EXT_texture_array);
-
-   switch (target) {
-      case GL_TEXTURE_1D:
-         return texUnit->CurrentTex[TEXTURE_1D_INDEX];
-      case GL_PROXY_TEXTURE_1D:
-         return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];
-      case GL_TEXTURE_2D:
-         return texUnit->CurrentTex[TEXTURE_2D_INDEX];
-      case GL_PROXY_TEXTURE_2D:
-         return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];
-      case GL_TEXTURE_3D:
-         return texUnit->CurrentTex[TEXTURE_3D_INDEX];
-      case GL_PROXY_TEXTURE_3D:
-         return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.ARB_texture_cube_map
-                ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.ARB_texture_cube_map
-                ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL;
-      case GL_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle
-                ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle
-                ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         return arrayTex ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         return arrayTex ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
-      default:
-         _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");
-         return NULL;
-   }
-}
-
-
-/**
- * Return pointer to texture object for given target on current texture unit.
- */
-struct gl_texture_object *
-_mesa_get_current_tex_object(struct gl_context *ctx, GLenum target)
-{
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   return _mesa_select_tex_object(ctx, texUnit, target);
-}
-
-
-/**
- * Get a texture image pointer from a texture object, given a texture
- * target and mipmap level.  The target and level parameters should
- * have already been error-checked.
- *
- * \param ctx GL context.
- * \param texObj texture unit.
- * \param target texture target.
- * \param level image level.
- *
- * \return pointer to the texture image structure, or NULL on failure.
- */
-struct gl_texture_image *
-_mesa_select_tex_image(struct gl_context *ctx,
-                       const struct gl_texture_object *texObj,
-		       GLenum target, GLint level)
-{
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT(texObj);
-   ASSERT(level >= 0);
-   ASSERT(level < MAX_TEXTURE_LEVELS);
-
-   return texObj->Image[face][level];
-}
-
-
-/**
- * Like _mesa_select_tex_image() but if the image doesn't exist, allocate
- * it and install it.  Only return NULL if passed a bad parameter or run
- * out of memory.
- */
-struct gl_texture_image *
-_mesa_get_tex_image(struct gl_context *ctx, struct gl_texture_object *texObj,
-                    GLenum target, GLint level)
-{
-   struct gl_texture_image *texImage;
-
-   if (!texObj)
-      return NULL;
-   
-   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-   if (!texImage) {
-      texImage = ctx->Driver.NewTextureImage(ctx);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture image allocation");
-         return NULL;
-      }
-
-      _mesa_set_tex_image(texObj, target, level, texImage);
-   }
-
-   return texImage;
-}
-
-
-/**
- * Return pointer to the specified proxy texture image.
- * Note that proxy textures are per-context, not per-texture unit.
- * \return pointer to texture image or NULL if invalid target, invalid
- *         level, or out of memory.
- */
-struct gl_texture_image *
-_mesa_get_proxy_tex_image(struct gl_context *ctx, GLenum target, GLint level)
-{
-   struct gl_texture_image *texImage;
-   GLuint texIndex;
-
-   if (level < 0 )
-      return NULL;
-
-   switch (target) {
-   case GL_PROXY_TEXTURE_1D:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_1D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_2D:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_2D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_3D:
-      if (level >= ctx->Const.Max3DTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_3D_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-      if (level >= ctx->Const.MaxCubeTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_CUBE_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      if (level > 0)
-         return NULL;
-      texIndex = TEXTURE_RECT_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_1D_ARRAY_INDEX;
-      break;
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      if (level >= ctx->Const.MaxTextureLevels)
-         return NULL;
-      texIndex = TEXTURE_2D_ARRAY_INDEX;
-      break;
-   default:
-      return NULL;
-   }
-
-   texImage = ctx->Texture.ProxyTex[texIndex]->Image[0][level];
-   if (!texImage) {
-      texImage = ctx->Driver.NewTextureImage(ctx);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-         return NULL;
-      }
-      ctx->Texture.ProxyTex[texIndex]->Image[0][level] = texImage;
-      /* Set the 'back' pointer */
-      texImage->TexObject = ctx->Texture.ProxyTex[texIndex];
-   }
-   return texImage;
-}
-
-
-/**
- * Get the maximum number of allowed mipmap levels.
- *
- * \param ctx GL context.
- * \param target texture target.
- * 
- * \return the maximum number of allowed mipmap levels for the given
- * texture target, or zero if passed a bad target.
- *
- * \sa gl_constants.
- */
-GLint
-_mesa_max_texture_levels(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return ctx->Const.MaxTextureLevels;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-      return ctx->Const.Max3DTextureLevels;
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      return ctx->Extensions.ARB_texture_cube_map
-         ? ctx->Const.MaxCubeTextureLevels : 0;
-   case GL_TEXTURE_RECTANGLE_NV:
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      return ctx->Extensions.NV_texture_rectangle ? 1 : 0;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      return (ctx->Extensions.MESA_texture_array ||
-              ctx->Extensions.EXT_texture_array)
-         ? ctx->Const.MaxTextureLevels : 0;
-   default:
-      return 0; /* bad target */
-   }
-}
-
-
-/**
- * Return number of dimensions per mipmap level for the given texture target.
- */
-GLint
-_mesa_get_texture_dimensions(GLenum target)
-{
-   switch (target) {
-   case GL_TEXTURE_1D:
-   case GL_PROXY_TEXTURE_1D:
-      return 1;
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_RECTANGLE:
-   case GL_TEXTURE_CUBE_MAP:
-   case GL_PROXY_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_RECTANGLE:
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-   case GL_TEXTURE_1D_ARRAY:
-   case GL_PROXY_TEXTURE_1D_ARRAY:
-      return 2;
-   case GL_TEXTURE_3D:
-   case GL_PROXY_TEXTURE_3D:
-   case GL_TEXTURE_2D_ARRAY:
-   case GL_PROXY_TEXTURE_2D_ARRAY:
-      return 3;
-   default:
-      _mesa_problem(NULL, "invalid target 0x%x in get_texture_dimensions()",
-                    target);
-      return 2;
-   }
-}
-
-
-
-
-#if 000 /* not used anymore */
-/*
- * glTexImage[123]D can accept a NULL image pointer.  In this case we
- * create a texture image with unspecified image contents per the OpenGL
- * spec.
- */
-static GLubyte *
-make_null_texture(GLint width, GLint height, GLint depth, GLenum format)
-{
-   const GLint components = _mesa_components_in_format(format);
-   const GLint numPixels = width * height * depth;
-   GLubyte *data = (GLubyte *) MALLOC(numPixels * components * sizeof(GLubyte));
-
-#ifdef DEBUG
-   /*
-    * Let's see if anyone finds this.  If glTexImage2D() is called with
-    * a NULL image pointer then load the texture image with something
-    * interesting instead of leaving it indeterminate.
-    */
-   if (data) {
-      static const char message[8][32] = {
-         "   X   X  XXXXX   XXX     X    ",
-         "   XX XX  X      X   X   X X   ",
-         "   X X X  X      X      X   X  ",
-         "   X   X  XXXX    XXX   XXXXX  ",
-         "   X   X  X          X  X   X  ",
-         "   X   X  X      X   X  X   X  ",
-         "   X   X  XXXXX   XXX   X   X  ",
-         "                               "
-      };
-
-      GLubyte *imgPtr = data;
-      GLint h, i, j, k;
-      for (h = 0; h < depth; h++) {
-         for (i = 0; i < height; i++) {
-            GLint srcRow = 7 - (i % 8);
-            for (j = 0; j < width; j++) {
-               GLint srcCol = j % 32;
-               GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;
-               for (k = 0; k < components; k++) {
-                  *imgPtr++ = texel;
-               }
-            }
-         }
-      }
-   }
-#endif
-
-   return data;
-}
-#endif
-
-
-
-/**
- * Reset the fields of a gl_texture_image struct to zero.
- * 
- * \param img texture image structure.
- *
- * This is called when a proxy texture test fails, we set all the
- * image members (except DriverData) to zero.
- * It's also used in glTexImage[123]D as a safeguard to be sure all
- * required fields get initialized properly by the Driver.TexImage[123]D
- * functions.
- */
-static void
-clear_teximage_fields(struct gl_texture_image *img)
-{
-   ASSERT(img);
-   img->_BaseFormat = 0;
-   img->InternalFormat = 0;
-   img->Border = 0;
-   img->Width = 0;
-   img->Height = 0;
-   img->Depth = 0;
-   img->RowStride = 0;
-   if (img->ImageOffsets) {
-      free(img->ImageOffsets);
-      img->ImageOffsets = NULL;
-   }
-   img->Width2 = 0;
-   img->Height2 = 0;
-   img->Depth2 = 0;
-   img->WidthLog2 = 0;
-   img->HeightLog2 = 0;
-   img->DepthLog2 = 0;
-   img->Data = NULL;
-   img->TexFormat = MESA_FORMAT_NONE;
-   img->FetchTexelc = NULL;
-   img->FetchTexelf = NULL;
-}
-
-
-/**
- * Initialize basic fields of the gl_texture_image struct.
- *
- * \param ctx GL context.
- * \param target texture target (GL_TEXTURE_1D, GL_TEXTURE_RECTANGLE, etc).
- * \param img texture image structure to be initialized.
- * \param width image width.
- * \param height image height.
- * \param depth image depth.
- * \param border image border.
- * \param internalFormat internal format.
- * \param format  the actual hardware format (one of MESA_FORMAT_*)
- *
- * Fills in the fields of \p img with the given information.
- * Note: width, height and depth include the border.
- */
-void
-_mesa_init_teximage_fields(struct gl_context *ctx, GLenum target,
-                           struct gl_texture_image *img,
-                           GLsizei width, GLsizei height, GLsizei depth,
-                           GLint border, GLenum internalFormat,
-                           gl_format format)
-{
-   GLint i, dims;
-
-   ASSERT(img);
-   ASSERT(width >= 0);
-   ASSERT(height >= 0);
-   ASSERT(depth >= 0);
-
-   img->_BaseFormat = _mesa_base_tex_format( ctx, internalFormat );
-   ASSERT(img->_BaseFormat > 0);
-   img->InternalFormat = internalFormat;
-   img->Border = border;
-   img->Width = width;
-   img->Height = height;
-   img->Depth = depth;
-
-   img->Width2 = width - 2 * border;   /* == 1 << img->WidthLog2; */
-   img->WidthLog2 = logbase2(img->Width2);
-
-   if (height == 1) { /* 1-D texture */
-      img->Height2 = 1;
-      img->HeightLog2 = 0;
-   }
-   else {
-      img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */
-      img->HeightLog2 = logbase2(img->Height2);
-   }
-
-   if (depth == 1) {  /* 2-D texture */
-      img->Depth2 = 1;
-      img->DepthLog2 = 0;
-   }
-   else {
-      img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */
-      img->DepthLog2 = logbase2(img->Depth2);
-   }
-
-   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
-
-   if ((width == 1 || _mesa_is_pow_two(img->Width2)) &&
-       (height == 1 || _mesa_is_pow_two(img->Height2)) &&
-       (depth == 1 || _mesa_is_pow_two(img->Depth2)))
-      img->_IsPowerOfTwo = GL_TRUE;
-   else
-      img->_IsPowerOfTwo = GL_FALSE;
-
-   /* RowStride and ImageOffsets[] describe how to address texels in 'Data' */
-   img->RowStride = width;
-   /* Allocate the ImageOffsets array and initialize to typical values.
-    * We allocate the array for 1D/2D textures too in order to avoid special-
-    * case code in the texstore routines.
-    */
-   if (img->ImageOffsets)
-      free(img->ImageOffsets);
-   img->ImageOffsets = (GLuint *) malloc(depth * sizeof(GLuint));
-   for (i = 0; i < depth; i++) {
-      img->ImageOffsets[i] = i * width * height;
-   }
-
-   /* Compute Width/Height/DepthScale for mipmap lod computation */
-   if (target == GL_TEXTURE_RECTANGLE_NV) {
-      /* scale = 1.0 since texture coords directly map to texels */
-      img->WidthScale = 1.0;
-      img->HeightScale = 1.0;
-      img->DepthScale = 1.0;
-   }
-   else {
-      img->WidthScale = (GLfloat) img->Width;
-      img->HeightScale = (GLfloat) img->Height;
-      img->DepthScale = (GLfloat) img->Depth;
-   }
-
-   img->TexFormat = format;
-
-   dims = _mesa_get_texture_dimensions(target);
-
-   _mesa_set_fetch_functions(img, dims);
-}
-
-
-/**
- * Free and clear fields of the gl_texture_image struct.
- *
- * \param ctx GL context.
- * \param texImage texture image structure to be cleared.
- *
- * After the call, \p texImage will have no data associated with it.  Its
- * fields are cleared so that its parent object will test incomplete.
- */
-void
-_mesa_clear_texture_image(struct gl_context *ctx,
-                          struct gl_texture_image *texImage)
-{
-   ctx->Driver.FreeTexImageData(ctx, texImage);
-   clear_teximage_fields(texImage);
-}
-
-
-/**
- * This is the fallback for Driver.TestProxyTexImage().  Test the texture
- * level, width, height and depth against the ctx->Const limits for textures.
- *
- * A hardware driver might override this function if, for example, the
- * max 3D texture size is 512x512x64 (i.e. not a cube).
- *
- * Note that width, height, depth == 0 is not an error.  However, a
- * texture with zero width/height/depth will be considered "incomplete"
- * and texturing will effectively be disabled.
- *
- * \param target  one of GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D,
- *                GL_PROXY_TEXTURE_3D, GL_PROXY_TEXTURE_RECTANGLE_NV,
- *                GL_PROXY_TEXTURE_CUBE_MAP_ARB.
- * \param level  as passed to glTexImage
- * \param internalFormat  as passed to glTexImage
- * \param format  as passed to glTexImage
- * \param type  as passed to glTexImage
- * \param width  as passed to glTexImage
- * \param height  as passed to glTexImage
- * \param depth  as passed to glTexImage
- * \param border  as passed to glTexImage
- * \return GL_TRUE if the image is acceptable, GL_FALSE if not acceptable.
- */
-GLboolean
-_mesa_test_proxy_teximage(struct gl_context *ctx, GLenum target, GLint level,
-                          GLint internalFormat, GLenum format, GLenum type,
-                          GLint width, GLint height, GLint depth, GLint border)
-{
-   GLint maxSize;
-
-   (void) internalFormat;
-   (void) format;
-   (void) type;
-
-   switch (target) {
-   case GL_PROXY_TEXTURE_1D:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_2D:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_3D:
-      maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (depth < 2 * border || depth > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.Max3DTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-         if (depth > 0 && !_mesa_is_pow_two(depth - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      maxSize = ctx->Const.MaxTextureRectSize;
-      if (width < 0 || width > maxSize)
-         return GL_FALSE;
-      if (height < 0 || height > maxSize)
-         return GL_FALSE;
-      if (level != 0)
-         return GL_FALSE;
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      maxSize = 1 << (ctx->Const.MaxCubeTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxCubeTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 1 || height > ctx->Const.MaxArrayTextureLayers)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
-      if (width < 2 * border || width > 2 + maxSize)
-         return GL_FALSE;
-      if (height < 2 * border || height > 2 + maxSize)
-         return GL_FALSE;
-      if (depth < 1 || depth > ctx->Const.MaxArrayTextureLayers)
-         return GL_FALSE;
-      if (level >= ctx->Const.MaxTextureLevels)
-         return GL_FALSE;
-      if (!ctx->Extensions.ARB_texture_non_power_of_two) {
-         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))
-            return GL_FALSE;
-         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))
-            return GL_FALSE;
-      }
-      return GL_TRUE;
-
-   default:
-      _mesa_problem(ctx, "Invalid target in _mesa_test_proxy_teximage");
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if the memory used by the texture would exceed the driver's limit.
- * This lets us support a max 3D texture size of 8K (for example) but
- * prevents allocating a full 8K x 8K x 8K texture.
- * XXX this could be rolled into the proxy texture size test (above) but
- * we don't have the actual texture internal format at that point.
- */
-static GLboolean
-legal_texture_size(struct gl_context *ctx, gl_format format,
-                   GLint width, GLint height, GLint depth)
-{
-   uint64_t bytes = _mesa_format_image_size64(format, width, height, depth);
-   uint64_t mbytes = bytes / (1024 * 1024); /* convert to MB */
-   return mbytes <= (uint64_t) ctx->Const.MaxTextureMbytes;
-}
-
-
-
-/**
- * Helper function to determine whether a target and specific compression
- * format are supported.
- */
-static GLboolean
-target_can_be_compressed(const struct gl_context *ctx, GLenum target,
-                         GLenum intFormat)
-{
-   (void) intFormat;  /* not used yet */
-
-   switch (target) {
-   case GL_TEXTURE_2D:
-   case GL_PROXY_TEXTURE_2D:
-      return GL_TRUE; /* true for any compressed format so far */
-   case GL_PROXY_TEXTURE_CUBE_MAP:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-      return ctx->Extensions.ARB_texture_cube_map;
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      return (ctx->Extensions.MESA_texture_array ||
-              ctx->Extensions.MESA_texture_array);
-   default:
-      return GL_FALSE;
-   }      
-}
-
-
-/**
- * Check if the given texture target value is legal for a
- * glTexImage1/2/3D call.
- */
-static GLboolean
-legal_teximage_target(struct gl_context *ctx, GLuint dims, GLenum target)
-{
-   switch (dims) {
-   case 1:
-      switch (target) {
-      case GL_TEXTURE_1D:
-      case GL_PROXY_TEXTURE_1D:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-      }
-   case 2:
-      switch (target) {
-      case GL_TEXTURE_2D:
-      case GL_PROXY_TEXTURE_2D:
-         return GL_TRUE;
-      case GL_PROXY_TEXTURE_CUBE_MAP:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-         return ctx->Extensions.ARB_texture_cube_map;
-      case GL_TEXTURE_RECTANGLE_NV:
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   case 3:
-      switch (target) {
-      case GL_TEXTURE_3D:
-      case GL_PROXY_TEXTURE_3D:
-         return GL_TRUE;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   default:
-      _mesa_problem(ctx, "invalid dims=%u in legal_teximage_target()", dims);
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Check if the given texture target value is legal for a
- * glTexSubImage, glCopyTexSubImage or glCopyTexImage call.
- * The difference compared to legal_teximage_target() above is that
- * proxy targets are not supported.
- */
-static GLboolean
-legal_texsubimage_target(struct gl_context *ctx, GLuint dims, GLenum target)
-{
-   switch (dims) {
-   case 1:
-      return target == GL_TEXTURE_1D;
-   case 2:
-      switch (target) {
-      case GL_TEXTURE_2D:
-         return GL_TRUE;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-         return ctx->Extensions.ARB_texture_cube_map;
-      case GL_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   case 3:
-      switch (target) {
-      case GL_TEXTURE_3D:
-         return GL_TRUE;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array ||
-                 ctx->Extensions.EXT_texture_array);
-      default:
-         return GL_FALSE;
-      }
-   default:
-      _mesa_problem(ctx, "invalid dims=%u in legal_texsubimage_target()",
-                    dims);
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Test the glTexImage[123]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param internalFormat internal format given by the user.
- * \param format pixel data format given by the user.
- * \param type pixel data type given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param depth image depth given by the user.
- * \param border image border given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- *
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-texture_error_check( struct gl_context *ctx,
-                     GLuint dimensions, GLenum target,
-                     GLint level, GLint internalFormat,
-                     GLenum format, GLenum type,
-                     GLint width, GLint height,
-                     GLint depth, GLint border )
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLboolean isProxy = target == proxyTarget;
-   GLboolean sizeOK = GL_TRUE;
-   GLboolean colorFormat, indexFormat;
-
-   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(level=%d)", dimensions, level);
-      }
-      return GL_TRUE;
-   }
-
-   /* Check border */
-   if (border < 0 || border > 1 ||
-       ((target == GL_TEXTURE_RECTANGLE_NV ||
-         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(border=%d)", dimensions, border);
-      }
-      return GL_TRUE;
-   }
-
-   if (width < 0 || height < 0 || depth < 0) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(width, height or depth < 0)", dimensions);
-      }
-      return GL_TRUE;
-   }
-
-   /* Do this simple check before calling the TestProxyTexImage() function */
-   if (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
-      sizeOK = (width == height);
-   }
-
-   /*
-    * Use the proxy texture driver hook to see if the size/level/etc are
-    * legal.
-    */
-   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                                    internalFormat, format,
-                                                    type, width, height,
-                                                    depth, border);
-   if (!sizeOK) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(level=%d, width=%d, height=%d, depth=%d)",
-                     dimensions, level, width, height, depth);
-      }
-      return GL_TRUE;
-   }
-
-   /* Check internalFormat */
-   if (_mesa_base_tex_format(ctx, internalFormat) < 0) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glTexImage%dD(internalFormat=%s)",
-                     dimensions, _mesa_lookup_enum_by_nr(internalFormat));
-      }
-      return GL_TRUE;
-   }
-
-   /* Check incoming image format and type */
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      /* Normally, GL_INVALID_OPERATION is generated by a format/type
-       * mismatch (see the 1.2 spec page 94, sec 3.6.4.).  But with the
-       * GL_EXT_texture_integer extension, some combinations should generate
-       * GL_INVALID_ENUM instead (grr!).
-       */
-      if (!isProxy) {
-         GLenum error = _mesa_is_integer_format(format)
-            ? GL_INVALID_ENUM : GL_INVALID_OPERATION;
-         _mesa_error(ctx, error,
-                     "glTexImage%dD(incompatible format 0x%x, type 0x%x)",
-                     dimensions, format, type);
-      }
-      return GL_TRUE;
-   }
-
-   /* make sure internal format and format basically agree */
-   colorFormat = _mesa_is_color_format(format);
-   indexFormat = _mesa_is_index_format(format);
-   if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) ||
-       (_mesa_is_index_format(internalFormat) && !indexFormat) ||
-       (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) ||
-       (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) ||
-       (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) ||
-       (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) {
-      if (!isProxy)
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)",
-                     dimensions, internalFormat, format);
-      return GL_TRUE;
-   }
-
-   /* additional checks for ycbcr textures */
-   if (internalFormat == GL_YCBCR_MESA) {
-      ASSERT(ctx->Extensions.MESA_ycbcr_texture);
-      if (type != GL_UNSIGNED_SHORT_8_8_MESA &&
-          type != GL_UNSIGNED_SHORT_8_8_REV_MESA) {
-         char message[100];
-         _mesa_snprintf(message, sizeof(message),
-                        "glTexImage%dD(format/type YCBCR mismatch", dimensions);
-         _mesa_error(ctx, GL_INVALID_ENUM, "%s", message);
-         return GL_TRUE; /* error */
-      }
-      if (target != GL_TEXTURE_2D &&
-          target != GL_PROXY_TEXTURE_2D &&
-          target != GL_TEXTURE_RECTANGLE_NV &&
-          target != GL_PROXY_TEXTURE_RECTANGLE_NV) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         if (!isProxy) {
-            char message[100];
-            _mesa_snprintf(message, sizeof(message),
-                           "glTexImage%dD(format=GL_YCBCR_MESA and border=%d)",
-                           dimensions, border);
-            _mesa_error(ctx, GL_INVALID_VALUE, "%s", message);
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for depth textures */
-   if (_mesa_base_tex_format(ctx, internalFormat) == GL_DEPTH_COMPONENT) {
-      /* Only 1D, 2D and rectangular textures supported, not 3D or cubes */
-      if (target != GL_TEXTURE_1D &&
-          target != GL_PROXY_TEXTURE_1D &&
-          target != GL_TEXTURE_2D &&
-          target != GL_PROXY_TEXTURE_2D &&
-          target != GL_TEXTURE_RECTANGLE_ARB &&
-          target != GL_PROXY_TEXTURE_RECTANGLE_ARB) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexImage(target/internalFormat)");
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for compressed textures */
-   if (_mesa_is_compressed_format(ctx, internalFormat)) {
-      if (!target_can_be_compressed(ctx, target, internalFormat)) {
-         if (!isProxy)
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexImage%dD(target)", dimensions);
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         if (!isProxy) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glTexImage%dD(border!=0)", dimensions);
-         }
-         return GL_TRUE;
-      }
-   }
-
-   /* additional checks for integer textures */
-   if (ctx->Extensions.EXT_texture_integer &&
-       (_mesa_is_integer_format(format) !=
-        _mesa_is_integer_format(internalFormat))) {
-      if (!isProxy) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage%dD(integer/non-integer format mismatch)",
-                     dimensions);
-      }
-      return GL_TRUE;
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/**
- * Test glTexSubImage[123]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param xoffset sub-image x offset given by the user.
- * \param yoffset sub-image y offset given by the user.
- * \param zoffset sub-image z offset given by the user.
- * \param format pixel data format given by the user.
- * \param type pixel data type given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param depth image depth given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- *
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-subtexture_error_check( struct gl_context *ctx, GLuint dimensions,
-                        GLenum target, GLint level,
-                        GLint xoffset, GLint yoffset, GLint zoffset,
-                        GLint width, GLint height, GLint depth,
-                        GLenum format, GLenum type )
-{
-   /* Basic level check */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level=%d)", level);
-      return GL_TRUE;
-   }
-
-   /* Check for negative sizes */
-   if (width < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(width=%d)", dimensions, width);
-      return GL_TRUE;
-   }
-   if (height < 0 && dimensions > 1) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(height=%d)", dimensions, height);
-      return GL_TRUE;
-   }
-   if (depth < 0 && dimensions > 2) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glTexSubImage%dD(depth=%d)", dimensions, depth);
-      return GL_TRUE;
-   }
-
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      /* As with the glTexImage2D check above, the error code here
-       * depends on texture integer.
-       */
-      GLenum error = _mesa_is_integer_format(format)
-         ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
-      _mesa_error(ctx, error,
-                  "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)",
-                  dimensions, format, type);
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Do second part of glTexSubImage which depends on the destination texture.
- * \return GL_TRUE if error recorded, GL_FALSE otherwise
- */
-static GLboolean
-subtexture_error_check2( struct gl_context *ctx, GLuint dimensions,
-			 GLenum target, GLint level,
-			 GLint xoffset, GLint yoffset, GLint zoffset,
-			 GLint width, GLint height, GLint depth,
-			 GLenum format, GLenum type,
-			 const struct gl_texture_image *destTex )
-{
-   if (!destTex) {
-      /* undefined image level */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage%dD", dimensions);
-      return GL_TRUE;
-   }
-
-   if (xoffset < -((GLint)destTex->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset)",
-                  dimensions);
-      return GL_TRUE;
-   }
-   if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset+width)",
-                  dimensions);
-      return GL_TRUE;
-   }
-   if (dimensions > 1) {
-      if (yoffset < -((GLint)destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset)",
-                     dimensions);
-         return GL_TRUE;
-      }
-      if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset+height)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-   if (dimensions > 2) {
-      if (zoffset < -((GLint)destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
-         return GL_TRUE;
-      }
-      if (zoffset + depth  > (GLint) (destTex->Depth + destTex->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
-         return GL_TRUE;
-      }
-   }
-
-   if (_mesa_is_format_compressed(destTex->TexFormat)) {
-      GLuint bw, bh;
-
-      /* do tests which depend on compression block size */
-      _mesa_get_format_block_size(destTex->TexFormat, &bw, &bh);
-
-      /* offset must be multiple of block size */
-      if ((xoffset % bw != 0) || (yoffset % bh != 0)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(xoffset = %d, yoffset = %d)",
-                     dimensions, xoffset, yoffset);
-         return GL_TRUE;
-      }
-      /* size must be multiple of bw by bh or equal to whole texture size */
-      if ((width % bw != 0) && (GLuint) width != destTex->Width) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(width = %d)", dimensions, width);
-         return GL_TRUE;
-      }         
-      if ((height % bh != 0) && (GLuint) height != destTex->Height) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexSubImage%dD(height = %d)", dimensions, height);
-         return GL_TRUE;
-      }         
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Test glCopyTexImage[12]D() parameters for errors.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * \param internalFormat internal format given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- * \param border texture border.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- * 
- * Verifies each of the parameters against the constants specified in
- * __struct gl_contextRec::Const and the supported extensions, and according
- * to the OpenGL specification.
- */
-static GLboolean
-copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
-                         GLenum target, GLint level, GLint internalFormat,
-                         GLint width, GLint height, GLint border )
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLenum type = GL_FLOAT;
-   GLboolean sizeOK;
-   GLint format;
-
-   /* check target */
-   if (!legal_texsubimage_target(ctx, dimensions, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexImage%uD(target=%s)",
-                  dimensions, _mesa_lookup_enum_by_nr(target));
-      return GL_TRUE;
-   }       
-
-   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexImage%dD(level=%d)", dimensions, level);
-      return GL_TRUE;
-   }
-
-   /* Check that the source buffer is complete */
-   if (ctx->ReadBuffer->Name) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
-      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* Check border */
-   if (border < 0 || border > 1 ||
-       ((target == GL_TEXTURE_RECTANGLE_NV ||
-         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {
-      return GL_TRUE;
-   }
-
-   format = _mesa_base_tex_format(ctx, internalFormat);
-   if (format < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexImage%dD(internalFormat)", dimensions);
-      return GL_TRUE;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, format)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexImage%dD(missing readbuffer)", dimensions);
-      return GL_TRUE;
-   }
-
-   /* Do size, level checking */
-   sizeOK = (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB)
-      ? (width == height) : 1;
-
-   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                                    internalFormat, format,
-                                                    type, width, height,
-                                                    1, border);
-
-   if (!sizeOK) {
-      if (dimensions == 1) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexImage1D(width=%d)", width);
-      }
-      else {
-         ASSERT(dimensions == 2);
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexImage2D(width=%d, height=%d)", width, height);
-      }
-      return GL_TRUE;
-   }
-
-   if (_mesa_is_compressed_format(ctx, internalFormat)) {
-      if (!target_can_be_compressed(ctx, target, internalFormat)) {
-         _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glCopyTexImage%dD(target)", dimensions);
-         return GL_TRUE;
-      }
-      if (border != 0) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(border!=0)", dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depth_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth)", dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (_mesa_is_depthstencil_format(internalFormat)) {
-      /* make sure we have depth/stencil buffers */
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexImage%dD(no depth/stencil buffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/**
- * Test glCopyTexSubImage[12]D() parameters for errors.
- * Note that this is the first part of error checking.
- * See also copytexsubimage_error_check2() below for the second part.
- * 
- * \param ctx GL context.
- * \param dimensions texture image dimensions (must be 1, 2 or 3).
- * \param target texture target given by the user.
- * \param level image level given by the user.
- * 
- * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
- */
-static GLboolean
-copytexsubimage_error_check1( struct gl_context *ctx, GLuint dimensions,
-                              GLenum target, GLint level)
-{
-   /* Check that the source buffer is complete */
-   if (ctx->ReadBuffer->Name) {
-      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
-      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* check target (proxies not allowed) */
-   if (!legal_texsubimage_target(ctx, dimensions, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexSubImage%uD(target=%s)",
-                  dimensions, _mesa_lookup_enum_by_nr(target));
-      return GL_TRUE;
-   }
-
-   /* Check level */
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(level=%d)", dimensions, level);
-      return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Second part of error checking for glCopyTexSubImage[12]D().
- * \param xoffset sub-image x offset given by the user.
- * \param yoffset sub-image y offset given by the user.
- * \param zoffset sub-image z offset given by the user.
- * \param width image width given by the user.
- * \param height image height given by the user.
- */
-static GLboolean
-copytexsubimage_error_check2( struct gl_context *ctx, GLuint dimensions,
-			      GLenum target, GLint level,
-			      GLint xoffset, GLint yoffset, GLint zoffset,
-			      GLsizei width, GLsizei height,
-			      const struct gl_texture_image *teximage )
-{
-   /* check that dest tex image exists */
-   if (!teximage) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(undefined texture level: %d)",
-                  dimensions, level);
-      return GL_TRUE;
-   }
-
-   /* Check size */
-   if (width < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(width=%d)", dimensions, width);
-      return GL_TRUE;
-   }
-   if (dimensions > 1 && height < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(height=%d)", dimensions, height);
-      return GL_TRUE;
-   }
-
-   /* check x/y offsets */
-   if (xoffset < -((GLint)teximage->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);
-      return GL_TRUE;
-   }
-   if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexSubImage%dD(xoffset+width)", dimensions);
-      return GL_TRUE;
-   }
-   if (dimensions > 1) {
-      if (yoffset < -((GLint)teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);
-         return GL_TRUE;
-      }
-      /* NOTE: we're adding the border here, not subtracting! */
-      if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(yoffset+height)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* check z offset */
-   if (dimensions > 2) {
-      if (zoffset < -((GLint)teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(zoffset)", dimensions);
-         return GL_TRUE;
-      }
-      if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(zoffset+depth)", dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   if (_mesa_is_format_compressed(teximage->TexFormat)) {
-      /* offset must be multiple of 4 */
-      if ((xoffset & 3) || (yoffset & 3)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(xoffset or yoffset)", dimensions);
-         return GL_TRUE;
-      }
-      /* size must be multiple of 4 */
-      if ((width & 3) != 0 && (GLuint) width != teximage->Width) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(width)", dimensions);
-         return GL_TRUE;
-      }         
-      if ((height & 3) != 0 && (GLuint) height != teximage->Height) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyTexSubImage%dD(height)", dimensions);
-         return GL_TRUE;
-      }         
-   }
-
-   if (teximage->InternalFormat == GL_YCBCR_MESA) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");
-      return GL_TRUE;
-   }
-
-   if (!_mesa_source_buffer_exists(ctx, teximage->_BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(missing readbuffer, format=0x%x)",
-                  dimensions, teximage->_BaseFormat);
-      return GL_TRUE;
-   }
-
-   if (teximage->_BaseFormat == GL_DEPTH_COMPONENT) {
-      if (!ctx->ReadBuffer->_DepthBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-   else if (teximage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
-      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glCopyTexSubImage%dD(no depth/stencil buffer)",
-                     dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* If copying into an integer texture, the source buffer must also be
-    * integer-valued.
-    */
-   if (_mesa_is_format_integer_color(teximage->TexFormat)) {
-      struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;
-      if (!_mesa_is_format_integer_color(rb->Format)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyTexSubImage%dD(source buffer is not integer format)",
-                  dimensions);
-         return GL_TRUE;
-      }
-   }
-
-   /* if we get here, the parameters are OK */
-   return GL_FALSE;
-}
-
-
-/** Callback info for walking over FBO hash table */
-struct cb_info
-{
-   struct gl_context *ctx;
-   struct gl_texture_object *texObj;
-   GLuint level, face;
-};
-
-
-/**
- * Check render to texture callback.  Called from _mesa_HashWalk().
- */
-static void
-check_rtt_cb(GLuint key, void *data, void *userData)
-{
-   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
-   const struct cb_info *info = (struct cb_info *) userData;
-   struct gl_context *ctx = info->ctx;
-   const struct gl_texture_object *texObj = info->texObj;
-   const GLuint level = info->level, face = info->face;
-
-   /* If this is a user-created FBO */
-   if (fb->Name) {
-      GLuint i;
-      /* check if any of the FBO's attachments point to 'texObj' */
-      for (i = 0; i < BUFFER_COUNT; i++) {
-         struct gl_renderbuffer_attachment *att = fb->Attachment + i;
-         if (att->Type == GL_TEXTURE &&
-             att->Texture == texObj &&
-             att->TextureLevel == level &&
-             att->CubeMapFace == face) {
-            ASSERT(att->Texture->Image[att->CubeMapFace][att->TextureLevel]);
-            /* Tell driver about the new renderbuffer texture */
-            ctx->Driver.RenderTexture(ctx, ctx->DrawBuffer, att);
-            /* Mark fb status as indeterminate to force re-validation */
-            fb->_Status = 0;
-         }
-      }
-   }
-}
-
-
-/**
- * When a texture image is specified we have to check if it's bound to
- * any framebuffer objects (render to texture) in order to detect changes
- * in size or format since that effects FBO completeness.
- * Any FBOs rendering into the texture must be re-validated.
- */
-static void
-update_fbo_texture(struct gl_context *ctx, struct gl_texture_object *texObj,
-                   GLuint face, GLuint level)
-{
-   /* Only check this texture if it's been marked as RenderToTexture */
-   if (texObj->_RenderToTexture) {
-      struct cb_info info;
-      info.ctx = ctx;
-      info.texObj = texObj;
-      info.level = level;
-      info.face = face;
-      _mesa_HashWalk(ctx->Shared->FrameBuffers, check_rtt_cb, &info);
-   }
-}
-
-
-/**
- * If the texture object's GenerateMipmap flag is set and we've
- * changed the texture base level image, regenerate the rest of the
- * mipmap levels now.
- */
-static INLINE void
-check_gen_mipmap(struct gl_context *ctx, GLenum target,
-                 struct gl_texture_object *texObj, GLint level)
-{
-   ASSERT(target != GL_TEXTURE_CUBE_MAP);
-   if (texObj->GenerateMipmap &&
-       level == texObj->BaseLevel &&
-       level < texObj->MaxLevel) {
-      ASSERT(ctx->Driver.GenerateMipmap);
-      ctx->Driver.GenerateMipmap(ctx, target, texObj);
-   }
-}
-
-
-/** Debug helper: override the user-requested internal format */
-static GLenum
-override_internal_format(GLenum internalFormat, GLint width, GLint height)
-{
-#if 0
-   if (internalFormat == GL_RGBA16F_ARB ||
-       internalFormat == GL_RGBA32F_ARB) {
-      printf("Convert rgba float tex to int %d x %d\n", width, height);
-      return GL_RGBA;
-   }
-   else if (internalFormat == GL_RGB16F_ARB ||
-            internalFormat == GL_RGB32F_ARB) {
-      printf("Convert rgb float tex to int %d x %d\n", width, height);
-      return GL_RGB;
-   }
-   else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB ||
-            internalFormat == GL_LUMINANCE_ALPHA32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_LUMINANCE_ALPHA;
-   }
-   else if (internalFormat == GL_LUMINANCE16F_ARB ||
-            internalFormat == GL_LUMINANCE32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_LUMINANCE;
-   }
-   else if (internalFormat == GL_ALPHA16F_ARB ||
-            internalFormat == GL_ALPHA32F_ARB) {
-      printf("Convert luminance float tex to int %d x %d\n", width, height);
-      return GL_ALPHA;
-   }
-   /*
-   else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {
-      internalFormat = GL_RGBA;
-   }
-   */
-   else {
-      return internalFormat;
-   }
-#else
-   return internalFormat;
-#endif
-}
-
-
-/**
- * Choose the actual hardware format for a texture image.
- * Try to use the same format as the previous image level when possible.
- * Otherwise, ask the driver for the best format.
- * It's important to try to choose a consistant format for all levels
- * for efficient texture memory layout/allocation.  In particular, this
- * comes up during automatic mipmap generation.
- */
-gl_format
-_mesa_choose_texture_format(struct gl_context *ctx,
-                            struct gl_texture_object *texObj,
-                            GLenum target, GLint level,
-                            GLenum internalFormat, GLenum format, GLenum type)
-{
-   gl_format f;
-
-   /* see if we've already chosen a format for the previous level */
-   if (level > 0) {
-      struct gl_texture_image *prevImage =
-	 _mesa_select_tex_image(ctx, texObj, target, level - 1);
-      /* See if the prev level is defined and has an internal format which
-       * matches the new internal format.
-       */
-      if (prevImage &&
-          prevImage->Width > 0 &&
-          prevImage->InternalFormat == internalFormat) {
-         /* use the same format */
-         ASSERT(prevImage->TexFormat != MESA_FORMAT_NONE);
-         return prevImage->TexFormat;
-      }
-   }
-
-   /* choose format from scratch */
-   f = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);
-   ASSERT(f != MESA_FORMAT_NONE);
-   return f;
-}
-
-
-/**
- * Common code to implement all the glTexImage1D/2D/3D functions.
- */
-static void
-teximage(struct gl_context *ctx, GLuint dims,
-         GLenum target, GLint level, GLint internalFormat,
-         GLsizei width, GLsizei height, GLsizei depth,
-         GLint border, GLenum format, GLenum type,
-         const GLvoid *pixels)
-{
-   GLboolean error;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glTexImage%uD %s %d %s %d %d %d %d %s %s %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  width, height, depth, border,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type), pixels);
-
-   internalFormat = override_internal_format(internalFormat, width, height);
-
-   /* target error checking */
-   if (!legal_teximage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }
-
-   /* general error checking */
-   error = texture_error_check(ctx, dims, target, level, internalFormat,
-                               format, type, width, height, depth, border);
-
-   if (_mesa_is_proxy_texture(target)) {
-      /* Proxy texture: just clear or set state depending on error checking */
-      struct gl_texture_image *texImage =
-         _mesa_get_proxy_tex_image(ctx, target, level);
-
-      if (error) {
-         /* when error, clear all proxy texture image parameters */
-         if (texImage)
-            clear_teximage_fields(texImage);
-      }
-      else {
-         /* no error, set the tex image parameters */
-         struct gl_texture_object *texObj =
-            _mesa_get_current_tex_object(ctx, target);
-         gl_format texFormat = _mesa_choose_texture_format(ctx, texObj,
-                                                           target, level,
-                                                           internalFormat,
-                                                           format, type);
-
-         if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height,
-                                       depth, border, internalFormat,
-                                       texFormat);
-         }
-         else if (texImage) {
-            clear_teximage_fields(texImage);
-         }
-      }
-   }
-   else {
-      /* non-proxy target */
-      const GLuint face = _mesa_tex_target_to_face(target);
-      struct gl_texture_object *texObj;
-      struct gl_texture_image *texImage;
-
-      if (error) {
-         return;   /* error was recorded */
-      }
-
-      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-	 _mesa_update_state(ctx);
-
-      texObj = _mesa_get_current_tex_object(ctx, target);
-
-      _mesa_lock_texture(ctx, texObj);
-      {
-	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-
-	 if (!texImage) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
-	 }
-         else {
-            gl_format texFormat;
-
-            if (texImage->Data) {
-               ctx->Driver.FreeTexImageData( ctx, texImage );
-            }
-
-            ASSERT(texImage->Data == NULL);
-            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                    internalFormat, format,
-                                                    type);
-
-            if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-               _mesa_init_teximage_fields(ctx, target, texImage,
-                                          width, height, depth,
-                                          border, internalFormat, texFormat);
-
-               /* Give the texture to the driver.  <pixels> may be null. */
-               ASSERT(ctx->Driver.TexImage3D);
-               switch (dims) {
-               case 1:
-                  ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
-                                         width, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               case 2:
-                  ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
-                                         width, height, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               case 3:
-                  ctx->Driver.TexImage3D(ctx, target, level, internalFormat,
-                                         width, height, depth, border, format,
-                                         type, pixels, &ctx->Unpack, texObj,
-                                         texImage);
-                  break;
-               default:
-                  _mesa_problem(ctx, "invalid dims=%u in teximage()", dims);
-               }
-
-               check_gen_mipmap(ctx, target, texObj, level);
-
-               update_fbo_texture(ctx, texObj, face, level);
-
-               /* state update */
-               texObj->_Complete = GL_FALSE;
-               ctx->NewState |= _NEW_TEXTURE;
-            }
-            else {
-               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);
-            }
-         }
-      }
-      _mesa_unlock_texture(ctx, texObj);
-   }
-}
-
-
-/*
- * Called from the API.  Note that width includes the border.
- */
-void GLAPIENTRY
-_mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLint border, GLenum format,
-                  GLenum type, const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 1, target, level, internalFormat, width, 1, 1,
-            border, format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLsizei height, GLint border,
-                  GLenum format, GLenum type,
-                  const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 2, target, level, internalFormat, width, height, 1,
-            border, format, type, pixels);
-}
-
-
-/*
- * Called by the API or display list executor.
- * Note that width and height include the border.
- */
-void GLAPIENTRY
-_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
-                  GLsizei width, GLsizei height, GLsizei depth,
-                  GLint border, GLenum format, GLenum type,
-                  const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   teximage(ctx, 3, target, level, internalFormat, width, height, depth,
-            border, format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalFormat,
-                     GLsizei width, GLsizei height, GLsizei depth,
-                     GLint border, GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,
-                    depth, border, format, type, pixels);
-}
-
-
-#if FEATURE_OES_EGL_image
-void GLAPIENTRY
-_mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (!ctx->Extensions.OES_EGL_image) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glEGLImageTargetTexture2DOES(unsupported)");
-      return;
-   }
-
-   if (target != GL_TEXTURE_2D) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-		  "glEGLImageTargetTexture2D(target=%d)", target);
-      return;
-   }
-
-   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_state(ctx);
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-   _mesa_lock_texture(ctx, texObj);
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, 0);
-   if (!texImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEGLImageTargetTexture2D");
-   } else {
-      if (texImage->Data)
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-
-      ASSERT(texImage->Data == NULL);
-      ctx->Driver.EGLImageTargetTexture2D(ctx, target,
-					  texObj, texImage, image);
-
-      /* state update */
-      texObj->_Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
-   }
-   _mesa_unlock_texture(ctx, texObj);
-
-}
-#endif
-
-
-
-/**
- * Implement all the glTexSubImage1/2/3D() functions.
- */
-static void
-texsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,
-            GLint xoffset, GLint yoffset, GLint zoffset,
-            GLsizei width, GLsizei height, GLsizei depth,
-            GLenum format, GLenum type, const GLvoid *pixels )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glTexSubImage%uD %s %d %d %d %d %d %d %d %s %s %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  xoffset, yoffset, zoffset, width, height, depth,
-                  _mesa_lookup_enum_by_nr(format),
-                  _mesa_lookup_enum_by_nr(type), pixels);
-
-   /* check target (proxies not allowed) */
-   if (!legal_texsubimage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }       
-
-   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_state(ctx);
-
-   if (subtexture_error_check(ctx, dims, target, level, xoffset, yoffset, zoffset,
-                              width, height, depth, format, type)) {
-      return;   /* error was detected */
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-      if (subtexture_error_check2(ctx, dims, target, level,
-                                  xoffset, yoffset, zoffset,
-				  width, height, depth,
-                                  format, type, texImage)) {
-         /* error was recorded */
-      }
-      else if (width > 0 && height > 0 && height > 0) {
-         /* If we have a border, offset=-1 is legal.  Bias by border width. */
-         switch (dims) {
-         case 3:
-            zoffset += texImage->Border;
-            /* fall-through */
-         case 2:
-            yoffset += texImage->Border;
-            /* fall-through */
-         case 1:
-            xoffset += texImage->Border;
-         }
-
-         switch (dims) {
-         case 1:
-            ctx->Driver.TexSubImage1D(ctx, target, level,
-                                      xoffset, width,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         case 2:
-            ctx->Driver.TexSubImage2D(ctx, target, level,
-                                      xoffset, yoffset, width, height,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         case 3:
-            ctx->Driver.TexSubImage3D(ctx, target, level,
-                                      xoffset, yoffset, zoffset,
-                                      width, height, depth,
-                                      format, type, pixels,
-                                      &ctx->Unpack, texObj, texImage );
-            break;
-         default:
-            _mesa_problem(ctx, "unexpected dims in subteximage()");
-         }
-
-         check_gen_mipmap(ctx, target, texObj, level);
-
-         ctx->NewState |= _NEW_TEXTURE;
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_TexSubImage1D( GLenum target, GLint level,
-                     GLint xoffset, GLsizei width,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 1, target, level,
-               xoffset, 0, 0,
-               width, 1, 1,
-               format, type, pixels);
-}
-
-
-void GLAPIENTRY
-_mesa_TexSubImage2D( GLenum target, GLint level,
-                     GLint xoffset, GLint yoffset,
-                     GLsizei width, GLsizei height,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 2, target, level,
-               xoffset, yoffset, 0,
-               width, height, 1,
-               format, type, pixels);
-}
-
-
-
-void GLAPIENTRY
-_mesa_TexSubImage3D( GLenum target, GLint level,
-                     GLint xoffset, GLint yoffset, GLint zoffset,
-                     GLsizei width, GLsizei height, GLsizei depth,
-                     GLenum format, GLenum type,
-                     const GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   texsubimage(ctx, 3, target, level,
-               xoffset, yoffset, zoffset,
-               width, height, depth,
-               format, type, pixels);
-}
-
-
-
-/**
- * Implement the glCopyTexImage1/2D() functions.
- */
-static void
-copyteximage(struct gl_context *ctx, GLuint dims,
-             GLenum target, GLint level, GLenum internalFormat,
-             GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   const GLuint face = _mesa_tex_target_to_face(target);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glCopyTexImage%uD %s %d %s %d %d %d %d %d\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  x, y, width, height, border);
-
-   if (ctx->NewState & NEW_COPY_TEX_STATE)
-      _mesa_update_state(ctx);
-
-   if (copytexture_error_check(ctx, dims, target, level, internalFormat,
-                               width, height, border))
-      return;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-
-      if (!texImage) {
-	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
-      }
-      else {
-         gl_format texFormat;
-
-         if (texImage->Data) {
-            ctx->Driver.FreeTexImageData( ctx, texImage );
-         }
-
-         ASSERT(texImage->Data == NULL);
-
-         texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                 internalFormat, GL_NONE,
-                                                 GL_NONE);
-
-         if (legal_texture_size(ctx, texFormat, width, height, 1)) {
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
-                                       border, internalFormat, texFormat);
-
-            ASSERT(ctx->Driver.CopyTexImage2D);
-            if (dims == 1)
-               ctx->Driver.CopyTexImage1D(ctx, target, level, internalFormat,
-                                          x, y, width, border);
-            else
-               ctx->Driver.CopyTexImage2D(ctx, target, level, internalFormat,
-                                          x, y, width, height, border);
-
-            check_gen_mipmap(ctx, target, texObj, level);
-
-            update_fbo_texture(ctx, texObj, face, level);
-
-            /* state update */
-            texObj->_Complete = GL_FALSE;
-            ctx->NewState |= _NEW_TEXTURE;
-         }
-         else {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);
-         }
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexImage1D( GLenum target, GLint level,
-                      GLenum internalFormat,
-                      GLint x, GLint y,
-                      GLsizei width, GLint border )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copyteximage(ctx, 1, target, level, internalFormat, x, y, width, 1, border);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
-                      GLint x, GLint y, GLsizei width, GLsizei height,
-                      GLint border )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copyteximage(ctx, 2, target, level, internalFormat,
-                x, y, width, height, border);
-}
-
-
-
-/**
- * Implementation for glCopyTexSubImage1/2/3D() functions.
- */
-static void
-copytexsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,
-                GLint xoffset, GLint yoffset, GLint zoffset,
-                GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glCopyTexSubImage%uD %s %d %d %d %d %d %d %d %d\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target),
-                  level, xoffset, yoffset, zoffset, x, y, width, height);
-
-   if (ctx->NewState & NEW_COPY_TEX_STATE)
-      _mesa_update_state(ctx);
-
-   if (copytexsubimage_error_check1(ctx, dims, target, level))
-      return;
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
-      if (copytexsubimage_error_check2(ctx, dims, target, level, xoffset, yoffset,
-				       zoffset, width, height, texImage)) {
-         /* error was recored */
-      }
-      else {
-         /* If we have a border, offset=-1 is legal.  Bias by border width. */
-         switch (dims) {
-         case 3:
-            zoffset += texImage->Border;
-            /* fall-through */
-         case 2:
-            yoffset += texImage->Border;
-            /* fall-through */
-         case 1:
-            xoffset += texImage->Border;
-         }
-
-         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,
-                                        &width, &height)) {
-            switch (dims) {
-            case 1:
-               ctx->Driver.CopyTexSubImage1D(ctx, target, level,
-                                             xoffset, x, y, width);
-               break;
-            case 2:
-               ctx->Driver.CopyTexSubImage2D(ctx, target, level,
-                                             xoffset, yoffset,
-                                             x, y, width, height);
-               break;
-            case 3:
-               ctx->Driver.CopyTexSubImage3D(ctx, target, level,
-                                             xoffset, yoffset, zoffset,
-                                             x, y, width, height);
-               break;
-            default:
-               _mesa_problem(ctx, "bad dims in copytexsubimage()");
-            }
-
-            check_gen_mipmap(ctx, target, texObj, level);
-
-            ctx->NewState |= _NEW_TEXTURE;
-         }
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage1D( GLenum target, GLint level,
-                         GLint xoffset, GLint x, GLint y, GLsizei width )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 1, target, level, xoffset, 0, 0, x, y, width, 1);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage2D( GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset,
-                         GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 2, target, level, xoffset, yoffset, 0, x, y,
-                   width, height);
-}
-
-
-
-void GLAPIENTRY
-_mesa_CopyTexSubImage3D( GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset, GLint zoffset,
-                         GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   copytexsubimage(ctx, 3, target, level, xoffset, yoffset, zoffset,
-                   x, y, width, height);
-}
-
-
-
-
-/**********************************************************************/
-/******                   Compressed Textures                    ******/
-/**********************************************************************/
-
-
-/**
- * Return expected size of a compressed texture.
- */
-static GLuint
-compressed_tex_size(GLsizei width, GLsizei height, GLsizei depth,
-                    GLenum glformat)
-{
-   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);
-   return _mesa_format_image_size(mesaFormat, width, height, depth);
-}
-
-
-/*
- * Return compressed texture block size, in pixels.
- */
-static void
-get_compressed_block_size(GLenum glformat, GLuint *bw, GLuint *bh)
-{
-   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);
-   _mesa_get_format_block_size(mesaFormat, bw, bh);
-}
-
-
-/**
- * Error checking for glCompressedTexImage[123]D().
- * \return error code or GL_NO_ERROR.
- */
-static GLenum
-compressed_texture_error_check(struct gl_context *ctx, GLint dimensions,
-                               GLenum target, GLint level,
-                               GLenum internalFormat, GLsizei width,
-                               GLsizei height, GLsizei depth, GLint border,
-                               GLsizei imageSize)
-{
-   const GLenum proxyTarget = get_proxy_target(target);
-   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);
-   GLint expectedSize;
-
-   /* check level */
-   if (level < 0 || level >= maxLevels)
-      return GL_INVALID_VALUE;
-
-   if (!target_can_be_compressed(ctx, target, internalFormat)) {
-      return GL_INVALID_ENUM;
-   }
-
-   /* This will detect any invalid internalFormat value */
-   if (!_mesa_is_compressed_format(ctx, internalFormat))
-      return GL_INVALID_ENUM;
-
-   /* This should really never fail */
-   if (_mesa_base_tex_format(ctx, internalFormat) < 0)
-      return GL_INVALID_ENUM;
-
-   /* No compressed formats support borders at this time */
-   if (border != 0)
-      return GL_INVALID_VALUE;
-
-   /* For cube map, width must equal height */
-   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height)
-      return GL_INVALID_VALUE;
-
-   /* check image size against compression block size */
-   {
-      gl_format texFormat =
-         ctx->Driver.ChooseTextureFormat(ctx, internalFormat,
-                                         GL_NONE, GL_NONE);
-      GLuint bw, bh;
-
-      _mesa_get_format_block_size(texFormat, &bw, &bh);
-      if ((width > bw && width % bw > 0) ||
-          (height > bh && height % bh > 0)) {
-         /*
-          * Per GL_ARB_texture_compression:  GL_INVALID_OPERATION is
-          * generated [...] if any parameter combinations are not
-          * supported by the specific compressed internal format. 
-          */
-         return GL_INVALID_OPERATION;
-      }
-   }
-
-   /* check image sizes */
-   if (!ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,
-                                      internalFormat, GL_NONE, GL_NONE,
-                                      width, height, depth, border)) {
-      /* See error comment above */
-      return GL_INVALID_OPERATION;
-   }
-
-   /* check image size in bytes */
-   expectedSize = compressed_tex_size(width, height, depth, internalFormat);
-   if (expectedSize != imageSize) {
-      /* Per GL_ARB_texture_compression:  GL_INVALID_VALUE is generated [...]
-       * if <imageSize> is not consistent with the format, dimensions, and
-       * contents of the specified image.
-       */
-      return GL_INVALID_VALUE;
-   }
-
-   return GL_NO_ERROR;
-}
-
-
-/**
- * Error checking for glCompressedTexSubImage[123]D().
- * \warning  There are some bad assumptions here about the size of compressed
- *           texture tiles (multiple of 4) used to test the validity of the
- *           offset and size parameters.
- * \return error code or GL_NO_ERROR.
- */
-static GLenum
-compressed_subtexture_error_check(struct gl_context *ctx, GLint dimensions,
-                                  GLenum target, GLint level,
-                                  GLint xoffset, GLint yoffset, GLint zoffset,
-                                  GLsizei width, GLsizei height, GLsizei depth,
-                                  GLenum format, GLsizei imageSize)
-{
-   GLint expectedSize, maxLevels = 0, maxTextureSize;
-   GLuint bw, bh;
-   (void) zoffset;
-
-   if (dimensions == 1) {
-      /* 1D compressed textures not allowed */
-      return GL_INVALID_ENUM;
-   }
-   else if (dimensions == 2) {
-      if (target == GL_PROXY_TEXTURE_2D) {
-         maxLevels = ctx->Const.MaxTextureLevels;
-      }
-      else if (target == GL_TEXTURE_2D) {
-         maxLevels = ctx->Const.MaxTextureLevels;
-      }
-      else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
-         if (!ctx->Extensions.ARB_texture_cube_map)
-            return GL_INVALID_ENUM; /*target*/
-         maxLevels = ctx->Const.MaxCubeTextureLevels;
-      }
-      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
-         if (!ctx->Extensions.ARB_texture_cube_map)
-            return GL_INVALID_ENUM; /*target*/
-         maxLevels = ctx->Const.MaxCubeTextureLevels;
-      }
-      else {
-         return GL_INVALID_ENUM; /*target*/
-      }
-   }
-   else if (dimensions == 3) {
-      /* 3D compressed textures not allowed */
-      return GL_INVALID_ENUM;
-   }
-
-   maxTextureSize = 1 << (maxLevels - 1);
-
-   /* this will catch any invalid compressed format token */
-   if (!_mesa_is_compressed_format(ctx, format))
-      return GL_INVALID_ENUM;
-
-   if (width < 1 || width > maxTextureSize)
-      return GL_INVALID_VALUE;
-
-   if ((height < 1 || height > maxTextureSize)
-       && dimensions > 1)
-      return GL_INVALID_VALUE;
-
-   if (level < 0 || level >= maxLevels)
-      return GL_INVALID_VALUE;
-
-   /*
-    * do checks which depend on compression block size
-    */
-   get_compressed_block_size(format, &bw, &bh);
-
-   if ((xoffset % bw != 0) || (yoffset % bh != 0))
-      return GL_INVALID_VALUE;
-
-   if ((width % bw != 0) && width != 2 && width != 1)
-      return GL_INVALID_VALUE;
-
-   if ((height % bh != 0) && height != 2 && height != 1)
-      return GL_INVALID_VALUE;
-
-   expectedSize = compressed_tex_size(width, height, depth, format);
-   if (expectedSize != imageSize)
-      return GL_INVALID_VALUE;
-
-   return GL_NO_ERROR;
-}
-
-
-/**
- * Do second part of glCompressedTexSubImage error checking.
- * \return GL_TRUE if error found, GL_FALSE otherwise.
- */
-static GLboolean
-compressed_subtexture_error_check2(struct gl_context *ctx, GLuint dims,
-                                   GLsizei width, GLsizei height,
-                                   GLsizei depth, GLenum format,
-                                   struct gl_texture_image *texImage)
-{
-
-   if ((GLint) format != texImage->InternalFormat) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCompressedTexSubImage%uD(format=0x%x)", dims, format);
-      return GL_TRUE;
-   }
-
-   if (((width == 1 || width == 2) &&
-        width != (GLsizei) texImage->Width) ||
-       (width > (GLsizei) texImage->Width)) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCompressedTexSubImage%uD(width=%d)", dims, width);
-      return GL_TRUE;
-   }
-
-   if (dims >= 2) {
-      if (((height == 1 || height == 2) &&
-           height != (GLsizei) texImage->Height) ||
-          (height > (GLsizei) texImage->Height)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCompressedTexSubImage%uD(height=%d)", dims, height);
-         return GL_TRUE;
-      }
-   }
-
-   if (dims >= 3) {
-      if (((depth == 1 || depth == 2) &&
-           depth != (GLsizei) texImage->Depth) ||
-          (depth > (GLsizei) texImage->Depth)) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCompressedTexSubImage%uD(depth=%d)", dims, depth);
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-/**
- * Implementation of the glCompressedTexImage1/2/3D() functions.
- */
-static void
-compressedteximage(struct gl_context *ctx, GLuint dims,
-                   GLenum target, GLint level,
-                   GLenum internalFormat, GLsizei width,
-                   GLsizei height, GLsizei depth, GLint border,
-                   GLsizei imageSize, const GLvoid *data)
-{
-   GLenum error;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx,
-                  "glCompressedTexImage%uDARB %s %d %s %d %d %d %d %d %p\n",
-                  dims,
-                  _mesa_lookup_enum_by_nr(target), level,
-                  _mesa_lookup_enum_by_nr(internalFormat),
-                  width, height, depth, border, imageSize, data);
-
-   /* check target */
-   if (!legal_teximage_target(ctx, dims, target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage%uD(target=%s)",
-                  dims, _mesa_lookup_enum_by_nr(target));
-      return;
-   }
-
-   error = compressed_texture_error_check(ctx, dims, target, level,
-                                          internalFormat, width, height, depth,
-                                          border, imageSize);
-
-#if FEATURE_ES
-   /* XXX this is kind of a hack */
-   if (error) {
-      _mesa_error(ctx, error, "glTexImage2D");
-      return;
-   }
-
-   if (dims == 2) {
-      switch (internalFormat) {
-      case GL_PALETTE4_RGB8_OES:
-      case GL_PALETTE4_RGBA8_OES:
-      case GL_PALETTE4_R5_G6_B5_OES:
-      case GL_PALETTE4_RGBA4_OES:
-      case GL_PALETTE4_RGB5_A1_OES:
-      case GL_PALETTE8_RGB8_OES:
-      case GL_PALETTE8_RGBA8_OES:
-      case GL_PALETTE8_R5_G6_B5_OES:
-      case GL_PALETTE8_RGBA4_OES:
-      case GL_PALETTE8_RGB5_A1_OES:
-         _mesa_cpal_compressed_teximage2d(target, level, internalFormat,
-                                          width, height, imageSize, data);
-         return;
-      }
-   }
-#endif
-
-   if (_mesa_is_proxy_texture(target)) {
-      /* Proxy texture: just check for errors and update proxy state */
-      struct gl_texture_image *texImage;
-
-      if (!error) {
-         struct gl_texture_object *texObj =
-            _mesa_get_current_tex_object(ctx, target);
-         gl_format texFormat =
-            _mesa_choose_texture_format(ctx, texObj, target, level,
-                                        internalFormat, GL_NONE, GL_NONE);
-         if (!legal_texture_size(ctx, texFormat, width, height, depth)) {
-            error = GL_OUT_OF_MEMORY;
-         }
-      }
-
-      texImage = _mesa_get_proxy_tex_image(ctx, target, level);
-      if (texImage) {
-         if (error) {
-            /* if error, clear all proxy texture image parameters */
-            clear_teximage_fields(texImage);
-         }
-         else {
-            /* no error: store the teximage parameters */
-            _mesa_init_teximage_fields(ctx, target, texImage, width, height,
-                                       depth, border, internalFormat,
-                                       MESA_FORMAT_NONE);
-         }
-      }
-   }
-   else {
-      /* non-proxy target */
-      struct gl_texture_object *texObj;
-      struct gl_texture_image *texImage;
-
-      if (error) {
-         _mesa_error(ctx, error, "glCompressedTexImage%uD", dims);
-         return;
-      }
-
-      texObj = _mesa_get_current_tex_object(ctx, target);
-
-      _mesa_lock_texture(ctx, texObj);
-      {
-	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-	 if (!texImage) {
-	    _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                        "glCompressedTexImage%uD", dims);
-	 }
-         else {
-            gl_format texFormat;
-
-            if (texImage->Data) {
-               ctx->Driver.FreeTexImageData( ctx, texImage );
-            }
-            ASSERT(texImage->Data == NULL);
-
-            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,
-                                                    internalFormat, GL_NONE,
-                                                    GL_NONE);
-
-            if (legal_texture_size(ctx, texFormat, width, height, depth)) {
-               _mesa_init_teximage_fields(ctx, target, texImage,
-                                          width, height, depth,
-                                          border, internalFormat, texFormat);
-
-               switch (dims) {
-               case 1:
-                  ASSERT(ctx->Driver.CompressedTexImage1D);
-                  ctx->Driver.CompressedTexImage1D(ctx, target, level,
-                                                   internalFormat,
-                                                   width,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               case 2:
-                  ASSERT(ctx->Driver.CompressedTexImage2D);
-                  ctx->Driver.CompressedTexImage2D(ctx, target, level,
-                                                   internalFormat,
-                                                   width, height,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               case 3:
-                  ASSERT(ctx->Driver.CompressedTexImage3D);
-                  ctx->Driver.CompressedTexImage3D(ctx, target, level,
-                                                   internalFormat,
-                                                   width, height, depth,
-                                                   border, imageSize, data,
-                                                   texObj, texImage);
-                  break;
-               default:
-                  _mesa_problem(ctx, "bad dims in compressedteximage");
-               }
-
-               check_gen_mipmap(ctx, target, texObj, level);
-
-               /* state update */
-               texObj->_Complete = GL_FALSE;
-               ctx->NewState |= _NEW_TEXTURE;
-            }
-            else {
-               _mesa_error(ctx, GL_OUT_OF_MEMORY,
-                           "glCompressedTexImage%uD", dims);
-            }
-         }
-      }
-      _mesa_unlock_texture(ctx, texObj);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage1DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLint border, GLsizei imageSize,
-                              const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 1, target, level, internalFormat,
-                      width, 1, 1, border, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage2DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLsizei height, GLint border, GLsizei imageSize,
-                              const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 2, target, level, internalFormat,
-                      width, height, 1, border, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexImage3DARB(GLenum target, GLint level,
-                              GLenum internalFormat, GLsizei width,
-                              GLsizei height, GLsizei depth, GLint border,
-                              GLsizei imageSize, const GLvoid *data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   compressedteximage(ctx, 3, target, level, internalFormat,
-                      width, height, depth, border, imageSize, data);
-}
-
-
-/**
- * Common helper for glCompressedTexSubImage1/2/3D().
- */
-static void
-compressed_tex_sub_image(GLuint dims, GLenum target, GLint level,
-                         GLint xoffset, GLint yoffset, GLint zoffset,
-                         GLsizei width, GLsizei height, GLsizei depth,
-                         GLenum format, GLsizei imageSize, const GLvoid *data)
-{
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLenum error;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   error = compressed_subtexture_error_check(ctx, dims, target, level,
-                                             xoffset, 0, 0, /* pos */
-                                             width, height, depth,   /* size */
-                                             format, imageSize);
-   if (error) {
-      _mesa_error(ctx, error, "glCompressedTexSubImage%uD", dims);
-      return;
-   }
-
-   texObj = _mesa_get_current_tex_object(ctx, target);
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-      assert(texImage);
-
-      if (compressed_subtexture_error_check2(ctx, dims, width, height, depth,
-                                             format, texImage)) {
-         /* error was recorded */
-      }
-      else if (width > 0 && height > 0 && depth > 0) {
-         switch (dims) {
-         case 1:
-            if (ctx->Driver.CompressedTexSubImage1D) {
-               ctx->Driver.CompressedTexSubImage1D(ctx, target, level,
-                                                   xoffset, width,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         case 2:
-            if (ctx->Driver.CompressedTexSubImage2D) {
-               ctx->Driver.CompressedTexSubImage2D(ctx, target, level,
-                                                   xoffset, yoffset,
-                                                   width, height,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         case 3:
-            if (ctx->Driver.CompressedTexSubImage3D) {
-               ctx->Driver.CompressedTexSubImage3D(ctx, target, level,
-                                                   xoffset, yoffset, zoffset,
-                                                   width, height, depth,
-                                                   format, imageSize, data,
-                                                   texObj, texImage);
-            }
-            break;
-         default:
-            ;
-         }
-
-         check_gen_mipmap(ctx, target, texObj, level);
-
-         ctx->NewState |= _NEW_TEXTURE;
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLsizei width, GLenum format,
-                                 GLsizei imageSize, const GLvoid *data)
-{
-   compressed_tex_sub_image(1, target, level, xoffset, 0, 0, width, 1, 1,
-                            format, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLint yoffset, GLsizei width, GLsizei height,
-                                 GLenum format, GLsizei imageSize,
-                                 const GLvoid *data)
-{
-   compressed_tex_sub_image(2, target, level, xoffset, yoffset, 0,
-                            width, height, 1, format, imageSize, data);
-}
-
-
-void GLAPIENTRY
-_mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
-                                 GLint yoffset, GLint zoffset, GLsizei width,
-                                 GLsizei height, GLsizei depth, GLenum format,
-                                 GLsizei imageSize, const GLvoid *data)
-{
-   compressed_tex_sub_image(3, target, level, xoffset, yoffset, zoffset,
-                            width, height, depth, format, imageSize, data);
-}
+/*

+ * mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2009  VMware, Inc.  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

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

+ * BRIAN PAUL 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 teximage.c

+ * Texture image-related functions.

+ */

+

+

+#include "glheader.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "enums.h"

+#include "fbobject.h"

+#include "framebuffer.h"

+#include "hash.h"

+#include "image.h"

+#include "imports.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "state.h"

+#include "texcompress.h"

+#include "texfetch.h"

+#include "teximage.h"

+#include "texstate.h"

+#include "texpal.h"

+#include "mtypes.h"

+

+

+/**

+ * State changes which we care about for glCopyTex[Sub]Image() calls.

+ * In particular, we care about pixel transfer state and buffer state

+ * (such as glReadBuffer to make sure we read from the right renderbuffer).

+ */

+#define NEW_COPY_TEX_STATE (_MESA_NEW_TRANSFER_STATE | \

+                            _NEW_BUFFERS | \

+                            _NEW_PIXEL)

+

+

+

+/**

+ * We allocate texture memory on 512-byte boundaries so we can use MMX/SSE

+ * elsewhere.

+ */

+void *

+_mesa_alloc_texmemory(GLsizei bytes)

+{

+   return _mesa_align_malloc(bytes, 512);

+}

+

+

+/**

+ * Free texture memory allocated with _mesa_alloc_texmemory()

+ */

+void

+_mesa_free_texmemory(void *m)

+{

+   _mesa_align_free(m);

+}

+

+

+/*

+ * Compute floor(log_base_2(n)).

+ * If n < 0 return -1.

+ */

+static int

+logbase2( int n )

+{

+   GLint i = 1;

+   GLint log2 = 0;

+

+   if (n < 0)

+      return -1;

+

+   if (n == 0)

+      return 0;

+

+   while ( n > i ) {

+      i *= 2;

+      log2++;

+   }

+   if (i != n) {

+      return log2 - 1;

+   }

+   else {

+      return log2;

+   }

+}

+

+

+

+/**

+ * Return the simple base format for a given internal texture format.

+ * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.

+ *

+ * \param ctx GL context.

+ * \param internalFormat the internal texture format token or 1, 2, 3, or 4.

+ *

+ * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,

+ * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.

+ *

+ * This is the format which is used during texture application (i.e. the

+ * texture format and env mode determine the arithmetic used.

+ *

+ * XXX this could be static

+ */

+GLint

+_mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )

+{

+   switch (internalFormat) {

+      case GL_ALPHA:

+      case GL_ALPHA4:

+      case GL_ALPHA8:

+      case GL_ALPHA12:

+      case GL_ALPHA16:

+         return GL_ALPHA;

+      case 1:

+      case GL_LUMINANCE:

+      case GL_LUMINANCE4:

+      case GL_LUMINANCE8:

+      case GL_LUMINANCE12:

+      case GL_LUMINANCE16:

+         return GL_LUMINANCE;

+      case 2:

+      case GL_LUMINANCE_ALPHA:

+      case GL_LUMINANCE4_ALPHA4:

+      case GL_LUMINANCE6_ALPHA2:

+      case GL_LUMINANCE8_ALPHA8:

+      case GL_LUMINANCE12_ALPHA4:

+      case GL_LUMINANCE12_ALPHA12:

+      case GL_LUMINANCE16_ALPHA16:

+         return GL_LUMINANCE_ALPHA;

+      case GL_INTENSITY:

+      case GL_INTENSITY4:

+      case GL_INTENSITY8:

+      case GL_INTENSITY12:

+      case GL_INTENSITY16:

+         return GL_INTENSITY;

+      case 3:

+      case GL_RGB:

+      case GL_R3_G3_B2:

+      case GL_RGB4:

+      case GL_RGB5:

+      case GL_RGB8:

+      case GL_RGB10:

+      case GL_RGB12:

+      case GL_RGB16:

+         return GL_RGB;

+      case 4:

+      case GL_RGBA:

+      case GL_RGBA2:

+      case GL_RGBA4:

+      case GL_RGB5_A1:

+      case GL_RGBA8:

+      case GL_RGB10_A2:

+      case GL_RGBA12:

+      case GL_RGBA16:

+         return GL_RGBA;

+      default:

+         ; /* fallthrough */

+   }

+

+   if (ctx->Extensions.EXT_texture_format_BGRA8888) {

+      switch (internalFormat) {

+         case GL_BGRA_EXT:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_paletted_texture) {

+      switch (internalFormat) {

+         case GL_COLOR_INDEX:

+         case GL_COLOR_INDEX1_EXT:

+         case GL_COLOR_INDEX2_EXT:

+         case GL_COLOR_INDEX4_EXT:

+         case GL_COLOR_INDEX8_EXT:

+         case GL_COLOR_INDEX12_EXT:

+         case GL_COLOR_INDEX16_EXT:

+            return GL_COLOR_INDEX;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_depth_texture) {

+      switch (internalFormat) {

+         case GL_DEPTH_COMPONENT:

+         case GL_DEPTH_COMPONENT16:

+         case GL_DEPTH_COMPONENT24:

+         case GL_DEPTH_COMPONENT32:

+            return GL_DEPTH_COMPONENT;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   switch (internalFormat) {

+   case GL_COMPRESSED_ALPHA:

+      return GL_ALPHA;

+   case GL_COMPRESSED_LUMINANCE:

+      return GL_LUMINANCE;

+   case GL_COMPRESSED_LUMINANCE_ALPHA:

+      return GL_LUMINANCE_ALPHA;

+   case GL_COMPRESSED_INTENSITY:

+      return GL_INTENSITY;

+   case GL_COMPRESSED_RGB:

+      return GL_RGB;

+   case GL_COMPRESSED_RGBA:

+      return GL_RGBA;

+   default:

+      ; /* fallthrough */

+   }

+         

+   if (ctx->Extensions.TDFX_texture_compression_FXT1) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_FXT1_3DFX:

+            return GL_RGB;

+         case GL_COMPRESSED_RGBA_FXT1_3DFX:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_compression_s3tc) {

+      switch (internalFormat) {

+         case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+            return GL_RGB;

+         case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+         case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+         case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.S3_s3tc) {

+      switch (internalFormat) {

+         case GL_RGB_S3TC:

+         case GL_RGB4_S3TC:

+            return GL_RGB;

+         case GL_RGBA_S3TC:

+         case GL_RGBA4_S3TC:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.MESA_ycbcr_texture) {

+      if (internalFormat == GL_YCBCR_MESA)

+         return GL_YCBCR_MESA;

+   }

+

+   if (ctx->Extensions.ARB_texture_float) {

+      switch (internalFormat) {

+         case GL_ALPHA16F_ARB:

+         case GL_ALPHA32F_ARB:

+            return GL_ALPHA;

+         case GL_RGBA16F_ARB:

+         case GL_RGBA32F_ARB:

+            return GL_RGBA;

+         case GL_RGB16F_ARB:

+         case GL_RGB32F_ARB:

+            return GL_RGB;

+         case GL_INTENSITY16F_ARB:

+         case GL_INTENSITY32F_ARB:

+            return GL_INTENSITY;

+         case GL_LUMINANCE16F_ARB:

+         case GL_LUMINANCE32F_ARB:

+            return GL_LUMINANCE;

+         case GL_LUMINANCE_ALPHA16F_ARB:

+         case GL_LUMINANCE_ALPHA32F_ARB:

+            return GL_LUMINANCE_ALPHA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ATI_envmap_bumpmap) {

+      switch (internalFormat) {

+         case GL_DUDV_ATI:

+         case GL_DU8DV8_ATI:

+            return GL_DUDV_ATI;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.MESA_texture_signed_rgba) {

+      switch (internalFormat) {

+         case GL_RGBA_SNORM:

+         case GL_RGBA8_SNORM:

+            return GL_RGBA;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_packed_depth_stencil) {

+      switch (internalFormat) {

+         case GL_DEPTH_STENCIL_EXT:

+         case GL_DEPTH24_STENCIL8_EXT:

+            return GL_DEPTH_STENCIL_EXT;

+         default:

+            ; /* fallthrough */

+      }

+   }

+

+#if FEATURE_EXT_texture_sRGB

+   if (ctx->Extensions.EXT_texture_sRGB) {

+      switch (internalFormat) {

+      case GL_SRGB_EXT:

+      case GL_SRGB8_EXT:

+      case GL_COMPRESSED_SRGB_EXT:

+      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+         return GL_RGB;

+      case GL_SRGB_ALPHA_EXT:

+      case GL_SRGB8_ALPHA8_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+         return GL_RGBA;

+      case GL_SLUMINANCE_ALPHA_EXT:

+      case GL_SLUMINANCE8_ALPHA8_EXT:

+      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+         return GL_LUMINANCE_ALPHA;

+      case GL_SLUMINANCE_EXT:

+      case GL_SLUMINANCE8_EXT:

+      case GL_COMPRESSED_SLUMINANCE_EXT:

+         return GL_LUMINANCE;

+      default:

+         ; /* fallthrough */

+      }

+   }

+#endif /* FEATURE_EXT_texture_sRGB */

+

+   if (ctx->Extensions.EXT_texture_integer) {

+      switch (internalFormat) {

+      case GL_RGBA8UI_EXT:

+      case GL_RGBA16UI_EXT:

+      case GL_RGBA32UI_EXT:

+      case GL_RGBA8I_EXT:

+      case GL_RGBA16I_EXT:

+      case GL_RGBA32I_EXT:

+         return GL_RGBA;

+      case GL_RGB8UI_EXT:

+      case GL_RGB16UI_EXT:

+      case GL_RGB32UI_EXT:

+      case GL_RGB8I_EXT:

+      case GL_RGB16I_EXT:

+      case GL_RGB32I_EXT:

+         return GL_RGB;

+      case GL_ALPHA8UI_EXT:

+      case GL_ALPHA16UI_EXT:

+      case GL_ALPHA32UI_EXT:

+      case GL_ALPHA8I_EXT:

+      case GL_ALPHA16I_EXT:

+      case GL_ALPHA32I_EXT:

+         return GL_ALPHA;

+      case GL_INTENSITY8UI_EXT:

+      case GL_INTENSITY16UI_EXT:

+      case GL_INTENSITY32UI_EXT:

+      case GL_INTENSITY8I_EXT:

+      case GL_INTENSITY16I_EXT:

+      case GL_INTENSITY32I_EXT:

+         return GL_INTENSITY;

+      case GL_LUMINANCE8UI_EXT:

+      case GL_LUMINANCE16UI_EXT:

+      case GL_LUMINANCE32UI_EXT:

+      case GL_LUMINANCE8I_EXT:

+      case GL_LUMINANCE16I_EXT:

+      case GL_LUMINANCE32I_EXT:

+         return GL_LUMINANCE;

+      case GL_LUMINANCE_ALPHA8UI_EXT:

+      case GL_LUMINANCE_ALPHA16UI_EXT:

+      case GL_LUMINANCE_ALPHA32UI_EXT:

+      case GL_LUMINANCE_ALPHA8I_EXT:

+      case GL_LUMINANCE_ALPHA16I_EXT:

+      case GL_LUMINANCE_ALPHA32I_EXT:

+         return GL_LUMINANCE_ALPHA;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_rg) {

+      switch (internalFormat) {

+      case GL_R16F:

+	 /* R16F depends on both ARB_half_float_pixel and ARB_texture_float.

+	  */

+	 if (!ctx->Extensions.ARB_half_float_pixel)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_R32F:

+	 if (!ctx->Extensions.ARB_texture_float)

+	    break;

+         return GL_RED;

+      case GL_R8I:

+      case GL_R8UI:

+      case GL_R16I:

+      case GL_R16UI:

+      case GL_R32I:

+      case GL_R32UI:

+	 if (!ctx->Extensions.EXT_texture_integer)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_R8:

+      case GL_R16:

+      case GL_RED:

+      case GL_COMPRESSED_RED:

+         return GL_RED;

+

+      case GL_RG16F:

+	 /* RG16F depends on both ARB_half_float_pixel and ARB_texture_float.

+	  */

+	 if (!ctx->Extensions.ARB_half_float_pixel)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_RG32F:

+	 if (!ctx->Extensions.ARB_texture_float)

+	    break;

+         return GL_RG;

+      case GL_RG8I:

+      case GL_RG8UI:

+      case GL_RG16I:

+      case GL_RG16UI:

+      case GL_RG32I:

+      case GL_RG32UI:

+	 if (!ctx->Extensions.EXT_texture_integer)

+	    break;

+	 /* FALLTHROUGH */

+      case GL_RG:

+      case GL_RG8:

+      case GL_RG16:

+      case GL_COMPRESSED_RG:

+         return GL_RG;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_texture_shared_exponent) {

+      switch (internalFormat) {

+      case GL_RGB9_E5_EXT:

+         return GL_RGB;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.EXT_packed_float) {

+      switch (internalFormat) {

+      case GL_R11F_G11F_B10F_EXT:

+         return GL_RGB;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_depth_buffer_float) {

+      switch (internalFormat) {

+      case GL_DEPTH_COMPONENT32F:

+         return GL_DEPTH_COMPONENT;

+      case GL_DEPTH32F_STENCIL8:

+         return GL_DEPTH_STENCIL;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   if (ctx->Extensions.ARB_texture_compression_rgtc) {

+      switch (internalFormat) {

+      case GL_COMPRESSED_RED_RGTC1:

+      case GL_COMPRESSED_SIGNED_RED_RGTC1:

+         return GL_RED;

+      case GL_COMPRESSED_RG_RGTC2:

+      case GL_COMPRESSED_SIGNED_RG_RGTC2:

+         return GL_RG;

+      default:

+         ; /* fallthrough */

+      }

+   }

+

+   return -1; /* error */

+}

+

+

+/**

+ * For cube map faces, return a face index in [0,5].

+ * For other targets return 0;

+ */

+GLuint

+_mesa_tex_target_to_face(GLenum target)

+{

+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)

+      return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;

+   else

+      return 0;

+}

+

+

+

+/**

+ * Store a gl_texture_image pointer in a gl_texture_object structure

+ * according to the target and level parameters.

+ * 

+ * \param tObj texture object.

+ * \param target texture target.

+ * \param level image level.

+ * \param texImage texture image.

+ * 

+ * This was basically prompted by the introduction of cube maps.

+ */

+void

+_mesa_set_tex_image(struct gl_texture_object *tObj,

+                    GLenum target, GLint level,

+                    struct gl_texture_image *texImage)

+{

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT(tObj);

+   ASSERT(texImage);

+   ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0);

+

+   tObj->Image[face][level] = texImage;

+

+   /* Set the 'back' pointer */

+   texImage->TexObject = tObj;

+}

+

+

+/**

+ * Allocate a texture image structure.

+ * 

+ * Called via ctx->Driver.NewTextureImage() unless overriden by a device

+ * driver.

+ *

+ * \return a pointer to gl_texture_image struct with all fields initialized to

+ * zero.

+ */

+struct gl_texture_image *

+_mesa_new_texture_image( struct gl_context *ctx )

+{

+   (void) ctx;

+   return CALLOC_STRUCT(gl_texture_image);

+}

+

+

+/**

+ * Free texture image data.

+ * This function is a fallback called via ctx->Driver.FreeTexImageData().

+ *

+ * \param texImage texture image.

+ *

+ * Free the texture image data if it's not marked as client data.

+ */

+void

+_mesa_free_texture_image_data(struct gl_context *ctx,

+                              struct gl_texture_image *texImage)

+{

+   (void) ctx;

+

+   if (texImage->Data && !texImage->IsClientData) {

+      /* free the old texture data */

+      _mesa_free_texmemory(texImage->Data);

+   }

+

+   texImage->Data = NULL;

+}

+

+

+/**

+ * Free texture image.

+ *

+ * \param texImage texture image.

+ *

+ * Free the texture image structure and the associated image data.

+ */

+void

+_mesa_delete_texture_image(struct gl_context *ctx,

+                           struct gl_texture_image *texImage)

+{

+   /* Free texImage->Data and/or any other driver-specific texture

+    * image storage.

+    */

+   ASSERT(ctx->Driver.FreeTexImageData);

+   ctx->Driver.FreeTexImageData( ctx, texImage );

+

+   ASSERT(texImage->Data == NULL);

+   if (texImage->ImageOffsets)

+      free(texImage->ImageOffsets);

+   free(texImage);

+}

+

+

+/**

+ * Test if a target is a proxy target.

+ *

+ * \param target texture target.

+ *

+ * \return GL_TRUE if the target is a proxy target, GL_FALSE otherwise.

+ */

+GLboolean

+_mesa_is_proxy_texture(GLenum target)

+{

+   /* NUM_TEXTURE_TARGETS should match number of terms below */

+   assert(NUM_TEXTURE_TARGETS == 7);

+

+   return (target == GL_PROXY_TEXTURE_1D ||

+           target == GL_PROXY_TEXTURE_2D ||

+           target == GL_PROXY_TEXTURE_3D ||

+           target == GL_PROXY_TEXTURE_CUBE_MAP_ARB ||

+           target == GL_PROXY_TEXTURE_RECTANGLE_NV ||

+           target == GL_PROXY_TEXTURE_1D_ARRAY_EXT ||

+           target == GL_PROXY_TEXTURE_2D_ARRAY_EXT);

+}

+

+

+/**

+ * Return the proxy target which corresponds to the given texture target

+ */

+static GLenum

+get_proxy_target(GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+      return GL_PROXY_TEXTURE_1D;

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return GL_PROXY_TEXTURE_2D;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+      return GL_PROXY_TEXTURE_3D;

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      return GL_PROXY_TEXTURE_CUBE_MAP_ARB;

+   case GL_TEXTURE_RECTANGLE_NV:

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      return GL_PROXY_TEXTURE_RECTANGLE_NV;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      return GL_PROXY_TEXTURE_1D_ARRAY_EXT;

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      return GL_PROXY_TEXTURE_2D_ARRAY_EXT;

+   default:

+      _mesa_problem(NULL, "unexpected target in get_proxy_target()");

+      return 0;

+   }

+}

+

+

+/**

+ * Get the texture object that corresponds to the target of the given

+ * texture unit.

+ *

+ * \param ctx GL context.

+ * \param texUnit texture unit.

+ * \param target texture target.

+ *

+ * \return pointer to the texture object on success, or NULL on failure.

+ * 

+ * \sa gl_texture_unit.

+ */

+struct gl_texture_object *

+_mesa_select_tex_object(struct gl_context *ctx,

+                        const struct gl_texture_unit *texUnit,

+                        GLenum target)

+{

+   const GLboolean arrayTex = (ctx->Extensions.MESA_texture_array ||

+                               ctx->Extensions.EXT_texture_array);

+

+   switch (target) {

+      case GL_TEXTURE_1D:

+         return texUnit->CurrentTex[TEXTURE_1D_INDEX];

+      case GL_PROXY_TEXTURE_1D:

+         return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];

+      case GL_TEXTURE_2D:

+         return texUnit->CurrentTex[TEXTURE_2D_INDEX];

+      case GL_PROXY_TEXTURE_2D:

+         return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];

+      case GL_TEXTURE_3D:

+         return texUnit->CurrentTex[TEXTURE_3D_INDEX];

+      case GL_PROXY_TEXTURE_3D:

+         return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+      case GL_TEXTURE_CUBE_MAP_ARB:

+         return ctx->Extensions.ARB_texture_cube_map

+                ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+         return ctx->Extensions.ARB_texture_cube_map

+                ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL;

+      case GL_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle

+                ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle

+                ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         return arrayTex ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         return arrayTex ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL;

+      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+         return arrayTex ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL;

+      default:

+         _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");

+         return NULL;

+   }

+}

+

+

+/**

+ * Return pointer to texture object for given target on current texture unit.

+ */

+struct gl_texture_object *

+_mesa_get_current_tex_object(struct gl_context *ctx, GLenum target)

+{

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   return _mesa_select_tex_object(ctx, texUnit, target);

+}

+

+

+/**

+ * Get a texture image pointer from a texture object, given a texture

+ * target and mipmap level.  The target and level parameters should

+ * have already been error-checked.

+ *

+ * \param ctx GL context.

+ * \param texObj texture unit.

+ * \param target texture target.

+ * \param level image level.

+ *

+ * \return pointer to the texture image structure, or NULL on failure.

+ */

+struct gl_texture_image *

+_mesa_select_tex_image(struct gl_context *ctx,

+                       const struct gl_texture_object *texObj,

+		       GLenum target, GLint level)

+{

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT(texObj);

+   ASSERT(level >= 0);

+   ASSERT(level < MAX_TEXTURE_LEVELS);

+

+   return texObj->Image[face][level];

+}

+

+

+/**

+ * Like _mesa_select_tex_image() but if the image doesn't exist, allocate

+ * it and install it.  Only return NULL if passed a bad parameter or run

+ * out of memory.

+ */

+struct gl_texture_image *

+_mesa_get_tex_image(struct gl_context *ctx, struct gl_texture_object *texObj,

+                    GLenum target, GLint level)

+{

+   struct gl_texture_image *texImage;

+

+   if (!texObj)

+      return NULL;

+   

+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+   if (!texImage) {

+      texImage = ctx->Driver.NewTextureImage(ctx);

+      if (!texImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture image allocation");

+         return NULL;

+      }

+

+      _mesa_set_tex_image(texObj, target, level, texImage);

+   }

+

+   return texImage;

+}

+

+

+/**

+ * Return pointer to the specified proxy texture image.

+ * Note that proxy textures are per-context, not per-texture unit.

+ * \return pointer to texture image or NULL if invalid target, invalid

+ *         level, or out of memory.

+ */

+struct gl_texture_image *

+_mesa_get_proxy_tex_image(struct gl_context *ctx, GLenum target, GLint level)

+{

+   struct gl_texture_image *texImage;

+   GLuint texIndex;

+

+   if (level < 0 )

+      return NULL;

+

+   switch (target) {

+   case GL_PROXY_TEXTURE_1D:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_1D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_2D:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_2D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_3D:

+      if (level >= ctx->Const.Max3DTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_3D_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+      if (level >= ctx->Const.MaxCubeTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_CUBE_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      if (level > 0)

+         return NULL;

+      texIndex = TEXTURE_RECT_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_1D_ARRAY_INDEX;

+      break;

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      if (level >= ctx->Const.MaxTextureLevels)

+         return NULL;

+      texIndex = TEXTURE_2D_ARRAY_INDEX;

+      break;

+   default:

+      return NULL;

+   }

+

+   texImage = ctx->Texture.ProxyTex[texIndex]->Image[0][level];

+   if (!texImage) {

+      texImage = ctx->Driver.NewTextureImage(ctx);

+      if (!texImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");

+         return NULL;

+      }

+      ctx->Texture.ProxyTex[texIndex]->Image[0][level] = texImage;

+      /* Set the 'back' pointer */

+      texImage->TexObject = ctx->Texture.ProxyTex[texIndex];

+   }

+   return texImage;

+}

+

+

+/**

+ * Get the maximum number of allowed mipmap levels.

+ *

+ * \param ctx GL context.

+ * \param target texture target.

+ * 

+ * \return the maximum number of allowed mipmap levels for the given

+ * texture target, or zero if passed a bad target.

+ *

+ * \sa gl_constants.

+ */

+GLint

+_mesa_max_texture_levels(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return ctx->Const.MaxTextureLevels;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+      return ctx->Const.Max3DTextureLevels;

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      return ctx->Extensions.ARB_texture_cube_map

+         ? ctx->Const.MaxCubeTextureLevels : 0;

+   case GL_TEXTURE_RECTANGLE_NV:

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      return ctx->Extensions.NV_texture_rectangle ? 1 : 0;

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      return (ctx->Extensions.MESA_texture_array ||

+              ctx->Extensions.EXT_texture_array)

+         ? ctx->Const.MaxTextureLevels : 0;

+   default:

+      return 0; /* bad target */

+   }

+}

+

+

+/**

+ * Return number of dimensions per mipmap level for the given texture target.

+ */

+GLint

+_mesa_get_texture_dimensions(GLenum target)

+{

+   switch (target) {

+   case GL_TEXTURE_1D:

+   case GL_PROXY_TEXTURE_1D:

+      return 1;

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_RECTANGLE:

+   case GL_TEXTURE_CUBE_MAP:

+   case GL_PROXY_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_RECTANGLE:

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+   case GL_TEXTURE_1D_ARRAY:

+   case GL_PROXY_TEXTURE_1D_ARRAY:

+      return 2;

+   case GL_TEXTURE_3D:

+   case GL_PROXY_TEXTURE_3D:

+   case GL_TEXTURE_2D_ARRAY:

+   case GL_PROXY_TEXTURE_2D_ARRAY:

+      return 3;

+   default:

+      _mesa_problem(NULL, "invalid target 0x%x in get_texture_dimensions()",

+                    target);

+      return 2;

+   }

+}

+

+

+

+

+#if 000 /* not used anymore */

+/*

+ * glTexImage[123]D can accept a NULL image pointer.  In this case we

+ * create a texture image with unspecified image contents per the OpenGL

+ * spec.

+ */

+static GLubyte *

+make_null_texture(GLint width, GLint height, GLint depth, GLenum format)

+{

+   const GLint components = _mesa_components_in_format(format);

+   const GLint numPixels = width * height * depth;

+   GLubyte *data = (GLubyte *) MALLOC(numPixels * components * sizeof(GLubyte));

+

+#ifdef DEBUG

+   /*

+    * Let's see if anyone finds this.  If glTexImage2D() is called with

+    * a NULL image pointer then load the texture image with something

+    * interesting instead of leaving it indeterminate.

+    */

+   if (data) {

+      static const char message[8][32] = {

+         "   X   X  XXXXX   XXX     X    ",

+         "   XX XX  X      X   X   X X   ",

+         "   X X X  X      X      X   X  ",

+         "   X   X  XXXX    XXX   XXXXX  ",

+         "   X   X  X          X  X   X  ",

+         "   X   X  X      X   X  X   X  ",

+         "   X   X  XXXXX   XXX   X   X  ",

+         "                               "

+      };

+

+      GLubyte *imgPtr = data;

+      GLint h, i, j, k;

+      for (h = 0; h < depth; h++) {

+         for (i = 0; i < height; i++) {

+            GLint srcRow = 7 - (i % 8);

+            for (j = 0; j < width; j++) {

+               GLint srcCol = j % 32;

+               GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;

+               for (k = 0; k < components; k++) {

+                  *imgPtr++ = texel;

+               }

+            }

+         }

+      }

+   }

+#endif

+

+   return data;

+}

+#endif

+

+

+

+/**

+ * Reset the fields of a gl_texture_image struct to zero.

+ * 

+ * \param img texture image structure.

+ *

+ * This is called when a proxy texture test fails, we set all the

+ * image members (except DriverData) to zero.

+ * It's also used in glTexImage[123]D as a safeguard to be sure all

+ * required fields get initialized properly by the Driver.TexImage[123]D

+ * functions.

+ */

+static void

+clear_teximage_fields(struct gl_texture_image *img)

+{

+   ASSERT(img);

+   img->_BaseFormat = 0;

+   img->InternalFormat = 0;

+   img->Border = 0;

+   img->Width = 0;

+   img->Height = 0;

+   img->Depth = 0;

+   img->RowStride = 0;

+   if (img->ImageOffsets) {

+      free(img->ImageOffsets);

+      img->ImageOffsets = NULL;

+   }

+   img->Width2 = 0;

+   img->Height2 = 0;

+   img->Depth2 = 0;

+   img->WidthLog2 = 0;

+   img->HeightLog2 = 0;

+   img->DepthLog2 = 0;

+   img->Data = NULL;

+   img->TexFormat = MESA_FORMAT_NONE;

+   img->FetchTexelc = NULL;

+   img->FetchTexelf = NULL;

+}

+

+

+/**

+ * Initialize basic fields of the gl_texture_image struct.

+ *

+ * \param ctx GL context.

+ * \param target texture target (GL_TEXTURE_1D, GL_TEXTURE_RECTANGLE, etc).

+ * \param img texture image structure to be initialized.

+ * \param width image width.

+ * \param height image height.

+ * \param depth image depth.

+ * \param border image border.

+ * \param internalFormat internal format.

+ * \param format  the actual hardware format (one of MESA_FORMAT_*)

+ *

+ * Fills in the fields of \p img with the given information.

+ * Note: width, height and depth include the border.

+ */

+void

+_mesa_init_teximage_fields(struct gl_context *ctx, GLenum target,

+                           struct gl_texture_image *img,

+                           GLsizei width, GLsizei height, GLsizei depth,

+                           GLint border, GLenum internalFormat,

+                           gl_format format)

+{

+   GLint i, dims;

+

+   ASSERT(img);

+   ASSERT(width >= 0);

+   ASSERT(height >= 0);

+   ASSERT(depth >= 0);

+

+   img->_BaseFormat = _mesa_base_tex_format( ctx, internalFormat );

+   ASSERT(img->_BaseFormat > 0);

+   img->InternalFormat = internalFormat;

+   img->Border = border;

+   img->Width = width;

+   img->Height = height;

+   img->Depth = depth;

+

+   img->Width2 = width - 2 * border;   /* == 1 << img->WidthLog2; */

+   img->WidthLog2 = logbase2(img->Width2);

+

+   if (height == 1) { /* 1-D texture */

+      img->Height2 = 1;

+      img->HeightLog2 = 0;

+   }

+   else {

+      img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */

+      img->HeightLog2 = logbase2(img->Height2);

+   }

+

+   if (depth == 1) {  /* 2-D texture */

+      img->Depth2 = 1;

+      img->DepthLog2 = 0;

+   }

+   else {

+      img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */

+      img->DepthLog2 = logbase2(img->Depth2);

+   }

+

+   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);

+

+   if ((width == 1 || _mesa_is_pow_two(img->Width2)) &&

+       (height == 1 || _mesa_is_pow_two(img->Height2)) &&

+       (depth == 1 || _mesa_is_pow_two(img->Depth2)))

+      img->_IsPowerOfTwo = GL_TRUE;

+   else

+      img->_IsPowerOfTwo = GL_FALSE;

+

+   /* RowStride and ImageOffsets[] describe how to address texels in 'Data' */

+   img->RowStride = width;

+   /* Allocate the ImageOffsets array and initialize to typical values.

+    * We allocate the array for 1D/2D textures too in order to avoid special-

+    * case code in the texstore routines.

+    */

+   if (img->ImageOffsets)

+      free(img->ImageOffsets);

+   img->ImageOffsets = (GLuint *) malloc(depth * sizeof(GLuint));

+   for (i = 0; i < depth; i++) {

+      img->ImageOffsets[i] = i * width * height;

+   }

+

+   /* Compute Width/Height/DepthScale for mipmap lod computation */

+   if (target == GL_TEXTURE_RECTANGLE_NV) {

+      /* scale = 1.0 since texture coords directly map to texels */

+      img->WidthScale = 1.0;

+      img->HeightScale = 1.0;

+      img->DepthScale = 1.0;

+   }

+   else {

+      img->WidthScale = (GLfloat) img->Width;

+      img->HeightScale = (GLfloat) img->Height;

+      img->DepthScale = (GLfloat) img->Depth;

+   }

+

+   img->TexFormat = format;

+

+   dims = _mesa_get_texture_dimensions(target);

+

+   _mesa_set_fetch_functions(img, dims);

+}

+

+

+/**

+ * Free and clear fields of the gl_texture_image struct.

+ *

+ * \param ctx GL context.

+ * \param texImage texture image structure to be cleared.

+ *

+ * After the call, \p texImage will have no data associated with it.  Its

+ * fields are cleared so that its parent object will test incomplete.

+ */

+void

+_mesa_clear_texture_image(struct gl_context *ctx,

+                          struct gl_texture_image *texImage)

+{

+   ctx->Driver.FreeTexImageData(ctx, texImage);

+   clear_teximage_fields(texImage);

+}

+

+

+/**

+ * This is the fallback for Driver.TestProxyTexImage().  Test the texture

+ * level, width, height and depth against the ctx->Const limits for textures.

+ *

+ * A hardware driver might override this function if, for example, the

+ * max 3D texture size is 512x512x64 (i.e. not a cube).

+ *

+ * Note that width, height, depth == 0 is not an error.  However, a

+ * texture with zero width/height/depth will be considered "incomplete"

+ * and texturing will effectively be disabled.

+ *

+ * \param target  one of GL_PROXY_TEXTURE_1D, GL_PROXY_TEXTURE_2D,

+ *                GL_PROXY_TEXTURE_3D, GL_PROXY_TEXTURE_RECTANGLE_NV,

+ *                GL_PROXY_TEXTURE_CUBE_MAP_ARB.

+ * \param level  as passed to glTexImage

+ * \param internalFormat  as passed to glTexImage

+ * \param format  as passed to glTexImage

+ * \param type  as passed to glTexImage

+ * \param width  as passed to glTexImage

+ * \param height  as passed to glTexImage

+ * \param depth  as passed to glTexImage

+ * \param border  as passed to glTexImage

+ * \return GL_TRUE if the image is acceptable, GL_FALSE if not acceptable.

+ */

+GLboolean

+_mesa_test_proxy_teximage(struct gl_context *ctx, GLenum target, GLint level,

+                          GLint internalFormat, GLenum format, GLenum type,

+                          GLint width, GLint height, GLint depth, GLint border)

+{

+   GLint maxSize;

+

+   (void) internalFormat;

+   (void) format;

+   (void) type;

+

+   switch (target) {

+   case GL_PROXY_TEXTURE_1D:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_2D:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_3D:

+      maxSize = 1 << (ctx->Const.Max3DTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (depth < 2 * border || depth > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.Max3DTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+         if (depth > 0 && !_mesa_is_pow_two(depth - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_RECTANGLE_NV:

+      maxSize = ctx->Const.MaxTextureRectSize;

+      if (width < 0 || width > maxSize)

+         return GL_FALSE;

+      if (height < 0 || height > maxSize)

+         return GL_FALSE;

+      if (level != 0)

+         return GL_FALSE;

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:

+      maxSize = 1 << (ctx->Const.MaxCubeTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxCubeTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 1 || height > ctx->Const.MaxArrayTextureLayers)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+      maxSize = 1 << (ctx->Const.MaxTextureLevels - 1);

+      if (width < 2 * border || width > 2 + maxSize)

+         return GL_FALSE;

+      if (height < 2 * border || height > 2 + maxSize)

+         return GL_FALSE;

+      if (depth < 1 || depth > ctx->Const.MaxArrayTextureLayers)

+         return GL_FALSE;

+      if (level >= ctx->Const.MaxTextureLevels)

+         return GL_FALSE;

+      if (!ctx->Extensions.ARB_texture_non_power_of_two) {

+         if (width > 0 && !_mesa_is_pow_two(width - 2 * border))

+            return GL_FALSE;

+         if (height > 0 && !_mesa_is_pow_two(height - 2 * border))

+            return GL_FALSE;

+      }

+      return GL_TRUE;

+

+   default:

+      _mesa_problem(ctx, "Invalid target in _mesa_test_proxy_teximage");

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if the memory used by the texture would exceed the driver's limit.

+ * This lets us support a max 3D texture size of 8K (for example) but

+ * prevents allocating a full 8K x 8K x 8K texture.

+ * XXX this could be rolled into the proxy texture size test (above) but

+ * we don't have the actual texture internal format at that point.

+ */

+static GLboolean

+legal_texture_size(struct gl_context *ctx, gl_format format,

+                   GLint width, GLint height, GLint depth)

+{

+   uint64_t bytes = _mesa_format_image_size64(format, width, height, depth);

+   uint64_t mbytes = bytes / (1024 * 1024); /* convert to MB */

+   return mbytes <= (uint64_t) ctx->Const.MaxTextureMbytes;

+}

+

+

+

+/**

+ * Helper function to determine whether a target and specific compression

+ * format are supported.

+ */

+static GLboolean

+target_can_be_compressed(const struct gl_context *ctx, GLenum target,

+                         GLenum intFormat)

+{

+   (void) intFormat;  /* not used yet */

+

+   switch (target) {

+   case GL_TEXTURE_2D:

+   case GL_PROXY_TEXTURE_2D:

+      return GL_TRUE; /* true for any compressed format so far */

+   case GL_PROXY_TEXTURE_CUBE_MAP:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+      return ctx->Extensions.ARB_texture_cube_map;

+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+      return (ctx->Extensions.MESA_texture_array ||

+              ctx->Extensions.EXT_texture_array);

+   default:

+      return GL_FALSE;

+   }      

+}

+

+

+/**

+ * Check if the given texture target value is legal for a

+ * glTexImage1/2/3D call.

+ */

+static GLboolean

+legal_teximage_target(struct gl_context *ctx, GLuint dims, GLenum target)

+{

+   switch (dims) {

+   case 1:

+      switch (target) {

+      case GL_TEXTURE_1D:

+      case GL_PROXY_TEXTURE_1D:

+         return GL_TRUE;

+      default:

+         return GL_FALSE;

+      }

+   case 2:

+      switch (target) {

+      case GL_TEXTURE_2D:

+      case GL_PROXY_TEXTURE_2D:

+         return GL_TRUE;

+      case GL_PROXY_TEXTURE_CUBE_MAP:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+         return ctx->Extensions.ARB_texture_cube_map;

+      case GL_TEXTURE_RECTANGLE_NV:

+      case GL_PROXY_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   case 3:

+      switch (target) {

+      case GL_TEXTURE_3D:

+      case GL_PROXY_TEXTURE_3D:

+         return GL_TRUE;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   default:

+      _mesa_problem(ctx, "invalid dims=%u in legal_teximage_target()", dims);

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Check if the given texture target value is legal for a

+ * glTexSubImage, glCopyTexSubImage or glCopyTexImage call.

+ * The difference compared to legal_teximage_target() above is that

+ * proxy targets are not supported.

+ */

+static GLboolean

+legal_texsubimage_target(struct gl_context *ctx, GLuint dims, GLenum target)

+{

+   switch (dims) {

+   case 1:

+      return target == GL_TEXTURE_1D;

+   case 2:

+      switch (target) {

+      case GL_TEXTURE_2D:

+         return GL_TRUE;

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

+         return ctx->Extensions.ARB_texture_cube_map;

+      case GL_TEXTURE_RECTANGLE_NV:

+         return ctx->Extensions.NV_texture_rectangle;

+      case GL_TEXTURE_1D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   case 3:

+      switch (target) {

+      case GL_TEXTURE_3D:

+         return GL_TRUE;

+      case GL_TEXTURE_2D_ARRAY_EXT:

+         return (ctx->Extensions.MESA_texture_array ||

+                 ctx->Extensions.EXT_texture_array);

+      default:

+         return GL_FALSE;

+      }

+   default:

+      _mesa_problem(ctx, "invalid dims=%u in legal_texsubimage_target()",

+                    dims);

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Test the glTexImage[123]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param internalFormat internal format given by the user.

+ * \param format pixel data format given by the user.

+ * \param type pixel data type given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param depth image depth given by the user.

+ * \param border image border given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ *

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+texture_error_check( struct gl_context *ctx,

+                     GLuint dimensions, GLenum target,

+                     GLint level, GLint internalFormat,

+                     GLenum format, GLenum type,

+                     GLint width, GLint height,

+                     GLint depth, GLint border )

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLboolean isProxy = target == proxyTarget;

+   GLboolean sizeOK = GL_TRUE;

+   GLboolean colorFormat, indexFormat;

+

+   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(level=%d)", dimensions, level);

+      }

+      return GL_TRUE;

+   }

+

+   /* Check border */

+   if (border < 0 || border > 1 ||

+       ((target == GL_TEXTURE_RECTANGLE_NV ||

+         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(border=%d)", dimensions, border);

+      }

+      return GL_TRUE;

+   }

+

+   if (width < 0 || height < 0 || depth < 0) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(width, height or depth < 0)", dimensions);

+      }

+      return GL_TRUE;

+   }

+

+   /* Do this simple check before calling the TestProxyTexImage() function */

+   if (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {

+      sizeOK = (width == height);

+   }

+

+   /*

+    * Use the proxy texture driver hook to see if the size/level/etc are

+    * legal.

+    */

+   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                                    internalFormat, format,

+                                                    type, width, height,

+                                                    depth, border);

+   if (!sizeOK) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(level=%d, width=%d, height=%d, depth=%d)",

+                     dimensions, level, width, height, depth);

+      }

+      return GL_TRUE;

+   }

+

+   /* Check internalFormat */

+   if (_mesa_base_tex_format(ctx, internalFormat) < 0) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glTexImage%dD(internalFormat=%s)",

+                     dimensions, _mesa_lookup_enum_by_nr(internalFormat));

+      }

+      return GL_TRUE;

+   }

+

+   /* Check incoming image format and type */

+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {

+      /* Normally, GL_INVALID_OPERATION is generated by a format/type

+       * mismatch (see the 1.2 spec page 94, sec 3.6.4.).  But with the

+       * GL_EXT_texture_integer extension, some combinations should generate

+       * GL_INVALID_ENUM instead (grr!).

+       */

+      if (!isProxy) {

+         GLenum error = _mesa_is_integer_format(format)

+            ? GL_INVALID_ENUM : GL_INVALID_OPERATION;

+         _mesa_error(ctx, error,

+                     "glTexImage%dD(incompatible format 0x%x, type 0x%x)",

+                     dimensions, format, type);

+      }

+      return GL_TRUE;

+   }

+

+   /* make sure internal format and format basically agree */

+   colorFormat = _mesa_is_color_format(format);

+   indexFormat = _mesa_is_index_format(format);

+   if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) ||

+       (_mesa_is_index_format(internalFormat) && !indexFormat) ||

+       (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) ||

+       (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) ||

+       (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) ||

+       (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) {

+      if (!isProxy)

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)",

+                     dimensions, internalFormat, format);

+      return GL_TRUE;

+   }

+

+   /* additional checks for ycbcr textures */

+   if (internalFormat == GL_YCBCR_MESA) {

+      ASSERT(ctx->Extensions.MESA_ycbcr_texture);

+      if (type != GL_UNSIGNED_SHORT_8_8_MESA &&

+          type != GL_UNSIGNED_SHORT_8_8_REV_MESA) {

+         char message[100];

+         _mesa_snprintf(message, sizeof(message),

+                        "glTexImage%dD(format/type YCBCR mismatch", dimensions);

+         _mesa_error(ctx, GL_INVALID_ENUM, "%s", message);

+         return GL_TRUE; /* error */

+      }

+      if (target != GL_TEXTURE_2D &&

+          target != GL_PROXY_TEXTURE_2D &&

+          target != GL_TEXTURE_RECTANGLE_NV &&

+          target != GL_PROXY_TEXTURE_RECTANGLE_NV) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         if (!isProxy) {

+            char message[100];

+            _mesa_snprintf(message, sizeof(message),

+                           "glTexImage%dD(format=GL_YCBCR_MESA and border=%d)",

+                           dimensions, border);

+            _mesa_error(ctx, GL_INVALID_VALUE, "%s", message);

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for depth textures */

+   if (_mesa_base_tex_format(ctx, internalFormat) == GL_DEPTH_COMPONENT) {

+      /* Only 1D, 2D and rectangular textures supported, not 3D or cubes */

+      if (target != GL_TEXTURE_1D &&

+          target != GL_PROXY_TEXTURE_1D &&

+          target != GL_TEXTURE_2D &&

+          target != GL_PROXY_TEXTURE_2D &&

+          target != GL_TEXTURE_RECTANGLE_ARB &&

+          target != GL_PROXY_TEXTURE_RECTANGLE_ARB) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM,

+                        "glTexImage(target/internalFormat)");

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for compressed textures */

+   if (_mesa_is_compressed_format(ctx, internalFormat)) {

+      if (!target_can_be_compressed(ctx, target, internalFormat)) {

+         if (!isProxy)

+            _mesa_error(ctx, GL_INVALID_ENUM,

+                        "glTexImage%dD(target)", dimensions);

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         if (!isProxy) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                        "glTexImage%dD(border!=0)", dimensions);

+         }

+         return GL_TRUE;

+      }

+   }

+

+   /* additional checks for integer textures */

+   if (ctx->Extensions.EXT_texture_integer &&

+       (_mesa_is_integer_format(format) !=

+        _mesa_is_integer_format(internalFormat))) {

+      if (!isProxy) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexImage%dD(integer/non-integer format mismatch)",

+                     dimensions);

+      }

+      return GL_TRUE;

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glTexSubImage[123]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param xoffset sub-image x offset given by the user.

+ * \param yoffset sub-image y offset given by the user.

+ * \param zoffset sub-image z offset given by the user.

+ * \param format pixel data format given by the user.

+ * \param type pixel data type given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param depth image depth given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ *

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+subtexture_error_check( struct gl_context *ctx, GLuint dimensions,

+                        GLenum target, GLint level,

+                        GLint xoffset, GLint yoffset, GLint zoffset,

+                        GLint width, GLint height, GLint depth,

+                        GLenum format, GLenum type )

+{

+   /* Basic level check */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level=%d)", level);

+      return GL_TRUE;

+   }

+

+   /* Check for negative sizes */

+   if (width < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(width=%d)", dimensions, width);

+      return GL_TRUE;

+   }

+   if (height < 0 && dimensions > 1) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(height=%d)", dimensions, height);

+      return GL_TRUE;

+   }

+   if (depth < 0 && dimensions > 2) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glTexSubImage%dD(depth=%d)", dimensions, depth);

+      return GL_TRUE;

+   }

+

+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {

+      /* As with the glTexImage2D check above, the error code here

+       * depends on texture integer.

+       */

+      GLenum error = _mesa_is_integer_format(format)

+         ? GL_INVALID_OPERATION : GL_INVALID_ENUM;

+      _mesa_error(ctx, error,

+                  "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)",

+                  dimensions, format, type);

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Do second part of glTexSubImage which depends on the destination texture.

+ * \return GL_TRUE if error recorded, GL_FALSE otherwise

+ */

+static GLboolean

+subtexture_error_check2( struct gl_context *ctx, GLuint dimensions,

+			 GLenum target, GLint level,

+			 GLint xoffset, GLint yoffset, GLint zoffset,

+			 GLint width, GLint height, GLint depth,

+			 GLenum format, GLenum type,

+			 const struct gl_texture_image *destTex )

+{

+   if (!destTex) {

+      /* undefined image level */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage%dD", dimensions);

+      return GL_TRUE;

+   }

+

+   if (xoffset < -((GLint)destTex->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset)",

+                  dimensions);

+      return GL_TRUE;

+   }

+   if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(xoffset+width)",

+                  dimensions);

+      return GL_TRUE;

+   }

+   if (dimensions > 1) {

+      if (yoffset < -((GLint)destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset)",

+                     dimensions);

+         return GL_TRUE;

+      }

+      if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage%dD(yoffset+height)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+   if (dimensions > 2) {

+      if (zoffset < -((GLint)destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");

+         return GL_TRUE;

+      }

+      if (zoffset + depth  > (GLint) (destTex->Depth + destTex->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");

+         return GL_TRUE;

+      }

+   }

+

+   if (_mesa_is_format_compressed(destTex->TexFormat)) {

+      GLuint bw, bh;

+

+      /* do tests which depend on compression block size */

+      _mesa_get_format_block_size(destTex->TexFormat, &bw, &bh);

+

+      /* offset must be multiple of block size */

+      if ((xoffset % bw != 0) || (yoffset % bh != 0)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(xoffset = %d, yoffset = %d)",

+                     dimensions, xoffset, yoffset);

+         return GL_TRUE;

+      }

+      /* size must be multiple of bw by bh or equal to whole texture size */

+      if ((width % bw != 0) && (GLuint) width != destTex->Width) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(width = %d)", dimensions, width);

+         return GL_TRUE;

+      }         

+      if ((height % bh != 0) && (GLuint) height != destTex->Height) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glTexSubImage%dD(height = %d)", dimensions, height);

+         return GL_TRUE;

+      }         

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glCopyTexImage[12]D() parameters for errors.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * \param internalFormat internal format given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ * \param border texture border.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ * 

+ * Verifies each of the parameters against the constants specified in

+ * __struct gl_contextRec::Const and the supported extensions, and according

+ * to the OpenGL specification.

+ */

+static GLboolean

+copytexture_error_check( struct gl_context *ctx, GLuint dimensions,

+                         GLenum target, GLint level, GLint internalFormat,

+                         GLint width, GLint height, GLint border )

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLenum type = GL_FLOAT;

+   GLboolean sizeOK;

+   GLint format;

+

+   /* check target */

+   if (!legal_texsubimage_target(ctx, dimensions, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexImage%uD(target=%s)",

+                  dimensions, _mesa_lookup_enum_by_nr(target));

+      return GL_TRUE;

+   }       

+

+   /* Basic level check (more checking in ctx->Driver.TestProxyTexImage) */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexImage%dD(level=%d)", dimensions, level);

+      return GL_TRUE;

+   }

+

+   /* Check that the source buffer is complete */

+   if (ctx->ReadBuffer->Name) {

+      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);

+      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* Check border */

+   if (border < 0 || border > 1 ||

+       ((target == GL_TEXTURE_RECTANGLE_NV ||

+         target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0)) {

+      return GL_TRUE;

+   }

+

+   format = _mesa_base_tex_format(ctx, internalFormat);

+   if (format < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexImage%dD(internalFormat)", dimensions);

+      return GL_TRUE;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, format)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexImage%dD(missing readbuffer)", dimensions);

+      return GL_TRUE;

+   }

+

+   /* Do size, level checking */

+   sizeOK = (proxyTarget == GL_PROXY_TEXTURE_CUBE_MAP_ARB)

+      ? (width == height) : 1;

+

+   sizeOK = sizeOK && ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                                    internalFormat, format,

+                                                    type, width, height,

+                                                    1, border);

+

+   if (!sizeOK) {

+      if (dimensions == 1) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexImage1D(width=%d)", width);

+      }

+      else {

+         ASSERT(dimensions == 2);

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexImage2D(width=%d, height=%d)", width, height);

+      }

+      return GL_TRUE;

+   }

+

+   if (_mesa_is_compressed_format(ctx, internalFormat)) {

+      if (!target_can_be_compressed(ctx, target, internalFormat)) {

+         _mesa_error(ctx, GL_INVALID_ENUM,

+                     "glCopyTexImage%dD(target)", dimensions);

+         return GL_TRUE;

+      }

+      if (border != 0) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(border!=0)", dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (_mesa_is_depth_format(internalFormat)) {

+      /* make sure we have depth/stencil buffers */

+      if (!ctx->ReadBuffer->_DepthBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(no depth)", dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (_mesa_is_depthstencil_format(internalFormat)) {

+      /* make sure we have depth/stencil buffers */

+      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexImage%dD(no depth/stencil buffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/**

+ * Test glCopyTexSubImage[12]D() parameters for errors.

+ * Note that this is the first part of error checking.

+ * See also copytexsubimage_error_check2() below for the second part.

+ * 

+ * \param ctx GL context.

+ * \param dimensions texture image dimensions (must be 1, 2 or 3).

+ * \param target texture target given by the user.

+ * \param level image level given by the user.

+ * 

+ * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.

+ */

+static GLboolean

+copytexsubimage_error_check1( struct gl_context *ctx, GLuint dimensions,

+                              GLenum target, GLint level)

+{

+   /* Check that the source buffer is complete */

+   if (ctx->ReadBuffer->Name) {

+      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);

+      if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+         _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                     "glCopyTexImage%dD(invalid readbuffer)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* check target (proxies not allowed) */

+   if (!legal_texsubimage_target(ctx, dimensions, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyTexSubImage%uD(target=%s)",

+                  dimensions, _mesa_lookup_enum_by_nr(target));

+      return GL_TRUE;

+   }

+

+   /* Check level */

+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(level=%d)", dimensions, level);

+      return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Second part of error checking for glCopyTexSubImage[12]D().

+ * \param xoffset sub-image x offset given by the user.

+ * \param yoffset sub-image y offset given by the user.

+ * \param zoffset sub-image z offset given by the user.

+ * \param width image width given by the user.

+ * \param height image height given by the user.

+ */

+static GLboolean

+copytexsubimage_error_check2( struct gl_context *ctx, GLuint dimensions,

+			      GLenum target, GLint level,

+			      GLint xoffset, GLint yoffset, GLint zoffset,

+			      GLsizei width, GLsizei height,

+			      const struct gl_texture_image *teximage )

+{

+   /* check that dest tex image exists */

+   if (!teximage) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(undefined texture level: %d)",

+                  dimensions, level);

+      return GL_TRUE;

+   }

+

+   /* Check size */

+   if (width < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(width=%d)", dimensions, width);

+      return GL_TRUE;

+   }

+   if (dimensions > 1 && height < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(height=%d)", dimensions, height);

+      return GL_TRUE;

+   }

+

+   /* check x/y offsets */

+   if (xoffset < -((GLint)teximage->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);

+      return GL_TRUE;

+   }

+   if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyTexSubImage%dD(xoffset+width)", dimensions);

+      return GL_TRUE;

+   }

+   if (dimensions > 1) {

+      if (yoffset < -((GLint)teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);

+         return GL_TRUE;

+      }

+      /* NOTE: we're adding the border here, not subtracting! */

+      if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(yoffset+height)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* check z offset */

+   if (dimensions > 2) {

+      if (zoffset < -((GLint)teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(zoffset)", dimensions);

+         return GL_TRUE;

+      }

+      if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(zoffset+depth)", dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   if (_mesa_is_format_compressed(teximage->TexFormat)) {

+      /* offset must be multiple of 4 */

+      if ((xoffset & 3) || (yoffset & 3)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(xoffset or yoffset)", dimensions);

+         return GL_TRUE;

+      }

+      /* size must be multiple of 4 */

+      if ((width & 3) != 0 && (GLuint) width != teximage->Width) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(width)", dimensions);

+         return GL_TRUE;

+      }         

+      if ((height & 3) != 0 && (GLuint) height != teximage->Height) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyTexSubImage%dD(height)", dimensions);

+         return GL_TRUE;

+      }         

+   }

+

+   if (teximage->InternalFormat == GL_YCBCR_MESA) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");

+      return GL_TRUE;

+   }

+

+   if (!_mesa_source_buffer_exists(ctx, teximage->_BaseFormat)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(missing readbuffer, format=0x%x)",

+                  dimensions, teximage->_BaseFormat);

+      return GL_TRUE;

+   }

+

+   if (teximage->_BaseFormat == GL_DEPTH_COMPONENT) {

+      if (!ctx->ReadBuffer->_DepthBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexSubImage%dD(no depth buffer)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+   else if (teximage->_BaseFormat == GL_DEPTH_STENCIL_EXT) {

+      if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glCopyTexSubImage%dD(no depth/stencil buffer)",

+                     dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* If copying into an integer texture, the source buffer must also be

+    * integer-valued.

+    */

+   if (_mesa_is_format_integer_color(teximage->TexFormat)) {

+      struct gl_renderbuffer *rb = ctx->ReadBuffer->_ColorReadBuffer;

+      if (!_mesa_is_format_integer_color(rb->Format)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyTexSubImage%dD(source buffer is not integer format)",

+                  dimensions);

+         return GL_TRUE;

+      }

+   }

+

+   /* if we get here, the parameters are OK */

+   return GL_FALSE;

+}

+

+

+/** Callback info for walking over FBO hash table */

+struct cb_info

+{

+   struct gl_context *ctx;

+   struct gl_texture_object *texObj;

+   GLuint level, face;

+};

+

+

+/**

+ * Check render to texture callback.  Called from _mesa_HashWalk().

+ */

+static void

+check_rtt_cb(GLuint key, void *data, void *userData)

+{

+   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;

+   const struct cb_info *info = (struct cb_info *) userData;

+   struct gl_context *ctx = info->ctx;

+   const struct gl_texture_object *texObj = info->texObj;

+   const GLuint level = info->level, face = info->face;

+

+   /* If this is a user-created FBO */

+   if (fb->Name) {

+      GLuint i;

+      /* check if any of the FBO's attachments point to 'texObj' */

+      for (i = 0; i < BUFFER_COUNT; i++) {

+         struct gl_renderbuffer_attachment *att = fb->Attachment + i;

+         if (att->Type == GL_TEXTURE &&

+             att->Texture == texObj &&

+             att->TextureLevel == level &&

+             att->CubeMapFace == face) {

+            ASSERT(att->Texture->Image[att->CubeMapFace][att->TextureLevel]);

+            /* Tell driver about the new renderbuffer texture */

+            ctx->Driver.RenderTexture(ctx, ctx->DrawBuffer, att);

+            /* Mark fb status as indeterminate to force re-validation */

+            fb->_Status = 0;

+         }

+      }

+   }

+}

+

+

+/**

+ * When a texture image is specified we have to check if it's bound to

+ * any framebuffer objects (render to texture) in order to detect changes

+ * in size or format since that effects FBO completeness.

+ * Any FBOs rendering into the texture must be re-validated.

+ */

+static void

+update_fbo_texture(struct gl_context *ctx, struct gl_texture_object *texObj,

+                   GLuint face, GLuint level)

+{

+   /* Only check this texture if it's been marked as RenderToTexture */

+   if (texObj->_RenderToTexture) {

+      struct cb_info info;

+      info.ctx = ctx;

+      info.texObj = texObj;

+      info.level = level;

+      info.face = face;

+      _mesa_HashWalk(ctx->Shared->FrameBuffers, check_rtt_cb, &info);

+   }

+}

+

+

+/**

+ * If the texture object's GenerateMipmap flag is set and we've

+ * changed the texture base level image, regenerate the rest of the

+ * mipmap levels now.

+ */

+static INLINE void

+check_gen_mipmap(struct gl_context *ctx, GLenum target,

+                 struct gl_texture_object *texObj, GLint level)

+{

+   ASSERT(target != GL_TEXTURE_CUBE_MAP);

+   if (texObj->GenerateMipmap &&

+       level == texObj->BaseLevel &&

+       level < texObj->MaxLevel) {

+      ASSERT(ctx->Driver.GenerateMipmap);

+      ctx->Driver.GenerateMipmap(ctx, target, texObj);

+   }

+}

+

+

+/** Debug helper: override the user-requested internal format */

+static GLenum

+override_internal_format(GLenum internalFormat, GLint width, GLint height)

+{

+#if 0

+   if (internalFormat == GL_RGBA16F_ARB ||

+       internalFormat == GL_RGBA32F_ARB) {

+      printf("Convert rgba float tex to int %d x %d\n", width, height);

+      return GL_RGBA;

+   }

+   else if (internalFormat == GL_RGB16F_ARB ||

+            internalFormat == GL_RGB32F_ARB) {

+      printf("Convert rgb float tex to int %d x %d\n", width, height);

+      return GL_RGB;

+   }

+   else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB ||

+            internalFormat == GL_LUMINANCE_ALPHA32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_LUMINANCE_ALPHA;

+   }

+   else if (internalFormat == GL_LUMINANCE16F_ARB ||

+            internalFormat == GL_LUMINANCE32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_LUMINANCE;

+   }

+   else if (internalFormat == GL_ALPHA16F_ARB ||

+            internalFormat == GL_ALPHA32F_ARB) {

+      printf("Convert luminance float tex to int %d x %d\n", width, height);

+      return GL_ALPHA;

+   }

+   /*

+   else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {

+      internalFormat = GL_RGBA;

+   }

+   */

+   else {

+      return internalFormat;

+   }

+#else

+   return internalFormat;

+#endif

+}

+

+

+/**

+ * Choose the actual hardware format for a texture image.

+ * Try to use the same format as the previous image level when possible.

+ * Otherwise, ask the driver for the best format.

+ * It's important to try to choose a consistant format for all levels

+ * for efficient texture memory layout/allocation.  In particular, this

+ * comes up during automatic mipmap generation.

+ */

+gl_format

+_mesa_choose_texture_format(struct gl_context *ctx,

+                            struct gl_texture_object *texObj,

+                            GLenum target, GLint level,

+                            GLenum internalFormat, GLenum format, GLenum type)

+{

+   gl_format f;

+

+   /* see if we've already chosen a format for the previous level */

+   if (level > 0) {

+      struct gl_texture_image *prevImage =

+	 _mesa_select_tex_image(ctx, texObj, target, level - 1);

+      /* See if the prev level is defined and has an internal format which

+       * matches the new internal format.

+       */

+      if (prevImage &&

+          prevImage->Width > 0 &&

+          prevImage->InternalFormat == internalFormat) {

+         /* use the same format */

+         ASSERT(prevImage->TexFormat != MESA_FORMAT_NONE);

+         return prevImage->TexFormat;

+      }

+   }

+

+   /* choose format from scratch */

+   f = ctx->Driver.ChooseTextureFormat(ctx, internalFormat, format, type);

+   ASSERT(f != MESA_FORMAT_NONE);

+   return f;

+}

+

+

+/**

+ * Common code to implement all the glTexImage1D/2D/3D functions.

+ */

+static void

+teximage(struct gl_context *ctx, GLuint dims,

+         GLenum target, GLint level, GLint internalFormat,

+         GLsizei width, GLsizei height, GLsizei depth,

+         GLint border, GLenum format, GLenum type,

+         const GLvoid *pixels)

+{

+   GLboolean error;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glTexImage%uD %s %d %s %d %d %d %d %s %s %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  width, height, depth, border,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type), pixels);

+

+   internalFormat = override_internal_format(internalFormat, width, height);

+

+   /* target error checking */

+   if (!legal_teximage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }

+

+   /* general error checking */

+   error = texture_error_check(ctx, dims, target, level, internalFormat,

+                               format, type, width, height, depth, border);

+

+   if (_mesa_is_proxy_texture(target)) {

+      /* Proxy texture: just clear or set state depending on error checking */

+      struct gl_texture_image *texImage =

+         _mesa_get_proxy_tex_image(ctx, target, level);

+

+      if (error) {

+         /* when error, clear all proxy texture image parameters */

+         if (texImage)

+            clear_teximage_fields(texImage);

+      }

+      else {

+         /* no error, set the tex image parameters */

+         struct gl_texture_object *texObj =

+            _mesa_get_current_tex_object(ctx, target);

+         gl_format texFormat = _mesa_choose_texture_format(ctx, texObj,

+                                                           target, level,

+                                                           internalFormat,

+                                                           format, type);

+

+         if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height,

+                                       depth, border, internalFormat,

+                                       texFormat);

+         }

+         else if (texImage) {

+            clear_teximage_fields(texImage);

+         }

+      }

+   }

+   else {

+      /* non-proxy target */

+      const GLuint face = _mesa_tex_target_to_face(target);

+      struct gl_texture_object *texObj;

+      struct gl_texture_image *texImage;

+

+      if (error) {

+         return;   /* error was recorded */

+      }

+

+      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+	 _mesa_update_state(ctx);

+

+      texObj = _mesa_get_current_tex_object(ctx, target);

+

+      _mesa_lock_texture(ctx, texObj);

+      {

+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+

+	 if (!texImage) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);

+	 }

+         else {

+            gl_format texFormat;

+

+            if (texImage->Data) {

+               ctx->Driver.FreeTexImageData( ctx, texImage );

+            }

+

+            ASSERT(texImage->Data == NULL);

+            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                    internalFormat, format,

+                                                    type);

+

+            if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+               _mesa_init_teximage_fields(ctx, target, texImage,

+                                          width, height, depth,

+                                          border, internalFormat, texFormat);

+

+               /* Give the texture to the driver.  <pixels> may be null. */

+               ASSERT(ctx->Driver.TexImage3D);

+               switch (dims) {

+               case 1:

+                  ctx->Driver.TexImage1D(ctx, target, level, internalFormat,

+                                         width, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               case 2:

+                  ctx->Driver.TexImage2D(ctx, target, level, internalFormat,

+                                         width, height, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               case 3:

+                  ctx->Driver.TexImage3D(ctx, target, level, internalFormat,

+                                         width, height, depth, border, format,

+                                         type, pixels, &ctx->Unpack, texObj,

+                                         texImage);

+                  break;

+               default:

+                  _mesa_problem(ctx, "invalid dims=%u in teximage()", dims);

+               }

+

+               check_gen_mipmap(ctx, target, texObj, level);

+

+               update_fbo_texture(ctx, texObj, face, level);

+

+               /* state update */

+               texObj->_Complete = GL_FALSE;

+               ctx->NewState |= _NEW_TEXTURE;

+            }

+            else {

+               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims);

+            }

+         }

+      }

+      _mesa_unlock_texture(ctx, texObj);

+   }

+}

+

+

+/*

+ * Called from the API.  Note that width includes the border.

+ */

+void GLAPIENTRY

+_mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLint border, GLenum format,

+                  GLenum type, const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 1, target, level, internalFormat, width, 1, 1,

+            border, format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLsizei height, GLint border,

+                  GLenum format, GLenum type,

+                  const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 2, target, level, internalFormat, width, height, 1,

+            border, format, type, pixels);

+}

+

+

+/*

+ * Called by the API or display list executor.

+ * Note that width and height include the border.

+ */

+void GLAPIENTRY

+_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,

+                  GLsizei width, GLsizei height, GLsizei depth,

+                  GLint border, GLenum format, GLenum type,

+                  const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   teximage(ctx, 3, target, level, internalFormat, width, height, depth,

+            border, format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalFormat,

+                     GLsizei width, GLsizei height, GLsizei depth,

+                     GLint border, GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,

+                    depth, border, format, type, pixels);

+}

+

+

+#if FEATURE_OES_EGL_image

+void GLAPIENTRY

+_mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (!ctx->Extensions.OES_EGL_image) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glEGLImageTargetTexture2DOES(unsupported)");

+      return;

+   }

+

+   if (target != GL_TEXTURE_2D) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+		  "glEGLImageTargetTexture2D(target=%d)", target);

+      return;

+   }

+

+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_state(ctx);

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+   _mesa_lock_texture(ctx, texObj);

+

+   texImage = _mesa_get_tex_image(ctx, texObj, target, 0);

+   if (!texImage) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEGLImageTargetTexture2D");

+   } else {

+      if (texImage->Data)

+	 ctx->Driver.FreeTexImageData( ctx, texImage );

+

+      ASSERT(texImage->Data == NULL);

+      ctx->Driver.EGLImageTargetTexture2D(ctx, target,

+					  texObj, texImage, image);

+

+      /* state update */

+      texObj->_Complete = GL_FALSE;

+      ctx->NewState |= _NEW_TEXTURE;

+   }

+   _mesa_unlock_texture(ctx, texObj);

+

+}

+#endif

+

+

+

+/**

+ * Implement all the glTexSubImage1/2/3D() functions.

+ */

+static void

+texsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,

+            GLint xoffset, GLint yoffset, GLint zoffset,

+            GLsizei width, GLsizei height, GLsizei depth,

+            GLenum format, GLenum type, const GLvoid *pixels )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glTexSubImage%uD %s %d %d %d %d %d %d %d %s %s %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  xoffset, yoffset, zoffset, width, height, depth,

+                  _mesa_lookup_enum_by_nr(format),

+                  _mesa_lookup_enum_by_nr(type), pixels);

+

+   /* check target (proxies not allowed) */

+   if (!legal_texsubimage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexSubImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }       

+

+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_state(ctx);

+

+   if (subtexture_error_check(ctx, dims, target, level, xoffset, yoffset, zoffset,

+                              width, height, depth, format, type)) {

+      return;   /* error was detected */

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+      if (subtexture_error_check2(ctx, dims, target, level,

+                                  xoffset, yoffset, zoffset,

+				  width, height, depth,

+                                  format, type, texImage)) {

+         /* error was recorded */

+      }

+      else if (width > 0 && height > 0 && height > 0) {

+         /* If we have a border, offset=-1 is legal.  Bias by border width. */

+         switch (dims) {

+         case 3:

+            zoffset += texImage->Border;

+            /* fall-through */

+         case 2:

+            yoffset += texImage->Border;

+            /* fall-through */

+         case 1:

+            xoffset += texImage->Border;

+         }

+

+         switch (dims) {

+         case 1:

+            ctx->Driver.TexSubImage1D(ctx, target, level,

+                                      xoffset, width,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         case 2:

+            ctx->Driver.TexSubImage2D(ctx, target, level,

+                                      xoffset, yoffset, width, height,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         case 3:

+            ctx->Driver.TexSubImage3D(ctx, target, level,

+                                      xoffset, yoffset, zoffset,

+                                      width, height, depth,

+                                      format, type, pixels,

+                                      &ctx->Unpack, texObj, texImage );

+            break;

+         default:

+            _mesa_problem(ctx, "unexpected dims in subteximage()");

+         }

+

+         check_gen_mipmap(ctx, target, texObj, level);

+

+         ctx->NewState |= _NEW_TEXTURE;

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_TexSubImage1D( GLenum target, GLint level,

+                     GLint xoffset, GLsizei width,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 1, target, level,

+               xoffset, 0, 0,

+               width, 1, 1,

+               format, type, pixels);

+}

+

+

+void GLAPIENTRY

+_mesa_TexSubImage2D( GLenum target, GLint level,

+                     GLint xoffset, GLint yoffset,

+                     GLsizei width, GLsizei height,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 2, target, level,

+               xoffset, yoffset, 0,

+               width, height, 1,

+               format, type, pixels);

+}

+

+

+

+void GLAPIENTRY

+_mesa_TexSubImage3D( GLenum target, GLint level,

+                     GLint xoffset, GLint yoffset, GLint zoffset,

+                     GLsizei width, GLsizei height, GLsizei depth,

+                     GLenum format, GLenum type,

+                     const GLvoid *pixels )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   texsubimage(ctx, 3, target, level,

+               xoffset, yoffset, zoffset,

+               width, height, depth,

+               format, type, pixels);

+}

+

+

+

+/**

+ * Implement the glCopyTexImage1/2D() functions.

+ */

+static void

+copyteximage(struct gl_context *ctx, GLuint dims,

+             GLenum target, GLint level, GLenum internalFormat,

+             GLint x, GLint y, GLsizei width, GLsizei height, GLint border )

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   const GLuint face = _mesa_tex_target_to_face(target);

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glCopyTexImage%uD %s %d %s %d %d %d %d %d\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  x, y, width, height, border);

+

+   if (ctx->NewState & NEW_COPY_TEX_STATE)

+      _mesa_update_state(ctx);

+

+   if (copytexture_error_check(ctx, dims, target, level, internalFormat,

+                               width, height, border))

+      return;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+

+      if (!texImage) {

+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);

+      }

+      else {

+         gl_format texFormat;

+

+         if (texImage->Data) {

+            ctx->Driver.FreeTexImageData( ctx, texImage );

+         }

+

+         ASSERT(texImage->Data == NULL);

+

+         texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                 internalFormat, GL_NONE,

+                                                 GL_NONE);

+

+         if (legal_texture_size(ctx, texFormat, width, height, 1)) {

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,

+                                       border, internalFormat, texFormat);

+

+            ASSERT(ctx->Driver.CopyTexImage2D);

+            if (dims == 1)

+               ctx->Driver.CopyTexImage1D(ctx, target, level, internalFormat,

+                                          x, y, width, border);

+            else

+               ctx->Driver.CopyTexImage2D(ctx, target, level, internalFormat,

+                                          x, y, width, height, border);

+

+            check_gen_mipmap(ctx, target, texObj, level);

+

+            update_fbo_texture(ctx, texObj, face, level);

+

+            /* state update */

+            texObj->_Complete = GL_FALSE;

+            ctx->NewState |= _NEW_TEXTURE;

+         }

+         else {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage%uD", dims);

+         }

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexImage1D( GLenum target, GLint level,

+                      GLenum internalFormat,

+                      GLint x, GLint y,

+                      GLsizei width, GLint border )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copyteximage(ctx, 1, target, level, internalFormat, x, y, width, 1, border);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,

+                      GLint x, GLint y, GLsizei width, GLsizei height,

+                      GLint border )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copyteximage(ctx, 2, target, level, internalFormat,

+                x, y, width, height, border);

+}

+

+

+

+/**

+ * Implementation for glCopyTexSubImage1/2/3D() functions.

+ */

+static void

+copytexsubimage(struct gl_context *ctx, GLuint dims, GLenum target, GLint level,

+                GLint xoffset, GLint yoffset, GLint zoffset,

+                GLint x, GLint y, GLsizei width, GLsizei height)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx, "glCopyTexSubImage%uD %s %d %d %d %d %d %d %d %d\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target),

+                  level, xoffset, yoffset, zoffset, x, y, width, height);

+

+   if (ctx->NewState & NEW_COPY_TEX_STATE)

+      _mesa_update_state(ctx);

+

+   if (copytexsubimage_error_check1(ctx, dims, target, level))

+      return;

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+

+      if (copytexsubimage_error_check2(ctx, dims, target, level, xoffset, yoffset,

+				       zoffset, width, height, texImage)) {

+         /* error was recored */

+      }

+      else {

+         /* If we have a border, offset=-1 is legal.  Bias by border width. */

+         switch (dims) {

+         case 3:

+            zoffset += texImage->Border;

+            /* fall-through */

+         case 2:

+            yoffset += texImage->Border;

+            /* fall-through */

+         case 1:

+            xoffset += texImage->Border;

+         }

+

+         if (_mesa_clip_copytexsubimage(ctx, &xoffset, &yoffset, &x, &y,

+                                        &width, &height)) {

+            switch (dims) {

+            case 1:

+               ctx->Driver.CopyTexSubImage1D(ctx, target, level,

+                                             xoffset, x, y, width);

+               break;

+            case 2:

+               ctx->Driver.CopyTexSubImage2D(ctx, target, level,

+                                             xoffset, yoffset,

+                                             x, y, width, height);

+               break;

+            case 3:

+               ctx->Driver.CopyTexSubImage3D(ctx, target, level,

+                                             xoffset, yoffset, zoffset,

+                                             x, y, width, height);

+               break;

+            default:

+               _mesa_problem(ctx, "bad dims in copytexsubimage()");

+            }

+

+            check_gen_mipmap(ctx, target, texObj, level);

+

+            ctx->NewState |= _NEW_TEXTURE;

+         }

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage1D( GLenum target, GLint level,

+                         GLint xoffset, GLint x, GLint y, GLsizei width )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 1, target, level, xoffset, 0, 0, x, y, width, 1);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage2D( GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset,

+                         GLint x, GLint y, GLsizei width, GLsizei height )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 2, target, level, xoffset, yoffset, 0, x, y,

+                   width, height);

+}

+

+

+

+void GLAPIENTRY

+_mesa_CopyTexSubImage3D( GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset, GLint zoffset,

+                         GLint x, GLint y, GLsizei width, GLsizei height )

+{

+   GET_CURRENT_CONTEXT(ctx);

+   copytexsubimage(ctx, 3, target, level, xoffset, yoffset, zoffset,

+                   x, y, width, height);

+}

+

+

+

+

+/**********************************************************************/

+/******                   Compressed Textures                    ******/

+/**********************************************************************/

+

+

+/**

+ * Return expected size of a compressed texture.

+ */

+static GLuint

+compressed_tex_size(GLsizei width, GLsizei height, GLsizei depth,

+                    GLenum glformat)

+{

+   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);

+   return _mesa_format_image_size(mesaFormat, width, height, depth);

+}

+

+

+/*

+ * Return compressed texture block size, in pixels.

+ */

+static void

+get_compressed_block_size(GLenum glformat, GLuint *bw, GLuint *bh)

+{

+   gl_format mesaFormat = _mesa_glenum_to_compressed_format(glformat);

+   _mesa_get_format_block_size(mesaFormat, bw, bh);

+}

+

+

+/**

+ * Error checking for glCompressedTexImage[123]D().

+ * \return error code or GL_NO_ERROR.

+ */

+static GLenum

+compressed_texture_error_check(struct gl_context *ctx, GLint dimensions,

+                               GLenum target, GLint level,

+                               GLenum internalFormat, GLsizei width,

+                               GLsizei height, GLsizei depth, GLint border,

+                               GLsizei imageSize)

+{

+   const GLenum proxyTarget = get_proxy_target(target);

+   const GLint maxLevels = _mesa_max_texture_levels(ctx, target);

+   GLint expectedSize;

+

+   /* check level */

+   if (level < 0 || level >= maxLevels)

+      return GL_INVALID_VALUE;

+

+   if (!target_can_be_compressed(ctx, target, internalFormat)) {

+      return GL_INVALID_ENUM;

+   }

+

+   /* This will detect any invalid internalFormat value */

+   if (!_mesa_is_compressed_format(ctx, internalFormat))

+      return GL_INVALID_ENUM;

+

+   /* This should really never fail */

+   if (_mesa_base_tex_format(ctx, internalFormat) < 0)

+      return GL_INVALID_ENUM;

+

+   /* No compressed formats support borders at this time */

+   if (border != 0)

+      return GL_INVALID_VALUE;

+

+   /* For cube map, width must equal height */

+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB && width != height)

+      return GL_INVALID_VALUE;

+

+   /* check image size against compression block size */

+   {

+      gl_format texFormat =

+         ctx->Driver.ChooseTextureFormat(ctx, internalFormat,

+                                         GL_NONE, GL_NONE);

+      GLuint bw, bh;

+

+      _mesa_get_format_block_size(texFormat, &bw, &bh);

+      if ((width > bw && width % bw > 0) ||

+          (height > bh && height % bh > 0)) {

+         /*

+          * Per GL_ARB_texture_compression:  GL_INVALID_OPERATION is

+          * generated [...] if any parameter combinations are not

+          * supported by the specific compressed internal format. 

+          */

+         return GL_INVALID_OPERATION;

+      }

+   }

+

+   /* check image sizes */

+   if (!ctx->Driver.TestProxyTexImage(ctx, proxyTarget, level,

+                                      internalFormat, GL_NONE, GL_NONE,

+                                      width, height, depth, border)) {

+      /* See error comment above */

+      return GL_INVALID_OPERATION;

+   }

+

+   /* check image size in bytes */

+   expectedSize = compressed_tex_size(width, height, depth, internalFormat);

+   if (expectedSize != imageSize) {

+      /* Per GL_ARB_texture_compression:  GL_INVALID_VALUE is generated [...]

+       * if <imageSize> is not consistent with the format, dimensions, and

+       * contents of the specified image.

+       */

+      return GL_INVALID_VALUE;

+   }

+

+   return GL_NO_ERROR;

+}

+

+

+/**

+ * Error checking for glCompressedTexSubImage[123]D().

+ * \warning  There are some bad assumptions here about the size of compressed

+ *           texture tiles (multiple of 4) used to test the validity of the

+ *           offset and size parameters.

+ * \return error code or GL_NO_ERROR.

+ */

+static GLenum

+compressed_subtexture_error_check(struct gl_context *ctx, GLint dimensions,

+                                  GLenum target, GLint level,

+                                  GLint xoffset, GLint yoffset, GLint zoffset,

+                                  GLsizei width, GLsizei height, GLsizei depth,

+                                  GLenum format, GLsizei imageSize)

+{

+   GLint expectedSize, maxLevels = 0, maxTextureSize;

+   GLuint bw, bh;

+   (void) zoffset;

+

+   if (dimensions == 1) {

+      /* 1D compressed textures not allowed */

+      return GL_INVALID_ENUM;

+   }

+   else if (dimensions == 2) {

+      if (target == GL_PROXY_TEXTURE_2D) {

+         maxLevels = ctx->Const.MaxTextureLevels;

+      }

+      else if (target == GL_TEXTURE_2D) {

+         maxLevels = ctx->Const.MaxTextureLevels;

+      }

+      else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {

+         if (!ctx->Extensions.ARB_texture_cube_map)

+            return GL_INVALID_ENUM; /*target*/

+         maxLevels = ctx->Const.MaxCubeTextureLevels;

+      }

+      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&

+               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {

+         if (!ctx->Extensions.ARB_texture_cube_map)

+            return GL_INVALID_ENUM; /*target*/

+         maxLevels = ctx->Const.MaxCubeTextureLevels;

+      }

+      else {

+         return GL_INVALID_ENUM; /*target*/

+      }

+   }

+   else if (dimensions == 3) {

+      /* 3D compressed textures not allowed */

+      return GL_INVALID_ENUM;

+   }

+

+   maxTextureSize = 1 << (maxLevels - 1);

+

+   /* this will catch any invalid compressed format token */

+   if (!_mesa_is_compressed_format(ctx, format))

+      return GL_INVALID_ENUM;

+

+   if (width < 1 || width > maxTextureSize)

+      return GL_INVALID_VALUE;

+

+   if ((height < 1 || height > maxTextureSize)

+       && dimensions > 1)

+      return GL_INVALID_VALUE;

+

+   if (level < 0 || level >= maxLevels)

+      return GL_INVALID_VALUE;

+

+   /*

+    * do checks which depend on compression block size

+    */

+   get_compressed_block_size(format, &bw, &bh);

+

+   if ((xoffset % bw != 0) || (yoffset % bh != 0))

+      return GL_INVALID_VALUE;

+

+   if ((width % bw != 0) && width != 2 && width != 1)

+      return GL_INVALID_VALUE;

+

+   if ((height % bh != 0) && height != 2 && height != 1)

+      return GL_INVALID_VALUE;

+

+   expectedSize = compressed_tex_size(width, height, depth, format);

+   if (expectedSize != imageSize)

+      return GL_INVALID_VALUE;

+

+   return GL_NO_ERROR;

+}

+

+

+/**

+ * Do second part of glCompressedTexSubImage error checking.

+ * \return GL_TRUE if error found, GL_FALSE otherwise.

+ */

+static GLboolean

+compressed_subtexture_error_check2(struct gl_context *ctx, GLuint dims,

+                                   GLsizei width, GLsizei height,

+                                   GLsizei depth, GLenum format,

+                                   struct gl_texture_image *texImage)

+{

+

+   if ((GLint) format != texImage->InternalFormat) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCompressedTexSubImage%uD(format=0x%x)", dims, format);

+      return GL_TRUE;

+   }

+

+   if (((width == 1 || width == 2) &&

+        width != (GLsizei) texImage->Width) ||

+       (width > (GLsizei) texImage->Width)) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCompressedTexSubImage%uD(width=%d)", dims, width);

+      return GL_TRUE;

+   }

+

+   if (dims >= 2) {

+      if (((height == 1 || height == 2) &&

+           height != (GLsizei) texImage->Height) ||

+          (height > (GLsizei) texImage->Height)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCompressedTexSubImage%uD(height=%d)", dims, height);

+         return GL_TRUE;

+      }

+   }

+

+   if (dims >= 3) {

+      if (((depth == 1 || depth == 2) &&

+           depth != (GLsizei) texImage->Depth) ||

+          (depth > (GLsizei) texImage->Depth)) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCompressedTexSubImage%uD(depth=%d)", dims, depth);

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Implementation of the glCompressedTexImage1/2/3D() functions.

+ */

+static void

+compressedteximage(struct gl_context *ctx, GLuint dims,

+                   GLenum target, GLint level,

+                   GLenum internalFormat, GLsizei width,

+                   GLsizei height, GLsizei depth, GLint border,

+                   GLsizei imageSize, const GLvoid *data)

+{

+   GLenum error;

+

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))

+      _mesa_debug(ctx,

+                  "glCompressedTexImage%uDARB %s %d %s %d %d %d %d %d %p\n",

+                  dims,

+                  _mesa_lookup_enum_by_nr(target), level,

+                  _mesa_lookup_enum_by_nr(internalFormat),

+                  width, height, depth, border, imageSize, data);

+

+   /* check target */

+   if (!legal_teximage_target(ctx, dims, target)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage%uD(target=%s)",

+                  dims, _mesa_lookup_enum_by_nr(target));

+      return;

+   }

+

+   error = compressed_texture_error_check(ctx, dims, target, level,

+                                          internalFormat, width, height, depth,

+                                          border, imageSize);

+

+#if FEATURE_ES

+   /* XXX this is kind of a hack */

+   if (error) {

+      _mesa_error(ctx, error, "glTexImage2D");

+      return;

+   }

+

+   if (dims == 2) {

+      switch (internalFormat) {

+      case GL_PALETTE4_RGB8_OES:

+      case GL_PALETTE4_RGBA8_OES:

+      case GL_PALETTE4_R5_G6_B5_OES:

+      case GL_PALETTE4_RGBA4_OES:

+      case GL_PALETTE4_RGB5_A1_OES:

+      case GL_PALETTE8_RGB8_OES:

+      case GL_PALETTE8_RGBA8_OES:

+      case GL_PALETTE8_R5_G6_B5_OES:

+      case GL_PALETTE8_RGBA4_OES:

+      case GL_PALETTE8_RGB5_A1_OES:

+         _mesa_cpal_compressed_teximage2d(target, level, internalFormat,

+                                          width, height, imageSize, data);

+         return;

+      }

+   }

+#endif

+

+   if (_mesa_is_proxy_texture(target)) {

+      /* Proxy texture: just check for errors and update proxy state */

+      struct gl_texture_image *texImage;

+

+      if (!error) {

+         struct gl_texture_object *texObj =

+            _mesa_get_current_tex_object(ctx, target);

+         gl_format texFormat =

+            _mesa_choose_texture_format(ctx, texObj, target, level,

+                                        internalFormat, GL_NONE, GL_NONE);

+         if (!legal_texture_size(ctx, texFormat, width, height, depth)) {

+            error = GL_OUT_OF_MEMORY;

+         }

+      }

+

+      texImage = _mesa_get_proxy_tex_image(ctx, target, level);

+      if (texImage) {

+         if (error) {

+            /* if error, clear all proxy texture image parameters */

+            clear_teximage_fields(texImage);

+         }

+         else {

+            /* no error: store the teximage parameters */

+            _mesa_init_teximage_fields(ctx, target, texImage, width, height,

+                                       depth, border, internalFormat,

+                                       MESA_FORMAT_NONE);

+         }

+      }

+   }

+   else {

+      /* non-proxy target */

+      struct gl_texture_object *texObj;

+      struct gl_texture_image *texImage;

+

+      if (error) {

+         _mesa_error(ctx, error, "glCompressedTexImage%uD", dims);

+         return;

+      }

+

+      texObj = _mesa_get_current_tex_object(ctx, target);

+

+      _mesa_lock_texture(ctx, texObj);

+      {

+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+	 if (!texImage) {

+	    _mesa_error(ctx, GL_OUT_OF_MEMORY,

+                        "glCompressedTexImage%uD", dims);

+	 }

+         else {

+            gl_format texFormat;

+

+            if (texImage->Data) {

+               ctx->Driver.FreeTexImageData( ctx, texImage );

+            }

+            ASSERT(texImage->Data == NULL);

+

+            texFormat = _mesa_choose_texture_format(ctx, texObj, target, level,

+                                                    internalFormat, GL_NONE,

+                                                    GL_NONE);

+

+            if (legal_texture_size(ctx, texFormat, width, height, depth)) {

+               _mesa_init_teximage_fields(ctx, target, texImage,

+                                          width, height, depth,

+                                          border, internalFormat, texFormat);

+

+               switch (dims) {

+               case 1:

+                  ASSERT(ctx->Driver.CompressedTexImage1D);

+                  ctx->Driver.CompressedTexImage1D(ctx, target, level,

+                                                   internalFormat,

+                                                   width,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               case 2:

+                  ASSERT(ctx->Driver.CompressedTexImage2D);

+                  ctx->Driver.CompressedTexImage2D(ctx, target, level,

+                                                   internalFormat,

+                                                   width, height,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               case 3:

+                  ASSERT(ctx->Driver.CompressedTexImage3D);

+                  ctx->Driver.CompressedTexImage3D(ctx, target, level,

+                                                   internalFormat,

+                                                   width, height, depth,

+                                                   border, imageSize, data,

+                                                   texObj, texImage);

+                  break;

+               default:

+                  _mesa_problem(ctx, "bad dims in compressedteximage");

+               }

+

+               check_gen_mipmap(ctx, target, texObj, level);

+

+               /* state update */

+               texObj->_Complete = GL_FALSE;

+               ctx->NewState |= _NEW_TEXTURE;

+            }

+            else {

+               _mesa_error(ctx, GL_OUT_OF_MEMORY,

+                           "glCompressedTexImage%uD", dims);

+            }

+         }

+      }

+      _mesa_unlock_texture(ctx, texObj);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage1DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLint border, GLsizei imageSize,

+                              const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 1, target, level, internalFormat,

+                      width, 1, 1, border, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage2DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLsizei height, GLint border, GLsizei imageSize,

+                              const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 2, target, level, internalFormat,

+                      width, height, 1, border, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexImage3DARB(GLenum target, GLint level,

+                              GLenum internalFormat, GLsizei width,

+                              GLsizei height, GLsizei depth, GLint border,

+                              GLsizei imageSize, const GLvoid *data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   compressedteximage(ctx, 3, target, level, internalFormat,

+                      width, height, depth, border, imageSize, data);

+}

+

+

+/**

+ * Common helper for glCompressedTexSubImage1/2/3D().

+ */

+static void

+compressed_tex_sub_image(GLuint dims, GLenum target, GLint level,

+                         GLint xoffset, GLint yoffset, GLint zoffset,

+                         GLsizei width, GLsizei height, GLsizei depth,

+                         GLenum format, GLsizei imageSize, const GLvoid *data)

+{

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   GLenum error;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+

+   error = compressed_subtexture_error_check(ctx, dims, target, level,

+                                             xoffset, 0, 0, /* pos */

+                                             width, height, depth,   /* size */

+                                             format, imageSize);

+   if (error) {

+      _mesa_error(ctx, error, "glCompressedTexSubImage%uD", dims);

+      return;

+   }

+

+   texObj = _mesa_get_current_tex_object(ctx, target);

+

+   _mesa_lock_texture(ctx, texObj);

+   {

+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);

+      assert(texImage);

+

+      if (compressed_subtexture_error_check2(ctx, dims, width, height, depth,

+                                             format, texImage)) {

+         /* error was recorded */

+      }

+      else if (width > 0 && height > 0 && depth > 0) {

+         switch (dims) {

+         case 1:

+            if (ctx->Driver.CompressedTexSubImage1D) {

+               ctx->Driver.CompressedTexSubImage1D(ctx, target, level,

+                                                   xoffset, width,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         case 2:

+            if (ctx->Driver.CompressedTexSubImage2D) {

+               ctx->Driver.CompressedTexSubImage2D(ctx, target, level,

+                                                   xoffset, yoffset,

+                                                   width, height,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         case 3:

+            if (ctx->Driver.CompressedTexSubImage3D) {

+               ctx->Driver.CompressedTexSubImage3D(ctx, target, level,

+                                                   xoffset, yoffset, zoffset,

+                                                   width, height, depth,

+                                                   format, imageSize, data,

+                                                   texObj, texImage);

+            }

+            break;

+         default:

+            ;

+         }

+

+         check_gen_mipmap(ctx, target, texObj, level);

+

+         ctx->NewState |= _NEW_TEXTURE;

+      }

+   }

+   _mesa_unlock_texture(ctx, texObj);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLsizei width, GLenum format,

+                                 GLsizei imageSize, const GLvoid *data)

+{

+   compressed_tex_sub_image(1, target, level, xoffset, 0, 0, width, 1, 1,

+                            format, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLint yoffset, GLsizei width, GLsizei height,

+                                 GLenum format, GLsizei imageSize,

+                                 const GLvoid *data)

+{

+   compressed_tex_sub_image(2, target, level, xoffset, yoffset, 0,

+                            width, height, 1, format, imageSize, data);

+}

+

+

+void GLAPIENTRY

+_mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,

+                                 GLint yoffset, GLint zoffset, GLsizei width,

+                                 GLsizei height, GLsizei depth, GLenum format,

+                                 GLsizei imageSize, const GLvoid *data)

+{

+   compressed_tex_sub_image(3, target, level, xoffset, yoffset, zoffset,

+                            width, height, depth, format, imageSize, data);

+}

diff --git a/pixman/pixman/pixman-fast-path.c b/pixman/pixman/pixman-fast-path.c
index 868175f60..736e302c6 100644
--- a/pixman/pixman/pixman-fast-path.c
+++ b/pixman/pixman/pixman-fast-path.c
@@ -1,1937 +1,1936 @@
-/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
-/*
- * Copyright © 2000 SuSE, Inc.
- * Copyright © 2007 Red Hat, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of SuSE not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  SuSE makes no representations about the
- * suitability of this software for any purpose.  It is provided "as is"
- * without express or implied warranty.
- *
- * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
- * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Author:  Keith Packard, SuSE, Inc.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <string.h>
-#include <stdlib.h>
-#include "pixman-private.h"
-#include "pixman-combine32.h"
-#include "pixman-fast-path.h"
-
-static force_inline uint32_t
-fetch_24 (uint8_t *a)
-{
-    if (((unsigned long)a) & 1)
-    {
-#ifdef WORDS_BIGENDIAN
-	return (*a << 16) | (*(uint16_t *)(a + 1));
-#else
-	return *a | (*(uint16_t *)(a + 1) << 8);
-#endif
-    }
-    else
-    {
-#ifdef WORDS_BIGENDIAN
-	return (*(uint16_t *)a << 8) | *(a + 2);
-#else
-	return *(uint16_t *)a | (*(a + 2) << 16);
-#endif
-    }
-}
-
-static force_inline void
-store_24 (uint8_t *a,
-          uint32_t v)
-{
-    if (((unsigned long)a) & 1)
-    {
-#ifdef WORDS_BIGENDIAN
-	*a = (uint8_t) (v >> 16);
-	*(uint16_t *)(a + 1) = (uint16_t) (v);
-#else
-	*a = (uint8_t) (v);
-	*(uint16_t *)(a + 1) = (uint16_t) (v >> 8);
-#endif
-    }
-    else
-    {
-#ifdef WORDS_BIGENDIAN
-	*(uint16_t *)a = (uint16_t)(v >> 8);
-	*(a + 2) = (uint8_t)v;
-#else
-	*(uint16_t *)a = (uint16_t)v;
-	*(a + 2) = (uint8_t)(v >> 16);
-#endif
-    }
-}
-
-static force_inline uint32_t
-over (uint32_t src,
-      uint32_t dest)
-{
-    uint32_t a = ~src >> 24;
-
-    UN8x4_MUL_UN8_ADD_UN8x4 (dest, a, src);
-
-    return dest;
-}
-
-static uint32_t
-in (uint32_t x,
-    uint8_t  y)
-{
-    uint16_t a = y;
-
-    UN8x4_MUL_UN8 (x, a);
-
-    return x;
-}
-
-/*
- * Naming convention:
- *
- *  op_src_mask_dest
- */
-static void
-fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,
-                                 pixman_op_t              op,
-                                 pixman_image_t *         src_image,
-                                 pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
-                                 int32_t                  src_x,
-                                 int32_t                  src_y,
-                                 int32_t                  mask_x,
-                                 int32_t                  mask_y,
-                                 int32_t                  dest_x,
-                                 int32_t                  dest_y,
-                                 int32_t                  width,
-                                 int32_t                  height)
-{
-    uint32_t    *src, *src_line;
-    uint32_t    *dst, *dst_line;
-    uint8_t     *mask, *mask_line;
-    int src_stride, mask_stride, dst_stride;
-    uint8_t m;
-    uint32_t s, d;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	src = src_line;
-	src_line += src_stride;
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-
-	w = width;
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m)
-	    {
-		s = *src | 0xff000000;
-
-		if (m == 0xff)
-		{
-		    *dst = s;
-		}
-		else
-		{
-		    d = in (s, m);
-		    *dst = over (d, *dst);
-		}
-	    }
-	    src++;
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_in_n_8_8 (pixman_implementation_t *imp,
-                         pixman_op_t              op,
-                         pixman_image_t *         src_image,
-                         pixman_image_t *         mask_image,
-                         pixman_image_t *         dest_image,
-                         int32_t                  src_x,
-                         int32_t                  src_y,
-                         int32_t                  mask_x,
-                         int32_t                  mask_y,
-                         int32_t                  dest_x,
-                         int32_t                  dest_y,
-                         int32_t                  width,
-                         int32_t                  height)
-{
-    uint32_t src, srca;
-    uint8_t     *dst_line, *dst;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-    uint16_t t;
-
-    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
-
-    srca = src >> 24;
-
-    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    if (srca == 0xff)
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    while (w--)
-	    {
-		m = *mask++;
-
-		if (m == 0)
-		    *dst = 0;
-		else if (m != 0xff)
-		    *dst = MUL_UN8 (m, *dst, t);
-
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    while (w--)
-	    {
-		m = *mask++;
-		m = MUL_UN8 (m, srca, t);
-
-		if (m == 0)
-		    *dst = 0;
-		else if (m != 0xff)
-		    *dst = MUL_UN8 (m, *dst, t);
-
-		dst++;
-	    }
-	}
-    }
-}
-
-static void
-fast_composite_in_8_8 (pixman_implementation_t *imp,
-                       pixman_op_t              op,
-                       pixman_image_t *         src_image,
-                       pixman_image_t *         mask_image,
-                       pixman_image_t *         dest_image,
-                       int32_t                  src_x,
-                       int32_t                  src_y,
-                       int32_t                  mask_x,
-                       int32_t                  mask_y,
-                       int32_t                  dest_x,
-                       int32_t                  dest_y,
-                       int32_t                  width,
-                       int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint8_t s;
-    uint16_t t;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-
-	    if (s == 0)
-		*dst = 0;
-	    else if (s != 0xff)
-		*dst = MUL_UN8 (s, *dst, t);
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint32_t    *dst_line, *dst, d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    *dst = src;
-		else
-		    *dst = over (src, *dst);
-	    }
-	    else if (m)
-	    {
-		d = in (src, m);
-		*dst = over (d, *dst);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
-				   pixman_op_t              op,
-				   pixman_image_t *         src_image,
-				   pixman_image_t *         mask_image,
-				   pixman_image_t *         dst_image,
-				   int32_t                  src_x,
-				   int32_t                  src_y,
-				   int32_t                  mask_x,
-				   int32_t                  mask_y,
-				   int32_t                  dest_x,
-				   int32_t                  dest_y,
-				   int32_t                  width,
-				   int32_t                  height)
-{
-    uint32_t src, srca, s;
-    uint32_t    *dst_line, *dst, d;
-    uint32_t    *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-
-	    if (ma)
-	    {
-		d = *dst;
-		s = src;
-
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (s, ma, d);
-
-		*dst = s;
-	    }
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
-                                    pixman_op_t              op,
-                                    pixman_image_t *         src_image,
-                                    pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
-                                    int32_t                  src_x,
-                                    int32_t                  src_y,
-                                    int32_t                  mask_x,
-                                    int32_t                  mask_y,
-                                    int32_t                  dest_x,
-                                    int32_t                  dest_y,
-                                    int32_t                  width,
-                                    int32_t                  height)
-{
-    uint32_t src, srca, s;
-    uint32_t    *dst_line, *dst, d;
-    uint32_t    *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-	    if (ma == 0xffffffff)
-	    {
-		if (srca == 0xff)
-		    *dst = src;
-		else
-		    *dst = over (src, *dst);
-	    }
-	    else if (ma)
-	    {
-		d = *dst;
-		s = src;
-
-		UN8x4_MUL_UN8x4 (s, ma);
-		UN8x4_MUL_UN8 (ma, srca);
-		ma = ~ma;
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);
-
-		*dst = d;
-	    }
-
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_0888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint8_t     *dst_line, *dst;
-    uint32_t d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		{
-		    d = src;
-		}
-		else
-		{
-		    d = fetch_24 (dst);
-		    d = over (src, d);
-		}
-		store_24 (dst, d);
-	    }
-	    else if (m)
-	    {
-		d = over (in (src, m), fetch_24 (dst));
-		store_24 (dst, d);
-	    }
-	    dst += 3;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t src, srca;
-    uint16_t    *dst_line, *dst;
-    uint32_t d;
-    uint8_t     *mask_line, *mask, m;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		{
-		    d = src;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (src, CONVERT_0565_TO_0888 (d));
-		}
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    else if (m)
-	    {
-		d = *dst;
-		d = over (in (src, m), CONVERT_0565_TO_0888 (d));
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
-                                    pixman_op_t              op,
-                                    pixman_image_t *         src_image,
-                                    pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
-                                    int32_t                  src_x,
-                                    int32_t                  src_y,
-                                    int32_t                  mask_x,
-                                    int32_t                  mask_y,
-                                    int32_t                  dest_x,
-                                    int32_t                  dest_y,
-                                    int32_t                  width,
-                                    int32_t                  height)
-{
-    uint32_t  src, srca, s;
-    uint16_t  src16;
-    uint16_t *dst_line, *dst;
-    uint32_t  d;
-    uint32_t *mask_line, *mask, ma;
-    int dst_stride, mask_stride;
-    int32_t w;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    src16 = CONVERT_8888_TO_0565 (src);
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    ma = *mask++;
-	    if (ma == 0xffffffff)
-	    {
-		if (srca == 0xff)
-		{
-		    *dst = src16;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (src, CONVERT_0565_TO_0888 (d));
-		    *dst = CONVERT_8888_TO_0565 (d);
-		}
-	    }
-	    else if (ma)
-	    {
-		d = *dst;
-		d = CONVERT_0565_TO_0888 (d);
-
-		s = src;
-
-		UN8x4_MUL_UN8x4 (s, ma);
-		UN8x4_MUL_UN8 (ma, srca);
-		ma = ~ma;
-		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);
-
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_over_8888_8888 (pixman_implementation_t *imp,
-                               pixman_op_t              op,
-                               pixman_image_t *         src_image,
-                               pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
-                               int32_t                  src_x,
-                               int32_t                  src_y,
-                               int32_t                  mask_x,
-                               int32_t                  mask_y,
-                               int32_t                  dest_x,
-                               int32_t                  dest_y,
-                               int32_t                  width,
-                               int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src, s;
-    int dst_stride, src_stride;
-    uint8_t a;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (a == 0xff)
-		*dst = s;
-	    else if (s)
-		*dst = over (s, *dst);
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_src_x888_8888 (pixman_implementation_t *imp,
-			      pixman_op_t              op,
-			      pixman_image_t *         src_image,
-			      pixman_image_t *         mask_image,
-			      pixman_image_t *         dst_image,
-			      int32_t                  src_x,
-			      int32_t                  src_y,
-			      int32_t                  mask_x,
-			      int32_t                  mask_y,
-			      int32_t                  dest_x,
-			      int32_t                  dest_y,
-			      int32_t                  width,
-			      int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	    *dst++ = (*src++) | 0xff000000;
-    }
-}
-
-#if 0
-static void
-fast_composite_over_8888_0888 (pixman_implementation_t *imp,
-			       pixman_op_t              op,
-			       pixman_image_t *         src_image,
-			       pixman_image_t *         mask_image,
-			       pixman_image_t *         dst_image,
-			       int32_t                  src_x,
-			       int32_t                  src_y,
-			       int32_t                  mask_x,
-			       int32_t                  mask_y,
-			       int32_t                  dest_x,
-			       int32_t                  dest_y,
-			       int32_t                  width,
-			       int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint32_t d;
-    uint32_t    *src_line, *src, s;
-    uint8_t a;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (a)
-	    {
-		if (a == 0xff)
-		    d = s;
-		else
-		    d = over (s, fetch_24 (dst));
-
-		store_24 (dst, d);
-	    }
-	    dst += 3;
-	}
-    }
-}
-#endif
-
-static void
-fast_composite_over_8888_0565 (pixman_implementation_t *imp,
-                               pixman_op_t              op,
-                               pixman_image_t *         src_image,
-                               pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
-                               int32_t                  src_x,
-                               int32_t                  src_y,
-                               int32_t                  mask_x,
-                               int32_t                  mask_y,
-                               int32_t                  dest_x,
-                               int32_t                  dest_y,
-                               int32_t                  width,
-                               int32_t                  height)
-{
-    uint16_t    *dst_line, *dst;
-    uint32_t d;
-    uint32_t    *src_line, *src, s;
-    uint8_t a;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    a = s >> 24;
-	    if (s)
-	    {
-		if (a == 0xff)
-		{
-		    d = s;
-		}
-		else
-		{
-		    d = *dst;
-		    d = over (s, CONVERT_0565_TO_0888 (d));
-		}
-		*dst = CONVERT_8888_TO_0565 (d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_src_x888_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint16_t    *dst_line, *dst;
-    uint32_t    *src_line, *src, s;
-    int dst_stride, src_stride;
-    int32_t w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    *dst = CONVERT_8888_TO_0565 (s);
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_8_8 (pixman_implementation_t *imp,
-			pixman_op_t              op,
-			pixman_image_t *         src_image,
-			pixman_image_t *         mask_image,
-			pixman_image_t *         dst_image,
-			int32_t                  src_x,
-			int32_t                  src_y,
-			int32_t                  mask_x,
-			int32_t                  mask_y,
-			int32_t                  dest_x,
-			int32_t                  dest_y,
-			int32_t                  width,
-			int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint8_t s, d;
-    uint16_t t;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    if (s)
-	    {
-		if (s != 0xff)
-		{
-		    d = *dst;
-		    t = d + s;
-		    s = t | (0 - (t >> 8));
-		}
-		*dst = s;
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_8888_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t    *dst_line, *dst;
-    uint32_t    *src_line, *src;
-    int dst_stride, src_stride;
-    int32_t w;
-    uint32_t s, d;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    s = *src++;
-	    if (s)
-	    {
-		if (s != 0xffffffff)
-		{
-		    d = *dst;
-		    if (d)
-			UN8x4_ADD_UN8x4 (s, d);
-		}
-		*dst = s;
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-fast_composite_add_n_8_8 (pixman_implementation_t *imp,
-			  pixman_op_t              op,
-			  pixman_image_t *         src_image,
-			  pixman_image_t *         mask_image,
-			  pixman_image_t *         dst_image,
-			  int32_t                  src_x,
-			  int32_t                  src_y,
-			  int32_t                  mask_x,
-			  int32_t                  mask_y,
-			  int32_t                  dest_x,
-			  int32_t                  dest_y,
-			  int32_t                  width,
-			  int32_t                  height)
-{
-    uint8_t     *dst_line, *dst;
-    uint8_t     *mask_line, *mask;
-    int dst_stride, mask_stride;
-    int32_t w;
-    uint32_t src;
-    uint8_t sa;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    sa = (src >> 24);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	mask = mask_line;
-	mask_line += mask_stride;
-	w = width;
-
-	while (w--)
-	{
-	    uint16_t tmp;
-	    uint16_t a;
-	    uint32_t m, d;
-	    uint32_t r;
-
-	    a = *mask++;
-	    d = *dst;
-
-	    m = MUL_UN8 (sa, a, tmp);
-	    r = ADD_UN8 (m, d, tmp);
-
-	    *dst++ = r;
-	}
-    }
-}
-
-#ifdef WORDS_BIGENDIAN
-#define CREATE_BITMASK(n) (0x80000000 >> (n))
-#define UPDATE_BITMASK(n) ((n) >> 1)
-#else
-#define CREATE_BITMASK(n) (1 << (n))
-#define UPDATE_BITMASK(n) ((n) << 1)
-#endif
-
-#define TEST_BIT(p, n)					\
-    (*((p) + ((n) >> 5)) & CREATE_BITMASK ((n) & 31))
-#define SET_BIT(p, n)							\
-    do { *((p) + ((n) >> 5)) |= CREATE_BITMASK ((n) & 31); } while (0);
-
-static void
-fast_composite_add_1000_1000 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     *dst_line, *dst;
-    uint32_t     *src_line, *src;
-    int           dst_stride, src_stride;
-    int32_t       w;
-
-    PIXMAN_IMAGE_GET_LINE (src_image, 0, src_y, uint32_t,
-                           src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, 0, dest_y, uint32_t,
-                           dst_stride, dst_line, 1);
-
-    while (height--)
-    {
-	dst = dst_line;
-	dst_line += dst_stride;
-	src = src_line;
-	src_line += src_stride;
-	w = width;
-
-	while (w--)
-	{
-	    /*
-	     * TODO: improve performance by processing uint32_t data instead
-	     *       of individual bits
-	     */
-	    if (TEST_BIT (src, src_x + w))
-		SET_BIT (dst, dest_x + w);
-	}
-    }
-}
-
-static void
-fast_composite_over_n_1_8888 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     src, srca;
-    uint32_t    *dst, *dst_line;
-    uint32_t    *mask, *mask_line;
-    int          mask_stride, dst_stride;
-    uint32_t     bitcache, bitmask;
-    int32_t      w;
-
-    if (width <= 0)
-	return;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t,
-                           dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
-                           mask_stride, mask_line, 1);
-    mask_line += mask_x >> 5;
-
-    if (srca == 0xff)
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = src;
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = over (src, *dst);
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-}
-
-static void
-fast_composite_over_n_1_0565 (pixman_implementation_t *imp,
-                              pixman_op_t              op,
-                              pixman_image_t *         src_image,
-                              pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
-                              int32_t                  src_x,
-                              int32_t                  src_y,
-                              int32_t                  mask_x,
-                              int32_t                  mask_y,
-                              int32_t                  dest_x,
-                              int32_t                  dest_y,
-                              int32_t                  width,
-                              int32_t                  height)
-{
-    uint32_t     src, srca;
-    uint16_t    *dst, *dst_line;
-    uint32_t    *mask, *mask_line;
-    int          mask_stride, dst_stride;
-    uint32_t     bitcache, bitmask;
-    int32_t      w;
-    uint32_t     d;
-    uint16_t     src565;
-
-    if (width <= 0)
-	return;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-    srca = src >> 24;
-    if (src == 0)
-	return;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t,
-                           dst_stride, dst_line, 1);
-    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
-                           mask_stride, mask_line, 1);
-    mask_line += mask_x >> 5;
-
-    if (srca == 0xff)
-    {
-	src565 = CONVERT_8888_TO_0565 (src);
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		    *dst = src565;
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    dst = dst_line;
-	    dst_line += dst_stride;
-	    mask = mask_line;
-	    mask_line += mask_stride;
-	    w = width;
-
-	    bitcache = *mask++;
-	    bitmask = CREATE_BITMASK (mask_x & 31);
-
-	    while (w--)
-	    {
-		if (bitmask == 0)
-		{
-		    bitcache = *mask++;
-		    bitmask = CREATE_BITMASK (0);
-		}
-		if (bitcache & bitmask)
-		{
-		    d = over (src, CONVERT_0565_TO_0888 (*dst));
-		    *dst = CONVERT_8888_TO_0565 (d);
-		}
-		bitmask = UPDATE_BITMASK (bitmask);
-		dst++;
-	    }
-	}
-    }
-}
-
-/*
- * Simple bitblt
- */
-
-static void
-fast_composite_solid_fill (pixman_implementation_t *imp,
-                           pixman_op_t              op,
-                           pixman_image_t *         src_image,
-                           pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
-                           int32_t                  src_x,
-                           int32_t                  src_y,
-                           int32_t                  mask_x,
-                           int32_t                  mask_y,
-                           int32_t                  dest_x,
-                           int32_t                  dest_y,
-                           int32_t                  width,
-                           int32_t                  height)
-{
-    uint32_t src;
-
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
-
-    if (dst_image->bits.format == PIXMAN_a1)
-    {
-	src = src >> 31;
-    }
-    else if (dst_image->bits.format == PIXMAN_a8)
-    {
-	src = src >> 24;
-    }
-    else if (dst_image->bits.format == PIXMAN_r5g6b5 ||
-             dst_image->bits.format == PIXMAN_b5g6r5)
-    {
-	src = CONVERT_8888_TO_0565 (src);
-    }
-
-    pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,
-                 PIXMAN_FORMAT_BPP (dst_image->bits.format),
-                 dest_x, dest_y,
-                 width, height,
-                 src);
-}
-
-static void
-fast_composite_src_memcpy (pixman_implementation_t *imp,
-			   pixman_op_t              op,
-			   pixman_image_t *         src_image,
-			   pixman_image_t *         mask_image,
-			   pixman_image_t *         dst_image,
-			   int32_t                  src_x,
-			   int32_t                  src_y,
-			   int32_t                  mask_x,
-			   int32_t                  mask_y,
-			   int32_t                  dest_x,
-			   int32_t                  dest_y,
-			   int32_t                  width,
-			   int32_t                  height)
-{
-    int bpp = PIXMAN_FORMAT_BPP (dst_image->bits.format) / 8;
-    uint32_t n_bytes = width * bpp;
-    int dst_stride, src_stride;
-    uint8_t    *dst;
-    uint8_t    *src;
-
-    src_stride = src_image->bits.rowstride * 4;
-    dst_stride = dst_image->bits.rowstride * 4;
-
-    src = (uint8_t *)src_image->bits.bits + src_y * src_stride + src_x * bpp;
-    dst = (uint8_t *)dst_image->bits.bits + dest_y * dst_stride + dest_x * bpp;
-
-    while (height--)
-    {
-	memcpy (dst, src, n_bytes);
-
-	dst += dst_stride;
-	src += src_stride;
-    }
-}
-
-FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, SRC, COVER)
-FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, SRC, NONE)
-FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, SRC, PAD)
-FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, SRC, NORMAL)
-FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, OVER, COVER)
-FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, OVER, NONE)
-FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, OVER, PAD)
-FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, OVER, NORMAL)
-FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, SRC, COVER)
-FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, NONE)
-FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, SRC, PAD)
-FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, NORMAL)
-FAST_NEAREST (565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, NORMAL)
-FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, OVER, COVER)
-FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, NONE)
-FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, OVER, PAD)
-FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, NORMAL)
-
-/* Use more unrolling for src_0565_0565 because it is typically CPU bound */
-static force_inline void
-scaled_nearest_scanline_565_565_SRC (uint16_t *      dst,
-				     uint16_t *      src,
-				     int32_t         w,
-				     pixman_fixed_t  vx,
-				     pixman_fixed_t  unit_x,
-				     pixman_fixed_t  max_vx)
-{
-    uint16_t tmp1, tmp2, tmp3, tmp4;
-    while ((w -= 4) >= 0)
-    {
-	tmp1 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp2 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp3 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp4 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	*dst++ = tmp1;
-	*dst++ = tmp2;
-	*dst++ = tmp3;
-	*dst++ = tmp4;
-    }
-    if (w & 2)
-    {
-	tmp1 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	tmp2 = src[pixman_fixed_to_int (vx)];
-	vx += unit_x;
-	*dst++ = tmp1;
-	*dst++ = tmp2;
-    }
-    if (w & 1)
-	*dst++ = src[pixman_fixed_to_int (vx)];
-}
-
-FAST_NEAREST_MAINLOOP (565_565_cover_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, COVER)
-FAST_NEAREST_MAINLOOP (565_565_none_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, NONE)
-FAST_NEAREST_MAINLOOP (565_565_pad_SRC,
-		       scaled_nearest_scanline_565_565_SRC,
-		       uint16_t, uint16_t, PAD)
-
-static force_inline uint32_t
-fetch_nearest (pixman_repeat_t src_repeat,
-	       pixman_format_code_t format,
-	       uint32_t *src, int x, int src_width)
-{
-    if (repeat (src_repeat, &x, src_width))
-    {
-	if (format == PIXMAN_x8r8g8b8)
-	    return *(src + x) | 0xff000000;
-	else
-	    return *(src + x);
-    }
-    else
-    {
-	return 0;
-    }
-}
-
-static force_inline void
-combine_over (uint32_t s, uint32_t *dst)
-{
-    if (s)
-    {
-	uint8_t ia = 0xff - (s >> 24);
-
-	if (ia)
-	    UN8x4_MUL_UN8_ADD_UN8x4 (*dst, ia, s);
-	else
-	    *dst = s;
-    }
-}
-
-static force_inline void
-combine_src (uint32_t s, uint32_t *dst)
-{
-    *dst = s;
-}
-
-static void
-fast_composite_scaled_nearest (pixman_implementation_t *imp,
-			       pixman_op_t              op,
-			       pixman_image_t *         src_image,
-			       pixman_image_t *         mask_image,
-			       pixman_image_t *         dst_image,
-			       int32_t                  src_x,
-			       int32_t                  src_y,
-			       int32_t                  mask_x,
-			       int32_t                  mask_y,
-			       int32_t                  dest_x,
-			       int32_t                  dest_y,
-			       int32_t                  width,
-			       int32_t                  height)
-{
-    uint32_t       *dst_line;
-    uint32_t       *src_line;
-    int             dst_stride, src_stride;
-    int		    src_width, src_height;
-    pixman_repeat_t src_repeat;
-    pixman_fixed_t unit_x, unit_y;
-    pixman_format_code_t src_format;
-    pixman_vector_t v;
-    pixman_fixed_t vy;
-
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
-    /* pass in 0 instead of src_x and src_y because src_x and src_y need to be
-     * transformed from destination space to source space
-     */
-    PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, uint32_t, src_stride, src_line, 1);
-
-    /* reference point is the center of the pixel */
-    v.vector[0] = pixman_int_to_fixed (src_x) + pixman_fixed_1 / 2;
-    v.vector[1] = pixman_int_to_fixed (src_y) + pixman_fixed_1 / 2;
-    v.vector[2] = pixman_fixed_1;
-
-    if (!pixman_transform_point_3d (src_image->common.transform, &v))
-	return;
-
-    unit_x = src_image->common.transform->matrix[0][0];
-    unit_y = src_image->common.transform->matrix[1][1];
-
-    /* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */
-    v.vector[0] -= pixman_fixed_e;
-    v.vector[1] -= pixman_fixed_e;
-
-    src_height = src_image->bits.height;
-    src_width = src_image->bits.width;
-    src_repeat = src_image->common.repeat;
-    src_format = src_image->bits.format;
-
-    vy = v.vector[1];
-    while (height--)
-    {
-        pixman_fixed_t vx = v.vector[0];
-	int y = pixman_fixed_to_int (vy);
-	uint32_t *dst = dst_line;
-
-	dst_line += dst_stride;
-
-        /* adjust the y location by a unit vector in the y direction
-         * this is equivalent to transforming y+1 of the destination point to source space */
-        vy += unit_y;
-
-	if (!repeat (src_repeat, &y, src_height))
-	{
-	    if (op == PIXMAN_OP_SRC)
-		memset (dst, 0, sizeof (*dst) * width);
-	}
-	else
-	{
-	    int w = width;
-
-	    uint32_t *src = src_line + y * src_stride;
-
-	    while (w >= 2)
-	    {
-		uint32_t s1, s2;
-		int x1, x2;
-
-		x1 = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		x2 = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		w -= 2;
-
-		s1 = fetch_nearest (src_repeat, src_format, src, x1, src_width);
-		s2 = fetch_nearest (src_repeat, src_format, src, x2, src_width);
-
-		if (op == PIXMAN_OP_OVER)
-		{
-		    combine_over (s1, dst++);
-		    combine_over (s2, dst++);
-		}
-		else
-		{
-		    combine_src (s1, dst++);
-		    combine_src (s2, dst++);
-		}
-	    }
-
-	    while (w--)
-	    {
-		uint32_t s;
-		int x;
-
-		x = pixman_fixed_to_int (vx);
-		vx += unit_x;
-
-		s = fetch_nearest (src_repeat, src_format, src, x, src_width);
-
-		if (op == PIXMAN_OP_OVER)
-		    combine_over (s, dst++);
-		else
-		    combine_src (s, dst++);
-	    }
-	}
-    }
-}
-
-static const pixman_fast_path_t c_fast_paths[] =
-{
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, fast_composite_over_n_8_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, fast_composite_over_n_8_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r8g8b8, fast_composite_over_n_8_0888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b8g8r8, fast_composite_over_n_8_0888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8r8g8b8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8r8g8b8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8b8g8r8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8b8g8r8, fast_composite_over_n_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8r8g8b8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8r8g8b8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8b8g8r8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8b8g8r8, fast_composite_over_n_1_8888),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, r5g6b5,   fast_composite_over_n_1_0565),
-    PIXMAN_STD_FAST_PATH (OVER, solid, a1, b5g6r5,   fast_composite_over_n_1_0565),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, a8r8g8b8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, x8r8g8b8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, r5g6b5, fast_composite_over_n_8888_0565_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, a8b8g8r8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, x8b8g8r8, fast_composite_over_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, b5g6r5, fast_composite_over_n_8888_0565_ca),
-    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, x8r8g8b8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, a8r8g8b8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, x8b8g8r8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, a8b8g8r8, fast_composite_over_x888_8_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, a8r8g8b8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, x8r8g8b8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, r5g6b5, fast_composite_over_8888_0565),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, a8b8g8r8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, x8b8g8r8, fast_composite_over_8888_8888),
-    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, b5g6r5, fast_composite_over_8888_0565),
-    PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, fast_composite_add_8888_8888),
-    PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, fast_composite_add_8888_8888),
-    PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, fast_composite_add_8_8),
-    PIXMAN_STD_FAST_PATH (ADD, a1, null, a1, fast_composite_add_1000_1000),
-    PIXMAN_STD_FAST_PATH_CA (ADD, solid, a8r8g8b8, a8r8g8b8, fast_composite_add_n_8888_8888_ca),
-    PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, fast_composite_add_n_8_8),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8r8g8b8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8r8g8b8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8b8g8r8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8b8g8r8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a1, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, solid, null, r5g6b5, fast_composite_solid_fill),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, a8r8g8b8, fast_composite_src_x888_8888),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, a8b8g8r8, fast_composite_src_x888_8888),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, a8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, a8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8x8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8a8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8x8, null, b8g8r8x8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, r8g8b8, null, r8g8b8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, b8g8r8, null, b8g8r8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, x1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8, null, a8, fast_composite_src_memcpy),
-    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),
-    PIXMAN_STD_FAST_PATH (IN, a8, null, a8, fast_composite_in_8_8),
-    PIXMAN_STD_FAST_PATH (IN, solid, a8, a8, fast_composite_in_n_8_8),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, r5g6b5, 8888_565),
-    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, r5g6b5, 8888_565),
-
-    SIMPLE_NEAREST_FAST_PATH (SRC, r5g6b5, r5g6b5, 565_565),
-
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, 8888_8888),
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, 8888_8888),
-
-    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, r5g6b5, 8888_565),
-
-#define NEAREST_FAST_PATH(op,s,d)		\
-    {   PIXMAN_OP_ ## op,			\
-	PIXMAN_ ## s, SCALED_NEAREST_FLAGS,	\
-	PIXMAN_null, 0,				\
-	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,	\
-	fast_composite_scaled_nearest,		\
-    }
-
-    NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8),
-    NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8),
-
-    NEAREST_FAST_PATH (SRC, x8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (SRC, x8b8g8r8, a8b8g8r8),
-    NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8),
-
-    NEAREST_FAST_PATH (OVER, x8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8),
-    NEAREST_FAST_PATH (OVER, x8b8g8r8, x8b8g8r8),
-    NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8),
-
-    NEAREST_FAST_PATH (OVER, x8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8),
-    NEAREST_FAST_PATH (OVER, x8b8g8r8, a8b8g8r8),
-    NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8),
-
-    {   PIXMAN_OP_NONE	},
-};
-
-#ifdef WORDS_BIGENDIAN
-#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (32 - (offs) - (n)))
-#else
-#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (offs))
-#endif
-
-static force_inline void
-pixman_fill1_line (uint32_t *dst, int offs, int width, int v)
-{
-    if (offs)
-    {
-	int leading_pixels = 32 - offs;
-	if (leading_pixels >= width)
-	{
-	    if (v)
-		*dst |= A1_FILL_MASK (width, offs);
-	    else
-		*dst &= ~A1_FILL_MASK (width, offs);
-	    return;
-	}
-	else
-	{
-	    if (v)
-		*dst++ |= A1_FILL_MASK (leading_pixels, offs);
-	    else
-		*dst++ &= ~A1_FILL_MASK (leading_pixels, offs);
-	    width -= leading_pixels;
-	}
-    }
-    while (width >= 32)
-    {
-	if (v)
-	    *dst++ = 0xFFFFFFFF;
-	else
-	    *dst++ = 0;
-	width -= 32;
-    }
-    if (width > 0)
-    {
-	if (v)
-	    *dst |= A1_FILL_MASK (width, 0);
-	else
-	    *dst &= ~A1_FILL_MASK (width, 0);
-    }
-}
-
-static void
-pixman_fill1 (uint32_t *bits,
-              int       stride,
-              int       x,
-              int       y,
-              int       width,
-              int       height,
-              uint32_t  xor)
-{
-    uint32_t *dst = bits + y * stride + (x >> 5);
-    int offs = x & 31;
-
-    if (xor & 1)
-    {
-	while (height--)
-	{
-	    pixman_fill1_line (dst, offs, width, 1);
-	    dst += stride;
-	}
-    }
-    else
-    {
-	while (height--)
-	{
-	    pixman_fill1_line (dst, offs, width, 0);
-	    dst += stride;
-	}
-    }
-}
-
-static void
-pixman_fill8 (uint32_t *bits,
-              int       stride,
-              int       x,
-              int       y,
-              int       width,
-              int       height,
-              uint32_t xor)
-{
-    int byte_stride = stride * (int) sizeof (uint32_t);
-    uint8_t *dst = (uint8_t *) bits;
-    uint8_t v = xor & 0xff;
-    int i;
-
-    dst = dst + y * byte_stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    dst[i] = v;
-
-	dst += byte_stride;
-    }
-}
-
-static void
-pixman_fill16 (uint32_t *bits,
-               int       stride,
-               int       x,
-               int       y,
-               int       width,
-               int       height,
-               uint32_t xor)
-{
-    int short_stride =
-	(stride * (int)sizeof (uint32_t)) / (int)sizeof (uint16_t);
-    uint16_t *dst = (uint16_t *)bits;
-    uint16_t v = xor & 0xffff;
-    int i;
-
-    dst = dst + y * short_stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    dst[i] = v;
-
-	dst += short_stride;
-    }
-}
-
-static void
-pixman_fill32 (uint32_t *bits,
-               int       stride,
-               int       x,
-               int       y,
-               int       width,
-               int       height,
-               uint32_t  xor)
-{
-    int i;
-
-    bits = bits + y * stride + x;
-
-    while (height--)
-    {
-	for (i = 0; i < width; ++i)
-	    bits[i] = xor;
-
-	bits += stride;
-    }
-}
-
-static pixman_bool_t
-fast_path_fill (pixman_implementation_t *imp,
-                uint32_t *               bits,
-                int                      stride,
-                int                      bpp,
-                int                      x,
-                int                      y,
-                int                      width,
-                int                      height,
-                uint32_t		 xor)
-{
-    switch (bpp)
-    {
-    case 1:
-	pixman_fill1 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 8:
-	pixman_fill8 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 16:
-	pixman_fill16 (bits, stride, x, y, width, height, xor);
-	break;
-
-    case 32:
-	pixman_fill32 (bits, stride, x, y, width, height, xor);
-	break;
-
-    default:
-	return _pixman_implementation_fill (
-	    imp->delegate, bits, stride, bpp, x, y, width, height, xor);
-	break;
-    }
-
-    return TRUE;
-}
-
-pixman_implementation_t *
-_pixman_implementation_create_fast_path (void)
-{
-    pixman_implementation_t *general = _pixman_implementation_create_general ();
-    pixman_implementation_t *imp = _pixman_implementation_create (general, c_fast_paths);
-
-    imp->fill = fast_path_fill;
-
-    return imp;
-}
+/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */

+/*

+ * Copyright © 2000 SuSE, Inc.

+ * Copyright © 2007 Red Hat, Inc.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of SuSE not be used in advertising or

+ * publicity pertaining to distribution of the software without specific,

+ * written prior permission.  SuSE makes no representations about the

+ * suitability of this software for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ *

+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE

+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author:  Keith Packard, SuSE, Inc.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include <string.h>

+#include <stdlib.h>

+#include "pixman-private.h"

+#include "pixman-combine32.h"

+#include "pixman-fast-path.h"

+

+static force_inline uint32_t

+fetch_24 (uint8_t *a)

+{

+    if (((unsigned long)a) & 1)

+    {

+#ifdef WORDS_BIGENDIAN

+	return (*a << 16) | (*(uint16_t *)(a + 1));

+#else

+	return *a | (*(uint16_t *)(a + 1) << 8);

+#endif

+    }

+    else

+    {

+#ifdef WORDS_BIGENDIAN

+	return (*(uint16_t *)a << 8) | *(a + 2);

+#else

+	return *(uint16_t *)a | (*(a + 2) << 16);

+#endif

+    }

+}

+

+static force_inline void

+store_24 (uint8_t *a,

+          uint32_t v)

+{

+    if (((unsigned long)a) & 1)

+    {

+#ifdef WORDS_BIGENDIAN

+	*a = (uint8_t) (v >> 16);

+	*(uint16_t *)(a + 1) = (uint16_t) (v);

+#else

+	*a = (uint8_t) (v);

+	*(uint16_t *)(a + 1) = (uint16_t) (v >> 8);

+#endif

+    }

+    else

+    {

+#ifdef WORDS_BIGENDIAN

+	*(uint16_t *)a = (uint16_t)(v >> 8);

+	*(a + 2) = (uint8_t)v;

+#else

+	*(uint16_t *)a = (uint16_t)v;

+	*(a + 2) = (uint8_t)(v >> 16);

+#endif

+    }

+}

+

+static force_inline uint32_t

+over (uint32_t src,

+      uint32_t dest)

+{

+    uint32_t a = ~src >> 24;

+

+    UN8x4_MUL_UN8_ADD_UN8x4 (dest, a, src);

+

+    return dest;

+}

+

+static uint32_t

+in (uint32_t x,

+    uint8_t  y)

+{

+    uint16_t a = y;

+

+    UN8x4_MUL_UN8 (x, a);

+

+    return x;

+}

+

+/*

+ * Naming convention:

+ *

+ *  op_src_mask_dest

+ */

+static void

+fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,

+                                 pixman_op_t              op,

+                                 pixman_image_t *         src_image,

+                                 pixman_image_t *         mask_image,

+                                 pixman_image_t *         dst_image,

+                                 int32_t                  src_x,

+                                 int32_t                  src_y,

+                                 int32_t                  mask_x,

+                                 int32_t                  mask_y,

+                                 int32_t                  dest_x,

+                                 int32_t                  dest_y,

+                                 int32_t                  width,

+                                 int32_t                  height)

+{

+    uint32_t    *src, *src_line;

+    uint32_t    *dst, *dst_line;

+    uint8_t     *mask, *mask_line;

+    int src_stride, mask_stride, dst_stride;

+    uint8_t m;

+    uint32_t s, d;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	src = src_line;

+	src_line += src_stride;

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+

+	w = width;

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m)

+	    {

+		s = *src | 0xff000000;

+

+		if (m == 0xff)

+		{

+		    *dst = s;

+		}

+		else

+		{

+		    d = in (s, m);

+		    *dst = over (d, *dst);

+		}

+	    }

+	    src++;

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_in_n_8_8 (pixman_implementation_t *imp,

+                         pixman_op_t              op,

+                         pixman_image_t *         src_image,

+                         pixman_image_t *         mask_image,

+                         pixman_image_t *         dest_image,

+                         int32_t                  src_x,

+                         int32_t                  src_y,

+                         int32_t                  mask_x,

+                         int32_t                  mask_y,

+                         int32_t                  dest_x,

+                         int32_t                  dest_y,

+                         int32_t                  width,

+                         int32_t                  height)

+{

+    uint32_t src, srca;

+    uint8_t     *dst_line, *dst;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+    uint16_t t;

+

+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);

+

+    srca = src >> 24;

+

+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    if (srca == 0xff)

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    while (w--)

+	    {

+		m = *mask++;

+

+		if (m == 0)

+		    *dst = 0;

+		else if (m != 0xff)

+		    *dst = MUL_UN8 (m, *dst, t);

+

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    while (w--)

+	    {

+		m = *mask++;

+		m = MUL_UN8 (m, srca, t);

+

+		if (m == 0)

+		    *dst = 0;

+		else if (m != 0xff)

+		    *dst = MUL_UN8 (m, *dst, t);

+

+		dst++;

+	    }

+	}

+    }

+}

+

+static void

+fast_composite_in_8_8 (pixman_implementation_t *imp,

+                       pixman_op_t              op,

+                       pixman_image_t *         src_image,

+                       pixman_image_t *         mask_image,

+                       pixman_image_t *         dest_image,

+                       int32_t                  src_x,

+                       int32_t                  src_y,

+                       int32_t                  mask_x,

+                       int32_t                  mask_y,

+                       int32_t                  dest_x,

+                       int32_t                  dest_y,

+                       int32_t                  width,

+                       int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint8_t s;

+    uint16_t t;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+

+	    if (s == 0)

+		*dst = 0;

+	    else if (s != 0xff)

+		*dst = MUL_UN8 (s, *dst, t);

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint32_t    *dst_line, *dst, d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    *dst = src;

+		else

+		    *dst = over (src, *dst);

+	    }

+	    else if (m)

+	    {

+		d = in (src, m);

+		*dst = over (d, *dst);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,

+				   pixman_op_t              op,

+				   pixman_image_t *         src_image,

+				   pixman_image_t *         mask_image,

+				   pixman_image_t *         dst_image,

+				   int32_t                  src_x,

+				   int32_t                  src_y,

+				   int32_t                  mask_x,

+				   int32_t                  mask_y,

+				   int32_t                  dest_x,

+				   int32_t                  dest_y,

+				   int32_t                  width,

+				   int32_t                  height)

+{

+    uint32_t src, s;

+    uint32_t    *dst_line, *dst, d;

+    uint32_t    *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+

+	    if (ma)

+	    {

+		d = *dst;

+		s = src;

+

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (s, ma, d);

+

+		*dst = s;

+	    }

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,

+                                    pixman_op_t              op,

+                                    pixman_image_t *         src_image,

+                                    pixman_image_t *         mask_image,

+                                    pixman_image_t *         dst_image,

+                                    int32_t                  src_x,

+                                    int32_t                  src_y,

+                                    int32_t                  mask_x,

+                                    int32_t                  mask_y,

+                                    int32_t                  dest_x,

+                                    int32_t                  dest_y,

+                                    int32_t                  width,

+                                    int32_t                  height)

+{

+    uint32_t src, srca, s;

+    uint32_t    *dst_line, *dst, d;

+    uint32_t    *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+	    if (ma == 0xffffffff)

+	    {

+		if (srca == 0xff)

+		    *dst = src;

+		else

+		    *dst = over (src, *dst);

+	    }

+	    else if (ma)

+	    {

+		d = *dst;

+		s = src;

+

+		UN8x4_MUL_UN8x4 (s, ma);

+		UN8x4_MUL_UN8 (ma, srca);

+		ma = ~ma;

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);

+

+		*dst = d;

+	    }

+

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_0888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint8_t     *dst_line, *dst;

+    uint32_t d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		{

+		    d = src;

+		}

+		else

+		{

+		    d = fetch_24 (dst);

+		    d = over (src, d);

+		}

+		store_24 (dst, d);

+	    }

+	    else if (m)

+	    {

+		d = over (in (src, m), fetch_24 (dst));

+		store_24 (dst, d);

+	    }

+	    dst += 3;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t src, srca;

+    uint16_t    *dst_line, *dst;

+    uint32_t d;

+    uint8_t     *mask_line, *mask, m;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		{

+		    d = src;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (src, CONVERT_0565_TO_0888 (d));

+		}

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    else if (m)

+	    {

+		d = *dst;

+		d = over (in (src, m), CONVERT_0565_TO_0888 (d));

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,

+                                    pixman_op_t              op,

+                                    pixman_image_t *         src_image,

+                                    pixman_image_t *         mask_image,

+                                    pixman_image_t *         dst_image,

+                                    int32_t                  src_x,

+                                    int32_t                  src_y,

+                                    int32_t                  mask_x,

+                                    int32_t                  mask_y,

+                                    int32_t                  dest_x,

+                                    int32_t                  dest_y,

+                                    int32_t                  width,

+                                    int32_t                  height)

+{

+    uint32_t  src, srca, s;

+    uint16_t  src16;

+    uint16_t *dst_line, *dst;

+    uint32_t  d;

+    uint32_t *mask_line, *mask, ma;

+    int dst_stride, mask_stride;

+    int32_t w;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    src16 = CONVERT_8888_TO_0565 (src);

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    ma = *mask++;

+	    if (ma == 0xffffffff)

+	    {

+		if (srca == 0xff)

+		{

+		    *dst = src16;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (src, CONVERT_0565_TO_0888 (d));

+		    *dst = CONVERT_8888_TO_0565 (d);

+		}

+	    }

+	    else if (ma)

+	    {

+		d = *dst;

+		d = CONVERT_0565_TO_0888 (d);

+

+		s = src;

+

+		UN8x4_MUL_UN8x4 (s, ma);

+		UN8x4_MUL_UN8 (ma, srca);

+		ma = ~ma;

+		UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ma, s);

+

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_over_8888_8888 (pixman_implementation_t *imp,

+                               pixman_op_t              op,

+                               pixman_image_t *         src_image,

+                               pixman_image_t *         mask_image,

+                               pixman_image_t *         dst_image,

+                               int32_t                  src_x,

+                               int32_t                  src_y,

+                               int32_t                  mask_x,

+                               int32_t                  mask_y,

+                               int32_t                  dest_x,

+                               int32_t                  dest_y,

+                               int32_t                  width,

+                               int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src, s;

+    int dst_stride, src_stride;

+    uint8_t a;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (a == 0xff)

+		*dst = s;

+	    else if (s)

+		*dst = over (s, *dst);

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_src_x888_8888 (pixman_implementation_t *imp,

+			      pixman_op_t              op,

+			      pixman_image_t *         src_image,

+			      pixman_image_t *         mask_image,

+			      pixman_image_t *         dst_image,

+			      int32_t                  src_x,

+			      int32_t                  src_y,

+			      int32_t                  mask_x,

+			      int32_t                  mask_y,

+			      int32_t                  dest_x,

+			      int32_t                  dest_y,

+			      int32_t                  width,

+			      int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	    *dst++ = (*src++) | 0xff000000;

+    }

+}

+

+#if 0

+static void

+fast_composite_over_8888_0888 (pixman_implementation_t *imp,

+			       pixman_op_t              op,

+			       pixman_image_t *         src_image,

+			       pixman_image_t *         mask_image,

+			       pixman_image_t *         dst_image,

+			       int32_t                  src_x,

+			       int32_t                  src_y,

+			       int32_t                  mask_x,

+			       int32_t                  mask_y,

+			       int32_t                  dest_x,

+			       int32_t                  dest_y,

+			       int32_t                  width,

+			       int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint32_t d;

+    uint32_t    *src_line, *src, s;

+    uint8_t a;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (a)

+	    {

+		if (a == 0xff)

+		    d = s;

+		else

+		    d = over (s, fetch_24 (dst));

+

+		store_24 (dst, d);

+	    }

+	    dst += 3;

+	}

+    }

+}

+#endif

+

+static void

+fast_composite_over_8888_0565 (pixman_implementation_t *imp,

+                               pixman_op_t              op,

+                               pixman_image_t *         src_image,

+                               pixman_image_t *         mask_image,

+                               pixman_image_t *         dst_image,

+                               int32_t                  src_x,

+                               int32_t                  src_y,

+                               int32_t                  mask_x,

+                               int32_t                  mask_y,

+                               int32_t                  dest_x,

+                               int32_t                  dest_y,

+                               int32_t                  width,

+                               int32_t                  height)

+{

+    uint16_t    *dst_line, *dst;

+    uint32_t d;

+    uint32_t    *src_line, *src, s;

+    uint8_t a;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    a = s >> 24;

+	    if (s)

+	    {

+		if (a == 0xff)

+		{

+		    d = s;

+		}

+		else

+		{

+		    d = *dst;

+		    d = over (s, CONVERT_0565_TO_0888 (d));

+		}

+		*dst = CONVERT_8888_TO_0565 (d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_src_x888_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint16_t    *dst_line, *dst;

+    uint32_t    *src_line, *src, s;

+    int dst_stride, src_stride;

+    int32_t w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    *dst = CONVERT_8888_TO_0565 (s);

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_8_8 (pixman_implementation_t *imp,

+			pixman_op_t              op,

+			pixman_image_t *         src_image,

+			pixman_image_t *         mask_image,

+			pixman_image_t *         dst_image,

+			int32_t                  src_x,

+			int32_t                  src_y,

+			int32_t                  mask_x,

+			int32_t                  mask_y,

+			int32_t                  dest_x,

+			int32_t                  dest_y,

+			int32_t                  width,

+			int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint8_t s, d;

+    uint16_t t;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    if (s)

+	    {

+		if (s != 0xff)

+		{

+		    d = *dst;

+		    t = d + s;

+		    s = t | (0 - (t >> 8));

+		}

+		*dst = s;

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_8888_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t    *dst_line, *dst;

+    uint32_t    *src_line, *src;

+    int dst_stride, src_stride;

+    int32_t w;

+    uint32_t s, d;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    s = *src++;

+	    if (s)

+	    {

+		if (s != 0xffffffff)

+		{

+		    d = *dst;

+		    if (d)

+			UN8x4_ADD_UN8x4 (s, d);

+		}

+		*dst = s;

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+fast_composite_add_n_8_8 (pixman_implementation_t *imp,

+			  pixman_op_t              op,

+			  pixman_image_t *         src_image,

+			  pixman_image_t *         mask_image,

+			  pixman_image_t *         dst_image,

+			  int32_t                  src_x,

+			  int32_t                  src_y,

+			  int32_t                  mask_x,

+			  int32_t                  mask_y,

+			  int32_t                  dest_x,

+			  int32_t                  dest_y,

+			  int32_t                  width,

+			  int32_t                  height)

+{

+    uint8_t     *dst_line, *dst;

+    uint8_t     *mask_line, *mask;

+    int dst_stride, mask_stride;

+    int32_t w;

+    uint32_t src;

+    uint8_t sa;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    sa = (src >> 24);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	mask = mask_line;

+	mask_line += mask_stride;

+	w = width;

+

+	while (w--)

+	{

+	    uint16_t tmp;

+	    uint16_t a;

+	    uint32_t m, d;

+	    uint32_t r;

+

+	    a = *mask++;

+	    d = *dst;

+

+	    m = MUL_UN8 (sa, a, tmp);

+	    r = ADD_UN8 (m, d, tmp);

+

+	    *dst++ = r;

+	}

+    }

+}

+

+#ifdef WORDS_BIGENDIAN

+#define CREATE_BITMASK(n) (0x80000000 >> (n))

+#define UPDATE_BITMASK(n) ((n) >> 1)

+#else

+#define CREATE_BITMASK(n) (1 << (n))

+#define UPDATE_BITMASK(n) ((n) << 1)

+#endif

+

+#define TEST_BIT(p, n)					\

+    (*((p) + ((n) >> 5)) & CREATE_BITMASK ((n) & 31))

+#define SET_BIT(p, n)							\

+    do { *((p) + ((n) >> 5)) |= CREATE_BITMASK ((n) & 31); } while (0);

+

+static void

+fast_composite_add_1000_1000 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     *dst_line, *dst;

+    uint32_t     *src_line, *src;

+    int           dst_stride, src_stride;

+    int32_t       w;

+

+    PIXMAN_IMAGE_GET_LINE (src_image, 0, src_y, uint32_t,

+                           src_stride, src_line, 1);

+    PIXMAN_IMAGE_GET_LINE (dst_image, 0, dest_y, uint32_t,

+                           dst_stride, dst_line, 1);

+

+    while (height--)

+    {

+	dst = dst_line;

+	dst_line += dst_stride;

+	src = src_line;

+	src_line += src_stride;

+	w = width;

+

+	while (w--)

+	{

+	    /*

+	     * TODO: improve performance by processing uint32_t data instead

+	     *       of individual bits

+	     */

+	    if (TEST_BIT (src, src_x + w))

+		SET_BIT (dst, dest_x + w);

+	}

+    }

+}

+

+static void

+fast_composite_over_n_1_8888 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     src, srca;

+    uint32_t    *dst, *dst_line;

+    uint32_t    *mask, *mask_line;

+    int          mask_stride, dst_stride;

+    uint32_t     bitcache, bitmask;

+    int32_t      w;

+

+    if (width <= 0)

+	return;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t,

+                           dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,

+                           mask_stride, mask_line, 1);

+    mask_line += mask_x >> 5;

+

+    if (srca == 0xff)

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = src;

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = over (src, *dst);

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+}

+

+static void

+fast_composite_over_n_1_0565 (pixman_implementation_t *imp,

+                              pixman_op_t              op,

+                              pixman_image_t *         src_image,

+                              pixman_image_t *         mask_image,

+                              pixman_image_t *         dst_image,

+                              int32_t                  src_x,

+                              int32_t                  src_y,

+                              int32_t                  mask_x,

+                              int32_t                  mask_y,

+                              int32_t                  dest_x,

+                              int32_t                  dest_y,

+                              int32_t                  width,

+                              int32_t                  height)

+{

+    uint32_t     src, srca;

+    uint16_t    *dst, *dst_line;

+    uint32_t    *mask, *mask_line;

+    int          mask_stride, dst_stride;

+    uint32_t     bitcache, bitmask;

+    int32_t      w;

+    uint32_t     d;

+    uint16_t     src565;

+

+    if (width <= 0)

+	return;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+    srca = src >> 24;

+    if (src == 0)

+	return;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t,

+                           dst_stride, dst_line, 1);

+    PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,

+                           mask_stride, mask_line, 1);

+    mask_line += mask_x >> 5;

+

+    if (srca == 0xff)

+    {

+	src565 = CONVERT_8888_TO_0565 (src);

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		    *dst = src565;

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    dst = dst_line;

+	    dst_line += dst_stride;

+	    mask = mask_line;

+	    mask_line += mask_stride;

+	    w = width;

+

+	    bitcache = *mask++;

+	    bitmask = CREATE_BITMASK (mask_x & 31);

+

+	    while (w--)

+	    {

+		if (bitmask == 0)

+		{

+		    bitcache = *mask++;

+		    bitmask = CREATE_BITMASK (0);

+		}

+		if (bitcache & bitmask)

+		{

+		    d = over (src, CONVERT_0565_TO_0888 (*dst));

+		    *dst = CONVERT_8888_TO_0565 (d);

+		}

+		bitmask = UPDATE_BITMASK (bitmask);

+		dst++;

+	    }

+	}

+    }

+}

+

+/*

+ * Simple bitblt

+ */

+

+static void

+fast_composite_solid_fill (pixman_implementation_t *imp,

+                           pixman_op_t              op,

+                           pixman_image_t *         src_image,

+                           pixman_image_t *         mask_image,

+                           pixman_image_t *         dst_image,

+                           int32_t                  src_x,

+                           int32_t                  src_y,

+                           int32_t                  mask_x,

+                           int32_t                  mask_y,

+                           int32_t                  dest_x,

+                           int32_t                  dest_y,

+                           int32_t                  width,

+                           int32_t                  height)

+{

+    uint32_t src;

+

+    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);

+

+    if (dst_image->bits.format == PIXMAN_a1)

+    {

+	src = src >> 31;

+    }

+    else if (dst_image->bits.format == PIXMAN_a8)

+    {

+	src = src >> 24;

+    }

+    else if (dst_image->bits.format == PIXMAN_r5g6b5 ||

+             dst_image->bits.format == PIXMAN_b5g6r5)

+    {

+	src = CONVERT_8888_TO_0565 (src);

+    }

+

+    pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,

+                 PIXMAN_FORMAT_BPP (dst_image->bits.format),

+                 dest_x, dest_y,

+                 width, height,

+                 src);

+}

+

+static void

+fast_composite_src_memcpy (pixman_implementation_t *imp,

+			   pixman_op_t              op,

+			   pixman_image_t *         src_image,

+			   pixman_image_t *         mask_image,

+			   pixman_image_t *         dst_image,

+			   int32_t                  src_x,

+			   int32_t                  src_y,

+			   int32_t                  mask_x,

+			   int32_t                  mask_y,

+			   int32_t                  dest_x,

+			   int32_t                  dest_y,

+			   int32_t                  width,

+			   int32_t                  height)

+{

+    int bpp = PIXMAN_FORMAT_BPP (dst_image->bits.format) / 8;

+    uint32_t n_bytes = width * bpp;

+    int dst_stride, src_stride;

+    uint8_t    *dst;

+    uint8_t    *src;

+

+    src_stride = src_image->bits.rowstride * 4;

+    dst_stride = dst_image->bits.rowstride * 4;

+

+    src = (uint8_t *)src_image->bits.bits + src_y * src_stride + src_x * bpp;

+    dst = (uint8_t *)dst_image->bits.bits + dest_y * dst_stride + dest_x * bpp;

+

+    while (height--)

+    {

+	memcpy (dst, src, n_bytes);

+

+	dst += dst_stride;

+	src += src_stride;

+    }

+}

+

+FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, SRC, COVER)

+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, SRC, NONE)

+FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, SRC, PAD)

+FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, SRC, NORMAL)

+FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, OVER, COVER)

+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, OVER, NONE)

+FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, OVER, PAD)

+FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, OVER, NORMAL)

+FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, SRC, COVER)

+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, NONE)

+FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, SRC, PAD)

+FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, NORMAL)

+FAST_NEAREST (565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, NORMAL)

+FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, OVER, COVER)

+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, NONE)

+FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, OVER, PAD)

+FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, NORMAL)

+

+/* Use more unrolling for src_0565_0565 because it is typically CPU bound */

+static force_inline void

+scaled_nearest_scanline_565_565_SRC (uint16_t *      dst,

+				     uint16_t *      src,

+				     int32_t         w,

+				     pixman_fixed_t  vx,

+				     pixman_fixed_t  unit_x,

+				     pixman_fixed_t  max_vx)

+{

+    uint16_t tmp1, tmp2, tmp3, tmp4;

+    while ((w -= 4) >= 0)

+    {

+	tmp1 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp2 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp3 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp4 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	*dst++ = tmp1;

+	*dst++ = tmp2;

+	*dst++ = tmp3;

+	*dst++ = tmp4;

+    }

+    if (w & 2)

+    {

+	tmp1 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	tmp2 = src[pixman_fixed_to_int (vx)];

+	vx += unit_x;

+	*dst++ = tmp1;

+	*dst++ = tmp2;

+    }

+    if (w & 1)

+	*dst++ = src[pixman_fixed_to_int (vx)];

+}

+

+FAST_NEAREST_MAINLOOP (565_565_cover_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, COVER)

+FAST_NEAREST_MAINLOOP (565_565_none_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, NONE)

+FAST_NEAREST_MAINLOOP (565_565_pad_SRC,

+		       scaled_nearest_scanline_565_565_SRC,

+		       uint16_t, uint16_t, PAD)

+

+static force_inline uint32_t

+fetch_nearest (pixman_repeat_t src_repeat,

+	       pixman_format_code_t format,

+	       uint32_t *src, int x, int src_width)

+{

+    if (repeat (src_repeat, &x, src_width))

+    {

+	if (format == PIXMAN_x8r8g8b8)

+	    return *(src + x) | 0xff000000;

+	else

+	    return *(src + x);

+    }

+    else

+    {

+	return 0;

+    }

+}

+

+static force_inline void

+combine_over (uint32_t s, uint32_t *dst)

+{

+    if (s)

+    {

+	uint8_t ia = 0xff - (s >> 24);

+

+	if (ia)

+	    UN8x4_MUL_UN8_ADD_UN8x4 (*dst, ia, s);

+	else

+	    *dst = s;

+    }

+}

+

+static force_inline void

+combine_src (uint32_t s, uint32_t *dst)

+{

+    *dst = s;

+}

+

+static void

+fast_composite_scaled_nearest (pixman_implementation_t *imp,

+			       pixman_op_t              op,

+			       pixman_image_t *         src_image,

+			       pixman_image_t *         mask_image,

+			       pixman_image_t *         dst_image,

+			       int32_t                  src_x,

+			       int32_t                  src_y,

+			       int32_t                  mask_x,

+			       int32_t                  mask_y,

+			       int32_t                  dest_x,

+			       int32_t                  dest_y,

+			       int32_t                  width,

+			       int32_t                  height)

+{

+    uint32_t       *dst_line;

+    uint32_t       *src_line;

+    int             dst_stride, src_stride;

+    int		    src_width, src_height;

+    pixman_repeat_t src_repeat;

+    pixman_fixed_t unit_x, unit_y;

+    pixman_format_code_t src_format;

+    pixman_vector_t v;

+    pixman_fixed_t vy;

+

+    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);

+    /* pass in 0 instead of src_x and src_y because src_x and src_y need to be

+     * transformed from destination space to source space

+     */

+    PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, uint32_t, src_stride, src_line, 1);

+

+    /* reference point is the center of the pixel */

+    v.vector[0] = pixman_int_to_fixed (src_x) + pixman_fixed_1 / 2;

+    v.vector[1] = pixman_int_to_fixed (src_y) + pixman_fixed_1 / 2;

+    v.vector[2] = pixman_fixed_1;

+

+    if (!pixman_transform_point_3d (src_image->common.transform, &v))

+	return;

+

+    unit_x = src_image->common.transform->matrix[0][0];

+    unit_y = src_image->common.transform->matrix[1][1];

+

+    /* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */

+    v.vector[0] -= pixman_fixed_e;

+    v.vector[1] -= pixman_fixed_e;

+

+    src_height = src_image->bits.height;

+    src_width = src_image->bits.width;

+    src_repeat = src_image->common.repeat;

+    src_format = src_image->bits.format;

+

+    vy = v.vector[1];

+    while (height--)

+    {

+        pixman_fixed_t vx = v.vector[0];

+	int y = pixman_fixed_to_int (vy);

+	uint32_t *dst = dst_line;

+

+	dst_line += dst_stride;

+

+        /* adjust the y location by a unit vector in the y direction

+         * this is equivalent to transforming y+1 of the destination point to source space */

+        vy += unit_y;

+

+	if (!repeat (src_repeat, &y, src_height))

+	{

+	    if (op == PIXMAN_OP_SRC)

+		memset (dst, 0, sizeof (*dst) * width);

+	}

+	else

+	{

+	    int w = width;

+

+	    uint32_t *src = src_line + y * src_stride;

+

+	    while (w >= 2)

+	    {

+		uint32_t s1, s2;

+		int x1, x2;

+

+		x1 = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		x2 = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		w -= 2;

+

+		s1 = fetch_nearest (src_repeat, src_format, src, x1, src_width);

+		s2 = fetch_nearest (src_repeat, src_format, src, x2, src_width);

+

+		if (op == PIXMAN_OP_OVER)

+		{

+		    combine_over (s1, dst++);

+		    combine_over (s2, dst++);

+		}

+		else

+		{

+		    combine_src (s1, dst++);

+		    combine_src (s2, dst++);

+		}

+	    }

+

+	    while (w--)

+	    {

+		uint32_t s;

+		int x;

+

+		x = pixman_fixed_to_int (vx);

+		vx += unit_x;

+

+		s = fetch_nearest (src_repeat, src_format, src, x, src_width);

+

+		if (op == PIXMAN_OP_OVER)

+		    combine_over (s, dst++);

+		else

+		    combine_src (s, dst++);

+	    }

+	}

+    }

+}

+

+static const pixman_fast_path_t c_fast_paths[] =

+{

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, fast_composite_over_n_8_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, fast_composite_over_n_8_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, r8g8b8, fast_composite_over_n_8_0888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, b8g8r8, fast_composite_over_n_8_0888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8r8g8b8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8r8g8b8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8b8g8r8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8b8g8r8, fast_composite_over_n_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8r8g8b8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8r8g8b8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, a8b8g8r8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, x8b8g8r8, fast_composite_over_n_1_8888),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, r5g6b5,   fast_composite_over_n_1_0565),

+    PIXMAN_STD_FAST_PATH (OVER, solid, a1, b5g6r5,   fast_composite_over_n_1_0565),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, a8r8g8b8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, x8r8g8b8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, r5g6b5, fast_composite_over_n_8888_0565_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, a8b8g8r8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, x8b8g8r8, fast_composite_over_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, b5g6r5, fast_composite_over_n_8888_0565_ca),

+    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, x8r8g8b8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, a8r8g8b8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, x8b8g8r8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, a8b8g8r8, fast_composite_over_x888_8_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, a8r8g8b8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, x8r8g8b8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, r5g6b5, fast_composite_over_8888_0565),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, a8b8g8r8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, x8b8g8r8, fast_composite_over_8888_8888),

+    PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, b5g6r5, fast_composite_over_8888_0565),

+    PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, fast_composite_add_8888_8888),

+    PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, fast_composite_add_8888_8888),

+    PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, fast_composite_add_8_8),

+    PIXMAN_STD_FAST_PATH (ADD, a1, null, a1, fast_composite_add_1000_1000),

+    PIXMAN_STD_FAST_PATH_CA (ADD, solid, a8r8g8b8, a8r8g8b8, fast_composite_add_n_8888_8888_ca),

+    PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, fast_composite_add_n_8_8),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8r8g8b8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8r8g8b8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8b8g8r8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, x8b8g8r8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a1, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, a8, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, solid, null, r5g6b5, fast_composite_solid_fill),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, a8r8g8b8, fast_composite_src_x888_8888),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, a8b8g8r8, fast_composite_src_x888_8888),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, a8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, x8r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, a8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, x8b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8x8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8a8, null, b8g8r8a8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8x8, null, b8g8r8x8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, r8g8b8, null, r8g8b8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, b8g8r8, null, b8g8r8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, x1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a1r5g5b5, null, x1r5g5b5, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8, null, a8, fast_composite_src_memcpy),

+    PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, fast_composite_src_x888_0565),

+    PIXMAN_STD_FAST_PATH (IN, a8, null, a8, fast_composite_in_8_8),

+    PIXMAN_STD_FAST_PATH (IN, solid, a8, a8, fast_composite_in_n_8_8),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, x8r8g8b8, r5g6b5, 8888_565),

+    SIMPLE_NEAREST_FAST_PATH (SRC, a8r8g8b8, r5g6b5, 8888_565),

+

+    SIMPLE_NEAREST_FAST_PATH (SRC, r5g6b5, r5g6b5, 565_565),

+

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, 8888_8888),

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, 8888_8888),

+

+    SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, r5g6b5, 8888_565),

+

+#define NEAREST_FAST_PATH(op,s,d)		\

+    {   PIXMAN_OP_ ## op,			\

+	PIXMAN_ ## s, SCALED_NEAREST_FLAGS,	\

+	PIXMAN_null, 0,				\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,	\

+	fast_composite_scaled_nearest,		\

+    }

+

+    NEAREST_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8),

+    NEAREST_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8),

+

+    NEAREST_FAST_PATH (SRC, x8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (SRC, x8b8g8r8, a8b8g8r8),

+    NEAREST_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8),

+

+    NEAREST_FAST_PATH (OVER, x8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8),

+    NEAREST_FAST_PATH (OVER, x8b8g8r8, x8b8g8r8),

+    NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8),

+

+    NEAREST_FAST_PATH (OVER, x8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8),

+    NEAREST_FAST_PATH (OVER, x8b8g8r8, a8b8g8r8),

+    NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8),

+

+    {   PIXMAN_OP_NONE	},

+};

+

+#ifdef WORDS_BIGENDIAN

+#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (32 - (offs) - (n)))

+#else

+#define A1_FILL_MASK(n, offs) (((1 << (n)) - 1) << (offs))

+#endif

+

+static force_inline void

+pixman_fill1_line (uint32_t *dst, int offs, int width, int v)

+{

+    if (offs)

+    {

+	int leading_pixels = 32 - offs;

+	if (leading_pixels >= width)

+	{

+	    if (v)

+		*dst |= A1_FILL_MASK (width, offs);

+	    else

+		*dst &= ~A1_FILL_MASK (width, offs);

+	    return;

+	}

+	else

+	{

+	    if (v)

+		*dst++ |= A1_FILL_MASK (leading_pixels, offs);

+	    else

+		*dst++ &= ~A1_FILL_MASK (leading_pixels, offs);

+	    width -= leading_pixels;

+	}

+    }

+    while (width >= 32)

+    {

+	if (v)

+	    *dst++ = 0xFFFFFFFF;

+	else

+	    *dst++ = 0;

+	width -= 32;

+    }

+    if (width > 0)

+    {

+	if (v)

+	    *dst |= A1_FILL_MASK (width, 0);

+	else

+	    *dst &= ~A1_FILL_MASK (width, 0);

+    }

+}

+

+static void

+pixman_fill1 (uint32_t *bits,

+              int       stride,

+              int       x,

+              int       y,

+              int       width,

+              int       height,

+              uint32_t  xor)

+{

+    uint32_t *dst = bits + y * stride + (x >> 5);

+    int offs = x & 31;

+

+    if (xor & 1)

+    {

+	while (height--)

+	{

+	    pixman_fill1_line (dst, offs, width, 1);

+	    dst += stride;

+	}

+    }

+    else

+    {

+	while (height--)

+	{

+	    pixman_fill1_line (dst, offs, width, 0);

+	    dst += stride;

+	}

+    }

+}

+

+static void

+pixman_fill8 (uint32_t *bits,

+              int       stride,

+              int       x,

+              int       y,

+              int       width,

+              int       height,

+              uint32_t xor)

+{

+    int byte_stride = stride * (int) sizeof (uint32_t);

+    uint8_t *dst = (uint8_t *) bits;

+    uint8_t v = xor & 0xff;

+    int i;

+

+    dst = dst + y * byte_stride + x;

+

+    while (height--)

+    {

+	for (i = 0; i < width; ++i)

+	    dst[i] = v;

+

+	dst += byte_stride;

+    }

+}

+

+static void

+pixman_fill16 (uint32_t *bits,

+               int       stride,

+               int       x,

+               int       y,

+               int       width,

+               int       height,

+               uint32_t xor)

+{

+    int short_stride =

+	(stride * (int)sizeof (uint32_t)) / (int)sizeof (uint16_t);

+    uint16_t *dst = (uint16_t *)bits;

+    uint16_t v = xor & 0xffff;

+    int i;

+

+    dst = dst + y * short_stride + x;

+

+    while (height--)

+    {

+	for (i = 0; i < width; ++i)

+	    dst[i] = v;

+

+	dst += short_stride;

+    }

+}

+

+static void

+pixman_fill32 (uint32_t *bits,

+               int       stride,

+               int       x,

+               int       y,

+               int       width,

+               int       height,

+               uint32_t  xor)

+{

+    int i;

+

+    bits = bits + y * stride + x;

+

+    while (height--)

+    {

+	for (i = 0; i < width; ++i)

+	    bits[i] = xor;

+

+	bits += stride;

+    }

+}

+

+static pixman_bool_t

+fast_path_fill (pixman_implementation_t *imp,

+                uint32_t *               bits,

+                int                      stride,

+                int                      bpp,

+                int                      x,

+                int                      y,

+                int                      width,

+                int                      height,

+                uint32_t		 xor)

+{

+    switch (bpp)

+    {

+    case 1:

+	pixman_fill1 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 8:

+	pixman_fill8 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 16:

+	pixman_fill16 (bits, stride, x, y, width, height, xor);

+	break;

+

+    case 32:

+	pixman_fill32 (bits, stride, x, y, width, height, xor);

+	break;

+

+    default:

+	return _pixman_implementation_fill (

+	    imp->delegate, bits, stride, bpp, x, y, width, height, xor);

+	break;

+    }

+

+    return TRUE;

+}

+

+pixman_implementation_t *

+_pixman_implementation_create_fast_path (void)

+{

+    pixman_implementation_t *general = _pixman_implementation_create_general ();

+    pixman_implementation_t *imp = _pixman_implementation_create (general, c_fast_paths);

+

+    imp->fill = fast_path_fill;

+

+    return imp;

+}

diff --git a/pixman/pixman/pixman-matrix.c b/pixman/pixman/pixman-matrix.c
index f2f67ab41..0b3ae78b3 100644
--- a/pixman/pixman/pixman-matrix.c
+++ b/pixman/pixman/pixman-matrix.c
@@ -1,769 +1,766 @@
-/*
- * Copyright © 2008 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that copyright
- * notice and this permission notice appear in supporting documentation, and
- * that the name of the copyright holders not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  The copyright holders make no representations
- * about the suitability of this software for any purpose.  It is provided "as
- * is" without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
- * OF THIS SOFTWARE.
- */
-
-/*
- * Matrix interfaces
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <math.h>
-#include <string.h>
-#include "pixman-private.h"
-
-#define F(x)    pixman_int_to_fixed (x)
-
-PIXMAN_EXPORT void
-pixman_transform_init_identity (struct pixman_transform *matrix)
-{
-    int i;
-
-    memset (matrix, '\0', sizeof (struct pixman_transform));
-    for (i = 0; i < 3; i++)
-	matrix->matrix[i][i] = F (1);
-}
-
-typedef pixman_fixed_32_32_t pixman_fixed_34_30_t;
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_point_3d (const struct pixman_transform *transform,
-                           struct pixman_vector *         vector)
-{
-    struct pixman_vector result;
-    pixman_fixed_32_32_t partial;
-    pixman_fixed_48_16_t v;
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	v = 0;
-	for (i = 0; i < 3; i++)
-	{
-	    partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *
-	               (pixman_fixed_48_16_t) vector->vector[i]);
-	    v += partial >> 16;
-	}
-	
-	if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
-	    return FALSE;
-	
-	result.vector[j] = (pixman_fixed_t) v;
-    }
-    
-    *vector = result;
-
-    if (!result.vector[2])
-	return FALSE;
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_point (const struct pixman_transform *transform,
-                        struct pixman_vector *         vector)
-{
-    pixman_fixed_32_32_t partial;
-    pixman_fixed_34_30_t v[3];
-    pixman_fixed_48_16_t quo;
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	v[j] = 0;
-	
-	for (i = 0; i < 3; i++)
-	{
-	    partial = ((pixman_fixed_32_32_t) transform->matrix[j][i] *
-	               (pixman_fixed_32_32_t) vector->vector[i]);
-	    v[j] += partial >> 2;
-	}
-    }
-    
-    if (!(v[2] >> 16))
-	return FALSE;
-
-    for (j = 0; j < 2; j++)
-    {
-	quo = v[j] / (v[2] >> 16);
-	if (quo > pixman_max_fixed_48_16 || quo < pixman_min_fixed_48_16)
-	    return FALSE;
-	vector->vector[j] = (pixman_fixed_t) quo;
-    }
-    
-    vector->vector[2] = pixman_fixed_1;
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_multiply (struct pixman_transform *      dst,
-                           const struct pixman_transform *l,
-                           const struct pixman_transform *r)
-{
-    struct pixman_transform d;
-    int dx, dy;
-    int o;
-
-    for (dy = 0; dy < 3; dy++)
-    {
-	for (dx = 0; dx < 3; dx++)
-	{
-	    pixman_fixed_48_16_t v;
-	    pixman_fixed_32_32_t partial;
-	    
-	    v = 0;
-	    for (o = 0; o < 3; o++)
-	    {
-		partial =
-		    (pixman_fixed_32_32_t) l->matrix[dy][o] *
-		    (pixman_fixed_32_32_t) r->matrix[o][dx];
-
-		v += partial >> 16;
-	    }
-
-	    if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
-		return FALSE;
-	    
-	    d.matrix[dy][dx] = (pixman_fixed_t) v;
-	}
-    }
-
-    *dst = d;
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_scale (struct pixman_transform *t,
-                             pixman_fixed_t           sx,
-                             pixman_fixed_t           sy)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = sx;
-    t->matrix[1][1] = sy;
-    t->matrix[2][2] = F (1);
-}
-
-static pixman_fixed_t
-fixed_inverse (pixman_fixed_t x)
-{
-    return (pixman_fixed_t) ((((pixman_fixed_48_16_t) F (1)) * F (1)) / x);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_scale (struct pixman_transform *forward,
-                        struct pixman_transform *reverse,
-                        pixman_fixed_t           sx,
-                        pixman_fixed_t           sy)
-{
-    struct pixman_transform t;
-
-    if (sx == 0 || sy == 0)
-	return FALSE;
-
-    if (forward)
-    {
-	pixman_transform_init_scale (&t, sx, sy);
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-    
-    if (reverse)
-    {
-	pixman_transform_init_scale (&t, fixed_inverse (sx),
-	                             fixed_inverse (sy));
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_rotate (struct pixman_transform *t,
-                              pixman_fixed_t           c,
-                              pixman_fixed_t           s)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = c;
-    t->matrix[0][1] = -s;
-    t->matrix[1][0] = s;
-    t->matrix[1][1] = c;
-    t->matrix[2][2] = F (1);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_rotate (struct pixman_transform *forward,
-                         struct pixman_transform *reverse,
-                         pixman_fixed_t           c,
-                         pixman_fixed_t           s)
-{
-    struct pixman_transform t;
-
-    if (forward)
-    {
-	pixman_transform_init_rotate (&t, c, s);
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-
-    if (reverse)
-    {
-	pixman_transform_init_rotate (&t, c, -s);
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_transform_init_translate (struct pixman_transform *t,
-                                 pixman_fixed_t           tx,
-                                 pixman_fixed_t           ty)
-{
-    memset (t, '\0', sizeof (struct pixman_transform));
-
-    t->matrix[0][0] = F (1);
-    t->matrix[0][2] = tx;
-    t->matrix[1][1] = F (1);
-    t->matrix[1][2] = ty;
-    t->matrix[2][2] = F (1);
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_translate (struct pixman_transform *forward,
-                            struct pixman_transform *reverse,
-                            pixman_fixed_t           tx,
-                            pixman_fixed_t           ty)
-{
-    struct pixman_transform t;
-
-    if (forward)
-    {
-	pixman_transform_init_translate (&t, tx, ty);
-
-	if (!pixman_transform_multiply (forward, &t, forward))
-	    return FALSE;
-    }
-
-    if (reverse)
-    {
-	pixman_transform_init_translate (&t, -tx, -ty);
-
-	if (!pixman_transform_multiply (reverse, reverse, &t))
-	    return FALSE;
-    }
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_bounds (const struct pixman_transform *matrix,
-                         struct pixman_box16 *          b)
-
-{
-    struct pixman_vector v[4];
-    int i;
-    int x1, y1, x2, y2;
-
-    v[0].vector[0] = F (b->x1);
-    v[0].vector[1] = F (b->y1);
-    v[0].vector[2] = F (1);
-
-    v[1].vector[0] = F (b->x2);
-    v[1].vector[1] = F (b->y1);
-    v[1].vector[2] = F (1);
-
-    v[2].vector[0] = F (b->x2);
-    v[2].vector[1] = F (b->y2);
-    v[2].vector[2] = F (1);
-
-    v[3].vector[0] = F (b->x1);
-    v[3].vector[1] = F (b->y2);
-    v[3].vector[2] = F (1);
-
-    for (i = 0; i < 4; i++)
-    {
-	if (!pixman_transform_point (matrix, &v[i]))
-	    return FALSE;
-
-	x1 = pixman_fixed_to_int (v[i].vector[0]);
-	y1 = pixman_fixed_to_int (v[i].vector[1]);
-	x2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[0]));
-	y2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[1]));
-
-	if (i == 0)
-	{
-	    b->x1 = x1;
-	    b->y1 = y1;
-	    b->x2 = x2;
-	    b->y2 = y2;
-	}
-	else
-	{
-	    if (x1 < b->x1) b->x1 = x1;
-	    if (y1 < b->y1) b->y1 = y1;
-	    if (x2 > b->x2) b->x2 = x2;
-	    if (y2 > b->y2) b->y2 = y2;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_invert (struct pixman_transform *      dst,
-                         const struct pixman_transform *src)
-{
-    struct pixman_f_transform m, r;
-
-    pixman_f_transform_from_pixman_transform (&m, src);
-
-    if (!pixman_f_transform_invert (&r, &m))
-	return FALSE;
-
-    if (!pixman_transform_from_pixman_f_transform (dst, &r))
-	return FALSE;
-
-    return TRUE;
-}
-
-static pixman_bool_t
-within_epsilon (pixman_fixed_t a,
-                pixman_fixed_t b,
-                pixman_fixed_t epsilon)
-{
-    pixman_fixed_t t = a - b;
-
-    if (t < 0)
-	t = -t;
-
-    return t <= epsilon;
-}
-
-#define EPSILON (pixman_fixed_t) (2)
-
-#define IS_SAME(a, b) (within_epsilon (a, b, EPSILON))
-#define IS_ZERO(a)    (within_epsilon (a, 0, EPSILON))
-#define IS_ONE(a)     (within_epsilon (a, F (1), EPSILON))
-#define IS_UNIT(a)			    \
-    (within_epsilon (a, F (1), EPSILON) ||  \
-     within_epsilon (a, F (-1), EPSILON) || \
-     IS_ZERO (a))
-#define IS_INT(a)    (IS_ZERO (pixman_fixed_frac (a)))
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_identity (const struct pixman_transform *t)
-{
-    return (IS_SAME (t->matrix[0][0], t->matrix[1][1]) &&
-	    IS_SAME (t->matrix[0][0], t->matrix[2][2]) &&
-	    !IS_ZERO (t->matrix[0][0]) &&
-	    IS_ZERO (t->matrix[0][1]) &&
-	    IS_ZERO (t->matrix[0][2]) &&
-	    IS_ZERO (t->matrix[1][0]) &&
-	    IS_ZERO (t->matrix[1][2]) &&
-	    IS_ZERO (t->matrix[2][0]) &&
-	    IS_ZERO (t->matrix[2][1]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_scale (const struct pixman_transform *t)
-{
-    return (!IS_ZERO (t->matrix[0][0]) &&
-            IS_ZERO (t->matrix[0][1]) &&
-            IS_ZERO (t->matrix[0][2]) &&
-
-            IS_ZERO (t->matrix[1][0]) &&
-            !IS_ZERO (t->matrix[1][1]) &&
-            IS_ZERO (t->matrix[1][2]) &&
-
-            IS_ZERO (t->matrix[2][0]) &&
-            IS_ZERO (t->matrix[2][1]) &&
-            !IS_ZERO (t->matrix[2][2]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_int_translate (const struct pixman_transform *t)
-{
-    return (IS_ONE (t->matrix[0][0]) &&
-            IS_ZERO (t->matrix[0][1]) &&
-            IS_INT (t->matrix[0][2]) &&
-
-            IS_ZERO (t->matrix[1][0]) &&
-            IS_ONE (t->matrix[1][1]) &&
-            IS_INT (t->matrix[1][2]) &&
-
-            IS_ZERO (t->matrix[2][0]) &&
-            IS_ZERO (t->matrix[2][1]) &&
-            IS_ONE (t->matrix[2][2]));
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_is_inverse (const struct pixman_transform *a,
-                             const struct pixman_transform *b)
-{
-    struct pixman_transform t;
-
-    if (!pixman_transform_multiply (&t, a, b))
-	return FALSE;
-
-    return pixman_transform_is_identity (&t);
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_from_pixman_transform (struct pixman_f_transform *    ft,
-                                          const struct pixman_transform *t)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	    ft->m[j][i] = pixman_fixed_to_double (t->matrix[j][i]);
-    }
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_transform_from_pixman_f_transform (struct pixman_transform *        t,
-                                          const struct pixman_f_transform *ft)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	{
-	    double d = ft->m[j][i];
-	    if (d < -32767.0 || d > 32767.0)
-		return FALSE;
-	    d = d * 65536.0 + 0.5;
-	    t->matrix[j][i] = (pixman_fixed_t) floor (d);
-	}
-    }
-    
-    return TRUE;
-}
-
-static const int a[3] = { 3, 3, 2 };
-static const int b[3] = { 2, 1, 1 };
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_invert (struct pixman_f_transform *      dst,
-                           const struct pixman_f_transform *src)
-{
-    double det;
-    int i, j;
-    static int a[3] = { 2, 2, 1 };
-    static int b[3] = { 1, 0, 0 };
-
-    det = 0;
-    for (i = 0; i < 3; i++)
-    {
-	double p;
-	int ai = a[i];
-	int bi = b[i];
-	p = src->m[i][0] * (src->m[ai][2] * src->m[bi][1] -
-	                    src->m[ai][1] * src->m[bi][2]);
-	if (i == 1)
-	    p = -p;
-	det += p;
-    }
-    
-    if (det == 0)
-	return FALSE;
-    
-    det = 1 / det;
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	{
-	    double p;
-	    int ai = a[i];
-	    int aj = a[j];
-	    int bi = b[i];
-	    int bj = b[j];
-
-	    p = (src->m[ai][aj] * src->m[bi][bj] -
-	         src->m[ai][bj] * src->m[bi][aj]);
-	    
-	    if (((i + j) & 1) != 0)
-		p = -p;
-	    
-	    dst->m[j][i] = det * p;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_point (const struct pixman_f_transform *t,
-                          struct pixman_f_vector *         v)
-{
-    struct pixman_f_vector result;
-    int i, j;
-    double a;
-
-    for (j = 0; j < 3; j++)
-    {
-	a = 0;
-	for (i = 0; i < 3; i++)
-	    a += t->m[j][i] * v->v[i];
-	result.v[j] = a;
-    }
-    
-    if (!result.v[2])
-	return FALSE;
-
-    for (j = 0; j < 2; j++)
-	v->v[j] = result.v[j] / result.v[2];
-
-    v->v[2] = 1;
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_point_3d (const struct pixman_f_transform *t,
-                             struct pixman_f_vector *         v)
-{
-    struct pixman_f_vector result;
-    int i, j;
-    double a;
-
-    for (j = 0; j < 3; j++)
-    {
-	a = 0;
-	for (i = 0; i < 3; i++)
-	    a += t->m[j][i] * v->v[i];
-	result.v[j] = a;
-    }
-    
-    *v = result;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_multiply (struct pixman_f_transform *      dst,
-                             const struct pixman_f_transform *l,
-                             const struct pixman_f_transform *r)
-{
-    struct pixman_f_transform d;
-    int dx, dy;
-    int o;
-
-    for (dy = 0; dy < 3; dy++)
-    {
-	for (dx = 0; dx < 3; dx++)
-	{
-	    double v = 0;
-	    for (o = 0; o < 3; o++)
-		v += l->m[dy][o] * r->m[o][dx];
-	    d.m[dy][dx] = v;
-	}
-    }
-    
-    *dst = d;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_scale (struct pixman_f_transform *t,
-                               double                     sx,
-                               double                     sy)
-{
-    t->m[0][0] = sx;
-    t->m[0][1] = 0;
-    t->m[0][2] = 0;
-    t->m[1][0] = 0;
-    t->m[1][1] = sy;
-    t->m[1][2] = 0;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_scale (struct pixman_f_transform *forward,
-                          struct pixman_f_transform *reverse,
-                          double                     sx,
-                          double                     sy)
-{
-    struct pixman_f_transform t;
-
-    if (sx == 0 || sy == 0)
-	return FALSE;
-
-    if (forward)
-    {
-	pixman_f_transform_init_scale (&t, sx, sy);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-    
-    if (reverse)
-    {
-	pixman_f_transform_init_scale (&t, 1 / sx, 1 / sy);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-    
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_rotate (struct pixman_f_transform *t,
-                                double                     c,
-                                double                     s)
-{
-    t->m[0][0] = c;
-    t->m[0][1] = -s;
-    t->m[0][2] = 0;
-    t->m[1][0] = s;
-    t->m[1][1] = c;
-    t->m[1][2] = 0;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_rotate (struct pixman_f_transform *forward,
-                           struct pixman_f_transform *reverse,
-                           double                     c,
-                           double                     s)
-{
-    struct pixman_f_transform t;
-
-    if (forward)
-    {
-	pixman_f_transform_init_rotate (&t, c, s);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-    
-    if (reverse)
-    {
-	pixman_f_transform_init_rotate (&t, c, -s);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_translate (struct pixman_f_transform *t,
-                                   double                     tx,
-                                   double                     ty)
-{
-    t->m[0][0] = 1;
-    t->m[0][1] = 0;
-    t->m[0][2] = tx;
-    t->m[1][0] = 0;
-    t->m[1][1] = 1;
-    t->m[1][2] = ty;
-    t->m[2][0] = 0;
-    t->m[2][1] = 0;
-    t->m[2][2] = 1;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_translate (struct pixman_f_transform *forward,
-                              struct pixman_f_transform *reverse,
-                              double                     tx,
-                              double                     ty)
-{
-    struct pixman_f_transform t;
-
-    if (forward)
-    {
-	pixman_f_transform_init_translate (&t, tx, ty);
-	pixman_f_transform_multiply (forward, &t, forward);
-    }
-
-    if (reverse)
-    {
-	pixman_f_transform_init_translate (&t, -tx, -ty);
-	pixman_f_transform_multiply (reverse, reverse, &t);
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT pixman_bool_t
-pixman_f_transform_bounds (const struct pixman_f_transform *t,
-                           struct pixman_box16 *            b)
-{
-    struct pixman_f_vector v[4];
-    int i;
-    int x1, y1, x2, y2;
-
-    v[0].v[0] = b->x1;
-    v[0].v[1] = b->y1;
-    v[0].v[2] = 1;
-    v[1].v[0] = b->x2;
-    v[1].v[1] = b->y1;
-    v[1].v[2] = 1;
-    v[2].v[0] = b->x2;
-    v[2].v[1] = b->y2;
-    v[2].v[2] = 1;
-    v[3].v[0] = b->x1;
-    v[3].v[1] = b->y2;
-    v[3].v[2] = 1;
-
-    for (i = 0; i < 4; i++)
-    {
-	if (!pixman_f_transform_point (t, &v[i]))
-	    return FALSE;
-
-	x1 = floor (v[i].v[0]);
-	y1 = floor (v[i].v[1]);
-	x2 = ceil (v[i].v[0]);
-	y2 = ceil (v[i].v[1]);
-
-	if (i == 0)
-	{
-	    b->x1 = x1;
-	    b->y1 = y1;
-	    b->x2 = x2;
-	    b->y2 = y2;
-	}
-	else
-	{
-	    if (x1 < b->x1) b->x1 = x1;
-	    if (y1 < b->y1) b->y1 = y1;
-	    if (x2 > b->x2) b->x2 = x2;
-	    if (y2 > b->y2) b->y2 = y2;
-	}
-    }
-
-    return TRUE;
-}
-
-PIXMAN_EXPORT void
-pixman_f_transform_init_identity (struct pixman_f_transform *t)
-{
-    int i, j;
-
-    for (j = 0; j < 3; j++)
-    {
-	for (i = 0; i < 3; i++)
-	    t->m[j][i] = i == j ? 1 : 0;
-    }
-}
+/*

+ * Copyright © 2008 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that copyright

+ * notice and this permission notice appear in supporting documentation, and

+ * that the name of the copyright holders not be used in advertising or

+ * publicity pertaining to distribution of the software without specific,

+ * written prior permission.  The copyright holders make no representations

+ * about the suitability of this software for any purpose.  It is provided "as

+ * is" without express or implied warranty.

+ *

+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

+ * OF THIS SOFTWARE.

+ */

+

+/*

+ * Matrix interfaces

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <math.h>

+#include <string.h>

+#include "pixman-private.h"

+

+#define F(x)    pixman_int_to_fixed (x)

+

+PIXMAN_EXPORT void

+pixman_transform_init_identity (struct pixman_transform *matrix)

+{

+    int i;

+

+    memset (matrix, '\0', sizeof (struct pixman_transform));

+    for (i = 0; i < 3; i++)

+	matrix->matrix[i][i] = F (1);

+}

+

+typedef pixman_fixed_32_32_t pixman_fixed_34_30_t;

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_point_3d (const struct pixman_transform *transform,

+                           struct pixman_vector *         vector)

+{

+    struct pixman_vector result;

+    pixman_fixed_32_32_t partial;

+    pixman_fixed_48_16_t v;

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	v = 0;

+	for (i = 0; i < 3; i++)

+	{

+	    partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *

+	               (pixman_fixed_48_16_t) vector->vector[i]);

+	    v += partial >> 16;

+	}

+	

+	if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)

+	    return FALSE;

+	

+	result.vector[j] = (pixman_fixed_t) v;

+    }

+    

+    *vector = result;

+

+    if (!result.vector[2])

+	return FALSE;

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_point (const struct pixman_transform *transform,

+                        struct pixman_vector *         vector)

+{

+    pixman_fixed_32_32_t partial;

+    pixman_fixed_34_30_t v[3];

+    pixman_fixed_48_16_t quo;

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	v[j] = 0;

+	

+	for (i = 0; i < 3; i++)

+	{

+	    partial = ((pixman_fixed_32_32_t) transform->matrix[j][i] *

+	               (pixman_fixed_32_32_t) vector->vector[i]);

+	    v[j] += partial >> 2;

+	}

+    }

+    

+    if (!(v[2] >> 16))

+	return FALSE;

+

+    for (j = 0; j < 2; j++)

+    {

+	quo = v[j] / (v[2] >> 16);

+	if (quo > pixman_max_fixed_48_16 || quo < pixman_min_fixed_48_16)

+	    return FALSE;

+	vector->vector[j] = (pixman_fixed_t) quo;

+    }

+    

+    vector->vector[2] = pixman_fixed_1;

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_multiply (struct pixman_transform *      dst,

+                           const struct pixman_transform *l,

+                           const struct pixman_transform *r)

+{

+    struct pixman_transform d;

+    int dx, dy;

+    int o;

+

+    for (dy = 0; dy < 3; dy++)

+    {

+	for (dx = 0; dx < 3; dx++)

+	{

+	    pixman_fixed_48_16_t v;

+	    pixman_fixed_32_32_t partial;

+	    

+	    v = 0;

+	    for (o = 0; o < 3; o++)

+	    {

+		partial =

+		    (pixman_fixed_32_32_t) l->matrix[dy][o] *

+		    (pixman_fixed_32_32_t) r->matrix[o][dx];

+

+		v += partial >> 16;

+	    }

+

+	    if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)

+		return FALSE;

+	    

+	    d.matrix[dy][dx] = (pixman_fixed_t) v;

+	}

+    }

+

+    *dst = d;

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_scale (struct pixman_transform *t,

+                             pixman_fixed_t           sx,

+                             pixman_fixed_t           sy)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = sx;

+    t->matrix[1][1] = sy;

+    t->matrix[2][2] = F (1);

+}

+

+static pixman_fixed_t

+fixed_inverse (pixman_fixed_t x)

+{

+    return (pixman_fixed_t) ((((pixman_fixed_48_16_t) F (1)) * F (1)) / x);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_scale (struct pixman_transform *forward,

+                        struct pixman_transform *reverse,

+                        pixman_fixed_t           sx,

+                        pixman_fixed_t           sy)

+{

+    struct pixman_transform t;

+

+    if (sx == 0 || sy == 0)

+	return FALSE;

+

+    if (forward)

+    {

+	pixman_transform_init_scale (&t, sx, sy);

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+    

+    if (reverse)

+    {

+	pixman_transform_init_scale (&t, fixed_inverse (sx),

+	                             fixed_inverse (sy));

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_rotate (struct pixman_transform *t,

+                              pixman_fixed_t           c,

+                              pixman_fixed_t           s)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = c;

+    t->matrix[0][1] = -s;

+    t->matrix[1][0] = s;

+    t->matrix[1][1] = c;

+    t->matrix[2][2] = F (1);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_rotate (struct pixman_transform *forward,

+                         struct pixman_transform *reverse,

+                         pixman_fixed_t           c,

+                         pixman_fixed_t           s)

+{

+    struct pixman_transform t;

+

+    if (forward)

+    {

+	pixman_transform_init_rotate (&t, c, s);

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+

+    if (reverse)

+    {

+	pixman_transform_init_rotate (&t, c, -s);

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_transform_init_translate (struct pixman_transform *t,

+                                 pixman_fixed_t           tx,

+                                 pixman_fixed_t           ty)

+{

+    memset (t, '\0', sizeof (struct pixman_transform));

+

+    t->matrix[0][0] = F (1);

+    t->matrix[0][2] = tx;

+    t->matrix[1][1] = F (1);

+    t->matrix[1][2] = ty;

+    t->matrix[2][2] = F (1);

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_translate (struct pixman_transform *forward,

+                            struct pixman_transform *reverse,

+                            pixman_fixed_t           tx,

+                            pixman_fixed_t           ty)

+{

+    struct pixman_transform t;

+

+    if (forward)

+    {

+	pixman_transform_init_translate (&t, tx, ty);

+

+	if (!pixman_transform_multiply (forward, &t, forward))

+	    return FALSE;

+    }

+

+    if (reverse)

+    {

+	pixman_transform_init_translate (&t, -tx, -ty);

+

+	if (!pixman_transform_multiply (reverse, reverse, &t))

+	    return FALSE;

+    }

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_bounds (const struct pixman_transform *matrix,

+                         struct pixman_box16 *          b)

+

+{

+    struct pixman_vector v[4];

+    int i;

+    int x1, y1, x2, y2;

+

+    v[0].vector[0] = F (b->x1);

+    v[0].vector[1] = F (b->y1);

+    v[0].vector[2] = F (1);

+

+    v[1].vector[0] = F (b->x2);

+    v[1].vector[1] = F (b->y1);

+    v[1].vector[2] = F (1);

+

+    v[2].vector[0] = F (b->x2);

+    v[2].vector[1] = F (b->y2);

+    v[2].vector[2] = F (1);

+

+    v[3].vector[0] = F (b->x1);

+    v[3].vector[1] = F (b->y2);

+    v[3].vector[2] = F (1);

+

+    for (i = 0; i < 4; i++)

+    {

+	if (!pixman_transform_point (matrix, &v[i]))

+	    return FALSE;

+

+	x1 = pixman_fixed_to_int (v[i].vector[0]);

+	y1 = pixman_fixed_to_int (v[i].vector[1]);

+	x2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[0]));

+	y2 = pixman_fixed_to_int (pixman_fixed_ceil (v[i].vector[1]));

+

+	if (i == 0)

+	{

+	    b->x1 = x1;

+	    b->y1 = y1;

+	    b->x2 = x2;

+	    b->y2 = y2;

+	}

+	else

+	{

+	    if (x1 < b->x1) b->x1 = x1;

+	    if (y1 < b->y1) b->y1 = y1;

+	    if (x2 > b->x2) b->x2 = x2;

+	    if (y2 > b->y2) b->y2 = y2;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_invert (struct pixman_transform *      dst,

+                         const struct pixman_transform *src)

+{

+    struct pixman_f_transform m, r;

+

+    pixman_f_transform_from_pixman_transform (&m, src);

+

+    if (!pixman_f_transform_invert (&r, &m))

+	return FALSE;

+

+    if (!pixman_transform_from_pixman_f_transform (dst, &r))

+	return FALSE;

+

+    return TRUE;

+}

+

+static pixman_bool_t

+within_epsilon (pixman_fixed_t a,

+                pixman_fixed_t b,

+                pixman_fixed_t epsilon)

+{

+    pixman_fixed_t t = a - b;

+

+    if (t < 0)

+	t = -t;

+

+    return t <= epsilon;

+}

+

+#define EPSILON (pixman_fixed_t) (2)

+

+#define IS_SAME(a, b) (within_epsilon (a, b, EPSILON))

+#define IS_ZERO(a)    (within_epsilon (a, 0, EPSILON))

+#define IS_ONE(a)     (within_epsilon (a, F (1), EPSILON))

+#define IS_UNIT(a)			    \

+    (within_epsilon (a, F (1), EPSILON) ||  \

+     within_epsilon (a, F (-1), EPSILON) || \

+     IS_ZERO (a))

+#define IS_INT(a)    (IS_ZERO (pixman_fixed_frac (a)))

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_identity (const struct pixman_transform *t)

+{

+    return (IS_SAME (t->matrix[0][0], t->matrix[1][1]) &&

+	    IS_SAME (t->matrix[0][0], t->matrix[2][2]) &&

+	    !IS_ZERO (t->matrix[0][0]) &&

+	    IS_ZERO (t->matrix[0][1]) &&

+	    IS_ZERO (t->matrix[0][2]) &&

+	    IS_ZERO (t->matrix[1][0]) &&

+	    IS_ZERO (t->matrix[1][2]) &&

+	    IS_ZERO (t->matrix[2][0]) &&

+	    IS_ZERO (t->matrix[2][1]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_scale (const struct pixman_transform *t)

+{

+    return (!IS_ZERO (t->matrix[0][0]) &&

+            IS_ZERO (t->matrix[0][1]) &&

+            IS_ZERO (t->matrix[0][2]) &&

+

+            IS_ZERO (t->matrix[1][0]) &&

+            !IS_ZERO (t->matrix[1][1]) &&

+            IS_ZERO (t->matrix[1][2]) &&

+

+            IS_ZERO (t->matrix[2][0]) &&

+            IS_ZERO (t->matrix[2][1]) &&

+            !IS_ZERO (t->matrix[2][2]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_int_translate (const struct pixman_transform *t)

+{

+    return (IS_ONE (t->matrix[0][0]) &&

+            IS_ZERO (t->matrix[0][1]) &&

+            IS_INT (t->matrix[0][2]) &&

+

+            IS_ZERO (t->matrix[1][0]) &&

+            IS_ONE (t->matrix[1][1]) &&

+            IS_INT (t->matrix[1][2]) &&

+

+            IS_ZERO (t->matrix[2][0]) &&

+            IS_ZERO (t->matrix[2][1]) &&

+            IS_ONE (t->matrix[2][2]));

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_is_inverse (const struct pixman_transform *a,

+                             const struct pixman_transform *b)

+{

+    struct pixman_transform t;

+

+    if (!pixman_transform_multiply (&t, a, b))

+	return FALSE;

+

+    return pixman_transform_is_identity (&t);

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_from_pixman_transform (struct pixman_f_transform *    ft,

+                                          const struct pixman_transform *t)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	for (i = 0; i < 3; i++)

+	    ft->m[j][i] = pixman_fixed_to_double (t->matrix[j][i]);

+    }

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_transform_from_pixman_f_transform (struct pixman_transform *        t,

+                                          const struct pixman_f_transform *ft)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	for (i = 0; i < 3; i++)

+	{

+	    double d = ft->m[j][i];

+	    if (d < -32767.0 || d > 32767.0)

+		return FALSE;

+	    d = d * 65536.0 + 0.5;

+	    t->matrix[j][i] = (pixman_fixed_t) floor (d);

+	}

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_invert (struct pixman_f_transform *      dst,

+                           const struct pixman_f_transform *src)

+{

+    double det;

+    int i, j;

+    static int a[3] = { 2, 2, 1 };

+    static int b[3] = { 1, 0, 0 };

+

+    det = 0;

+    for (i = 0; i < 3; i++)

+    {

+	double p;

+	int ai = a[i];

+	int bi = b[i];

+	p = src->m[i][0] * (src->m[ai][2] * src->m[bi][1] -

+	                    src->m[ai][1] * src->m[bi][2]);

+	if (i == 1)

+	    p = -p;

+	det += p;

+    }

+    

+    if (det == 0)

+	return FALSE;

+    

+    det = 1 / det;

+    for (j = 0; j < 3; j++)

+    {

+	for (i = 0; i < 3; i++)

+	{

+	    double p;

+	    int ai = a[i];

+	    int aj = a[j];

+	    int bi = b[i];

+	    int bj = b[j];

+

+	    p = (src->m[ai][aj] * src->m[bi][bj] -

+	         src->m[ai][bj] * src->m[bi][aj]);

+	    

+	    if (((i + j) & 1) != 0)

+		p = -p;

+	    

+	    dst->m[j][i] = det * p;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_point (const struct pixman_f_transform *t,

+                          struct pixman_f_vector *         v)

+{

+    struct pixman_f_vector result;

+    int i, j;

+    double a;

+

+    for (j = 0; j < 3; j++)

+    {

+	a = 0;

+	for (i = 0; i < 3; i++)

+	    a += t->m[j][i] * v->v[i];

+	result.v[j] = a;

+    }

+    

+    if (!result.v[2])

+	return FALSE;

+

+    for (j = 0; j < 2; j++)

+	v->v[j] = result.v[j] / result.v[2];

+

+    v->v[2] = 1;

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_point_3d (const struct pixman_f_transform *t,

+                             struct pixman_f_vector *         v)

+{

+    struct pixman_f_vector result;

+    int i, j;

+    double a;

+

+    for (j = 0; j < 3; j++)

+    {

+	a = 0;

+	for (i = 0; i < 3; i++)

+	    a += t->m[j][i] * v->v[i];

+	result.v[j] = a;

+    }

+    

+    *v = result;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_multiply (struct pixman_f_transform *      dst,

+                             const struct pixman_f_transform *l,

+                             const struct pixman_f_transform *r)

+{

+    struct pixman_f_transform d;

+    int dx, dy;

+    int o;

+

+    for (dy = 0; dy < 3; dy++)

+    {

+	for (dx = 0; dx < 3; dx++)

+	{

+	    double v = 0;

+	    for (o = 0; o < 3; o++)

+		v += l->m[dy][o] * r->m[o][dx];

+	    d.m[dy][dx] = v;

+	}

+    }

+    

+    *dst = d;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_scale (struct pixman_f_transform *t,

+                               double                     sx,

+                               double                     sy)

+{

+    t->m[0][0] = sx;

+    t->m[0][1] = 0;

+    t->m[0][2] = 0;

+    t->m[1][0] = 0;

+    t->m[1][1] = sy;

+    t->m[1][2] = 0;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_scale (struct pixman_f_transform *forward,

+                          struct pixman_f_transform *reverse,

+                          double                     sx,

+                          double                     sy)

+{

+    struct pixman_f_transform t;

+

+    if (sx == 0 || sy == 0)

+	return FALSE;

+

+    if (forward)

+    {

+	pixman_f_transform_init_scale (&t, sx, sy);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+    

+    if (reverse)

+    {

+	pixman_f_transform_init_scale (&t, 1 / sx, 1 / sy);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+    

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_rotate (struct pixman_f_transform *t,

+                                double                     c,

+                                double                     s)

+{

+    t->m[0][0] = c;

+    t->m[0][1] = -s;

+    t->m[0][2] = 0;

+    t->m[1][0] = s;

+    t->m[1][1] = c;

+    t->m[1][2] = 0;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_rotate (struct pixman_f_transform *forward,

+                           struct pixman_f_transform *reverse,

+                           double                     c,

+                           double                     s)

+{

+    struct pixman_f_transform t;

+

+    if (forward)

+    {

+	pixman_f_transform_init_rotate (&t, c, s);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+    

+    if (reverse)

+    {

+	pixman_f_transform_init_rotate (&t, c, -s);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_translate (struct pixman_f_transform *t,

+                                   double                     tx,

+                                   double                     ty)

+{

+    t->m[0][0] = 1;

+    t->m[0][1] = 0;

+    t->m[0][2] = tx;

+    t->m[1][0] = 0;

+    t->m[1][1] = 1;

+    t->m[1][2] = ty;

+    t->m[2][0] = 0;

+    t->m[2][1] = 0;

+    t->m[2][2] = 1;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_translate (struct pixman_f_transform *forward,

+                              struct pixman_f_transform *reverse,

+                              double                     tx,

+                              double                     ty)

+{

+    struct pixman_f_transform t;

+

+    if (forward)

+    {

+	pixman_f_transform_init_translate (&t, tx, ty);

+	pixman_f_transform_multiply (forward, &t, forward);

+    }

+

+    if (reverse)

+    {

+	pixman_f_transform_init_translate (&t, -tx, -ty);

+	pixman_f_transform_multiply (reverse, reverse, &t);

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT pixman_bool_t

+pixman_f_transform_bounds (const struct pixman_f_transform *t,

+                           struct pixman_box16 *            b)

+{

+    struct pixman_f_vector v[4];

+    int i;

+    int x1, y1, x2, y2;

+

+    v[0].v[0] = b->x1;

+    v[0].v[1] = b->y1;

+    v[0].v[2] = 1;

+    v[1].v[0] = b->x2;

+    v[1].v[1] = b->y1;

+    v[1].v[2] = 1;

+    v[2].v[0] = b->x2;

+    v[2].v[1] = b->y2;

+    v[2].v[2] = 1;

+    v[3].v[0] = b->x1;

+    v[3].v[1] = b->y2;

+    v[3].v[2] = 1;

+

+    for (i = 0; i < 4; i++)

+    {

+	if (!pixman_f_transform_point (t, &v[i]))

+	    return FALSE;

+

+	x1 = floor (v[i].v[0]);

+	y1 = floor (v[i].v[1]);

+	x2 = ceil (v[i].v[0]);

+	y2 = ceil (v[i].v[1]);

+

+	if (i == 0)

+	{

+	    b->x1 = x1;

+	    b->y1 = y1;

+	    b->x2 = x2;

+	    b->y2 = y2;

+	}

+	else

+	{

+	    if (x1 < b->x1) b->x1 = x1;

+	    if (y1 < b->y1) b->y1 = y1;

+	    if (x2 > b->x2) b->x2 = x2;

+	    if (y2 > b->y2) b->y2 = y2;

+	}

+    }

+

+    return TRUE;

+}

+

+PIXMAN_EXPORT void

+pixman_f_transform_init_identity (struct pixman_f_transform *t)

+{

+    int i, j;

+

+    for (j = 0; j < 3; j++)

+    {

+	for (i = 0; i < 3; i++)

+	    t->m[j][i] = i == j ? 1 : 0;

+    }

+}

diff --git a/pixman/pixman/pixman-trap.c b/pixman/pixman/pixman-trap.c
index 8353992c5..787093a85 100644
--- a/pixman/pixman/pixman-trap.c
+++ b/pixman/pixman/pixman-trap.c
@@ -1,392 +1,386 @@
-/*
- * Copyright © 2004 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdio.h>
-#include "pixman-private.h"
-
-/*
- * Compute the smallest value greater than or equal to y which is on a
- * grid row.
- */
-
-PIXMAN_EXPORT pixman_fixed_t
-pixman_sample_ceil_y (pixman_fixed_t y, int n)
-{
-    pixman_fixed_t f = pixman_fixed_frac (y);
-    pixman_fixed_t i = pixman_fixed_floor (y);
-
-    f = DIV (f - Y_FRAC_FIRST (n) + (STEP_Y_SMALL (n) - pixman_fixed_e), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +
-	Y_FRAC_FIRST (n);
-    
-    if (f > Y_FRAC_LAST (n))
-    {
-	if (pixman_fixed_to_int (i) == 0x7fff)
-	{
-	    f = 0xffff; /* saturate */
-	}
-	else
-	{
-	    f = Y_FRAC_FIRST (n);
-	    i += pixman_fixed_1;
-	}
-    }
-    return (i | f);
-}
-
-/*
- * Compute the largest value strictly less than y which is on a
- * grid row.
- */
-PIXMAN_EXPORT pixman_fixed_t
-pixman_sample_floor_y (pixman_fixed_t y,
-                       int            n)
-{
-    pixman_fixed_t f = pixman_fixed_frac (y);
-    pixman_fixed_t i = pixman_fixed_floor (y);
-
-    f = DIV (f - pixman_fixed_e - Y_FRAC_FIRST (n), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +
-	Y_FRAC_FIRST (n);
-
-    if (f < Y_FRAC_FIRST (n))
-    {
-	if (pixman_fixed_to_int (i) == 0x8000)
-	{
-	    f = 0; /* saturate */
-	}
-	else
-	{
-	    f = Y_FRAC_LAST (n);
-	    i -= pixman_fixed_1;
-	}
-    }
-    return (i | f);
-}
-
-/*
- * Step an edge by any amount (including negative values)
- */
-PIXMAN_EXPORT void
-pixman_edge_step (pixman_edge_t *e,
-                  int            n)
-{
-    pixman_fixed_48_16_t ne;
-
-    e->x += n * e->stepx;
-
-    ne = e->e + n * (pixman_fixed_48_16_t) e->dx;
-
-    if (n >= 0)
-    {
-	if (ne > 0)
-	{
-	    int nx = (ne + e->dy - 1) / e->dy;
-	    e->e = ne - nx * (pixman_fixed_48_16_t) e->dy;
-	    e->x += nx * e->signdx;
-	}
-    }
-    else
-    {
-	if (ne <= -e->dy)
-	{
-	    int nx = (-ne) / e->dy;
-	    e->e = ne + nx * (pixman_fixed_48_16_t) e->dy;
-	    e->x -= nx * e->signdx;
-	}
-    }
-}
-
-/*
- * A private routine to initialize the multi-step
- * elements of an edge structure
- */
-static void
-_pixman_edge_multi_init (pixman_edge_t * e,
-                         int             n,
-                         pixman_fixed_t *stepx_p,
-                         pixman_fixed_t *dx_p)
-{
-    pixman_fixed_t stepx;
-    pixman_fixed_48_16_t ne;
-
-    ne = n * (pixman_fixed_48_16_t) e->dx;
-    stepx = n * e->stepx;
-
-    if (ne > 0)
-    {
-	int nx = ne / e->dy;
-	ne -= nx * e->dy;
-	stepx += nx * e->signdx;
-    }
-
-    *dx_p = ne;
-    *stepx_p = stepx;
-}
-
-/*
- * Initialize one edge structure given the line endpoints and a
- * starting y value
- */
-PIXMAN_EXPORT void
-pixman_edge_init (pixman_edge_t *e,
-                  int            n,
-                  pixman_fixed_t y_start,
-                  pixman_fixed_t x_top,
-                  pixman_fixed_t y_top,
-                  pixman_fixed_t x_bot,
-                  pixman_fixed_t y_bot)
-{
-    pixman_fixed_t dx, dy;
-
-    e->x = x_top;
-    e->e = 0;
-    dx = x_bot - x_top;
-    dy = y_bot - y_top;
-    e->dy = dy;
-    e->dx = 0;
-
-    if (dy)
-    {
-	if (dx >= 0)
-	{
-	    e->signdx = 1;
-	    e->stepx = dx / dy;
-	    e->dx = dx % dy;
-	    e->e = -dy;
-	}
-	else
-	{
-	    e->signdx = -1;
-	    e->stepx = -(-dx / dy);
-	    e->dx = -dx % dy;
-	    e->e = 0;
-	}
-
-	_pixman_edge_multi_init (e, STEP_Y_SMALL (n),
-				 &e->stepx_small, &e->dx_small);
-
-	_pixman_edge_multi_init (e, STEP_Y_BIG (n),
-				 &e->stepx_big, &e->dx_big);
-    }
-    pixman_edge_step (e, y_start - y_top);
-}
-
-/*
- * Initialize one edge structure given a line, starting y value
- * and a pixel offset for the line
- */
-PIXMAN_EXPORT void
-pixman_line_fixed_edge_init (pixman_edge_t *            e,
-                             int                        n,
-                             pixman_fixed_t             y,
-                             const pixman_line_fixed_t *line,
-                             int                        x_off,
-                             int                        y_off)
-{
-    pixman_fixed_t x_off_fixed = pixman_int_to_fixed (x_off);
-    pixman_fixed_t y_off_fixed = pixman_int_to_fixed (y_off);
-    const pixman_point_fixed_t *top, *bot;
-
-    if (line->p1.y <= line->p2.y)
-    {
-	top = &line->p1;
-	bot = &line->p2;
-    }
-    else
-    {
-	top = &line->p2;
-	bot = &line->p1;
-    }
-    
-    pixman_edge_init (e, n, y,
-                      top->x + x_off_fixed,
-                      top->y + y_off_fixed,
-                      bot->x + x_off_fixed,
-                      bot->y + y_off_fixed);
-}
-
-PIXMAN_EXPORT void
-pixman_add_traps (pixman_image_t * image,
-                  int16_t          x_off,
-                  int16_t          y_off,
-                  int              ntrap,
-                  pixman_trap_t *  traps)
-{
-    int bpp;
-    int width;
-    int height;
-
-    pixman_fixed_t x_off_fixed;
-    pixman_fixed_t y_off_fixed;
-    pixman_edge_t l, r;
-    pixman_fixed_t t, b;
-
-    _pixman_image_validate (image);
-    
-    width = image->bits.width;
-    height = image->bits.height;
-    bpp = PIXMAN_FORMAT_BPP (image->bits.format);
-
-    x_off_fixed = pixman_int_to_fixed (x_off);
-    y_off_fixed = pixman_int_to_fixed (y_off);
-
-    while (ntrap--)
-    {
-	t = traps->top.y + y_off_fixed;
-	if (t < 0)
-	    t = 0;
-	t = pixman_sample_ceil_y (t, bpp);
-
-	b = traps->bot.y + y_off_fixed;
-	if (pixman_fixed_to_int (b) >= height)
-	    b = pixman_int_to_fixed (height) - 1;
-	b = pixman_sample_floor_y (b, bpp);
-
-	if (b >= t)
-	{
-	    /* initialize edge walkers */
-	    pixman_edge_init (&l, bpp, t,
-	                      traps->top.l + x_off_fixed,
-	                      traps->top.y + y_off_fixed,
-	                      traps->bot.l + x_off_fixed,
-	                      traps->bot.y + y_off_fixed);
-
-	    pixman_edge_init (&r, bpp, t,
-	                      traps->top.r + x_off_fixed,
-	                      traps->top.y + y_off_fixed,
-	                      traps->bot.r + x_off_fixed,
-	                      traps->bot.y + y_off_fixed);
-
-	    pixman_rasterize_edges (image, &l, &r, t, b);
-	}
-
-	traps++;
-    }
-}
-
-#if 0
-static void
-dump_image (pixman_image_t *image,
-            const char *    title)
-{
-    int i, j;
-
-    if (!image->type == BITS)
-	printf ("%s is not a regular image\n", title);
-
-    if (!image->bits.format == PIXMAN_a8)
-	printf ("%s is not an alpha mask\n", title);
-
-    printf ("\n\n\n%s: \n", title);
-
-    for (i = 0; i < image->bits.height; ++i)
-    {
-	uint8_t *line =
-	    (uint8_t *)&(image->bits.bits[i * image->bits.rowstride]);
-
-	for (j = 0; j < image->bits.width; ++j)
-	    printf ("%c", line[j] ? '#' : ' ');
-
-	printf ("\n");
-    }
-}
-#endif
-
-PIXMAN_EXPORT void
-pixman_add_trapezoids (pixman_image_t *          image,
-                       int16_t                   x_off,
-                       int                       y_off,
-                       int                       ntraps,
-                       const pixman_trapezoid_t *traps)
-{
-    int i;
-
-#if 0
-    dump_image (image, "before");
-#endif
-
-    for (i = 0; i < ntraps; ++i)
-    {
-	const pixman_trapezoid_t *trap = &(traps[i]);
-
-	if (!pixman_trapezoid_valid (trap))
-	    continue;
-
-	pixman_rasterize_trapezoid (image, trap, x_off, y_off);
-    }
-
-#if 0
-    dump_image (image, "after");
-#endif
-}
-
-PIXMAN_EXPORT void
-pixman_rasterize_trapezoid (pixman_image_t *          image,
-                            const pixman_trapezoid_t *trap,
-                            int                       x_off,
-                            int                       y_off)
-{
-    int bpp;
-    int width;
-    int height;
-
-    pixman_fixed_t x_off_fixed;
-    pixman_fixed_t y_off_fixed;
-    pixman_edge_t l, r;
-    pixman_fixed_t t, b;
-
-    return_if_fail (image->type == BITS);
-
-    _pixman_image_validate (image);
-    
-    if (!pixman_trapezoid_valid (trap))
-	return;
-
-    width = image->bits.width;
-    height = image->bits.height;
-    bpp = PIXMAN_FORMAT_BPP (image->bits.format);
-
-    x_off_fixed = pixman_int_to_fixed (x_off);
-    y_off_fixed = pixman_int_to_fixed (y_off);
-
-    t = trap->top + y_off_fixed;
-    if (t < 0)
-	t = 0;
-    t = pixman_sample_ceil_y (t, bpp);
-
-    b = trap->bottom + y_off_fixed;
-    if (pixman_fixed_to_int (b) >= height)
-	b = pixman_int_to_fixed (height) - 1;
-    b = pixman_sample_floor_y (b, bpp);
-    
-    if (b >= t)
-    {
-	/* initialize edge walkers */
-	pixman_line_fixed_edge_init (&l, bpp, t, &trap->left, x_off, y_off);
-	pixman_line_fixed_edge_init (&r, bpp, t, &trap->right, x_off, y_off);
-
-	pixman_rasterize_edges (image, &l, &r, t, b);
-    }
-}
+/*

+ * Copyright © 2004 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <stdio.h>

+#include "pixman-private.h"

+

+/*

+ * Compute the smallest value greater than or equal to y which is on a

+ * grid row.

+ */

+

+PIXMAN_EXPORT pixman_fixed_t

+pixman_sample_ceil_y (pixman_fixed_t y, int n)

+{

+    pixman_fixed_t f = pixman_fixed_frac (y);

+    pixman_fixed_t i = pixman_fixed_floor (y);

+

+    f = DIV (f - Y_FRAC_FIRST (n) + (STEP_Y_SMALL (n) - pixman_fixed_e), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +

+	Y_FRAC_FIRST (n);

+    

+    if (f > Y_FRAC_LAST (n))

+    {

+	if (pixman_fixed_to_int (i) == 0x7fff)

+	{

+	    f = 0xffff; /* saturate */

+	}

+	else

+	{

+	    f = Y_FRAC_FIRST (n);

+	    i += pixman_fixed_1;

+	}

+    }

+    return (i | f);

+}

+

+/*

+ * Compute the largest value strictly less than y which is on a

+ * grid row.

+ */

+PIXMAN_EXPORT pixman_fixed_t

+pixman_sample_floor_y (pixman_fixed_t y,

+                       int            n)

+{

+    pixman_fixed_t f = pixman_fixed_frac (y);

+    pixman_fixed_t i = pixman_fixed_floor (y);

+

+    f = DIV (f - pixman_fixed_e - Y_FRAC_FIRST (n), STEP_Y_SMALL (n)) * STEP_Y_SMALL (n) +

+	Y_FRAC_FIRST (n);

+

+    if (f < Y_FRAC_FIRST (n))

+    {

+	if (pixman_fixed_to_int (i) == 0x8000)

+	{

+	    f = 0; /* saturate */

+	}

+	else

+	{

+	    f = Y_FRAC_LAST (n);

+	    i -= pixman_fixed_1;

+	}

+    }

+    return (i | f);

+}

+

+/*

+ * Step an edge by any amount (including negative values)

+ */

+PIXMAN_EXPORT void

+pixman_edge_step (pixman_edge_t *e,

+                  int            n)

+{

+    pixman_fixed_48_16_t ne;

+

+    e->x += n * e->stepx;

+

+    ne = e->e + n * (pixman_fixed_48_16_t) e->dx;

+

+    if (n >= 0)

+    {

+	if (ne > 0)

+	{

+	    int nx = (ne + e->dy - 1) / e->dy;

+	    e->e = ne - nx * (pixman_fixed_48_16_t) e->dy;

+	    e->x += nx * e->signdx;

+	}

+    }

+    else

+    {

+	if (ne <= -e->dy)

+	{

+	    int nx = (-ne) / e->dy;

+	    e->e = ne + nx * (pixman_fixed_48_16_t) e->dy;

+	    e->x -= nx * e->signdx;

+	}

+    }

+}

+

+/*

+ * A private routine to initialize the multi-step

+ * elements of an edge structure

+ */

+static void

+_pixman_edge_multi_init (pixman_edge_t * e,

+                         int             n,

+                         pixman_fixed_t *stepx_p,

+                         pixman_fixed_t *dx_p)

+{

+    pixman_fixed_t stepx;

+    pixman_fixed_48_16_t ne;

+

+    ne = n * (pixman_fixed_48_16_t) e->dx;

+    stepx = n * e->stepx;

+

+    if (ne > 0)

+    {

+	int nx = ne / e->dy;

+	ne -= nx * e->dy;

+	stepx += nx * e->signdx;

+    }

+

+    *dx_p = ne;

+    *stepx_p = stepx;

+}

+

+/*

+ * Initialize one edge structure given the line endpoints and a

+ * starting y value

+ */

+PIXMAN_EXPORT void

+pixman_edge_init (pixman_edge_t *e,

+                  int            n,

+                  pixman_fixed_t y_start,

+                  pixman_fixed_t x_top,

+                  pixman_fixed_t y_top,

+                  pixman_fixed_t x_bot,

+                  pixman_fixed_t y_bot)

+{

+    pixman_fixed_t dx, dy;

+

+    e->x = x_top;

+    e->e = 0;

+    dx = x_bot - x_top;

+    dy = y_bot - y_top;

+    e->dy = dy;

+    e->dx = 0;

+

+    if (dy)

+    {

+	if (dx >= 0)

+	{

+	    e->signdx = 1;

+	    e->stepx = dx / dy;

+	    e->dx = dx % dy;

+	    e->e = -dy;

+	}

+	else

+	{

+	    e->signdx = -1;

+	    e->stepx = -(-dx / dy);

+	    e->dx = -dx % dy;

+	    e->e = 0;

+	}

+

+	_pixman_edge_multi_init (e, STEP_Y_SMALL (n),

+				 &e->stepx_small, &e->dx_small);

+

+	_pixman_edge_multi_init (e, STEP_Y_BIG (n),

+				 &e->stepx_big, &e->dx_big);

+    }

+    pixman_edge_step (e, y_start - y_top);

+}

+

+/*

+ * Initialize one edge structure given a line, starting y value

+ * and a pixel offset for the line

+ */

+PIXMAN_EXPORT void

+pixman_line_fixed_edge_init (pixman_edge_t *            e,

+                             int                        n,

+                             pixman_fixed_t             y,

+                             const pixman_line_fixed_t *line,

+                             int                        x_off,

+                             int                        y_off)

+{

+    pixman_fixed_t x_off_fixed = pixman_int_to_fixed (x_off);

+    pixman_fixed_t y_off_fixed = pixman_int_to_fixed (y_off);

+    const pixman_point_fixed_t *top, *bot;

+

+    if (line->p1.y <= line->p2.y)

+    {

+	top = &line->p1;

+	bot = &line->p2;

+    }

+    else

+    {

+	top = &line->p2;

+	bot = &line->p1;

+    }

+    

+    pixman_edge_init (e, n, y,

+                      top->x + x_off_fixed,

+                      top->y + y_off_fixed,

+                      bot->x + x_off_fixed,

+                      bot->y + y_off_fixed);

+}

+

+PIXMAN_EXPORT void

+pixman_add_traps (pixman_image_t * image,

+                  int16_t          x_off,

+                  int16_t          y_off,

+                  int              ntrap,

+                  pixman_trap_t *  traps)

+{

+    int bpp;

+    int height;

+

+    pixman_fixed_t x_off_fixed;

+    pixman_fixed_t y_off_fixed;

+    pixman_edge_t l, r;

+    pixman_fixed_t t, b;

+

+    _pixman_image_validate (image);

+    

+    height = image->bits.height;

+    bpp = PIXMAN_FORMAT_BPP (image->bits.format);

+

+    x_off_fixed = pixman_int_to_fixed (x_off);

+    y_off_fixed = pixman_int_to_fixed (y_off);

+

+    while (ntrap--)

+    {

+	t = traps->top.y + y_off_fixed;

+	if (t < 0)

+	    t = 0;

+	t = pixman_sample_ceil_y (t, bpp);

+

+	b = traps->bot.y + y_off_fixed;

+	if (pixman_fixed_to_int (b) >= height)

+	    b = pixman_int_to_fixed (height) - 1;

+	b = pixman_sample_floor_y (b, bpp);

+

+	if (b >= t)

+	{

+	    /* initialize edge walkers */

+	    pixman_edge_init (&l, bpp, t,

+	                      traps->top.l + x_off_fixed,

+	                      traps->top.y + y_off_fixed,

+	                      traps->bot.l + x_off_fixed,

+	                      traps->bot.y + y_off_fixed);

+

+	    pixman_edge_init (&r, bpp, t,

+	                      traps->top.r + x_off_fixed,

+	                      traps->top.y + y_off_fixed,

+	                      traps->bot.r + x_off_fixed,

+	                      traps->bot.y + y_off_fixed);

+

+	    pixman_rasterize_edges (image, &l, &r, t, b);

+	}

+

+	traps++;

+    }

+}

+

+#if 0

+static void

+dump_image (pixman_image_t *image,

+            const char *    title)

+{

+    int i, j;

+

+    if (!image->type == BITS)

+	printf ("%s is not a regular image\n", title);

+

+    if (!image->bits.format == PIXMAN_a8)

+	printf ("%s is not an alpha mask\n", title);

+

+    printf ("\n\n\n%s: \n", title);

+

+    for (i = 0; i < image->bits.height; ++i)

+    {

+	uint8_t *line =

+	    (uint8_t *)&(image->bits.bits[i * image->bits.rowstride]);

+

+	for (j = 0; j < image->bits.width; ++j)

+	    printf ("%c", line[j] ? '#' : ' ');

+

+	printf ("\n");

+    }

+}

+#endif

+

+PIXMAN_EXPORT void

+pixman_add_trapezoids (pixman_image_t *          image,

+                       int16_t                   x_off,

+                       int                       y_off,

+                       int                       ntraps,

+                       const pixman_trapezoid_t *traps)

+{

+    int i;

+

+#if 0

+    dump_image (image, "before");

+#endif

+

+    for (i = 0; i < ntraps; ++i)

+    {

+	const pixman_trapezoid_t *trap = &(traps[i]);

+

+	if (!pixman_trapezoid_valid (trap))

+	    continue;

+

+	pixman_rasterize_trapezoid (image, trap, x_off, y_off);

+    }

+

+#if 0

+    dump_image (image, "after");

+#endif

+}

+

+PIXMAN_EXPORT void

+pixman_rasterize_trapezoid (pixman_image_t *          image,

+                            const pixman_trapezoid_t *trap,

+                            int                       x_off,

+                            int                       y_off)

+{

+    int bpp;

+    int height;

+

+    pixman_fixed_t y_off_fixed;

+    pixman_edge_t l, r;

+    pixman_fixed_t t, b;

+

+    return_if_fail (image->type == BITS);

+

+    _pixman_image_validate (image);

+    

+    if (!pixman_trapezoid_valid (trap))

+	return;

+

+    height = image->bits.height;

+    bpp = PIXMAN_FORMAT_BPP (image->bits.format);

+

+    y_off_fixed = pixman_int_to_fixed (y_off);

+

+    t = trap->top + y_off_fixed;

+    if (t < 0)

+	t = 0;

+    t = pixman_sample_ceil_y (t, bpp);

+

+    b = trap->bottom + y_off_fixed;

+    if (pixman_fixed_to_int (b) >= height)

+	b = pixman_int_to_fixed (height) - 1;

+    b = pixman_sample_floor_y (b, bpp);

+    

+    if (b >= t)

+    {

+	/* initialize edge walkers */

+	pixman_line_fixed_edge_init (&l, bpp, t, &trap->left, x_off, y_off);

+	pixman_line_fixed_edge_init (&r, bpp, t, &trap->right, x_off, y_off);

+

+	pixman_rasterize_edges (image, &l, &r, t, b);

+    }

+}

diff --git a/pixman/test/affine-test.c b/pixman/test/affine-test.c
index 3e32b5a23..fbb35caa9 100644
--- a/pixman/test/affine-test.c
+++ b/pixman/test/affine-test.c
@@ -40,9 +40,9 @@ test_composite (int      testnum,
     int                w, h;

     pixman_fixed_t     scale_x = 65536, scale_y = 65536;

     pixman_fixed_t     translate_x = 0, translate_y = 0;

-    int                op;

-    int                repeat = 0;

-    int                src_fmt, dst_fmt;

+    pixman_op_t        op;

+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_format_code_t src_fmt, dst_fmt;

     uint32_t *         srcbuf;

     uint32_t *         dstbuf;

     uint32_t           crc32;

diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 0ff9a1d48..3b27cd8c1 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -27,7 +27,7 @@ create_random_image (pixman_format_code_t *allowed_formats,
     uint32_t *buf;

     pixman_image_t *img;

 

-    while (allowed_formats[n] != -1)

+    while (allowed_formats[n] != PIXMAN_null)

 	n++;

     fmt = allowed_formats[lcg_rand_n (n)];

 

@@ -78,7 +78,7 @@ free_random_image (uint32_t initcrc,
     uint32_t *data = pixman_image_get_data (img);

     int height = pixman_image_get_height (img);

 

-    if (fmt != -1)

+    if (fmt != PIXMAN_null)

     {

 	/* mask unused 'x' part */

 	if (PIXMAN_FORMAT_BPP (fmt) - PIXMAN_FORMAT_DEPTH (fmt) &&

@@ -218,7 +218,7 @@ static pixman_format_code_t img_fmt_list[] = {
     PIXMAN_a1r1g1b1,

     PIXMAN_a1b1g1r1,

     PIXMAN_a1,

-    -1

+    PIXMAN_null

 };

 

 static pixman_format_code_t mask_fmt_list[] = {

@@ -226,7 +226,7 @@ static pixman_format_code_t mask_fmt_list[] = {
     PIXMAN_a8,

     PIXMAN_a4,

     PIXMAN_a1,

-    -1

+    PIXMAN_null

 };

 

 

@@ -247,7 +247,7 @@ test_composite (int testnum, int verbose)
     int dst_x, dst_y;

     int mask_x, mask_y;

     int w, h;

-    int op;

+    pixman_op_t op;

     pixman_format_code_t src_fmt, dst_fmt, mask_fmt;

     uint32_t *dstbuf, *srcbuf, *maskbuf;

     uint32_t crc32;

@@ -305,7 +305,7 @@ test_composite (int testnum, int verbose)
     dst_y = lcg_rand_n (dst_height);

 

     mask_img = NULL;

-    mask_fmt = -1;

+    mask_fmt = PIXMAN_null;

     mask_x = 0;

     mask_y = 0;

     maskbuf = NULL;

@@ -385,7 +385,7 @@ test_composite (int testnum, int verbose)
 	printf ("---\n");

     }

 

-    free_random_image (0, src_img, -1);

+    free_random_image (0, src_img, PIXMAN_null);

     crc32 = free_random_image (0, dst_img, dst_fmt);

 

     if (mask_img)

@@ -393,7 +393,7 @@ test_composite (int testnum, int verbose)
 	if (srcbuf == maskbuf)

 	    pixman_image_unref(mask_img);

 	else

-	    free_random_image (0, mask_img, -1);

+	    free_random_image (0, mask_img, PIXMAN_null);

     }

 

     FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();

diff --git a/pixman/test/scaling-crash-test.c b/pixman/test/scaling-crash-test.c
index 0ce1fece9..23ee8c6be 100644
--- a/pixman/test/scaling-crash-test.c
+++ b/pixman/test/scaling-crash-test.c
@@ -95,21 +95,29 @@ run_test (int32_t		dst_width,
     return result;

 }

 

-typedef struct info_t info_t;

-struct info_t

+typedef struct filter_info_t filter_info_t;

+struct filter_info_t

 {

-    int value;

+    pixman_filter_t value;

     char name[28];

 };

 

-static const info_t filters[] =

+static const filter_info_t filters[] =

 {

     { PIXMAN_FILTER_NEAREST, "NEAREST" },

     { PIXMAN_FILTER_BILINEAR, "BILINEAR" },

     { PIXMAN_FILTER_CONVOLUTION, "CONVOLUTION" },

 };

 

-static const info_t repeats[] =

+typedef struct repeat_info_t repeat_info_t;

+struct repeat_info_t

+{

+    pixman_repeat_t value;

+    char name[28];

+};

+

+

+static const repeat_info_t repeats[] =

 {

     { PIXMAN_REPEAT_PAD, "PAD" },

     { PIXMAN_REPEAT_REFLECT, "REFLECT" },

diff --git a/pixman/test/scaling-test.c b/pixman/test/scaling-test.c
index 872805338..7b78017a3 100644
--- a/pixman/test/scaling-test.c
+++ b/pixman/test/scaling-test.c
@@ -40,9 +40,9 @@ test_composite (int      testnum,
     int                w, h;

     pixman_fixed_t     scale_x = 65536, scale_y = 65536;

     pixman_fixed_t     translate_x = 0, translate_y = 0;

-    int                op;

-    int                repeat = 0;

-    int                src_fmt, dst_fmt;

+    pixman_op_t        op;

+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_format_code_t src_fmt, dst_fmt;

     uint32_t *         srcbuf;

     uint32_t *         dstbuf;

     uint32_t           crc32;