Merge texmem-0-3-branch.

1 files changed, 628 insertions, 452 deletions

diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c
index c2ba450cb3f..662f697147d 100644
--- a/src/mesa/main/teximage.c
+++ b/src/mesa/main/teximage.c
@@ -706,9 +706,12 @@ _mesa_free_texture_image_data(GLcontext *ctx,
 void
 _mesa_delete_texture_image( GLcontext *ctx, struct gl_texture_image *texImage )
 {
-   if (texImage->Data) {
-      ctx->Driver.FreeTexImageData( ctx, 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)
       _mesa_free(texImage->ImageOffsets);
@@ -801,24 +804,23 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
  * \sa gl_texture_unit.
  */
 struct gl_texture_image *
-_mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_unit *texUnit,
-                       GLenum target, GLint level)
+_mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_object *texObj,
+		       GLenum target, GLint level)
 {
-   ASSERT(texUnit);
-   ASSERT(level < MAX_TEXTURE_LEVELS);
+   ASSERT(texObj);
+
+   if (level < 0 || level >= MAX_TEXTURE_LEVELS) 
+      return NULL;
+
    switch (target) {
       case GL_TEXTURE_1D:
-         return texUnit->Current1D->Image[0][level];
       case GL_PROXY_TEXTURE_1D:
-         return ctx->Texture.Proxy1D->Image[0][level];
       case GL_TEXTURE_2D:
-         return texUnit->Current2D->Image[0][level];
       case GL_PROXY_TEXTURE_2D:
-         return ctx->Texture.Proxy2D->Image[0][level];
       case GL_TEXTURE_3D:
-         return texUnit->Current3D->Image[0][level];
       case GL_PROXY_TEXTURE_3D:
-         return ctx->Texture.Proxy3D->Image[0][level];
+         return texObj->Image[0][level];
+
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
@@ -828,33 +830,25 @@ _mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_unit *texUnit,
          if (ctx->Extensions.ARB_texture_cube_map) {
 	    GLuint face = ((GLuint) target - 
 			   (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X);
-            return texUnit->CurrentCubeMap->Image[face][level];
+            return texObj->Image[face][level];
 	 }
          else
             return NULL;
+
       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
          if (ctx->Extensions.ARB_texture_cube_map)
-            return ctx->Texture.ProxyCubeMap->Image[0][level];
+            return texObj->Image[0][level];
          else
             return NULL;
+
       case GL_TEXTURE_RECTANGLE_NV:
-         if (ctx->Extensions.NV_texture_rectangle) {
-            ASSERT(level == 0);
-            return texUnit->CurrentRect->Image[0][level];
-         }
-         else {
-            return NULL;
-         }
       case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         if (ctx->Extensions.NV_texture_rectangle) {
-            ASSERT(level == 0);
-            return ctx->Texture.ProxyRect->Image[0][level];
-         }
-         else {
+         if (ctx->Extensions.NV_texture_rectangle && level == 0) 
+            return texObj->Image[0][level];
+         else 
             return NULL;
-         }
+
       default:
-         _mesa_problem(ctx, "bad target in _mesa_select_tex_image()");
          return NULL;
    }
 }
@@ -866,22 +860,25 @@ _mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_unit *texUnit,
  * out of memory.
  */
 struct gl_texture_image *
-_mesa_get_tex_image(GLcontext *ctx, const struct gl_texture_unit *texUnit,
+_mesa_get_tex_image(GLcontext *ctx, struct gl_texture_object *texObj,
                     GLenum target, GLint level)
 {
    struct gl_texture_image *texImage;
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+
+   if (!texObj)
+      return NULL;
+   
+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
    if (!texImage) {
-      struct gl_texture_object *texObj;
       texImage = ctx->Driver.NewTextureImage(ctx);
       if (!texImage) {
          _mesa_error(ctx, GL_OUT_OF_MEMORY, "texture image allocation");
          return NULL;
       }
-      texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      ASSERT(texObj);
+
       _mesa_set_tex_image(texObj, target, level, texImage);
    }
+
    return texImage;
 }
 
@@ -1584,9 +1581,6 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
                         GLint width, GLint height, GLint depth,
                         GLenum format, GLenum type )
 {
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   struct gl_texture_image *destTex;
-
    /* Check target */
    if (dimensions == 1) {
       if (target != GL_TEXTURE_1D) {
@@ -1602,8 +1596,7 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
             return GL_TRUE;
          }
       }
-      else if (ctx->Extensions.NV_texture_rectangle &&
-               target == GL_TEXTURE_RECTANGLE_NV) {
+      else if (target == GL_TEXTURE_RECTANGLE_NV) {
          if (!ctx->Extensions.NV_texture_rectangle) {
             _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
             return GL_TRUE;
@@ -1647,8 +1640,23 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
       return GL_TRUE;
    }
 
-   destTex = _mesa_select_tex_image(ctx, texUnit, target, level);
+   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glTexSubImage%dD(format or type)", dimensions);
+      return GL_TRUE;
+   }
+
+   return GL_FALSE;
+}
 
+static GLboolean
+subtexture_error_check2( GLcontext *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);
@@ -1688,12 +1696,6 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
       }
    }
 
-   if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glTexSubImage%dD(format or type)", dimensions);
-      return GL_TRUE;
-   }
-
 #if FEATURE_EXT_texture_sRGB
    if (destTex->InternalFormat == GL_COMPRESSED_SRGB_S3TC_DXT1_EXT ||
        destTex->InternalFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT ||
@@ -1709,11 +1711,6 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
 #endif
 
    if (destTex->IsCompressed) {
-      const struct gl_texture_unit *texUnit;
-      const struct gl_texture_image *texImage;
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-
       if (target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D) {
          /* OK */
       }
@@ -1735,12 +1732,12 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
          return GL_TRUE;
       }
       /* size must be multiple of 4 or equal to whole texture size */
-      if ((width & 3) && (GLuint) width != texImage->Width) {
+      if ((width & 3) && (GLuint) width != destTex->Width) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glTexSubImage%D(width)", dimensions);
          return GL_TRUE;
       }         
-      if ((height & 3) && (GLuint) height != texImage->Height) {
+      if ((height & 3) && (GLuint) height != destTex->Height) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glTexSubImage%D(width)", dimensions);
          return GL_TRUE;
@@ -1781,6 +1778,11 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions,
 
    /* 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);
@@ -1791,11 +1793,6 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions,
       }
    }
 
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyTexImage%dD(level=%d)", dimensions, level);
-      return GL_TRUE;
-   }
-
    /* Check border */
    if (border < 0 || border > 1 ||
        ((target == GL_TEXTURE_RECTANGLE_NV ||
@@ -1945,11 +1942,8 @@ static GLboolean
 copytexsubimage_error_check( GLcontext *ctx, GLuint dimensions,
                              GLenum target, GLint level,
                              GLint xoffset, GLint yoffset, GLint zoffset,
-                             GLsizei width, GLsizei height )
+                             GLsizei width, GLsizei height)
 {
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   struct gl_texture_image *teximage;
-
    /* Check target */
    /* Check that the source buffer is complete */
    if (ctx->ReadBuffer->Name) {
@@ -2012,7 +2006,16 @@ copytexsubimage_error_check( GLcontext *ctx, GLuint dimensions,
       return GL_TRUE;
    }
 
-   teximage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   return GL_FALSE;
+}
+
+static GLboolean
+copytexsubimage_error_check2( GLcontext *ctx, GLuint dimensions,
+			      GLenum target, GLint level,
+			      GLint xoffset, GLint yoffset, GLint zoffset,
+			      GLsizei width, GLsizei height,
+			      const struct gl_texture_image *teximage )
+{
    if (!teximage) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glCopyTexSubImage%dD(undefined texture level: %d)",
@@ -2186,59 +2189,66 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format,
    if (!pixels)
       return;
 
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   if (!texImage) {
-      /* invalid mipmap level, not an error */
-      return;
-   }
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      if (!texImage) {
+	 /* invalid mipmap level, not an error */
+	 goto out;
+      }
 
-   /* Make sure the requested image format is compatible with the
-    * texture's format.  Note that a color index texture can be converted
-    * to RGBA so that combo is allowed.
-    */
-   if (is_color_format(format)
-       && !is_color_format(texImage->TexFormat->BaseFormat)
-       && !is_index_format(texImage->TexFormat->BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return;
-   }
-   else if (is_index_format(format)
-       && !is_index_format(texImage->TexFormat->BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return;
-   }
-   else if (is_depth_format(format)
-       && !is_depth_format(texImage->TexFormat->BaseFormat)
-       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return;
-   }
-   else if (is_ycbcr_format(format)
-       && !is_ycbcr_format(texImage->TexFormat->BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return;
-   }
-   else if (is_depthstencil_format(format)
-       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-      return;
-   }
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* packing texture image into a PBO */
-      const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
-      if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,
-                                     texImage->Height, texImage->Depth,
-                                     format, type, pixels)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetTexImage(invalid PBO access)");
-         return;
+      /* Make sure the requested image format is compatible with the
+       * texture's format.  Note that a color index texture can be converted
+       * to RGBA so that combo is allowed.
+       */
+      if (is_color_format(format)
+	  && !is_color_format(texImage->TexFormat->BaseFormat)
+	  && !is_index_format(texImage->TexFormat->BaseFormat)) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+	 goto out;
+      }
+      else if (is_index_format(format)
+	       && !is_index_format(texImage->TexFormat->BaseFormat)) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+	 goto out;
+      }
+      else if (is_depth_format(format)
+	       && !is_depth_format(texImage->TexFormat->BaseFormat)
+	       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+	 goto out;
+      }
+      else if (is_ycbcr_format(format)
+	       && !is_ycbcr_format(texImage->TexFormat->BaseFormat)) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+	 goto out;
+      }
+      else if (is_depthstencil_format(format)
+	       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+	 goto out;
+      }
+
+      if (ctx->Pack.BufferObj->Name) {
+	 /* packing texture image into a PBO */
+	 const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
+	 if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,
+					texImage->Height, texImage->Depth,
+					format, type, pixels)) {
+	    _mesa_error(ctx, GL_INVALID_OPERATION,
+			"glGetTexImage(invalid PBO access)");
+	    goto out;
+	 }
       }
-   }
 
-   /* typically, this will call _mesa_get_teximage() */
-   ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,
-                           texObj, texImage);
+      /* typically, this will call _mesa_get_teximage() */
+      ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,
+			      texObj, texImage);
+
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2301,40 +2311,47 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
-      clear_teximage_fields(texImage); /* not really needed, but helpful */
-      _mesa_init_teximage_fields(ctx, target, texImage,
-                                 postConvWidth, 1, 1,
-                                 border, internalFormat);
-
       if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
