← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/r300/r300_texstate.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/r300/r300_texstate.c
47
47
#include "r300_tex.h"
48
48
#include "r300_reg.h"
49
49
 
50
 
#define R200_TXFORMAT_A8        R200_TXFORMAT_I8
51
 
#define R200_TXFORMAT_L8        R200_TXFORMAT_I8
52
 
#define R200_TXFORMAT_AL88      R200_TXFORMAT_AI88
53
 
#define R200_TXFORMAT_YCBCR     R200_TXFORMAT_YVYU422
54
 
#define R200_TXFORMAT_YCBCR_REV R200_TXFORMAT_VYUY422
55
 
#define R200_TXFORMAT_RGB_DXT1  R200_TXFORMAT_DXT1
56
 
#define R200_TXFORMAT_RGBA_DXT1 R200_TXFORMAT_DXT1
57
 
#define R200_TXFORMAT_RGBA_DXT3 R200_TXFORMAT_DXT23
58
 
#define R200_TXFORMAT_RGBA_DXT5 R200_TXFORMAT_DXT45
59
 
 
60
 
#define _COLOR(f) \
61
 
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f, 0 }
62
 
#define _COLOR_REV(f) \
63
 
    [ MESA_FORMAT_ ## f ## _REV ] = { R200_TXFORMAT_ ## f, 0 }
64
 
#define _ALPHA(f) \
65
 
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f | R200_TXFORMAT_ALPHA_IN_MAP, 0 }
66
 
#define _ALPHA_REV(f) \
67
 
    [ MESA_FORMAT_ ## f ## _REV ] = { R200_TXFORMAT_ ## f | R200_TXFORMAT_ALPHA_IN_MAP, 0 }
68
 
#define _YUV(f) \
69
 
    [ MESA_FORMAT_ ## f ] = { R200_TXFORMAT_ ## f, R200_YUV_TO_RGB }
70
 
#define _INVALID(f) \
71
 
    [ MESA_FORMAT_ ## f ] = { 0xffffffff, 0 }
72
 
#define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5 \
73
 
        || ((f) >= MESA_FORMAT_RGBA_FLOAT32 && (f) <= MESA_FORMAT_INTENSITY_FLOAT16)) \
74
 
                             && tx_table[f].flag )
75
 
 
76
 
#define _ASSIGN(entry, format)  \
 
50
 
 
51
#define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5                 \
 
52
                           || ((f) >= MESA_FORMAT_RGBA_FLOAT32 &&       \
 
53
                               (f) <= MESA_FORMAT_INTENSITY_FLOAT16))   \
 
54
                          && tx_table_le[f].flag )
 
55
 
 
56
#define _ASSIGN(entry, format)                          \
77
57
        [ MESA_FORMAT_ ## entry ] = { format, 0, 1}
78
58
 
79
59
static const struct {
80
 
        GLuint format, filter;
81
 
} tx_table0[] = {
82
 
            _ALPHA(RGBA8888),
83
 
            _ALPHA_REV(RGBA8888),
84
 
            _ALPHA(ARGB8888),
85
 
            _ALPHA_REV(ARGB8888),
86
 
            _INVALID(RGB888),
87
 
            _COLOR(RGB565),
88
 
            _COLOR_REV(RGB565),
89
 
            _ALPHA(ARGB4444),
90
 
            _ALPHA_REV(ARGB4444),
91
 
            _ALPHA(ARGB1555),
92
 
            _ALPHA_REV(ARGB1555),
93
 
            _ALPHA(AL88),
94
 
            _ALPHA_REV(AL88),
95
 
            _ALPHA(A8),
96
 
            _COLOR(L8),
97
 
            _ALPHA(I8),
98
 
            _INVALID(CI8),
99
 
            _YUV(YCBCR),
100
 
            _YUV(YCBCR_REV),
101
 
            _INVALID(RGB_FXT1),
102
 
            _INVALID(RGBA_FXT1),
103
 
            _COLOR(RGB_DXT1),
104
 
            _ALPHA(RGBA_DXT1),
105
 
            _ALPHA(RGBA_DXT3),
106
 
            _ALPHA(RGBA_DXT5),
107
 
            };
108
 
 
109
 
static const struct {
110
60
        GLuint format, filter, flag;
111
 
} tx_table[] = {
 
61
} tx_table_be[] = {
112
62
        /*
113
63
         * Note that the _REV formats are the same as the non-REV formats.
114
64
         * This is because the REV and non-REV formats are identical as a
118
68
         * byte-swapping), the R300 sees the REV and non-REV formats
119
69
         * identically.  -- paulus
120
70
         */
 
71
            _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
 
72
            _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
 
73
            _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
 
74
            _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
 
75
            _ASSIGN(RGB888, 0xffffffff),
 
76
            _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
 
77
            _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
 
78
            _ASSIGN(ARGB4444, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
 
79
            _ASSIGN(ARGB4444_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
 
80
            _ASSIGN(ARGB1555, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
 
81
            _ASSIGN(ARGB1555_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
 
82
            _ASSIGN(AL88, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
 
83
            _ASSIGN(AL88_REV, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
 
84
            _ASSIGN(RGB332, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z3Y3X2)),
 
85
            _ASSIGN(A8, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X8)),
 
86
            _ASSIGN(L8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8)),
 
87
            _ASSIGN(I8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 
88
            _ASSIGN(CI8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 
89
            _ASSIGN(YCBCR, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8)|R300_TX_FORMAT_YUV_MODE ),
 
90
            _ASSIGN(YCBCR_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8)|R300_TX_FORMAT_YUV_MODE),
 
91
            _ASSIGN(RGB_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, ONE, DXT1)),
 
92
            _ASSIGN(RGBA_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT1)),
 
93
            _ASSIGN(RGBA_DXT3, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT3)),
 
94
            _ASSIGN(RGBA_DXT5, R300_EASY_TX_FORMAT(Y, Z, W, X, DXT5)),
 
95
            _ASSIGN(RGBA_FLOAT32, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R32G32B32A32)),
 
96
            _ASSIGN(RGBA_FLOAT16, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R16G16B16A16)),
 
