r300_texstate.c

mesa-6.5-minigui源码

/* $XFree86: xc/lib/GL/mesa/src/drv/r300/r300_texstate.c,v 1.3 2003/02/15 22:18:47 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.

The Weather Channel (TM) funded Tungsten Graphics to develop the
initial release of the Radeon 8500 driver under the XFree86 license.
This notice must be preserved.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice (including the
next paragraph) shall be included in all copies or substantial
portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

**************************************************************************/

/*
 * Authors:
 *   Keith Whitwell <[e-mail]>
 */

#include "glheader.h"
#include "imports.h"
#include "context.h"
#include "macros.h"
#include "texformat.h"
#include "enums.h"

#include "r300_context.h"
#include "r300_state.h"
#include "r300_ioctl.h"
#include "radeon_ioctl.h"
#include "r300_tex.h"
#include "r300_reg.h"

#define R200_TXFORMAT_A8        R200_TXFORMAT_I8
#define R200_TXFORMAT_L8        R200_TXFORMAT_I8
#define R200_TXFORMAT_AL88      R200_TXFORMAT_AI88
#define R200_TXFORMAT_YCBCR     R200_TXFORMAT_YVYU422
#define R200_TXFORMAT_YCBCR_REV R200_TXFORMAT_VYUY422
#define R200_TXFORMAT_RGB_DXT1  R200_TXFORMAT_DXT1
#define R200_TXFORMAT_RGBA_DXT1 R200_TXFORMAT_DXT1
#define R200_TXFORMAT_RGBA_DXT3 R200_TXFORMAT_DXT23
#define R200_TXFORMAT_RGBA_DXT5 R200_TXFORMAT_DXT45

#define _COLOR(f) \
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f, 0 }
#define _COLOR_REV(f) \
    [ MESA_FORMAT_ ## f ## _REV ] = { R200_TXFORMAT_ ## f, 0 }
#define _ALPHA(f) \
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f | R200_TXFORMAT_ALPHA_IN_MAP, 0 }
#define _ALPHA_REV(f) \
    [ MESA_FORMAT_ ## f ## _REV ] = { R200_TXFORMAT_ ## f | R200_TXFORMAT_ALPHA_IN_MAP, 0 }
#define _YUV(f) \
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f, R200_YUV_TO_RGB }
#define _INVALID(f) \
    [ MESA_FORMAT_ ## f ] = { 0xffffffff, 0 }
#define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5 \
	|| ((f) >= MESA_FORMAT_RGBA_FLOAT32 && (f) <= MESA_FORMAT_INTENSITY_FLOAT16)) \
			     && tx_table[f].flag )