-         _mesa_update_state(ctx);
+	 _mesa_update_state(ctx);
 
-      ASSERT(ctx->Driver.TexImage1D);
+      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+	    goto out;
+	 }
+      
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
 
-      /* Give the texture to the driver!  <pixels> may be null! */
-      (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
-                                width, border, format, type, pixels,
-                                &ctx->Unpack, texObj, texImage);
+	 ASSERT(texImage->Data == NULL);
 
-      ASSERT(texImage->TexFormat);
+	 clear_teximage_fields(texImage); /* not really needed, but helpful */
+	 _mesa_init_teximage_fields(ctx, target, texImage,
+				    postConvWidth, 1, 1,
+				    border, internalFormat);
+	 
+	 ASSERT(ctx->Driver.TexImage1D);
 
-      update_fbo_texture(ctx, texObj, face, level);
+	 /* Give the texture to the driver!  <pixels> may be null! */
+	 (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+				   width, border, format, type, pixels,
+				   &ctx->Unpack, texObj, texImage);
+	 
+	 ASSERT(texImage->TexFormat);
 
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+	 update_fbo_texture(ctx, texObj, face, level);
+	 
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
       /* Proxy texture: check for errors and update proxy state */
@@ -2396,39 +2413,46 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
-      clear_teximage_fields(texImage); /* not really needed, but helpful */
-      _mesa_init_teximage_fields(ctx, target, texImage,
-                                 postConvWidth, postConvHeight, 1,
-                                 border, internalFormat);
-
       if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