97
            _ASSIGN(RGB_FLOAT32, 0xffffffff),
 
98
            _ASSIGN(RGB_FLOAT16, 0xffffffff),
 
99
            _ASSIGN(ALPHA_FLOAT32, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I32)),
 
100
            _ASSIGN(ALPHA_FLOAT16, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I16)),
 
101
            _ASSIGN(LUMINANCE_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I32)),
 
102
            _ASSIGN(LUMINANCE_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I16)),
 
103
            _ASSIGN(LUMINANCE_ALPHA_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I32A32)),
 
104
            _ASSIGN(LUMINANCE_ALPHA_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I16A16)),
 
105
            _ASSIGN(INTENSITY_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, X, FL_I32)),
 
106
            _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
 
107
            };
 
108
 
 
109
static const struct {
 
110
        GLuint format, filter, flag;
 
111
} tx_table_le[] = {
121
112
            _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
122
 
            _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
 
113
            _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
123
114
            _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
124
 
            _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
 
115
            _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
125
116
            _ASSIGN(RGB888, 0xffffffff),
126
117
            _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
127
118
            _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
156
147
            _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
157
148
            };
158
149
 
159
 
#undef _COLOR
160
 
#undef _ALPHA
161
 
#undef _INVALID
162
150
#undef _ASSIGN
163
151
 
164
152
 
186
174
 
187
175
        /* Set the hardware texture format
188
176
         */
189
 
 
190
 
        t->format &= ~(R200_TXFORMAT_FORMAT_MASK |
191
 
                            R200_TXFORMAT_ALPHA_IN_MAP);
