st_cb_texture.c File Reference

Include dependency graph for st_cb_texture.c:

Go to the source code of this file.

Defines
#define	DBG   if (0) printf
#define	__memcpy(a, b, c)   memcpy(a,b,c)
	From linux kernel i386 header files, copes with odd sizes better than COPY_DWORDS would: XXX Put this in src/mesa/main/imports.h ???
Functions
static enum pipe_texture_target	gl_target_to_pipe (GLenum target)
static int	compressed_num_bytes (GLuint mesaFormat)
	Return nominal bytes per texel for a compressed format, 0 for non-compressed format.
static struct gl_texture_image *	st_NewTextureImage (GLcontext *ctx)
	called via ctx->Driver.NewTextureImage()
static struct gl_texture_object *	st_NewTextureObject (GLcontext *ctx, GLuint name, GLenum target)
	called via ctx->Driver.NewTextureObject()
static void	st_DeleteTextureObject (GLcontext *ctx, struct gl_texture_object *texObj)
	called via ctx->Driver.DeleteTextureImage()
static void	st_FreeTextureImageData (GLcontext *ctx, struct gl_texture_image *texImage)
	called via ctx->Driver.FreeTexImageData()
static void *	do_memcpy (void *dest, const void *src, size_t n)
	The system memcpy (at least on ubuntu 5.10) has problems copying to agp (writecombined) memory from a source which isn't 64-byte aligned - there is a 4x performance falloff.
static int	logbase2 (int n)
static void	guess_and_alloc_texture (struct st_context *st, struct st_texture_object *stObj, const struct st_texture_image *stImage)
	Allocate a pipe_texture object for the given st_texture_object using the given st_texture_image to guess the mipmap size/levels.
static void	strip_texture_border (GLint border, GLint *width, GLint *height, GLint *depth, const struct gl_pixelstore_attrib *unpack, struct gl_pixelstore_attrib *unpackNew)
	Adjust pixel unpack params and image dimensions to strip off the texture border.
static void	st_TexImage (GLcontext *ctx, GLint dims, GLenum target, GLint level, GLint internalFormat, GLint width, GLint height, GLint depth, GLint border, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *unpack, struct gl_texture_object *texObj, struct gl_texture_image *texImage, GLsizei imageSize, int compressed)
	Do glTexImage1/2/3D().