-         _mesa_update_state(ctx);
+	 _mesa_update_state(ctx);
 
-      ASSERT(ctx->Driver.TexImage2D);
-
-      /* Give the texture to the driver!  <pixels> may be null! */
-      (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
-                                width, height, border, format, type, pixels,
-                                &ctx->Unpack, texObj, texImage);
-
-      ASSERT(texImage->TexFormat);
-
-      update_fbo_texture(ctx, texObj, face, level);
-
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+	    goto out;
+	 }
+	 
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
+	 
+	 ASSERT(texImage->Data == NULL);
+	 clear_teximage_fields(texImage); /* not really needed, but helpful */
+	 _mesa_init_teximage_fields(ctx, target, texImage,
+				    postConvWidth, postConvHeight, 1,
+				    border, internalFormat);
+	 
+	 ASSERT(ctx->Driver.TexImage2D);
+
+	 /* Give the texture to the driver!  <pixels> may be null! */
+	 (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+				   width, height, border, format, type, pixels,
+				   &ctx->Unpack, texObj, texImage);
+	 
+	 ASSERT(texImage->TexFormat);
+
+	 update_fbo_texture(ctx, texObj, face, level);
+
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_2D ||
             (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB &&
@@ -2486,39 +2510,46 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
+      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+	 _mesa_update_state(ctx);
+
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
-      clear_teximage_fields(texImage); /* not really needed, but helpful */
-      _mesa_init_teximage_fields(ctx, target, texImage,
-                                 width, height, depth,
-                                 border, internalFormat);
-
-      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
-         _mesa_update_state(ctx);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+	    goto out;
+	 }
+	 
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
+	 
+	 ASSERT(texImage->Data == NULL);
+	 clear_teximage_fields(texImage); /* not really needed, but helpful */
+	 _mesa_init_teximage_fields(ctx, target, texImage,
+				    width, height, depth,
+				    border, internalFormat);
 