#define _ASSIGN(entry, format)	\
	[ MESA_FORMAT_ ## entry ] = { format, 0, 1}

static const struct {
	GLuint format, filter;
} tx_table0[] = {
	    _ALPHA(RGBA8888),
	    _ALPHA_REV(RGBA8888),
	    _ALPHA(ARGB8888),
	    _ALPHA_REV(ARGB8888),
	    _INVALID(RGB888),
	    _COLOR(RGB565),
	    _COLOR_REV(RGB565),
	    _ALPHA(ARGB4444),
	    _ALPHA_REV(ARGB4444),
	    _ALPHA(ARGB1555),
	    _ALPHA_REV(ARGB1555),
	    _ALPHA(AL88),
	    _ALPHA_REV(AL88),
	    _ALPHA(A8),
	    _COLOR(L8),
	    _ALPHA(I8),
	    _INVALID(CI8),
	    _YUV(YCBCR),
	    _YUV(YCBCR_REV),
	    _INVALID(RGB_FXT1),
	    _INVALID(RGBA_FXT1),
	    _COLOR(RGB_DXT1),
	    _ALPHA(RGBA_DXT1),
	    _ALPHA(RGBA_DXT3),
	    _ALPHA(RGBA_DXT5),
	    };

static const struct {
	GLuint format, filter, flag;
} tx_table[] = {
	/*
	 * Note that the _REV formats are the same as the non-REV formats.
	 * This is because the REV and non-REV formats are identical as a
	 * byte string, but differ when accessed as 16-bit or 32-bit words
	 * depending on the endianness of the host.  Since the textures are
	 * transferred to the R300 as a byte string (i.e. without any
	 * byte-swapping), the R300 sees the REV and non-REV formats
	 * identically.  -- paulus
	 */
	    _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
	    _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
	    _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
	    _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
	    _ASSIGN(RGB888, 0xffffffff),
	    _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
	    _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
	    _ASSIGN(ARGB4444, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
	    _ASSIGN(ARGB4444_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
	    _ASSIGN(ARGB1555, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
	    _ASSIGN(ARGB1555_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
	    _ASSIGN(AL88, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
	    _ASSIGN(AL88_REV, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
	    _ASSIGN(RGB332, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z3Y3X2)),
	    _ASSIGN(A8, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X8)),
	    _ASSIGN(L8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8)),
	    _ASSIGN(I8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
	    _ASSIGN(CI8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
	    _ASSIGN(YCBCR, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8)|R300_TX_FORMAT_YUV_MODE ),
	    _ASSIGN(YCBCR_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8)|R300_TX_FORMAT_YUV_MODE),
	    _ASSIGN(RGB_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, ONE, DXT1)),
	    _ASSIGN(RGBA_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT1)),
	    _ASSIGN(RGBA_DXT3, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT3)),
	    _ASSIGN(RGBA_DXT5, R300_EASY_TX_FORMAT(Y, Z, W, X, DXT5)),
	    _ASSIGN(RGBA_FLOAT32, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R32G32B32A32)),
	    _ASSIGN(RGBA_FLOAT16, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R16G16B16A16)),
	    _ASSIGN(RGB_FLOAT32, 0xffffffff),
	    _ASSIGN(RGB_FLOAT16, 0xffffffff),
	    _ASSIGN(ALPHA_FLOAT32, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I32)),
	    _ASSIGN(ALPHA_FLOAT16, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I16)),
	    _ASSIGN(LUMINANCE_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I32)),
	    _ASSIGN(LUMINANCE_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I16)),
	    _ASSIGN(LUMINANCE_ALPHA_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I32A32)),
	    _ASSIGN(LUMINANCE_ALPHA_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I16A16)),
	    _ASSIGN(INTENSITY_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, X, FL_I32)),
	    _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
	    };

#undef _COLOR
#undef _ALPHA
#undef _INVALID
#undef _ASSIGN


/**
 * This function computes the number of bytes of storage needed for
 * the given texture object (all mipmap levels, all cube faces).
 * The \c image[face][level].x/y/width/height parameters for upload/blitting
 * are computed here.  \c filter, \c format, etc. will be set here
 * too.
 *
 * \param rmesa Context pointer
 * \param tObj GL texture object whose images are to be posted to
 *                 hardware state.
 */
static void r300SetTexImages(r300ContextPtr rmesa,
			     struct gl_texture_object *tObj)
{
	r300TexObjPtr t = (r300TexObjPtr) tObj->DriverData;
	const struct gl_texture_image *baseImage =
	    tObj->Image[0][tObj->BaseLevel];
	GLint curOffset, blitWidth;
	GLint i, texelBytes;
	GLint numLevels;
	GLint log2Width, log2Height, log2Depth;

	/* Set the hardware texture format
	 */

	t->format &= ~(R200_TXFORMAT_FORMAT_MASK |
			    R200_TXFORMAT_ALPHA_IN_MAP);

	if (VALID_FORMAT(baseImage->TexFormat->MesaFormat)) {
		t->format =
		    tx_table[baseImage->TexFormat->MesaFormat].format;
#if 1
		t->filter |=
		    tx_table[baseImage->TexFormat->MesaFormat].filter;
#endif
	} else {
		_mesa_problem(NULL, "unexpected texture format in %s",
			      __FUNCTION__);
		return;
	}

	texelBytes = baseImage->TexFormat->TexelBytes;

	/* Compute which mipmap levels we really want to send to the hardware.
	 */

	driCalculateTextureFirstLastLevel((driTextureObject *) t);
	log2Width = tObj->Image[0][t->base.firstLevel]->WidthLog2;
	log2Height = tObj->Image[0][t->base.firstLevel]->HeightLog2;
	log2Depth = tObj->Image[0][t->base.firstLevel]->DepthLog2;

	numLevels = t->base.lastLevel - t->base.firstLevel + 1;

	assert(numLevels <= RADEON_MAX_TEXTURE_LEVELS);