192
 
 
193
 
        if (VALID_FORMAT(baseImage->TexFormat->MesaFormat) &&
194
 
            tx_table[baseImage->TexFormat->MesaFormat].flag) {
195
 
                t->format =
196
 
                    tx_table[baseImage->TexFormat->MesaFormat].format;
197
 
#if 1
198
 
                t->filter |=
199
 
                    tx_table[baseImage->TexFormat->MesaFormat].filter;
200
 
#endif
 
177
        if (VALID_FORMAT(baseImage->TexFormat->MesaFormat)) {
 
178
                if (_mesa_little_endian()) {
 
179
                        t->format =
 
180
                            tx_table_le[baseImage->TexFormat->MesaFormat].format;
 
181
                        t->filter |=
 
182
                            tx_table_le[baseImage->TexFormat->MesaFormat].filter;
 
183
                } else {
 
184
                        t->format =
 
185
                            tx_table_be[baseImage->TexFormat->MesaFormat].format;
 
186
                        t->filter |=
 
187
                            tx_table_be[baseImage->TexFormat->MesaFormat].filter;
 
188
                }
201
189
        } else {
202
190
                _mesa_problem(NULL, "unexpected texture format in %s",
203
191
                              __FUNCTION__);
208
196
 
209
197
        /* Compute which mipmap levels we really want to send to the hardware.
210
198
         */
211
 
 
212
199
        driCalculateTextureFirstLastLevel((driTextureObject *) t);
213
200
        log2Width = tObj->Image[0][t->base.firstLevel]->WidthLog2;
214
201
        log2Height = tObj->Image[0][t->base.firstLevel]->HeightLog2;
223
210
         * memory organized as a rectangle of width BLIT_WIDTH_BYTES.
224
211
         */
225
212
        curOffset = 0;
226
 
        blitWidth = BLIT_WIDTH_BYTES;
 
213
        blitWidth = R300_BLIT_WIDTH_BYTES;
227
214
        t->tile_bits = 0;
228
215
 
229
216
        /* figure out if this texture is suitable for tiling. */
311
298
            t->image[0][i].width = MIN2(size / texelBytes, blitWidth);
312
299
            t->image[0][i].height = (size / texelBytes) / t->image[0][i].width;
313
300
          } else {
314
 
            t->image[0][i].x = curOffset % BLIT_WIDTH_BYTES;
315
 
            t->image[0][i].y = curOffset / BLIT_WIDTH_BYTES;
316
 
            t->image[0][i].width = MIN2(size, BLIT_WIDTH_BYTES);
 
301
            t->image[0][i].x = curOffset % R300_BLIT_WIDTH_BYTES;
 
302
            t->image[0][i].y = curOffset / R300_BLIT_WIDTH_BYTES;
 
303
            t->image[0][i].width = MIN2(size, R300_BLIT_WIDTH_BYTES);
317
304
            t->image[0][i].height = size / t->image[0][i].width;
318
305
          }
319
306
#if 0
320
307
          /* for debugging only and only  applicable to non-rectangle targets */
321
308
          assert(size % t->image[0][i].width == 0);
322
309
          assert(t->image[0][i].x == 0
323
 
                 || (size < BLIT_WIDTH_BYTES
 
310
                 || (size < R300_BLIT_WIDTH_BYTES
324
311
                     && t->image[0][i].height == 1));
325
312
#endif
326
313
          
367
354
        t->format |= ((log2Width << R200_TXFORMAT_WIDTH_SHIFT) |
368
355
                           (log2Height << R200_TXFORMAT_HEIGHT_SHIFT));
369
356
#endif
370
 
 
 
357
#if 0
371
358
        t->format_x &= ~(R200_DEPTH_LOG2_MASK | R200_TEXCOORD_MASK);
372
359
        if (tObj->Target == GL_TEXTURE_3D) {
373
360
                t->format_x |= (log2Depth << R200_DEPTH_LOG2_SHIFT);
386
373
                                     (log2Width << R200_FACE_WIDTH_4_SHIFT) |
387
374
                                     (log2Height << R200_FACE_HEIGHT_4_SHIFT));
388
375
        }
 
376
#endif
 
377
        if (tObj->Target == GL_TEXTURE_CUBE_MAP) {
 
378
                ASSERT(log2Width == log2Height);
 
379
                t->format |= R300_TX_FORMAT_CUBIC_MAP;
 
380
        }
389
381
        
390
382
        t->size = (((tObj->Image[0][t->base.firstLevel]->Width - 1) << R300_TX_WIDTHMASK_SHIFT)
391
383
                        |((tObj->Image[0][t->base.firstLevel]->Height - 1) << R300_TX_HEIGHTMASK_SHIFT))
452
444
 
453
445
        /* Need to load the 3d images associated with this unit.
454
446
         */
 
447
#if 0
455
448
        if (t->format & R200_TXFORMAT_NON_POWER2) {
456
449
                t->format &= ~R200_TXFORMAT_NON_POWER2;
457
450
                t->base.dirty_images[0] = ~0;
458
451
        }
459
 
 
 
452
#endif
460
453
        ASSERT(tObj->Target == GL_TEXTURE_3D);
461
454
 
462
455
        /* R100 & R200 do not support mipmaps for 3D textures.
487
480
 
488
481
        /* Need to load the 2d images associated with this unit.
489
482
         */
 
483
#if 0
490
484
        if (t->format & R200_TXFORMAT_NON_POWER2) {
491
485
                t->format &= ~R200_TXFORMAT_NON_POWER2;
492
486
                for (face = 0; face < 6; face++)
493
487
                        t->base.dirty_images[face] = ~0;
494
488
        }
495
 
 
 
489
#endif
496
490
        ASSERT(tObj->Target == GL_TEXTURE_CUBE_MAP);
497
491
 
498
492
        if (t->base.dirty_images[0] || t->base.dirty_images[1] ||
571
565
                driUpdateTextureLRU((driTextureObject *) t);    /* XXX: should be locked! */
572
566
        }
573
567
 
574
 
#if R200_MERGED
575
 
        FALLBACK(&rmesa->radeon, RADEON_FALLBACK_BORDER_MODE, t->border_fallback);
576
 
#endif
577
 
                
578
568
        return !t->border_fallback;
579
569
}
580
570
 
618
608
              r300UpdateTextureUnit(ctx, 6) &&
619
609
              r300UpdateTextureUnit(ctx, 7)
620
610
              );
621
 
 
622
 
#if R200_MERGED
623
 
        FALLBACK(&rmesa->radeon, RADEON_FALLBACK_TEXTURE, !ok);
624
 
#endif  
625
611
}