-      ASSERT(ctx->Driver.TexImage3D);
+	 ASSERT(ctx->Driver.TexImage3D);
 
-      /* Give the texture to the driver!  <pixels> may be null! */
-      (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
-                                width, height, depth, border, format, type,
-                                pixels, &ctx->Unpack, texObj, texImage);
+	 /* Give the texture to the driver!  <pixels> may be null! */
+	 (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
+				   width, height, depth, border, format, type,
+				   pixels, &ctx->Unpack, texObj, texImage);
 
-      ASSERT(texImage->TexFormat);
+	 ASSERT(texImage->TexFormat);
 
-      update_fbo_texture(ctx, texObj, face, level);
+	 update_fbo_texture(ctx, texObj, face, level);
 
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_3D) {
       /* Proxy texture: check for errors and update proxy state */
@@ -2566,7 +2597,7 @@ _mesa_TexSubImage1D( GLenum target, GLint level,
    GLsizei postConvWidth = width;
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
+   struct gl_texture_image *texImage = NULL;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
@@ -2579,26 +2610,38 @@ _mesa_TexSubImage1D( GLenum target, GLint level,
    }
 
    if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
-                              postConvWidth, 1, 1, format, type)) {
+			       postConvWidth, 1, 1, format, type)) {
       return;   /* error was detected */
    }
 
+
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
+   assert(texObj);
 
-   if (width == 0)
-      return;  /* no-op, not an error */
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
+      if (subtexture_error_check2(ctx, 1, target, level, xoffset, 0, 0,
+				  postConvWidth, 1, 1, format, type, texImage)) {
+	 goto out;   /* error was detected */
+      }
+
+      if (width == 0)
+	 goto out;  /* no-op, not an error */
+
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
 
-   ASSERT(ctx->Driver.TexSubImage1D);
-   (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
-                                format, type, pixels, &ctx->Unpack,
-                                texObj, texImage);
-   ctx->NewState |= _NEW_TEXTURE;
+      ASSERT(ctx->Driver.TexSubImage1D);
+      (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
+				   format, type, pixels, &ctx->Unpack,
+				   texObj, texImage);
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2626,27 +2669,37 @@ _mesa_TexSubImage2D( GLenum target, GLint level,
    }
 
    if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
-                             postConvWidth, postConvHeight, 1, format, type)) {
+			      postConvWidth, postConvHeight, 1, format, type)) {
       return;   /* error was detected */
    }
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-   if (width == 0 || height == 0)
-      return;  /* no-op, not an error */
+      if (subtexture_error_check2(ctx, 2, target, level, xoffset, yoffset, 0,
+				  postConvWidth, postConvHeight, 1, format, type, 
+				  texImage)) {
+	 goto out;   /* error was detected */
+      }
 
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
-   yoffset += texImage->Border;
+      if (width == 0 || height == 0)
+	 goto out;  /* no-op, not an error */
 
