src/mesa/main/pixel.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /**
  27  * \file pixel.c
  28  * Pixel transfer functions (glPixelZoom, glPixelMap, glPixelTransfer)
  29  */
  30
  31 #include "c99_math.h"
  32 #include "glheader.h"
  33 #include "bufferobj.h"
  34 #include "context.h"
  35 #include "macros.h"
  36 #include "pixel.h"
  37 #include "pbo.h"
  38 #include "mtypes.h"
  39
  40
  41 /**********************************************************************/
  42 /*****                    glPixelZoom                             *****/
  43 /**********************************************************************/
  44
  45 void GLAPIENTRY
  46 _mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
  47 {
  48    GET_CURRENT_CONTEXT(ctx);
  49
  50    if (ctx->Pixel.ZoomX == xfactor &&
  51        ctx->Pixel.ZoomY == yfactor)
  52       return;
  53
  54    FLUSH_VERTICES(ctx, _NEW_PIXEL);
  55    ctx->Pixel.ZoomX = xfactor;
  56    ctx->Pixel.ZoomY = yfactor;
  57 }
  58
  59
  60
  61 /**********************************************************************/
  62 /*****                         glPixelMap                         *****/
  63 /**********************************************************************/
  64
  65 /**
  66  * Return pointer to a pixelmap by name.
  67  */
  68 static struct gl_pixelmap *
  69 get_pixelmap(struct gl_context *ctx, GLenum map)
  70 {
  71    switch (map) {
  72    case GL_PIXEL_MAP_I_TO_I:
  73       return &ctx->PixelMaps.ItoI;
  74    case GL_PIXEL_MAP_S_TO_S:
  75       return &ctx->PixelMaps.StoS;
  76    case GL_PIXEL_MAP_I_TO_R:
  77       return &ctx->PixelMaps.ItoR;
  78    case GL_PIXEL_MAP_I_TO_G:
  79       return &ctx->PixelMaps.ItoG;
  80    case GL_PIXEL_MAP_I_TO_B:
  81       return &ctx->PixelMaps.ItoB;
  82    case GL_PIXEL_MAP_I_TO_A:
  83       return &ctx->PixelMaps.ItoA;
  84    case GL_PIXEL_MAP_R_TO_R:
  85       return &ctx->PixelMaps.RtoR;
  86    case GL_PIXEL_MAP_G_TO_G:
  87       return &ctx->PixelMaps.GtoG;
  88    case GL_PIXEL_MAP_B_TO_B:
  89       return &ctx->PixelMaps.BtoB;
  90    case GL_PIXEL_MAP_A_TO_A:
  91       return &ctx->PixelMaps.AtoA;
  92    default:
  93       return NULL;
  94    }
  95 }
  96
  97
  98 /**
  99  * Helper routine used by the other _mesa_PixelMap() functions.
 100  */
 101 static void
 102 store_pixelmap(struct gl_context *ctx, GLenum map, GLsizei mapsize,
 103                const GLfloat *values)
 104 {
 105    GLint i;
 106    struct gl_pixelmap *pm = get_pixelmap(ctx, map);
 107    if (!pm) {
 108       _mesa_error(ctx, GL_INVALID_ENUM, "glPixelMap(map)");
 109       return;
 110    }
 111
 112    switch (map) {
 113    case GL_PIXEL_MAP_S_TO_S:
 114       /* special case */
 115       ctx->PixelMaps.StoS.Size = mapsize;
 116       for (i = 0; i < mapsize; i++) {
 117          ctx->PixelMaps.StoS.Map[i] = roundf(values[i]);
 118       }
 119       break;
 120    case GL_PIXEL_MAP_I_TO_I:
 121       /* special case */
 122       ctx->PixelMaps.ItoI.Size = mapsize;
 123       for (i = 0; i < mapsize; i++) {
 124          ctx->PixelMaps.ItoI.Map[i] = values[i];
 125       }
 126       break;
 127    default:
 128       /* general case */
 129       pm->Size = mapsize;
 130       for (i = 0; i < mapsize; i++) {
 131          GLfloat val = CLAMP(values[i], 0.0F, 1.0F);
 132          pm->Map[i] = val;
 133       }
 134    }
 135 }
 136
 137
 138 /**
 139  * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().
 140  */
 141 static GLboolean
 142 validate_pbo_access(struct gl_context *ctx,
 143                     struct gl_pixelstore_attrib *pack, GLsizei mapsize,
 144                     GLenum format, GLenum type, GLsizei clientMemSize,
 145                     const GLvoid *ptr)
 146 {
 147    GLboolean ok;
 148
 149    /* Note, need to use DefaultPacking and Unpack's buffer object */
 150    _mesa_reference_buffer_object(ctx,
 151                                  &ctx->DefaultPacking.BufferObj,
 152                                  pack->BufferObj);
 153
 154    ok = _mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
 155                                   format, type, clientMemSize, ptr);
 156
 157    /* restore */
 158    _mesa_reference_buffer_object(ctx,
 159                                  &ctx->DefaultPacking.BufferObj, NULL);
 160
 161    if (!ok) {
 162       if (pack->BufferObj) {
 163          _mesa_error(ctx, GL_INVALID_OPERATION,
 164                      "gl[Get]PixelMap*v(out of bounds PBO access)");
 165       } else {
 166          _mesa_error(ctx, GL_INVALID_OPERATION,
 167                      "glGetnPixelMap*vARB(out of bounds access:"
 168                      " bufSize (%d) is too small)", clientMemSize);
 169       }
 170    }
 171    return ok;
 172 }
 173
 174
 175 void GLAPIENTRY
 176 _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
 177 {
 178    GET_CURRENT_CONTEXT(ctx);
 179
 180    /* XXX someday, test against ctx->Const.MaxPixelMapTableSize */
 181    if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
 182       _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 183       return;
 184    }
 185
 186    if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
 187       /* test that mapsize is a power of two */
 188       if (!util_is_power_of_two_or_zero(mapsize)) {
 189          _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
 190          return;
 191       }
 192    }
 193
 194    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 195
 196    if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, GL_INTENSITY,
 197                             GL_FLOAT, INT_MAX, values)) {
 198       return;
 199    }
 200
 201    values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
 202    if (!values) {
 203       if (ctx->Unpack.BufferObj) {
 204          _mesa_error(ctx, GL_INVALID_OPERATION,
 205                      "glPixelMapfv(PBO is mapped)");
 206       }
 207       return;
 208    }
 209
 210    store_pixelmap(ctx, map, mapsize, values);
 211
 212    _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 213 }
 214
 215
 216 void GLAPIENTRY
 217 _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
 218 {
 219    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
 220    GET_CURRENT_CONTEXT(ctx);
 221
 222    if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
 223       _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
 224       return;
 225    }
 226
 227    if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
 228       /* test that mapsize is a power of two */
 229       if (!util_is_power_of_two_or_zero(mapsize)) {
 230          _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapuiv(mapsize)" );
 231          return;
 232       }
 233    }
 234
 235    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 236
 237    if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, GL_INTENSITY,
 238                             GL_UNSIGNED_INT, INT_MAX, values)) {
 239       return;
 240    }
 241
 242    values = (const GLuint *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
 243    if (!values) {
 244       if (ctx->Unpack.BufferObj) {
 245          _mesa_error(ctx, GL_INVALID_OPERATION,
 246                      "glPixelMapuiv(PBO is mapped)");
 247       }
 248       return;
 249    }
 250
 251    /* convert to floats */
 252    if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
 253       GLint i;
 254       for (i = 0; i < mapsize; i++) {
 255          fvalues[i] = (GLfloat) values[i];
 256       }
 257    }
 258    else {
 259       GLint i;
 260       for (i = 0; i < mapsize; i++) {
 261          fvalues[i] = UINT_TO_FLOAT( values[i] );
 262       }
 263    }
 264
 265    _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 266
 267    store_pixelmap(ctx, map, mapsize, fvalues);
 268 }
 269
 270
 271 void GLAPIENTRY
 272 _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
 273 {
 274    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
 275    GET_CURRENT_CONTEXT(ctx);
 276
 277    if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
 278       _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
 279       return;
 280    }
 281
 282    if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
 283       /* test that mapsize is a power of two */
 284       if (!util_is_power_of_two_or_zero(mapsize)) {
 285          _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapusv(mapsize)" );
 286          return;
 287       }
 288    }
 289
 290    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 291
 292    if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, GL_INTENSITY,
 293                             GL_UNSIGNED_SHORT, INT_MAX, values)) {
 294       return;
 295    }
 296
 297    values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
 298    if (!values) {
 299       if (ctx->Unpack.BufferObj) {
 300          _mesa_error(ctx, GL_INVALID_OPERATION,
 301                      "glPixelMapusv(PBO is mapped)");
 302       }
 303       return;
 304    }
 305
 306    /* convert to floats */
 307    if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
 308       GLint i;
 309       for (i = 0; i < mapsize; i++) {
 310          fvalues[i] = (GLfloat) values[i];
 311       }
 312    }
 313    else {
 314       GLint i;
 315       for (i = 0; i < mapsize; i++) {
 316          fvalues[i] = USHORT_TO_FLOAT( values[i] );
 317       }
 318    }
 319
 320    _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 321
 322    store_pixelmap(ctx, map, mapsize, fvalues);
 323 }
 324
 325
 326 void GLAPIENTRY
 327 _mesa_GetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat *values )
 328 {
 329    GET_CURRENT_CONTEXT(ctx);
 330    GLint mapsize, i;
 331    const struct gl_pixelmap *pm;
 332
 333    pm = get_pixelmap(ctx, map);
 334    if (!pm) {
 335       _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapfv(map)");
 336       return;
 337    }
 338
 339    mapsize = pm->Size;
 340
 341    if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, GL_INTENSITY,
 342                             GL_FLOAT, bufSize, values)) {
 343       return;
 344    }
 345
 346    values = (GLfloat *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
 347    if (!values) {
 348       if (ctx->Pack.BufferObj) {
 349          _mesa_error(ctx, GL_INVALID_OPERATION,
 350                      "glGetPixelMapfv(PBO is mapped)");
 351       }
 352       return;
 353    }
 354
 355    if (map == GL_PIXEL_MAP_S_TO_S) {
 356       /* special case */
 357       for (i = 0; i < mapsize; i++) {
 358          values[i] = (GLfloat) ctx->PixelMaps.StoS.Map[i];
 359       }
 360    }
 361    else {
 362       memcpy(values, pm->Map, mapsize * sizeof(GLfloat));
 363    }
 364
 365    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 366 }
 367
 368
 369 void GLAPIENTRY
 370 _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
 371 {
 372    _mesa_GetnPixelMapfvARB(map, INT_MAX, values);
 373 }
 374
 375 void GLAPIENTRY
 376 _mesa_GetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint *values )
 377 {
 378    GET_CURRENT_CONTEXT(ctx);
 379    GLint mapsize, i;
 380    const struct gl_pixelmap *pm;
 381
 382    pm = get_pixelmap(ctx, map);
 383    if (!pm) {
 384       _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapuiv(map)");
 385       return;
 386    }
 387
 388    mapsize = pm->Size;
 389
 390    if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, GL_INTENSITY,
 391                             GL_UNSIGNED_INT, bufSize, values)) {
 392       return;
 393    }
 394
 395    values = (GLuint *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
 396    if (!values) {
 397       if (ctx->Pack.BufferObj) {
 398          _mesa_error(ctx, GL_INVALID_OPERATION,
 399                      "glGetPixelMapuiv(PBO is mapped)");
 400       }
 401       return;
 402    }
 403
 404    if (map == GL_PIXEL_MAP_S_TO_S) {
 405       /* special case */
 406       memcpy(values, ctx->PixelMaps.StoS.Map, mapsize * sizeof(GLint));
 407    }
 408    else {
 409       for (i = 0; i < mapsize; i++) {
 410          values[i] = FLOAT_TO_UINT( pm->Map[i] );
 411       }
 412    }
 413
 414    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 415 }
 416
 417
 418 void GLAPIENTRY
 419 _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
 420 {
 421    _mesa_GetnPixelMapuivARB(map, INT_MAX, values);
 422 }
 423
 424 void GLAPIENTRY
 425 _mesa_GetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort *values )
 426 {
 427    GET_CURRENT_CONTEXT(ctx);
 428    GLint mapsize, i;
 429    const struct gl_pixelmap *pm;
 430
 431    pm = get_pixelmap(ctx, map);
 432    if (!pm) {
 433       _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelMapusv(map)");
 434       return;
 435    }
 436
 437    mapsize = pm->Size;
 438
 439    if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, GL_INTENSITY,
 440                             GL_UNSIGNED_SHORT, bufSize, values)) {
 441       return;
 442    }
 443
 444    values = (GLushort *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
 445    if (!values) {
 446       if (ctx->Pack.BufferObj) {
 447          _mesa_error(ctx, GL_INVALID_OPERATION,
 448                      "glGetPixelMapusv(PBO is mapped)");
 449       }
 450       return;
 451    }
 452
 453    switch (map) {
 454    /* special cases */
 455    case GL_PIXEL_MAP_I_TO_I:
 456       for (i = 0; i < mapsize; i++) {
 457          values[i] = (GLushort) CLAMP(ctx->PixelMaps.ItoI.Map[i], 0.0F, 65535.0F);
 458       }
 459       break;
 460    case GL_PIXEL_MAP_S_TO_S:
 461       for (i = 0; i < mapsize; i++) {
 462          values[i] = (GLushort) CLAMP(ctx->PixelMaps.StoS.Map[i], 0.0F, 65535.0F);
 463       }
 464       break;
 465    default:
 466       for (i = 0; i < mapsize; i++) {
 467          CLAMPED_FLOAT_TO_USHORT(values[i], pm->Map[i] );
 468       }
 469    }
 470
 471    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 472 }
 473
 474
 475 void GLAPIENTRY
 476 _mesa_GetPixelMapusv( GLenum map, GLushort *values )
 477 {
 478    _mesa_GetnPixelMapusvARB(map, INT_MAX, values);
 479 }
 480
 481
 482 /**********************************************************************/
 483 /*****                       glPixelTransfer                      *****/
 484 /**********************************************************************/
 485
 486
 487 /*
 488  * Implements glPixelTransfer[fi] whether called immediately or from a
 489  * display list.
 490  */
 491 void GLAPIENTRY
 492 _mesa_PixelTransferf( GLenum pname, GLfloat param )
 493 {
 494    GET_CURRENT_CONTEXT(ctx);
 495
 496    switch (pname) {
 497       case GL_MAP_COLOR:
 498          if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
 499             return;
 500          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 501          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
 502          break;
 503       case GL_MAP_STENCIL:
 504          if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
 505             return;
 506          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 507          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
 508          break;
 509       case GL_INDEX_SHIFT:
 510          if (ctx->Pixel.IndexShift == (GLint) param)
 511             return;
 512          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 513          ctx->Pixel.IndexShift = (GLint) param;
 514          break;
 515       case GL_INDEX_OFFSET:
 516          if (ctx->Pixel.IndexOffset == (GLint) param)
 517             return;
 518          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 519          ctx->Pixel.IndexOffset = (GLint) param;
 520          break;
 521       case GL_RED_SCALE:
 522          if (ctx->Pixel.RedScale == param)
 523             return;
 524          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 525          ctx->Pixel.RedScale = param;
 526          break;
 527       case GL_RED_BIAS:
 528          if (ctx->Pixel.RedBias == param)
 529             return;
 530          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 531          ctx->Pixel.RedBias = param;
 532          break;
 533       case GL_GREEN_SCALE:
 534          if (ctx->Pixel.GreenScale == param)
 535             return;
 536          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 537          ctx->Pixel.GreenScale = param;
 538          break;
 539       case GL_GREEN_BIAS:
 540          if (ctx->Pixel.GreenBias == param)
 541             return;
 542          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 543          ctx->Pixel.GreenBias = param;
 544          break;
 545       case GL_BLUE_SCALE:
 546          if (ctx->Pixel.BlueScale == param)
 547             return;
 548          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 549          ctx->Pixel.BlueScale = param;
 550          break;
 551       case GL_BLUE_BIAS:
 552          if (ctx->Pixel.BlueBias == param)
 553             return;
 554          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 555          ctx->Pixel.BlueBias = param;
 556          break;
 557       case GL_ALPHA_SCALE:
 558          if (ctx->Pixel.AlphaScale == param)
 559             return;
 560          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 561          ctx->Pixel.AlphaScale = param;
 562          break;
 563       case GL_ALPHA_BIAS:
 564          if (ctx->Pixel.AlphaBias == param)
 565             return;
 566          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 567          ctx->Pixel.AlphaBias = param;
 568          break;
 569       case GL_DEPTH_SCALE:
 570          if (ctx->Pixel.DepthScale == param)
 571             return;
 572          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 573          ctx->Pixel.DepthScale = param;
 574          break;
 575       case GL_DEPTH_BIAS:
 576          if (ctx->Pixel.DepthBias == param)
 577             return;
 578          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 579          ctx->Pixel.DepthBias = param;
 580          break;
 581       default:
 582          _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
 583          return;
 584    }
 585 }
 586
 587
 588 void GLAPIENTRY
 589 _mesa_PixelTransferi( GLenum pname, GLint param )
 590 {
 591    _mesa_PixelTransferf( pname, (GLfloat) param );
 592 }
 593
 594
 595
 596 /**********************************************************************/
 597 /*****                    State Management                        *****/
 598 /**********************************************************************/
 599
 600
 601 /**
 602  * Update mesa pixel transfer derived state to indicate which operations are
 603  * enabled.
 604  */
 605 void
 606 _mesa_update_pixel( struct gl_context *ctx )
 607 {
 608    GLuint mask = 0;
 609
 610    if (ctx->Pixel.RedScale   != 1.0F || ctx->Pixel.RedBias   != 0.0F ||
 611        ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
 612        ctx->Pixel.BlueScale  != 1.0F || ctx->Pixel.BlueBias  != 0.0F ||
 613        ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
 614       mask |= IMAGE_SCALE_BIAS_BIT;
 615
 616    if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
 617       mask |= IMAGE_SHIFT_OFFSET_BIT;
 618
 619    if (ctx->Pixel.MapColorFlag)
 620       mask |= IMAGE_MAP_COLOR_BIT;
 621
 622    ctx->_ImageTransferState = mask;
 623 }
 624
 625
 626 /**********************************************************************/
 627 /*****                      Initialization                        *****/
 628 /**********************************************************************/
 629
 630 static void
 631 init_pixelmap(struct gl_pixelmap *map)
 632 {
 633    map->Size = 1;
 634    map->Map[0] = 0.0;
 635 }
 636
 637
 638 /**
 639  * Initialize the context's PIXEL attribute group.
 640  */
 641 void
 642 _mesa_init_pixel( struct gl_context *ctx )
 643 {
 644    /* Pixel group */
 645    ctx->Pixel.RedBias = 0.0;
 646    ctx->Pixel.RedScale = 1.0;
 647    ctx->Pixel.GreenBias = 0.0;
 648    ctx->Pixel.GreenScale = 1.0;
 649    ctx->Pixel.BlueBias = 0.0;
 650    ctx->Pixel.BlueScale = 1.0;
 651    ctx->Pixel.AlphaBias = 0.0;
 652    ctx->Pixel.AlphaScale = 1.0;
 653    ctx->Pixel.DepthBias = 0.0;
 654    ctx->Pixel.DepthScale = 1.0;
 655    ctx->Pixel.IndexOffset = 0;
 656    ctx->Pixel.IndexShift = 0;
 657    ctx->Pixel.ZoomX = 1.0;
 658    ctx->Pixel.ZoomY = 1.0;
 659    ctx->Pixel.MapColorFlag = GL_FALSE;
 660    ctx->Pixel.MapStencilFlag = GL_FALSE;
 661    init_pixelmap(&ctx->PixelMaps.StoS);
 662    init_pixelmap(&ctx->PixelMaps.ItoI);
 663    init_pixelmap(&ctx->PixelMaps.ItoR);
 664    init_pixelmap(&ctx->PixelMaps.ItoG);
 665    init_pixelmap(&ctx->PixelMaps.ItoB);
 666    init_pixelmap(&ctx->PixelMaps.ItoA);
 667    init_pixelmap(&ctx->PixelMaps.RtoR);
 668    init_pixelmap(&ctx->PixelMaps.GtoG);
 669    init_pixelmap(&ctx->PixelMaps.BtoB);
 670    init_pixelmap(&ctx->PixelMaps.AtoA);
 671
 672    if (ctx->Visual.doubleBufferMode) {
 673       ctx->Pixel.ReadBuffer = GL_BACK;
 674    }
 675    else {
 676       ctx->Pixel.ReadBuffer = GL_FRONT;
 677    }
 678
 679    /* Miscellaneous */
 680    ctx->_ImageTransferState = 0;
 681 }