src/mesa/drivers/dri/r300/r300_texstate.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /**
  31  * \file
  32  *
  33  * \author Keith Whitwell <keith@tungstengraphics.com>
  34  *
  35  * \todo Enable R300 texture tiling code?
  36  */
  37
  38 #include "main/glheader.h"
  39 #include "main/imports.h"
  40 #include "main/context.h"
  41 #include "main/macros.h"
  42 #include "main/teximage.h"
  43 #include "main/texobj.h"
  44 #include "main/enums.h"
  45 #include "main/simple_list.h"
  46
  47 #include "r300_context.h"
  48 #include "r300_state.h"
  49 #include "r300_ioctl.h"
  50 #include "radeon_mipmap_tree.h"
  51 #include "r300_tex.h"
  52 #include "r300_reg.h"
  53
  54 #define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5                 \
  55                            || ((f) >= MESA_FORMAT_RGBA_FLOAT32 &&       \
  56                                (f) <= MESA_FORMAT_INTENSITY_FLOAT16))   \
  57                           && tx_table[f].flag )
  58
  59 #define _ASSIGN(entry, format)                          \
  60         [ MESA_FORMAT_ ## entry ] = { format, 0, 1}
  61
  62 /*
  63  * Note that the _REV formats are the same as the non-REV formats.  This is
  64  * because the REV and non-REV formats are identical as a byte string, but
  65  * differ when accessed as 16-bit or 32-bit words depending on the endianness of
  66  * the host.  Since the textures are transferred to the R300 as a byte string
  67  * (i.e. without any byte-swapping), the R300 sees the REV and non-REV formats
  68  * identically.  -- paulus
  69  */
  70
  71 static const struct tx_table {
  72         GLuint format, filter, flag;
  73 } tx_table[] = {
  74         /* *INDENT-OFF* */
  75 #ifdef MESA_LITTLE_ENDIAN
  76         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  77         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  78         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  79         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  80 #else
  81         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  82         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  83         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  84         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  85 #endif
  86         _ASSIGN(XRGB8888, R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8)),
  87         _ASSIGN(RGB888, R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8)),
  88         _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  89         _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  90         _ASSIGN(ARGB4444, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  91         _ASSIGN(ARGB4444_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  92         _ASSIGN(ARGB1555, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  93         _ASSIGN(ARGB1555_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  94         _ASSIGN(AL88, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  95         _ASSIGN(AL88_REV, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  96         _ASSIGN(RGB332, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z3Y3X2)),
  97         _ASSIGN(A8, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X8)),
  98         _ASSIGN(L8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8)),
  99         _ASSIGN(I8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 100         _ASSIGN(CI8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 101         _ASSIGN(YCBCR, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 102         _ASSIGN(YCBCR_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 103         _ASSIGN(RGB_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, ONE, DXT1)),
 104         _ASSIGN(RGBA_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT1)),
 105         _ASSIGN(RGBA_DXT3, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT3)),
 106         _ASSIGN(RGBA_DXT5, R300_EASY_TX_FORMAT(Y, Z, W, X, DXT5)),
 107         _ASSIGN(RGBA_FLOAT32, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R32G32B32A32)),
 108         _ASSIGN(RGBA_FLOAT16, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R16G16B16A16)),
 109         _ASSIGN(RGB_FLOAT32, 0xffffffff),
 110         _ASSIGN(RGB_FLOAT16, 0xffffffff),
 111         _ASSIGN(ALPHA_FLOAT32, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I32)),
 112         _ASSIGN(ALPHA_FLOAT16, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I16)),
 113         _ASSIGN(LUMINANCE_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I32)),
 114         _ASSIGN(LUMINANCE_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I16)),
 115         _ASSIGN(LUMINANCE_ALPHA_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I32A32)),
 116         _ASSIGN(LUMINANCE_ALPHA_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I16A16)),
 117         _ASSIGN(INTENSITY_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, X, FL_I32)),
 118         _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
 119         _ASSIGN(Z16, R300_EASY_TX_FORMAT(X, X, X, X, X16)),
 120         _ASSIGN(Z24_S8, R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8)),
 121         _ASSIGN(S8_Z24, R300_EASY_TX_FORMAT(Y, Y, Y, Y, X24_Y8)),
 122         _ASSIGN(Z32, R300_EASY_TX_FORMAT(X, X, X, X, X32)),
 123         /* EXT_texture_sRGB */
 124         _ASSIGN(SRGBA8, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8) | R300_TX_FORMAT_GAMMA),
 125         _ASSIGN(SLA8, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8) | R300_TX_FORMAT_GAMMA),
 126         _ASSIGN(SL8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8) | R300_TX_FORMAT_GAMMA),
 127         /* *INDENT-ON* */
 128 };
 129
 130 #undef _ASSIGN
 131
 132 void r300SetDepthTexMode(struct gl_texture_object *tObj)
 133 {
 134         static const GLuint formats[3][3] = {
 135                 {
 136                         R300_EASY_TX_FORMAT(X, X, X, ONE, X16),
 137                         R300_EASY_TX_FORMAT(X, X, X, X, X16),
 138                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X16),
 139                 },
 140                 {
 141                         R300_EASY_TX_FORMAT(X, X, X, ONE, X24_Y8),
 142                         R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8),
 143                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X24_Y8),
 144                 },
 145                 {
 146                         R300_EASY_TX_FORMAT(X, X, X, ONE, X32),
 147                         R300_EASY_TX_FORMAT(X, X, X, X, X32),
 148                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X32),
 149                 },
 150         };
 151         const GLuint *format;
 152         radeonTexObjPtr t;
 153
 154         if (!tObj)
 155                 return;
 156
 157         t = radeon_tex_obj(tObj);
 158
 159         switch (tObj->Image[0][tObj->BaseLevel]->TexFormat) {
 160         case MESA_FORMAT_Z16:
 161                 format = formats[0];
 162                 break;
 163         case MESA_FORMAT_S8_Z24:
 164                 format = formats[1];
 165                 break;
 166         case MESA_FORMAT_Z32:
 167                 format = formats[2];
 168                 break;
 169         default:
 170                 /* Error...which should have already been caught by higher
 171                  * levels of Mesa.
 172                  */
 173                 ASSERT(0);
 174                 return;
 175         }
 176
 177         switch (tObj->DepthMode) {
 178         case GL_LUMINANCE:
 179                 t->pp_txformat = format[0];
 180                 break;
 181         case GL_INTENSITY:
 182                 t->pp_txformat = format[1];
 183                 break;
 184         case GL_ALPHA:
 185                 t->pp_txformat = format[2];
 186                 break;
 187         default:
 188                 /* Error...which should have already been caught by higher
 189                  * levels of Mesa.
 190                  */
 191                 ASSERT(0);
 192                 return;
 193         }
 194 }
 195
 196
 197 /**
 198  * Compute the cached hardware register values for the given texture object.
 199  *
 200  * \param rmesa Context pointer
 201  * \param t the r300 texture object
 202  */
 203 static void setup_hardware_state(r300ContextPtr rmesa, radeonTexObj *t)
 204 {
 205         const struct gl_texture_image *firstImage;
 206         firstImage = t->base.Image[0][t->minLod];
 207
 208         if (!t->image_override
 209             && VALID_FORMAT(firstImage->TexFormat)) {
 210                 if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 211                         r300SetDepthTexMode(&t->base);
 212                 } else {
 213                         t->pp_txformat = tx_table[firstImage->TexFormat].format;
 214                 }
 215
 216                 t->pp_txfilter |= tx_table[firstImage->TexFormat].filter;
 217         } else if (!t->image_override) {
 218                 _mesa_problem(NULL, "unexpected texture format in %s",
 219                               __FUNCTION__);
 220                 return;
 221         }
 222
 223         if (t->image_override && t->bo)
 224                 return;
 225
 226         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((firstImage->Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 227                         | ((R300_TX_HEIGHTMASK_MASK & ((firstImage->Height - 1) << R300_TX_HEIGHTMASK_SHIFT)))
 228                         | ((R300_TX_DEPTHMASK_MASK & ((firstImage->DepthLog2) << R300_TX_DEPTHMASK_SHIFT)))
 229                         | ((R300_TX_MAX_MIP_LEVEL_MASK & ((t->maxLod - t->minLod) << R300_TX_MAX_MIP_LEVEL_SHIFT))));
 230
 231         t->tile_bits = 0;
 232
 233         if (t->base.Target == GL_TEXTURE_CUBE_MAP)
 234                 t->pp_txformat |= R300_TX_FORMAT_CUBIC_MAP;
 235         if (t->base.Target == GL_TEXTURE_3D)
 236                 t->pp_txformat |= R300_TX_FORMAT_3D;
 237
 238
 239         if (t->base.Target == GL_TEXTURE_RECTANGLE_NV) {
 240                 unsigned int align = (64 / _mesa_get_format_bytes(firstImage->TexFormat)) - 1;
 241                 t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 242                 if (!t->image_override)
 243                         t->pp_txpitch = ((firstImage->Width + align) & ~align) - 1;
 244         }
 245
 246         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 247             if (firstImage->Width > 2048)
 248                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 249             else
 250                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 251             if (firstImage->Height > 2048)
 252                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 253             else
 254                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 255         }
 256 }
 257
 258 /**
 259  * Ensure the given texture is ready for rendering.
 260  *
 261  * Mostly this means populating the texture object's mipmap tree.
 262  */
 263 static GLboolean r300_validate_texture(GLcontext * ctx, struct gl_texture_object *texObj)
 264 {
 265         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 266         radeonTexObj *t = radeon_tex_obj(texObj);
 267
 268         if (!radeon_validate_texture_miptree(ctx, texObj))
 269                 return GL_FALSE;
 270
 271         /* Configure the hardware registers (more precisely, the cached version
 272          * of the hardware registers). */
 273         setup_hardware_state(rmesa, t);
 274
 275         t->validated = GL_TRUE;
 276         return GL_TRUE;
 277 }
 278
 279 /**
 280  * Ensure all enabled and complete textures are uploaded along with any buffers being used.
 281  */
 282 GLboolean r300ValidateBuffers(GLcontext * ctx)
 283 {
 284         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 285         struct radeon_renderbuffer *rrb;
 286         int i;
 287         int ret;
 288
 289         radeon_cs_space_reset_bos(rmesa->radeon.cmdbuf.cs);
 290
 291         rrb = radeon_get_colorbuffer(&rmesa->radeon);
 292         /* color buffer */
 293         if (rrb && rrb->bo) {
 294                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 295                                                   rrb->bo, 0,
 296                                                   RADEON_GEM_DOMAIN_VRAM);
 297         }
 298
 299         /* depth buffer */
 300         rrb = radeon_get_depthbuffer(&rmesa->radeon);
 301         if (rrb && rrb->bo) {
 302                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 303                                                   rrb->bo, 0,
 304                                                   RADEON_GEM_DOMAIN_VRAM);
 305         }
 306
 307         for (i = 0; i < ctx->Const.MaxTextureImageUnits; ++i) {
 308                 radeonTexObj *t;
 309
 310                 if (!ctx->Texture.Unit[i]._ReallyEnabled)
 311                         continue;
 312
 313                 if (!r300_validate_texture(ctx, ctx->Texture.Unit[i]._Current)) {
 314                         _mesa_warning(ctx,
 315                                       "failed to validate texture for unit %d.\n",
 316                                       i);
 317                 }
 318                 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
 319                 if (t->image_override && t->bo)
 320                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 321                                                           t->bo,
 322                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 323                 else if (t->mt->bo)
 324                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 325                                                           t->mt->bo,
 326                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 327         }
 328
 329         ret = radeon_cs_space_check_with_bo(rmesa->radeon.cmdbuf.cs, first_elem(&rmesa->radeon.dma.reserved)->bo, RADEON_GEM_DOMAIN_GTT, 0);
 330         if (ret)
 331                 return GL_FALSE;
 332         return GL_TRUE;
 333 }
 334
 335 void r300SetTexOffset(__DRIcontext * pDRICtx, GLint texname,
 336                       unsigned long long offset, GLint depth, GLuint pitch)
 337 {
 338         r300ContextPtr rmesa = pDRICtx->driverPrivate;
 339         struct gl_texture_object *tObj =
 340             _mesa_lookup_texture(rmesa->radeon.glCtx, texname);
 341         radeonTexObjPtr t = radeon_tex_obj(tObj);
 342         uint32_t pitch_val;
 343
 344         if (!tObj)
 345                 return;
 346
 347         t->image_override = GL_TRUE;
 348
 349         if (!offset)
 350                 return;
 351
 352         t->bo = NULL;
 353         t->override_offset = offset;
 354         t->pp_txpitch &= (1 << 13) -1;
 355         pitch_val = pitch;
 356
 357         switch (depth) {
 358         case 32:
 359                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 360                 t->pp_txfilter |= tx_table[2].filter;
 361                 pitch_val /= 4;
 362                 break;
 363         case 24:
 364         default:
 365                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 366                 t->pp_txfilter |= tx_table[4].filter;
 367                 pitch_val /= 4;
 368                 break;
 369         case 16:
 370                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 371                 t->pp_txfilter |= tx_table[5].filter;
 372                 pitch_val /= 2;
 373                 break;
 374         }
 375         pitch_val--;
 376
 377         t->pp_txpitch |= pitch_val;
 378 }
 379
 380 void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_format, __DRIdrawable *dPriv)
 381 {
 382         struct gl_texture_unit *texUnit;
 383         struct gl_texture_object *texObj;
 384         struct gl_texture_image *texImage;
 385         struct radeon_renderbuffer *rb;
 386         radeon_texture_image *rImage;
 387         radeonContextPtr radeon;
 388         r300ContextPtr rmesa;
 389         struct radeon_framebuffer *rfb;
 390         radeonTexObjPtr t;
 391         uint32_t pitch_val;
 392         uint32_t internalFormat, type, format;
 393
 394         type = GL_BGRA;
 395         format = GL_UNSIGNED_BYTE;
 396         internalFormat = (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT ? 3 : 4);
 397
 398         radeon = pDRICtx->driverPrivate;
 399         rmesa = pDRICtx->driverPrivate;
 400
 401         rfb = dPriv->driverPrivate;
 402         texUnit = &radeon->glCtx->Texture.Unit[radeon->glCtx->Texture.CurrentUnit];
 403         texObj = _mesa_select_tex_object(radeon->glCtx, texUnit, target);
 404         texImage = _mesa_get_tex_image(radeon->glCtx, texObj, target, 0);
 405
 406         rImage = get_radeon_texture_image(texImage);
 407         t = radeon_tex_obj(texObj);
 408         if (t == NULL) {
 409             return;
 410         }
 411
 412         radeon_update_renderbuffers(pDRICtx, dPriv);
 413         /* back & depth buffer are useless free them right away */
 414         rb = (void*)rfb->base.Attachment[BUFFER_DEPTH].Renderbuffer;
 415         if (rb && rb->bo) {
 416                 radeon_bo_unref(rb->bo);
 417         rb->bo = NULL;
 418         }
 419         rb = (void*)rfb->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 420         if (rb && rb->bo) {
 421                 radeon_bo_unref(rb->bo);
 422                 rb->bo = NULL;
 423         }
 424         rb = rfb->color_rb[0];
 425         if (rb->bo == NULL) {
 426                 /* Failed to BO for the buffer */
 427                 return;
 428         }
 429
 430         _mesa_lock_texture(radeon->glCtx, texObj);
 431         if (t->bo) {
 432                 radeon_bo_unref(t->bo);
 433                 t->bo = NULL;
 434         }
 435         if (rImage->bo) {
 436                 radeon_bo_unref(rImage->bo);
 437                 rImage->bo = NULL;
 438         }
 439
 440         radeon_miptree_unreference(&t->mt);
 441         radeon_miptree_unreference(&rImage->mt);
 442
 443         _mesa_init_teximage_fields(radeon->glCtx, target, texImage,
 444                                    rb->base.Width, rb->base.Height, 1, 0, rb->cpp);
 445         texImage->RowStride = rb->pitch / rb->cpp;
 446         rImage->bo = rb->bo;
 447         radeon_bo_ref(rImage->bo);
 448         t->bo = rb->bo;
 449         radeon_bo_ref(t->bo);
 450         t->tile_bits = 0;
 451         t->image_override = GL_TRUE;
 452         t->override_offset = 0;
 453         t->pp_txpitch &= (1 << 13) -1;
 454         pitch_val = rb->pitch;
 455         switch (rb->cpp) {
 456         case 4:
 457                 if (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT)
 458                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 459                 else
 460                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 461                 t->pp_txfilter |= tx_table[2].filter;
 462                 pitch_val /= 4;
 463                 break;
 464         case 3:
 465         default:
 466                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 467                 t->pp_txfilter |= tx_table[4].filter;
 468                 pitch_val /= 4;
 469                 break;
 470         case 2:
 471                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 472                 t->pp_txfilter |= tx_table[5].filter;
 473                 pitch_val /= 2;
 474                 break;
 475         }
 476         pitch_val--;
 477         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((rb->base.Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 478                         | ((R300_TX_HEIGHTMASK_MASK & ((rb->base.Height - 1) << R300_TX_HEIGHTMASK_SHIFT))));
 479         t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 480         t->pp_txpitch |= pitch_val;
 481
 482         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 483             if (rb->base.Width > 2048)
 484                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 485             else
 486                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 487             if (rb->base.Height > 2048)
 488                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 489             else
 490                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 491         }
 492         t->validated = GL_TRUE;
 493         _mesa_unlock_texture(radeon->glCtx, texObj);
 494         return;
 495 }
 496
 497 void r300SetTexBuffer(__DRIcontext *pDRICtx, GLint target, __DRIdrawable *dPriv)
 498 {
 499         r300SetTexBuffer2(pDRICtx, target, GLX_TEXTURE_FORMAT_RGBA_EXT, dPriv);
 500 }