-   ASSERT(ctx->Driver.TexSubImage2D);
-   (*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
-                                width, height, format, type, pixels,
-                                &ctx->Unpack, texObj, texImage);
-   ctx->NewState |= _NEW_TEXTURE;
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
+      yoffset += texImage->Border;
+      
+      ASSERT(ctx->Driver.TexSubImage2D);
+      (*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
+				   width, height, format, type, pixels,
+				   &ctx->Unpack, texObj, texImage);
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2674,24 +2727,34 @@ _mesa_TexSubImage3D( GLenum target, GLint level,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
-
-   if (width == 0 || height == 0 || height == 0)
-      return;  /* no-op, not an error */
-
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
-   yoffset += texImage->Border;
-   zoffset += texImage->Border;
-
-   ASSERT(ctx->Driver.TexSubImage3D);
-   (*ctx->Driver.TexSubImage3D)(ctx, target, level,
-                                xoffset, yoffset, zoffset,
-                                width, height, depth,
-                                format, type, pixels,
-                                &ctx->Unpack, texObj, texImage );
-   ctx->NewState |= _NEW_TEXTURE;
+
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+
+      if (subtexture_error_check2(ctx, 3, target, level, xoffset, yoffset, zoffset,
+				  width, height, depth, format, type, texImage)) {
+	 goto out;   /* error was detected */
+      }
+
+      if (width == 0 || height == 0 || height == 0)
+	 goto out;  /* no-op, not an error */
+
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
+      yoffset += texImage->Border;
+      zoffset += texImage->Border;
+
+      ASSERT(ctx->Driver.TexSubImage3D);
+      (*ctx->Driver.TexSubImage3D)(ctx, target, level,
+				   xoffset, yoffset, zoffset,
+				   width, height, depth,
+				   format, type, pixels,
+				   &ctx->Unpack, texObj, texImage );
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2723,32 +2786,39 @@ _mesa_CopyTexImage1D( GLenum target, GLint level,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-   if (!texImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
-      return;
-   }
-   else if (texImage->Data) {
-      ctx->Driver.FreeTexImageData( ctx, texImage );
-   }
-   ASSERT(texImage->Data == NULL);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+      if (!texImage) {
+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
+	 goto out;
+      }
+
+      if (texImage->Data) {
+	 ctx->Driver.FreeTexImageData( ctx, texImage );
+      }
+      
+      ASSERT(texImage->Data == NULL);
 
-   clear_teximage_fields(texImage); /* not really needed, but helpful */
-   _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
-                              border, internalFormat);
+      clear_teximage_fields(texImage); /* not really needed, but helpful */
+      _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
+				 border, internalFormat);
 
 
-   ASSERT(ctx->Driver.CopyTexImage1D);
-   (*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
-                                 x, y, width, border);
+      ASSERT(ctx->Driver.CopyTexImage1D);
+      (*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
+				    x, y, width, border);
 
-   ASSERT(texImage->TexFormat);
+      ASSERT(texImage->TexFormat);
 
-   update_fbo_texture(ctx, texObj, face, level);
+      update_fbo_texture(ctx, texObj, face, level);
 
-   /* state update */
-   texObj->Complete = GL_FALSE;
-   ctx->NewState |= _NEW_TEXTURE;
+      /* state update */
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2780,41 +2850,50 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-   if (!texImage) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
-      return;
-   }
-   else if (texImage->Data) {
-      ctx->Driver.FreeTexImageData( ctx, texImage );
-   }
-   ASSERT(texImage->Data == NULL);
 
-   clear_teximage_fields(texImage); /* not really needed, but helpful */
-   _mesa_init_teximage_fields(ctx, target, texImage,
-                              postConvWidth, postConvHeight, 1,
-                              border, internalFormat);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_get_tex_image(ctx, texObj, target, level);
 
-   ASSERT(ctx->Driver.CopyTexImage2D);
-   (*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
-                                 x, y, width, height, border);
+      if (!texImage) {
+	 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
+	 goto out;
+      }
+      
+      if (texImage->Data) {
+	 ctx->Driver.FreeTexImageData( ctx, texImage );
+      }
+      
+      ASSERT(texImage->Data == NULL);
 
-   ASSERT(texImage->TexFormat);
+      clear_teximage_fields(texImage); /* not really needed, but helpful */
+      _mesa_init_teximage_fields(ctx, target, texImage,
+				 postConvWidth, postConvHeight, 1,
+				 border, internalFormat);
+      
+      ASSERT(ctx->Driver.CopyTexImage2D);
+      (*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
+				    x, y, width, height, border);
+      
+      ASSERT(texImage->TexFormat);
 
-   update_fbo_texture(ctx, texObj, face, level);
+      update_fbo_texture(ctx, texObj, face, level);
 
