src/mesa/main/colortab.c

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