src/mesa/main/pixel.c

   1 /* $Id: pixel.c,v 1.2 1999/10/08 09:27:11 keithw Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.1
   6  *
   7  * Copyright (C) 1999  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
  29
  30
  31 /*
  32  * glPixelStore, glPixelTransfer, glPixelMap, glPixelZoom, etc.
  33  */
  34
  35
  36 #ifdef PC_HEADER
  37 #include "all.h"
  38 #else
  39 #ifndef XFree86Server
  40 #include <assert.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #else
  44 #include "GL/xf86glx.h"
  45 #endif
  46 #include "context.h"
  47 #include "macros.h"
  48 #include "pixel.h"
  49 #include "types.h"
  50 #ifdef XFree86Server
  51 #include "GL/xf86glx.h"
  52 #endif
  53 #endif
  54
  55
  56
  57 /**********************************************************************/
  58 /*****                    glPixelZoom                             *****/
  59 /**********************************************************************/
  60
  61
  62
  63 void gl_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
  64 {
  65    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelZoom");
  66
  67    ctx->Pixel.ZoomX = xfactor;
  68    ctx->Pixel.ZoomY = yfactor;
  69 }
  70
  71
  72
  73 /**********************************************************************/
  74 /*****                    glPixelStore                            *****/
  75 /**********************************************************************/
  76
  77
  78 void gl_PixelStorei( GLcontext *ctx, GLenum pname, GLint param )
  79 {
  80    /* NOTE: this call can't be compiled into the display list */
  81
  82    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelStore");
  83
  84
  85    switch (pname) {
  86       case GL_PACK_SWAP_BYTES:
  87          ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  88          break;
  89       case GL_PACK_LSB_FIRST:
  90          ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  91          break;
  92       case GL_PACK_ROW_LENGTH:
  93          if (param<0) {
  94             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  95          }
  96          else {
  97             ctx->Pack.RowLength = param;
  98          }
  99          break;
 100       case GL_PACK_IMAGE_HEIGHT:
 101          if (param<0)
 102             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 103          else
 104             ctx->Pack.ImageHeight = param;
 105          break;
 106       case GL_PACK_SKIP_PIXELS:
 107          if (param<0) {
 108             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 109          }
 110          else {
 111             ctx->Pack.SkipPixels = param;
 112          }
 113          break;
 114       case GL_PACK_SKIP_ROWS:
 115          if (param<0) {
 116             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 117          }
 118          else {
 119             ctx->Pack.SkipRows = param;
 120          }
 121          break;
 122       case GL_PACK_ALIGNMENT:
 123          if (param==1 || param==2 || param==4 || param==8) {
 124             ctx->Pack.Alignment = param;
 125          }
 126          else {
 127             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 128          }
 129          break;
 130       case GL_UNPACK_SWAP_BYTES:
 131          ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
 132          break;
 133       case GL_UNPACK_LSB_FIRST:
 134          ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
 135          break;
 136       case GL_UNPACK_ROW_LENGTH:
 137          if (param<0) {
 138             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 139          }
 140          else {
 141             ctx->Unpack.RowLength = param;
 142          }
 143          break;
 144       case GL_UNPACK_IMAGE_HEIGHT:
 145          if (param<0)
 146             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 147          else
 148             ctx->Unpack.ImageHeight = param;
 149          break;
 150       case GL_UNPACK_SKIP_PIXELS:
 151          if (param<0) {
 152             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 153          }
 154          else {
 155             ctx->Unpack.SkipPixels = param;
 156          }
 157          break;
 158       case GL_UNPACK_SKIP_ROWS:
 159          if (param<0) {
 160             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
 161          }
 162          else {
 163             ctx->Unpack.SkipRows = param;
 164          }
 165          break;
 166       case GL_UNPACK_ALIGNMENT:
 167          if (param==1 || param==2 || param==4 || param==8) {
 168             ctx->Unpack.Alignment = param;
 169          }
 170          else {
 171             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
 172          }
 173          break;
 174       default:
 175          gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
 176    }
 177 }
 178
 179
 180
 181
 182
 183 /**********************************************************************/
 184 /*****                         glPixelMap                         *****/
 185 /**********************************************************************/
 186
 187
 188
 189 void gl_PixelMapfv( GLcontext *ctx,
 190                     GLenum map, GLint mapsize, const GLfloat *values )
 191 {
 192    GLint i;
 193
 194    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelMapfv");
 195
 196
 197    if (mapsize<0 || mapsize>MAX_PIXEL_MAP_TABLE) {
 198       gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 199       return;
 200    }
 201
 202    if (map>=GL_PIXEL_MAP_S_TO_S && map<=GL_PIXEL_MAP_I_TO_A) {
 203       /* test that mapsize is a power of two */
 204       GLuint p;
 205       GLboolean ok = GL_FALSE;
 206       for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
 207          if ( (p&mapsize) == p ) {
 208             ok = GL_TRUE;
 209             break;
 210          }
 211       }
 212       if (!ok) {
 213          gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 214          return;
 215       }
 216    }
 217
 218    switch (map) {
 219       case GL_PIXEL_MAP_S_TO_S:
 220          ctx->Pixel.MapStoSsize = mapsize;
 221          for (i=0;i<mapsize;i++) {
 222             ctx->Pixel.MapStoS[i] = (GLint) values[i];
 223          }
 224          break;
 225       case GL_PIXEL_MAP_I_TO_I:
 226          ctx->Pixel.MapItoIsize = mapsize;
 227          for (i=0;i<mapsize;i++) {
 228             ctx->Pixel.MapItoI[i] = (GLint) values[i];
 229          }
 230          break;
 231       case GL_PIXEL_MAP_I_TO_R:
 232          ctx->Pixel.MapItoRsize = mapsize;
 233          for (i=0;i<mapsize;i++) {
 234             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
 235             ctx->Pixel.MapItoR[i] = val;
 236             ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
 237          }
 238          break;
 239       case GL_PIXEL_MAP_I_TO_G:
 240          ctx->Pixel.MapItoGsize = mapsize;
 241          for (i=0;i<mapsize;i++) {
 242             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
 243             ctx->Pixel.MapItoG[i] = val;
 244             ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
 245          }
 246          break;
 247       case GL_PIXEL_MAP_I_TO_B:
 248          ctx->Pixel.MapItoBsize = mapsize;
 249          for (i=0;i<mapsize;i++) {
 250             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
 251             ctx->Pixel.MapItoB[i] = val;
 252             ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
 253          }
 254          break;
 255       case GL_PIXEL_MAP_I_TO_A:
 256          ctx->Pixel.MapItoAsize = mapsize;
 257          for (i=0;i<mapsize;i++) {
 258             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
 259             ctx->Pixel.MapItoA[i] = val;
 260             ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
 261          }
 262          break;
 263       case GL_PIXEL_MAP_R_TO_R:
 264          ctx->Pixel.MapRtoRsize = mapsize;
 265          for (i=0;i<mapsize;i++) {
 266             ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
 267          }
 268          break;
 269       case GL_PIXEL_MAP_G_TO_G:
 270          ctx->Pixel.MapGtoGsize = mapsize;
 271          for (i=0;i<mapsize;i++) {
 272             ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
 273          }
 274          break;
 275       case GL_PIXEL_MAP_B_TO_B:
 276          ctx->Pixel.MapBtoBsize = mapsize;
 277          for (i=0;i<mapsize;i++) {
 278             ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
 279          }
 280          break;
 281       case GL_PIXEL_MAP_A_TO_A:
 282          ctx->Pixel.MapAtoAsize = mapsize;
 283          for (i=0;i<mapsize;i++) {
 284             ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
 285          }
 286          break;
 287       default:
 288          gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
 289    }
 290 }
 291
 292
 293
 294
 295
 296 void gl_GetPixelMapfv( GLcontext *ctx, GLenum map, GLfloat *values )
 297 {
 298    GLint i;
 299
 300    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
 301
 302    switch (map) {
 303       case GL_PIXEL_MAP_I_TO_I:
 304          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
 305             values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
 306          }
 307          break;
 308       case GL_PIXEL_MAP_S_TO_S:
 309          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
 310             values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
 311          }
 312          break;
 313       case GL_PIXEL_MAP_I_TO_R:
 314          MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
 315          break;
 316       case GL_PIXEL_MAP_I_TO_G:
 317          MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
 318          break;
 319       case GL_PIXEL_MAP_I_TO_B:
 320          MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
 321          break;
 322       case GL_PIXEL_MAP_I_TO_A:
 323          MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
 324          break;
 325       case GL_PIXEL_MAP_R_TO_R:
 326          MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
 327          break;
 328       case GL_PIXEL_MAP_G_TO_G:
 329          MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
 330          break;
 331       case GL_PIXEL_MAP_B_TO_B:
 332          MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
 333          break;
 334       case GL_PIXEL_MAP_A_TO_A:
 335          MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
 336          break;
 337       default:
 338          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 339    }
 340 }
 341
 342
 343 void gl_GetPixelMapuiv( GLcontext *ctx, GLenum map, GLuint *values )
 344 {
 345    GLint i;
 346
 347    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
 348
 349    switch (map) {
 350       case GL_PIXEL_MAP_I_TO_I:
 351          MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
 352          break;
 353       case GL_PIXEL_MAP_S_TO_S:
 354          MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
 355          break;
 356       case GL_PIXEL_MAP_I_TO_R:
 357          for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
 358             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
 359          }
 360          break;
 361       case GL_PIXEL_MAP_I_TO_G:
 362          for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
 363             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
 364          }
 365          break;
 366       case GL_PIXEL_MAP_I_TO_B:
 367          for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
 368             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
 369          }
 370          break;
 371       case GL_PIXEL_MAP_I_TO_A:
 372          for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
 373             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
 374          }
 375          break;
 376       case GL_PIXEL_MAP_R_TO_R:
 377          for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
 378             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
 379          }
 380          break;
 381       case GL_PIXEL_MAP_G_TO_G:
 382          for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
 383             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
 384          }
 385          break;
 386       case GL_PIXEL_MAP_B_TO_B:
 387          for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
 388             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
 389          }
 390          break;
 391       case GL_PIXEL_MAP_A_TO_A:
 392          for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
 393             values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
 394          }
 395          break;
 396       default:
 397          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 398    }
 399 }
 400
 401
 402 void gl_GetPixelMapusv( GLcontext *ctx, GLenum map, GLushort *values )
 403 {
 404    GLint i;
 405
 406    ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
 407
 408    switch (map) {
 409       case GL_PIXEL_MAP_I_TO_I:
 410          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
 411             values[i] = (GLushort) ctx->Pixel.MapItoI[i];
 412          }
 413          break;
 414       case GL_PIXEL_MAP_S_TO_S:
 415          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
 416             values[i] = (GLushort) ctx->Pixel.MapStoS[i];
 417          }
 418          break;
 419       case GL_PIXEL_MAP_I_TO_R:
 420          for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
 421             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
 422          }
 423          break;
 424       case GL_PIXEL_MAP_I_TO_G:
 425          for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
 426             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
 427          }
 428          break;
 429       case GL_PIXEL_MAP_I_TO_B:
 430          for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
 431             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
 432          }
 433          break;
 434       case GL_PIXEL_MAP_I_TO_A:
 435          for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
 436             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
 437          }
 438          break;
 439       case GL_PIXEL_MAP_R_TO_R:
 440          for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
 441             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
 442          }
 443          break;
 444       case GL_PIXEL_MAP_G_TO_G:
 445          for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
 446             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
 447          }
 448          break;
 449       case GL_PIXEL_MAP_B_TO_B:
 450          for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
 451             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
 452          }
 453          break;
 454       case GL_PIXEL_MAP_A_TO_A:
 455          for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
 456             values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
 457          }
 458          break;
 459       default:
 460          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
 461    }
 462 }
 463
 464
 465
 466 /**********************************************************************/
 467 /*****                       glPixelTransfer                      *****/
 468 /**********************************************************************/
 469
 470
 471 /*
 472  * Implements glPixelTransfer[fi] whether called immediately or from a
 473  * display list.
 474  */
 475 void gl_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
 476 {
 477    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTransfer");
 478
 479
 480    switch (pname) {
 481       case GL_MAP_COLOR:
 482          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
 483          break;
 484       case GL_MAP_STENCIL:
 485          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
 486          break;
 487       case GL_INDEX_SHIFT:
 488          ctx->Pixel.IndexShift = (GLint) param;
 489          break;
 490       case GL_INDEX_OFFSET:
 491          ctx->Pixel.IndexOffset = (GLint) param;
 492          break;
 493       case GL_RED_SCALE:
 494          ctx->Pixel.RedScale = param;
 495          break;
 496       case GL_RED_BIAS:
 497          ctx->Pixel.RedBias = param;
 498          break;
 499       case GL_GREEN_SCALE:
 500          ctx->Pixel.GreenScale = param;
 501          break;
 502       case GL_GREEN_BIAS:
 503          ctx->Pixel.GreenBias = param;
 504          break;
 505       case GL_BLUE_SCALE:
 506          ctx->Pixel.BlueScale = param;
 507          break;
 508       case GL_BLUE_BIAS:
 509          ctx->Pixel.BlueBias = param;
 510          break;
 511       case GL_ALPHA_SCALE:
 512          ctx->Pixel.AlphaScale = param;
 513          break;
 514       case GL_ALPHA_BIAS:
 515          ctx->Pixel.AlphaBias = param;
 516          break;
 517       case GL_DEPTH_SCALE:
 518          ctx->Pixel.DepthScale = param;
 519          break;
 520       case GL_DEPTH_BIAS:
 521          ctx->Pixel.DepthBias = param;
 522          break;
 523       default:
 524          gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
 525          return;
 526    }
 527
 528    if (ctx->Pixel.RedScale!=1.0F   || ctx->Pixel.RedBias!=0.0F ||
 529        ctx->Pixel.GreenScale!=1.0F || ctx->Pixel.GreenBias!=0.0F ||
 530        ctx->Pixel.BlueScale!=1.0F  || ctx->Pixel.BlueBias!=0.0F ||
 531        ctx->Pixel.AlphaScale!=1.0F || ctx->Pixel.AlphaBias!=0.0F) {
 532       ctx->Pixel.ScaleOrBiasRGBA = GL_TRUE;
 533    }
 534    else {
 535       ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
 536    }
 537 }
 538
 539
 540
 541
 542 /*
 543  * Pixel processing functions
 544  */
 545
 546
 547 /*
 548  * Apply scale and bias factors to an array of RGBA pixels.
 549  */
 550 void gl_scale_and_bias_color( const GLcontext *ctx, GLuint n,
 551                               GLfloat red[], GLfloat green[],
 552                               GLfloat blue[], GLfloat alpha[] )
 553 {
 554    GLuint i;
 555    for (i=0;i<n;i++) {
 556       GLfloat r = red[i]   * ctx->Pixel.RedScale   + ctx->Pixel.RedBias;
 557       GLfloat g = green[i] * ctx->Pixel.GreenScale + ctx->Pixel.GreenBias;
 558       GLfloat b = blue[i]  * ctx->Pixel.BlueScale  + ctx->Pixel.BlueBias;
 559       GLfloat a = alpha[i] * ctx->Pixel.AlphaScale + ctx->Pixel.AlphaBias;
 560       red[i]   = CLAMP( r, 0.0F, 1.0F );
 561       green[i] = CLAMP( g, 0.0F, 1.0F );
 562       blue[i]  = CLAMP( b, 0.0F, 1.0F );
 563       alpha[i] = CLAMP( a, 0.0F, 1.0F );
 564    }
 565 }
 566
 567
 568 /*
 569  * Apply scale and bias factors to an array of RGBA pixels.
 570  */
 571 void gl_scale_and_bias_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
 572 {
 573    GLfloat rbias = ctx->Pixel.RedBias   * 255.0F;
 574    GLfloat gbias = ctx->Pixel.GreenBias * 255.0F;
 575    GLfloat bbias = ctx->Pixel.BlueBias  * 255.0F;
 576    GLfloat abias = ctx->Pixel.AlphaBias * 255.0F;
 577    GLuint i;
 578    for (i=0;i<n;i++) {
 579       GLint r = (GLint) (rgba[i][RCOMP] * ctx->Pixel.RedScale   + rbias);
 580       GLint g = (GLint) (rgba[i][GCOMP] * ctx->Pixel.GreenScale + gbias);
 581       GLint b = (GLint) (rgba[i][BCOMP] * ctx->Pixel.BlueScale  + bbias);
 582       GLint a = (GLint) (rgba[i][ACOMP] * ctx->Pixel.AlphaScale + abias);
 583       rgba[i][RCOMP] = CLAMP( r, 0, 255 );
 584       rgba[i][GCOMP] = CLAMP( g, 0, 255 );
 585       rgba[i][BCOMP] = CLAMP( b, 0, 255 );
 586       rgba[i][ACOMP] = CLAMP( a, 0, 255 );
 587    }
 588 }
 589
 590
 591 /*
 592  * Apply pixel mapping to an array of RGBA pixels.
 593  */
 594 void gl_map_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
 595 {
 596    GLfloat rscale = (ctx->Pixel.MapRtoRsize - 1) / 255.0F;
 597    GLfloat gscale = (ctx->Pixel.MapGtoGsize - 1) / 255.0F;
 598    GLfloat bscale = (ctx->Pixel.MapBtoBsize - 1) / 255.0F;
 599    GLfloat ascale = (ctx->Pixel.MapAtoAsize - 1) / 255.0F;
 600    GLuint i;
 601    for (i=0;i<n;i++) {
 602       GLint ir = (GLint) (rgba[i][RCOMP] * rscale);
 603       GLint ig = (GLint) (rgba[i][GCOMP] * gscale);
 604       GLint ib = (GLint) (rgba[i][BCOMP] * bscale);
 605       GLint ia = (GLint) (rgba[i][ACOMP] * ascale);
 606       rgba[i][RCOMP] = (GLint) (ctx->Pixel.MapRtoR[ir] * 255.0F);
 607       rgba[i][GCOMP] = (GLint) (ctx->Pixel.MapGtoG[ig] * 255.0F);
 608       rgba[i][BCOMP] = (GLint) (ctx->Pixel.MapBtoB[ib] * 255.0F);
 609       rgba[i][ACOMP] = (GLint) (ctx->Pixel.MapAtoA[ia] * 255.0F);
 610    }
 611 }
 612
 613
 614 /*
 615  * Apply pixel mapping to an array of RGBA pixels.
 616  */
 617 void gl_map_color( const GLcontext *ctx, GLuint n,
 618                    GLfloat red[], GLfloat green[],
 619                    GLfloat blue[], GLfloat alpha[] )
 620 {
 621    GLfloat rscale = ctx->Pixel.MapRtoRsize-1;
 622    GLfloat gscale = ctx->Pixel.MapGtoGsize-1;
 623    GLfloat bscale = ctx->Pixel.MapBtoBsize-1;
 624    GLfloat ascale = ctx->Pixel.MapAtoAsize-1;
 625    GLuint i;
 626    for (i=0;i<n;i++) {
 627       red[i]   = ctx->Pixel.MapRtoR[ (GLint) (red[i]   * rscale) ];
 628       green[i] = ctx->Pixel.MapGtoG[ (GLint) (green[i] * gscale) ];
 629       blue[i]  = ctx->Pixel.MapBtoB[ (GLint) (blue[i]  * bscale) ];
 630       alpha[i] = ctx->Pixel.MapAtoA[ (GLint) (alpha[i] * ascale) ];
 631    }
 632 }
 633
 634
 635
 636 /*
 637  * Apply color index shift and offset to an array of pixels.
 638  */
 639 void gl_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
 640 {
 641    GLint shift = ctx->Pixel.IndexShift;
 642    GLint offset = ctx->Pixel.IndexOffset;
 643    GLuint i;
 644    if (shift > 0) {
 645       for (i=0;i<n;i++) {
 646          indexes[i] = (indexes[i] << shift) + offset;
 647       }
 648    }
 649    else if (shift < 0) {
 650       shift = -shift;
 651       for (i=0;i<n;i++) {
 652          indexes[i] = (indexes[i] >> shift) + offset;
 653       }
 654    }
 655    else {
 656       for (i=0;i<n;i++) {
 657          indexes[i] = indexes[i] + offset;
 658       }
 659    }
 660 }
 661
 662
 663 /*
 664  * Apply color index mapping to color indexes.
 665  */
 666 void gl_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
 667 {
 668    GLuint mask = ctx->Pixel.MapItoIsize - 1;
 669    GLuint i;
 670    for (i=0;i<n;i++) {
 671       index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
 672    }
 673 }
 674
 675
 676 /*
 677  * Map color indexes to rgb values.
 678  */
 679 void gl_map_ci_to_rgba( const GLcontext *ctx, GLuint n, const GLuint index[],
 680                         GLubyte rgba[][4] )
 681 {
 682    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
 683    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
 684    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
 685    GLuint amask = ctx->Pixel.MapItoAsize - 1;
 686    const GLubyte *rMap = ctx->Pixel.MapItoR8;
 687    const GLubyte *gMap = ctx->Pixel.MapItoG8;
 688    const GLubyte *bMap = ctx->Pixel.MapItoB8;
 689    const GLubyte *aMap = ctx->Pixel.MapItoA8;
 690    GLuint i;
 691    for (i=0;i<n;i++) {
 692       rgba[i][RCOMP] = rMap[index[i] & rmask];
 693       rgba[i][GCOMP] = gMap[index[i] & gmask];
 694       rgba[i][BCOMP] = bMap[index[i] & bmask];
 695       rgba[i][ACOMP] = aMap[index[i] & amask];
 696    }
 697 }
 698
 699
 700 /*
 701  * Map 8-bit color indexes to rgb values.
 702  */
 703 void gl_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
 704                          GLubyte rgba[][4] )
 705 {
 706    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
 707    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
 708    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
 709    GLuint amask = ctx->Pixel.MapItoAsize - 1;
 710    const GLubyte *rMap = ctx->Pixel.MapItoR8;
 711    const GLubyte *gMap = ctx->Pixel.MapItoG8;
 712    const GLubyte *bMap = ctx->Pixel.MapItoB8;
 713    const GLubyte *aMap = ctx->Pixel.MapItoA8;
 714    GLuint i;
 715    for (i=0;i<n;i++) {
 716       rgba[i][RCOMP] = rMap[index[i] & rmask];
 717       rgba[i][GCOMP] = gMap[index[i] & gmask];
 718       rgba[i][BCOMP] = bMap[index[i] & bmask];
 719       rgba[i][ACOMP] = aMap[index[i] & amask];
 720    }
 721 }
 722
 723
 724 void gl_map_ci_to_color( const GLcontext *ctx, GLuint n, const GLuint index[],
 725                          GLfloat r[], GLfloat g[],
 726                          GLfloat b[], GLfloat a[] )
 727 {
 728    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
 729    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
 730    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
 731    GLuint amask = ctx->Pixel.MapItoAsize - 1;
 732    GLuint i;
 733    for (i=0;i<n;i++) {
 734       r[i] = ctx->Pixel.MapItoR[index[i] & rmask];
 735       g[i] = ctx->Pixel.MapItoG[index[i] & gmask];
 736       b[i] = ctx->Pixel.MapItoB[index[i] & bmask];
 737       a[i] = ctx->Pixel.MapItoA[index[i] & amask];
 738    }
 739 }
 740
 741
 742
 743 void gl_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
 744                                   GLstencil stencil[] )
 745 {
 746    GLuint i;
 747    GLint shift = ctx->Pixel.IndexShift;
 748    GLint offset = ctx->Pixel.IndexOffset;
 749    if (shift > 0) {
 750       for (i=0;i<n;i++) {
 751          stencil[i] = (stencil[i] << shift) + offset;
 752       }
 753    }
 754    else if (shift < 0) {
 755       shift = -shift;
 756       for (i=0;i<n;i++) {
 757          stencil[i] = (stencil[i] >> shift) + offset;
 758       }
 759    }
 760    else {
 761       for (i=0;i<n;i++) {
 762          stencil[i] = stencil[i] + offset;
 763       }
 764    }
 765
 766 }
 767
 768
 769
 770 void gl_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
 771 {
 772    GLuint mask = ctx->Pixel.MapStoSsize - 1;
 773    GLuint i;
 774    for (i=0;i<n;i++) {
 775       stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
 776    }
 777 }
 778