src/mesa/main/colortab.c

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