src/mesa/main/colortab.c

   1 /* $Id: colortab.c,v 1.36 2001/03/07 05:06:11 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2001  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 "colortab.h"
  33 #include "context.h"
  34 #include "image.h"
  35 #include "macros.h"
  36 #include "mem.h"
  37 #include "mmath.h"
  38 #include "state.h"
  39 #include "swrast/s_span.h" /* XXX SWRAST hack */
  40 #endif
  41
  42
  43
  44 /*
  45  * Given an internalFormat token passed to glColorTable,
  46  * return the corresponding base format.
  47  * Return -1 if invalid token.
  48  */
  49 static GLint
  50 base_colortab_format( GLenum format )
  51 {
  52    switch (format) {
  53       case GL_ALPHA:
  54       case GL_ALPHA4:
  55       case GL_ALPHA8:
  56       case GL_ALPHA12:
  57       case GL_ALPHA16:
  58          return GL_ALPHA;
  59       case GL_LUMINANCE:
  60       case GL_LUMINANCE4:
  61       case GL_LUMINANCE8:
  62       case GL_LUMINANCE12:
  63       case GL_LUMINANCE16:
  64          return GL_LUMINANCE;
  65       case GL_LUMINANCE_ALPHA:
  66       case GL_LUMINANCE4_ALPHA4:
  67       case GL_LUMINANCE6_ALPHA2:
  68       case GL_LUMINANCE8_ALPHA8:
  69       case GL_LUMINANCE12_ALPHA4:
  70       case GL_LUMINANCE12_ALPHA12:
  71       case GL_LUMINANCE16_ALPHA16:
  72          return GL_LUMINANCE_ALPHA;
  73       case GL_INTENSITY:
  74       case GL_INTENSITY4:
  75       case GL_INTENSITY8:
  76       case GL_INTENSITY12:
  77       case GL_INTENSITY16:
  78          return GL_INTENSITY;
  79       case GL_RGB:
  80       case GL_R3_G3_B2:
  81       case GL_RGB4:
  82       case GL_RGB5:
  83       case GL_RGB8:
  84       case GL_RGB10:
  85       case GL_RGB12:
  86       case GL_RGB16:
  87          return GL_RGB;
  88       case GL_RGBA:
  89       case GL_RGBA2:
  90       case GL_RGBA4:
  91       case GL_RGB5_A1:
  92       case GL_RGBA8:
  93       case GL_RGB10_A2:
  94       case GL_RGBA12:
  95       case GL_RGBA16:
  96          return GL_RGBA;
  97       default:
  98          return -1;  /* error */
  99    }
 100 }
 101
 102
 103 void
 104 _mesa_init_colortable( struct gl_color_table *p )
 105 {
 106    p->FloatTable = GL_FALSE;
 107    p->Table = NULL;
 108    p->Size = 0;
 109    p->IntFormat = GL_RGBA;
 110 }
 111
 112
 113
 114 void
 115 _mesa_free_colortable_data( struct gl_color_table *p )
 116 {
 117    if (p->Table) {
 118       FREE(p->Table);
 119       p->Table = NULL;
 120    }
 121 }
 122
 123
 124 /*
 125  * Examine table's format and set the component sizes accordingly.
 126  */
 127 static void
 128 set_component_sizes( struct gl_color_table *table )
 129 {
 130    /* XXX what about GLfloat tables? */
 131    switch (table->Format) {
 132       case GL_ALPHA:
 133          table->RedSize = 0;
 134          table->GreenSize = 0;
 135          table->BlueSize = 0;
 136          table->AlphaSize = CHAN_BITS;
 137          table->IntensitySize = 0;
 138          table->LuminanceSize = 0;
 139          break;
 140       case GL_LUMINANCE:
 141          table->RedSize = 0;
 142          table->GreenSize = 0;
 143          table->BlueSize = 0;
 144          table->AlphaSize = 0;
 145          table->IntensitySize = 0;
 146          table->LuminanceSize = CHAN_BITS;
 147          break;
 148       case GL_LUMINANCE_ALPHA:
 149          table->RedSize = 0;
 150          table->GreenSize = 0;
 151          table->BlueSize = 0;
 152          table->AlphaSize = CHAN_BITS;
 153          table->IntensitySize = 0;
 154          table->LuminanceSize = CHAN_BITS;
 155          break;
 156       case GL_INTENSITY:
 157          table->RedSize = 0;
 158          table->GreenSize = 0;
 159          table->BlueSize = 0;
 160          table->AlphaSize = 0;
 161          table->IntensitySize = CHAN_BITS;
 162          table->LuminanceSize = 0;
 163          break;
 164       case GL_RGB:
 165          table->RedSize = CHAN_BITS;
 166          table->GreenSize = CHAN_BITS;
 167          table->BlueSize = CHAN_BITS;
 168          table->AlphaSize = 0;
 169          table->IntensitySize = 0;
 170          table->LuminanceSize = 0;
 171          break;
 172       case GL_RGBA:
 173          table->RedSize = CHAN_BITS;
 174          table->GreenSize = CHAN_BITS;
 175          table->BlueSize = CHAN_BITS;
 176          table->AlphaSize = CHAN_BITS;
 177          table->IntensitySize = 0;
 178          table->LuminanceSize = 0;
 179          break;
 180       default:
 181          _mesa_problem(NULL, "unexpected format in set_component_sizes");
 182    }
 183 }
 184
 185
 186
 187 void
 188 _mesa_ColorTable( GLenum target, GLenum internalFormat,
 189                   GLsizei width, GLenum format, GLenum type,
 190                   const GLvoid *data )
 191 {
 192    GET_CURRENT_CONTEXT(ctx);
 193    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 194    struct gl_texture_object *texObj = NULL;
 195    struct gl_color_table *table = NULL;
 196    GLboolean proxy = GL_FALSE;
 197    GLint baseFormat;
 198    GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0;
 199    GLfloat rBias  = 0.0, gBias  = 0.0, bBias  = 0.0, aBias  = 0.0;
 200    GLboolean floatTable = GL_FALSE;
 201    GLint comps;
 202    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
 203
 204    switch (target) {
 205       case GL_TEXTURE_1D:
 206          texObj = texUnit->Current1D;
 207          table = &texObj->Palette;
 208          break;
 209       case GL_TEXTURE_2D:
 210          texObj = texUnit->Current2D;
 211          table = &texObj->Palette;
 212          break;
 213       case GL_TEXTURE_3D:
 214          texObj = texUnit->Current3D;
 215          table = &texObj->Palette;
 216          break;
 217       case GL_PROXY_TEXTURE_1D:
 218          texObj = ctx->Texture.Proxy1D;
 219          table = &texObj->Palette;
 220          proxy = GL_TRUE;
 221          break;
 222       case GL_PROXY_TEXTURE_2D:
 223          texObj = ctx->Texture.Proxy2D;
 224          table = &texObj->Palette;
 225          proxy = GL_TRUE;
 226          break;
 227       case GL_PROXY_TEXTURE_3D:
 228          texObj = ctx->Texture.Proxy3D;
 229          table = &texObj->Palette;
 230          proxy = GL_TRUE;
 231          break;
 232       case GL_SHARED_TEXTURE_PALETTE_EXT:
 233          table = &ctx->Texture.Palette;
 234          break;
 235       case GL_COLOR_TABLE:
 236          table = &ctx->ColorTable;
 237          floatTable = GL_TRUE;
 238          rScale = ctx->Pixel.ColorTableScale[0];
 239          gScale = ctx->Pixel.ColorTableScale[1];
 240          bScale = ctx->Pixel.ColorTableScale[2];
 241          aScale = ctx->Pixel.ColorTableScale[3];
 242          rBias = ctx->Pixel.ColorTableBias[0];
 243          gBias = ctx->Pixel.ColorTableBias[1];
 244          bBias = ctx->Pixel.ColorTableBias[2];
 245          aBias = ctx->Pixel.ColorTableBias[3];
 246          break;
 247       case GL_PROXY_COLOR_TABLE:
 248          table = &ctx->ProxyColorTable;
 249          proxy = GL_TRUE;
 250          break;
 251       case GL_POST_CONVOLUTION_COLOR_TABLE:
 252          table = &ctx->PostConvolutionColorTable;
 253          floatTable = GL_TRUE;
 254          rScale = ctx->Pixel.PCCTscale[0];
 255          gScale = ctx->Pixel.PCCTscale[1];
 256          bScale = ctx->Pixel.PCCTscale[2];
 257          aScale = ctx->Pixel.PCCTscale[3];
 258          rBias = ctx->Pixel.PCCTbias[0];
 259          gBias = ctx->Pixel.PCCTbias[1];
 260          bBias = ctx->Pixel.PCCTbias[2];
 261          aBias = ctx->Pixel.PCCTbias[3];
 262          break;
 263       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
 264          table = &ctx->ProxyPostConvolutionColorTable;
 265          proxy = GL_TRUE;
 266          break;
 267       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 268          table = &ctx->PostColorMatrixColorTable;
 269          floatTable = GL_TRUE;
 270          rScale = ctx->Pixel.PCMCTscale[0];
 271          gScale = ctx->Pixel.PCMCTscale[1];
 272          bScale = ctx->Pixel.PCMCTscale[2];
 273          aScale = ctx->Pixel.PCMCTscale[3];
 274          rBias = ctx->Pixel.PCMCTbias[0];
 275          gBias = ctx->Pixel.PCMCTbias[1];
 276          bBias = ctx->Pixel.PCMCTbias[2];
 277          aBias = ctx->Pixel.PCMCTbias[3];
 278          break;
 279       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
 280          table = &ctx->ProxyPostColorMatrixColorTable;
 281          proxy = GL_TRUE;
 282          break;
 283       default:
 284          _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
 285          return;
 286    }
 287
 288    assert(table);
 289
 290    if (!_mesa_is_legal_format_and_type(format, type) ||
 291        format == GL_INTENSITY) {
 292       _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)");
 293       return;
 294    }
 295
 296    baseFormat = base_colortab_format(internalFormat);
 297    if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
 298       _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
 299       return;
 300    }
 301
 302    if (width < 0 || (width != 0 && _mesa_bitcount(width) != 1)) {
 303       /* error */
 304       if (proxy) {
 305          table->Size = 0;
 306          table->IntFormat = (GLenum) 0;
 307          table->Format = (GLenum) 0;
 308       }
 309       else {
 310          char msg[100];
 311          sprintf(msg, "glColorTable(width=%d)", width);
 312          _mesa_error(ctx, GL_INVALID_VALUE, msg);
 313       }
 314       return;
 315    }
 316
 317    if (width > (GLsizei) ctx->Const.MaxColorTableSize) {
 318       if (proxy) {
 319          table->Size = 0;
 320          table->IntFormat = (GLenum) 0;
 321          table->Format = (GLenum) 0;
 322       }
 323       else {
 324          _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
 325       }
 326       return;
 327    }
 328
 329    table->Size = width;
 330    table->IntFormat = internalFormat;
 331    table->Format = (GLenum) baseFormat;
 332    set_component_sizes(table);
 333
 334    comps = _mesa_components_in_format(table->Format);
 335    assert(comps > 0);  /* error should have been caught sooner */
 336
 337    if (!proxy) {
 338       /* free old table, if any */
 339       if (table->Table) {
 340          FREE(table->Table);
 341          table->Table = NULL;
 342       }
 343       if (width > 0) {
 344          if (floatTable) {
 345             GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
 346             GLfloat *tableF;
 347             GLint i;
 348
 349             _mesa_unpack_float_color_span(ctx, width, table->Format,
 350                                           tempTab,  /* dest */
 351                                           format, type, data, &ctx->Unpack,
 352                                           0, GL_FALSE);
 353
 354             table->FloatTable = GL_TRUE;
 355             table->Table = MALLOC(comps * width * sizeof(GLfloat));
 356             if (!table->Table) {
 357                _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
 358                return;
 359             }
 360
 361             tableF = (GLfloat *) table->Table;
 362
 363             switch (table->Format) {
 364                case GL_INTENSITY:
 365                   for (i = 0; i < width; i++) {
 366                      tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
 367                   }
 368                   break;
 369                case GL_LUMINANCE:
 370                   for (i = 0; i < width; i++) {
 371                      tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
 372                   }
 373                   break;
 374                case GL_ALPHA:
 375                   for (i = 0; i < width; i++) {
 376                      tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);
 377                   }
 378                   break;
 379                case GL_LUMINANCE_ALPHA:
 380                   for (i = 0; i < width; i++) {
 381                      tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);
 382                      tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);
 383                   }
 384                   break;
 385                case GL_RGB:
 386                   for (i = 0; i < width; i++) {
 387                      tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);
 388                      tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);
 389                      tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);
 390                   }
 391                   break;
 392                case GL_RGBA:
 393                   for (i = 0; i < width; i++) {
 394                      tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);
 395                      tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);
 396                      tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);
 397                      tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);
 398                   }
 399                   break;
 400                default:
 401                   _mesa_problem(ctx, "Bad format in _mesa_ColorTable");
 402                   return;
 403             }
 404          }
 405          else {
 406             /* store GLchan table */
 407             table->FloatTable = GL_FALSE;
 408             table->Table = MALLOC(comps * width * sizeof(GLchan));
 409             if (!table->Table) {
 410                _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
 411                return;
 412             }
 413             _mesa_unpack_chan_color_span(ctx, width, table->Format,
 414                                          (GLchan *) table->Table,  /* dest */
 415                                          format, type, data,
 416                                          &ctx->Unpack, 0);
 417          } /* floatTable */
 418       } /* width > 0 */
 419    } /* proxy */
 420
 421    if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
 422       /* texture object palette, texObj==NULL means the shared palette */
 423       if (ctx->Driver.UpdateTexturePalette) {
 424          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
 425       }
 426    }
 427
 428    ctx->NewState |= _NEW_PIXEL;
 429 }
 430
 431
 432
 433 void
 434 _mesa_ColorSubTable( GLenum target, GLsizei start,
 435                      GLsizei count, GLenum format, GLenum type,
 436                      const GLvoid *data )
 437 {
 438    GET_CURRENT_CONTEXT(ctx);
 439    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 440    struct gl_texture_object *texObj = NULL;
 441    struct gl_color_table *table = NULL;
 442    GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0;
 443    GLfloat rBias  = 0.0, gBias  = 0.0, bBias  = 0.0, aBias  = 0.0;
 444    GLint comps;
 445    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 446
 447    switch (target) {
 448       case GL_TEXTURE_1D:
 449          texObj = texUnit->Current1D;
 450          table = &texObj->Palette;
 451          break;
 452       case GL_TEXTURE_2D:
 453          texObj = texUnit->Current2D;
 454          table = &texObj->Palette;
 455          break;
 456       case GL_TEXTURE_3D:
 457          texObj = texUnit->Current3D;
 458          table = &texObj->Palette;
 459          break;
 460       case GL_SHARED_TEXTURE_PALETTE_EXT:
 461          table = &ctx->Texture.Palette;
 462          break;
 463       case GL_COLOR_TABLE:
 464          table = &ctx->ColorTable;
 465          rScale = ctx->Pixel.ColorTableScale[0];
 466          gScale = ctx->Pixel.ColorTableScale[1];
 467          bScale = ctx->Pixel.ColorTableScale[2];
 468          aScale = ctx->Pixel.ColorTableScale[3];
 469          rBias = ctx->Pixel.ColorTableBias[0];
 470          gBias = ctx->Pixel.ColorTableBias[1];
 471          bBias = ctx->Pixel.ColorTableBias[2];
 472          aBias = ctx->Pixel.ColorTableBias[3];
 473          break;
 474       case GL_POST_CONVOLUTION_COLOR_TABLE:
 475          table = &ctx->PostConvolutionColorTable;
 476          rScale = ctx->Pixel.PCCTscale[0];
 477          gScale = ctx->Pixel.PCCTscale[1];
 478          bScale = ctx->Pixel.PCCTscale[2];
 479          aScale = ctx->Pixel.PCCTscale[3];
 480          rBias = ctx->Pixel.PCCTbias[0];
 481          gBias = ctx->Pixel.PCCTbias[1];
 482          bBias = ctx->Pixel.PCCTbias[2];
 483          aBias = ctx->Pixel.PCCTbias[3];
 484          break;
 485       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 486          table = &ctx->PostColorMatrixColorTable;
 487          rScale = ctx->Pixel.PCMCTscale[0];
 488          gScale = ctx->Pixel.PCMCTscale[1];
 489          bScale = ctx->Pixel.PCMCTscale[2];
 490          aScale = ctx->Pixel.PCMCTscale[3];
 491          rBias = ctx->Pixel.PCMCTbias[0];
 492          gBias = ctx->Pixel.PCMCTbias[1];
 493          bBias = ctx->Pixel.PCMCTbias[2];
 494          aBias = ctx->Pixel.PCMCTbias[3];
 495          break;
 496       default:
 497          _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
 498          return;
 499    }
 500
 501    assert(table);
 502
 503    if (!_mesa_is_legal_format_and_type(format, type) ||
 504        format == GL_INTENSITY) {
 505       _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)");
 506       return;
 507    }
 508
 509    if (count < 1) {
 510       _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
 511       return;
 512    }
 513
 514    comps = _mesa_components_in_format(table->Format);
 515    assert(comps > 0);  /* error should have been caught sooner */
 516
 517    if (start + count > (GLint) table->Size) {
 518       _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
 519       return;
 520    }
 521
 522    if (!table->Table) {
 523       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable");
 524       return;
 525    }
 526
 527    if (!table->FloatTable) {
 528       GLchan *dest = (GLchan *) table->Table + start * comps * sizeof(GLchan);
 529       _mesa_unpack_chan_color_span(ctx, count, table->Format, dest,
 530                                    format, type, data, &ctx->Unpack, 0);
 531    }
 532    else {
 533       GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
 534       GLfloat *tableF;
 535       GLint i;
 536
 537       ASSERT(table->FloatTable);
 538
 539       _mesa_unpack_float_color_span(ctx, count, table->Format,
 540                                     tempTab,  /* dest */
 541                                     format, type, data, &ctx->Unpack,
 542                                     0, GL_FALSE);
 543
 544       tableF = (GLfloat *) table->Table;
 545
 546       switch (table->Format) {
 547          case GL_INTENSITY:
 548             for (i = 0; i < count; i++) {
 549                GLuint j = start + i;
 550                tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
 551             }
 552             break;
 553          case GL_LUMINANCE:
 554             for (i = 0; i < count; i++) {
 555                GLuint j = start + i;
 556                tableF[j] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
 557             }
 558             break;
 559          case GL_ALPHA:
 560             for (i = 0; i < count; i++) {
 561                GLuint j = start + i;
 562                tableF[j] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);
 563             }
 564             break;
 565          case GL_LUMINANCE_ALPHA:
 566             for (i = 0; i < count; i++) {
 567                GLuint j = start + i;
 568                tableF[j*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);
 569                tableF[j*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);
 570             }
 571             break;
 572          case GL_RGB:
 573             for (i = 0; i < count; i++) {
 574                GLuint j = start + i;
 575                tableF[j*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);
 576                tableF[j*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);
 577                tableF[j*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);
 578             }
 579             break;
 580          case GL_RGBA:
 581             for (i = 0; i < count; i++) {
 582                GLuint j = start + i;
 583                tableF[j*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);
 584                tableF[j*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);
 585                tableF[j*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);
 586                tableF[j*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);
 587             }
 588             break;
 589          default:
 590             _mesa_problem(ctx, "Bad format in _mesa_ColorSubTable");
 591             return;
 592          }
 593    }
 594
 595    if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
 596       /* per-texture object palette */
 597       if (ctx->Driver.UpdateTexturePalette) {
 598          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
 599       }
 600    }
 601
 602    ctx->NewState |= _NEW_PIXEL;
 603 }
 604
 605
 606
 607 /* XXX not tested */
 608 void
 609 _mesa_CopyColorTable(GLenum target, GLenum internalformat,
 610                      GLint x, GLint y, GLsizei width)
 611 {
 612    GLchan data[MAX_WIDTH][4];
 613    GET_CURRENT_CONTEXT(ctx);
 614    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 615
 616    /* Select buffer to read from */
 617    (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 618                                  ctx->Pixel.DriverReadBuffer );
 619
 620    if (width > MAX_WIDTH)
 621       width = MAX_WIDTH;
 622
 623    /* read the data from framebuffer */
 624    RENDER_START(ctx);
 625    _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
 626    RENDER_FINISH(ctx);
 627
 628    /* Restore reading from draw buffer (the default) */
 629    (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 630                                  ctx->Color.DriverDrawBuffer );
 631
 632    _mesa_ColorTable(target, internalformat, width,
 633                     GL_RGBA, GL_UNSIGNED_BYTE, data);
 634 }
 635
 636
 637
 638 /* XXX not tested */
 639 void
 640 _mesa_CopyColorSubTable(GLenum target, GLsizei start,
 641                         GLint x, GLint y, GLsizei width)
 642 {
 643    GLchan data[MAX_WIDTH][4];
 644    GET_CURRENT_CONTEXT(ctx);
 645    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 646
 647    /* Select buffer to read from */
 648    (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
 649                                  ctx->Pixel.DriverReadBuffer );
 650
 651    if (width > MAX_WIDTH)
 652       width = MAX_WIDTH;
 653
 654    /* read the data from framebuffer */
 655    RENDER_START(ctx);
 656    _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
 657    RENDER_FINISH(ctx);
 658
 659    /* Restore reading from draw buffer (the default) */
 660    (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
 661                                  ctx->Color.DriverDrawBuffer );
 662
 663    _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data);
 664 }
 665
 666
 667
 668 void
 669 _mesa_GetColorTable( GLenum target, GLenum format,
 670                      GLenum type, GLvoid *data )
 671 {
 672    GET_CURRENT_CONTEXT(ctx);
 673    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 674    struct gl_color_table *table = NULL;
 675    GLchan rgba[MAX_COLOR_TABLE_SIZE][4];
 676    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 677
 678    if (ctx->NewState) {
 679       _mesa_update_state(ctx);
 680    }
 681
 682    switch (target) {
 683       case GL_TEXTURE_1D:
 684          table = &texUnit->Current1D->Palette;
 685          break;
 686       case GL_TEXTURE_2D:
 687          table = &texUnit->Current2D->Palette;
 688          break;
 689       case GL_TEXTURE_3D:
 690          table = &texUnit->Current3D->Palette;
 691          break;
 692       case GL_SHARED_TEXTURE_PALETTE_EXT:
 693          table = &ctx->Texture.Palette;
 694          break;
 695       case GL_COLOR_TABLE:
 696          table = &ctx->ColorTable;
 697          break;
 698       case GL_POST_CONVOLUTION_COLOR_TABLE:
 699          table = &ctx->PostConvolutionColorTable;
 700          break;
 701       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
 702          table = &ctx->PostColorMatrixColorTable;
 703          break;
 704       default:
 705          _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
 706          return;
 707    }
 708
 709    assert(table);
 710
 711    switch (table->Format) {
 712       case GL_ALPHA:
 713          if (table->FloatTable) {
 714             const GLfloat *tableF = (const GLfloat *) table->Table;
 715             GLuint i;
 716             for (i = 0; i < table->Size; i++) {
 717                rgba[i][RCOMP] = 0;
 718                rgba[i][GCOMP] = 0;
 719                rgba[i][BCOMP] = 0;
 720                rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 721             }
 722          }
 723          else {
 724             const GLchan *tableUB = (const GLchan *) table->Table;
 725             GLuint i;
 726             for (i = 0; i < table->Size; i++) {
 727                rgba[i][RCOMP] = 0;
 728                rgba[i][GCOMP] = 0;
 729                rgba[i][BCOMP] = 0;
 730                rgba[i][ACOMP] = tableUB[i];
 731             }
 732          }
 733          break;
 734       case GL_LUMINANCE:
 735          if (table->FloatTable) {
 736             const GLfloat *tableF = (const GLfloat *) table->Table;
 737             GLuint i;
 738             for (i = 0; i < table->Size; i++) {
 739                rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 740                rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 741                rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 742                rgba[i][ACOMP] = CHAN_MAX;
 743             }
 744          }
 745          else {
 746             const GLchan *tableUB = (const GLchan *) table->Table;
 747             GLuint i;
 748             for (i = 0; i < table->Size; i++) {
 749                rgba[i][RCOMP] = tableUB[i];
 750                rgba[i][GCOMP] = tableUB[i];
 751                rgba[i][BCOMP] = tableUB[i];
 752                rgba[i][ACOMP] = CHAN_MAX;
 753             }
 754          }
 755          break;
 756       case GL_LUMINANCE_ALPHA:
 757          if (table->FloatTable) {
 758             const GLfloat *tableF = (const GLfloat *) table->Table;
 759             GLuint i;
 760             for (i = 0; i < table->Size; i++) {
 761                rgba[i][RCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF);
 762                rgba[i][GCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF);
 763                rgba[i][BCOMP] = (GLint) (tableF[i*2+0] * CHAN_MAXF);
 764                rgba[i][ACOMP] = (GLint) (tableF[i*2+1] * CHAN_MAXF);
 765             }
 766          }
 767          else {
 768             const GLchan *tableUB = (const GLchan *) table->Table;
 769             GLuint i;
 770             for (i = 0; i < table->Size; i++) {
 771                rgba[i][RCOMP] = tableUB[i*2+0];
 772                rgba[i][GCOMP] = tableUB[i*2+0];
 773                rgba[i][BCOMP] = tableUB[i*2+0];
 774                rgba[i][ACOMP] = tableUB[i*2+1];
 775             }
 776          }
 777          break;
 778       case GL_INTENSITY:
 779          if (table->FloatTable) {
 780             const GLfloat *tableF = (const GLfloat *) table->Table;
 781             GLuint i;
 782             for (i = 0; i < table->Size; i++) {
 783                rgba[i][RCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 784                rgba[i][GCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 785                rgba[i][BCOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 786                rgba[i][ACOMP] = (GLint) (tableF[i] * CHAN_MAXF);
 787             }
 788          }
 789          else {
 790             const GLchan *tableUB = (const GLchan *) table->Table;
 791             GLuint i;
 792             for (i = 0; i < table->Size; i++) {
 793                rgba[i][RCOMP] = tableUB[i];
 794                rgba[i][GCOMP] = tableUB[i];
 795                rgba[i][BCOMP] = tableUB[i];
 796                rgba[i][ACOMP] = tableUB[i];
 797             }
 798          }
 799          break;
 800       case GL_RGB:
 801          if (table->FloatTable) {
 802             const GLfloat *tableF = (const GLfloat *) table->Table;
 803             GLuint i;
 804             for (i = 0; i < table->Size; i++) {
 805                rgba[i][RCOMP] = (GLint) (tableF[i*3+0] * CHAN_MAXF);
 806                rgba[i][GCOMP] = (GLint) (tableF[i*3+1] * CHAN_MAXF);
 807                rgba[i][BCOMP] = (GLint) (tableF[i*3+2] * CHAN_MAXF);
 808                rgba[i][ACOMP] = CHAN_MAX;
 809             }
 810          }
 811          else {
 812             const GLchan *tableUB = (const GLchan *) table->Table;
 813             GLuint i;
 814             for (i = 0; i < table->Size; i++) {
 815                rgba[i][RCOMP] = tableUB[i*3+0];
 816                rgba[i][GCOMP] = tableUB[i*3+1];
 817                rgba[i][BCOMP] = tableUB[i*3+2];
 818                rgba[i][ACOMP] = CHAN_MAX;
 819             }
 820          }
 821          break;
 822       case GL_RGBA:
 823          if (table->FloatTable) {
 824             const GLfloat *tableF = (const GLfloat *) table->Table;
 825             GLuint i;
 826             for (i = 0; i < table->Size; i++) {
 827                rgba[i][RCOMP] = (GLint) (tableF[i*4+0] * CHAN_MAXF + 0.5F);
 828                rgba[i][GCOMP] = (GLint) (tableF[i*4+1] * CHAN_MAXF + 0.5F);
 829                rgba[i][BCOMP] = (GLint) (tableF[i*4+2] * CHAN_MAXF + 0.5F);
 830                rgba[i][ACOMP] = (GLint) (tableF[i*4+3] * CHAN_MAXF + 0.5F);
 831             }
 832          }
 833          else {
 834             const GLchan *tableUB = (const GLchan *) table->Table;
 835             GLuint i;
 836             for (i = 0; i < table->Size; i++) {
 837                rgba[i][RCOMP] = tableUB[i*4+0];
 838                rgba[i][GCOMP] = tableUB[i*4+1];
 839                rgba[i][BCOMP] = tableUB[i*4+2];
 840                rgba[i][ACOMP] = tableUB[i*4+3];
 841             }
 842          }
 843          break;
 844       default:
 845          _mesa_problem(ctx, "bad table format in glGetColorTable");
 846          return;
 847    }
 848
 849    _mesa_pack_rgba_span(ctx, table->Size, (const GLchan (*)[]) rgba,
 850                         format, type, data, &ctx->Pack, GL_FALSE);
 851 }
 852
 853
 854
 855 void
 856 _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 857 {
 858    GET_CURRENT_CONTEXT(ctx);
 859    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 860
 861    switch (target) {
 862       case GL_COLOR_TABLE_SGI:
 863          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 864             ctx->Pixel.ColorTableScale[0] = params[0];
 865             ctx->Pixel.ColorTableScale[1] = params[1];
 866             ctx->Pixel.ColorTableScale[2] = params[2];
 867             ctx->Pixel.ColorTableScale[3] = params[3];
 868          }
 869          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 870             ctx->Pixel.ColorTableBias[0] = params[0];
 871             ctx->Pixel.ColorTableBias[1] = params[1];
 872             ctx->Pixel.ColorTableBias[2] = params[2];
 873             ctx->Pixel.ColorTableBias[3] = params[3];
 874          }
 875          else {
 876             _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 877             return;
 878          }
 879          break;
 880       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 881          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 882             ctx->Pixel.PCCTscale[0] = params[0];
 883             ctx->Pixel.PCCTscale[1] = params[1];
 884             ctx->Pixel.PCCTscale[2] = params[2];
 885             ctx->Pixel.PCCTscale[3] = params[3];
 886          }
 887          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 888             ctx->Pixel.PCCTbias[0] = params[0];
 889             ctx->Pixel.PCCTbias[1] = params[1];
 890             ctx->Pixel.PCCTbias[2] = params[2];
 891             ctx->Pixel.PCCTbias[3] = params[3];
 892          }
 893          else {
 894             _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 895             return;
 896          }
 897          break;
 898       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 899          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 900             ctx->Pixel.PCMCTscale[0] = params[0];
 901             ctx->Pixel.PCMCTscale[1] = params[1];
 902             ctx->Pixel.PCMCTscale[2] = params[2];
 903             ctx->Pixel.PCMCTscale[3] = params[3];
 904          }
 905          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 906             ctx->Pixel.PCMCTbias[0] = params[0];
 907             ctx->Pixel.PCMCTbias[1] = params[1];
 908             ctx->Pixel.PCMCTbias[2] = params[2];
 909             ctx->Pixel.PCMCTbias[3] = params[3];
 910          }
 911          else {
 912             _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
 913             return;
 914          }
 915          break;
 916       default:
 917          _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)");
 918          return;
 919    }
 920
 921    ctx->NewState |= _NEW_PIXEL;
 922 }
 923
 924
 925
 926 void
 927 _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 928 {
 929    GLfloat fparams[4];
 930    if (pname == GL_COLOR_TABLE_SGI ||
 931        pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
 932        pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
 933       /* four values */
 934       fparams[0] = (GLfloat) params[0];
 935       fparams[1] = (GLfloat) params[1];
 936       fparams[2] = (GLfloat) params[2];
 937       fparams[3] = (GLfloat) params[3];
 938    }
 939    else {
 940       /* one values */
 941       fparams[0] = (GLfloat) params[0];
 942    }
 943    _mesa_ColorTableParameterfv(target, pname, fparams);
 944 }
 945
 946
 947
 948 void
 949 _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
 950 {
 951    GET_CURRENT_CONTEXT(ctx);
 952    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 953    struct gl_color_table *table = NULL;
 954    ASSERT_OUTSIDE_BEGIN_END(ctx);
 955
 956    switch (target) {
 957       case GL_TEXTURE_1D:
 958          table = &texUnit->Current1D->Palette;
 959          break;
 960       case GL_TEXTURE_2D:
 961          table = &texUnit->Current2D->Palette;
 962          break;
 963       case GL_TEXTURE_3D:
 964          table = &texUnit->Current3D->Palette;
 965          break;
 966       case GL_PROXY_TEXTURE_1D:
 967          table = &ctx->Texture.Proxy1D->Palette;
 968          break;
 969       case GL_PROXY_TEXTURE_2D:
 970          table = &ctx->Texture.Proxy2D->Palette;
 971          break;
 972       case GL_PROXY_TEXTURE_3D:
 973          table = &ctx->Texture.Proxy3D->Palette;
 974          break;
 975       case GL_SHARED_TEXTURE_PALETTE_EXT:
 976          table = &ctx->Texture.Palette;
 977          break;
 978       case GL_COLOR_TABLE:
 979          table = &ctx->ColorTable;
 980          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
 981             params[0] = ctx->Pixel.ColorTableScale[0];
 982             params[1] = ctx->Pixel.ColorTableScale[1];
 983             params[2] = ctx->Pixel.ColorTableScale[2];
 984             params[3] = ctx->Pixel.ColorTableScale[3];
 985             return;
 986          }
 987          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
 988             params[0] = ctx->Pixel.ColorTableBias[0];
 989             params[1] = ctx->Pixel.ColorTableBias[1];
 990             params[2] = ctx->Pixel.ColorTableBias[2];
 991             params[3] = ctx->Pixel.ColorTableBias[3];
 992             return;
 993          }
 994          break;
 995       case GL_PROXY_COLOR_TABLE:
 996          table = &ctx->ProxyColorTable;
 997          break;
 998       case GL_POST_CONVOLUTION_COLOR_TABLE:
 999          table = &ctx->PostConvolutionColorTable;
