Merge remote-tracking branch 'origin/released'

* origin/released:
  mesa pixman xserver git update 13 Feb 2013

5 files changed, 346 insertions, 637 deletions

diff --git a/mesalib/src/mesa/main/formats.c b/mesalib/src/mesa/main/formats.c
index 176067d53..68ce98430 100644
--- a/mesalib/src/mesa/main/formats.c
+++ b/mesalib/src/mesa/main/formats.c
@@ -2870,6 +2870,7 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_RGBA8888:
+   case MESA_FORMAT_SRGBA8:
       if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
          return GL_TRUE;
 
@@ -2917,6 +2918,7 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_ARGB8888:
+   case MESA_FORMAT_SARGB8:
       if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
           !swapBytes)
          return GL_TRUE;
@@ -2951,6 +2953,7 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_RGB888:
+   case MESA_FORMAT_SRGB8:
       return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian;
 
    case MESA_FORMAT_BGR888:
@@ -2987,6 +2990,7 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
    case MESA_FORMAT_AL44:
       return GL_FALSE;
    case MESA_FORMAT_AL88:
+   case MESA_FORMAT_SLA8:
       return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian;
    case MESA_FORMAT_AL88_REV:
       return GL_FALSE;
@@ -3002,22 +3006,25 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
    case MESA_FORMAT_A8:
       return format == GL_ALPHA && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_A16:
-      return format == GL_ALPHA && type == GL_UNSIGNED_SHORT &&
-         littleEndian && !swapBytes;
+      return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes;
    case MESA_FORMAT_L8:
+   case MESA_FORMAT_SL8:
       return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_L16:
-      return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT &&
-         littleEndian && !swapBytes;
+      return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes;
    case MESA_FORMAT_I8:
       return format == GL_INTENSITY && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_I16:
-      return format == GL_INTENSITY && type == GL_UNSIGNED_SHORT &&
-         littleEndian && !swapBytes;
+      return format == GL_INTENSITY && type == GL_UNSIGNED_SHORT && !swapBytes;
 
    case MESA_FORMAT_YCBCR:
+      return format == GL_YCBCR_MESA &&
+             ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian != swapBytes) ||
+              (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian == swapBytes));
    case MESA_FORMAT_YCBCR_REV:
-      return GL_FALSE;
+      return format == GL_YCBCR_MESA &&
+             ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) ||
+              (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes));
 
    case MESA_FORMAT_R8:
       return format == GL_RED && type == GL_UNSIGNED_BYTE;
@@ -3027,7 +3034,7 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_R16:
-      return format == GL_RED && type == GL_UNSIGNED_SHORT && littleEndian &&
+      return format == GL_RED && type == GL_UNSIGNED_SHORT &&
          !swapBytes;
    case MESA_FORMAT_GR1616:
       return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian &&
@@ -3060,11 +3067,6 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
    case MESA_FORMAT_S8:
       return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE;
 
-   case MESA_FORMAT_SRGB8:
-   case MESA_FORMAT_SRGBA8:
-   case MESA_FORMAT_SARGB8:
-   case MESA_FORMAT_SL8:
-   case MESA_FORMAT_SLA8:
    case MESA_FORMAT_SRGB_DXT1:
    case MESA_FORMAT_SRGBA_DXT1:
    case MESA_FORMAT_SRGBA_DXT3:
@@ -3119,14 +3121,20 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
    case MESA_FORMAT_RG_FLOAT16:
       return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes;
 
-      /* FINISHME: What do we want to do for GL_EXT_texture_integer? */
    case MESA_FORMAT_ALPHA_UINT8:
+      return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_ALPHA_UINT16:
+      return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_ALPHA_UINT32:
+      return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT &&
+             !swapBytes;
    case MESA_FORMAT_ALPHA_INT8:
+      return format == GL_ALPHA_INTEGER && type == GL_BYTE;
    case MESA_FORMAT_ALPHA_INT16:
+      return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_ALPHA_INT32:
-      return GL_FALSE;
+      return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes;
 
    case MESA_FORMAT_INTENSITY_UINT8:
    case MESA_FORMAT_INTENSITY_UINT16:
@@ -3134,55 +3142,107 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
    case MESA_FORMAT_INTENSITY_INT8:
    case MESA_FORMAT_INTENSITY_INT16:
    case MESA_FORMAT_INTENSITY_INT32:
+      /* GL_INTENSITY_INTEGER_EXT doesn't exist. */
       return GL_FALSE;
 
    case MESA_FORMAT_LUMINANCE_UINT8:
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_LUMINANCE_UINT16:
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_LUMINANCE_UINT32:
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT &&
+             !swapBytes;
    case MESA_FORMAT_LUMINANCE_INT8:
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE;
    case MESA_FORMAT_LUMINANCE_INT16:
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_LUMINANCE_INT32:
-      return GL_FALSE;
+      return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes;
 
    case MESA_FORMAT_LUMINANCE_ALPHA_UINT8:
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
+             type == GL_UNSIGNED_BYTE && !swapBytes;
    case MESA_FORMAT_LUMINANCE_ALPHA_UINT16:
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
+             type == GL_UNSIGNED_SHORT && !swapBytes;
    case MESA_FORMAT_LUMINANCE_ALPHA_UINT32:
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
+             type == GL_UNSIGNED_INT && !swapBytes;
    case MESA_FORMAT_LUMINANCE_ALPHA_INT8:
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE &&
+             !swapBytes;
    case MESA_FORMAT_LUMINANCE_ALPHA_INT16:
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_LUMINANCE_ALPHA_INT32:
-      return GL_FALSE;
+      return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT &&
+             !swapBytes;
 
    case MESA_FORMAT_R_INT8:
+      return format == GL_RED_INTEGER && type == GL_BYTE;
    case MESA_FORMAT_RG_INT8:
+      return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes;
    case MESA_FORMAT_RGB_INT8:
+      return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes;
    case MESA_FORMAT_RGBA_INT8:
+      return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes;
    case MESA_FORMAT_R_INT16:
+      return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_RG_INT16:
+      return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_RGB_INT16:
+      return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_RGBA_INT16:
+      return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_R_INT32:
+      return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
    case MESA_FORMAT_RG_INT32:
+      return format == GL_RG_INTEGER && type == GL_INT && !swapBytes;
    case MESA_FORMAT_RGB_INT32:
+      return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes;
    case MESA_FORMAT_RGBA_INT32:
-      return GL_FALSE;
+      return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes;
 
    case MESA_FORMAT_R_UINT8:
+      return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
    case MESA_FORMAT_RG_UINT8:
+      return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
    case MESA_FORMAT_RGB_UINT8:
+      return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
    case MESA_FORMAT_RGBA_UINT8:
+      return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE &&
+             !swapBytes;
    case MESA_FORMAT_R_UINT16:
+      return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_RG_UINT16:
+      return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
    case MESA_FORMAT_RGB_UINT16:
+      return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_RGBA_UINT16:
+      return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_R_UINT32:
+      return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
    case MESA_FORMAT_RG_UINT32:
+      return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
    case MESA_FORMAT_RGB_UINT32:
+      return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
    case MESA_FORMAT_RGBA_UINT32:
-      return GL_FALSE;
+      return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
 
    case MESA_FORMAT_DUDV8:
+      return (format == GL_DU8DV8_ATI || format == GL_DUDV_ATI) &&
+             type == GL_BYTE && littleEndian && !swapBytes;
+
    case MESA_FORMAT_SIGNED_R8:
+      return format == GL_RED && type == GL_BYTE;
    case MESA_FORMAT_SIGNED_RG88_REV:
+      return format == GL_RG && type == GL_BYTE && littleEndian &&
+             !swapBytes;
    case MESA_FORMAT_SIGNED_RGBX8888:
       return GL_FALSE;
 
@@ -3205,12 +3265,17 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_SIGNED_R16:
+      return format == GL_RED && type == GL_SHORT &&
+             !swapBytes;
    case MESA_FORMAT_SIGNED_GR1616:
+      return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes;
    case MESA_FORMAT_SIGNED_RGB_16:
+      return format == GL_RGB && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_SIGNED_RGBA_16:
+      return format == GL_RGBA && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_RGBA_16:
-      /* FINISHME: SNORM */
-      return GL_FALSE;
+      return format == GL_RGBA && type == GL_UNSIGNED_SHORT &&
+             !swapBytes;
 
    case MESA_FORMAT_RED_RGTC1:
    case MESA_FORMAT_SIGNED_RED_RGTC1:
@@ -3238,15 +3303,24 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return GL_FALSE;
 
    case MESA_FORMAT_SIGNED_A8:
+      return format == GL_ALPHA && type == GL_BYTE;
    case MESA_FORMAT_SIGNED_L8:
+      return format == GL_LUMINANCE && type == GL_BYTE;
    case MESA_FORMAT_SIGNED_AL88:
+      return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
+             littleEndian && !swapBytes;
    case MESA_FORMAT_SIGNED_I8:
+      return format == GL_INTENSITY && type == GL_BYTE;
    case MESA_FORMAT_SIGNED_A16:
+      return format == GL_ALPHA && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_SIGNED_L16:
+      return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes;
    case MESA_FORMAT_SIGNED_AL1616:
+      return format == GL_LUMINANCE_ALPHA && type == GL_SHORT &&
+             littleEndian && !swapBytes;
    case MESA_FORMAT_SIGNED_I16:
