src/mesa/main/texfetch_tmp.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.7
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  * Copyright (c) 2008-2009  VMware, Inc.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /**
  28  * \file texfetch_tmp.h
  29  * Texel fetch functions template.
  30  *
  31  * This template file is used by texfetch.c to generate texel fetch functions
  32  * for 1-D, 2-D and 3-D texture images.
  33  *
  34  * It should be expanded by defining \p DIM as the number texture dimensions
  35  * (1, 2 or 3).  According to the value of \p DIM a series of macros is defined
  36  * for the texel lookup in the gl_texture_image::Data.
  37  *
  38  * \author Gareth Hughes
  39  * \author Brian Paul
  40  */
  41
  42
  43 #if DIM == 1
  44
  45 #define TEXEL_ADDR( type, image, i, j, k, size ) \
  46         ((void) (j), (void) (k), ((type *)(image)->Data + (i) * (size)))
  47
  48 #define FETCH(x) fetch_texel_1d_##x
  49
  50 #elif DIM == 2
  51
  52 #define TEXEL_ADDR( type, image, i, j, k, size )                        \
  53         ((void) (k),                                                    \
  54          ((type *)(image)->Data + ((image)->RowStride * (j) + (i)) * (size)))
  55
  56 #define FETCH(x) fetch_texel_2d_##x
  57
  58 #elif DIM == 3
  59
  60 #define TEXEL_ADDR( type, image, i, j, k, size )                        \
  61         ((type *)(image)->Data + ((image)->ImageOffsets[k]              \
  62              + (image)->RowStride * (j) + (i)) * (size))
  63
  64 #define FETCH(x) fetch_texel_3d_##x
  65
  66 #else
  67 #error  illegal number of texture dimensions
  68 #endif
  69
  70
  71 /* MESA_FORMAT_Z32 ***********************************************************/
  72
  73 /* Fetch depth texel from 1D, 2D or 3D 32-bit depth texture,
  74  * returning 1 GLfloat.
  75  * Note: no GLchan version of this function.
  76  */
  77 static void FETCH(f_z32)( const struct gl_texture_image *texImage,
  78                           GLint i, GLint j, GLint k, GLfloat *texel )
  79 {
  80    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
  81    texel[0] = src[0] * (1.0F / 0xffffffff);
  82 }
  83
  84 #if DIM == 3
  85 static void store_texel_z32(struct gl_texture_image *texImage,
  86                             GLint i, GLint j, GLint k, const void *texel)
  87 {
  88    const GLuint *depth = (const GLuint *) texel;
  89    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
  90    dst[0] = *depth;
  91 }
  92 #endif
  93
  94
  95 /* MESA_FORMAT_Z16 ***********************************************************/
  96
  97 /* Fetch depth texel from 1D, 2D or 3D 16-bit depth texture,
  98  * returning 1 GLfloat.
  99  * Note: no GLchan version of this function.
 100  */
 101 static void FETCH(f_z16)(const struct gl_texture_image *texImage,
 102                          GLint i, GLint j, GLint k, GLfloat *texel )
 103 {
 104    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 105    texel[0] = src[0] * (1.0F / 65535.0F);
 106 }
 107
 108 #if DIM == 3
 109 static void store_texel_z16(struct gl_texture_image *texImage,
 110                             GLint i, GLint j, GLint k, const void *texel)
 111 {
 112    const GLushort *depth = (const GLushort *) texel;
 113    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 114    dst[0] = *depth;
 115 }
 116 #endif
 117
 118
 119 /* MESA_FORMAT_RGBA_F32 ******************************************************/
 120
 121 /* Fetch texel from 1D, 2D or 3D RGBA_FLOAT32 texture, returning 4 GLfloats.
 122  */
 123 static void FETCH(f_rgba_f32)( const struct gl_texture_image *texImage,
 124                                GLint i, GLint j, GLint k, GLfloat *texel )
 125 {
 126    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);
 127    texel[RCOMP] = src[0];
 128    texel[GCOMP] = src[1];
 129    texel[BCOMP] = src[2];
 130    texel[ACOMP] = src[3];
 131 }
 132
 133 #if DIM == 3
 134 static void store_texel_rgba_f32(struct gl_texture_image *texImage,
 135                                  GLint i, GLint j, GLint k, const void *texel)
 136 {
 137    const GLfloat *depth = (const GLfloat *) texel;
 138    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 139    dst[0] = depth[RCOMP];
 140    dst[1] = depth[GCOMP];
 141    dst[2] = depth[BCOMP];
 142    dst[3] = depth[ACOMP];
 143 }
 144 #endif
 145
 146
 147 /* MESA_FORMAT_RGBA_F16 ******************************************************/
 148
 149 /* Fetch texel from 1D, 2D or 3D RGBA_FLOAT16 texture,
 150  * returning 4 GLfloats.
 151  */
 152 static void FETCH(f_rgba_f16)( const struct gl_texture_image *texImage,
 153                                GLint i, GLint j, GLint k, GLfloat *texel )
 154 {
 155    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);
 156    texel[RCOMP] = _mesa_half_to_float(src[0]);
 157    texel[GCOMP] = _mesa_half_to_float(src[1]);
 158    texel[BCOMP] = _mesa_half_to_float(src[2]);
 159    texel[ACOMP] = _mesa_half_to_float(src[3]);
 160 }
 161
 162 #if DIM == 3
 163 static void store_texel_rgba_f16(struct gl_texture_image *texImage,
 164                                  GLint i, GLint j, GLint k, const void *texel)
 165 {
 166    const GLfloat *depth = (const GLfloat *) texel;
 167    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 168    dst[0] = _mesa_float_to_half(*depth);
 169 }
 170 #endif
 171
 172 /* MESA_FORMAT_RGB_F32 *******************************************************/
 173
 174 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT32 texture,
 175  * returning 4 GLfloats.
 176  */
 177 static void FETCH(f_rgb_f32)( const struct gl_texture_image *texImage,
 178                               GLint i, GLint j, GLint k, GLfloat *texel )
 179 {
 180    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
 181    texel[RCOMP] = src[0];
 182    texel[GCOMP] = src[1];
 183    texel[BCOMP] = src[2];
 184    texel[ACOMP] = 1.0F;
 185 }
 186
 187 #if DIM == 3
 188 static void store_texel_rgb_f32(struct gl_texture_image *texImage,
 189                                  GLint i, GLint j, GLint k, const void *texel)
 190 {
 191    const GLfloat *depth = (const GLfloat *) texel;
 192    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 193    dst[0] = *depth;
 194 }
 195 #endif
 196
 197
 198 /* MESA_FORMAT_RGB_F16 *******************************************************/
 199
 200 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT16 texture,
 201  * returning 4 GLfloats.
 202  */
 203 static void FETCH(f_rgb_f16)( const struct gl_texture_image *texImage,
 204                               GLint i, GLint j, GLint k, GLfloat *texel )
 205 {
 206    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
 207    texel[RCOMP] = _mesa_half_to_float(src[0]);
 208    texel[GCOMP] = _mesa_half_to_float(src[1]);
 209    texel[BCOMP] = _mesa_half_to_float(src[2]);
 210    texel[ACOMP] = 1.0F;
 211 }
 212
 213 #if DIM == 3
 214 static void store_texel_rgb_f16(struct gl_texture_image *texImage,
 215                                 GLint i, GLint j, GLint k, const void *texel)
 216 {
 217    const GLfloat *depth = (const GLfloat *) texel;
 218    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 219    dst[0] = _mesa_float_to_half(*depth);
 220 }
 221 #endif
 222
 223
 224 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
 225
 226 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT32 texture,
 227  * returning 4 GLfloats.
 228  */
 229 static void FETCH(f_alpha_f32)( const struct gl_texture_image *texImage,
 230                               GLint i, GLint j, GLint k, GLfloat *texel )
 231 {
 232    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 233    texel[RCOMP] =
 234    texel[GCOMP] =
 235    texel[BCOMP] = 0.0F;
 236    texel[ACOMP] = src[0];
 237 }
 238
 239 #if DIM == 3
 240 static void store_texel_alpha_f32(struct gl_texture_image *texImage,
 241                                   GLint i, GLint j, GLint k, const void *texel)
 242 {
 243    const GLfloat *rgba = (const GLfloat *) texel;
 244    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 245    dst[0] = rgba[ACOMP];
 246 }
 247 #endif
 248
 249
 250 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
 251
 252 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT16 texture,
 253  * returning 4 GLfloats.
 254  */
 255 static void FETCH(f_alpha_f16)( const struct gl_texture_image *texImage,
 256                               GLint i, GLint j, GLint k, GLfloat *texel )
 257 {
 258    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 259    texel[RCOMP] =
 260    texel[GCOMP] =
 261    texel[BCOMP] = 0.0F;
 262    texel[ACOMP] = _mesa_half_to_float(src[0]);
 263 }
 264
 265 #if DIM == 3
 266 static void store_texel_alpha_f16(struct gl_texture_image *texImage,
 267                                   GLint i, GLint j, GLint k, const void *texel)
 268 {
 269    const GLfloat *rgba = (const GLfloat *) texel;
 270    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 271    dst[0] = _mesa_float_to_half(rgba[ACOMP]);
 272 }
 273 #endif
 274
 275
 276 /* MESA_FORMAT_LUMINANCE_F32 *************************************************/
 277
 278 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT32 texture,
 279  * returning 4 GLfloats.
 280  */
 281 static void FETCH(f_luminance_f32)( const struct gl_texture_image *texImage,
 282                                     GLint i, GLint j, GLint k, GLfloat *texel )
 283 {
 284    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 285    texel[RCOMP] =
 286    texel[GCOMP] =
 287    texel[BCOMP] = src[0];
 288    texel[ACOMP] = 1.0F;
 289 }
 290
 291 #if DIM == 3
 292 static void store_texel_luminance_f32(struct gl_texture_image *texImage,
 293                                   GLint i, GLint j, GLint k, const void *texel)
 294 {
 295    const GLfloat *rgba = (const GLfloat *) texel;
 296    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 297    dst[0] = rgba[RCOMP];
 298 }
 299 #endif
 300
 301
 302 /* MESA_FORMAT_LUMINANCE_F16 *************************************************/
 303
 304 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT16 texture,
 305  * returning 4 GLfloats.
 306  */
 307 static void FETCH(f_luminance_f16)( const struct gl_texture_image *texImage,
 308                                     GLint i, GLint j, GLint k, GLfloat *texel )
 309 {
 310    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 311    texel[RCOMP] =
 312    texel[GCOMP] =
 313    texel[BCOMP] = _mesa_half_to_float(src[0]);
 314    texel[ACOMP] = 1.0F;
 315 }
 316
 317 #if DIM == 3
 318 static void store_texel_luminance_f16(struct gl_texture_image *texImage,
 319                                   GLint i, GLint j, GLint k, const void *texel)
 320 {
 321    const GLfloat *rgba = (const GLfloat *) texel;
 322    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 323    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 324 }
 325 #endif
 326
 327
 328 /* MESA_FORMAT_LUMINANCE_ALPHA_F32 *******************************************/
 329
 330 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT32 texture,
 331  * returning 4 GLfloats.
 332  */
 333 static void FETCH(f_luminance_alpha_f32)( const struct gl_texture_image *texImage,
 334                                     GLint i, GLint j, GLint k, GLfloat *texel )
 335 {
 336    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 337    texel[RCOMP] =
 338    texel[GCOMP] =
 339    texel[BCOMP] = src[0];
 340    texel[ACOMP] = src[1];
 341 }
 342
 343 #if DIM == 3
 344 static void store_texel_luminance_alpha_f32(struct gl_texture_image *texImage,
 345                                   GLint i, GLint j, GLint k, const void *texel)
 346 {
 347    const GLfloat *rgba = (const GLfloat *) texel;
 348    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 349    dst[0] = rgba[RCOMP];
 350    dst[1] = rgba[ACOMP];
 351 }
 352 #endif
 353
 354
 355 /* MESA_FORMAT_LUMINANCE_ALPHA_F16 *******************************************/
 356
 357 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT16 texture,
 358  * returning 4 GLfloats.
 359  */
 360 static void FETCH(f_luminance_alpha_f16)( const struct gl_texture_image *texImage,
 361                                     GLint i, GLint j, GLint k, GLfloat *texel )
 362 {
 363    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 364    texel[RCOMP] =
 365    texel[GCOMP] =
 366    texel[BCOMP] = _mesa_half_to_float(src[0]);
 367    texel[ACOMP] = _mesa_half_to_float(src[1]);
 368 }
 369
 370 #if DIM == 3
 371 static void store_texel_luminance_alpha_f16(struct gl_texture_image *texImage,
 372                                   GLint i, GLint j, GLint k, const void *texel)
 373 {
 374    const GLfloat *rgba = (const GLfloat *) texel;
 375    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 376    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 377    dst[1] = _mesa_float_to_half(rgba[ACOMP]);
 378 }
 379 #endif
 380
 381
 382 /* MESA_FORMAT_INTENSITY_F32 *************************************************/
 383
 384 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT32 texture,
 385  * returning 4 GLfloats.
 386  */
 387 static void FETCH(f_intensity_f32)( const struct gl_texture_image *texImage,
 388                                     GLint i, GLint j, GLint k, GLfloat *texel )
 389 {
 390    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 391    texel[RCOMP] =
 392    texel[GCOMP] =
 393    texel[BCOMP] =
 394    texel[ACOMP] = src[0];
 395 }
 396
 397 #if DIM == 3
 398 static void store_texel_intensity_f32(struct gl_texture_image *texImage,
 399                                   GLint i, GLint j, GLint k, const void *texel)
 400 {
 401    const GLfloat *rgba = (const GLfloat *) texel;
 402    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 403    dst[0] = rgba[RCOMP];
 404 }
 405 #endif
 406
 407
 408 /* MESA_FORMAT_INTENSITY_F16 *************************************************/
 409
 410 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT16 texture,
 411  * returning 4 GLfloats.
 412  */
 413 static void FETCH(f_intensity_f16)( const struct gl_texture_image *texImage,
 414                                     GLint i, GLint j, GLint k, GLfloat *texel )
 415 {
 416    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 417    texel[RCOMP] =
 418    texel[GCOMP] =
 419    texel[BCOMP] =
 420    texel[ACOMP] = _mesa_half_to_float(src[0]);
 421 }
 422
 423 #if DIM == 3
 424 static void store_texel_intensity_f16(struct gl_texture_image *texImage,
 425                                   GLint i, GLint j, GLint k, const void *texel)
 426 {
 427    const GLfloat *rgba = (const GLfloat *) texel;
 428    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 429    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 430 }
 431 #endif
 432
 433
 434
 435
 436 /*
 437  * Begin Hardware formats
 438  */
 439
 440 /* MESA_FORMAT_RGBA8888 ******************************************************/
 441
 442 /* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */
 443 static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,
 444                                GLint i, GLint j, GLint k, GLfloat *texel )
 445 {
 446    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 447    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 448    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 449    texel[BCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 450    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 451 }
 452
 453
 454
 455 #if DIM == 3
 456 static void store_texel_rgba8888(struct gl_texture_image *texImage,
 457                                  GLint i, GLint j, GLint k, const void *texel)
 458 {
 459    const GLubyte *rgba = (const GLubyte *) texel;
 460    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 461    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 462 }
 463 #endif
 464
 465
 466 /* MESA_FORMAT_RGBA888_REV ***************************************************/
 467
 468 /* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */
 469 static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,
 470                                    GLint i, GLint j, GLint k, GLfloat *texel )
 471 {
 472    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 473    texel[RCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 474    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 475    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 476    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 477 }
 478
 479 #if DIM == 3
 480 static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,
 481                                   GLint i, GLint j, GLint k, const void *texel)
 482 {
 483    const GLubyte *rgba = (const GLubyte *) texel;
 484    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 485    *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 486 }
 487 #endif
 488
 489
 490 /* MESA_FORMAT_ARGB8888 ******************************************************/
 491
 492 /* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */
 493 static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,
 494                                GLint i, GLint j, GLint k, GLfloat *texel )
 495 {
 496    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 497    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 498    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 499    texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 500    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 501 }
 502
 503 #if DIM == 3
 504 static void store_texel_argb8888(struct gl_texture_image *texImage,
 505                                  GLint i, GLint j, GLint k, const void *texel)
 506 {
 507    const GLubyte *rgba = (const GLubyte *) texel;
 508    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 509    *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 510 }
 511 #endif
 512
 513
 514 /* MESA_FORMAT_ARGB8888_REV **************************************************/
 515
 516 /* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */
 517 static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,
 518                                    GLint i, GLint j, GLint k, GLfloat *texel )
 519 {
 520    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 521    texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 522    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 523    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 524    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 525 }
 526
 527 #if DIM == 3
 528 static void store_texel_argb8888_rev(struct gl_texture_image *texImage,
 529                                   GLint i, GLint j, GLint k, const void *texel)
 530 {
 531    const GLubyte *rgba = (const GLubyte *) texel;
 532    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 533    *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], rgba[ACOMP]);
 534 }
 535 #endif
 536
 537
 538 /* MESA_FORMAT_XRGB8888 ******************************************************/
 539
 540 /* Fetch texel from 1D, 2D or 3D xrgb8888 texture, return 4 GLchans */
 541 static void FETCH(f_xrgb8888)( const struct gl_texture_image *texImage,
 542                                GLint i, GLint j, GLint k, GLfloat *texel )
 543 {
 544    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 545    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 546    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 547    texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 548    texel[ACOMP] = 1.0f;
 549 }
 550
 551 #if DIM == 3
 552 static void store_texel_xrgb8888(struct gl_texture_image *texImage,
 553                                  GLint i, GLint j, GLint k, const void *texel)
 554 {
 555    const GLubyte *rgba = (const GLubyte *) texel;
 556    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 557    *dst = PACK_COLOR_8888(0xff, rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 558 }
 559 #endif
 560
 561
 562 /* MESA_FORMAT_XRGB8888_REV **************************************************/
 563
 564 /* Fetch texel from 1D, 2D or 3D xrgb8888_rev texture, return 4 GLfloats */
 565 static void FETCH(f_xrgb8888_rev)( const struct gl_texture_image *texImage,
 566                                    GLint i, GLint j, GLint k, GLfloat *texel )
 567 {
 568    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 569    texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 570    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 571    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 572    texel[ACOMP] = 1.0f;
 573 }
 574
 575 #if DIM == 3
 576 static void store_texel_xrgb8888_rev(struct gl_texture_image *texImage,
 577                                      GLint i, GLint j, GLint k, const void *texel)
 578 {
 579    const GLubyte *rgba = (const GLubyte *) texel;
 580    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 581    *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], 0xff);
 582 }
 583 #endif
 584
 585
 586 /* MESA_FORMAT_RGB888 ********************************************************/
 587
 588 /* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */
 589 static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,
 590                              GLint i, GLint j, GLint k, GLfloat *texel )
 591 {
 592    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 593    texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );
 594    texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
 595    texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
 596    texel[ACOMP] = 1.0F;
 597 }
 598
 599 #if DIM == 3
 600 static void store_texel_rgb888(struct gl_texture_image *texImage,
 601                                GLint i, GLint j, GLint k, const void *texel)
 602 {
 603    const GLubyte *rgba = (const GLubyte *) texel;
 604    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 605    dst[0] = rgba[BCOMP];
 606    dst[1] = rgba[GCOMP];
 607    dst[2] = rgba[RCOMP];
 608 }
 609 #endif
 610
 611
 612 /* MESA_FORMAT_BGR888 ********************************************************/
 613
 614 /* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */
 615 static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,
 616                              GLint i, GLint j, GLint k, GLfloat *texel )
 617 {
 618    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 619    texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );
 620    texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
 621    texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );
 622    texel[ACOMP] = 1.0F;
 623 }
 624
 625 #if DIM == 3
 626 static void store_texel_bgr888(struct gl_texture_image *texImage,
 627                                GLint i, GLint j, GLint k, const void *texel)
 628 {
 629    const GLubyte *rgba = (const GLubyte *) texel;
 630    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 631    dst[0] = rgba[RCOMP];
 632    dst[1] = rgba[GCOMP];
 633    dst[2] = rgba[BCOMP];
 634 }
 635 #endif
 636
 637
 638 /* use color expansion like (g << 2) | (g >> 4) (does somewhat random rounding)
 639    instead of slow (g << 2) * 255 / 252 (always rounds down) */
 640
 641 /* MESA_FORMAT_RGB565 ********************************************************/
 642
 643 /* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */
 644 static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,
 645                              GLint i, GLint j, GLint k, GLfloat *texel )
 646 {
 647    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 648    const GLushort s = *src;
 649    texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
 650    texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);
 651    texel[BCOMP] = ((s      ) & 0x1f) * (1.0F / 31.0F);
 652    texel[ACOMP] = 1.0F;
 653 }
 654
 655 #if DIM == 3
 656 static void store_texel_rgb565(struct gl_texture_image *texImage,
 657                                GLint i, GLint j, GLint k, const void *texel)
 658 {
 659    const GLubyte *rgba = (const GLubyte *) texel;
 660    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 661    *dst = PACK_COLOR_565(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 662 }
 663 #endif
 664
 665
 666 /* MESA_FORMAT_RGB565_REV ****************************************************/
 667
 668 /* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */
 669 static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,
 670                                  GLint i, GLint j, GLint k, GLfloat *texel )
 671 {
 672    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 673    const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */
 674    texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
 675    texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
 676    texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
 677    texel[ACOMP] = 1.0F;
 678 }
 679
 680 #if DIM == 3
 681 static void store_texel_rgb565_rev(struct gl_texture_image *texImage,
 682                                   GLint i, GLint j, GLint k, const void *texel)
 683 {
 684    const GLubyte *rgba = (const GLubyte *) texel;
 685    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 686    *dst = PACK_COLOR_565(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
 687 }
 688 #endif
 689
 690
 691 /* MESA_FORMAT_ARGB4444 ******************************************************/
 692
 693 /* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
 694 static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,
 695                                GLint i, GLint j, GLint k, GLfloat *texel )
 696 {
 697    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 698    const GLushort s = *src;
 699    texel[RCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
 700    texel[GCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
 701    texel[BCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
 702    texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
 703 }
 704
 705 #if DIM == 3
 706 static void store_texel_argb4444(struct gl_texture_image *texImage,
 707                                  GLint i, GLint j, GLint k, const void *texel)
 708 {
 709    const GLubyte *rgba = (const GLubyte *) texel;
 710    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 711    *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 712 }
 713 #endif
 714
 715
 716 /* MESA_FORMAT_ARGB4444_REV **************************************************/
 717
 718 /* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */
 719 static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,
 720                                    GLint i, GLint j, GLint k, GLfloat *texel )
 721 {
 722    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 723    texel[RCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
 724    texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
 725    texel[BCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
 726    texel[ACOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
 727 }
 728
 729 #if DIM == 3
 730 static void store_texel_argb4444_rev(struct gl_texture_image *texImage,
 731                                  GLint i, GLint j, GLint k, const void *texel)
 732 {
 733    const GLubyte *rgba = (const GLubyte *) texel;
 734    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 735    *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
 736 }
 737 #endif
 738
 739 /* MESA_FORMAT_RGBA5551 ******************************************************/
 740
 741 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
 742 static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,
 743                                GLint i, GLint j, GLint k, GLfloat *texel )
 744 {
 745    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 746    const GLushort s = *src;
 747    texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
 748    texel[GCOMP] = ((s >>  6) & 0x1f) * (1.0F / 31.0F);
 749    texel[BCOMP] = ((s >>  1) & 0x1f) * (1.0F / 31.0F);
 750    texel[ACOMP] = ((s      ) & 0x01) * 1.0F;
 751 }
 752
 753 #if DIM == 3
 754 static void store_texel_rgba5551(struct gl_texture_image *texImage,
 755                                  GLint i, GLint j, GLint k, const void *texel)
 756 {
 757    const GLubyte *rgba = (const GLubyte *) texel;
 758    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 759    *dst = PACK_COLOR_5551(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 760 }
 761 #endif
 762
 763 /* MESA_FORMAT_ARGB1555 ******************************************************/
 764
 765 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
 766 static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,
 767                              GLint i, GLint j, GLint k, GLfloat *texel )
 768 {
 769    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 770    const GLushort s = *src;
 771    texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);
 772    texel[GCOMP] = ((s >>  5) & 0x1f) * (1.0F / 31.0F);
 773    texel[BCOMP] = ((s >>  0) & 0x1f) * (1.0F / 31.0F);
 774    texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;
 775 }
 776
 777 #if DIM == 3
 778 static void store_texel_argb1555(struct gl_texture_image *texImage,
 779                                  GLint i, GLint j, GLint k, const void *texel)
 780 {
 781    const GLubyte *rgba = (const GLubyte *) texel;
 782    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 783    *dst = PACK_COLOR_1555(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 784 }
 785 #endif
 786
 787
 788 /* MESA_FORMAT_ARGB1555_REV **************************************************/
 789
 790 /* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */
 791 static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,
 792                                    GLint i, GLint j, GLint k, GLfloat *texel )
 793 {
 794    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 795    const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */
 796    texel[RCOMP] = UBYTE_TO_FLOAT( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
 797    texel[GCOMP] = UBYTE_TO_FLOAT( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
 798    texel[BCOMP] = UBYTE_TO_FLOAT( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
 799    texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );
 800 }
 801
 802 #if DIM == 3
 803 static void store_texel_argb1555_rev(struct gl_texture_image *texImage,
 804                                  GLint i, GLint j, GLint k, const void *texel)
 805 {
 806    const GLubyte *rgba = (const GLubyte *) texel;
 807    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 808    *dst = PACK_COLOR_1555_REV(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 809 }
 810 #endif
 811
 812
 813 /* MESA_FORMAT_AL88 **********************************************************/
 814
 815 /* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */
 816 static void FETCH(f_al88)( const struct gl_texture_image *texImage,
 817                            GLint i, GLint j, GLint k, GLfloat *texel )
 818 {
 819    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 820    texel[RCOMP] =
 821    texel[GCOMP] =
 822    texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );
 823    texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );
 824 }
 825
 826 #if DIM == 3
 827 static void store_texel_al88(struct gl_texture_image *texImage,
 828                              GLint i, GLint j, GLint k, const void *texel)
 829 {
 830    const GLubyte *rgba = (const GLubyte *) texel;
 831    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 832    *dst = PACK_COLOR_88(rgba[ACOMP], rgba[RCOMP]);
 833 }
 834 #endif
 835
 836
 837 /* MESA_FORMAT_AL88_REV ******************************************************/
 838
 839 /* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */
 840 static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,
 841                                GLint i, GLint j, GLint k, GLfloat *texel )
 842 {
 843    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 844    texel[RCOMP] =
 845    texel[GCOMP] =
 846    texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );
 847    texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );
 848 }
 849
 850 #if DIM == 3
 851 static void store_texel_al88_rev(struct gl_texture_image *texImage,
 852                                  GLint i, GLint j, GLint k, const void *texel)
 853 {
 854    const GLubyte *rgba = (const GLubyte *) texel;
 855    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 856    *dst = PACK_COLOR_88(rgba[RCOMP], rgba[ACOMP]);
 857 }
 858 #endif
 859
 860
 861 /* MESA_FORMAT_AL1616 ********************************************************/
 862
 863 /* Fetch texel from 1D, 2D or 3D al1616 texture, return 4 GLchans */
 864 static void FETCH(f_al1616)( const struct gl_texture_image *texImage,
 865                              GLint i, GLint j, GLint k, GLfloat *texel )
 866 {
 867    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 868    texel[RCOMP] =
 869    texel[GCOMP] =
 870    texel[BCOMP] = USHORT_TO_FLOAT( s & 0xffff );
 871    texel[ACOMP] = USHORT_TO_FLOAT( s >> 16 );
 872 }
 873
 874 #if DIM == 3
 875 static void store_texel_al1616(struct gl_texture_image *texImage,
 876                              GLint i, GLint j, GLint k, const void *texel)
 877 {
 878    const GLushort *rgba = (const GLushort *) texel;
 879    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 880    *dst = PACK_COLOR_1616(rgba[ACOMP], rgba[RCOMP]);
 881 }
 882 #endif
 883
 884
 885 /* MESA_FORMAT_AL1616_REV ****************************************************/
 886
 887 /* Fetch texel from 1D, 2D or 3D al1616_rev texture, return 4 GLchans */
 888 static void FETCH(f_al1616_rev)( const struct gl_texture_image *texImage,
 889                                  GLint i, GLint j, GLint k, GLfloat *texel )
 890 {
 891    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 892    texel[RCOMP] =
 893    texel[GCOMP] =
 894    texel[BCOMP] = USHORT_TO_FLOAT( s >> 16 );
 895    texel[ACOMP] = USHORT_TO_FLOAT( s & 0xffff );
 896 }
 897
 898 #if DIM == 3
 899 static void store_texel_al1616_rev(struct gl_texture_image *texImage,
 900                                    GLint i, GLint j, GLint k, const void *texel)
 901 {
 902    const GLushort *rgba = (const GLushort *) texel;
 903    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 904    *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[ACOMP]);
 905 }
 906 #endif
 907
 908
 909 /* MESA_FORMAT_RGB332 ********************************************************/
 910
 911 /* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */
 912 static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,
 913                              GLint i, GLint j, GLint k, GLfloat *texel )
 914 {
 915    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 916    const GLubyte s = *src;
 917    texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);
 918    texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);
 919    texel[BCOMP] = ((s     ) & 0x3) * (1.0F / 3.0F);
 920    texel[ACOMP] = 1.0F;
 921 }
 922
 923 #if DIM == 3
 924 static void store_texel_rgb332(struct gl_texture_image *texImage,
 925                                GLint i, GLint j, GLint k, const void *texel)
 926 {
 927    const GLubyte *rgba = (const GLubyte *) texel;
 928    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 929    *dst = PACK_COLOR_332(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 930 }
 931 #endif
 932
 933
 934 /* MESA_FORMAT_A8 ************************************************************/
 935
 936 /* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
 937 static void FETCH(f_a8)( const struct gl_texture_image *texImage,
 938                          GLint i, GLint j, GLint k, GLfloat *texel )
 939 {
 940    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 941    texel[RCOMP] =
 942    texel[GCOMP] =
 943    texel[BCOMP] = 0.0F;
 944    texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
 945 }
 946
 947 #if DIM == 3
 948 static void store_texel_a8(struct gl_texture_image *texImage,
 949                            GLint i, GLint j, GLint k, const void *texel)
 950 {
 951    const GLubyte *rgba = (const GLubyte *) texel;
 952    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 953    *dst = rgba[ACOMP];
 954 }
 955 #endif
 956
 957
 958 /* MESA_FORMAT_L8 ************************************************************/
 959
 960 /* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */
 961 static void FETCH(f_l8)( const struct gl_texture_image *texImage,
 962                          GLint i, GLint j, GLint k, GLfloat *texel )
 963 {
 964    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 965    texel[RCOMP] =
 966    texel[GCOMP] =
 967    texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
 968    texel[ACOMP] = 1.0F;
 969 }
 970
 971 #if DIM == 3
 972 static void store_texel_l8(struct gl_texture_image *texImage,
 973                            GLint i, GLint j, GLint k, const void *texel)
 974 {
 975    const GLubyte *rgba = (const GLubyte *) texel;
 976    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 977    *dst = rgba[RCOMP];
 978 }
 979 #endif
 980
 981
 982 /* MESA_FORMAT_I8 ************************************************************/
 983
 984 /* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */
 985 static void FETCH(f_i8)( const struct gl_texture_image *texImage,
 986                          GLint i, GLint j, GLint k, GLfloat *texel )
 987 {
 988    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
 989    texel[RCOMP] =
 990    texel[GCOMP] =
 991    texel[BCOMP] =
 992    texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
 993 }
 994
 995 #if DIM == 3
 996 static void store_texel_i8(struct gl_texture_image *texImage,
 997                            GLint i, GLint j, GLint k, const void *texel)
 998 {
 999    const GLubyte *rgba = (const GLubyte *) texel;
1000    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1001    *dst = rgba[RCOMP];
1002 }
1003 #endif
1004
1005
1006 /* MESA_FORMAT_CI8 ***********************************************************/
1007
1008 /* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a
1009  * color table, and return 4 GLchans.
1010  */
1011 static void FETCH(f_ci8)( const struct gl_texture_image *texImage,
1012                           GLint i, GLint j, GLint k, GLfloat *texel )
1013 {
1014    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1015    const struct gl_color_table *palette;
1016    GLuint index;
1017    GET_CURRENT_CONTEXT(ctx);
1018
1019    if (ctx->Texture.SharedPalette) {
1020       palette = &ctx->Texture.Palette;
1021    }
1022    else {
1023       palette = &texImage->TexObject->Palette;
1024    }
1025    if (palette->Size == 0)
1026       return; /* undefined results */
1027
1028    /* Mask the index against size of palette to avoid going out of bounds */
1029    index = (*src) & (palette->Size - 1);
1030
1031    {
1032       const GLfloat *table = palette->TableF;
1033       switch (palette->_BaseFormat) {
1034       case GL_ALPHA:
1035          texel[RCOMP] =
1036          texel[GCOMP] =
1037          texel[BCOMP] = 0.0F;
1038          texel[ACOMP] = table[index];
1039          break;
1040       case GL_LUMINANCE:
1041          texel[RCOMP] =
1042          texel[GCOMP] =
1043          texel[BCOMP] = table[index];
1044          texel[ACOMP] = 1.0F;
1045          break;
1046       case GL_INTENSITY:
1047          texel[RCOMP] =
1048          texel[GCOMP] =
1049          texel[BCOMP] =
1050          texel[ACOMP] = table[index];
1051          break;
1052       case GL_LUMINANCE_ALPHA:
1053          texel[RCOMP] =
1054          texel[GCOMP] =
1055          texel[BCOMP] = table[index * 2 + 0];
1056          texel[ACOMP] = table[index * 2 + 1];
1057          break;
1058       case GL_RGB:
1059          texel[RCOMP] = table[index * 3 + 0];
1060          texel[GCOMP] = table[index * 3 + 1];
1061          texel[BCOMP] = table[index * 3 + 2];
1062          texel[ACOMP] = 1.0F;
1063          break;
1064       case GL_RGBA:
1065          texel[RCOMP] = table[index * 4 + 0];
1066          texel[GCOMP] = table[index * 4 + 1];
1067          texel[BCOMP] = table[index * 4 + 2];
1068          texel[ACOMP] = table[index * 4 + 3];
1069          break;
1070       default:
1071          _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");
1072          return;
1073       }
1074    }
1075 }
1076
1077 #if DIM == 3
1078 static void store_texel_ci8(struct gl_texture_image *texImage,
1079                             GLint i, GLint j, GLint k, const void *texel)
1080 {
1081    const GLubyte *index = (const GLubyte *) texel;
1082    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1083    *dst = *index;
1084 }
1085 #endif
1086
1087
1088 /* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */
1089 /* Note: component order is same as for MESA_FORMAT_RGB888 */
1090 static void FETCH(srgb8)(const struct gl_texture_image *texImage,
1091                          GLint i, GLint j, GLint k, GLfloat *texel )
1092 {
1093    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1094    texel[RCOMP] = nonlinear_to_linear(src[2]);
1095    texel[GCOMP] = nonlinear_to_linear(src[1]);
1096    texel[BCOMP] = nonlinear_to_linear(src[0]);
1097    texel[ACOMP] = 1.0F;
1098 }
1099
1100 #if DIM == 3
1101 static void store_texel_srgb8(struct gl_texture_image *texImage,
1102                               GLint i, GLint j, GLint k, const void *texel)
1103 {
1104    const GLubyte *rgba = (const GLubyte *) texel;
1105    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1106    dst[0] = rgba[BCOMP]; /* no conversion */
1107    dst[1] = rgba[GCOMP];
1108    dst[2] = rgba[RCOMP];
1109 }
1110 #endif
1111
1112 /* Fetch texel from 1D, 2D or 3D srgba8 texture, return 4 GLfloats */
1113 static void FETCH(srgba8)(const struct gl_texture_image *texImage,
1114                           GLint i, GLint j, GLint k, GLfloat *texel )
1115 {
1116    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1117    texel[RCOMP] = nonlinear_to_linear( (s >> 24) );
1118    texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1119    texel[BCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
1120    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff ); /* linear! */
1121 }
1122
1123 #if DIM == 3
1124 static void store_texel_srgba8(struct gl_texture_image *texImage,
1125                                GLint i, GLint j, GLint k, const void *texel)
1126 {
1127    const GLubyte *rgba = (const GLubyte *) texel;
1128    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1129    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1130 }
1131 #endif
1132
1133 /* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */
1134 static void FETCH(sargb8)(const struct gl_texture_image *texImage,
1135                           GLint i, GLint j, GLint k, GLfloat *texel )
1136 {
1137    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1138    texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1139    texel[GCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
1140    texel[BCOMP] = nonlinear_to_linear( (s      ) & 0xff );
1141    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */
1142 }
1143
1144 #if DIM == 3
1145 static void store_texel_sargb8(struct gl_texture_image *texImage,
1146                                GLint i, GLint j, GLint k, const void *texel)
1147 {
1148    const GLubyte *rgba = (const GLubyte *) texel;
1149    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1150    *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
1151 }
1152 #endif
1153
1154 /* Fetch texel from 1D, 2D or 3D sl8 texture, return 4 GLfloats */
1155 static void FETCH(sl8)(const struct gl_texture_image *texImage,
1156                        GLint i, GLint j, GLint k, GLfloat *texel )
1157 {
1158    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1159    texel[RCOMP] =
1160    texel[GCOMP] =
1161    texel[BCOMP] = nonlinear_to_linear(src[0]);
1162    texel[ACOMP] = 1.0F;
1163 }
1164
1165 #if DIM == 3
1166 static void store_texel_sl8(struct gl_texture_image *texImage,
1167                             GLint i, GLint j, GLint k, const void *texel)
1168 {
1169    const GLubyte *rgba = (const GLubyte *) texel;
1170    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1171    dst[0] = rgba[RCOMP];
1172 }
1173 #endif
1174
1175 /* Fetch texel from 1D, 2D or 3D sla8 texture, return 4 GLfloats */
1176 static void FETCH(sla8)(const struct gl_texture_image *texImage,
1177                        GLint i, GLint j, GLint k, GLfloat *texel )
1178 {
1179    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1180    texel[RCOMP] =
1181    texel[GCOMP] =
1182    texel[BCOMP] = nonlinear_to_linear(src[0]);
1183    texel[ACOMP] = UBYTE_TO_FLOAT(src[1]); /* linear */
1184 }
1185
1186 #if DIM == 3
1187 static void store_texel_sla8(struct gl_texture_image *texImage,
1188                             GLint i, GLint j, GLint k, const void *texel)
1189 {
1190    const GLubyte *rgba = (const GLubyte *) texel;
1191    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1192    dst[0] = rgba[RCOMP];
1193    dst[1] = rgba[ACOMP];
1194 }
1195 #endif
1196
1197
1198 /* MESA_FORMAT_RGBA_INT8 **************************************************/
1199
1200 static void
1201 FETCH(rgba_int8)(const struct gl_texture_image *texImage,
1202                  GLint i, GLint j, GLint k, GLfloat *texel )
1203 {
1204    const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1205    texel[RCOMP] = (GLfloat) src[0];
1206    texel[GCOMP] = (GLfloat) src[1];
1207    texel[BCOMP] = (GLfloat) src[2];
1208    texel[ACOMP] = (GLfloat) src[3];
1209 }
1210
1211 #if DIM == 3
1212 static void
1213 store_texel_rgba_int8(struct gl_texture_image *texImage,
1214                       GLint i, GLint j, GLint k, const void *texel)
1215 {
1216    const GLbyte *rgba = (const GLbyte *) texel;
1217    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1218    dst[0] = rgba[RCOMP];
1219    dst[1] = rgba[GCOMP];
1220    dst[2] = rgba[BCOMP];
1221    dst[3] = rgba[ACOMP];
1222 }
1223 #endif
1224
1225
1226 /* MESA_FORMAT_RGBA_INT16 **************************************************/
1227
1228 static void
1229 FETCH(rgba_int16)(const struct gl_texture_image *texImage,
1230                   GLint i, GLint j, GLint k, GLfloat *texel )
1231 {
1232    const GLshort *src = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1233    texel[RCOMP] = (GLfloat) src[0];
1234    texel[GCOMP] = (GLfloat) src[1];
1235    texel[BCOMP] = (GLfloat) src[2];
1236    texel[ACOMP] = (GLfloat) src[3];
1237 }
1238
1239 #if DIM == 3
1240 static void
1241 store_texel_rgba_int16(struct gl_texture_image *texImage,
1242                        GLint i, GLint j, GLint k, const void *texel)
1243 {
1244    const GLshort *rgba = (const GLshort *) texel;
1245    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1246    dst[0] = rgba[RCOMP];
1247    dst[1] = rgba[GCOMP];
1248    dst[2] = rgba[BCOMP];
1249    dst[3] = rgba[ACOMP];
1250 }
1251 #endif
1252
1253
1254 /* MESA_FORMAT_RGBA_INT32 **************************************************/
1255
1256 static void
1257 FETCH(rgba_int32)(const struct gl_texture_image *texImage,
1258                   GLint i, GLint j, GLint k, GLfloat *texel )
1259 {
1260    const GLint *src = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1261    texel[RCOMP] = (GLfloat) src[0];
1262    texel[GCOMP] = (GLfloat) src[1];
1263    texel[BCOMP] = (GLfloat) src[2];
1264    texel[ACOMP] = (GLfloat) src[3];
1265 }
1266
1267 #if DIM == 3
1268 static void
1269 store_texel_rgba_int32(struct gl_texture_image *texImage,
1270                        GLint i, GLint j, GLint k, const void *texel)
1271 {
1272    const GLint *rgba = (const GLint *) texel;
1273    GLint *dst = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1274    dst[0] = rgba[RCOMP];
1275    dst[1] = rgba[GCOMP];
1276    dst[2] = rgba[BCOMP];
1277    dst[3] = rgba[ACOMP];
1278 }
1279 #endif
1280
1281
1282 /* MESA_FORMAT_RGBA_UINT8 **************************************************/
1283
1284 static void
1285 FETCH(rgba_uint8)(const struct gl_texture_image *texImage,
1286                  GLint i, GLint j, GLint k, GLfloat *texel )
1287 {
1288    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1289    texel[RCOMP] = (GLfloat) src[0];
1290    texel[GCOMP] = (GLfloat) src[1];
1291    texel[BCOMP] = (GLfloat) src[2];
1292    texel[ACOMP] = (GLfloat) src[3];
1293 }
1294
1295 #if DIM == 3
1296 static void
1297 store_texel_rgba_uint8(struct gl_texture_image *texImage,
1298                       GLint i, GLint j, GLint k, const void *texel)
1299 {
1300    const GLubyte *rgba = (const GLubyte *) texel;
1301    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1302    dst[0] = rgba[RCOMP];
1303    dst[1] = rgba[GCOMP];
1304    dst[2] = rgba[BCOMP];
1305    dst[3] = rgba[ACOMP];
1306 }
1307 #endif
1308
1309
1310 /* MESA_FORMAT_RGBA_UINT16 **************************************************/
1311
1312 static void
1313 FETCH(rgba_uint16)(const struct gl_texture_image *texImage,
1314                   GLint i, GLint j, GLint k, GLfloat *texel )
1315 {
1316    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1317    texel[RCOMP] = (GLfloat) src[0];
1318    texel[GCOMP] = (GLfloat) src[1];
1319    texel[BCOMP] = (GLfloat) src[2];
1320    texel[ACOMP] = (GLfloat) src[3];
1321 }
1322
1323 #if DIM == 3
1324 static void
1325 store_texel_rgba_uint16(struct gl_texture_image *texImage,
1326                        GLint i, GLint j, GLint k, const void *texel)
1327 {
1328    const GLushort *rgba = (const GLushort *) texel;
1329    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1330    dst[0] = rgba[RCOMP];
1331    dst[1] = rgba[GCOMP];
1332    dst[2] = rgba[BCOMP];
1333    dst[3] = rgba[ACOMP];
1334 }
1335 #endif
1336
1337
1338 /* MESA_FORMAT_RGBA_UINT32 **************************************************/
1339
1340 static void
1341 FETCH(rgba_uint32)(const struct gl_texture_image *texImage,
1342                   GLint i, GLint j, GLint k, GLfloat *texel )
1343 {
1344    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1345    texel[RCOMP] = (GLfloat) src[0];
1346    texel[GCOMP] = (GLfloat) src[1];
1347    texel[BCOMP] = (GLfloat) src[2];
1348    texel[ACOMP] = (GLfloat) src[3];
1349 }
1350
1351 #if DIM == 3
1352 static void
1353 store_texel_rgba_uint32(struct gl_texture_image *texImage,
1354                        GLint i, GLint j, GLint k, const void *texel)
1355 {
1356    const GLuint *rgba = (const GLuint *) texel;
1357    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1358    dst[0] = rgba[RCOMP];
1359    dst[1] = rgba[GCOMP];
1360    dst[2] = rgba[BCOMP];
1361    dst[3] = rgba[ACOMP];
1362 }
1363 #endif
1364
1365
1366 /* MESA_FORMAT_DUDV8 ********************************************************/
1367
1368 /* this format by definition produces 0,0,0,1 as rgba values,
1369    however we'll return the dudv values as rg and fix up elsewhere */
1370 static void FETCH(dudv8)(const struct gl_texture_image *texImage,
1371                          GLint i, GLint j, GLint k, GLfloat *texel )
1372 {
1373    const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);
1374    texel[RCOMP] = BYTE_TO_FLOAT(src[0]);
1375    texel[GCOMP] = BYTE_TO_FLOAT(src[1]);
1376    texel[BCOMP] = 0;
1377    texel[ACOMP] = 0;
1378 }
1379
1380
1381 /* MESA_FORMAT_SIGNED_R8 ***********************************************/
1382
1383 static void FETCH(signed_r8)( const struct gl_texture_image *texImage,
1384                               GLint i, GLint j, GLint k, GLfloat *texel )
1385 {
1386    const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1387    texel[RCOMP] = BYTE_TO_FLOAT_TEX( s );
1388    texel[GCOMP] = 0.0F;
1389    texel[BCOMP] = 0.0F;
1390    texel[ACOMP] = 1.0F;
1391 }
1392
1393 #if DIM == 3
1394 static void store_texel_signed_r8(struct gl_texture_image *texImage,
1395                                   GLint i, GLint j, GLint k, const void *texel)
1396 {
1397    const GLbyte *rgba = (const GLbyte *) texel;
1398    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1399    *dst = rgba[RCOMP];
1400 }
1401 #endif
1402
1403
1404 /* MESA_FORMAT_SIGNED_RG88 ***********************************************/
1405
1406 static void FETCH(signed_rg88)( const struct gl_texture_image *texImage,
1407                                 GLint i, GLint j, GLint k, GLfloat *texel )
1408 {
1409    const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1410    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1411    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
1412    texel[BCOMP] = 0.0F;
1413    texel[ACOMP] = 1.0F;
1414 }
1415
1416 #if DIM == 3
1417 static void store_texel_signed_rg88(struct gl_texture_image *texImage,
1418                                     GLint i, GLint j, GLint k, const void *texel)
1419 {
1420    const GLbyte *rg = (const GLbyte *) texel;
1421    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 2);
1422    *dst = PACK_COLOR_88(rg[RCOMP], rg[GCOMP]);
1423 }
1424 #endif
1425
1426
1427 /* MESA_FORMAT_SIGNED_RGBX8888 ***********************************************/
1428
1429 static void FETCH(signed_rgbx8888)( const struct gl_texture_image *texImage,
1430                                     GLint i, GLint j, GLint k, GLfloat *texel )
1431 {
1432    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1433    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1434    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1435    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1436    texel[ACOMP] = 1.0f;
1437 }
1438
1439 #if DIM == 3
1440 static void store_texel_signed_rgbx8888(struct gl_texture_image *texImage,
1441                                         GLint i, GLint j, GLint k, const void *texel)
1442 {
1443    const GLbyte *rgba = (const GLbyte *) texel;
1444    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1445    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], 255);
1446 }
1447 #endif
1448
1449
1450 /* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/
1451
1452 static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,
1453                                     GLint i, GLint j, GLint k, GLfloat *texel )
1454 {
1455    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1456    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1457    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1458    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1459    texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
1460 }
1461
1462 #if DIM == 3
1463 static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,
1464                                         GLint i, GLint j, GLint k, const void *texel)
1465 {
1466    const GLbyte *rgba = (const GLbyte *) texel;
1467    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1468    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1469 }
1470 #endif
1471
1472 static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,
1473                                         GLint i, GLint j, GLint k, GLfloat *texel )
1474 {
1475    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1476    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
1477    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1478    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1479    texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1480 }
1481
1482 #if DIM == 3
1483 static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,
1484                                             GLint i, GLint j, GLint k, const void *texel)
1485 {
1486    const GLubyte *rgba = (const GLubyte *) texel;
1487    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1488    *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1489 }
1490 #endif
1491
1492
1493
1494 /* MESA_FORMAT_SIGNED_R_16 ***********************************************/
1495
1496 static void
1497 FETCH(signed_r_16)(const struct gl_texture_image *texImage,
1498                    GLint i, GLint j, GLint k, GLfloat *texel)
1499 {
1500    const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1501    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s );
1502    texel[GCOMP] = 0.0F;
1503    texel[BCOMP] = 0.0F;
1504    texel[ACOMP] = 1.0F;
1505 }
1506
1507 #if DIM == 3
1508 static void
1509 store_texel_signed_r_16(struct gl_texture_image *texImage,
1510                         GLint i, GLint j, GLint k, const void *texel)
1511 {
1512    const GLshort *rgba = (const GLshort *) texel;
1513    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1514    *dst = rgba[0];
1515 }
1516 #endif
1517
1518
1519 /* MESA_FORMAT_SIGNED_RG_16 ***********************************************/
1520
1521 static void
1522 FETCH(signed_rg_16)(const struct gl_texture_image *texImage,
1523                     GLint i, GLint j, GLint k, GLfloat *texel)
1524 {
1525    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
1526    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1527    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1528    texel[BCOMP] = 0.0F;
1529    texel[ACOMP] = 1.0F;
1530 }
1531
1532 #if DIM == 3
1533 static void
1534 store_texel_signed_rg_16(struct gl_texture_image *texImage,
1535                          GLint i, GLint j, GLint k, const void *texel)
1536 {
1537    const GLshort *rgba = (const GLshort *) texel;
1538    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
1539    dst[0] = rgba[RCOMP];
1540    dst[1] = rgba[GCOMP];
1541 }
1542 #endif
1543
1544
1545 /* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
1546
1547 static void
1548 FETCH(signed_rgb_16)(const struct gl_texture_image *texImage,
1549                      GLint i, GLint j, GLint k, GLfloat *texel)
1550 {
1551    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
1552    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1553    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1554    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
1555    texel[ACOMP] = 1.0F;
1556 }
1557
1558 #if DIM == 3
1559 static void
1560 store_texel_signed_rgb_16(struct gl_texture_image *texImage,
1561                           GLint i, GLint j, GLint k, const void *texel)
1562 {
1563    const GLshort *rgba = (const GLshort *) texel;
1564    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
1565    dst[0] = rgba[RCOMP];
1566    dst[1] = rgba[GCOMP];
1567    dst[2] = rgba[BCOMP];
1568 }
1569 #endif
1570
1571
1572 /* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
1573
1574 static void
1575 FETCH(signed_rgba_16)(const struct gl_texture_image *texImage,
1576                       GLint i, GLint j, GLint k, GLfloat *texel)
1577 {
1578    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1579    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1580    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1581    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
1582    texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] );
1583 }
1584
1585 #if DIM == 3
1586 static void
1587 store_texel_signed_rgba_16(struct gl_texture_image *texImage,
1588                            GLint i, GLint j, GLint k, const void *texel)
1589 {
1590    const GLshort *rgba = (const GLshort *) texel;
1591    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1592    dst[0] = rgba[RCOMP];
1593    dst[1] = rgba[GCOMP];
1594    dst[2] = rgba[BCOMP];
1595    dst[3] = rgba[ACOMP];
1596 }
1597 #endif
1598
1599
1600
1601 /* MESA_FORMAT_RGBA_16 ***********************************************/
1602
1603 static void
1604 FETCH(rgba_16)(const struct gl_texture_image *texImage,
1605                GLint i, GLint j, GLint k, GLfloat *texel)
1606 {
1607    const GLushort *s = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1608    texel[RCOMP] = USHORT_TO_FLOAT( s[0] );
1609    texel[GCOMP] = USHORT_TO_FLOAT( s[1] );
1610    texel[BCOMP] = USHORT_TO_FLOAT( s[2] );
1611    texel[ACOMP] = USHORT_TO_FLOAT( s[3] );
1612 }
1613
1614 #if DIM == 3
1615 static void
1616 store_texel_rgba_16(struct gl_texture_image *texImage,
1617                     GLint i, GLint j, GLint k, const void *texel)
1618 {
1619    const GLushort *rgba = (const GLushort *) texel;
1620    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1621    dst[0] = rgba[RCOMP];
1622    dst[1] = rgba[GCOMP];
1623    dst[2] = rgba[BCOMP];
1624    dst[3] = rgba[ACOMP];
1625 }
1626 #endif
1627
1628
1629
1630 /* MESA_FORMAT_YCBCR *********************************************************/
1631
1632 /* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.
1633  * We convert YCbCr to RGB here.
1634  */
1635 static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,
1636                             GLint i, GLint j, GLint k, GLfloat *texel )
1637 {
1638    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
1639    const GLushort *src1 = src0 + 1;                               /* odd */
1640    const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
1641    const GLubyte cb = *src0 & 0xff;         /* chroma U */
1642    const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
1643    const GLubyte cr = *src1 & 0xff;         /* chroma V */
1644    const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
1645    GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
1646    GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
1647    GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
1648    r *= (1.0F / 255.0F);
1649    g *= (1.0F / 255.0F);
1650    b *= (1.0F / 255.0F);
1651    texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
1652    texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
1653    texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
1654    texel[ACOMP] = 1.0F;
1655 }
1656
1657 #if DIM == 3
1658 static void store_texel_ycbcr(struct gl_texture_image *texImage,
1659                               GLint i, GLint j, GLint k, const void *texel)
1660 {
1661    (void) texImage;
1662    (void) i;
1663    (void) j;
1664    (void) k;
1665    (void) texel;
1666    /* XXX to do */
1667 }
1668 #endif
1669
1670
1671 /* MESA_FORMAT_YCBCR_REV *****************************************************/
1672
1673 /* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.
1674  * We convert YCbCr to RGB here.
1675  */
1676 static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,
1677                                 GLint i, GLint j, GLint k, GLfloat *texel )
1678 {
1679    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
1680    const GLushort *src1 = src0 + 1;                               /* odd */
1681    const GLubyte y0 = *src0 & 0xff;         /* luminance */
1682    const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
1683    const GLubyte y1 = *src1 & 0xff;         /* luminance */
1684    const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
1685    const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
1686    GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
1687    GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
1688    GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
1689    r *= (1.0F / 255.0F);
1690    g *= (1.0F / 255.0F);
1691    b *= (1.0F / 255.0F);
1692    texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
1693    texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
1694    texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
1695    texel[ACOMP] = 1.0F;
1696 }
1697
1698 #if DIM == 3
1699 static void store_texel_ycbcr_rev(struct gl_texture_image *texImage,
1700                                   GLint i, GLint j, GLint k, const void *texel)
1701 {
1702    (void) texImage;
1703    (void) i;
1704    (void) j;
1705    (void) k;
1706    (void) texel;
1707    /* XXX to do */
1708 }
1709 #endif
1710
1711
1712 /* MESA_TEXFORMAT_Z24_S8 ***************************************************/
1713
1714 static void FETCH(f_z24_s8)( const struct gl_texture_image *texImage,
1715                              GLint i, GLint j, GLint k, GLfloat *texel )
1716 {
1717    /* only return Z, not stencil data */
1718    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1719    const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
1720    texel[0] = ((*src) >> 8) * scale;
1721    ASSERT(texImage->TexFormat == MESA_FORMAT_Z24_S8);
1722    ASSERT(texel[0] >= 0.0F);
1723    ASSERT(texel[0] <= 1.0F);
1724 }
1725
1726 #if DIM == 3
1727 static void store_texel_z24_s8(struct gl_texture_image *texImage,
1728                                GLint i, GLint j, GLint k, const void *texel)
1729 {
1730    /* only store Z, not stencil */
1731    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1732    GLfloat depth = *((GLfloat *) texel);
1733    GLuint zi = ((GLuint) (depth * 0xffffff)) << 8;
1734    *dst = zi | (*dst & 0xff);
1735 }
1736 #endif
1737
1738
1739 /* MESA_TEXFORMAT_S8_Z24 ***************************************************/
1740
1741 static void FETCH(f_s8_z24)( const struct gl_texture_image *texImage,
1742                              GLint i, GLint j, GLint k, GLfloat *texel )
1743 {
1744    /* only return Z, not stencil data */
1745    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1746    const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
1747    texel[0] = ((*src) & 0x00ffffff) * scale;
1748    ASSERT(texImage->TexFormat == MESA_FORMAT_S8_Z24);
1749    ASSERT(texel[0] >= 0.0F);
1750    ASSERT(texel[0] <= 1.0F);
1751 }
1752
1753 #if DIM == 3
1754 static void store_texel_s8_z24(struct gl_texture_image *texImage,
1755                                GLint i, GLint j, GLint k, const void *texel)
1756 {
1757    /* only store Z, not stencil */
1758    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1759    GLfloat depth = *((GLfloat *) texel);
1760    GLuint zi = (GLuint) (depth * 0xffffff);
1761    *dst = zi | (*dst & 0xff000000);
1762 }
1763 #endif
1764
1765
1766 #undef TEXEL_ADDR
1767 #undef DIM
1768 #undef FETCH