static void	st_TexImage3D (GLcontext *ctx, GLenum target, GLint level, GLint internalFormat, GLint width, GLint height, GLint depth, GLint border, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *unpack, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_TexImage2D (GLcontext *ctx, GLenum target, GLint level, GLint internalFormat, GLint width, GLint height, GLint border, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *unpack, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_TexImage1D (GLcontext *ctx, GLenum target, GLint level, GLint internalFormat, GLint width, GLint border, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *unpack, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_CompressedTexImage2D (GLcontext *ctx, GLenum target, GLint level, GLint internalFormat, GLint width, GLint height, GLint border, GLsizei imageSize, const GLvoid *data, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_get_tex_image (GLcontext *ctx, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels, struct gl_texture_object *texObj, struct gl_texture_image *texImage, int compressed)
	Need to map texture image into memory before copying image data, then unmap it.
static void	st_GetTexImage (GLcontext *ctx, GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_GetCompressedTexImage (GLcontext *ctx, GLenum target, GLint level, GLvoid *pixels, const struct gl_texture_object *texObj, const struct gl_texture_image *texImage)
static void	st_TexSubimage (GLcontext *ctx, GLint dims, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint width, GLint height, GLint depth, GLenum format, GLenum type, const void *pixels, const struct gl_pixelstore_attrib *packing, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_TexSubImage3D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels, const struct gl_pixelstore_attrib *packing, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_TexSubImage2D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, const struct gl_pixelstore_attrib *packing, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static void	st_TexSubImage1D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels, const struct gl_pixelstore_attrib *packing, struct gl_texture_object *texObj, struct gl_texture_image *texImage)
static uint	texture_face (GLenum target)
	Return 0 for GL_TEXTURE_CUBE_MAP_POSITIVE_X, 1 for GL_TEXTURE_CUBE_MAP_NEGATIVE_X, etc.
static void	fallback_copy_texsubimage (GLcontext *ctx, GLenum target, GLint level, struct st_renderbuffer *strb, struct st_texture_image *stImage, GLenum baseFormat, GLint destX, GLint destY, GLint destZ, GLint srcX, GLint srcY, GLsizei width, GLsizei height)
	Do a CopyTexSubImage operation by mapping the source surface and dest surface and using get_tile()/put_tile() to access the pixels/texels.
static void	st_copy_texsubimage (GLcontext *ctx, GLenum target, GLint level, GLint destX, GLint destY, GLint destZ, GLint srcX, GLint srcY, GLsizei width, GLsizei height)
	Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.
static void	st_CopyTexImage1D (GLcontext *ctx, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
static void	st_CopyTexImage2D (GLcontext *ctx, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
static void	st_CopyTexSubImage1D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
static void	st_CopyTexSubImage2D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
static void	st_CopyTexSubImage3D (GLcontext *ctx, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
static void	calculate_first_last_level (struct st_texture_object *stObj)
	Compute which mipmap levels that really need to be sent to the hardware.
static void	copy_image_data_to_texture (struct st_context *st, struct st_texture_object *stObj, GLuint dstLevel, struct st_texture_image *stImage)
GLboolean	st_finalize_texture (GLcontext *ctx, struct pipe_context *pipe, struct gl_texture_object *tObj, GLboolean *needFlush)
	Called during state validation.
struct gl_texture_object *	st_get_default_texture (struct st_context *st)
	Returns pointer to a default/dummy texture.
void	st_init_texture_functions (struct dd_function_table *functions)

---

Define Documentation

#define __memcpy	(	a,
		b,
		c		)	memcpy(a,b,c)

From linux kernel i386 header files, copes with odd sizes better than COPY_DWORDS would: XXX Put this in src/mesa/main/imports.h ???

Definition at line 187 of file st_cb_texture.c.

#define DBG   if (0) printf

Definition at line 58 of file st_cb_texture.c.

---

Function Documentation

static void calculate_first_last_level

(

struct st_texture_object *

stObj

)

[static]

Compute which mipmap levels that really need to be sent to the hardware.

This depends on the base image size, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.

Definition at line 1277 of file st_cb_texture.c.

References st_texture_object::base, st_texture_object::lastLevel, and MIN2.

{
   struct gl_texture_object *tObj = &stObj->base;

   /* These must be signed values.  MinLod and MaxLod can be negative numbers,
    * and having firstLevel and lastLevel as signed prevents the need for
    * extra sign checks.
    */
   int firstLevel;
   int lastLevel;

   /* Yes, this looks overly complicated, but it's all needed.
    */
   switch (tObj->Target) {
   case GL_TEXTURE_1D:
   case GL_TEXTURE_2D:
   case GL_TEXTURE_3D:
   case GL_TEXTURE_CUBE_MAP:
      if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
         /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
          */
         firstLevel = lastLevel = tObj->BaseLevel;
      }
      else {
         firstLevel = 0;
         lastLevel = MIN2(tObj->MaxLevel,
                          (int) tObj->Image[0][tObj->BaseLevel]->WidthLog2);
      }
      break;
   case GL_TEXTURE_RECTANGLE_NV:
   case GL_TEXTURE_4D_SGIS:
      firstLevel = lastLevel = 0;
      break;
   default:
      return;
   }

   stObj->lastLevel = lastLevel;
}

static int compressed_num_bytes

(

GLuint

mesaFormat

)

[static]

Return nominal bytes per texel for a compressed format, 0 for non-compressed format.

Definition at line 90 of file st_cb_texture.c.

{
   switch(mesaFormat) {
#if FEATURE_texture_fxt1
   case MESA_FORMAT_RGB_FXT1:
   case MESA_FORMAT_RGBA_FXT1:
#endif
#if FEATURE_texture_s3tc
   case MESA_FORMAT_RGB_DXT1:
   case MESA_FORMAT_RGBA_DXT1:
      return 2;
   case MESA_FORMAT_RGBA_DXT3:
   case MESA_FORMAT_RGBA_DXT5:
      return 4;
#endif
   default:
      return 0;
   }
}

static void copy_image_data_to_texture	(	struct st_context *	st,
		struct st_texture_object *	stObj,
		GLuint	dstLevel,
		struct st_texture_image *	stImage
	)			[static]

Definition at line 1319 of file st_cb_texture.c.

References assert, st_texture_image::base, pipe_texture::block, st_texture_image::face, st_context::pipe, pipe_texture_reference(), st_texture_object::pt, st_texture_image::pt, pipe_format_block::size, st_texture_image_copy(), and st_texture_image_data().

{
   if (stImage->pt) {
      /* Copy potentially with the blitter:
       */
      st_texture_image_copy(st->pipe,
                            stObj->pt, dstLevel,  /* dest texture, level */
                            stImage->pt, /* src texture */
                            stImage->face
                            );

      pipe_texture_reference(&stImage->pt, NULL);
   }
   else if (stImage->base.Data) {
      assert(stImage->base.Data != NULL);

      /* More straightforward upload.  
       */
      st_texture_image_data(st->pipe,
                               stObj->pt,
                               stImage->face,
                               dstLevel,
                               stImage->base.Data,
                               stImage->base.RowStride * 
                               stObj->pt->block.size,
                               stImage->base.RowStride *
                               stImage->base.Height *
                               stObj->pt->block.size);
      _mesa_align_free(stImage->base.Data);
      stImage->base.Data = NULL;
   }

   pipe_texture_reference(&stImage->pt, stObj->pt);
}

static void* do_memcpy	(	void *	dest,
		const void *	src,
		size_t	n
	)			[static]

The system memcpy (at least on ubuntu 5.10) has problems copying to agp (writecombined) memory from a source which isn't 64-byte aligned - there is a 4x performance falloff.

The x86 __memcpy is immune to this but is slightly slower (10-ish) than the system memcpy.

The sse_memcpy seems to have a slight cliff at 64/32 bytes, but isn't much faster than x86_memcpy for agp copies.

TODO: switch dynamically.

Definition at line 205 of file st_cb_texture.c.

References __memcpy.

{
   if ((((unsigned) src) & 63) || (((unsigned) dest) & 63)) {
      return __memcpy(dest, src, n);
   }
   else
      return memcpy(dest, src, n);
}

static void fallback_copy_texsubimage	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		struct st_renderbuffer *	strb,
		struct st_texture_image *	stImage,
		GLenum	baseFormat,
		GLint	destX,
		GLint	destY,
		GLint	destZ,
		GLint	srcX,
		GLint	srcY,
		GLsizei	width,
		GLsizei	height
	)			[static]

Do a CopyTexSubImage operation by mapping the source surface and dest surface and using get_tile()/put_tile() to access the pixels/texels.

Note: srcY=0=TOP of renderbuffer

Definition at line 925 of file st_cb_texture.c.

References assert, st_texture_image::base, st_renderbuffer::Base, pipe_screen::get_tex_surface, MAX_WIDTH, PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, pipe_get_tile_rgba(), pipe_get_tile_z(), pipe_put_tile_z(), st_texture_image::pt, pipe_context::screen, st_fb_orientation(), st_texture_image_map(), st_texture_image_unmap(), pipe_surface::stride, st_texture_image::surface, pipe_screen::tex_surface_release, st_renderbuffer::texture, texture_face(), and Y_0_TOP.

{
   struct pipe_context *pipe = ctx->st->pipe;
   struct pipe_screen *screen = pipe->screen;
   const uint face = texture_face(target);
   struct pipe_texture *pt = stImage->pt;
   struct pipe_surface *src_surf, *dest_surf;

   /* We'd use strb->surface, here but it's created for GPU read/write only */
   src_surf = pipe->screen->get_tex_surface( pipe->screen,
                                             strb->texture,
                                             0, 0, 0,
                                             PIPE_BUFFER_USAGE_CPU_READ);

   dest_surf = screen->get_tex_surface(screen, pt, face, level, destZ,
                                       PIPE_BUFFER_USAGE_CPU_WRITE);

   assert(width <= MAX_WIDTH);

   if (baseFormat == GL_DEPTH_COMPONENT) {
      const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F ||
                                     ctx->Pixel.DepthBias != 0.0F);
      GLint row, yStep;

      /* determine bottom-to-top vs. top-to-bottom order for src buffer */
      if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
         srcY = strb->Base.Height - 1 - srcY;
         yStep = -1;
      }
      else {
         yStep = 1;
      }

      /* To avoid a large temp memory allocation, do copy row by row */
      for (row = 0; row < height; row++, srcY += yStep, destY++) {
         uint data[MAX_WIDTH];
         pipe_get_tile_z(src_surf, srcX, srcY, width, 1, data);
         if (scaleOrBias) {
            _mesa_scale_and_bias_depth_uint(ctx, width, data);
         }
         pipe_put_tile_z(dest_surf, destX, destY, width, 1, data);
      }
   }
   else {
      /* RGBA format */
      GLfloat *tempSrc =
         (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
      GLvoid *texDest =
         st_texture_image_map(ctx->st, stImage, 0,PIPE_BUFFER_USAGE_CPU_WRITE);

      if (tempSrc && texDest) {
         const GLint dims = 2;
         struct gl_texture_image *texImage = &stImage->base;
         GLint dstRowStride = stImage->surface->stride;
         struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;

         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
            /* need to invert src */
            srcY = strb->Base.Height - srcY - height;
            unpack.Invert = GL_TRUE;
         }

         /* get float/RGBA image from framebuffer */
         /* XXX this usually involves a lot of int/float conversion.
          * try to avoid that someday.
          */
         pipe_get_tile_rgba(src_surf, srcX, srcY, width, height, tempSrc);

         /* Store into texture memory.
          * Note that this does some special things such as pixel transfer
          * ops and format conversion.  In particular, if the dest tex format
          * is actually RGBA but the user created the texture as GL_RGB we
          * need to fill-in/override the alpha channel with 1.0.
          */
         texImage->TexFormat->StoreImage(ctx, dims,
                                         texImage->_BaseFormat, 
                                         texImage->TexFormat, 
                                         texDest,
                                         destX, destY, destZ,
                                         dstRowStride,
                                         texImage->ImageOffsets,
                                         width, height, 1,
                                         GL_RGBA, GL_FLOAT, tempSrc, /* src */
                                         &unpack);
      }
      else {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
      }

      if (tempSrc)
         _mesa_free(tempSrc);
      if (texDest)
         st_texture_image_unmap(ctx->st, stImage);
   }

   screen->tex_surface_release(screen, &dest_surf);
   screen->tex_surface_release(screen, &src_surf);
}

static enum pipe_texture_target gl_target_to_pipe

(

GLenum

target

)

[static]

Definition at line 62 of file st_cb_texture.c.

References assert, PIPE_TEXTURE_1D, PIPE_TEXTURE_2D, PIPE_TEXTURE_3D, and PIPE_TEXTURE_CUBE.

{
   switch (target) {
   case GL_TEXTURE_1D:
      return PIPE_TEXTURE_1D;

   case GL_TEXTURE_2D:
   case GL_TEXTURE_RECTANGLE_NV:
      return PIPE_TEXTURE_2D;

   case GL_TEXTURE_3D:
      return PIPE_TEXTURE_3D;

   case GL_TEXTURE_CUBE_MAP_ARB:
      return PIPE_TEXTURE_CUBE;

   default:
      assert(0);
      return 0;
   }
}

static void guess_and_alloc_texture	(	struct st_context *	st,
		struct st_texture_object *	stObj,
		const struct st_texture_image *	stImage
	)			[static]

Allocate a pipe_texture object for the given st_texture_object using the given st_texture_image to guess the mipmap size/levels.

[comments...] Otherwise, store it in memory if (Border != 0) or (any dimension == 1).

Otherwise, if max_level >= level >= min_level, create texture with space for images from min_level down to max_level.

Otherwise, create texture with space for images from (level 0)..(1x1). Consider pruning this texture at a validation if the saving is worth it.

Definition at line 242 of file st_cb_texture.c.

References assert, st_texture_object::base, st_texture_image::base, compressed_num_bytes(), DBG, gl_target_to_pipe(), st_texture_image::level, logbase2(), MAX2, pf_is_depth_stencil(), PIPE_TEXTURE_USAGE_DEPTH_STENCIL, PIPE_TEXTURE_USAGE_RENDER_TARGET, PIPE_TEXTURE_USAGE_SAMPLER, st_texture_object::pt, st_mesa_format_to_pipe_format(), and st_texture_create().

{
   GLuint firstLevel;
   GLuint lastLevel;
   GLuint width = stImage->base.Width2;  /* size w/out border */
   GLuint height = stImage->base.Height2;
   GLuint depth = stImage->base.Depth2;
   GLuint i, comp_byte = 0;
   enum pipe_format fmt;

   DBG("%s\n", __FUNCTION__);

   assert(!stObj->pt);

   if (stObj->pt &&
       (GLint) stImage->level > stObj->base.BaseLevel &&
       (stImage->base.Width == 1 ||
        (stObj->base.Target != GL_TEXTURE_1D &&
         stImage->base.Height == 1) ||
        (stObj->base.Target == GL_TEXTURE_3D &&
         stImage->base.Depth == 1)))
      return;

   /* If this image disrespects BaseLevel, allocate from level zero.
    * Usually BaseLevel == 0, so it's unlikely to happen.
    */
   if ((GLint) stImage->level < stObj->base.BaseLevel)
      firstLevel = 0;
   else
      firstLevel = stObj->base.BaseLevel;


   /* Figure out image dimensions at start level. 
    */
   for (i = stImage->level; i > firstLevel; i--) {
      if (width != 1)
         width <<= 1;
      if (height != 1)
         height <<= 1;
      if (depth != 1)
         depth <<= 1;
   }

   if (width == 0 || height == 0 || depth == 0) {
      /* no texture needed */
      return;
   }

   /* Guess a reasonable value for lastLevel.  This is probably going
    * to be wrong fairly often and might mean that we have to look at
    * resizable buffers, or require that buffers implement lazy
    * pagetable arrangements.
    */
   if ((stObj->base.MinFilter == GL_NEAREST ||
        stObj->base.MinFilter == GL_LINEAR) &&
       stImage->level == firstLevel) {
      lastLevel = firstLevel;
   }
   else {
      GLuint l2width = logbase2(width);
      GLuint l2height = logbase2(height);
      GLuint l2depth = logbase2(depth);
      lastLevel = firstLevel + MAX2(MAX2(l2width, l2height), l2depth);
   }

   if (stImage->base.IsCompressed)
      comp_byte = compressed_num_bytes(stImage->base.TexFormat->MesaFormat);

   fmt = st_mesa_format_to_pipe_format(stImage->base.TexFormat->MesaFormat);
   stObj->pt = st_texture_create(st,
                                 gl_target_to_pipe(stObj->base.Target),
                                 fmt,
                                 lastLevel,
                                 width,
                                 height,
                                 depth,
                                 comp_byte,
                                 ( (pf_is_depth_stencil(fmt) ?
                                   PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
                                   PIPE_TEXTURE_USAGE_RENDER_TARGET) |
                                   PIPE_TEXTURE_USAGE_SAMPLER ));

   DBG("%s - success\n", __FUNCTION__);
}

static int logbase2

(

int

n

)

[static]

Definition at line 216 of file st_cb_texture.c.

{
   GLint i = 1, log2 = 0;
   while (n > i) {
      i *= 2;
      log2++;
   }
   return log2;
}

static void st_CompressedTexImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLint	width,
		GLint	height,
		GLint	border,
		GLsizei	imageSize,
		const GLvoid *	data,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 653 of file st_cb_texture.c.

References st_TexImage().

{
   st_TexImage(ctx, 2, target, level,
                 internalFormat, width, height, 1, border,
                 0, 0, data, &ctx->Unpack, texObj, texImage, imageSize, 1);
}

static void st_copy_texsubimage	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	destX,
		GLint	destY,
		GLint	destZ,
		GLint	srcX,
		GLint	srcY,
		GLsizei	width,
		GLsizei	height
	)			[static]

Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible.

Note that the region to copy has already been clipped so we know we won't read from outside the source renderbuffer's bounds.

Note: srcY=0=Bottom of renderbuffer (GL convention)

Definition at line 1041 of file st_cb_texture.c.

References assert, st_renderbuffer::Base, st_texture_image::face, fallback_copy_texsubimage(), pipe_texture::format, pipe_surface::format, pipe_screen::get_tex_surface, pipe_surface::height, pipe_screen::is_format_supported, st_texture_image::level, PIPE_BUFFER_USAGE_GPU_WRITE, pipe_surface_reference(), PIPE_TEX_MIPFILTER_NEAREST, PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_RENDER_TARGET, PIPE_TEXTURE_USAGE_SAMPLER, st_texture_image::pt, pipe_context::screen, st_fb_orientation(), st_finish(), st_renderbuffer(), st_texture_image(), st_renderbuffer::surface, pipe_context::surface_copy, util_blit_pixels(), and Y_0_TOP.

{
   struct gl_texture_unit *texUnit =
      &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
   struct gl_texture_object *texObj =
      _mesa_select_tex_object(ctx, texUnit, target);
   struct gl_texture_image *texImage =
      _mesa_select_tex_image(ctx, texObj, target, level);
   struct st_texture_image *stImage = st_texture_image(texImage);
   const GLenum texBaseFormat = texImage->InternalFormat;
   struct gl_framebuffer *fb = ctx->ReadBuffer;
   struct st_renderbuffer *strb;
   struct pipe_context *pipe = ctx->st->pipe;
   struct pipe_screen *screen = pipe->screen;
   enum pipe_format dest_format, src_format;
   GLboolean use_fallback = GL_TRUE;
   GLboolean matching_base_formats;

   /* any rendering in progress must complete before we grab the fb image */
   st_finish(ctx->st);

   /* determine if copying depth or color data */
   if (texBaseFormat == GL_DEPTH_COMPONENT) {
      strb = st_renderbuffer(fb->_DepthBuffer);
   }
   else if (texBaseFormat == GL_DEPTH_STENCIL_EXT) {
      strb = st_renderbuffer(fb->_StencilBuffer);
   }
   else {
      /* texBaseFormat == GL_RGB, GL_RGBA, GL_ALPHA, etc */
      strb = st_renderbuffer(fb->_ColorReadBuffer);
   }

   assert(strb);
   assert(strb->surface);
   assert(stImage->pt);

   src_format = strb->surface->format;
   dest_format = stImage->pt->format;

   /*
    * Determine if the src framebuffer and dest texture have the same
    * base format.  We need this to detect a case such as the framebuffer
    * being GL_RGBA but the texture being GL_RGB.  If the actual hardware
    * texture format stores RGBA we need to set A=1 (overriding the
    * framebuffer's alpha values).  We can't do that with the blit or
    * textured-quad paths.
    */
   matching_base_formats = (strb->Base._BaseFormat == texImage->_BaseFormat);

   if (matching_base_formats && ctx->_ImageTransferState == 0x0) {
      /* try potential hardware path */
      struct pipe_surface *dest_surface = NULL;

      if (src_format == dest_format) {
         /* use surface_copy() / blit */
         boolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);

         dest_surface = screen->get_tex_surface(screen, stImage->pt,
                                                stImage->face, stImage->level,
                                                destZ,
                                                PIPE_BUFFER_USAGE_GPU_WRITE);
         if (do_flip)
            srcY = strb->surface->height - srcY - height;

         /* for surface_copy(), y=0=top, always */
         pipe->surface_copy(pipe,
                            do_flip,
                            /* dest */
                            dest_surface,
                            destX, destY,
                            /* src */
                            strb->surface,
                            srcX, srcY,
                            /* size */
                            width, height);
         use_fallback = GL_FALSE;
      }
      else if (screen->is_format_supported(screen, src_format,
                                           PIPE_TEXTURE_2D, 
                                           PIPE_TEXTURE_USAGE_SAMPLER,
                                           0) &&
               screen->is_format_supported(screen, dest_format,
                                           PIPE_TEXTURE_2D, 
                                           PIPE_TEXTURE_USAGE_RENDER_TARGET,
                                           0)) {
         /* draw textured quad to do the copy */
         boolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP);
         int srcY0, srcY1;

         dest_surface = screen->get_tex_surface(screen, stImage->pt,
                                                stImage->face, stImage->level,
                                                destZ,
                                                PIPE_BUFFER_USAGE_GPU_WRITE);

         if (do_flip) {
            srcY1 = strb->Base.Height - srcY - height;
            srcY0 = srcY1 + height;
         }
         else {
            srcY0 = srcY;
            srcY1 = srcY0 + height;
         }
         util_blit_pixels(ctx->st->blit,
                          strb->surface,
                          srcX, srcY0,
                          srcX + width, srcY1,
                          dest_surface,
                          destX, destY,
                          destX + width, destY + height,
                          0.0, PIPE_TEX_MIPFILTER_NEAREST);
         use_fallback = GL_FALSE;
      }

      if (dest_surface)
         pipe_surface_reference(&dest_surface, NULL);
   }

   if (use_fallback) {
      /* software fallback */
      fallback_copy_texsubimage(ctx, target, level,
                                strb, stImage, texBaseFormat,
                                destX, destY, destZ,
                                srcX, srcY, width, height);
   }

   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
      ctx->Driver.GenerateMipmap(ctx, target, texObj);
   }
}