-      /* FINISHME: SNORM */
-      return GL_FALSE;
+      return format == GL_INTENSITY && type == GL_SHORT && littleEndian &&
+             !swapBytes;
 
    case MESA_FORMAT_ARGB2101010_UINT:
       return (format == GL_BGRA_INTEGER_EXT &&
@@ -3270,7 +3344,8 @@ _mesa_format_matches_format_and_type(gl_format gl_format,
       return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes;
 
    case MESA_FORMAT_Z32_FLOAT_X24S8:
-      return GL_FALSE;
+      return format == GL_DEPTH_STENCIL &&
+             type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes;
 
    case MESA_FORMAT_XRGB4444_UNORM:
    case MESA_FORMAT_XRGB1555_UNORM:
diff --git a/mesalib/src/mesa/main/pack.c b/mesalib/src/mesa/main/pack.c
index e00ae63fc..d976e5aae 100644
--- a/mesalib/src/mesa/main/pack.c
+++ b/mesalib/src/mesa/main/pack.c
@@ -6027,6 +6027,20 @@ _mesa_rebase_rgba_float(GLuint n, GLfloat rgba[][4], GLenum baseFormat)
          rgba[i][ACOMP] = 1.0F;
       }
       break;
+   case GL_RG:
+      for (i = 0; i < n; i++) {
+         rgba[i][BCOMP] = 0.0F;
+         rgba[i][ACOMP] = 1.0F;
+      }
+      break;
+   case GL_RED:
+      for (i = 0; i < n; i++) {
+         rgba[i][GCOMP] = 0.0F;
+         rgba[i][BCOMP] = 0.0F;
+         rgba[i][ACOMP] = 1.0F;
+      }
+      break;
+
    default:
       /* no-op */
       ;
@@ -6070,6 +6084,18 @@ _mesa_rebase_rgba_uint(GLuint n, GLuint rgba[][4], GLenum baseFormat)
          rgba[i][ACOMP] = 1;
       }
       break;
+   case GL_RG:
+      for (i = 0; i < n; i++) {
+         rgba[i][BCOMP] = 0;
+         rgba[i][ACOMP] = 1;
+      }
+      break;
+   case GL_RED:
+      for (i = 0; i < n; i++) {
+         rgba[i][GCOMP] = 0;
+         rgba[i][BCOMP] = 0;
+         rgba[i][ACOMP] = 1;
+      }
    default:
       /* no-op */
       ;
