src/mesa/main/pixel.c

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