src/mesa/main/colortab.c

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