diff --git a/mesalib/src/mesa/main/texgetimage.c b/mesalib/src/mesa/main/texgetimage.c
index 3a550d941..7299a4b23 100644
--- a/mesalib/src/mesa/main/texgetimage.c
+++ b/mesalib/src/mesa/main/texgetimage.c
@@ -311,6 +311,41 @@ get_tex_rgba_compressed(struct gl_context *ctx, GLuint dimensions,
 
 
 /**
+ * Return a base GL format given the user-requested format
+ * for glGetTexImage().
+ */
+static GLenum
+_mesa_base_pack_format(GLenum format)
+{
+   switch (format) {
+   case GL_ABGR_EXT:
+   case GL_BGRA:
+   case GL_BGRA_INTEGER:
+   case GL_RGBA_INTEGER:
+      return GL_RGBA;
+   case GL_BGR:
+   case GL_BGR_INTEGER:
+   case GL_RGB_INTEGER:
+      return GL_RGB;
+   case GL_RED_INTEGER:
+      return GL_RED;
+   case GL_GREEN_INTEGER:
+      return GL_GREEN;
+   case GL_BLUE_INTEGER:
+      return GL_BLUE;
+   case GL_ALPHA_INTEGER:
+      return GL_ALPHA;
+   case GL_LUMINANCE_INTEGER_EXT:
+      return GL_LUMINANCE;
+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+      return GL_LUMINANCE_ALPHA;
+   default:
+      return format;
+   }
+}
+
+
+/**
  * Get an uncompressed color texture image.
  */
 static void
@@ -323,7 +358,7 @@ get_tex_rgba_uncompressed(struct gl_context *ctx, GLuint dimensions,
    const gl_format texFormat =
       _mesa_get_srgb_format_linear(texImage->TexFormat);
    const GLuint width = texImage->Width;
-   const GLenum destBaseFormat = _mesa_base_tex_format(ctx, format);
+   GLenum destBaseFormat = _mesa_base_pack_format(format);
    GLenum rebaseFormat = GL_NONE;
    GLuint height = texImage->Height;
    GLuint depth = texImage->Depth;
@@ -332,6 +367,7 @@ get_tex_rgba_uncompressed(struct gl_context *ctx, GLuint dimensions,
    GLuint (*rgba_uint)[4];
    GLboolean tex_is_integer = _mesa_is_format_integer_color(texImage->TexFormat);
    GLboolean tex_is_uint = _mesa_is_format_unsigned(texImage->TexFormat);
+   GLenum texBaseFormat = _mesa_get_format_base_format(texImage->TexFormat);
 
    /* Allocate buffer for one row of texels */
    rgba = malloc(4 * width * sizeof(GLfloat));
@@ -368,6 +404,50 @@ get_tex_rgba_uncompressed(struct gl_context *ctx, GLuint dimensions,
        */
       rebaseFormat = GL_LUMINANCE_ALPHA; /* this covers GL_LUMINANCE too */
    }
+   else if (texImage->_BaseFormat != texBaseFormat) {
+      /* The internal format and the real format differ, so we can't rely
+       * on the unpack functions setting the correct constant values.
+       * (e.g. reading back GL_RGB8 which is actually RGBA won't set alpha=1)
+       */
+      switch (texImage->_BaseFormat) {
+      case GL_RED:
+         if ((texBaseFormat == GL_RGBA ||
+              texBaseFormat == GL_RGB ||
+              texBaseFormat == GL_RG) &&
+             (destBaseFormat == GL_RGBA ||
+              destBaseFormat == GL_RGB ||
+              destBaseFormat == GL_RG ||
+              destBaseFormat == GL_GREEN)) {
+            rebaseFormat = texImage->_BaseFormat;
+            break;
+         }
+         /* fall through */
+      case GL_RG:
+         if ((texBaseFormat == GL_RGBA ||
+              texBaseFormat == GL_RGB) &&
+             (destBaseFormat == GL_RGBA ||
+              destBaseFormat == GL_RGB ||
+              destBaseFormat == GL_BLUE)) {
+            rebaseFormat = texImage->_BaseFormat;
+            break;
+         }
+         /* fall through */
+      case GL_RGB:
+         if (texBaseFormat == GL_RGBA &&
+             (destBaseFormat == GL_RGBA ||
+              destBaseFormat == GL_ALPHA ||
+              destBaseFormat == GL_LUMINANCE_ALPHA)) {
+            rebaseFormat = texImage->_BaseFormat;
+         }
+         break;
+
+      case GL_ALPHA:
+         if (destBaseFormat != GL_ALPHA) {
+            rebaseFormat = texImage->_BaseFormat;
+         }
+         break;
+      }
+   }
 
    for (img = 0; img < depth; img++) {
       GLubyte *srcMap;
@@ -467,16 +547,18 @@ get_tex_memcpy(struct gl_context *ctx, GLenum format, GLenum type,
 {
    const GLenum target = texImage->TexObject->Target;
    GLboolean memCopy = GL_FALSE;
+   GLenum texBaseFormat = _mesa_get_format_base_format(texImage->TexFormat);
 
    /*
     * Check if we can use memcpy to copy from the hardware texture
     * format to the user's format/type.
     * Note that GL's pixel transfer ops don't apply to glGetTexImage()
     */
-   if (target == GL_TEXTURE_1D ||
-       target == GL_TEXTURE_2D ||
-       target == GL_TEXTURE_RECTANGLE ||
-       _mesa_is_cube_face(target)) {
+   if ((target == GL_TEXTURE_1D ||
+        target == GL_TEXTURE_2D ||
+        target == GL_TEXTURE_RECTANGLE ||
+        _mesa_is_cube_face(target)) &&
+       texBaseFormat == texImage->_BaseFormat) {
       memCopy = _mesa_format_matches_format_and_type(texImage->TexFormat,
                                                      format, type,
                                                      ctx->Pack.SwapBytes);
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 9283ece8a..f8f517a42 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -2454,9 +2454,7 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
       }
    }
 
-   if ((_mesa_is_desktop_gl(ctx) &&
-        ctx->Extensions.ARB_framebuffer_object) ||
-       _mesa_is_gles3(ctx)) {
+   if (_mesa_is_gles3(ctx)) {
       bool rb_is_srgb = false;
       bool dst_is_srgb = false;
 
@@ -2470,22 +2468,16 @@ copytexture_error_check( struct gl_context *ctx, GLuint dimensions,
       }
 
       if (rb_is_srgb != dst_is_srgb) {
-         /* Page 190 (page 211 of the PDF) in section 8.6 of the OpenGL 4.3
-          * Core Profile spec says:
-          *
-          *     "An INVALID_OPERATION error is generated under any of the
-          *     following conditions:
-          *
-          *     ...
+         /* Page 137 (page 149 of the PDF) in section 3.8.5 of the
+          * OpenGLES 3.0.0 spec says:
           *
-          *     - if the value of FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
-          *       for the framebuffer attachment corresponding to the read
-          *       buffer is LINEAR (see section 9.2.3) and internalformat
-          *       is one of the sRGB formats in table 8.23
-          *     - if the value of FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
-          *       for the framebuffer attachment corresponding to the read
-          *       buffer is SRGB and internalformat is not one of the sRGB
-          *       formats. in table 8.23."
+          *     "The error INVALID_OPERATION is also generated if the
+          *     value of FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING for the
+          *     framebuffer attachment corresponding to the read buffer
+          *     is LINEAR (see section 6.1.13) and internalformat is
+          *     one of the sRGB formats described in section 3.8.16, or
+          *     if the value of FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING is
+          *     SRGB and internalformat is not one of the sRGB formats."
           */
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glCopyTexImage%dD(srgb usage mismatch)", dimensions);
diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c
index 6e7ce237f..9281aa9ea 100644
--- a/mesalib/src/mesa/main/texstore.c
+++ b/mesalib/src/mesa/main/texstore.c
@@ -1022,20 +1022,7 @@ _mesa_texstore_z32(TEXSTORE_PARAMS)
    else
       dstType = GL_FLOAT;
 
-   if (ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_DEPTH_COMPONENT &&
-       srcFormat == GL_DEPTH_COMPONENT &&
-       srcType == dstType) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       GLint img, row;
       for (img = 0; img < srcDepth; img++) {
@@ -1129,20 +1116,7 @@ _mesa_texstore_z16(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_Z16);
    ASSERT(_mesa_get_format_bytes(dstFormat) == sizeof(GLushort));
 
-   if (ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_DEPTH_COMPONENT &&
-       srcFormat == GL_DEPTH_COMPONENT &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       GLint img, row;
       for (img = 0; img < srcDepth; img++) {
@@ -1173,22 +1147,11 @@ _mesa_texstore_rgb565(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
 
    if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
        baseInternalFormat == GL_RGB &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            baseInternalFormat == GL_RGB &&
-            srcFormat == GL_RGB &&
-            srcType == GL_UNSIGNED_BYTE &&
-            dims == 2) {
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_BYTE &&
+       dims == 2) {
       /* do optimized tex store */
       const GLint srcRowStride =
          _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
@@ -1242,22 +1205,11 @@ _mesa_texstore_rgba8888(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
    if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    (srcType == GL_UNSIGNED_BYTE ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
+       (srcType == GL_UNSIGNED_BYTE ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
+       can_swizzle(baseInternalFormat) &&
+       can_swizzle(srcFormat)) {
 
       GLubyte dstmap[4];
 
@@ -1310,24 +1262,13 @@ _mesa_texstore_argb8888(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
    if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path (big endian) */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-	    (dstFormat == MESA_FORMAT_ARGB8888 ||
-             dstFormat == MESA_FORMAT_XRGB8888) &&
-            srcFormat == GL_RGB &&
-	    (baseInternalFormat == GL_RGBA ||
-	     baseInternalFormat == GL_RGB) &&
-            srcType == GL_UNSIGNED_BYTE) {
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_ARGB8888 ||
+        dstFormat == MESA_FORMAT_XRGB8888) &&
+       srcFormat == GL_RGB &&
+       (baseInternalFormat == GL_RGBA ||
+        baseInternalFormat == GL_RGB) &&
+       srcType == GL_UNSIGNED_BYTE) {
       int img, row, col;
       for (img = 0; img < srcDepth; img++) {
          const GLint srcRowStride =
@@ -1465,20 +1406,9 @@ _mesa_texstore_rgb888(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 3);
 
    if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGB &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            srcFormat == GL_RGBA &&
-            srcType == GL_UNSIGNED_BYTE) {
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_BYTE) {
       /* extract RGB from RGBA */
       GLint img, row, col;
       for (img = 0; img < srcDepth; img++) {
@@ -1538,20 +1468,9 @@ _mesa_texstore_bgr888(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 3);
 
    if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGB &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-            !srcPacking->SwapBytes &&
-            srcFormat == GL_RGBA &&
-            srcType == GL_UNSIGNED_BYTE) {
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_BYTE) {
       /* extract BGR from RGBA */
       int img, row, col;
       for (img = 0; img < srcDepth; img++) {
@@ -1605,105 +1524,13 @@ _mesa_texstore_bgr888(TEXSTORE_PARAMS)
 
 
 static GLboolean
-_mesa_texstore_argb4444(TEXSTORE_PARAMS)
-{
-   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||
-          dstFormat == MESA_FORMAT_ARGB4444_REV);
-   ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
-
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      return store_ubyte_texture(ctx, dims, baseInternalFormat,
-                                 dstFormat, dstRowStride, dstSlices,
-                                 srcWidth, srcHeight, srcDepth,
-                                 srcFormat, srcType, srcAddr, srcPacking);
-   }
-   return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_rgba5551(TEXSTORE_PARAMS)
-{
-   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);
-   ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
-
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      return store_ubyte_texture(ctx, dims, baseInternalFormat,
-                                 dstFormat, dstRowStride, dstSlices,
-                                 srcWidth, srcHeight, srcDepth,
-                                 srcFormat, srcType, srcAddr, srcPacking);
-   }
-   return GL_TRUE;
-}
-
-static GLboolean
-_mesa_texstore_argb1555(TEXSTORE_PARAMS)
-{
-   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||
-          dstFormat == MESA_FORMAT_ARGB1555_REV);
-   ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
-
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      return store_ubyte_texture(ctx, dims, baseInternalFormat,
-                                 dstFormat, dstRowStride, dstSlices,
-                                 srcWidth, srcHeight, srcDepth,
-                                 srcFormat, srcType, srcAddr, srcPacking);
-   }
-   return GL_TRUE;
-}
-
-
-static GLboolean
 _mesa_texstore_argb2101010(TEXSTORE_PARAMS)
 {
    ASSERT(dstFormat == MESA_FORMAT_ARGB2101010 ||
           dstFormat == MESA_FORMAT_XRGB2101010_UNORM);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       /* Hardcode GL_RGBA as the base format, which forces alpha to 1.0
        * if the internal format is RGB. */
@@ -1803,26 +1630,10 @@ _mesa_texstore_unorm88(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
 
    if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       ((dstFormat == MESA_FORMAT_AL88 &&
-         baseInternalFormat == GL_LUMINANCE_ALPHA &&
-         srcFormat == GL_LUMINANCE_ALPHA) ||
-        (dstFormat == MESA_FORMAT_GR88 &&
-         baseInternalFormat == srcFormat)) &&
+       littleEndian &&
        srcType == GL_UNSIGNED_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    littleEndian &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
+       can_swizzle(baseInternalFormat) &&
+       can_swizzle(srcFormat)) {
       GLubyte dstmap[4];
 
       /* dstmap - how to swizzle from RGBA to dst format:
@@ -1909,7 +1720,6 @@ _mesa_texstore_unorm88(TEXSTORE_PARAMS)
 static GLboolean
 _mesa_texstore_unorm1616(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
 
    ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
@@ -1918,23 +1728,7 @@ _mesa_texstore_unorm1616(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_RG1616);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       ((dstFormat == MESA_FORMAT_AL1616 &&
-         baseInternalFormat == GL_LUMINANCE_ALPHA &&
-         srcFormat == GL_LUMINANCE_ALPHA) ||
-        (dstFormat == MESA_FORMAT_GR1616 &&
-         baseInternalFormat == srcFormat)) &&
-       srcType == GL_UNSIGNED_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -1985,7 +1779,6 @@ _mesa_texstore_unorm1616(TEXSTORE_PARAMS)
 static GLboolean
 _mesa_texstore_unorm16(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
 
    ASSERT(dstFormat == MESA_FORMAT_R16 ||
@@ -1994,19 +1787,7 @@ _mesa_texstore_unorm16(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_I16);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2046,19 +1827,7 @@ _mesa_texstore_rgba_16(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_XBGR16161616_UNORM);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 8);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGBA &&
-       srcFormat == GL_RGBA &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       /* Hardcode GL_RGBA as the base format, which forces alpha to 1.0
        * if the internal format is RGB. */
@@ -2110,20 +1879,7 @@ _mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_SIGNED_RGBA_16 ||
           dstFormat == MESA_FORMAT_XBGR16161616_SNORM);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == GL_RGBA &&
-       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&
-       srcFormat == GL_RGBA &&
-       srcType == GL_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2192,33 +1948,6 @@ _mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
 }
 
 
-static GLboolean
-_mesa_texstore_rgb332(TEXSTORE_PARAMS)
-{
-   ASSERT(dstFormat == MESA_FORMAT_RGB332);
-   ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
-
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGB &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
-      return store_ubyte_texture(ctx, dims, baseInternalFormat,
-                                 dstFormat, dstRowStride, dstSlices,
-                                 srcWidth, srcHeight, srcDepth,
-                                 srcFormat, srcType, srcAddr, srcPacking);
-   }
-   return GL_TRUE;
-}
-
-
 /**
  * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.
  */
@@ -2234,20 +1963,9 @@ _mesa_texstore_unorm8(TEXSTORE_PARAMS)
    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
 
    if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (!ctx->_ImageTransferState &&
-	    srcType == GL_UNSIGNED_BYTE &&
-	    can_swizzle(baseInternalFormat) &&
-	    can_swizzle(srcFormat)) {
+       srcType == GL_UNSIGNED_BYTE &&
+       can_swizzle(baseInternalFormat) &&
+       can_swizzle(srcFormat)) {
       GLubyte dstmap[4];
 
       /* dstmap - how to swizzle from RGBA to dst format:
@@ -2357,16 +2075,7 @@ _mesa_texstore_dudv8(TEXSTORE_PARAMS)
 	  (srcFormat == GL_DUDV_ATI));
    ASSERT(baseInternalFormat == GL_DUDV_ATI);
 
-   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (srcType == GL_BYTE) {
+   if (srcType == GL_BYTE) {
       GLubyte dstmap[4];
 
       /* dstmap - how to swizzle from RGBA to dst format:
@@ -2445,18 +2154,7 @@ _mesa_texstore_snorm8(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_SIGNED_R8);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 1);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2491,26 +2189,13 @@ _mesa_texstore_snorm8(TEXSTORE_PARAMS)
 static GLboolean
 _mesa_texstore_snorm88(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
 
    ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL88 ||
           dstFormat == MESA_FORMAT_SIGNED_RG88_REV);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_BYTE &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2545,7 +2230,6 @@ _mesa_texstore_snorm88(TEXSTORE_PARAMS)
 static GLboolean
 _mesa_texstore_snorm16(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
 
    ASSERT(dstFormat == MESA_FORMAT_SIGNED_R16 ||
@@ -2554,19 +2238,7 @@ _mesa_texstore_snorm16(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_SIGNED_I16);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 2);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2604,26 +2276,13 @@ _mesa_texstore_snorm16(TEXSTORE_PARAMS)
 static GLboolean
 _mesa_texstore_snorm1616(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
 
    ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL1616 ||
           dstFormat == MESA_FORMAT_SIGNED_GR1616);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_SHORT &&
-       littleEndian) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2731,18 +2390,7 @@ _mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
           dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (!ctx->_ImageTransferState &&
-       baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-       /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -2805,18 +2453,8 @@ _mesa_texstore_z24_s8(TEXSTORE_PARAMS)
           srcFormat == GL_STENCIL_INDEX);
    ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
 
-   if (srcFormat == GL_DEPTH_STENCIL && ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes) {
-      /* simple path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (srcFormat == GL_DEPTH_COMPONENT ||
-            srcFormat == GL_STENCIL_INDEX) {
+   if (srcFormat == GL_DEPTH_COMPONENT ||
+       srcFormat == GL_STENCIL_INDEX) {
       GLuint *depth = malloc(srcWidth * sizeof(GLuint));
       GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
 
@@ -2972,18 +2610,7 @@ _mesa_texstore_s8(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_S8);
    ASSERT(srcFormat == GL_STENCIL_INDEX);
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       const GLint srcRowStride
 	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
       GLint img, row;
@@ -3064,19 +2691,7 @@ _mesa_texstore_rgba_float32(TEXSTORE_PARAMS)
           baseInternalFormat == GL_RG);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLfloat));
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       baseInternalFormat == baseFormat &&
-       srcType == GL_FLOAT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -3141,19 +2756,7 @@ _mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
           baseInternalFormat == GL_RG);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLhalfARB));
 
-   if (!ctx->_ImageTransferState &&
-       !srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       baseInternalFormat == baseFormat &&
-       srcType == GL_HALF_FLOAT_ARB) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -3217,20 +2820,7 @@ _mesa_texstore_rgba_int8(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLbyte));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
 						     baseInternalFormat,
@@ -3301,20 +2891,7 @@ _mesa_texstore_rgba_int16(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLshort));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
 						     baseInternalFormat,
@@ -3385,20 +2962,7 @@ _mesa_texstore_rgba_int32(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLint));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_INT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
 						     baseInternalFormat,
@@ -3469,20 +3033,7 @@ _mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLubyte));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_BYTE) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage =
          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
@@ -3550,20 +3101,7 @@ _mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLushort));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_SHORT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage =
          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
@@ -3631,20 +3169,7 @@ _mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)
           baseInternalFormat == GL_INTENSITY);
    ASSERT(_mesa_get_format_bytes(dstFormat) == components * sizeof(GLuint));
 
-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
-    * to integer formats.
-    */
-   if (!srcPacking->SwapBytes &&
-       baseInternalFormat == srcFormat &&
-       srcType == GL_UNSIGNED_INT) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage =
          make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
@@ -3802,17 +3327,7 @@ _mesa_texstore_rgb9_e5(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_RGB9_E5_FLOAT);
    ASSERT(baseInternalFormat == GL_RGB);
 
-   if (!ctx->_ImageTransferState &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -3850,17 +3365,7 @@ _mesa_texstore_r11_g11_b10f(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_R11_G11_B10_FLOAT);
    ASSERT(baseInternalFormat == GL_RGB);
 
-   if (!ctx->_ImageTransferState &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
                                                  baseInternalFormat,
@@ -3901,19 +3406,8 @@ _mesa_texstore_z32f_x24s8(TEXSTORE_PARAMS)
    ASSERT(srcFormat != GL_DEPTH_STENCIL ||
           srcType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
 
-   if (srcFormat == GL_DEPTH_STENCIL &&
-       ctx->Pixel.DepthScale == 1.0f &&
-       ctx->Pixel.DepthBias == 0.0f &&
-       !srcPacking->SwapBytes) {
-      /* simple path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else if (srcFormat == GL_DEPTH_COMPONENT ||
-            srcFormat == GL_STENCIL_INDEX) {
+   if (srcFormat == GL_DEPTH_COMPONENT ||
+       srcFormat == GL_STENCIL_INDEX) {
       GLint img, row;
       const GLint srcRowStride
          = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
@@ -3961,17 +3455,7 @@ _mesa_texstore_argb2101010_uint(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_ARGB2101010_UINT);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
                                                      baseInternalFormat,
@@ -4027,17 +3511,7 @@ _mesa_texstore_abgr2101010_uint(TEXSTORE_PARAMS)
    ASSERT(dstFormat == MESA_FORMAT_ABGR2101010_UINT);
    ASSERT(_mesa_get_format_bytes(dstFormat) == 4);
 
-   if (baseInternalFormat == GL_RGBA &&
-       _mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
-                                            srcPacking->SwapBytes)) {
-      /* simple memcpy path */
-      memcpy_texture(ctx, dims,
-                     dstFormat,
-                     dstRowStride, dstSlices,
-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
-                     srcAddr, srcPacking);
-   }
-   else {
+   {
       /* general path */
       const GLuint *tempImage = make_temp_uint_image(ctx, dims,
                                                      baseInternalFormat,
@@ -4127,17 +3601,17 @@ _mesa_get_texstore_func(gl_format format)
       table[MESA_FORMAT_BGR888] = _mesa_texstore_bgr888;
       table[MESA_FORMAT_RGB565] = _mesa_texstore_rgb565;
       table[MESA_FORMAT_RGB565_REV] = _mesa_texstore_rgb565;
-      table[MESA_FORMAT_ARGB4444] = _mesa_texstore_argb4444;
-      table[MESA_FORMAT_ARGB4444_REV] = _mesa_texstore_argb4444;
-      table[MESA_FORMAT_RGBA5551] = _mesa_texstore_rgba5551;
-      table[MESA_FORMAT_ARGB1555] = _mesa_texstore_argb1555;
-      table[MESA_FORMAT_ARGB1555_REV] = _mesa_texstore_argb1555;
+      table[MESA_FORMAT_ARGB4444] = store_ubyte_texture;
+      table[MESA_FORMAT_ARGB4444_REV] = store_ubyte_texture;
+      table[MESA_FORMAT_RGBA5551] = store_ubyte_texture;
+      table[MESA_FORMAT_ARGB1555] = store_ubyte_texture;
+      table[MESA_FORMAT_ARGB1555_REV] = store_ubyte_texture;
       table[MESA_FORMAT_AL44] = _mesa_texstore_unorm44;
       table[MESA_FORMAT_AL88] = _mesa_texstore_unorm88;
       table[MESA_FORMAT_AL88_REV] = _mesa_texstore_unorm88;
       table[MESA_FORMAT_AL1616] = _mesa_texstore_unorm1616;
       table[MESA_FORMAT_AL1616_REV] = _mesa_texstore_unorm1616;
-      table[MESA_FORMAT_RGB332] = _mesa_texstore_rgb332;
+      table[MESA_FORMAT_RGB332] = store_ubyte_texture;
       table[MESA_FORMAT_A8] = _mesa_texstore_unorm8;
       table[MESA_FORMAT_A16] = _mesa_texstore_unorm16;
       table[MESA_FORMAT_L8] = _mesa_texstore_unorm8;
@@ -4317,6 +3791,58 @@ _mesa_get_texstore_func(gl_format format)
 }
 
 
+static GLboolean
+_mesa_texstore_memcpy(TEXSTORE_PARAMS)
+{
+   GLenum dstType;
+
+   /* There are different restrictions depending on the base format... */
+   switch (baseInternalFormat) {
+   case GL_DEPTH_COMPONENT:
+   case GL_DEPTH_STENCIL:
+      /* Depth scale and bias are not allowed. */
+      if (ctx->Pixel.DepthScale != 1.0f ||
+          ctx->Pixel.DepthBias != 0.0f) {
+        return GL_FALSE;
+      }
+      break;
+
+   case GL_STENCIL_INDEX:
+      break;
+
+   default:
+      /* Color formats.
+       * Pixel transfer ops (scale, bias, table lookup) do not apply
+       * to integer formats.
+       */
+      dstType = _mesa_get_format_datatype(dstFormat);
+
+      if (dstType != GL_INT && dstType != GL_UNSIGNED_INT &&
+          ctx->_ImageTransferState) {
+         return GL_FALSE;
+      }
+   }
+
+   /* The base internal format and the base Mesa format must match. */
+   if (baseInternalFormat != _mesa_get_format_base_format(dstFormat)) {
+      return GL_FALSE;
+   }
+
+   /* The Mesa format must match the input format and type. */
+   if (!_mesa_format_matches_format_and_type(dstFormat, srcFormat, srcType,
+                                             srcPacking->SwapBytes)) {
+      return GL_FALSE;
+   }
+
+   memcpy_texture(ctx, dims,
+                  dstFormat,
+                  dstRowStride, dstSlices,
+                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                  srcAddr, srcPacking);
+   return GL_TRUE;
+}
+
+
 /**
  * Store user data into texture memory.
  * Called via glTex[Sub]Image1/2/3D()
@@ -4327,6 +3853,14 @@ _mesa_texstore(TEXSTORE_PARAMS)
    StoreTexImageFunc storeImage;
    GLboolean success;
 
+   if (_mesa_texstore_memcpy(ctx, dims, baseInternalFormat,
+                             dstFormat,
+                             dstRowStride, dstSlices,
+                             srcWidth, srcHeight, srcDepth,
+                             srcFormat, srcType, srcAddr, srcPacking)) {
+      return GL_TRUE;
+   }
+
    storeImage = _mesa_get_texstore_func(dstFormat);
 
    success = storeImage(ctx, dims, baseInternalFormat,