static void st_CopyTexImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	internalFormat,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLint	border
	)			[static]

Definition at line 1179 of file st_cb_texture.c.

References st_copy_texsubimage().

{
   struct gl_texture_unit *texUnit =
      &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
   struct gl_texture_object *texObj =
      _mesa_select_tex_object(ctx, texUnit, target);
   struct gl_texture_image *texImage =
      _mesa_select_tex_image(ctx, texObj, target, level);

#if 0
   if (border)
      goto fail;
#endif

   /* Setup or redefine the texture object, texture and texture
    * image.  Don't populate yet.  
    */
   ctx->Driver.TexImage1D(ctx, target, level, internalFormat,
                          width, border,
                          GL_RGBA, CHAN_TYPE, NULL,
                          &ctx->DefaultPacking, texObj, texImage);

   st_copy_texsubimage(ctx, target, level,
                       0, 0, 0,  /* destX,Y,Z */
                       x, y, width, 1);  /* src X, Y, size */
}

static void st_CopyTexImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	internalFormat,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height,
		GLint	border
	)			[static]

Definition at line 1210 of file st_cb_texture.c.

References st_copy_texsubimage().

{
   struct gl_texture_unit *texUnit =
      &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
   struct gl_texture_object *texObj =
      _mesa_select_tex_object(ctx, texUnit, target);
   struct gl_texture_image *texImage =
      _mesa_select_tex_image(ctx, texObj, target, level);

   /* Setup or redefine the texture object, texture and texture
    * image.  Don't populate yet.  
    */
   ctx->Driver.TexImage2D(ctx, target, level, internalFormat,
                          width, height, border,
                          GL_RGBA, CHAN_TYPE, NULL,
                          &ctx->DefaultPacking, texObj, texImage);

   st_copy_texsubimage(ctx, target, level,
                       0, 0, 0,  /* destX,Y,Z */
                       x, y, width, height);  /* src X, Y, size */
}

