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(RGB888, R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8)),
  87         _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  88         _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  89         _ASSIGN(ARGB4444, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  90         _ASSIGN(ARGB4444_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  91         _ASSIGN(ARGB1555, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  92         _ASSIGN(ARGB1555_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  93         _ASSIGN(AL88, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  94         _ASSIGN(AL88_REV, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  95         _ASSIGN(RGB332, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z3Y3X2)),
  96         _ASSIGN(A8, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X8)),
  97         _ASSIGN(L8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8)),
  98         _ASSIGN(I8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
  99         _ASSIGN(CI8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 100         _ASSIGN(YCBCR, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 101         _ASSIGN(YCBCR_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 102         _ASSIGN(RGB_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, ONE, DXT1)),
 103         _ASSIGN(RGBA_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT1)),
 104         _ASSIGN(RGBA_DXT3, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT3)),
 105         _ASSIGN(RGBA_DXT5, R300_EASY_TX_FORMAT(Y, Z, W, X, DXT5)),
 106         _ASSIGN(RGBA_FLOAT32, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R32G32B32A32)),
 107         _ASSIGN(RGBA_FLOAT16, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R16G16B16A16)),
 108         _ASSIGN(RGB_FLOAT32, 0xffffffff),
 109         _ASSIGN(RGB_FLOAT16, 0xffffffff),
 110         _ASSIGN(ALPHA_FLOAT32, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I32)),
 111         _ASSIGN(ALPHA_FLOAT16, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I16)),
 112         _ASSIGN(LUMINANCE_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I32)),
 113         _ASSIGN(LUMINANCE_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I16)),
 114         _ASSIGN(LUMINANCE_ALPHA_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I32A32)),
 115         _ASSIGN(LUMINANCE_ALPHA_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I16A16)),
 116         _ASSIGN(INTENSITY_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, X, FL_I32)),
 117         _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
 118         _ASSIGN(Z16, R300_EASY_TX_FORMAT(X, X, X, X, X16)),
 119         _ASSIGN(Z24_S8, R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8)),
 120         _ASSIGN(S8_Z24, R300_EASY_TX_FORMAT(Y, Y, Y, Y, X24_Y8)),
 121         _ASSIGN(Z32, R300_EASY_TX_FORMAT(X, X, X, X, X32)),
 122         /* EXT_texture_sRGB */
 123         _ASSIGN(SRGBA8, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8) | R300_TX_FORMAT_GAMMA),
 124         _ASSIGN(SLA8, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8) | R300_TX_FORMAT_GAMMA),
 125         _ASSIGN(SL8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8) | R300_TX_FORMAT_GAMMA),
 126         /* *INDENT-ON* */
 127 };
 128
 129 #undef _ASSIGN
 130
 131 void r300SetDepthTexMode(struct gl_texture_object *tObj)
 132 {
 133         static const GLuint formats[3][3] = {
 134                 {
 135                         R300_EASY_TX_FORMAT(X, X, X, ONE, X16),
 136                         R300_EASY_TX_FORMAT(X, X, X, X, X16),
 137                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X16),
 138                 },
 139                 {
 140                         R300_EASY_TX_FORMAT(X, X, X, ONE, X24_Y8),
 141                         R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8),
 142                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X24_Y8),
 143                 },
 144                 {
 145                         R300_EASY_TX_FORMAT(X, X, X, ONE, X32),
 146                         R300_EASY_TX_FORMAT(X, X, X, X, X32),
 147                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X32),
 148                 },
 149         };
 150         const GLuint *format;
 151         radeonTexObjPtr t;
 152
 153         if (!tObj)
 154                 return;
 155
 156         t = radeon_tex_obj(tObj);
 157
 158         switch (tObj->Image[0][tObj->BaseLevel]->TexFormat) {
 159         case MESA_FORMAT_Z16:
 160                 format = formats[0];
 161                 break;
 162         case MESA_FORMAT_S8_Z24:
 163                 format = formats[1];
 164                 break;
 165         case MESA_FORMAT_Z32:
 166                 format = formats[2];
 167                 break;
 168         default:
 169                 /* Error...which should have already been caught by higher
 170                  * levels of Mesa.
 171                  */
 172                 ASSERT(0);
 173                 return;
 174         }
 175
 176         switch (tObj->DepthMode) {
 177         case GL_LUMINANCE:
 178                 t->pp_txformat = format[0];
 179                 break;
 180         case GL_INTENSITY:
 181                 t->pp_txformat = format[1];
 182                 break;
 183         case GL_ALPHA:
 184                 t->pp_txformat = format[2];
 185                 break;
 186         default:
 187                 /* Error...which should have already been caught by higher
 188                  * levels of Mesa.
 189                  */
 190                 ASSERT(0);
 191                 return;
 192         }
 193 }
 194
 195
 196 /**
 197  * Compute the cached hardware register values for the given texture object.
 198  *
 199  * \param rmesa Context pointer
 200  * \param t the r300 texture object
 201  */
 202 static void setup_hardware_state(r300ContextPtr rmesa, radeonTexObj *t)
 203 {
 204         const struct gl_texture_image *firstImage;
 205         int firstlevel = t->mt ? t->mt->firstLevel : 0;
 206
 207         firstImage = t->base.Image[0][firstlevel];
 208
 209         if (!t->image_override
 210             && VALID_FORMAT(firstImage->TexFormat)) {
 211                 if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
 212                         r300SetDepthTexMode(&t->base);
 213                 } else {
 214                         t->pp_txformat = tx_table[firstImage->TexFormat].format;
 215                 }
 216
 217                 t->pp_txfilter |= tx_table[firstImage->TexFormat].filter;
 218         } else if (!t->image_override) {
 219                 _mesa_problem(NULL, "unexpected texture format in %s",
 220                               __FUNCTION__);
 221                 return;
 222         }
 223
 224         if (t->image_override && t->bo)
 225                 return;
 226
 227         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((firstImage->Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 228                         | ((R300_TX_HEIGHTMASK_MASK & ((firstImage->Height - 1) << R300_TX_HEIGHTMASK_SHIFT)))
 229                         | ((R300_TX_DEPTHMASK_MASK & ((firstImage->DepthLog2) << R300_TX_DEPTHMASK_SHIFT)))
 230                         | ((R300_TX_MAX_MIP_LEVEL_MASK & ((t->mt->lastLevel - t->mt->firstLevel) << R300_TX_MAX_MIP_LEVEL_SHIFT))));
 231
 232         t->tile_bits = 0;
 233
 234         if (t->base.Target == GL_TEXTURE_CUBE_MAP)
 235                 t->pp_txformat |= R300_TX_FORMAT_CUBIC_MAP;
 236         if (t->base.Target == GL_TEXTURE_3D)
 237                 t->pp_txformat |= R300_TX_FORMAT_3D;
 238
 239
 240         if (t->base.Target == GL_TEXTURE_RECTANGLE_NV) {
 241                 unsigned int align = (64 / t->mt->bpp) - 1;
 242                 t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 243                 if (!t->image_override)
 244                         t->pp_txpitch = ((firstImage->Width + align) & ~align) - 1;
 245         }
 246
 247         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 248             if (firstImage->Width > 2048)
 249                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 250             else
 251                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 252             if (firstImage->Height > 2048)
 253                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 254             else
 255                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 256         }
 257 }
 258
 259 /**
 260  * Ensure the given texture is ready for rendering.
 261  *
 262  * Mostly this means populating the texture object's mipmap tree.
 263  */
 264 static GLboolean r300_validate_texture(GLcontext * ctx, struct gl_texture_object *texObj)
 265 {
 266         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 267         radeonTexObj *t = radeon_tex_obj(texObj);
 268
 269         if (!radeon_validate_texture_miptree(ctx, texObj))
 270                 return GL_FALSE;
 271
 272         /* Configure the hardware registers (more precisely, the cached version
 273          * of the hardware registers). */
 274         setup_hardware_state(rmesa, t);
 275
 276         t->validated = GL_TRUE;
 277         return GL_TRUE;
 278 }
 279
 280 /**
 281  * Ensure all enabled and complete textures are uploaded along with any buffers being used.
 282  */
 283 GLboolean r300ValidateBuffers(GLcontext * ctx)
 284 {
 285         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 286         struct radeon_renderbuffer *rrb;
 287         int i;
 288         int ret;
 289
 290         radeon_cs_space_reset_bos(rmesa->radeon.cmdbuf.cs);
 291
 292         rrb = radeon_get_colorbuffer(&rmesa->radeon);
 293         /* color buffer */
 294         if (rrb && rrb->bo) {
 295                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 296                                                   rrb->bo, 0,
 297                                                   RADEON_GEM_DOMAIN_VRAM);
 298         }
 299
 300         /* depth buffer */
 301         rrb = radeon_get_depthbuffer(&rmesa->radeon);
 302         if (rrb && rrb->bo) {
 303                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 304                                                   rrb->bo, 0,
 305                                                   RADEON_GEM_DOMAIN_VRAM);
 306         }
 307
 308         for (i = 0; i < ctx->Const.MaxTextureImageUnits; ++i) {
 309                 radeonTexObj *t;
 310
 311                 if (!ctx->Texture.Unit[i]._ReallyEnabled)
 312                         continue;
 313
 314                 if (!r300_validate_texture(ctx, ctx->Texture.Unit[i]._Current)) {
 315                         _mesa_warning(ctx,
 316                                       "failed to validate texture for unit %d.\n",
 317                                       i);
 318                 }
 319                 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
 320                 if (t->image_override && t->bo)
 321                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 322                                                           t->bo,
 323                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 324                 else if (t->mt->bo)
 325                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 326                                                           t->mt->bo,
 327                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 328         }
 329
 330         ret = radeon_cs_space_check_with_bo(rmesa->radeon.cmdbuf.cs, first_elem(&rmesa->radeon.dma.reserved)->bo, RADEON_GEM_DOMAIN_GTT, 0);
 331         if (ret)
 332                 return GL_FALSE;
 333         return GL_TRUE;
 334 }
 335
 336 void r300SetTexOffset(__DRIcontext * pDRICtx, GLint texname,
 337                       unsigned long long offset, GLint depth, GLuint pitch)
 338 {
 339         r300ContextPtr rmesa = pDRICtx->driverPrivate;
 340         struct gl_texture_object *tObj =
 341             _mesa_lookup_texture(rmesa->radeon.glCtx, texname);
 342         radeonTexObjPtr t = radeon_tex_obj(tObj);
 343         uint32_t pitch_val;
 344
 345         if (!tObj)
 346                 return;
 347
 348         t->image_override = GL_TRUE;
 349
 350         if (!offset)
 351                 return;
 352
 353         t->bo = NULL;
 354         t->override_offset = offset;
 355         t->pp_txpitch &= (1 << 13) -1;
 356         pitch_val = pitch;
 357
 358         switch (depth) {
 359         case 32:
 360                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 361                 t->pp_txfilter |= tx_table[2].filter;
 362                 pitch_val /= 4;
 363                 break;
 364         case 24:
 365         default:
 366                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 367                 t->pp_txfilter |= tx_table[4].filter;
 368                 pitch_val /= 4;
 369                 break;
 370         case 16:
 371                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 372                 t->pp_txfilter |= tx_table[5].filter;
 373                 pitch_val /= 2;
 374                 break;
 375         }
 376         pitch_val--;
 377
 378         t->pp_txpitch |= pitch_val;
 379 }
 380
 381 void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_format, __DRIdrawable *dPriv)
 382 {
 383         struct gl_texture_unit *texUnit;
 384         struct gl_texture_object *texObj;
 385         struct gl_texture_image *texImage;
 386         struct radeon_renderbuffer *rb;
 387         radeon_texture_image *rImage;
 388         radeonContextPtr radeon;
 389         r300ContextPtr rmesa;
 390         struct radeon_framebuffer *rfb;
 391         radeonTexObjPtr t;
 392         uint32_t pitch_val;
 393         uint32_t internalFormat, type, format;
 394
 395         type = GL_BGRA;
 396         format = GL_UNSIGNED_BYTE;
 397         internalFormat = (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT ? 3 : 4);
 398
 399         radeon = pDRICtx->driverPrivate;
 400         rmesa = pDRICtx->driverPrivate;
 401
 402         rfb = dPriv->driverPrivate;
 403         texUnit = &radeon->glCtx->Texture.Unit[radeon->glCtx->Texture.CurrentUnit];
 404         texObj = _mesa_select_tex_object(radeon->glCtx, texUnit, target);
 405         texImage = _mesa_get_tex_image(radeon->glCtx, texObj, target, 0);
 406
 407         rImage = get_radeon_texture_image(texImage);
 408         t = radeon_tex_obj(texObj);
 409         if (t == NULL) {
 410             return;
 411         }
 412
 413         radeon_update_renderbuffers(pDRICtx, dPriv);
 414         /* back & depth buffer are useless free them right away */
 415         rb = (void*)rfb->base.Attachment[BUFFER_DEPTH].Renderbuffer;
 416         if (rb && rb->bo) {
 417                 radeon_bo_unref(rb->bo);
 418         rb->bo = NULL;
 419         }
 420         rb = (void*)rfb->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 421         if (rb && rb->bo) {
 422                 radeon_bo_unref(rb->bo);
 423                 rb->bo = NULL;
 424         }
 425         rb = rfb->color_rb[0];
 426         if (rb->bo == NULL) {
 427                 /* Failed to BO for the buffer */
 428                 return;
 429         }
 430
 431         _mesa_lock_texture(radeon->glCtx, texObj);
 432         if (t->bo) {
 433                 radeon_bo_unref(t->bo);
 434                 t->bo = NULL;
 435         }
 436         if (rImage->bo) {
 437                 radeon_bo_unref(rImage->bo);
 438                 rImage->bo = NULL;
 439         }
 440         if (t->mt) {
 441                 radeon_miptree_unreference(t->mt);
 442                 t->mt = NULL;
 443         }
 444         if (rImage->mt) {
 445                 radeon_miptree_unreference(rImage->mt);
 446                 rImage->mt = NULL;
 447         }
 448         _mesa_init_teximage_fields(radeon->glCtx, target, texImage,
 449                                    rb->base.Width, rb->base.Height, 1, 0, rb->cpp);
 450         texImage->RowStride = rb->pitch / rb->cpp;
 451         rImage->bo = rb->bo;
 452         radeon_bo_ref(rImage->bo);
 453         t->bo = rb->bo;
 454         radeon_bo_ref(t->bo);
 455         t->tile_bits = 0;
 456         t->image_override = GL_TRUE;
 457         t->override_offset = 0;
 458         t->pp_txpitch &= (1 << 13) -1;
 459         pitch_val = rb->pitch;
 460         switch (rb->cpp) {
 461         case 4:
 462                 if (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT)
 463                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 464                 else
 465                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 466                 t->pp_txfilter |= tx_table[2].filter;
 467                 pitch_val /= 4;
 468                 break;
 469         case 3:
 470         default:
 471                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 472                 t->pp_txfilter |= tx_table[4].filter;
 473                 pitch_val /= 4;
 474                 break;
 475         case 2:
 476                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 477                 t->pp_txfilter |= tx_table[5].filter;
 478                 pitch_val /= 2;
 479                 break;
 480         }
 481         pitch_val--;
 482         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((rb->base.Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 483                         | ((R300_TX_HEIGHTMASK_MASK & ((rb->base.Height - 1) << R300_TX_HEIGHTMASK_SHIFT))));
 484         t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 485         t->pp_txpitch |= pitch_val;
 486
 487         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 488             if (rb->base.Width > 2048)
 489                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 490             else
 491                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 492             if (rb->base.Height > 2048)
 493                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 494             else
 495                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 496         }
 497         t->validated = GL_TRUE;
 498         _mesa_unlock_texture(radeon->glCtx, texObj);
 499         return;
 500 }
 501
 502 void r300SetTexBuffer(__DRIcontext *pDRICtx, GLint target, __DRIdrawable *dPriv)
 503 {
 504         r300SetTexBuffer2(pDRICtx, target, GLX_TEXTURE_FORMAT_RGBA_EXT, dPriv);
 505 }