src/mesa/main/colortab.c

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