src/mesa/main/pixel.c

   1 /* $Id: pixel.c,v 1.37 2002/10/24 23:57:21 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 #include "glheader.h"
  28 #include "imports.h"
  29 #include "colormac.h"
  30 #include "context.h"
  31 #include "macros.h"
  32 #include "pixel.h"
  33 #include "mtypes.h"
  34
  35
  36 /**********************************************************************/
  37 /*****                    glPixelZoom                             *****/
  38 /**********************************************************************/
  39
  40
  41
  42 void
  43 _mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
  44 {
  45    GET_CURRENT_CONTEXT(ctx);
  46
  47    if (ctx->Pixel.ZoomX == xfactor &&
  48        ctx->Pixel.ZoomY == yfactor)
  49       return;
  50
  51    FLUSH_VERTICES(ctx, _NEW_PIXEL);
  52    ctx->Pixel.ZoomX = xfactor;
  53    ctx->Pixel.ZoomY = yfactor;
  54 }
  55
  56
  57
  58 /**********************************************************************/
  59 /*****                    glPixelStore                            *****/
  60 /**********************************************************************/
  61
  62
  63 void
  64 _mesa_PixelStorei( GLenum pname, GLint param )
  65 {
  66    /* NOTE: this call can't be compiled into the display list */
  67    GET_CURRENT_CONTEXT(ctx);
  68    ASSERT_OUTSIDE_BEGIN_END(ctx);
  69
  70    switch (pname) {
  71       case GL_PACK_SWAP_BYTES:
  72          if (param == (GLint)ctx->Pack.SwapBytes)
  73             return;
  74          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
  75          ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  76          break;
  77       case GL_PACK_LSB_FIRST:
  78          if (param == (GLint)ctx->Pack.LsbFirst)
  79             return;
  80          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
  81          ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  82          break;
  83       case GL_PACK_ROW_LENGTH:
  84          if (param<0) {
  85             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  86             return;
  87          }
  88          if (ctx->Pack.RowLength == param)
  89             return;
  90          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
  91          ctx->Pack.RowLength = param;
  92          break;
  93       case GL_PACK_IMAGE_HEIGHT:
  94          if (param<0) {
  95             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  96             return;
  97          }
  98          if (ctx->Pack.ImageHeight == param)
  99             return;
 100          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 101          ctx->Pack.ImageHeight = param;
 102          break;
 103       case GL_PACK_SKIP_PIXELS:
 104          if (param<0) {
 105             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 106             return;
 107          }
 108          if (ctx->Pack.SkipPixels == param)
 109             return;
 110          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 111          ctx->Pack.SkipPixels = param;
 112          break;
 113       case GL_PACK_SKIP_ROWS:
 114          if (param<0) {
 115             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 116             return;
 117          }
 118          if (ctx->Pack.SkipRows == param)
 119             return;
 120          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 121          ctx->Pack.SkipRows = param;
 122          break;
 123       case GL_PACK_SKIP_IMAGES:
 124          if (param<0) {
 125             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 126             return;
 127          }
 128          if (ctx->Pack.SkipImages == param)
 129             return;
 130          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 131          ctx->Pack.SkipImages = param;
 132          break;
 133       case GL_PACK_ALIGNMENT:
 134          if (param!=1 && param!=2 && param!=4 && param!=8) {
 135             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 136             return;
 137          }
 138          if (ctx->Pack.Alignment == param)
 139             return;
 140          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 141          ctx->Pack.Alignment = param;
 142          break;
 143       case GL_PACK_INVERT_MESA:
 144          if (!ctx->Extensions.MESA_pack_invert) {
 145             _mesa_error( ctx, GL_INVALID_ENUM, "glPixelstore(pname)" );
 146             return;
 147          }
 148          if (ctx->Pack.Invert == param)
 149             return;
 150          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 151          ctx->Pack.Invert = param;
 152          break;
 153
 154       case GL_UNPACK_SWAP_BYTES:
 155          if (param == (GLint)ctx->Unpack.SwapBytes)
 156             return;
 157          if ((GLint)ctx->Unpack.SwapBytes == param)
 158             return;
 159          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 160          ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
 161          break;
 162       case GL_UNPACK_LSB_FIRST:
 163          if (param == (GLint)ctx->Unpack.LsbFirst)
 164             return;
 165          if ((GLint)ctx->Unpack.LsbFirst == param)
 166             return;
 167          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 168          ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
 169          break;
 170       case GL_UNPACK_ROW_LENGTH:
 171          if (param<0) {
 172             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 173             return;
 174          }
 175          if (ctx->Unpack.RowLength == param)
 176             return;
 177          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 178          ctx->Unpack.RowLength = param;
 179          break;
 180       case GL_UNPACK_IMAGE_HEIGHT:
 181          if (param<0) {
 182             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 183             return;
 184          }
 185          if (ctx->Unpack.ImageHeight == param)
 186             return;
 187
 188          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 189          ctx->Unpack.ImageHeight = param;
 190          break;
 191       case GL_UNPACK_SKIP_PIXELS:
 192          if (param<0) {
 193             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 194             return;
 195          }
 196          if (ctx->Unpack.SkipPixels == param)
 197             return;
 198          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 199          ctx->Unpack.SkipPixels = param;
 200          break;
 201       case GL_UNPACK_SKIP_ROWS:
 202          if (param<0) {
 203             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 204             return;
 205          }
 206          if (ctx->Unpack.SkipRows == param)
 207             return;
 208          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 209          ctx->Unpack.SkipRows = param;
 210          break;
 211       case GL_UNPACK_SKIP_IMAGES:
 212          if (param < 0) {
 213             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 214             return;
 215          }
 216          if (ctx->Unpack.SkipImages == param)
 217             return;
 218          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 219          ctx->Unpack.SkipImages = param;
 220          break;
 221       case GL_UNPACK_ALIGNMENT:
 222          if (param!=1 && param!=2 && param!=4 && param!=8) {
 223             _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
 224             return;
 225          }
 226          if (ctx->Unpack.Alignment == param)
 227             return;
 228          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 229          ctx->Unpack.Alignment = param;
 230          break;
 231       case GL_UNPACK_CLIENT_STORAGE_APPLE:
 232          if (param == (GLint)ctx->Unpack.ClientStorage)
 233             return;
 234          FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 235          ctx->Unpack.ClientStorage = param ? GL_TRUE : GL_FALSE;
 236          break;
 237       default:
 238          _mesa_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
 239          return;
 240    }
 241 }
 242
 243
 244 void
 245 _mesa_PixelStoref( GLenum pname, GLfloat param )
 246 {
 247    _mesa_PixelStorei( pname, (GLint) param );
 248 }
 249
 250
 251
 252 /**********************************************************************/
 253 /*****                         glPixelMap                         *****/
 254 /**********************************************************************/
 255
 256
 257
 258 void
 259 _mesa_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
 260 {
 261    GLint i;
 262    GET_CURRENT_CONTEXT(ctx);
 263    ASSERT_OUTSIDE_BEGIN_END(ctx);
 264
 265    if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
 266       _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 267       return;
 268    }
 269
 270    if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
 271       /* test that mapsize is a power of two */
 272       if (_mesa_bitcount((GLuint) mapsize) != 1) {
 273          _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 274          return;
 275       }
 276    }
 277
 278    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 279
 280    switch (map) {
 281       case GL_PIXEL_MAP_S_TO_S:
 282          ctx->Pixel.MapStoSsize = mapsize;
 283          for (i=0;i<mapsize;i++) {
 284             ctx->Pixel.MapStoS[i] = (GLint) values[i];
 285          }
 286          break;
 287       case GL_PIXEL_MAP_I_TO_I:
 288          ctx->Pixel.MapItoIsize = mapsize;
 289          for (i=0;i<mapsize;i++) {
 290             ctx->Pixel.MapItoI[i] = (GLint) values[i];
 291          }
 292          break;
 293       case GL_PIXEL_MAP_I_TO_R:
 294          ctx->Pixel.MapItoRsize = mapsize;
 295          for (i=0;i<mapsize;i++) {
 296             GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 297             ctx->Pixel.MapItoR[i] = val;
 298             ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
 299          }
 300          break;
 301       case GL_PIXEL_MAP_I_TO_G:
 302          ctx->Pixel.MapItoGsize = mapsize;
 303          for (i=0;i<mapsize;i++) {
 304             GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 305             ctx->Pixel.MapItoG[i] = val;
 306             ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
 307          }
 308          break;
 309       case GL_PIXEL_MAP_I_TO_B:
 310          ctx->Pixel.MapItoBsize = mapsize;
 311          for (i=0;i<mapsize;i++) {
 312             GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 313             ctx->Pixel.MapItoB[i] = val;
 314             ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
 315          }
 316          break;
 317       case GL_PIXEL_MAP_I_TO_A:
 318          ctx->Pixel.MapItoAsize = mapsize;
 319          for (i=0;i<mapsize;i++) {
 320             GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 321             ctx->Pixel.MapItoA[i] = val;
 322             ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
 323          }
 324          break;
 325       case GL_PIXEL_MAP_R_TO_R:
 326          ctx->Pixel.MapRtoRsize = mapsize;
 327          for (i=0;i<mapsize;i++) {
 328             ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0F, 1.0F );
 329          }
 330          break;
 331       case GL_PIXEL_MAP_G_TO_G:
 332          ctx->Pixel.MapGtoGsize = mapsize;
 333          for (i=0;i<mapsize;i++) {
 334             ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0F, 1.0F );
 335          }
 336          break;
 337       case GL_PIXEL_MAP_B_TO_B:
 338          ctx->Pixel.MapBtoBsize = mapsize;
 339          for (i=0;i<mapsize;i++) {
 340             ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0F, 1.0F );
 341          }
 342          break;
 343       case GL_PIXEL_MAP_A_TO_A:
 344          ctx->Pixel.MapAtoAsize = mapsize;
 345          for (i=0;i<mapsize;i++) {
 346             ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0F, 1.0F );
 347          }
 348          break;
 349       default:
 350          _mesa_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
 351    }
 352 }
 353
 354
 355
 356 void
 357 _mesa_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
 358 {
 359    const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
 360    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
 361    GLint i;
 362    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
 363       for (i=0;i<n;i++) {
 364          fvalues[i] = (GLfloat) values[i];
 365       }
 366    }
 367    else {
 368       for (i=0;i<n;i++) {
 369          fvalues[i] = UINT_TO_FLOAT( values[i] );
 370       }
 371    }
 372    _mesa_PixelMapfv(map, mapsize, fvalues);
 373 }
 374
 375
 376
 377 void
 378 _mesa_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values )
 379 {
 380    const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
 381    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
 382    GLint i;
 383    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
 384       for (i=0;i<n;i++) {
 385          fvalues[i] = (GLfloat) values[i];
 386       }
 387    }
 388    else {
 389       for (i=0;i<n;i++) {
 390          fvalues[i] = USHORT_TO_FLOAT( values[i] );
 391       }
 392    }
 393    _mesa_PixelMapfv(map, mapsize, fvalues);
 394 }
 395
 396
 397
 398 void
 399 _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
 400 {
 401    GET_CURRENT_CONTEXT(ctx);
 402    GLint i;
 403    ASSERT_OUTSIDE_BEGIN_END(ctx);
 404
 405    switch (map) {
 406       case GL_PIXEL_MAP_I_TO_I:
 407          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
 408             values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
 409          }
 410          break;
 411       case GL_PIXEL_MAP_S_TO_S:
 412          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
 413             values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
 414          }
 415          break;
 416       case GL_PIXEL_MAP_I_TO_R:
 417          MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
 418          break;
 419       case GL_PIXEL_MAP_I_TO_G:
 420          MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
 421          break;
 422       case GL_PIXEL_MAP_I_TO_B:
 423          MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
 424          break;
 425       case GL_PIXEL_MAP_I_TO_A:
 426          MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
 427          break;
 428       case GL_PIXEL_MAP_R_TO_R:
 429          MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
 430          break;
 431       case GL_PIXEL_MAP_G_TO_G:
 432          MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
 433          break;
 434       case GL_PIXEL_MAP_B_TO_B:
 435          MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
 436          break;
 437       case GL_PIXEL_MAP_A_TO_A:
 438          MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
 439          break;
 440       default:
 441          _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 442    }
 443 }
 444
 445
 446 void
 447 _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
 448 {
 449    GET_CURRENT_CONTEXT(ctx);
 450    GLint i;
 451    ASSERT_OUTSIDE_BEGIN_END(ctx);
 452
 453    switch (map) {
 454       case GL_PIXEL_MAP_I_TO_I:
 455          MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
 456          break;
 457       case GL_PIXEL_MAP_S_TO_S:
 458          MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
 459          break;
 460       case GL_PIXEL_MAP_I_TO_R:
 461          for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
 462             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
 463          }
 464          break;
 465       case GL_PIXEL_MAP_I_TO_G:
 466          for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
 467             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
 468          }
 469          break;
 470       case GL_PIXEL_MAP_I_TO_B:
 471          for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
 472             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
 473          }
 474          break;
 475       case GL_PIXEL_MAP_I_TO_A:
 476          for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
 477             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
 478          }
 479          break;
 480       case GL_PIXEL_MAP_R_TO_R:
 481          for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
 482             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
 483          }
 484          break;
 485       case GL_PIXEL_MAP_G_TO_G:
 486          for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
 487             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
 488          }
 489          break;
 490       case GL_PIXEL_MAP_B_TO_B:
 491          for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
 492             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
 493          }
 494          break;
 495       case GL_PIXEL_MAP_A_TO_A:
 496          for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
 497             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
 498          }
 499          break;
 500       default:
 501          _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 502    }
 503 }
 504
 505
 506 void
 507 _mesa_GetPixelMapusv( GLenum map, GLushort *values )
 508 {
 509    GET_CURRENT_CONTEXT(ctx);
 510    GLint i;
 511    ASSERT_OUTSIDE_BEGIN_END(ctx);
 512
 513    switch (map) {
 514       case GL_PIXEL_MAP_I_TO_I:
 515          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
 516             values[i] = (GLushort) ctx->Pixel.MapItoI[i];
 517          }
 518          break;
 519       case GL_PIXEL_MAP_S_TO_S:
 520          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
 521             values[i] = (GLushort) ctx->Pixel.MapStoS[i];
 522          }
 523          break;
 524       case GL_PIXEL_MAP_I_TO_R:
 525          for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
 526             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
 527          }
 528          break;
 529       case GL_PIXEL_MAP_I_TO_G:
 530          for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
 531             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
 532          }
 533          break;
 534       case GL_PIXEL_MAP_I_TO_B:
 535          for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
 536             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
 537          }
 538          break;
 539       case GL_PIXEL_MAP_I_TO_A:
 540          for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
 541             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
 542          }
 543          break;
 544       case GL_PIXEL_MAP_R_TO_R:
 545          for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
 546             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
 547          }
 548          break;
 549       case GL_PIXEL_MAP_G_TO_G:
 550          for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
 551             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
 552          }
 553          break;
 554       case GL_PIXEL_MAP_B_TO_B:
 555          for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
 556             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
 557          }
 558          break;
 559       case GL_PIXEL_MAP_A_TO_A:
 560          for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
 561             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
 562          }
 563          break;
 564       default:
 565          _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 566    }
 567 }
 568
 569
 570
 571 /**********************************************************************/
 572 /*****                       glPixelTransfer                      *****/
 573 /**********************************************************************/
 574
 575
 576 /*
 577  * Implements glPixelTransfer[fi] whether called immediately or from a
 578  * display list.
 579  */
 580 void
 581 _mesa_PixelTransferf( GLenum pname, GLfloat param )
 582 {
 583    GET_CURRENT_CONTEXT(ctx);
 584    ASSERT_OUTSIDE_BEGIN_END(ctx);
 585
 586    switch (pname) {
 587       case GL_MAP_COLOR:
 588          if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
 589             return;
 590          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 591          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
 592          break;
 593       case GL_MAP_STENCIL:
 594          if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
 595             return;
 596          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 597          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
 598          break;
 599       case GL_INDEX_SHIFT:
 600          if (ctx->Pixel.IndexShift == (GLint) param)
 601             return;
 602          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 603          ctx->Pixel.IndexShift = (GLint) param;
 604          break;
 605       case GL_INDEX_OFFSET:
 606          if (ctx->Pixel.IndexOffset == (GLint) param)
 607             return;
 608          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 609          ctx->Pixel.IndexOffset = (GLint) param;
 610          break;
 611       case GL_RED_SCALE:
 612          if (ctx->Pixel.RedScale == param)
 613             return;
 614          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 615          ctx->Pixel.RedScale = param;
 616          break;
 617       case GL_RED_BIAS:
 618          if (ctx->Pixel.RedBias == param)
 619             return;
 620          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 621          ctx->Pixel.RedBias = param;
 622          break;
 623       case GL_GREEN_SCALE:
 624          if (ctx->Pixel.GreenScale == param)
 625             return;
 626          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 627          ctx->Pixel.GreenScale = param;
 628          break;
 629       case GL_GREEN_BIAS:
 630          if (ctx->Pixel.GreenBias == param)
 631             return;
 632          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 633          ctx->Pixel.GreenBias = param;
 634          break;
 635       case GL_BLUE_SCALE:
 636          if (ctx->Pixel.BlueScale == param)
 637             return;
 638          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 639          ctx->Pixel.BlueScale = param;
 640          break;
 641       case GL_BLUE_BIAS:
 642          if (ctx->Pixel.BlueBias == param)
 643             return;
 644          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 645          ctx->Pixel.BlueBias = param;
 646          break;
 647       case GL_ALPHA_SCALE:
 648          if (ctx->Pixel.AlphaScale == param)
 649             return;
 650          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 651          ctx->Pixel.AlphaScale = param;
 652          break;
 653       case GL_ALPHA_BIAS:
 654          if (ctx->Pixel.AlphaBias == param)
 655             return;
 656          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 657          ctx->Pixel.AlphaBias = param;
 658          break;
 659       case GL_DEPTH_SCALE:
 660          if (ctx->Pixel.DepthScale == param)
 661             return;
 662          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 663          ctx->Pixel.DepthScale = param;
 664          break;
 665       case GL_DEPTH_BIAS:
 666          if (ctx->Pixel.DepthBias == param)
 667             return;
 668          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 669          ctx->Pixel.DepthBias = param;
 670          break;
 671       case GL_POST_COLOR_MATRIX_RED_SCALE:
 672          if (ctx->Pixel.PostColorMatrixScale[0] == param)
 673             return;
 674          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 675          ctx->Pixel.PostColorMatrixScale[0] = param;
 676          break;
 677       case GL_POST_COLOR_MATRIX_RED_BIAS:
 678          if (ctx->Pixel.PostColorMatrixBias[0] == param)
 679             return;
 680          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 681          ctx->Pixel.PostColorMatrixBias[0] = param;
 682          break;
 683       case GL_POST_COLOR_MATRIX_GREEN_SCALE:
 684          if (ctx->Pixel.PostColorMatrixScale[1] == param)
 685             return;
 686          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 687          ctx->Pixel.PostColorMatrixScale[1] = param;
 688          break;
 689       case GL_POST_COLOR_MATRIX_GREEN_BIAS:
 690          if (ctx->Pixel.PostColorMatrixBias[1] == param)
 691             return;
 692          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 693          ctx->Pixel.PostColorMatrixBias[1] = param;
 694          break;
 695       case GL_POST_COLOR_MATRIX_BLUE_SCALE:
 696          if (ctx->Pixel.PostColorMatrixScale[2] == param)
 697             return;
 698          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 699          ctx->Pixel.PostColorMatrixScale[2] = param;
 700          break;
 701       case GL_POST_COLOR_MATRIX_BLUE_BIAS:
 702          if (ctx->Pixel.PostColorMatrixBias[2] == param)
 703             return;
 704          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 705          ctx->Pixel.PostColorMatrixBias[2] = param;
 706          break;
 707       case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
 708          if (ctx->Pixel.PostColorMatrixScale[3] == param)
 709             return;
 710          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 711          ctx->Pixel.PostColorMatrixScale[3] = param;
 712          break;
 713       case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
 714          if (ctx->Pixel.PostColorMatrixBias[3] == param)
 715             return;
 716          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 717          ctx->Pixel.PostColorMatrixBias[3] = param;
 718          break;
 719       case GL_POST_CONVOLUTION_RED_SCALE:
 720          if (ctx->Pixel.PostConvolutionScale[0] == param)
 721             return;
 722          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 723          ctx->Pixel.PostConvolutionScale[0] = param;
 724          break;
 725       case GL_POST_CONVOLUTION_RED_BIAS:
 726          if (ctx->Pixel.PostConvolutionBias[0] == param)
 727             return;
 728          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 729          ctx->Pixel.PostConvolutionBias[0] = param;
 730          break;
 731       case GL_POST_CONVOLUTION_GREEN_SCALE:
 732          if (ctx->Pixel.PostConvolutionScale[1] == param)
 733             return;
 734          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 735          ctx->Pixel.PostConvolutionScale[1] = param;
 736          break;
 737       case GL_POST_CONVOLUTION_GREEN_BIAS:
 738          if (ctx->Pixel.PostConvolutionBias[1] == param)
 739             return;
 740          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 741          ctx->Pixel.PostConvolutionBias[1] = param;
 742          break;
 743       case GL_POST_CONVOLUTION_BLUE_SCALE:
 744          if (ctx->Pixel.PostConvolutionScale[2] == param)
 745             return;
 746          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 747          ctx->Pixel.PostConvolutionScale[2] = param;
 748          break;
 749       case GL_POST_CONVOLUTION_BLUE_BIAS:
 750          if (ctx->Pixel.PostConvolutionBias[2] == param)
 751             return;
 752          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 753          ctx->Pixel.PostConvolutionBias[2] = param;
 754          break;
 755       case GL_POST_CONVOLUTION_ALPHA_SCALE:
 756          if (ctx->Pixel.PostConvolutionScale[2] == param)
 757             return;
 758          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 759          ctx->Pixel.PostConvolutionScale[2] = param;
 760          break;
 761       case GL_POST_CONVOLUTION_ALPHA_BIAS:
 762          if (ctx->Pixel.PostConvolutionBias[2] == param)
 763             return;
 764          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 765          ctx->Pixel.PostConvolutionBias[2] = param;
 766          break;
 767       default:
 768          _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
 769          return;
 770    }
 771 }
 772
 773
 774 void
 775 _mesa_PixelTransferi( GLenum pname, GLint param )
 776 {
 777    _mesa_PixelTransferf( pname, (GLfloat) param );
 778 }
 779
 780
 781
 782 /**********************************************************************/
 783 /*****                  Pixel processing functions               ******/
 784 /**********************************************************************/
 785
 786
 787 /*
 788  * Apply scale and bias factors to an array of RGBA pixels.
 789  */
 790 void
 791 _mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4],
 792                           GLfloat rScale, GLfloat gScale,
 793                           GLfloat bScale, GLfloat aScale,
 794                           GLfloat rBias, GLfloat gBias,
 795                           GLfloat bBias, GLfloat aBias)
 796 {
 797    if (rScale != 1.0 || rBias != 0.0) {
 798       GLuint i;
 799       for (i = 0; i < n; i++) {
 800          rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
 801       }
 802    }
 803    if (gScale != 1.0 || gBias != 0.0) {
 804       GLuint i;
 805       for (i = 0; i < n; i++) {
 806          rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
 807       }
 808    }
 809    if (bScale != 1.0 || bBias != 0.0) {
 810       GLuint i;
 811       for (i = 0; i < n; i++) {
 812          rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
 813       }
 814    }
 815    if (aScale != 1.0 || aBias != 0.0) {
 816       GLuint i;
 817       for (i = 0; i < n; i++) {
 818          rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
 819       }
 820    }
 821 }
 822
 823
 824 /*
 825  * Apply pixel mapping to an array of floating point RGBA pixels.
 826  */
 827 void
 828 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
 829 {
 830    const GLfloat rscale = (GLfloat) (ctx->Pixel.MapRtoRsize - 1);
 831    const GLfloat gscale = (GLfloat) (ctx->Pixel.MapGtoGsize - 1);
 832    const GLfloat bscale = (GLfloat) (ctx->Pixel.MapBtoBsize - 1);
 833    const GLfloat ascale = (GLfloat) (ctx->Pixel.MapAtoAsize - 1);
 834    const GLfloat *rMap = ctx->Pixel.MapRtoR;
 835    const GLfloat *gMap = ctx->Pixel.MapGtoG;
 836    const GLfloat *bMap = ctx->Pixel.MapBtoB;
 837    const GLfloat *aMap = ctx->Pixel.MapAtoA;
 838    GLuint i;
 839    for (i=0;i<n;i++) {
 840       GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
 841       GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
 842       GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
 843       GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
 844       rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
 845       rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
 846       rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
 847       rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
 848    }
 849 }
 850
 851
 852 /*
 853  * Apply the color matrix and post color matrix scaling and biasing.
 854  */
 855 void
 856 _mesa_transform_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
 857 {
 858    const GLfloat rs = ctx->Pixel.PostColorMatrixScale[0];
 859    const GLfloat rb = ctx->Pixel.PostColorMatrixBias[0];
 860    const GLfloat gs = ctx->Pixel.PostColorMatrixScale[1];
 861    const GLfloat gb = ctx->Pixel.PostColorMatrixBias[1];
 862    const GLfloat bs = ctx->Pixel.PostColorMatrixScale[2];
 863    const GLfloat bb = ctx->Pixel.PostColorMatrixBias[2];
 864    const GLfloat as = ctx->Pixel.PostColorMatrixScale[3];
 865    const GLfloat ab = ctx->Pixel.PostColorMatrixBias[3];
 866    const GLfloat *m = ctx->ColorMatrixStack.Top->m;
 867    GLuint i;
 868    for (i = 0; i < n; i++) {
 869       const GLfloat r = rgba[i][RCOMP];
 870       const GLfloat g = rgba[i][GCOMP];
 871       const GLfloat b = rgba[i][BCOMP];
 872       const GLfloat a = rgba[i][ACOMP];
 873       rgba[i][RCOMP] = (m[0] * r + m[4] * g + m[ 8] * b + m[12] * a) * rs + rb;
 874       rgba[i][GCOMP] = (m[1] * r + m[5] * g + m[ 9] * b + m[13] * a) * gs + gb;
 875       rgba[i][BCOMP] = (m[2] * r + m[6] * g + m[10] * b + m[14] * a) * bs + bb;
 876       rgba[i][ACOMP] = (m[3] * r + m[7] * g + m[11] * b + m[15] * a) * as + ab;
 877    }
 878 }
 879
 880
 881 /*
 882  * Apply a color table lookup to an array of colors.
 883  */
 884 void
 885 _mesa_lookup_rgba(const struct gl_color_table *table,
 886                   GLuint n, GLfloat rgba[][4])
 887 {
 888    ASSERT(table->FloatTable);
 889    if (!table->Table || table->Size == 0)
 890       return;
 891
 892    switch (table->Format) {
 893       case GL_INTENSITY:
 894          /* replace RGBA with I */
 895          if (!table->FloatTable) {
 896             const GLint max = table->Size - 1;
 897             const GLfloat scale = (GLfloat) max;
 898             const GLchan *lut = (const GLchan *) table->Table;
 899             GLuint i;
 900             for (i = 0; i < n; i++) {
 901                GLint j = IROUND(rgba[i][RCOMP] * scale);
 902                GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, 1)]);
 903                rgba[i][RCOMP] = rgba[i][GCOMP] =
 904                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
 905             }
 906
 907          }
 908          else {
 909             const GLint max = table->Size - 1;
 910             const GLfloat scale = (GLfloat) max;
 911             const GLfloat *lut = (const GLfloat *) table->Table;
 912             GLuint i;
 913             for (i = 0; i < n; i++) {
 914                GLint j = IROUND(rgba[i][RCOMP] * scale);
 915                GLfloat c = lut[CLAMP(j, 0, max)];
 916                rgba[i][RCOMP] = rgba[i][GCOMP] =
 917                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
 918             }
 919          }
 920          break;
 921       case GL_LUMINANCE:
 922          /* replace RGB with L */
 923          if (!table->FloatTable) {
 924             const GLint max = table->Size - 1;
 925             const GLfloat scale = (GLfloat) max;
 926             const GLchan *lut = (const GLchan *) table->Table;
 927             GLuint i;
 928             for (i = 0; i < n; i++) {
 929                GLint j = IROUND(rgba[i][RCOMP] * scale);
 930                GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
 931                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
 932             }
 933          }
 934          else {
 935             const GLint max = table->Size - 1;
 936             const GLfloat scale = (GLfloat) max;
 937             const GLfloat *lut = (const GLfloat *) table->Table;
 938             GLuint i;
 939             for (i = 0; i < n; i++) {
 940                GLint j = IROUND(rgba[i][RCOMP] * scale);
 941                GLfloat c = lut[CLAMP(j, 0, max)];
 942                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
 943             }
 944          }
 945          break;
 946       case GL_ALPHA:
 947          /* replace A with A */
 948          if (!table->FloatTable) {
 949             const GLint max = table->Size - 1;
 950             const GLfloat scale = (GLfloat) max;
 951             const GLchan *lut = (const GLchan *) table->Table;
 952             GLuint i;
 953             for (i = 0; i < n; i++) {
 954                GLint j = IROUND(rgba[i][ACOMP] * scale);
 955                rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
 956             }
 957          }
 958          else  {
 959             const GLint max = table->Size - 1;
 960             const GLfloat scale = (GLfloat) max;
 961             const GLfloat *lut = (const GLfloat *) table->Table;
 962             GLuint i;
 963             for (i = 0; i < n; i++) {
 964                GLint j = IROUND(rgba[i][ACOMP] * scale);
 965                rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
 966             }
 967          }
 968          break;
 969       case GL_LUMINANCE_ALPHA:
 970          /* replace RGBA with LLLA */
 971          if (!table->FloatTable) {
 972             const GLint max = table->Size - 1;
 973             const GLfloat scale = (GLfloat) max;
 974             const GLchan *lut = (const GLchan *) table->Table;
 975             GLuint i;
 976             for (i = 0; i < n; i++) {
 977                GLint jL = IROUND(rgba[i][RCOMP] * scale);
 978                GLint jA = IROUND(rgba[i][ACOMP] * scale);
 979                GLfloat luminance, alpha;
 980                jL = CLAMP(jL, 0, max);
 981                jA = CLAMP(jA, 0, max);
 982                luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
 983                alpha     = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
 984                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
 985                rgba[i][ACOMP] = alpha;;
 986             }
 987          }
 988          else {
 989             const GLint max = table->Size - 1;
 990             const GLfloat scale = (GLfloat) max;
 991             const GLfloat *lut = (const GLfloat *) table->Table;
 992             GLuint i;
 993             for (i = 0; i < n; i++) {
 994                GLint jL = IROUND(rgba[i][RCOMP] * scale);
 995                GLint jA = IROUND(rgba[i][ACOMP] * scale);
 996                GLfloat luminance, alpha;
 997                jL = CLAMP(jL, 0, max);
 998                jA = CLAMP(jA, 0, max);
 999                luminance = lut[jL * 2 + 0];
1000                alpha     = lut[jA * 2 + 1];
1001                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
1002                rgba[i][ACOMP] = alpha;;
1003             }
1004          }
1005          break;
1006       case GL_RGB:
1007          /* replace RGB with RGB */
1008          if (!table->FloatTable) {
1009             const GLint max = table->Size - 1;
1010             const GLfloat scale = (GLfloat) max;
1011             const GLchan *lut = (const GLchan *) table->Table;
1012             GLuint i;
1013             for (i = 0; i < n; i++) {
1014                GLint jR = IROUND(rgba[i][RCOMP] * scale);
1015                GLint jG = IROUND(rgba[i][GCOMP] * scale);
1016                GLint jB = IROUND(rgba[i][BCOMP] * scale);
1017                jR = CLAMP(jR, 0, max);
1018                jG = CLAMP(jG, 0, max);
1019                jB = CLAMP(jB, 0, max);
1020                rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
1021                rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
1022                rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
1023             }
1024          }
1025          else {
1026             const GLint max = table->Size - 1;
1027             const GLfloat scale = (GLfloat) max;
1028             const GLfloat *lut = (const GLfloat *) table->Table;
1029             GLuint i;
1030             for (i = 0; i < n; i++) {
1031                GLint jR = IROUND(rgba[i][RCOMP] * scale);
1032                GLint jG = IROUND(rgba[i][GCOMP] * scale);
1033                GLint jB = IROUND(rgba[i][BCOMP] * scale);
1034                jR = CLAMP(jR, 0, max);
1035                jG = CLAMP(jG, 0, max);
1036                jB = CLAMP(jB, 0, max);
1037                rgba[i][RCOMP] = lut[jR * 3 + 0];
1038                rgba[i][GCOMP] = lut[jG * 3 + 1];
1039                rgba[i][BCOMP] = lut[jB * 3 + 2];
1040             }
1041          }
1042          break;
1043       case GL_RGBA:
1044          /* replace RGBA with RGBA */
1045          if (!table->FloatTable) {
1046             const GLint max = table->Size - 1;
1047             const GLfloat scale = (GLfloat) max;
1048             const GLchan *lut = (const GLchan *) table->Table;
1049             GLuint i;
1050             for (i = 0; i < n; i++) {
1051                GLint jR = IROUND(rgba[i][RCOMP] * scale);
1052                GLint jG = IROUND(rgba[i][GCOMP] * scale);
1053                GLint jB = IROUND(rgba[i][BCOMP] * scale);
1054                GLint jA = IROUND(rgba[i][ACOMP] * scale);
1055                jR = CLAMP(jR, 0, max);
1056                jG = CLAMP(jG, 0, max);
1057                jB = CLAMP(jB, 0, max);
1058                jA = CLAMP(jA, 0, max);
1059                rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
1060                rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
1061                rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
1062                rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
1063             }
1064          }
1065          else {
1066             const GLint max = table->Size - 1;
1067             const GLfloat scale = (GLfloat) max;
1068             const GLfloat *lut = (const GLfloat *) table->Table;
1069             GLuint i;
1070             for (i = 0; i < n; i++) {
1071                GLint jR = IROUND(rgba[i][RCOMP] * scale);
1072                GLint jG = IROUND(rgba[i][GCOMP] * scale);
1073                GLint jB = IROUND(rgba[i][BCOMP] * scale);
1074                GLint jA = IROUND(rgba[i][ACOMP] * scale);
1075                jR = CLAMP(jR, 0, max);
1076                jG = CLAMP(jG, 0, max);
1077                jB = CLAMP(jB, 0, max);
1078                jA = CLAMP(jA, 0, max);
1079                rgba[i][RCOMP] = lut[jR * 4 + 0];
1080                rgba[i][GCOMP] = lut[jG * 4 + 1];
1081                rgba[i][BCOMP] = lut[jB * 4 + 2];
1082                rgba[i][ACOMP] = lut[jA * 4 + 3];
1083             }
1084          }
1085          break;
1086       default:
1087          _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba");
1088          return;
1089    }
1090 }
1091
1092
1093
1094 /*
1095  * Apply color index shift and offset to an array of pixels.
1096  */
1097 void
1098 _mesa_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
1099 {
1100    GLint shift = ctx->Pixel.IndexShift;
1101    GLint offset = ctx->Pixel.IndexOffset;
1102    GLuint i;
1103    if (shift > 0) {
1104       for (i=0;i<n;i++) {
1105          indexes[i] = (indexes[i] << shift) + offset;
1106       }
1107    }
1108    else if (shift < 0) {
1109       shift = -shift;
1110       for (i=0;i<n;i++) {
1111          indexes[i] = (indexes[i] >> shift) + offset;
1112       }
1113    }
1114    else {
1115       for (i=0;i<n;i++) {
1116          indexes[i] = indexes[i] + offset;
1117       }
1118    }
1119 }
1120
1121
1122 /*
1123  * Apply color index mapping to color indexes.
1124  */
1125 void
1126 _mesa_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
1127 {
1128    GLuint mask = ctx->Pixel.MapItoIsize - 1;
1129    GLuint i;
1130    for (i=0;i<n;i++) {
1131       index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
1132    }
1133 }
1134
1135
1136 /*
1137  * Map color indexes to rgba values.
1138  */
1139 void
1140 _mesa_map_ci_to_rgba_chan( const GLcontext *ctx, GLuint n,
1141                            const GLuint index[], GLchan rgba[][4] )
1142 {
1143 #if CHAN_BITS == 8
1144    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1145    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1146    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1147    GLuint amask = ctx->Pixel.MapItoAsize - 1;
1148    const GLubyte *rMap = ctx->Pixel.MapItoR8;
1149    const GLubyte *gMap = ctx->Pixel.MapItoG8;
1150    const GLubyte *bMap = ctx->Pixel.MapItoB8;
1151    const GLubyte *aMap = ctx->Pixel.MapItoA8;
1152    GLuint i;
1153    for (i=0;i<n;i++) {
1154       rgba[i][RCOMP] = rMap[index[i] & rmask];
1155       rgba[i][GCOMP] = gMap[index[i] & gmask];
1156       rgba[i][BCOMP] = bMap[index[i] & bmask];
1157       rgba[i][ACOMP] = aMap[index[i] & amask];
1158    }
1159 #else
1160    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1161    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1162    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1163    GLuint amask = ctx->Pixel.MapItoAsize - 1;
1164    const GLfloat *rMap = ctx->Pixel.MapItoR;
1165    const GLfloat *gMap = ctx->Pixel.MapItoG;
1166    const GLfloat *bMap = ctx->Pixel.MapItoB;
1167    const GLfloat *aMap = ctx->Pixel.MapItoA;
1168    GLuint i;
1169    for (i=0;i<n;i++) {
1170       CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1171       CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1172       CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1173       CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1174    }
1175 #endif
1176 }
1177
1178
1179 /*
1180  * Map color indexes to float rgba values.
1181  */
1182 void
1183 _mesa_map_ci_to_rgba( const GLcontext *ctx, GLuint n,
1184                       const GLuint index[], GLfloat rgba[][4] )
1185 {
1186    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1187    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1188    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1189    GLuint amask = ctx->Pixel.MapItoAsize - 1;
1190    const GLfloat *rMap = ctx->Pixel.MapItoR;
1191    const GLfloat *gMap = ctx->Pixel.MapItoG;
1192    const GLfloat *bMap = ctx->Pixel.MapItoB;
1193    const GLfloat *aMap = ctx->Pixel.MapItoA;
1194    GLuint i;
1195    for (i=0;i<n;i++) {
1196       rgba[i][RCOMP] = rMap[index[i] & rmask];
1197       rgba[i][GCOMP] = gMap[index[i] & gmask];
1198       rgba[i][BCOMP] = bMap[index[i] & bmask];
1199       rgba[i][ACOMP] = aMap[index[i] & amask];
1200    }
1201 }
1202
1203
1204 /*
1205  * Map 8-bit color indexes to rgb values.
1206  */
1207 void
1208 _mesa_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
1209                        GLchan rgba[][4] )
1210 {
1211 #if CHAN_BITS == 8
1212    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1213    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1214    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1215    GLuint amask = ctx->Pixel.MapItoAsize - 1;
1216    const GLubyte *rMap = ctx->Pixel.MapItoR8;
1217    const GLubyte *gMap = ctx->Pixel.MapItoG8;
1218    const GLubyte *bMap = ctx->Pixel.MapItoB8;
1219    const GLubyte *aMap = ctx->Pixel.MapItoA8;
1220    GLuint i;
1221    for (i=0;i<n;i++) {
1222       rgba[i][RCOMP] = rMap[index[i] & rmask];
1223       rgba[i][GCOMP] = gMap[index[i] & gmask];
1224       rgba[i][BCOMP] = bMap[index[i] & bmask];
1225       rgba[i][ACOMP] = aMap[index[i] & amask];
1226    }
1227 #else
1228    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
1229    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
1230    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
1231    GLuint amask = ctx->Pixel.MapItoAsize - 1;
1232    const GLfloat *rMap = ctx->Pixel.MapItoR;
1233    const GLfloat *gMap = ctx->Pixel.MapItoG;
1234    const GLfloat *bMap = ctx->Pixel.MapItoB;
1235    const GLfloat *aMap = ctx->Pixel.MapItoA;
1236    GLuint i;
1237    for (i=0;i<n;i++) {
1238       CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
1239       CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
1240       CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
1241       CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
1242    }
1243 #endif
1244 }
1245
1246
1247 void
1248 _mesa_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
1249                                 GLstencil stencil[] )
1250 {
1251    GLuint i;
1252    GLint shift = ctx->Pixel.IndexShift;
1253    GLint offset = ctx->Pixel.IndexOffset;
1254    if (shift > 0) {
1255       for (i=0;i<n;i++) {
1256          stencil[i] = (stencil[i] << shift) + offset;
1257       }
1258    }
1259    else if (shift < 0) {
1260       shift = -shift;
1261       for (i=0;i<n;i++) {
1262          stencil[i] = (stencil[i] >> shift) + offset;
1263       }
1264    }
1265    else {
1266       for (i=0;i<n;i++) {
1267          stencil[i] = stencil[i] + offset;
1268       }
1269    }
1270
1271 }
1272
1273
1274 void
1275 _mesa_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
1276 {
1277    GLuint mask = ctx->Pixel.MapStoSsize - 1;
1278    GLuint i;
1279    for (i=0;i<n;i++) {
1280       stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
1281    }
1282 }
1283
1284
1285
1286 /*
1287  * This function converts an array of GLchan colors to GLfloat colors.
1288  * Most importantly, it undoes the non-uniform quantization of pixel
1289  * values introduced when we convert shallow (< 8 bit) pixel values
1290  * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
1291  * This fixes a number of OpenGL conformance failures when running on
1292  * 16bpp displays, for example.
1293  */
1294 void
1295 _mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
1296                          CONST GLchan rgba[][4], GLfloat rgbaf[][4])
1297 {
1298 #if CHAN_TYPE == GL_FLOAT
1299    MEMCPY(rgbaf, rgba, n * 4 * sizeof(GLfloat));
1300 #else
1301    const GLuint rShift = CHAN_BITS - ctx->Visual.redBits;
1302    const GLuint gShift = CHAN_BITS - ctx->Visual.greenBits;
1303    const GLuint bShift = CHAN_BITS - ctx->Visual.blueBits;
1304    GLuint aShift;
1305    const GLfloat rScale = 1.0F / (GLfloat) ((1 << ctx->Visual.redBits  ) - 1);
1306    const GLfloat gScale = 1.0F / (GLfloat) ((1 << ctx->Visual.greenBits) - 1);
1307    const GLfloat bScale = 1.0F / (GLfloat) ((1 << ctx->Visual.blueBits ) - 1);
1308    GLfloat aScale;
1309    GLuint i;
1310
1311    if (ctx->Visual.alphaBits > 0) {
1312       aShift = CHAN_BITS - ctx->Visual.alphaBits;
1313       aScale = 1.0F / (GLfloat) ((1 << ctx->Visual.alphaBits) - 1);
1314    }
1315    else {
1316       aShift = 0;
1317       aScale = 1.0F / CHAN_MAXF;
1318    }
1319
1320    for (i = 0; i < n; i++) {
1321       const GLint r = rgba[i][RCOMP] >> rShift;
1322       const GLint g = rgba[i][GCOMP] >> gShift;
1323       const GLint b = rgba[i][BCOMP] >> bShift;
1324       const GLint a = rgba[i][ACOMP] >> aShift;
1325       rgbaf[i][RCOMP] = (GLfloat) r * rScale;
1326       rgbaf[i][GCOMP] = (GLfloat) g * gScale;
1327       rgbaf[i][BCOMP] = (GLfloat) b * bScale;
1328       rgbaf[i][ACOMP] = (GLfloat) a * aScale;
1329    }
1330 #endif
1331 }