1000          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1001             params[0] = ctx->Pixel.PCCTscale[0];
1002             params[1] = ctx->Pixel.PCCTscale[1];
1003             params[2] = ctx->Pixel.PCCTscale[2];
1004             params[3] = ctx->Pixel.PCCTscale[3];
1005             return;
1006          }
1007          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1008             params[0] = ctx->Pixel.PCCTbias[0];
1009             params[1] = ctx->Pixel.PCCTbias[1];
1010             params[2] = ctx->Pixel.PCCTbias[2];
1011             params[3] = ctx->Pixel.PCCTbias[3];
1012             return;
1013          }
1014          break;
1015       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
1016          table = &ctx->ProxyPostConvolutionColorTable;
1017          break;
1018       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
1019          table = &ctx->PostColorMatrixColorTable;
1020          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1021             params[0] = ctx->Pixel.PCMCTscale[0];
1022             params[1] = ctx->Pixel.PCMCTscale[1];
1023             params[2] = ctx->Pixel.PCMCTscale[2];
1024             params[3] = ctx->Pixel.PCMCTscale[3];
1025             return;
1026          }
1027          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1028             params[0] = ctx->Pixel.PCMCTbias[0];
1029             params[1] = ctx->Pixel.PCMCTbias[1];
1030             params[2] = ctx->Pixel.PCMCTbias[2];
1031             params[3] = ctx->Pixel.PCMCTbias[3];
1032             return;
1033          }
1034          break;
1035       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
1036          table = &ctx->ProxyPostColorMatrixColorTable;
1037          break;
1038       default:
1039          _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)");
1040          return;
1041    }
1042
1043    assert(table);
1044
1045    switch (pname) {
1046       case GL_COLOR_TABLE_FORMAT:
1047          *params = table->IntFormat;
1048          break;
1049       case GL_COLOR_TABLE_WIDTH:
1050          *params = table->Size;
1051          break;
1052       case GL_COLOR_TABLE_RED_SIZE:
1053          *params = table->RedSize;
1054          break;
1055       case GL_COLOR_TABLE_GREEN_SIZE:
1056          *params = table->GreenSize;
1057          break;
1058       case GL_COLOR_TABLE_BLUE_SIZE:
1059          *params = table->BlueSize;
1060          break;
1061       case GL_COLOR_TABLE_ALPHA_SIZE:
1062          *params = table->AlphaSize;
1063          break;
1064       case GL_COLOR_TABLE_LUMINANCE_SIZE:
1065          *params = table->LuminanceSize;
1066          break;
1067       case GL_COLOR_TABLE_INTENSITY_SIZE:
1068          *params = table->IntensitySize;
1069          break;
1070       default:
1071          _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
1072          return;
1073    }
1074 }
1075
1076
1077
1078 void
1079 _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
1080 {
1081    GET_CURRENT_CONTEXT(ctx);
1082    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1083    struct gl_color_table *table = NULL;
1084    ASSERT_OUTSIDE_BEGIN_END(ctx);
1085
1086    switch (target) {
1087       case GL_TEXTURE_1D:
1088          table = &texUnit->Current1D->Palette;
1089          break;
1090       case GL_TEXTURE_2D:
1091          table = &texUnit->Current2D->Palette;
1092          break;
1093       case GL_TEXTURE_3D:
1094          table = &texUnit->Current3D->Palette;
1095          break;
1096       case GL_PROXY_TEXTURE_1D:
1097          table = &ctx->Texture.Proxy1D->Palette;
1098          break;
1099       case GL_PROXY_TEXTURE_2D:
1100          table = &ctx->Texture.Proxy2D->Palette;
1101          break;
1102       case GL_PROXY_TEXTURE_3D:
1103          table = &ctx->Texture.Proxy3D->Palette;
1104          break;
1105       case GL_SHARED_TEXTURE_PALETTE_EXT:
1106          table = &ctx->Texture.Palette;
1107          break;
1108       case GL_COLOR_TABLE:
1109          table = &ctx->ColorTable;
1110          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1111             params[0] = (GLint) ctx->Pixel.ColorTableScale[0];
1112             params[1] = (GLint) ctx->Pixel.ColorTableScale[1];
1113             params[2] = (GLint) ctx->Pixel.ColorTableScale[2];
1114             params[3] = (GLint) ctx->Pixel.ColorTableScale[3];
1115             return;
1116          }
1117          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1118             params[0] = (GLint) ctx->Pixel.ColorTableBias[0];
1119             params[1] = (GLint) ctx->Pixel.ColorTableBias[1];
1120             params[2] = (GLint) ctx->Pixel.ColorTableBias[2];
1121             params[3] = (GLint) ctx->Pixel.ColorTableBias[3];
1122             return;
1123          }
1124          break;
1125       case GL_PROXY_COLOR_TABLE:
1126          table = &ctx->ProxyColorTable;
1127          break;
1128       case GL_POST_CONVOLUTION_COLOR_TABLE:
1129          table = &ctx->PostConvolutionColorTable;
1130          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1131             params[0] = (GLint) ctx->Pixel.PCCTscale[0];
1132             params[1] = (GLint) ctx->Pixel.PCCTscale[1];
1133             params[2] = (GLint) ctx->Pixel.PCCTscale[2];
1134             params[3] = (GLint) ctx->Pixel.PCCTscale[3];
1135             return;
1136          }
1137          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1138             params[0] = (GLint) ctx->Pixel.PCCTbias[0];
1139             params[1] = (GLint) ctx->Pixel.PCCTbias[1];
1140             params[2] = (GLint) ctx->Pixel.PCCTbias[2];
1141             params[3] = (GLint) ctx->Pixel.PCCTbias[3];
1142             return;
1143          }
1144          break;
1145       case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
1146          table = &ctx->ProxyPostConvolutionColorTable;
1147          break;
1148       case GL_POST_COLOR_MATRIX_COLOR_TABLE:
1149          table = &ctx->PostColorMatrixColorTable;
1150          if (pname == GL_COLOR_TABLE_SCALE_SGI) {
1151             params[0] = (GLint) ctx->Pixel.PCMCTscale[0];
1152             params[1] = (GLint) ctx->Pixel.PCMCTscale[1];
1153             params[2] = (GLint) ctx->Pixel.PCMCTscale[2];
1154             params[3] = (GLint) ctx->Pixel.PCMCTscale[3];
1155             return;
1156          }
1157          else if (pname == GL_COLOR_TABLE_BIAS_SGI) {
1158             params[0] = (GLint) ctx->Pixel.PCMCTbias[0];
1159             params[1] = (GLint) ctx->Pixel.PCMCTbias[1];
1160             params[2] = (GLint) ctx->Pixel.PCMCTbias[2];
1161             params[3] = (GLint) ctx->Pixel.PCMCTbias[3];
1162             return;
1163          }
1164          break;
1165       case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
1166          table = &ctx->ProxyPostColorMatrixColorTable;
1167          break;
1168       default:
1169          _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)");
1170          return;
1171    }
1172
1173    assert(table);
1174
1175    switch (pname) {
1176       case GL_COLOR_TABLE_FORMAT:
1177          *params = table->IntFormat;
1178          break;
1179       case GL_COLOR_TABLE_WIDTH:
1180          *params = table->Size;
1181          break;
1182       case GL_COLOR_TABLE_RED_SIZE:
1183          *params = table->RedSize;
1184          break;
1185       case GL_COLOR_TABLE_GREEN_SIZE:
1186          *params = table->GreenSize;
1187          break;
1188       case GL_COLOR_TABLE_BLUE_SIZE:
1189          *params = table->BlueSize;
1190          break;
1191       case GL_COLOR_TABLE_ALPHA_SIZE:
1192          *params = table->AlphaSize;
1193          break;
1194       case GL_COLOR_TABLE_LUMINANCE_SIZE:
1195          *params = table->LuminanceSize;
1196          break;
1197       case GL_COLOR_TABLE_INTENSITY_SIZE:
1198          *params = table->IntensitySize;
1199          break;
1200       default:
1201          _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
1202          return;
1203    }
1204 }