-   /* state update */
-   texObj->Complete = GL_FALSE;
-   ctx->NewState |= _NEW_TEXTURE;
+      /* state update */
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
-
 void GLAPIENTRY
 _mesa_CopyTexSubImage1D( GLenum target, GLint level,
                          GLint xoffset, GLint x, GLint y, GLsizei width )
 {
    struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
    GLsizei postConvWidth = width;
    GET_CURRENT_CONTEXT(ctx);
@@ -2831,15 +2910,27 @@ _mesa_CopyTexSubImage1D( GLenum target, GLint level,
       return;
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   ASSERT(texImage);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+
+      if (copytexsubimage_error_check2(ctx, 1, target, level,
+				       xoffset, 0, 0, postConvWidth, 1,
+				       texImage))
+	 goto out;
+      
 
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
 
-   ASSERT(ctx->Driver.CopyTexSubImage1D);
-   (*ctx->Driver.CopyTexSubImage1D)(ctx, target, level, xoffset, x, y, width);
-   ctx->NewState |= _NEW_TEXTURE;
+      ASSERT(ctx->Driver.CopyTexSubImage1D);
+      (*ctx->Driver.CopyTexSubImage1D)(ctx, target, level, xoffset, x, y, width);
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2850,6 +2941,7 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level,
                          GLint x, GLint y, GLsizei width, GLsizei height )
 {
    struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
    GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
@@ -2866,17 +2958,27 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level,
       return;
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   ASSERT(texImage);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
-   yoffset += texImage->Border;
+      if (copytexsubimage_error_check2(ctx, 2, target, level, xoffset, yoffset, 0,
+				       postConvWidth, postConvHeight, texImage))
+	 goto out;
 
-   ASSERT(ctx->Driver.CopyTexSubImage2D);
-   (*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
-                                    xoffset, yoffset, x, y, width, height);
-   ctx->NewState |= _NEW_TEXTURE;
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
+      yoffset += texImage->Border;
+      
+      ASSERT(ctx->Driver.CopyTexSubImage2D);
+      (*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
+				       xoffset, yoffset, x, y, width, height);
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -2887,6 +2989,7 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level,
                          GLint x, GLint y, GLsizei width, GLsizei height )
 {
    struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
    GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
@@ -2903,19 +3006,30 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level,
       return;
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   ASSERT(texImage);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
-   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
-   xoffset += texImage->Border;
-   yoffset += texImage->Border;
-   zoffset += texImage->Border;
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-   ASSERT(ctx->Driver.CopyTexSubImage3D);
-   (*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
-                                    xoffset, yoffset, zoffset,
-                                    x, y, width, height);
-   ctx->NewState |= _NEW_TEXTURE;
+      if (copytexsubimage_error_check2(ctx, 3, target, level, xoffset, yoffset,
+				       zoffset, postConvWidth, postConvHeight,
+				       texImage))
+	 goto out;
+
+      /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+      xoffset += texImage->Border;
+      yoffset += texImage->Border;
+      zoffset += texImage->Border;
+      
+      ASSERT(ctx->Driver.CopyTexSubImage3D);
+      (*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
+				       xoffset, yoffset, zoffset,
+				       x, y, width, height);
+      ctx->NewState |= _NEW_TEXTURE;
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -3136,28 +3250,35 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level,
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
 
-      _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
-                                 border, internalFormat);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1D");
+	    goto out;
+	 }
+	 
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
+	 ASSERT(texImage->Data == NULL);
+
+	 _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
+				    border, internalFormat);
 
-      ASSERT(ctx->Driver.CompressedTexImage1D);
-      (*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
-                                          internalFormat, width, border,
-                                          imageSize, data,
-                                          texObj, texImage);
+	 ASSERT(ctx->Driver.CompressedTexImage1D);
+	 (*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
+					     internalFormat, width, border,
+					     imageSize, data,
+					     texObj, texImage);
 
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
       /* Proxy texture: check for errors and update proxy state */
@@ -3179,11 +3300,18 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level,
       else {
          /* store the teximage parameters */
          struct gl_texture_unit *texUnit;
+         struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
          texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-         _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
-                                    border, internalFormat);
+	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+	 _mesa_lock_texture(ctx, texObj);
+	 {
+	    texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+	    _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
+				       border, internalFormat);
+	 }
+	 _mesa_unlock_texture(ctx, texObj);
       }
    }
    else {
@@ -3219,28 +3347,35 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level,
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
 
-      _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
-                                 border, internalFormat);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
+	    goto out;
+	 }
+	 
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
+	 ASSERT(texImage->Data == NULL);
 
