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