static void st_CopyTexSubImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	x,
		GLint	y,
		GLsizei	width
	)			[static]

Definition at line 1237 of file st_cb_texture.c.

References st_copy_texsubimage().

{
   const GLint yoffset = 0, zoffset = 0;
   const GLsizei height = 1;
   st_copy_texsubimage(ctx, target, level,
                       xoffset, yoffset, zoffset,  /* destX,Y,Z */
                       x, y, width, height);  /* src X, Y, size */
}

static void st_CopyTexSubImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height
	)			[static]

Definition at line 1249 of file st_cb_texture.c.

References st_copy_texsubimage().

{
   const GLint zoffset = 0;
   st_copy_texsubimage(ctx, target, level,
                       xoffset, yoffset, zoffset,  /* destX,Y,Z */
                       x, y, width, height);  /* src X, Y, size */
}

static void st_CopyTexSubImage3D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLint	zoffset,
		GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height
	)			[static]

Definition at line 1261 of file st_cb_texture.c.

References st_copy_texsubimage().

{
   st_copy_texsubimage(ctx, target, level,
                       xoffset, yoffset, zoffset,  /* destX,Y,Z */
                       x, y, width, height);  /* src X, Y, size */
}

static void st_DeleteTextureObject	(	GLcontext *	ctx,
		struct gl_texture_object *	texObj
	)			[static]