-      ASSERT(ctx->Driver.CompressedTexImage2D);
-      (*ctx->Driver.CompressedTexImage2D)(ctx, target, level,
-                                          internalFormat, width, height,
-                                          border, imageSize, data,
-                                          texObj, texImage);
+	 _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+				    border, internalFormat);
 
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+	 ASSERT(ctx->Driver.CompressedTexImage2D);
+	 (*ctx->Driver.CompressedTexImage2D)(ctx, target, level,
+					     internalFormat, width, height,
+					     border, imageSize, data,
+					     texObj, texImage);
+	 
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_2D ||
             (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB &&
@@ -3264,11 +3399,18 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level,
       else {
          /* store the teximage parameters */
          struct gl_texture_unit *texUnit;
+         struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
          texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-         _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
-                                    border, internalFormat);
+	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+	 _mesa_lock_texture(ctx, texObj);
+	 {
+	    texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+	    _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+				       border, internalFormat);
+	 }
+	 _mesa_unlock_texture(ctx, texObj);
       }
    }
    else {
@@ -3301,29 +3443,35 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level,
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
-      texImage = _mesa_get_tex_image(ctx, texUnit, target, level);
-      if (!texImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3D");
-         return;
-      }
-      else if (texImage->Data) {
-	 ctx->Driver.FreeTexImageData( ctx, texImage );
-      }
-      ASSERT(texImage->Data == NULL);
-
-      _mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
-                                 border, internalFormat);
+      _mesa_lock_texture(ctx, texObj);
+      {
+	 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
+	 if (!texImage) {
+	    _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3D");
+	    goto out;
+	 }
+	 
+	 if (texImage->Data) {
+	    ctx->Driver.FreeTexImageData( ctx, texImage );
+	 }
+	 ASSERT(texImage->Data == NULL);
 
-      ASSERT(ctx->Driver.CompressedTexImage3D);
-      (*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
-                                          internalFormat,
-                                          width, height, depth,
-                                          border, imageSize, data,
-                                          texObj, texImage);
+	 _mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
+				    border, internalFormat);
 
-      /* state update */
-      texObj->Complete = GL_FALSE;
-      ctx->NewState |= _NEW_TEXTURE;
+	 ASSERT(ctx->Driver.CompressedTexImage3D);
+	 (*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
+					     internalFormat,
+					     width, height, depth,
+					     border, imageSize, data,
+					     texObj, texImage);
+	 
+	 /* state update */
+	 texObj->Complete = GL_FALSE;
+	 ctx->NewState |= _NEW_TEXTURE;
+      }
+   out:
+      _mesa_unlock_texture(ctx, texObj);
    }
    else if (target == GL_PROXY_TEXTURE_3D) {
       /* Proxy texture: check for errors and update proxy state */
@@ -3345,11 +3493,17 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level,
       else {
          /* store the teximage parameters */
          struct gl_texture_unit *texUnit;
+         struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
          texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-         _mesa_init_teximage_fields(ctx, target, texImage, width, height,
-                                    depth, border, internalFormat);
+	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
+	 _mesa_lock_texture(ctx, texObj);
+	 {
+	    texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+	    _mesa_init_teximage_fields(ctx, target, texImage, width, height,
+				       depth, border, internalFormat);
+	 }
+	 _mesa_unlock_texture(ctx, texObj);
       }
    }
    else {
@@ -3382,30 +3536,35 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      assert(texImage);
 
-   if ((GLint) format != texImage->InternalFormat) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCompressedTexSubImage1D(format)");
-      return;
-   }
+      if ((GLint) format != texImage->InternalFormat) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION,
+		     "glCompressedTexSubImage1D(format)");
+	 goto out;
+      }
 
-   if ((width == 1 || width == 2) && (GLuint) width != texImage->Width) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage1D(width)");
-      return;
-   }
+      if ((width == 1 || width == 2) && (GLuint) width != texImage->Width) {
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage1D(width)");
+	 goto out;
+      }
       
-   if (width == 0)
-      return;  /* no-op, not an error */
+      if (width == 0)
+	 goto out;  /* no-op, not an error */
 
-   if (ctx->Driver.CompressedTexSubImage1D) {
-      (*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
-                                             xoffset, width,
-                                             format, imageSize, data,
-                                             texObj, texImage);
+      if (ctx->Driver.CompressedTexSubImage1D) {
+	 (*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
+						xoffset, width,
+						format, imageSize, data,
+						texObj, texImage);
+      }
+      ctx->NewState |= _NEW_TEXTURE;
    }
