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/texformat.h"
  43 #include "main/teximage.h"
  44 #include "main/texobj.h"
  45 #include "main/enums.h"
  46 #include "main/simple_list.h"
  47
  48 #include "r300_context.h"
  49 #include "r300_state.h"
  50 #include "r300_ioctl.h"
  51 #include "radeon_mipmap_tree.h"
  52 #include "r300_tex.h"
  53 #include "r300_reg.h"
  54
  55 #define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5                 \
  56                            || ((f) >= MESA_FORMAT_RGBA_FLOAT32 &&       \
  57                                (f) <= MESA_FORMAT_INTENSITY_FLOAT16))   \
  58                           && tx_table[f].flag )
  59
  60 #define _ASSIGN(entry, format)                          \
  61         [ MESA_FORMAT_ ## entry ] = { format, 0, 1}
  62
  63 /*
  64  * Note that the _REV formats are the same as the non-REV formats.  This is
  65  * because the REV and non-REV formats are identical as a byte string, but
  66  * differ when accessed as 16-bit or 32-bit words depending on the endianness of
  67  * the host.  Since the textures are transferred to the R300 as a byte string
  68  * (i.e. without any byte-swapping), the R300 sees the REV and non-REV formats
  69  * identically.  -- paulus
  70  */
  71
  72 static const struct tx_table {
  73         GLuint format, filter, flag;
  74 } tx_table[] = {
  75         /* *INDENT-OFF* */
  76 #ifdef MESA_LITTLE_ENDIAN
  77         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  78         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  79         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  80         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  81 #else
  82         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  83         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  84         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  85         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  86 #endif
  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->MesaFormat) {
 160         case MESA_FORMAT_Z16:
 161                 format = formats[0];
 162                 break;
 163         case MESA_FORMAT_Z24_S8:
 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         int firstlevel = t->mt ? t->mt->firstLevel : 0;
 207
 208         firstImage = t->base.Image[0][firstlevel];
 209
 210         if (!t->image_override
 211             && VALID_FORMAT(firstImage->TexFormat->MesaFormat)) {
 212                 if (firstImage->TexFormat->BaseFormat == GL_DEPTH_COMPONENT) {
 213                         r300SetDepthTexMode(&t->base);
 214                 } else {
 215                         t->pp_txformat = tx_table[firstImage->TexFormat->MesaFormat].format;
 216                 }
 217
 218                 t->pp_txfilter |= tx_table[firstImage->TexFormat->MesaFormat].filter;
 219         } else if (!t->image_override) {
 220                 _mesa_problem(NULL, "unexpected texture format in %s",
 221                               __FUNCTION__);
 222                 return;
 223         }
 224
 225         if (t->image_override && t->bo)
 226                 return;
 227
 228         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((firstImage->Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 229                         | ((R300_TX_HEIGHTMASK_MASK & ((firstImage->Height - 1) << R300_TX_HEIGHTMASK_SHIFT)))
 230                         | ((R300_TX_DEPTHMASK_MASK & ((firstImage->DepthLog2) << R300_TX_DEPTHMASK_SHIFT)))
 231                         | ((R300_TX_MAX_MIP_LEVEL_MASK & ((t->mt->lastLevel - t->mt->firstLevel) << R300_TX_MAX_MIP_LEVEL_SHIFT))));
 232
 233         t->tile_bits = 0;
 234
 235         if (t->base.Target == GL_TEXTURE_CUBE_MAP)
 236                 t->pp_txformat |= R300_TX_FORMAT_CUBIC_MAP;
 237         if (t->base.Target == GL_TEXTURE_3D)
 238                 t->pp_txformat |= R300_TX_FORMAT_3D;
 239
 240
 241         if (t->base.Target == GL_TEXTURE_RECTANGLE_NV) {
 242                 unsigned int align = (64 / t->mt->bpp) - 1;
 243                 t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 244                 if (!t->image_override)
 245                         t->pp_txpitch = ((firstImage->Width + align) & ~align) - 1;
 246         }
 247
 248         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 249             if (firstImage->Width > 2048)
 250                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 251             else
 252                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 253             if (firstImage->Height > 2048)
 254                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 255             else
 256                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 257         }
 258 }
 259
 260 /**
 261  * Ensure the given texture is ready for rendering.
 262  *
 263  * Mostly this means populating the texture object's mipmap tree.
 264  */
 265 static GLboolean r300_validate_texture(GLcontext * ctx, struct gl_texture_object *texObj)
 266 {
 267         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 268         radeonTexObj *t = radeon_tex_obj(texObj);
 269
 270         if (!radeon_validate_texture_miptree(ctx, texObj))
 271                 return GL_FALSE;
 272
 273         /* Configure the hardware registers (more precisely, the cached version
 274          * of the hardware registers). */
 275         setup_hardware_state(rmesa, t);
 276
 277         t->validated = GL_TRUE;
 278         return GL_TRUE;
 279 }
 280
 281 /**
 282  * Ensure all enabled and complete textures are uploaded along with any buffers being used.
 283  */
 284 GLboolean r300ValidateBuffers(GLcontext * ctx)
 285 {
 286         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 287         struct radeon_renderbuffer *rrb;
 288         int i;
 289         int ret;
 290
 291         radeon_cs_space_reset_bos(rmesa->radeon.cmdbuf.cs);
 292
 293         rrb = radeon_get_colorbuffer(&rmesa->radeon);
 294         /* color buffer */
 295         if (rrb && rrb->bo) {
 296                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 297                                                   rrb->bo, 0,
 298                                                   RADEON_GEM_DOMAIN_VRAM);
 299         }
 300
 301         /* depth buffer */
 302         rrb = radeon_get_depthbuffer(&rmesa->radeon);
 303         if (rrb && rrb->bo) {
 304                 radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 305                                                   rrb->bo, 0,
 306                                                   RADEON_GEM_DOMAIN_VRAM);
 307         }
 308
 309         for (i = 0; i < ctx->Const.MaxTextureImageUnits; ++i) {
 310                 radeonTexObj *t;
 311
 312                 if (!ctx->Texture.Unit[i]._ReallyEnabled)
 313                         continue;
 314
 315                 if (!r300_validate_texture(ctx, ctx->Texture.Unit[i]._Current)) {
 316                         _mesa_warning(ctx,
 317                                       "failed to validate texture for unit %d.\n",
 318                                       i);
 319                 }
 320                 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
 321                 if (t->image_override && t->bo)
 322                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 323                                                           t->bo,
 324                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 325                 else if (t->mt->bo)
 326                         radeon_cs_space_add_persistent_bo(rmesa->radeon.cmdbuf.cs,
 327                                                           t->mt->bo,
 328                                                           RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 329         }
 330
 331         ret = radeon_cs_space_check_with_bo(rmesa->radeon.cmdbuf.cs, first_elem(&rmesa->radeon.dma.reserved)->bo, RADEON_GEM_DOMAIN_GTT, 0);
 332         if (ret)
 333                 return GL_FALSE;
 334         return GL_TRUE;
 335 }
 336
 337 void r300SetTexOffset(__DRIcontext * pDRICtx, GLint texname,
 338                       unsigned long long offset, GLint depth, GLuint pitch)
 339 {
 340         r300ContextPtr rmesa = pDRICtx->driverPrivate;
 341         struct gl_texture_object *tObj =
 342             _mesa_lookup_texture(rmesa->radeon.glCtx, texname);
 343         radeonTexObjPtr t = radeon_tex_obj(tObj);
 344         uint32_t pitch_val;
 345
 346         if (!tObj)
 347                 return;
 348
 349         t->image_override = GL_TRUE;
 350
 351         if (!offset)
 352                 return;
 353
 354         t->bo = NULL;
 355         t->override_offset = offset;
 356         t->pp_txpitch &= (1 << 13) -1;
 357         pitch_val = pitch;
 358
 359         switch (depth) {
 360         case 32:
 361                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 362                 t->pp_txfilter |= tx_table[2].filter;
 363                 pitch_val /= 4;
 364                 break;
 365         case 24:
 366         default:
 367                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 368                 t->pp_txfilter |= tx_table[4].filter;
 369                 pitch_val /= 4;
 370                 break;
 371         case 16:
 372                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 373                 t->pp_txfilter |= tx_table[5].filter;
 374                 pitch_val /= 2;
 375                 break;
 376         }
 377         pitch_val--;
 378
 379         t->pp_txpitch |= pitch_val;
 380 }
 381
 382 void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_format, __DRIdrawable *dPriv)
 383 {
 384         struct gl_texture_unit *texUnit;
 385         struct gl_texture_object *texObj;
 386         struct gl_texture_image *texImage;
 387         struct radeon_renderbuffer *rb;
 388         radeon_texture_image *rImage;
 389         radeonContextPtr radeon;
 390         r300ContextPtr rmesa;
 391         struct radeon_framebuffer *rfb;
 392         radeonTexObjPtr t;
 393         uint32_t pitch_val;
 394         uint32_t internalFormat, type, format;
 395
 396         type = GL_BGRA;
 397         format = GL_UNSIGNED_BYTE;
 398         internalFormat = (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT ? 3 : 4);
 399
 400         radeon = pDRICtx->driverPrivate;
 401         rmesa = pDRICtx->driverPrivate;
 402
 403         rfb = dPriv->driverPrivate;
 404         texUnit = &radeon->glCtx->Texture.Unit[radeon->glCtx->Texture.CurrentUnit];
 405         texObj = _mesa_select_tex_object(radeon->glCtx, texUnit, target);
 406         texImage = _mesa_get_tex_image(radeon->glCtx, texObj, target, 0);
 407
 408         rImage = get_radeon_texture_image(texImage);
 409         t = radeon_tex_obj(texObj);
 410         if (t == NULL) {
 411             return;
 412         }
 413
 414         radeon_update_renderbuffers(pDRICtx, dPriv);
 415         /* back & depth buffer are useless free them right away */
 416         rb = (void*)rfb->base.Attachment[BUFFER_DEPTH].Renderbuffer;
 417         if (rb && rb->bo) {
 418                 radeon_bo_unref(rb->bo);
 419         rb->bo = NULL;
 420         }
 421         rb = (void*)rfb->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 422         if (rb && rb->bo) {
 423                 radeon_bo_unref(rb->bo);
 424                 rb->bo = NULL;
 425         }
 426         rb = rfb->color_rb[0];
 427         if (rb->bo == NULL) {
 428                 /* Failed to BO for the buffer */
 429                 return;
 430         }
 431
 432         _mesa_lock_texture(radeon->glCtx, texObj);
 433         if (t->bo) {
 434                 radeon_bo_unref(t->bo);
 435                 t->bo = NULL;
 436         }
 437         if (rImage->bo) {
 438                 radeon_bo_unref(rImage->bo);
 439                 rImage->bo = NULL;
 440         }
 441         if (t->mt) {
 442                 radeon_miptree_unreference(t->mt);
 443                 t->mt = NULL;
 444         }
 445         if (rImage->mt) {
 446                 radeon_miptree_unreference(rImage->mt);
 447                 rImage->mt = NULL;
 448         }
 449         _mesa_init_teximage_fields(radeon->glCtx, target, texImage,
 450                                    rb->base.Width, rb->base.Height, 1, 0, rb->cpp);
 451         texImage->RowStride = rb->pitch / rb->cpp;
 452         texImage->TexFormat = radeonChooseTextureFormat(radeon->glCtx,
 453                                                         internalFormat,
 454                                                         type, format, 0);
 455         rImage->bo = rb->bo;
 456         radeon_bo_ref(rImage->bo);
 457         t->bo = rb->bo;
 458         radeon_bo_ref(t->bo);
 459         t->tile_bits = 0;
 460         t->image_override = GL_TRUE;
 461         t->override_offset = 0;
 462         t->pp_txpitch &= (1 << 13) -1;
 463         pitch_val = rb->pitch;
 464         switch (rb->cpp) {
 465         case 4:
 466                 if (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT)
 467                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 468                 else
 469                         t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 470                 t->pp_txfilter |= tx_table[2].filter;
 471                 pitch_val /= 4;
 472                 break;
 473         case 3:
 474         default:
 475                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 476                 t->pp_txfilter |= tx_table[4].filter;
 477                 pitch_val /= 4;
 478                 break;
 479         case 2:
 480                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 481                 t->pp_txfilter |= tx_table[5].filter;
 482                 pitch_val /= 2;
 483                 break;
 484         }
 485         pitch_val--;
 486         t->pp_txsize = (((R300_TX_WIDTHMASK_MASK & ((rb->base.Width - 1) << R300_TX_WIDTHMASK_SHIFT)))
 487                         | ((R300_TX_HEIGHTMASK_MASK & ((rb->base.Height - 1) << R300_TX_HEIGHTMASK_SHIFT))));
 488         t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 489         t->pp_txpitch |= pitch_val;
 490
 491         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 492             if (rb->base.Width > 2048)
 493                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 494             else
 495                 t->pp_txpitch &= ~R500_TXWIDTH_BIT11;
 496             if (rb->base.Height > 2048)
 497                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 498             else
 499                 t->pp_txpitch &= ~R500_TXHEIGHT_BIT11;
 500         }
 501         t->validated = GL_TRUE;
 502         _mesa_unlock_texture(radeon->glCtx, texObj);
 503         return;
 504 }
 505
 506 void r300SetTexBuffer(__DRIcontext *pDRICtx, GLint target, __DRIdrawable *dPriv)
 507 {
 508         r300SetTexBuffer2(pDRICtx, target, GLX_TEXTURE_FORMAT_RGBA_EXT, dPriv);
 509 }