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, 4);
 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 *src = (const GLfloat *) texel;
 167    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);
 168    dst[0] = _mesa_float_to_half(src[RCOMP]);
 169    dst[1] = _mesa_float_to_half(src[GCOMP]);
 170    dst[2] = _mesa_float_to_half(src[BCOMP]);
 171    dst[3] = _mesa_float_to_half(src[ACOMP]);
 172 }
 173 #endif
 174
 175 /* MESA_FORMAT_RGB_F32 *******************************************************/
 176
 177 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT32 texture,
 178  * returning 4 GLfloats.
 179  */
 180 static void FETCH(f_rgb_f32)( const struct gl_texture_image *texImage,
 181                               GLint i, GLint j, GLint k, GLfloat *texel )
 182 {
 183    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
 184    texel[RCOMP] = src[0];
 185    texel[GCOMP] = src[1];
 186    texel[BCOMP] = src[2];
 187    texel[ACOMP] = 1.0F;
 188 }
 189
 190 #if DIM == 3
 191 static void store_texel_rgb_f32(struct gl_texture_image *texImage,
 192                                  GLint i, GLint j, GLint k, const void *texel)
 193 {
 194    const GLfloat *src = (const GLfloat *) texel;
 195    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
 196    dst[0] = src[RCOMP];
 197    dst[1] = src[GCOMP];
 198    dst[2] = src[BCOMP];
 199 }
 200 #endif
 201
 202
 203 /* MESA_FORMAT_RGB_F16 *******************************************************/
 204
 205 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT16 texture,
 206  * returning 4 GLfloats.
 207  */
 208 static void FETCH(f_rgb_f16)( const struct gl_texture_image *texImage,
 209                               GLint i, GLint j, GLint k, GLfloat *texel )
 210 {
 211    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
 212    texel[RCOMP] = _mesa_half_to_float(src[0]);
 213    texel[GCOMP] = _mesa_half_to_float(src[1]);
 214    texel[BCOMP] = _mesa_half_to_float(src[2]);
 215    texel[ACOMP] = 1.0F;
 216 }
 217
 218 #if DIM == 3
 219 static void store_texel_rgb_f16(struct gl_texture_image *texImage,
 220                                 GLint i, GLint j, GLint k, const void *texel)
 221 {
 222    const GLfloat *src = (const GLfloat *) texel;
 223    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
 224    dst[0] = _mesa_float_to_half(src[RCOMP]);
 225    dst[1] = _mesa_float_to_half(src[GCOMP]);
 226    dst[2] = _mesa_float_to_half(src[BCOMP]);
 227 }
 228 #endif
 229
 230
 231 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
 232
 233 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT32 texture,
 234  * returning 4 GLfloats.
 235  */
 236 static void FETCH(f_alpha_f32)( const struct gl_texture_image *texImage,
 237                               GLint i, GLint j, GLint k, GLfloat *texel )
 238 {
 239    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 240    texel[RCOMP] =
 241    texel[GCOMP] =
 242    texel[BCOMP] = 0.0F;
 243    texel[ACOMP] = src[0];
 244 }
 245
 246 #if DIM == 3
 247 static void store_texel_alpha_f32(struct gl_texture_image *texImage,
 248                                   GLint i, GLint j, GLint k, const void *texel)
 249 {
 250    const GLfloat *rgba = (const GLfloat *) texel;
 251    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 252    dst[0] = rgba[ACOMP];
 253 }
 254 #endif
 255
 256
 257 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
 258
 259 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT16 texture,
 260  * returning 4 GLfloats.
 261  */
 262 static void FETCH(f_alpha_f16)( const struct gl_texture_image *texImage,
 263                               GLint i, GLint j, GLint k, GLfloat *texel )
 264 {
 265    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 266    texel[RCOMP] =
 267    texel[GCOMP] =
 268    texel[BCOMP] = 0.0F;
 269    texel[ACOMP] = _mesa_half_to_float(src[0]);
 270 }
 271
 272 #if DIM == 3
 273 static void store_texel_alpha_f16(struct gl_texture_image *texImage,
 274                                   GLint i, GLint j, GLint k, const void *texel)
 275 {
 276    const GLfloat *rgba = (const GLfloat *) texel;
 277    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 278    dst[0] = _mesa_float_to_half(rgba[ACOMP]);
 279 }
 280 #endif
 281
 282
 283 /* MESA_FORMAT_LUMINANCE_F32 *************************************************/
 284
 285 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT32 texture,
 286  * returning 4 GLfloats.
 287  */
 288 static void FETCH(f_luminance_f32)( const struct gl_texture_image *texImage,
 289                                     GLint i, GLint j, GLint k, GLfloat *texel )
 290 {
 291    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 292    texel[RCOMP] =
 293    texel[GCOMP] =
 294    texel[BCOMP] = src[0];
 295    texel[ACOMP] = 1.0F;
 296 }
 297
 298 #if DIM == 3
 299 static void store_texel_luminance_f32(struct gl_texture_image *texImage,
 300                                   GLint i, GLint j, GLint k, const void *texel)
 301 {
 302    const GLfloat *rgba = (const GLfloat *) texel;
 303    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 304    dst[0] = rgba[RCOMP];
 305 }
 306 #endif
 307
 308
 309 /* MESA_FORMAT_LUMINANCE_F16 *************************************************/
 310
 311 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT16 texture,
 312  * returning 4 GLfloats.
 313  */
 314 static void FETCH(f_luminance_f16)( const struct gl_texture_image *texImage,
 315                                     GLint i, GLint j, GLint k, GLfloat *texel )
 316 {
 317    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 318    texel[RCOMP] =
 319    texel[GCOMP] =
 320    texel[BCOMP] = _mesa_half_to_float(src[0]);
 321    texel[ACOMP] = 1.0F;
 322 }
 323
 324 #if DIM == 3
 325 static void store_texel_luminance_f16(struct gl_texture_image *texImage,
 326                                   GLint i, GLint j, GLint k, const void *texel)
 327 {
 328    const GLfloat *rgba = (const GLfloat *) texel;
 329    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 330    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 331 }
 332 #endif
 333
 334
 335 /* MESA_FORMAT_LUMINANCE_ALPHA_F32 *******************************************/
 336
 337 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT32 texture,
 338  * returning 4 GLfloats.
 339  */
 340 static void FETCH(f_luminance_alpha_f32)( const struct gl_texture_image *texImage,
 341                                     GLint i, GLint j, GLint k, GLfloat *texel )
 342 {
 343    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 344    texel[RCOMP] =
 345    texel[GCOMP] =
 346    texel[BCOMP] = src[0];
 347    texel[ACOMP] = src[1];
 348 }
 349
 350 #if DIM == 3
 351 static void store_texel_luminance_alpha_f32(struct gl_texture_image *texImage,
 352                                   GLint i, GLint j, GLint k, const void *texel)
 353 {
 354    const GLfloat *rgba = (const GLfloat *) texel;
 355    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 356    dst[0] = rgba[RCOMP];
 357    dst[1] = rgba[ACOMP];
 358 }
 359 #endif
 360
 361
 362 /* MESA_FORMAT_LUMINANCE_ALPHA_F16 *******************************************/
 363
 364 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT16 texture,
 365  * returning 4 GLfloats.
 366  */
 367 static void FETCH(f_luminance_alpha_f16)( const struct gl_texture_image *texImage,
 368                                     GLint i, GLint j, GLint k, GLfloat *texel )
 369 {
 370    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 371    texel[RCOMP] =
 372    texel[GCOMP] =
 373    texel[BCOMP] = _mesa_half_to_float(src[0]);
 374    texel[ACOMP] = _mesa_half_to_float(src[1]);
 375 }
 376
 377 #if DIM == 3
 378 static void store_texel_luminance_alpha_f16(struct gl_texture_image *texImage,
 379                                   GLint i, GLint j, GLint k, const void *texel)
 380 {
 381    const GLfloat *rgba = (const GLfloat *) texel;
 382    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 383    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 384    dst[1] = _mesa_float_to_half(rgba[ACOMP]);
 385 }
 386 #endif
 387
 388
 389 /* MESA_FORMAT_INTENSITY_F32 *************************************************/
 390
 391 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT32 texture,
 392  * returning 4 GLfloats.
 393  */
 394 static void FETCH(f_intensity_f32)( const struct gl_texture_image *texImage,
 395                                     GLint i, GLint j, GLint k, GLfloat *texel )
 396 {
 397    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 398    texel[RCOMP] =
 399    texel[GCOMP] =
 400    texel[BCOMP] =
 401    texel[ACOMP] = src[0];
 402 }
 403
 404 #if DIM == 3
 405 static void store_texel_intensity_f32(struct gl_texture_image *texImage,
 406                                   GLint i, GLint j, GLint k, const void *texel)
 407 {
 408    const GLfloat *rgba = (const GLfloat *) texel;
 409    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 410    dst[0] = rgba[RCOMP];
 411 }
 412 #endif
 413
 414
 415 /* MESA_FORMAT_INTENSITY_F16 *************************************************/
 416
 417 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT16 texture,
 418  * returning 4 GLfloats.
 419  */
 420 static void FETCH(f_intensity_f16)( const struct gl_texture_image *texImage,
 421                                     GLint i, GLint j, GLint k, GLfloat *texel )
 422 {
 423    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 424    texel[RCOMP] =
 425    texel[GCOMP] =
 426    texel[BCOMP] =
 427    texel[ACOMP] = _mesa_half_to_float(src[0]);
 428 }
 429
 430 #if DIM == 3
 431 static void store_texel_intensity_f16(struct gl_texture_image *texImage,
 432                                   GLint i, GLint j, GLint k, const void *texel)
 433 {
 434    const GLfloat *rgba = (const GLfloat *) texel;
 435    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 436    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 437 }
 438 #endif
 439
 440
 441 /* MESA_FORMAT_R_FLOAT32 *****************************************************/
 442
 443 /* Fetch texel from 1D, 2D or 3D R_FLOAT32 texture,
 444  * returning 4 GLfloats.
 445  */
 446 static void FETCH(f_r_f32)( const struct gl_texture_image *texImage,
 447                             GLint i, GLint j, GLint k, GLfloat *texel )
 448 {
 449    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 450    texel[RCOMP] = src[0];
 451    texel[GCOMP] = 0.0F;
 452    texel[BCOMP] = 0.0F;
 453    texel[ACOMP] = 1.0F;
 454 }
 455
 456 #if DIM == 3
 457 static void store_texel_r_f32(struct gl_texture_image *texImage,
 458                               GLint i, GLint j, GLint k, const void *texel)
 459 {
 460    const GLfloat *rgba = (const GLfloat *) texel;
 461    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
 462    dst[0] = rgba[RCOMP];
 463 }
 464 #endif
 465
 466
 467 /* MESA_FORMAT_R_FLOAT16 *****************************************************/
 468
 469 /* Fetch texel from 1D, 2D or 3D R_FLOAT16 texture,
 470  * returning 4 GLfloats.
 471  */
 472 static void FETCH(f_r_f16)( const struct gl_texture_image *texImage,
 473                             GLint i, GLint j, GLint k, GLfloat *texel )
 474 {
 475    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 476    texel[RCOMP] = _mesa_half_to_float(src[0]);
 477    texel[GCOMP] = 0.0F;
 478    texel[BCOMP] = 0.0F;
 479    texel[ACOMP] = 1.0F;
 480 }
 481
 482 #if DIM == 3
 483 static void store_texel_r_f16(struct gl_texture_image *texImage,
 484                               GLint i, GLint j, GLint k, const void *texel)
 485 {
 486    const GLfloat *rgba = (const GLfloat *) texel;
 487    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
 488    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 489 }
 490 #endif
 491
 492
 493 /* MESA_FORMAT_RG_FLOAT32 ****************************************************/
 494
 495 /* Fetch texel from 1D, 2D or 3D RG_FLOAT32 texture,
 496  * returning 4 GLfloats.
 497  */
 498 static void FETCH(f_rg_f32)( const struct gl_texture_image *texImage,
 499                              GLint i, GLint j, GLint k, GLfloat *texel )
 500 {
 501    const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 502    texel[RCOMP] = src[0];
 503    texel[GCOMP] = src[1];
 504    texel[BCOMP] = 0.0F;
 505    texel[ACOMP] = 1.0F;
 506 }
 507
 508 #if DIM == 3
 509 static void store_texel_rg_f32(struct gl_texture_image *texImage,
 510                                GLint i, GLint j, GLint k, const void *texel)
 511 {
 512    const GLfloat *rgba = (const GLfloat *) texel;
 513    GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
 514    dst[0] = rgba[RCOMP];
 515    dst[1] = rgba[GCOMP];
 516 }
 517 #endif
 518
 519
 520 /* MESA_FORMAT_RG_FLOAT16 ****************************************************/
 521
 522 /* Fetch texel from 1D, 2D or 3D RG_FLOAT16 texture,
 523  * returning 4 GLfloats.
 524  */
 525 static void FETCH(f_rg_f16)( const struct gl_texture_image *texImage,
 526                              GLint i, GLint j, GLint k, GLfloat *texel )
 527 {
 528    const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 529    texel[RCOMP] = _mesa_half_to_float(src[0]);
 530    texel[GCOMP] = _mesa_half_to_float(src[1]);
 531    texel[BCOMP] = 0.0F;
 532    texel[ACOMP] = 1.0F;
 533 }
 534
 535 #if DIM == 3
 536 static void store_texel_rg_f16(struct gl_texture_image *texImage,
 537                                GLint i, GLint j, GLint k, const void *texel)
 538 {
 539    const GLfloat *rgba = (const GLfloat *) texel;
 540    GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
 541    dst[0] = _mesa_float_to_half(rgba[RCOMP]);
 542    dst[1] = _mesa_float_to_half(rgba[GCOMP]);
 543 }
 544 #endif
 545
 546
 547 /*
 548  * Begin Hardware formats
 549  */
 550
 551 /* MESA_FORMAT_RGBA8888 ******************************************************/
 552
 553 /* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */
 554 static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,
 555                                GLint i, GLint j, GLint k, GLfloat *texel )
 556 {
 557    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 558    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 559    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 560    texel[BCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 561    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 562 }
 563
 564
 565
 566 #if DIM == 3
 567 static void store_texel_rgba8888(struct gl_texture_image *texImage,
 568                                  GLint i, GLint j, GLint k, const void *texel)
 569 {
 570    const GLubyte *rgba = (const GLubyte *) texel;
 571    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 572    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 573 }
 574 #endif
 575
 576
 577 /* MESA_FORMAT_RGBA888_REV ***************************************************/
 578
 579 /* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */
 580 static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,
 581                                    GLint i, GLint j, GLint k, GLfloat *texel )
 582 {
 583    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 584    texel[RCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 585    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 586    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 587    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 588 }
 589
 590 #if DIM == 3
 591 static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,
 592                                   GLint i, GLint j, GLint k, const void *texel)
 593 {
 594    const GLubyte *rgba = (const GLubyte *) texel;
 595    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 596    *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 597 }
 598 #endif
 599
 600
 601 /* MESA_FORMAT_ARGB8888 ******************************************************/
 602
 603 /* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */
 604 static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,
 605                                GLint i, GLint j, GLint k, GLfloat *texel )
 606 {
 607    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 608    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 609    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 610    texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 611    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 612 }
 613
 614 #if DIM == 3
 615 static void store_texel_argb8888(struct gl_texture_image *texImage,
 616                                  GLint i, GLint j, GLint k, const void *texel)
 617 {
 618    const GLubyte *rgba = (const GLubyte *) texel;
 619    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 620    *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 621 }
 622 #endif
 623
 624
 625 /* MESA_FORMAT_ARGB8888_REV **************************************************/
 626
 627 /* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */
 628 static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,
 629                                    GLint i, GLint j, GLint k, GLfloat *texel )
 630 {
 631    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 632    texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 633    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 634    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 635    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 636 }
 637
 638 #if DIM == 3
 639 static void store_texel_argb8888_rev(struct gl_texture_image *texImage,
 640                                   GLint i, GLint j, GLint k, const void *texel)
 641 {
 642    const GLubyte *rgba = (const GLubyte *) texel;
 643    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 644    *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], rgba[ACOMP]);
 645 }
 646 #endif
 647
 648
 649 /* MESA_FORMAT_XRGB8888 ******************************************************/
 650
 651 /* Fetch texel from 1D, 2D or 3D xrgb8888 texture, return 4 GLchans */
 652 static void FETCH(f_xrgb8888)( const struct gl_texture_image *texImage,
 653                                GLint i, GLint j, GLint k, GLfloat *texel )
 654 {
 655    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 656    texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 657    texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 658    texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 659    texel[ACOMP] = 1.0f;
 660 }
 661
 662 #if DIM == 3
 663 static void store_texel_xrgb8888(struct gl_texture_image *texImage,
 664                                  GLint i, GLint j, GLint k, const void *texel)
 665 {
 666    const GLubyte *rgba = (const GLubyte *) texel;
 667    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 668    *dst = PACK_COLOR_8888(0xff, rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 669 }
 670 #endif
 671
 672
 673 /* MESA_FORMAT_XRGB8888_REV **************************************************/
 674
 675 /* Fetch texel from 1D, 2D or 3D xrgb8888_rev texture, return 4 GLfloats */
 676 static void FETCH(f_xrgb8888_rev)( const struct gl_texture_image *texImage,
 677                                    GLint i, GLint j, GLint k, GLfloat *texel )
 678 {
 679    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 680    texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
 681    texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
 682    texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 683    texel[ACOMP] = 1.0f;
 684 }
 685
 686 #if DIM == 3
 687 static void store_texel_xrgb8888_rev(struct gl_texture_image *texImage,
 688                                      GLint i, GLint j, GLint k, const void *texel)
 689 {
 690    const GLubyte *rgba = (const GLubyte *) texel;
 691    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 692    *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], 0xff);
 693 }
 694 #endif
 695
 696
 697 /* MESA_FORMAT_RGB888 ********************************************************/
 698
 699 /* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */
 700 static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,
 701                              GLint i, GLint j, GLint k, GLfloat *texel )
 702 {
 703    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 704    texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );
 705    texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
 706    texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
 707    texel[ACOMP] = 1.0F;
 708 }
 709
 710 #if DIM == 3
 711 static void store_texel_rgb888(struct gl_texture_image *texImage,
 712                                GLint i, GLint j, GLint k, const void *texel)
 713 {
 714    const GLubyte *rgba = (const GLubyte *) texel;
 715    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 716    dst[0] = rgba[BCOMP];
 717    dst[1] = rgba[GCOMP];
 718    dst[2] = rgba[RCOMP];
 719 }
 720 #endif
 721
 722
 723 /* MESA_FORMAT_BGR888 ********************************************************/
 724
 725 /* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */
 726 static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,
 727                              GLint i, GLint j, GLint k, GLfloat *texel )
 728 {
 729    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 730    texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );
 731    texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
 732    texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );
 733    texel[ACOMP] = 1.0F;
 734 }
 735
 736 #if DIM == 3
 737 static void store_texel_bgr888(struct gl_texture_image *texImage,
 738                                GLint i, GLint j, GLint k, const void *texel)
 739 {
 740    const GLubyte *rgba = (const GLubyte *) texel;
 741    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
 742    dst[0] = rgba[RCOMP];
 743    dst[1] = rgba[GCOMP];
 744    dst[2] = rgba[BCOMP];
 745 }
 746 #endif
 747
 748
 749 /* use color expansion like (g << 2) | (g >> 4) (does somewhat random rounding)
 750    instead of slow (g << 2) * 255 / 252 (always rounds down) */
 751
 752 /* MESA_FORMAT_RGB565 ********************************************************/
 753
 754 /* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */
 755 static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,
 756                              GLint i, GLint j, GLint k, GLfloat *texel )
 757 {
 758    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 759    const GLushort s = *src;
 760    texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
 761    texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);
 762    texel[BCOMP] = ((s      ) & 0x1f) * (1.0F / 31.0F);
 763    texel[ACOMP] = 1.0F;
 764 }
 765
 766 #if DIM == 3
 767 static void store_texel_rgb565(struct gl_texture_image *texImage,
 768                                GLint i, GLint j, GLint k, const void *texel)
 769 {
 770    const GLubyte *rgba = (const GLubyte *) texel;
 771    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 772    *dst = PACK_COLOR_565(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 773 }
 774 #endif
 775
 776
 777 /* MESA_FORMAT_RGB565_REV ****************************************************/
 778
 779 /* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */
 780 static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,
 781                                  GLint i, GLint j, GLint k, GLfloat *texel )
 782 {
 783    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 784    const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */
 785    texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
 786    texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
 787    texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
 788    texel[ACOMP] = 1.0F;
 789 }
 790
 791 #if DIM == 3
 792 static void store_texel_rgb565_rev(struct gl_texture_image *texImage,
 793                                   GLint i, GLint j, GLint k, const void *texel)
 794 {
 795    const GLubyte *rgba = (const GLubyte *) texel;
 796    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 797    *dst = PACK_COLOR_565(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
 798 }
 799 #endif
 800
 801
 802 /* MESA_FORMAT_ARGB4444 ******************************************************/
 803
 804 /* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
 805 static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,
 806                                GLint i, GLint j, GLint k, GLfloat *texel )
 807 {
 808    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 809    const GLushort s = *src;
 810    texel[RCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
 811    texel[GCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
 812    texel[BCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
 813    texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
 814 }
 815
 816 #if DIM == 3
 817 static void store_texel_argb4444(struct gl_texture_image *texImage,
 818                                  GLint i, GLint j, GLint k, const void *texel)
 819 {
 820    const GLubyte *rgba = (const GLubyte *) texel;
 821    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 822    *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 823 }
 824 #endif
 825
 826
 827 /* MESA_FORMAT_ARGB4444_REV **************************************************/
 828
 829 /* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */
 830 static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,
 831                                    GLint i, GLint j, GLint k, GLfloat *texel )
 832 {
 833    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 834    texel[RCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
 835    texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
 836    texel[BCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
 837    texel[ACOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
 838 }
 839
 840 #if DIM == 3
 841 static void store_texel_argb4444_rev(struct gl_texture_image *texImage,
 842                                  GLint i, GLint j, GLint k, const void *texel)
 843 {
 844    const GLubyte *rgba = (const GLubyte *) texel;
 845    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 846    *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
 847 }
 848 #endif
 849
 850 /* MESA_FORMAT_RGBA5551 ******************************************************/
 851
 852 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
 853 static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,
 854                                GLint i, GLint j, GLint k, GLfloat *texel )
 855 {
 856    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 857    const GLushort s = *src;
 858    texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
 859    texel[GCOMP] = ((s >>  6) & 0x1f) * (1.0F / 31.0F);
 860    texel[BCOMP] = ((s >>  1) & 0x1f) * (1.0F / 31.0F);
 861    texel[ACOMP] = ((s      ) & 0x01) * 1.0F;
 862 }
 863
 864 #if DIM == 3
 865 static void store_texel_rgba5551(struct gl_texture_image *texImage,
 866                                  GLint i, GLint j, GLint k, const void *texel)
 867 {
 868    const GLubyte *rgba = (const GLubyte *) texel;
 869    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 870    *dst = PACK_COLOR_5551(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
 871 }
 872 #endif
 873
 874 /* MESA_FORMAT_ARGB1555 ******************************************************/
 875
 876 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
 877 static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,
 878                              GLint i, GLint j, GLint k, GLfloat *texel )
 879 {
 880    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 881    const GLushort s = *src;
 882    texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);
 883    texel[GCOMP] = ((s >>  5) & 0x1f) * (1.0F / 31.0F);
 884    texel[BCOMP] = ((s >>  0) & 0x1f) * (1.0F / 31.0F);
 885    texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;
 886 }
 887
 888 #if DIM == 3
 889 static void store_texel_argb1555(struct gl_texture_image *texImage,
 890                                  GLint i, GLint j, GLint k, const void *texel)
 891 {
 892    const GLubyte *rgba = (const GLubyte *) texel;
 893    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 894    *dst = PACK_COLOR_1555(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 895 }
 896 #endif
 897
 898
 899 /* MESA_FORMAT_ARGB1555_REV **************************************************/
 900
 901 /* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */
 902 static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,
 903                                    GLint i, GLint j, GLint k, GLfloat *texel )
 904 {
 905    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 906    const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */
 907    texel[RCOMP] = UBYTE_TO_FLOAT( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
 908    texel[GCOMP] = UBYTE_TO_FLOAT( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
 909    texel[BCOMP] = UBYTE_TO_FLOAT( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
 910    texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );
 911 }
 912
 913 #if DIM == 3
 914 static void store_texel_argb1555_rev(struct gl_texture_image *texImage,
 915                                  GLint i, GLint j, GLint k, const void *texel)
 916 {
 917    const GLubyte *rgba = (const GLubyte *) texel;
 918    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 919    *dst = PACK_COLOR_1555_REV(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 920 }
 921 #endif
 922
 923
 924 /* MESA_FORMAT_ARGB2101010 ***************************************************/
 925
 926 /* Fetch texel from 1D, 2D or 3D argb2101010 texture, return 4 GLchans */
 927 static void FETCH(f_argb2101010)( const struct gl_texture_image *texImage,
 928                                   GLint i, GLint j, GLint k, GLfloat *texel )
 929 {
 930    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 931    const GLuint s = *src;
 932    texel[RCOMP] = ((s >> 20) & 0x3ff) * (1.0F / 1023.0F);
 933    texel[GCOMP] = ((s >> 10) & 0x3ff) * (1.0F / 1023.0F);
 934    texel[BCOMP] = ((s >>  0) & 0x3ff) * (1.0F / 1023.0F);
 935    texel[ACOMP] = ((s >> 30) & 0x03) * (1.0F / 3.0F);
 936 }
 937
 938 #if DIM == 3
 939 static void store_texel_argb2101010(struct gl_texture_image *texImage,
 940                                     GLint i, GLint j, GLint k, const void *texel)
 941 {
 942    const GLubyte *rgba = (const GLubyte *) texel;
 943    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
 944    *dst = PACK_COLOR_2101010_UB(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 945 }
 946 #endif
 947
 948
 949 /* MESA_FORMAT_RG88 **********************************************************/
 950
 951 /* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
 952 static void FETCH(f_rg88)( const struct gl_texture_image *texImage,
 953                            GLint i, GLint j, GLint k, GLfloat *texel )
 954 {
 955    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 956    texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
 957    texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
 958    texel[BCOMP] = 0.0;
 959    texel[ACOMP] = 1.0;
 960 }
 961
 962 #if DIM == 3
 963 static void store_texel_rg88(struct gl_texture_image *texImage,
 964                              GLint i, GLint j, GLint k, const void *texel)
 965 {
 966    const GLubyte *rgba = (const GLubyte *) texel;
 967    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 968    *dst = PACK_COLOR_88(rgba[RCOMP], rgba[GCOMP]);
 969 }
 970 #endif
 971
 972
 973 /* MESA_FORMAT_RG88_REV ******************************************************/
 974
 975 /* Fetch texel from 1D, 2D or 3D rg88_rev texture, return 4 GLchans */
 976 static void FETCH(f_rg88_rev)( const struct gl_texture_image *texImage,
 977                            GLint i, GLint j, GLint k, GLfloat *texel )
 978 {
 979    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 980    texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
 981    texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
 982    texel[BCOMP] = 0.0;
 983    texel[ACOMP] = 1.0;
 984 }
 985
 986 #if DIM == 3
 987 static void store_texel_rg88_rev(struct gl_texture_image *texImage,
 988                              GLint i, GLint j, GLint k, const void *texel)
 989 {
 990    const GLubyte *rgba = (const GLubyte *) texel;
 991    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
 992    *dst = PACK_COLOR_88(rgba[GCOMP], rgba[RCOMP]);
 993 }
 994 #endif
 995
 996
 997 /* MESA_FORMAT_AL44 **********************************************************/
 998
 999 /* Fetch texel from 1D, 2D or 3D al44 texture, return 4 GLchans */
1000 static void FETCH(f_al44)( const struct gl_texture_image *texImage,
1001                            GLint i, GLint j, GLint k, GLfloat *texel )
1002 {
1003    const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1004    texel[RCOMP] =
1005    texel[GCOMP] =
1006    texel[BCOMP] = (s & 0xf) * (1.0F / 15.0F);
1007    texel[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F);
1008 }
1009
1010 #if DIM == 3
1011 static void store_texel_al44(struct gl_texture_image *texImage,
1012                              GLint i, GLint j, GLint k, const void *texel)
1013 {
1014    const GLubyte *rgba = (const GLubyte *) texel;
1015    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1016    *dst = PACK_COLOR_44(rgba[ACOMP], rgba[RCOMP]);
1017 }
1018 #endif
1019
1020
1021 /* MESA_FORMAT_AL88 **********************************************************/
1022
1023 /* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */
1024 static void FETCH(f_al88)( const struct gl_texture_image *texImage,
1025                            GLint i, GLint j, GLint k, GLfloat *texel )
1026 {
1027    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1028    texel[RCOMP] =
1029    texel[GCOMP] =
1030    texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );
1031    texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );
1032 }
1033
1034 #if DIM == 3
1035 static void store_texel_al88(struct gl_texture_image *texImage,
1036                              GLint i, GLint j, GLint k, const void *texel)
1037 {
1038    const GLubyte *rgba = (const GLubyte *) texel;
1039    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1040    *dst = PACK_COLOR_88(rgba[ACOMP], rgba[RCOMP]);
1041 }
1042 #endif
1043
1044
1045 /* MESA_FORMAT_R8 ************************************************************/
1046
1047 /* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
1048 static void FETCH(f_r8)(const struct gl_texture_image *texImage,
1049                         GLint i, GLint j, GLint k, GLfloat *texel)
1050 {
1051    const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1052    texel[RCOMP] = UBYTE_TO_FLOAT(s);
1053    texel[GCOMP] = 0.0;
1054    texel[BCOMP] = 0.0;
1055    texel[ACOMP] = 1.0;
1056 }
1057
1058 #if DIM == 3
1059 static void store_texel_r8(struct gl_texture_image *texImage,
1060                            GLint i, GLint j, GLint k, const void *texel)
1061 {
1062    const GLubyte *rgba = (const GLubyte *) texel;
1063    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1064    *dst = rgba[RCOMP];
1065 }
1066 #endif
1067
1068
1069 /* MESA_FORMAT_R16 ***********************************************************/
1070
1071 /* Fetch texel from 1D, 2D or 3D r16 texture, return 4 GLchans */
1072 static void FETCH(f_r16)(const struct gl_texture_image *texImage,
1073                         GLint i, GLint j, GLint k, GLfloat *texel)
1074 {
1075    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1076    texel[RCOMP] = USHORT_TO_FLOAT(s);
1077    texel[GCOMP] = 0.0;
1078    texel[BCOMP] = 0.0;
1079    texel[ACOMP] = 1.0;
1080 }
1081
1082 #if DIM == 3
1083 static void store_texel_r16(struct gl_texture_image *texImage,
1084                             GLint i, GLint j, GLint k, const void *texel)
1085 {
1086    const GLushort *rgba = (const GLushort *) texel;
1087    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1088    *dst = rgba[RCOMP];
1089 }
1090 #endif
1091
1092
1093 /* MESA_FORMAT_AL88_REV ******************************************************/
1094
1095 /* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */
1096 static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,
1097                                GLint i, GLint j, GLint k, GLfloat *texel )
1098 {
1099    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1100    texel[RCOMP] =
1101    texel[GCOMP] =
1102    texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );
1103    texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );
1104 }
1105
1106 #if DIM == 3
1107 static void store_texel_al88_rev(struct gl_texture_image *texImage,
1108                                  GLint i, GLint j, GLint k, const void *texel)
1109 {
1110    const GLubyte *rgba = (const GLubyte *) texel;
1111    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1112    *dst = PACK_COLOR_88(rgba[RCOMP], rgba[ACOMP]);
1113 }
1114 #endif
1115
1116
1117 /* MESA_FORMAT_RG1616 ********************************************************/
1118
1119 /* Fetch texel from 1D, 2D or 3D rg1616 texture, return 4 GLchans */
1120 static void FETCH(f_rg1616)( const struct gl_texture_image *texImage,
1121                            GLint i, GLint j, GLint k, GLfloat *texel )
1122 {
1123    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1124    texel[RCOMP] = USHORT_TO_FLOAT( s & 0xffff );
1125    texel[GCOMP] = USHORT_TO_FLOAT( s >> 16 );
1126    texel[BCOMP] = 0.0;
1127    texel[ACOMP] = 1.0;
1128 }
1129
1130 #if DIM == 3
1131 static void store_texel_rg1616(struct gl_texture_image *texImage,
1132                              GLint i, GLint j, GLint k, const void *texel)
1133 {
1134    const GLubyte *rgba = (const GLubyte *) texel;
1135    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1136    *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[GCOMP]);
1137 }
1138 #endif
1139
1140
1141 /* MESA_FORMAT_RG1616_REV ****************************************************/
1142
1143 /* Fetch texel from 1D, 2D or 3D rg1616_rev texture, return 4 GLchans */
1144 static void FETCH(f_rg1616_rev)( const struct gl_texture_image *texImage,
1145                            GLint i, GLint j, GLint k, GLfloat *texel )
1146 {
1147    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1148    texel[RCOMP] = USHORT_TO_FLOAT( s >> 16 );
1149    texel[GCOMP] = USHORT_TO_FLOAT( s & 0xffff );
1150    texel[BCOMP] = 0.0;
1151    texel[ACOMP] = 1.0;
1152 }
1153
1154 #if DIM == 3
1155 static void store_texel_rg1616_rev(struct gl_texture_image *texImage,
1156                              GLint i, GLint j, GLint k, const void *texel)
1157 {
1158    const GLubyte *rgba = (const GLubyte *) texel;
1159    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1160    *dst = PACK_COLOR_1616(rgba[GCOMP], rgba[RCOMP]);
1161 }
1162 #endif
1163
1164
1165 /* MESA_FORMAT_AL1616 ********************************************************/
1166
1167 /* Fetch texel from 1D, 2D or 3D al1616 texture, return 4 GLchans */
1168 static void FETCH(f_al1616)( const struct gl_texture_image *texImage,
1169                              GLint i, GLint j, GLint k, GLfloat *texel )
1170 {
1171    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1172    texel[RCOMP] =
1173    texel[GCOMP] =
1174    texel[BCOMP] = USHORT_TO_FLOAT( s & 0xffff );
1175    texel[ACOMP] = USHORT_TO_FLOAT( s >> 16 );
1176 }
1177
1178 #if DIM == 3
1179 static void store_texel_al1616(struct gl_texture_image *texImage,
1180                              GLint i, GLint j, GLint k, const void *texel)
1181 {
1182    const GLushort *rgba = (const GLushort *) texel;
1183    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1184    *dst = PACK_COLOR_1616(rgba[ACOMP], rgba[RCOMP]);
1185 }
1186 #endif
1187
1188
1189 /* MESA_FORMAT_AL1616_REV ****************************************************/
1190
1191 /* Fetch texel from 1D, 2D or 3D al1616_rev texture, return 4 GLchans */
1192 static void FETCH(f_al1616_rev)( const struct gl_texture_image *texImage,
1193                                  GLint i, GLint j, GLint k, GLfloat *texel )
1194 {
1195    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1196    texel[RCOMP] =
1197    texel[GCOMP] =
1198    texel[BCOMP] = USHORT_TO_FLOAT( s >> 16 );
1199    texel[ACOMP] = USHORT_TO_FLOAT( s & 0xffff );
1200 }
1201
1202 #if DIM == 3
1203 static void store_texel_al1616_rev(struct gl_texture_image *texImage,
1204                                    GLint i, GLint j, GLint k, const void *texel)
1205 {
1206    const GLushort *rgba = (const GLushort *) texel;
1207    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1208    *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[ACOMP]);
1209 }
1210 #endif
1211
1212
1213 /* MESA_FORMAT_RGB332 ********************************************************/
1214
1215 /* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */
1216 static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,
1217                              GLint i, GLint j, GLint k, GLfloat *texel )
1218 {
1219    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1220    const GLubyte s = *src;
1221    texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);
1222    texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);
1223    texel[BCOMP] = ((s     ) & 0x3) * (1.0F / 3.0F);
1224    texel[ACOMP] = 1.0F;
1225 }
1226
1227 #if DIM == 3
1228 static void store_texel_rgb332(struct gl_texture_image *texImage,
1229                                GLint i, GLint j, GLint k, const void *texel)
1230 {
1231    const GLubyte *rgba = (const GLubyte *) texel;
1232    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1233    *dst = PACK_COLOR_332(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
1234 }
1235 #endif
1236
1237
1238 /* MESA_FORMAT_A8 ************************************************************/
1239
1240 /* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
1241 static void FETCH(f_a8)( const struct gl_texture_image *texImage,
1242                          GLint i, GLint j, GLint k, GLfloat *texel )
1243 {
1244    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1245    texel[RCOMP] =
1246    texel[GCOMP] =
1247    texel[BCOMP] = 0.0F;
1248    texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
1249 }
1250
1251 #if DIM == 3
1252 static void store_texel_a8(struct gl_texture_image *texImage,
1253                            GLint i, GLint j, GLint k, const void *texel)
1254 {
1255    const GLubyte *rgba = (const GLubyte *) texel;
1256    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1257    *dst = rgba[ACOMP];
1258 }
1259 #endif
1260
1261
1262 /* MESA_FORMAT_A16 ************************************************************/
1263
1264 /* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
1265 static void FETCH(f_a16)( const struct gl_texture_image *texImage,
1266                           GLint i, GLint j, GLint k, GLfloat *texel )
1267 {
1268    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1269    texel[RCOMP] =
1270    texel[GCOMP] =
1271    texel[BCOMP] = 0.0F;
1272    texel[ACOMP] = USHORT_TO_FLOAT( src[0] );
1273 }
1274
1275 #if DIM == 3
1276 static void store_texel_a16(struct gl_texture_image *texImage,
1277                             GLint i, GLint j, GLint k, const void *texel)
1278 {
1279    const GLushort *rgba = (const GLushort *) texel;
1280    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1281    *dst = rgba[ACOMP];
1282 }
1283 #endif
1284
1285
1286 /* MESA_FORMAT_L8 ************************************************************/
1287
1288 /* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */
1289 static void FETCH(f_l8)( const struct gl_texture_image *texImage,
1290                          GLint i, GLint j, GLint k, GLfloat *texel )
1291 {
1292    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1293    texel[RCOMP] =
1294    texel[GCOMP] =
1295    texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
1296    texel[ACOMP] = 1.0F;
1297 }
1298
1299 #if DIM == 3
1300 static void store_texel_l8(struct gl_texture_image *texImage,
1301                            GLint i, GLint j, GLint k, const void *texel)
1302 {
1303    const GLubyte *rgba = (const GLubyte *) texel;
1304    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1305    *dst = rgba[RCOMP];
1306 }
1307 #endif
1308
1309
1310 /* MESA_FORMAT_L16 ***********************************************************/
1311
1312 /* Fetch texel from 1D, 2D or 3D l16 texture, return 4 GLchans */
1313 static void FETCH(f_l16)( 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, 1);
1317    texel[RCOMP] =
1318    texel[GCOMP] =
1319    texel[BCOMP] = USHORT_TO_FLOAT( src[0] );
1320    texel[ACOMP] = 1.0F;
1321 }
1322
1323 #if DIM == 3
1324 static void store_texel_l16(struct gl_texture_image *texImage,
1325                             GLint i, GLint j, GLint k, const void *texel)
1326 {
1327    const GLushort *rgba = (const GLushort *) texel;
1328    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1329    *dst = rgba[RCOMP];
1330 }
1331 #endif
1332
1333
1334 /* MESA_FORMAT_I8 ************************************************************/
1335
1336 /* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */
1337 static void FETCH(f_i8)( const struct gl_texture_image *texImage,
1338                          GLint i, GLint j, GLint k, GLfloat *texel )
1339 {
1340    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1341    texel[RCOMP] =
1342    texel[GCOMP] =
1343    texel[BCOMP] =
1344    texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
1345 }
1346
1347 #if DIM == 3
1348 static void store_texel_i8(struct gl_texture_image *texImage,
1349                            GLint i, GLint j, GLint k, const void *texel)
1350 {
1351    const GLubyte *rgba = (const GLubyte *) texel;
1352    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1353    *dst = rgba[RCOMP];
1354 }
1355 #endif
1356
1357
1358 /* MESA_FORMAT_I16 ***********************************************************/
1359
1360 /* Fetch texel from 1D, 2D or 3D i16 texture, return 4 GLchans */
1361 static void FETCH(f_i16)( const struct gl_texture_image *texImage,
1362                           GLint i, GLint j, GLint k, GLfloat *texel )
1363 {
1364    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1365    texel[RCOMP] =
1366    texel[GCOMP] =
1367    texel[BCOMP] =
1368    texel[ACOMP] = USHORT_TO_FLOAT( src[0] );
1369 }
1370
1371 #if DIM == 3
1372 static void store_texel_i16(struct gl_texture_image *texImage,
1373                             GLint i, GLint j, GLint k, const void *texel)
1374 {
1375    const GLushort *rgba = (const GLushort *) texel;
1376    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1377    *dst = rgba[RCOMP];
1378 }
1379 #endif
1380
1381
1382 /* MESA_FORMAT_CI8 ***********************************************************/
1383
1384 /* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a
1385  * color table, and return 4 GLchans.
1386  */
1387 static void FETCH(f_ci8)( const struct gl_texture_image *texImage,
1388                           GLint i, GLint j, GLint k, GLfloat *texel )
1389 {
1390    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1391    const struct gl_color_table *palette;
1392    GLuint index;
1393    GET_CURRENT_CONTEXT(ctx);
1394
1395    if (ctx->Texture.SharedPalette) {
1396       palette = &ctx->Texture.Palette;
1397    }
1398    else {
1399       palette = &texImage->TexObject->Palette;
1400    }
1401    if (palette->Size == 0)
1402       return; /* undefined results */
1403
1404    /* Mask the index against size of palette to avoid going out of bounds */
1405    index = (*src) & (palette->Size - 1);
1406
1407    {
1408       const GLfloat *table = palette->TableF;
1409       switch (palette->_BaseFormat) {
1410       case GL_ALPHA:
1411          texel[RCOMP] =
1412          texel[GCOMP] =
1413          texel[BCOMP] = 0.0F;
1414          texel[ACOMP] = table[index];
1415          break;
1416       case GL_LUMINANCE:
1417          texel[RCOMP] =
1418          texel[GCOMP] =
1419          texel[BCOMP] = table[index];
1420          texel[ACOMP] = 1.0F;
1421          break;
1422       case GL_INTENSITY:
1423          texel[RCOMP] =
1424          texel[GCOMP] =
1425          texel[BCOMP] =
1426          texel[ACOMP] = table[index];
1427          break;
1428       case GL_LUMINANCE_ALPHA:
1429          texel[RCOMP] =
1430          texel[GCOMP] =
1431          texel[BCOMP] = table[index * 2 + 0];
1432          texel[ACOMP] = table[index * 2 + 1];
1433          break;
1434       case GL_RGB:
1435          texel[RCOMP] = table[index * 3 + 0];
1436          texel[GCOMP] = table[index * 3 + 1];
1437          texel[BCOMP] = table[index * 3 + 2];
1438          texel[ACOMP] = 1.0F;
1439          break;
1440       case GL_RGBA:
1441          texel[RCOMP] = table[index * 4 + 0];
1442          texel[GCOMP] = table[index * 4 + 1];
1443          texel[BCOMP] = table[index * 4 + 2];
1444          texel[ACOMP] = table[index * 4 + 3];
1445          break;
1446       default:
1447          _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");
1448          return;
1449       }
1450    }
1451 }
1452
1453 #if DIM == 3
1454 static void store_texel_ci8(struct gl_texture_image *texImage,
1455                             GLint i, GLint j, GLint k, const void *texel)
1456 {
1457    const GLubyte *index = (const GLubyte *) texel;
1458    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1459    *dst = *index;
1460 }
1461 #endif
1462
1463
1464 /* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */
1465 /* Note: component order is same as for MESA_FORMAT_RGB888 */
1466 static void FETCH(srgb8)(const struct gl_texture_image *texImage,
1467                          GLint i, GLint j, GLint k, GLfloat *texel )
1468 {
1469    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1470    texel[RCOMP] = nonlinear_to_linear(src[2]);
1471    texel[GCOMP] = nonlinear_to_linear(src[1]);
1472    texel[BCOMP] = nonlinear_to_linear(src[0]);
1473    texel[ACOMP] = 1.0F;
1474 }
1475
1476 #if DIM == 3
1477 static void store_texel_srgb8(struct gl_texture_image *texImage,
1478                               GLint i, GLint j, GLint k, const void *texel)
1479 {
1480    const GLubyte *rgba = (const GLubyte *) texel;
1481    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1482    dst[0] = rgba[BCOMP]; /* no conversion */
1483    dst[1] = rgba[GCOMP];
1484    dst[2] = rgba[RCOMP];
1485 }
1486 #endif
1487
1488 /* Fetch texel from 1D, 2D or 3D srgba8 texture, return 4 GLfloats */
1489 static void FETCH(srgba8)(const struct gl_texture_image *texImage,
1490                           GLint i, GLint j, GLint k, GLfloat *texel )
1491 {
1492    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1493    texel[RCOMP] = nonlinear_to_linear( (s >> 24) );
1494    texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1495    texel[BCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
1496    texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff ); /* linear! */
1497 }
1498
1499 #if DIM == 3
1500 static void store_texel_srgba8(struct gl_texture_image *texImage,
1501                                GLint i, GLint j, GLint k, const void *texel)
1502 {
1503    const GLubyte *rgba = (const GLubyte *) texel;
1504    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1505    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1506 }
1507 #endif
1508
1509 /* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */
1510 static void FETCH(sargb8)(const struct gl_texture_image *texImage,
1511                           GLint i, GLint j, GLint k, GLfloat *texel )
1512 {
1513    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1514    texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1515    texel[GCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
1516    texel[BCOMP] = nonlinear_to_linear( (s      ) & 0xff );
1517    texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */
1518 }
1519
1520 #if DIM == 3
1521 static void store_texel_sargb8(struct gl_texture_image *texImage,
1522                                GLint i, GLint j, GLint k, const void *texel)
1523 {
1524    const GLubyte *rgba = (const GLubyte *) texel;
1525    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1526    *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
1527 }
1528 #endif
1529
1530 /* Fetch texel from 1D, 2D or 3D sl8 texture, return 4 GLfloats */
1531 static void FETCH(sl8)(const struct gl_texture_image *texImage,
1532                        GLint i, GLint j, GLint k, GLfloat *texel )
1533 {
1534    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1535    texel[RCOMP] =
1536    texel[GCOMP] =
1537    texel[BCOMP] = nonlinear_to_linear(src[0]);
1538    texel[ACOMP] = 1.0F;
1539 }
1540
1541 #if DIM == 3
1542 static void store_texel_sl8(struct gl_texture_image *texImage,
1543                             GLint i, GLint j, GLint k, const void *texel)
1544 {
1545    const GLubyte *rgba = (const GLubyte *) texel;
1546    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1547    dst[0] = rgba[RCOMP];
1548 }
1549 #endif
1550
1551 /* Fetch texel from 1D, 2D or 3D sla8 texture, return 4 GLfloats */
1552 static void FETCH(sla8)(const struct gl_texture_image *texImage,
1553                        GLint i, GLint j, GLint k, GLfloat *texel )
1554 {
1555    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1556    texel[RCOMP] =
1557    texel[GCOMP] =
1558    texel[BCOMP] = nonlinear_to_linear(src[0]);
1559    texel[ACOMP] = UBYTE_TO_FLOAT(src[1]); /* linear */
1560 }
1561
1562 #if DIM == 3
1563 static void store_texel_sla8(struct gl_texture_image *texImage,
1564                             GLint i, GLint j, GLint k, const void *texel)
1565 {
1566    const GLubyte *rgba = (const GLubyte *) texel;
1567    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1568    dst[0] = rgba[RCOMP];
1569    dst[1] = rgba[ACOMP];
1570 }
1571 #endif
1572
1573
1574 /* MESA_FORMAT_RGBA_INT8 **************************************************/
1575
1576 static void
1577 FETCH(rgba_int8)(const struct gl_texture_image *texImage,
1578                  GLint i, GLint j, GLint k, GLfloat *texel )
1579 {
1580    const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1581    texel[RCOMP] = (GLfloat) src[0];
1582    texel[GCOMP] = (GLfloat) src[1];
1583    texel[BCOMP] = (GLfloat) src[2];
1584    texel[ACOMP] = (GLfloat) src[3];
1585 }
1586
1587 #if DIM == 3
1588 static void
1589 store_texel_rgba_int8(struct gl_texture_image *texImage,
1590                       GLint i, GLint j, GLint k, const void *texel)
1591 {
1592    const GLbyte *rgba = (const GLbyte *) texel;
1593    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1594    dst[0] = rgba[RCOMP];
1595    dst[1] = rgba[GCOMP];
1596    dst[2] = rgba[BCOMP];
1597    dst[3] = rgba[ACOMP];
1598 }
1599 #endif
1600
1601
1602 /* MESA_FORMAT_RGBA_INT16 **************************************************/
1603
1604 static void
1605 FETCH(rgba_int16)(const struct gl_texture_image *texImage,
1606                   GLint i, GLint j, GLint k, GLfloat *texel )
1607 {
1608    const GLshort *src = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1609    texel[RCOMP] = (GLfloat) src[0];
1610    texel[GCOMP] = (GLfloat) src[1];
1611    texel[BCOMP] = (GLfloat) src[2];
1612    texel[ACOMP] = (GLfloat) src[3];
1613 }
1614
1615 #if DIM == 3
1616 static void
1617 store_texel_rgba_int16(struct gl_texture_image *texImage,
1618                        GLint i, GLint j, GLint k, const void *texel)
1619 {
1620    const GLshort *rgba = (const GLshort *) texel;
1621    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1622    dst[0] = rgba[RCOMP];
1623    dst[1] = rgba[GCOMP];
1624    dst[2] = rgba[BCOMP];
1625    dst[3] = rgba[ACOMP];
1626 }
1627 #endif
1628
1629
1630 /* MESA_FORMAT_RGBA_INT32 **************************************************/
1631
1632 static void
1633 FETCH(rgba_int32)(const struct gl_texture_image *texImage,
1634                   GLint i, GLint j, GLint k, GLfloat *texel )
1635 {
1636    const GLint *src = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1637    texel[RCOMP] = (GLfloat) src[0];
1638    texel[GCOMP] = (GLfloat) src[1];
1639    texel[BCOMP] = (GLfloat) src[2];
1640    texel[ACOMP] = (GLfloat) src[3];
1641 }
1642
1643 #if DIM == 3
1644 static void
1645 store_texel_rgba_int32(struct gl_texture_image *texImage,
1646                        GLint i, GLint j, GLint k, const void *texel)
1647 {
1648    const GLint *rgba = (const GLint *) texel;
1649    GLint *dst = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1650    dst[0] = rgba[RCOMP];
1651    dst[1] = rgba[GCOMP];
1652    dst[2] = rgba[BCOMP];
1653    dst[3] = rgba[ACOMP];
1654 }
1655 #endif
1656
1657
1658 /* MESA_FORMAT_RGBA_UINT8 **************************************************/
1659
1660 static void
1661 FETCH(rgba_uint8)(const struct gl_texture_image *texImage,
1662                  GLint i, GLint j, GLint k, GLfloat *texel )
1663 {
1664    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1665    texel[RCOMP] = (GLfloat) src[0];
1666    texel[GCOMP] = (GLfloat) src[1];
1667    texel[BCOMP] = (GLfloat) src[2];
1668    texel[ACOMP] = (GLfloat) src[3];
1669 }
1670
1671 #if DIM == 3
1672 static void
1673 store_texel_rgba_uint8(struct gl_texture_image *texImage,
1674                       GLint i, GLint j, GLint k, const void *texel)
1675 {
1676    const GLubyte *rgba = (const GLubyte *) texel;
1677    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1678    dst[0] = rgba[RCOMP];
1679    dst[1] = rgba[GCOMP];
1680    dst[2] = rgba[BCOMP];
1681    dst[3] = rgba[ACOMP];
1682 }
1683 #endif
1684
1685
1686 /* MESA_FORMAT_RGBA_UINT16 **************************************************/
1687
1688 static void
1689 FETCH(rgba_uint16)(const struct gl_texture_image *texImage,
1690                   GLint i, GLint j, GLint k, GLfloat *texel )
1691 {
1692    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1693    texel[RCOMP] = (GLfloat) src[0];
1694    texel[GCOMP] = (GLfloat) src[1];
1695    texel[BCOMP] = (GLfloat) src[2];
1696    texel[ACOMP] = (GLfloat) src[3];
1697 }
1698
1699 #if DIM == 3
1700 static void
1701 store_texel_rgba_uint16(struct gl_texture_image *texImage,
1702                        GLint i, GLint j, GLint k, const void *texel)
1703 {
1704    const GLushort *rgba = (const GLushort *) texel;
1705    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1706    dst[0] = rgba[RCOMP];
1707    dst[1] = rgba[GCOMP];
1708    dst[2] = rgba[BCOMP];
1709    dst[3] = rgba[ACOMP];
1710 }
1711 #endif
1712
1713
1714 /* MESA_FORMAT_RGBA_UINT32 **************************************************/
1715
1716 static void
1717 FETCH(rgba_uint32)(const struct gl_texture_image *texImage,
1718                   GLint i, GLint j, GLint k, GLfloat *texel )
1719 {
1720    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1721    texel[RCOMP] = (GLfloat) src[0];
1722    texel[GCOMP] = (GLfloat) src[1];
1723    texel[BCOMP] = (GLfloat) src[2];
1724    texel[ACOMP] = (GLfloat) src[3];
1725 }
1726
1727 #if DIM == 3
1728 static void
1729 store_texel_rgba_uint32(struct gl_texture_image *texImage,
1730                        GLint i, GLint j, GLint k, const void *texel)
1731 {
1732    const GLuint *rgba = (const GLuint *) texel;
1733    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1734    dst[0] = rgba[RCOMP];
1735    dst[1] = rgba[GCOMP];
1736    dst[2] = rgba[BCOMP];
1737    dst[3] = rgba[ACOMP];
1738 }
1739 #endif
1740
1741
1742 /* MESA_FORMAT_DUDV8 ********************************************************/
1743
1744 /* this format by definition produces 0,0,0,1 as rgba values,
1745    however we'll return the dudv values as rg and fix up elsewhere */
1746 static void FETCH(dudv8)(const struct gl_texture_image *texImage,
1747                          GLint i, GLint j, GLint k, GLfloat *texel )
1748 {
1749    const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);
1750    texel[RCOMP] = BYTE_TO_FLOAT(src[0]);
1751    texel[GCOMP] = BYTE_TO_FLOAT(src[1]);
1752    texel[BCOMP] = 0;
1753    texel[ACOMP] = 0;
1754 }
1755
1756
1757 /* MESA_FORMAT_SIGNED_R8 ***********************************************/
1758
1759 static void FETCH(signed_r8)( const struct gl_texture_image *texImage,
1760                               GLint i, GLint j, GLint k, GLfloat *texel )
1761 {
1762    const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1763    texel[RCOMP] = BYTE_TO_FLOAT_TEX( s );
1764    texel[GCOMP] = 0.0F;
1765    texel[BCOMP] = 0.0F;
1766    texel[ACOMP] = 1.0F;
1767 }
1768
1769 #if DIM == 3
1770 static void store_texel_signed_r8(struct gl_texture_image *texImage,
1771                                   GLint i, GLint j, GLint k, const void *texel)
1772 {
1773    const GLbyte *rgba = (const GLbyte *) texel;
1774    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1775    *dst = rgba[RCOMP];
1776 }
1777 #endif
1778
1779
1780 /* MESA_FORMAT_SIGNED_A8 ***********************************************/
1781
1782 static void FETCH(signed_a8)( const struct gl_texture_image *texImage,
1783                               GLint i, GLint j, GLint k, GLfloat *texel )
1784 {
1785    const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1786    texel[RCOMP] = 0.0F;
1787    texel[GCOMP] = 0.0F;
1788    texel[BCOMP] = 0.0F;
1789    texel[ACOMP] = BYTE_TO_FLOAT_TEX( s );
1790 }
1791
1792 #if DIM == 3
1793 static void store_texel_signed_a8(struct gl_texture_image *texImage,
1794                                   GLint i, GLint j, GLint k, const void *texel)
1795 {
1796    const GLbyte *rgba = (const GLbyte *) texel;
1797    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1798    *dst = rgba[ACOMP];
1799 }
1800 #endif
1801
1802
1803 /* MESA_FORMAT_SIGNED_L8 ***********************************************/
1804
1805 static void FETCH(signed_l8)( const struct gl_texture_image *texImage,
1806                               GLint i, GLint j, GLint k, GLfloat *texel )
1807 {
1808    const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1809    texel[RCOMP] =
1810    texel[GCOMP] =
1811    texel[BCOMP] = BYTE_TO_FLOAT_TEX( s );
1812    texel[ACOMP] = 1.0F;
1813 }
1814
1815 #if DIM == 3
1816 static void store_texel_signed_l8(struct gl_texture_image *texImage,
1817                                   GLint i, GLint j, GLint k, const void *texel)
1818 {
1819    const GLbyte *rgba = (const GLbyte *) texel;
1820    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1821    *dst = rgba[RCOMP];
1822 }
1823 #endif
1824
1825
1826 /* MESA_FORMAT_SIGNED_I8 ***********************************************/
1827
1828 static void FETCH(signed_i8)( const struct gl_texture_image *texImage,
1829                               GLint i, GLint j, GLint k, GLfloat *texel )
1830 {
1831    const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1832    texel[RCOMP] =
1833    texel[GCOMP] =
1834    texel[BCOMP] =
1835    texel[ACOMP] = BYTE_TO_FLOAT_TEX( s );
1836 }
1837
1838 #if DIM == 3
1839 static void store_texel_signed_i8(struct gl_texture_image *texImage,
1840                                   GLint i, GLint j, GLint k, const void *texel)
1841 {
1842    const GLbyte *rgba = (const GLbyte *) texel;
1843    GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1844    *dst = rgba[RCOMP];
1845 }
1846 #endif
1847
1848
1849 /* MESA_FORMAT_SIGNED_RG88_REV ***********************************************/
1850
1851 static void FETCH(signed_rg88_rev)( const struct gl_texture_image *texImage,
1852                                     GLint i, GLint j, GLint k, GLfloat *texel )
1853 {
1854    const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1855    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
1856    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1857    texel[BCOMP] = 0.0F;
1858    texel[ACOMP] = 1.0F;
1859 }
1860
1861 #if DIM == 3
1862 static void store_texel_signed_rg88_rev(struct gl_texture_image *texImage,
1863                                         GLint i, GLint j, GLint k, const void *texel)
1864 {
1865    const GLbyte *rg = (const GLbyte *) texel;
1866    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1867    dst[0] = PACK_COLOR_88(rg[GCOMP], rg[RCOMP]);
1868 }
1869 #endif
1870
1871
1872 /* MESA_FORMAT_SIGNED_AL88 ***********************************************/
1873
1874 static void FETCH(signed_al88)( const struct gl_texture_image *texImage,
1875                                 GLint i, GLint j, GLint k, GLfloat *texel )
1876 {
1877    const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1878    texel[RCOMP] =
1879    texel[GCOMP] =
1880    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
1881    texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1882 }
1883
1884 #if DIM == 3
1885 static void store_texel_signed_al88(struct gl_texture_image *texImage,
1886                                     GLint i, GLint j, GLint k, const void *texel)
1887 {
1888    const GLbyte *rg = (const GLbyte *) texel;
1889    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1890    dst[0] = PACK_COLOR_88(rg[ACOMP], rg[RCOMP]);
1891 }
1892 #endif
1893
1894
1895 /* MESA_FORMAT_SIGNED_RGBX8888 ***********************************************/
1896
1897 static void FETCH(signed_rgbx8888)( const struct gl_texture_image *texImage,
1898                                     GLint i, GLint j, GLint k, GLfloat *texel )
1899 {
1900    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1901    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1902    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1903    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1904    texel[ACOMP] = 1.0f;
1905 }
1906
1907 #if DIM == 3
1908 static void store_texel_signed_rgbx8888(struct gl_texture_image *texImage,
1909                                         GLint i, GLint j, GLint k, const void *texel)
1910 {
1911    const GLbyte *rgba = (const GLbyte *) texel;
1912    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1913    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], 255);
1914 }
1915 #endif
1916
1917
1918 /* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/
1919
1920 static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,
1921                                     GLint i, GLint j, GLint k, GLfloat *texel )
1922 {
1923    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1924    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1925    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1926    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1927    texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
1928 }
1929
1930 #if DIM == 3
1931 static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,
1932                                         GLint i, GLint j, GLint k, const void *texel)
1933 {
1934    const GLbyte *rgba = (const GLbyte *) texel;
1935    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1936    *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1937 }
1938 #endif
1939
1940 static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,
1941                                         GLint i, GLint j, GLint k, GLfloat *texel )
1942 {
1943    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1944    texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
1945    texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
1946    texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1947    texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1948 }
1949
1950 #if DIM == 3
1951 static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,
1952                                             GLint i, GLint j, GLint k, const void *texel)
1953 {
1954    const GLubyte *rgba = (const GLubyte *) texel;
1955    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1956    *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1957 }
1958 #endif
1959
1960
1961
1962 /* MESA_FORMAT_SIGNED_R16 ***********************************************/
1963
1964 static void
1965 FETCH(signed_r16)(const struct gl_texture_image *texImage,
1966                   GLint i, GLint j, GLint k, GLfloat *texel)
1967 {
1968    const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1969    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s );
1970    texel[GCOMP] = 0.0F;
1971    texel[BCOMP] = 0.0F;
1972    texel[ACOMP] = 1.0F;
1973 }
1974
1975 #if DIM == 3
1976 static void
1977 store_texel_signed_r16(struct gl_texture_image *texImage,
1978                        GLint i, GLint j, GLint k, const void *texel)
1979 {
1980    const GLshort *rgba = (const GLshort *) texel;
1981    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1982    *dst = rgba[0];
1983 }
1984 #endif
1985
1986
1987 /* MESA_FORMAT_SIGNED_A16 ***********************************************/
1988
1989 static void
1990 FETCH(signed_a16)(const struct gl_texture_image *texImage,
1991                   GLint i, GLint j, GLint k, GLfloat *texel)
1992 {
1993    const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1994    texel[RCOMP] = 0.0F;
1995    texel[GCOMP] = 0.0F;
1996    texel[BCOMP] = 0.0F;
1997    texel[ACOMP] = SHORT_TO_FLOAT_TEX( s );
1998 }
1999
2000 #if DIM == 3
2001 static void
2002 store_texel_signed_a16(struct gl_texture_image *texImage,
2003                        GLint i, GLint j, GLint k, const void *texel)
2004 {
2005    const GLshort *rgba = (const GLshort *) texel;
2006    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
2007    *dst = rgba[ACOMP];
2008 }
2009 #endif
2010
2011
2012 /* MESA_FORMAT_SIGNED_L16 ***********************************************/
2013
2014 static void
2015 FETCH(signed_l16)(const struct gl_texture_image *texImage,
2016                   GLint i, GLint j, GLint k, GLfloat *texel)
2017 {
2018    const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
2019    texel[RCOMP] =
2020    texel[GCOMP] =
2021    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s );
2022    texel[ACOMP] = 1.0F;
2023 }
2024
2025 #if DIM == 3
2026 static void
2027 store_texel_signed_l16(struct gl_texture_image *texImage,
2028                        GLint i, GLint j, GLint k, const void *texel)
2029 {
2030    const GLshort *rgba = (const GLshort *) texel;
2031    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
2032    *dst = rgba[RCOMP];
2033 }
2034 #endif
2035
2036
2037 /* MESA_FORMAT_SIGNED_I16 ***********************************************/
2038
2039 static void
2040 FETCH(signed_i16)(const struct gl_texture_image *texImage,
2041                   GLint i, GLint j, GLint k, GLfloat *texel)
2042 {
2043    const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
2044    texel[RCOMP] =
2045    texel[GCOMP] =
2046    texel[BCOMP] =
2047    texel[ACOMP] = SHORT_TO_FLOAT_TEX( s );
2048 }
2049
2050 #if DIM == 3
2051 static void
2052 store_texel_signed_i16(struct gl_texture_image *texImage,
2053                        GLint i, GLint j, GLint k, const void *texel)
2054 {
2055    const GLshort *rgba = (const GLshort *) texel;
2056    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
2057    *dst = rgba[RCOMP];
2058 }
2059 #endif
2060
2061
2062 /* MESA_FORMAT_SIGNED_RG1616 ***********************************************/
2063
2064 static void
2065 FETCH(signed_rg1616)(const struct gl_texture_image *texImage,
2066                     GLint i, GLint j, GLint k, GLfloat *texel)
2067 {
2068    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
2069    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
2070    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
2071    texel[BCOMP] = 0.0F;
2072    texel[ACOMP] = 1.0F;
2073 }
2074
2075 #if DIM == 3
2076 static void
2077 store_texel_signed_rg1616(struct gl_texture_image *texImage,
2078                          GLint i, GLint j, GLint k, const void *texel)
2079 {
2080    const GLshort *rgba = (const GLshort *) texel;
2081    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
2082    dst[0] = rgba[RCOMP];
2083    dst[1] = rgba[GCOMP];
2084 }
2085 #endif
2086
2087
2088 /* MESA_FORMAT_SIGNED_AL1616 ***********************************************/
2089
2090 static void
2091 FETCH(signed_al1616)(const struct gl_texture_image *texImage,
2092                     GLint i, GLint j, GLint k, GLfloat *texel)
2093 {
2094    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
2095    texel[RCOMP] =
2096    texel[GCOMP] =
2097    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
2098    texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[1] );
2099 }
2100
2101 #if DIM == 3
2102 static void
2103 store_texel_signed_al1616(struct gl_texture_image *texImage,
2104                          GLint i, GLint j, GLint k, const void *texel)
2105 {
2106    const GLshort *rgba = (const GLshort *) texel;
2107    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
2108    dst[0] = rgba[RCOMP];
2109    dst[1] = rgba[ACOMP];
2110 }
2111 #endif
2112
2113
2114 /* MESA_FORMAT_SIGNED_RGB_16 ***********************************************/
2115
2116 static void
2117 FETCH(signed_rgb_16)(const struct gl_texture_image *texImage,
2118                      GLint i, GLint j, GLint k, GLfloat *texel)
2119 {
2120    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
2121    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
2122    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
2123    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
2124    texel[ACOMP] = 1.0F;
2125 }
2126
2127 #if DIM == 3
2128 static void
2129 store_texel_signed_rgb_16(struct gl_texture_image *texImage,
2130                           GLint i, GLint j, GLint k, const void *texel)
2131 {
2132    const GLshort *rgba = (const GLshort *) texel;
2133    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
2134    dst[0] = rgba[RCOMP];
2135    dst[1] = rgba[GCOMP];
2136    dst[2] = rgba[BCOMP];
2137 }
2138 #endif
2139
2140
2141 /* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
2142
2143 static void
2144 FETCH(signed_rgba_16)(const struct gl_texture_image *texImage,
2145                       GLint i, GLint j, GLint k, GLfloat *texel)
2146 {
2147    const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
2148    texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
2149    texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
2150    texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
2151    texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] );
2152 }
2153
2154 #if DIM == 3
2155 static void
2156 store_texel_signed_rgba_16(struct gl_texture_image *texImage,
2157                            GLint i, GLint j, GLint k, const void *texel)
2158 {
2159    const GLshort *rgba = (const GLshort *) texel;
2160    GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
2161    dst[0] = rgba[RCOMP];
2162    dst[1] = rgba[GCOMP];
2163    dst[2] = rgba[BCOMP];
2164    dst[3] = rgba[ACOMP];
2165 }
2166 #endif
2167
2168
2169
2170 /* MESA_FORMAT_RGBA_16 ***********************************************/
2171
2172 static void
2173 FETCH(rgba_16)(const struct gl_texture_image *texImage,
2174                GLint i, GLint j, GLint k, GLfloat *texel)
2175 {
2176    const GLushort *s = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
2177    texel[RCOMP] = USHORT_TO_FLOAT( s[0] );
2178    texel[GCOMP] = USHORT_TO_FLOAT( s[1] );
2179    texel[BCOMP] = USHORT_TO_FLOAT( s[2] );
2180    texel[ACOMP] = USHORT_TO_FLOAT( s[3] );
2181 }
2182
2183 #if DIM == 3
2184 static void
2185 store_texel_rgba_16(struct gl_texture_image *texImage,
2186                     GLint i, GLint j, GLint k, const void *texel)
2187 {
2188    const GLushort *rgba = (const GLushort *) texel;
2189    GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
2190    dst[0] = rgba[RCOMP];
2191    dst[1] = rgba[GCOMP];
2192    dst[2] = rgba[BCOMP];
2193    dst[3] = rgba[ACOMP];
2194 }
2195 #endif
2196
2197
2198
2199 /* MESA_FORMAT_YCBCR *********************************************************/
2200
2201 /* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.
2202  * We convert YCbCr to RGB here.
2203  */
2204 static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,
2205                             GLint i, GLint j, GLint k, GLfloat *texel )
2206 {
2207    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
2208    const GLushort *src1 = src0 + 1;                               /* odd */
2209    const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
2210    const GLubyte cb = *src0 & 0xff;         /* chroma U */
2211    const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
2212    const GLubyte cr = *src1 & 0xff;         /* chroma V */
2213    const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
2214    GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
2215    GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
2216    GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
2217    r *= (1.0F / 255.0F);
2218    g *= (1.0F / 255.0F);
2219    b *= (1.0F / 255.0F);
2220    texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
2221    texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
2222    texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
2223    texel[ACOMP] = 1.0F;
2224 }
2225
2226 #if DIM == 3
2227 static void store_texel_ycbcr(struct gl_texture_image *texImage,
2228                               GLint i, GLint j, GLint k, const void *texel)
2229 {
2230    (void) texImage;
2231    (void) i;
2232    (void) j;
2233    (void) k;
2234    (void) texel;
2235    /* XXX to do */
2236 }
2237 #endif
2238
2239
2240 /* MESA_FORMAT_YCBCR_REV *****************************************************/
2241
2242 /* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.
2243  * We convert YCbCr to RGB here.
2244  */
2245 static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,
2246                                 GLint i, GLint j, GLint k, GLfloat *texel )
2247 {
2248    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
2249    const GLushort *src1 = src0 + 1;                               /* odd */
2250    const GLubyte y0 = *src0 & 0xff;         /* luminance */
2251    const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
2252    const GLubyte y1 = *src1 & 0xff;         /* luminance */
2253    const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
2254    const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
2255    GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
2256    GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
2257    GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
2258    r *= (1.0F / 255.0F);
2259    g *= (1.0F / 255.0F);
2260    b *= (1.0F / 255.0F);
2261    texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
2262    texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
2263    texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
2264    texel[ACOMP] = 1.0F;
2265 }
2266
2267 #if DIM == 3
2268 static void store_texel_ycbcr_rev(struct gl_texture_image *texImage,
2269                                   GLint i, GLint j, GLint k, const void *texel)
2270 {
2271    (void) texImage;
2272    (void) i;
2273    (void) j;
2274    (void) k;
2275    (void) texel;
2276    /* XXX to do */
2277 }
2278 #endif
2279
2280
2281 /* MESA_TEXFORMAT_Z24_S8 ***************************************************/
2282
2283 static void FETCH(f_z24_s8)( const struct gl_texture_image *texImage,
2284                              GLint i, GLint j, GLint k, GLfloat *texel )
2285 {
2286    /* only return Z, not stencil data */
2287    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2288    const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
2289    texel[0] = ((*src) >> 8) * scale;
2290    ASSERT(texImage->TexFormat == MESA_FORMAT_Z24_S8);
2291    ASSERT(texel[0] >= 0.0F);
2292    ASSERT(texel[0] <= 1.0F);
2293 }
2294
2295 #if DIM == 3
2296 static void store_texel_z24_s8(struct gl_texture_image *texImage,
2297                                GLint i, GLint j, GLint k, const void *texel)
2298 {
2299    /* only store Z, not stencil */
2300    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2301    GLfloat depth = *((GLfloat *) texel);
2302    GLuint zi = ((GLuint) (depth * 0xffffff)) << 8;
2303    *dst = zi | (*dst & 0xff);
2304 }
2305 #endif
2306
2307
2308 /* MESA_TEXFORMAT_S8_Z24 ***************************************************/
2309
2310 static void FETCH(f_s8_z24)( const struct gl_texture_image *texImage,
2311                              GLint i, GLint j, GLint k, GLfloat *texel )
2312 {
2313    /* only return Z, not stencil data */
2314    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2315    const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
2316    texel[0] = ((*src) & 0x00ffffff) * scale;
2317    ASSERT(texImage->TexFormat == MESA_FORMAT_S8_Z24);
2318    ASSERT(texel[0] >= 0.0F);
2319    ASSERT(texel[0] <= 1.0F);
2320 }
2321
2322 #if DIM == 3
2323 static void store_texel_s8_z24(struct gl_texture_image *texImage,
2324                                GLint i, GLint j, GLint k, const void *texel)
2325 {
2326    /* only store Z, not stencil */
2327    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2328    GLfloat depth = *((GLfloat *) texel);
2329    GLuint zi = (GLuint) (depth * 0xffffff);
2330    *dst = zi | (*dst & 0xff000000);
2331 }
2332 #endif
2333
2334
2335 /* MESA_FORMAT_RGB9_E5 ******************************************************/
2336
2337 static void FETCH(rgb9_e5)( const struct gl_texture_image *texImage,
2338                             GLint i, GLint j, GLint k, GLfloat *texel )
2339 {
2340    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2341    rgb9e5_to_float3(*src, texel);
2342    texel[ACOMP] = 1.0F;
2343 }
2344
2345 #if DIM == 3
2346 static void store_texel_rgb9_e5(struct gl_texture_image *texImage,
2347                                 GLint i, GLint j, GLint k, const void *texel)
2348 {
2349    const GLfloat *src = (const GLfloat *) texel;
2350    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2351    *dst = float3_to_rgb9e5(src);
2352 }
2353 #endif
2354
2355
2356 /* MESA_FORMAT_R11_G11_B10_FLOAT *********************************************/
2357
2358 static void FETCH(r11_g11_b10f)( const struct gl_texture_image *texImage,
2359                                  GLint i, GLint j, GLint k, GLfloat *texel )
2360 {
2361    const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2362    r11g11b10f_to_float3(*src, texel);
2363    texel[ACOMP] = 1.0F;
2364 }
2365
2366 #if DIM == 3
2367 static void store_texel_r11_g11_b10f(struct gl_texture_image *texImage,
2368                                      GLint i, GLint j, GLint k, const void *texel)
2369 {
2370    const GLfloat *src = (const GLfloat *) texel;
2371    GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
2372    *dst = float3_to_r11g11b10f(src);
2373 }
2374 #endif
2375
2376
2377 #undef TEXEL_ADDR
2378 #undef DIM
2379 #undef FETCH