-   ctx->NewState |= _NEW_TEXTURE;
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -3434,31 +3593,36 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      assert(texImage);
 
-   if ((GLint) format != texImage->InternalFormat) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCompressedTexSubImage2D(format)");
-      return;
-   }
+      if ((GLint) format != texImage->InternalFormat) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION,
+		     "glCompressedTexSubImage2D(format)");
+	 goto out;
+      }
 
-   if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
-       ((height == 1 || height == 2) && (GLuint) height != texImage->Height)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage2D(size)");
-      return;
-   }
+      if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
+	  ((height == 1 || height == 2) && (GLuint) height != texImage->Height)) {
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage2D(size)");
+	 goto out;
+      }
       
-   if (width == 0 || height == 0)
-      return;  /* no-op, not an error */
+      if (width == 0 || height == 0)
+	 goto out;  /* no-op, not an error */
 
-   if (ctx->Driver.CompressedTexSubImage2D) {
-      (*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
-                                             xoffset, yoffset, width, height,
-                                             format, imageSize, data,
-                                             texObj, texImage);
+      if (ctx->Driver.CompressedTexSubImage2D) {
+	 (*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
+						xoffset, yoffset, width, height,
+						format, imageSize, data,
+						texObj, texImage);
+      }
+      ctx->NewState |= _NEW_TEXTURE;
    }
-   ctx->NewState |= _NEW_TEXTURE;
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -3486,33 +3650,38 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   assert(texImage);
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      assert(texImage);
 
-   if ((GLint) format != texImage->InternalFormat) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCompressedTexSubImage3D(format)");
-      return;
-   }
+      if ((GLint) format != texImage->InternalFormat) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION,
+		     "glCompressedTexSubImage3D(format)");
+	 goto out;
+      }
 
-   if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
-       ((height == 1 || height == 2) && (GLuint) height != texImage->Height) ||
-       ((depth == 1 || depth == 2) && (GLuint) depth != texImage->Depth)) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage3D(size)");
-      return;
-   }
+      if (((width == 1 || width == 2) && (GLuint) width != texImage->Width) ||
+	  ((height == 1 || height == 2) && (GLuint) height != texImage->Height) ||
+	  ((depth == 1 || depth == 2) && (GLuint) depth != texImage->Depth)) {
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glCompressedTexSubImage3D(size)");
+	 goto out;
+      }
       
-   if (width == 0 || height == 0 || depth == 0)
-      return;  /* no-op, not an error */
+      if (width == 0 || height == 0 || depth == 0)
+	 goto out;  /* no-op, not an error */
 
-   if (ctx->Driver.CompressedTexSubImage3D) {
-      (*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
-                                             xoffset, yoffset, zoffset,
-                                             width, height, depth,
-                                             format, imageSize, data,
-                                             texObj, texImage);
+      if (ctx->Driver.CompressedTexSubImage3D) {
+	 (*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
+						xoffset, yoffset, zoffset,
+						width, height, depth,
+						format, imageSize, data,
+						texObj, texImage);
+      }
+      ctx->NewState |= _NEW_TEXTURE;
    }
-   ctx->NewState |= _NEW_TEXTURE;
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }
 
 
@@ -3520,12 +3689,13 @@ void GLAPIENTRY
 _mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
 {
    const struct gl_texture_unit *texUnit;
-   const struct gl_texture_object *texObj;
+   struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
    GLint maxLevels;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    if (!texObj) {
@@ -3546,18 +3716,24 @@ _mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
       return;
    }
 
-   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
-   if (!texImage) {
-      /* probably invalid mipmap level */
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
-      return;
-   }
 
-   if (!texImage->IsCompressed) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
-      return;
-   }
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      if (!texImage) {
+	 /* probably invalid mipmap level */
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
+	 goto out;
+      }
+
+      if (!texImage->IsCompressed) {
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
+	 goto out;
+      }
 
-   /* this typically calls _mesa_get_compressed_teximage() */
-   ctx->Driver.GetCompressedTexImage(ctx, target, level, img, texObj,texImage);
+      /* this typically calls _mesa_get_compressed_teximage() */
+      ctx->Driver.GetCompressedTexImage(ctx, target, level, img, texObj,texImage);
+   }
+ out:
+   _mesa_unlock_texture(ctx, texObj);
 }