called via ctx->Driver.DeleteTextureImage()

Definition at line 135 of file st_cb_texture.c.

References pipe_texture_reference(), st_texture_object::pt, and st_texture_object().

{
   struct st_texture_object *stObj = st_texture_object(texObj);
   if (stObj->pt)
      pipe_texture_reference(&stObj->pt, NULL);

   _mesa_delete_texture_object(ctx, texObj);
}

GLboolean st_finalize_texture	(	GLcontext *	ctx,
		struct pipe_context *	pipe,
		struct gl_texture_object *	tObj,
		GLboolean *	needFlush
	)

Called during state validation.

When this function is finished, the texture object should be ready for rendering.

Returns:

GL_TRUE for success, GL_FALSE for failure (out of mem)

Definition at line 1364 of file st_cb_texture.c.

References assert, st_texture_image::base, st_texture_object::base, pipe_texture::block, calculate_first_last_level(), pipe_texture::compressed, compressed_num_bytes(), copy_image_data_to_texture(), pipe_texture::depth, pipe_texture::format, gl_target_to_pipe(), pipe_format_block::height, pipe_texture::height, pipe_texture::last_level, st_texture_object::lastLevel, st_texture_image::level, pf_is_depth_stencil(), pipe_texture_reference(), pipe_texture_release(), PIPE_TEXTURE_USAGE_DEPTH_STENCIL, PIPE_TEXTURE_USAGE_RENDER_TARGET, PIPE_TEXTURE_USAGE_SAMPLER, st_texture_object::pt, st_texture_image::pt, pipe_format_block::size, st_mesa_format_to_pipe_format(), ST_NEW_FRAMEBUFFER, st_texture_create(), st_texture_image(), st_texture_object(), pipe_texture::target, pipe_format_block::width, and pipe_texture::width.

{
   struct st_texture_object *stObj = st_texture_object(tObj);
   const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   int comp_byte = 0;
   int cpp;
   GLuint face;
   struct st_texture_image *firstImage;

   *needFlush = GL_FALSE;

   /* We know/require this is true by now: 
    */
   assert(stObj->base._Complete);

   /* What levels must the texture include at a minimum?
    */
   calculate_first_last_level(stObj);
   firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);

   /* If both firstImage and stObj point to a texture which can contain
    * all active images, favour firstImage.  Note that because of the
    * completeness requirement, we know that the image dimensions
    * will match.
    */
   if (firstImage->pt &&
       firstImage->pt != stObj->pt &&
       firstImage->pt->last_level >= stObj->lastLevel) {

      pipe_texture_reference(&stObj->pt, firstImage->pt);
   }

   /* FIXME: determine format block instead of cpp */
   if (firstImage->base.IsCompressed) {
      comp_byte = compressed_num_bytes(firstImage->base.TexFormat->MesaFormat);
      cpp = comp_byte;
   }
   else {
      cpp = firstImage->base.TexFormat->TexelBytes;
   }

   /* If we already have a gallium texture, check that it matches the texture
    * object's format, target, size, num_levels, etc.
    */
   if (stObj->pt) {
      const enum pipe_format fmt =
         st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
      if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
          stObj->pt->format != fmt ||
          stObj->pt->last_level < stObj->lastLevel ||
          stObj->pt->width[0] != firstImage->base.Width2 ||
          stObj->pt->height[0] != firstImage->base.Height2 ||
          stObj->pt->depth[0] != firstImage->base.Depth2 ||
          stObj->pt->block.size != cpp ||
          stObj->pt->block.width != 1 ||
          stObj->pt->block.height != 1 ||
          stObj->pt->compressed != firstImage->base.IsCompressed) {
         pipe_texture_release(&stObj->pt);
         ctx->st->dirty.st |= ST_NEW_FRAMEBUFFER;
      }
   }

   /* May need to create a new gallium texture:
    */
   if (!stObj->pt) {
      const enum pipe_format fmt =
         st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
      stObj->pt = st_texture_create(ctx->st,
                                    gl_target_to_pipe(stObj->base.Target),
                                    fmt,
                                    stObj->lastLevel,
                                    firstImage->base.Width2,
                                    firstImage->base.Height2,
                                    firstImage->base.Depth2,
                                    comp_byte,
                                    ( (pf_is_depth_stencil(fmt) ?
                                      PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
                                      PIPE_TEXTURE_USAGE_RENDER_TARGET) |
                                      PIPE_TEXTURE_USAGE_SAMPLER ));

      if (!stObj->pt) {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
         return GL_FALSE;
      }
   }

   /* Pull in any images not in the object's texture:
    */
   for (face = 0; face < nr_faces; face++) {
      GLuint level;
      for (level = 0; level <= stObj->lastLevel; level++) {
         struct st_texture_image *stImage =
            st_texture_image(stObj->base.Image[face][stObj->base.BaseLevel + level]);

         /* Need to import images in main memory or held in other textures.
          */
         if (stImage && stObj->pt != stImage->pt) {
            copy_image_data_to_texture(ctx->st, stObj, level, stImage);
            *needFlush = GL_TRUE;
         }
      }
   }

   return GL_TRUE;
}

static void st_FreeTextureImageData	(	GLcontext *	ctx,
		struct gl_texture_image *	texImage
	)			[static]

called via ctx->Driver.FreeTexImageData()

Definition at line 148 of file st_cb_texture.c.

References DBG, pipe_texture_reference(), st_texture_image::pt, and st_texture_image().

{
   struct st_texture_image *stImage = st_texture_image(texImage);

   DBG("%s\n", __FUNCTION__);

   if (stImage->pt) {
      pipe_texture_reference(&stImage->pt, NULL);
   }

   if (texImage->Data) {
      _mesa_align_free(texImage->Data);
      texImage->Data = NULL;
   }
}

struct gl_texture_object* st_get_default_texture

(

struct st_context *

st

)

[read]

Returns pointer to a default/dummy texture.

This is typically used when the current shader has tex/sample instructions but the user has not provided a (any) texture(s).

Definition at line 1480 of file st_cb_texture.c.

References st_context::ctx, st_context::default_texture, and st_TexImage().

{
   if (!st->default_texture) {
      static const GLenum target = GL_TEXTURE_2D;
      GLubyte pixels[16][16][4];
      struct gl_texture_object *texObj;
      struct gl_texture_image *texImg;

      /* init image to gray */
      memset(pixels, 127, sizeof(pixels));

      texObj = st->ctx->Driver.NewTextureObject(st->ctx, 0, target);

      texImg = _mesa_get_tex_image(st->ctx, texObj, target, 0);

      _mesa_init_teximage_fields(st->ctx, target, texImg,
                                 16, 16, 1, 0,  /* w, h, d, border */
                                 GL_RGBA);

      st_TexImage(st->ctx, 2, target,
                  0, GL_RGBA,    /* level, intformat */
                  16, 16, 1, 0,  /* w, h, d, border */
                  GL_RGBA, GL_UNSIGNED_BYTE, pixels,
                  &st->ctx->DefaultPacking,
                  texObj, texImg,
                  0, 0);

      texObj->MinFilter = GL_NEAREST;
      texObj->MagFilter = GL_NEAREST;
      texObj->_Complete = GL_TRUE;

      st->default_texture = texObj;
   }
   return st->default_texture;
}