	/* Calculate mipmap offsets and dimensions for blitting (uploading)
	 * The idea is that we lay out the mipmap levels within a block of
	 * memory organized as a rectangle of width BLIT_WIDTH_BYTES.
	 */
	curOffset = 0;
	blitWidth = BLIT_WIDTH_BYTES;
	t->tile_bits = 0;

	/* figure out if this texture is suitable for tiling. */
#if 0 /* Disabled for now */
	if (texelBytes) {
		if (rmesa->texmicrotile  && (tObj->Target != GL_TEXTURE_RECTANGLE_NV) &&
		   /* texrect might be able to use micro tiling too in theory? */
		   (baseImage->Height > 1)) {
			
			/* allow 32 (bytes) x 1 mip (which will use two times the space
			   the non-tiled version would use) max if base texture is large enough */
			if ((numLevels == 1) ||
				(((baseImage->Width * texelBytes / baseImage->Height) <= 32) &&
				(baseImage->Width * texelBytes > 64)) ||
				((baseImage->Width * texelBytes / baseImage->Height) <= 16)) {
				t->tile_bits |= R300_TXO_MICRO_TILE;
			}
		}
		
		if (tObj->Target != GL_TEXTURE_RECTANGLE_NV) {
			/* we can set macro tiling even for small textures, they will be untiled anyway */
			t->tile_bits |= R300_TXO_MACRO_TILE;
		}
	}
#endif

	for (i = 0; i < numLevels; i++) {
	  const struct gl_texture_image *texImage;
	  GLuint size;
	  
	  texImage = tObj->Image[0][i + t->base.firstLevel];
	  if (!texImage)
	    break;
	  
	  /* find image size in bytes */
	  if (texImage->IsCompressed) {
	    if ((t->format & R300_TX_FORMAT_DXT1) == R300_TX_FORMAT_DXT1) {
	      // fprintf(stderr,"DXT 1 %d %08X\n", texImage->Width, t->format);
	      if ((texImage->Width + 3) < 8) /* width one block */
		size = texImage->CompressedSize * 4;
	      else if ((texImage->Width + 3) < 16)
		size = texImage->CompressedSize * 2;
	      else size = texImage->CompressedSize;
	    }
	    else /* DXT3/5, 16 bytes per block */
	    {
	      WARN_ONCE("DXT 3/5 suffers from multitexturing problems!\n");
	      // fprintf(stderr,"DXT 3/5 %d\n", texImage->Width);
	      if ((texImage->Width + 3) < 8)
		size = texImage->CompressedSize * 2;
	      else size = texImage->CompressedSize;
	    }
	    
	  } else if (tObj->Target == GL_TEXTURE_RECTANGLE_NV) {
	    size = ((texImage->Width * texelBytes + 63) & ~63) * texImage->Height;
	    blitWidth = 64 / texelBytes;
	  } else if (t->tile_bits & R300_TXO_MICRO_TILE) {
		/* tile pattern is 16 bytes x2. mipmaps stay 32 byte aligned,
		   though the actual offset may be different (if texture is less than
		   32 bytes width) to the untiled case */
		int w = (texImage->Width * texelBytes * 2 + 31) & ~31;
		size = (w * ((texImage->Height + 1) / 2)) * texImage->Depth;
		blitWidth = MAX2(texImage->Width, 64 / texelBytes);
	  } else {
	    int w = (texImage->Width * texelBytes + 31) & ~31;
	    size = w * texImage->Height * texImage->Depth;
	    blitWidth = MAX2(texImage->Width, 64 / texelBytes);
	  }
	  assert(size > 0);
	  
	  if(0)
	    fprintf(stderr, "w=%d h=%d d=%d tb=%d intFormat=%d\n", texImage->Width, texImage->Height,
		    texImage->Depth, texImage->TexFormat->TexelBytes,
		    texImage->InternalFormat);
	  
	  /* Align to 32-byte offset.  It is faster to do this unconditionally
	   * (no branch penalty).
	   */
	  
	  curOffset = (curOffset + 0x1f) & ~0x1f;
	  
	  if (texelBytes) {
	    t->image[0][i].x = curOffset; /* fix x and y coords up later together with offset */
	    t->image[0][i].y = 0;
	    t->image[0][i].width = MIN2(size / texelBytes, blitWidth);
	    t->image[0][i].height = (size / texelBytes) / t->image[0][i].width;
	  } else {
	    t->image[0][i].x = curOffset % BLIT_WIDTH_BYTES;