static void st_get_tex_image	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	format,
		GLenum	type,
		GLvoid *	pixels,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage,
		int	compressed
	)			[static]

Need to map texture image into memory before copying image data, then unmap it.

Definition at line 671 of file st_cb_texture.c.

References assert, pipe_texture::block, PIPE_BUFFER_USAGE_CPU_READ, st_texture_image::pt, pipe_format_block::size, st_texture_image(), st_texture_image_map(), st_texture_image_unmap(), pipe_surface::stride, and st_texture_image::surface.

{
   struct st_texture_image *stImage = st_texture_image(texImage);
   GLuint dstImageStride = _mesa_image_image_stride(&ctx->Pack,
                                                    texImage->Width,
                                                    texImage->Height,
                                                    format, type);
   GLuint depth;
   GLuint i;
   GLubyte *dest;

   /* Map */
   if (stImage->pt) {
      /* Image is stored in hardware format in a buffer managed by the
       * kernel.  Need to explicitly map and unmap it.
       */
      texImage->Data = st_texture_image_map(ctx->st, stImage, 0,
                                            PIPE_BUFFER_USAGE_CPU_READ);
      texImage->RowStride = stImage->surface->stride / stImage->pt->block.size;
   }
   else {
      /* Otherwise, the image should actually be stored in
       * texImage->Data.  This is pretty confusing for
       * everybody, I'd much prefer to separate the two functions of
       * texImage->Data - storage for texture images in main memory
       * and access (ie mappings) of images.  In other words, we'd
       * create a new texImage->Map field and leave Data simply for
       * storage.
       */
      assert(texImage->Data);
   }

   depth = texImage->Depth;
   texImage->Depth = 1;

   dest = (GLubyte *) pixels;

   for (i = 0; i++ < depth;) {
      if (compressed) {
         _mesa_get_compressed_teximage(ctx, target, level, dest,
                                       texObj, texImage);
      } else {
         _mesa_get_teximage(ctx, target, level, format, type, dest,
                            texObj, texImage);
      }

      if (stImage->pt && i < depth) {
         st_texture_image_unmap(ctx->st, stImage);
         texImage->Data = st_texture_image_map(ctx->st, stImage, i,
                                               PIPE_BUFFER_USAGE_CPU_READ);
         dest += dstImageStride;
      }
   }

   texImage->Depth = depth;

   /* Unmap */
   if (stImage->pt) {
      st_texture_image_unmap(ctx->st, stImage);
      texImage->Data = NULL;
   }
}

static void st_GetCompressedTexImage	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLvoid *	pixels,
		const struct gl_texture_object *	texObj,
		const struct gl_texture_image *	texImage
	)			[static]

Definition at line 750 of file st_cb_texture.c.

References st_get_tex_image().

{
   st_get_tex_image(ctx, target, level, 0, 0, pixels,
                    (struct gl_texture_object *) texObj,
                    (struct gl_texture_image *) texImage, 1);
}

static void st_GetTexImage	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLenum	format,
		GLenum	type,
		GLvoid *	pixels,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 739 of file st_cb_texture.c.

References st_get_tex_image().

{
   st_get_tex_image(ctx, target, level, format, type, pixels,
                    texObj, texImage, 0);
}

void st_init_texture_functions

(

struct dd_function_table *

functions

)

Definition at line 1518 of file st_cb_texture.c.

References do_memcpy(), st_ChooseTextureFormat(), st_CompressedTexImage2D(), st_CopyTexImage1D(), st_CopyTexImage2D(), st_CopyTexSubImage1D(), st_CopyTexSubImage2D(), st_CopyTexSubImage3D(), st_DeleteTextureObject(), st_FreeTextureImageData(), st_generate_mipmap(), st_GetCompressedTexImage(), st_GetTexImage(), st_NewTextureImage(), st_NewTextureObject(), st_TexImage1D(), st_TexImage2D(), st_TexImage3D(), st_TexSubImage1D(), st_TexSubImage2D(), and st_TexSubImage3D().

{
   functions->ChooseTextureFormat = st_ChooseTextureFormat;
   functions->TexImage1D = st_TexImage1D;
   functions->TexImage2D = st_TexImage2D;
   functions->TexImage3D = st_TexImage3D;
   functions->TexSubImage1D = st_TexSubImage1D;
   functions->TexSubImage2D = st_TexSubImage2D;
   functions->TexSubImage3D = st_TexSubImage3D;
   functions->CopyTexImage1D = st_CopyTexImage1D;
   functions->CopyTexImage2D = st_CopyTexImage2D;
   functions->CopyTexSubImage1D = st_CopyTexSubImage1D;
   functions->CopyTexSubImage2D = st_CopyTexSubImage2D;
   functions->CopyTexSubImage3D = st_CopyTexSubImage3D;
   functions->GenerateMipmap = st_generate_mipmap;

   functions->GetTexImage = st_GetTexImage;

   /* compressed texture functions */
   functions->CompressedTexImage2D = st_CompressedTexImage2D;
   functions->GetCompressedTexImage = st_GetCompressedTexImage;
   functions->CompressedTextureSize = _mesa_compressed_texture_size;

   functions->NewTextureObject = st_NewTextureObject;
   functions->NewTextureImage = st_NewTextureImage;
   functions->DeleteTexture = st_DeleteTextureObject;
   functions->FreeTexImageData = st_FreeTextureImageData;
   functions->UpdateTexturePalette = 0;

   functions->TextureMemCpy = do_memcpy;

   /* XXX Temporary until we can query pipe's texture sizes */
   functions->TestProxyTexImage = _mesa_test_proxy_teximage;
}

static struct gl_texture_image* st_NewTextureImage

(

GLcontext *

ctx

)

[static, read]

called via ctx->Driver.NewTextureImage()

Definition at line 113 of file st_cb_texture.c.

References CALLOC_STRUCT, and DBG.

{
   DBG("%s\n", __FUNCTION__);
   (void) ctx;
   return (struct gl_texture_image *) CALLOC_STRUCT(st_texture_image);
}

static struct gl_texture_object* st_NewTextureObject	(	GLcontext *	ctx,
		GLuint	name,
		GLenum	target
	)			[static, read]

called via ctx->Driver.NewTextureObject()

Definition at line 123 of file st_cb_texture.c.

References st_texture_object::base, CALLOC_STRUCT, and DBG.

{
   struct st_texture_object *obj = CALLOC_STRUCT(st_texture_object);

   DBG("%s\n", __FUNCTION__);
   _mesa_initialize_texture_object(&obj->base, name, target);

   return &obj->base;
}

static void st_TexImage	(	GLcontext *	ctx,
		GLint	dims,
		GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLint	width,
		GLint	height,
		GLint	depth,
		GLint	border,
		GLenum	format,
		GLenum	type,
		const void *	pixels,
		const struct gl_pixelstore_attrib *	unpack,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage,
		GLsizei	imageSize,
		int	compressed
	)			[static]

Do glTexImage1/2/3D().

Definition at line 372 of file st_cb_texture.c.

References assert, st_texture_image::base, DBG, st_texture_image::face, FALSE, guess_and_alloc_texture(), pipe_texture::last_level, st_texture_image::level, PIPE_BUFFER_USAGE_CPU_WRITE, PIPE_TEXTURE_CUBE, pipe_texture_reference(), st_texture_object::pt, st_texture_image::pt, st_ChooseTextureFormat(), st_finish(), st_texture_image(), st_texture_image_map(), st_texture_image_unmap(), st_texture_match_image(), st_texture_object(), pipe_surface::stride, strip_texture_border(), st_texture_image::surface, pipe_texture::target, and st_texture_object::teximage_realloc.

{
   struct st_texture_object *stObj = st_texture_object(texObj);
   struct st_texture_image *stImage = st_texture_image(texImage);
   GLint postConvWidth, postConvHeight;
   GLint texelBytes, sizeInBytes;
   GLuint dstRowStride;
   struct gl_pixelstore_attrib unpackNB;

   DBG("%s target %s level %d %dx%dx%d border %d\n", __FUNCTION__,
       _mesa_lookup_enum_by_nr(target), level, width, height, depth, border);

   /* gallium does not support texture borders, strip it off */
   if (border) {
      strip_texture_border(border, &width, &height, &depth,
                           unpack, &unpackNB);
      unpack = &unpackNB;
      texImage->Width = width;
      texImage->Height = height;
      texImage->Depth = depth;
      texImage->Border = 0;
      border = 0;
   }

   postConvWidth = width;
   postConvHeight = height;

   stImage->face = _mesa_tex_target_to_face(target);
   stImage->level = level;

#if FEATURE_convolve
   if (ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
      _mesa_adjust_image_for_convolution(ctx, dims, &postConvWidth,
                                         &postConvHeight);
   }
#endif

   /* choose the texture format */
   texImage->TexFormat = st_ChooseTextureFormat(ctx, internalFormat,
                                                format, type);

   _mesa_set_fetch_functions(texImage, dims);

   if (texImage->TexFormat->TexelBytes == 0) {
      /* must be a compressed format */
      texelBytes = 0;
      texImage->IsCompressed = GL_TRUE;
      texImage->CompressedSize =
         ctx->Driver.CompressedTextureSize(ctx, texImage->Width,
                                           texImage->Height, texImage->Depth,
                                           texImage->TexFormat->MesaFormat);
   }
   else {
      texelBytes = texImage->TexFormat->TexelBytes;
      
      /* Minimum pitch of 32 bytes */
      if (postConvWidth * texelBytes < 32) {
         postConvWidth = 32 / texelBytes;
         texImage->RowStride = postConvWidth;
      }
      
      /* we'll set RowStride elsewhere when the texture is a "mapped" state */
      /*assert(texImage->RowStride == postConvWidth);*/
   }

   /* Release the reference to a potentially orphaned buffer.   
    * Release any old malloced memory.
    */
   if (stImage->pt) {
      pipe_texture_reference(&stImage->pt, NULL);
      assert(!texImage->Data);
   }
   else if (texImage->Data) {
      _mesa_align_free(texImage->Data);
   }

   if (width == 0 || height == 0 || depth == 0) {
      /* stop after freeing old image */
      return;
   }

   /* If this is the only mipmap level in the texture, could call
    * bmBufferData with NULL data to free the old block and avoid
    * waiting on any outstanding fences.
    */
   if (stObj->pt &&
       (stObj->teximage_realloc ||
        (/*stObj->pt->first_level == level &&*/
         stObj->pt->last_level == level &&
         stObj->pt->target != PIPE_TEXTURE_CUBE &&
         !st_texture_match_image(stObj->pt, &stImage->base,
                                 stImage->face, stImage->level)))) {

      DBG("release it\n");
      pipe_texture_reference(&stObj->pt, NULL);
      assert(!stObj->pt);
      stObj->teximage_realloc = FALSE;
   }

   if (!stObj->pt) {
      guess_and_alloc_texture(ctx->st, stObj, stImage);
      if (!stObj->pt) {
         /* Probably out of memory.
          * Try flushing any pending rendering, then retry.
          */
         st_finish(ctx->st);
         guess_and_alloc_texture(ctx->st, stObj, stImage);
         if (!stObj->pt) {
            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
            return;
         }
      }
   }

   assert(!stImage->pt);

   if (stObj->pt &&
       st_texture_match_image(stObj->pt, &stImage->base,
                                 stImage->face, stImage->level)) {

      pipe_texture_reference(&stImage->pt, stObj->pt);
      assert(stImage->pt);
   }

   if (!stImage->pt)
      DBG("XXX: Image did not fit into texture - storing in local memory!\n");

   /* st_CopyTexImage calls this function with pixels == NULL, with
    * the expectation that the texture will be set up but nothing
    * more will be done.  This is where those calls return:
    */
   if (compressed) {
      pixels = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, pixels,
                                                      unpack,
                                                      "glCompressedTexImage");
   } else {
      pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, 1,
                                           format, type,
                                           pixels, unpack, "glTexImage");
   }
   if (!pixels)
      return;

   if (stImage->pt) {
      texImage->Data = st_texture_image_map(ctx->st, stImage, 0,
                                            PIPE_BUFFER_USAGE_CPU_WRITE);
      if (stImage->surface)
         dstRowStride = stImage->surface->stride;
   }
   else {
      /* Allocate regular memory and store the image there temporarily.   */
      if (texImage->IsCompressed) {
         sizeInBytes = texImage->CompressedSize;
         dstRowStride =
            _mesa_compressed_row_stride(texImage->TexFormat->MesaFormat, width);
         assert(dims != 3);
      }
      else {
         dstRowStride = postConvWidth * texelBytes;
         sizeInBytes = depth * dstRowStride * postConvHeight;
      }

      texImage->Data = _mesa_align_malloc(sizeInBytes, 16);
   }

   if (!texImage->Data) {
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
      return;
   }

   DBG("Upload image %dx%dx%d row_len %x pitch %x\n",
       width, height, depth, width * texelBytes, dstRowStride);

   /* Copy data.  Would like to know when it's ok for us to eg. use
    * the blitter to copy.  Or, use the hardware to do the format
    * conversion and copy:
    */
   if (compressed) {
      memcpy(texImage->Data, pixels, imageSize);
   }
   else {
      GLuint srcImageStride = _mesa_image_image_stride(unpack, width, height,
                                                       format, type);
      int i;
      const GLubyte *src = (const GLubyte *) pixels;

      for (i = 0; i++ < depth;) {
         if (!texImage->TexFormat->StoreImage(ctx, dims, 
                                              texImage->_BaseFormat, 
                                              texImage->TexFormat, 
                                              texImage->Data,
                                              0, 0, 0, /* dstX/Y/Zoffset */
                                              dstRowStride,
                                              texImage->ImageOffsets,
                                              width, height, 1,
                                              format, type, src, unpack)) {
            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
         }

         if (stImage->pt && i < depth) {
            st_texture_image_unmap(ctx->st, stImage);
            texImage->Data = st_texture_image_map(ctx->st, stImage, i,
                                                  PIPE_BUFFER_USAGE_CPU_WRITE);
            src += srcImageStride;
         }
      }
   }

   _mesa_unmap_teximage_pbo(ctx, unpack);

   if (stImage->pt) {
      st_texture_image_unmap(ctx->st, stImage);
      texImage->Data = NULL;
   }

   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
      ctx->Driver.GenerateMipmap(ctx, target, texObj);
   }
}

static void st_TexImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLint	width,
		GLint	border,
		GLenum	format,
		GLenum	type,
		const void *	pixels,
		const struct gl_pixelstore_attrib *	unpack,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 637 of file st_cb_texture.c.

References st_TexImage().

{
   st_TexImage(ctx, 1, target, level,
                 internalFormat, width, 1, 1, border,
                 format, type, pixels, unpack, texObj, texImage, 0, 0);
}

static void st_TexImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLint	width,
		GLint	height,
		GLint	border,
		GLenum	format,
		GLenum	type,
		const void *	pixels,
		const struct gl_pixelstore_attrib *	unpack,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 621 of file st_cb_texture.c.

References st_TexImage().

{
   st_TexImage(ctx, 2, target, level,
                 internalFormat, width, height, 1, border,
                 format, type, pixels, unpack, texObj, texImage, 0, 0);
}

static void st_TexImage3D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	internalFormat,
		GLint	width,
		GLint	height,
		GLint	depth,
		GLint	border,
		GLenum	format,
		GLenum	type,
		const void *	pixels,
		const struct gl_pixelstore_attrib *	unpack,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 604 of file st_cb_texture.c.

References st_TexImage().

{
   st_TexImage(ctx, 3, target, level,
                 internalFormat, width, height, depth, border,
                 format, type, pixels, unpack, texObj, texImage, 0, 0);
}

static void st_TexSubimage	(	GLcontext *	ctx,
		GLint	dims,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLint	zoffset,
		GLint	width,
		GLint	height,
		GLint	depth,
		GLenum	format,
		GLenum	type,
		const void *	pixels,
		const struct gl_pixelstore_attrib *	packing,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 763 of file st_cb_texture.c.

References DBG, PIPE_BUFFER_USAGE_CPU_WRITE, st_texture_image::pt, st_texture_image(), st_texture_image_map(), st_texture_image_unmap(), pipe_surface::stride, and st_texture_image::surface.

{
   struct st_texture_image *stImage = st_texture_image(texImage);
   GLuint dstRowStride;
   GLuint srcImageStride = _mesa_image_image_stride(packing, width, height,
                                                    format, type);
   int i;
   const GLubyte *src;

   DBG("%s target %s level %d offset %d,%d %dx%d\n", __FUNCTION__,
       _mesa_lookup_enum_by_nr(target),
       level, xoffset, yoffset, width, height);

   pixels =
      _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, format,
                                  type, pixels, packing, "glTexSubImage2D");
   if (!pixels)
      return;

   /* Map buffer if necessary.  Need to lock to prevent other contexts
    * from uploading the buffer under us.
    */
   if (stImage->pt) {
      texImage->Data = st_texture_image_map(ctx->st, stImage, zoffset, 
                                            PIPE_BUFFER_USAGE_CPU_WRITE);
      if (stImage->surface)
         dstRowStride = stImage->surface->stride;
   }

   if (!texImage->Data) {
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
      return;
   }

   src = (const GLubyte *) pixels;

   for (i = 0; i++ < depth;) {
      if (!texImage->TexFormat->StoreImage(ctx, dims, texImage->_BaseFormat,
                                           texImage->TexFormat,
                                           texImage->Data,
                                           xoffset, yoffset, 0,
                                           dstRowStride,
                                           texImage->ImageOffsets,
                                           width, height, 1,
                                           format, type, src, packing)) {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage");
      }

      if (stImage->pt && i < depth) {
         /* map next slice of 3D texture */
         st_texture_image_unmap(ctx->st, stImage);
         texImage->Data = st_texture_image_map(ctx->st, stImage, zoffset + i,
                                               PIPE_BUFFER_USAGE_CPU_WRITE);
         src += srcImageStride;
      }
   }

   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
      ctx->Driver.GenerateMipmap(ctx, target, texObj);
   }

   _mesa_unmap_teximage_pbo(ctx, packing);

   if (stImage->pt) {
      st_texture_image_unmap(ctx->st, stImage);
      texImage->Data = NULL;
   }
}

static void st_TexSubImage1D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLsizei	width,
		GLenum	format,
		GLenum	type,
		const GLvoid *	pixels,
		const struct gl_pixelstore_attrib *	packing,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 881 of file st_cb_texture.c.

References st_TexSubimage().

{
   st_TexSubimage(ctx, 1, target, level,
                  xoffset, 0, 0,
                  width, 1, 1,
                  format, type, pixels, packing, texObj, texImage);
}

static void st_TexSubImage2D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const GLvoid *	pixels,
		const struct gl_pixelstore_attrib *	packing,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 862 of file st_cb_texture.c.

References st_TexSubimage().

{
   st_TexSubimage(ctx, 2, target, level,
                  xoffset, yoffset, 0,
                  width, height, 1,
                  format, type, pixels, packing, texObj, texImage);
}

static void st_TexSubImage3D	(	GLcontext *	ctx,
		GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLint	zoffset,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLenum	format,
		GLenum	type,
		const GLvoid *	pixels,
		const struct gl_pixelstore_attrib *	packing,
		struct gl_texture_object *	texObj,
		struct gl_texture_image *	texImage
	)			[static]

Definition at line 843 of file st_cb_texture.c.

References st_TexSubimage().

{
   st_TexSubimage(ctx, 3, target, level,
                  xoffset, yoffset, zoffset,
                  width, height, depth,
                  format, type, pixels, packing, texObj, texImage);
}

static void strip_texture_border	(	GLint	border,
		GLint *	width,
		GLint *	height,
		GLint *	depth,
		const struct gl_pixelstore_attrib *	unpack,
		struct gl_pixelstore_attrib *	unpackNew
	)			[static]

Adjust pixel unpack params and image dimensions to strip off the texture border.

Gallium doesn't support texture borders. They've seldem been used and seldom been implemented correctly anyway.

Parameters:

unpackNew

returns the new pixel unpack parameters

Definition at line 338 of file st_cb_texture.c.

References assert.

{
   assert(border > 0);  /* sanity check */

   *unpackNew = *unpack;

   if (unpackNew->RowLength == 0)
      unpackNew->RowLength = *width;

   if (depth && unpackNew->ImageHeight == 0)
      unpackNew->ImageHeight = *height;

   unpackNew->SkipPixels += border;
   if (height)
      unpackNew->SkipRows += border;
   if (depth)
      unpackNew->SkipImages += border;

   assert(*width >= 3);
   *width = *width - 2 * border;
   if (height && *height >= 3)
      *height = *height - 2 * border;
   if (depth && *depth >= 3)
      *depth = *depth - 2 * border;
}

static uint texture_face

(

GLenum

target

)

[static]

Return 0 for GL_TEXTURE_CUBE_MAP_POSITIVE_X, 1 for GL_TEXTURE_CUBE_MAP_NEGATIVE_X, etc.

XXX duplicated from main/teximage.c

Definition at line 907 of file st_cb_texture.c.

{
   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)
      return (GLuint) target - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X;
   else
      return 0;
}

---