src/mesa/main/glformats.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (c) 2008-2009  VMware, Inc.
   6  * Copyright (c) 2012 Intel Corporation
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  * OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #include "context.h"
  29 #include "glformats.h"
  30
  31
  32 /**
  33  * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
  34  */
  35 GLboolean
  36 _mesa_type_is_packed(GLenum type)
  37 {
  38    switch (type) {
  39    case GL_UNSIGNED_BYTE_3_3_2:
  40    case GL_UNSIGNED_BYTE_2_3_3_REV:
  41    case MESA_UNSIGNED_BYTE_4_4:
  42    case GL_UNSIGNED_SHORT_5_6_5:
  43    case GL_UNSIGNED_SHORT_5_6_5_REV:
  44    case GL_UNSIGNED_SHORT_4_4_4_4:
  45    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
  46    case GL_UNSIGNED_SHORT_5_5_5_1:
  47    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
  48    case GL_UNSIGNED_INT_8_8_8_8:
  49    case GL_UNSIGNED_INT_8_8_8_8_REV:
  50    case GL_UNSIGNED_INT_10_10_10_2:
  51    case GL_UNSIGNED_INT_2_10_10_10_REV:
  52    case GL_UNSIGNED_SHORT_8_8_MESA:
  53    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
  54    case GL_UNSIGNED_INT_24_8_EXT:
  55    case GL_UNSIGNED_INT_5_9_9_9_REV:
  56    case GL_UNSIGNED_INT_10F_11F_11F_REV:
  57    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  58       return GL_TRUE;
  59    }
  60
  61    return GL_FALSE;
  62 }
  63
  64
  65 /**
  66  * Get the size of a GL data type.
  67  *
  68  * \param type GL data type.
  69  *
  70  * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
  71  * if an invalid type enum.
  72  */
  73 GLint
  74 _mesa_sizeof_type(GLenum type)
  75 {
  76    switch (type) {
  77    case GL_BITMAP:
  78       return 0;
  79    case GL_UNSIGNED_BYTE:
  80       return sizeof(GLubyte);
  81    case GL_BYTE:
  82       return sizeof(GLbyte);
  83    case GL_UNSIGNED_SHORT:
  84       return sizeof(GLushort);
  85    case GL_SHORT:
  86       return sizeof(GLshort);
  87    case GL_UNSIGNED_INT:
  88       return sizeof(GLuint);
  89    case GL_INT:
  90       return sizeof(GLint);
  91    case GL_FLOAT:
  92       return sizeof(GLfloat);
  93    case GL_DOUBLE:
  94       return sizeof(GLdouble);
  95    case GL_HALF_FLOAT_ARB:
  96       return sizeof(GLhalfARB);
  97    case GL_FIXED:
  98       return sizeof(GLfixed);
  99    default:
 100       return -1;
 101    }
 102 }
 103
 104
 105 /**
 106  * Same as _mesa_sizeof_type() but also accepting the packed pixel
 107  * format data types.
 108  */
 109 GLint
 110 _mesa_sizeof_packed_type(GLenum type)
 111 {
 112    switch (type) {
 113    case GL_BITMAP:
 114       return 0;
 115    case GL_UNSIGNED_BYTE:
 116       return sizeof(GLubyte);
 117    case GL_BYTE:
 118       return sizeof(GLbyte);
 119    case GL_UNSIGNED_SHORT:
 120       return sizeof(GLushort);
 121    case GL_SHORT:
 122       return sizeof(GLshort);
 123    case GL_UNSIGNED_INT:
 124       return sizeof(GLuint);
 125    case GL_INT:
 126       return sizeof(GLint);
 127    case GL_HALF_FLOAT_ARB:
 128       return sizeof(GLhalfARB);
 129    case GL_FLOAT:
 130       return sizeof(GLfloat);
 131    case GL_UNSIGNED_BYTE_3_3_2:
 132    case GL_UNSIGNED_BYTE_2_3_3_REV:
 133    case MESA_UNSIGNED_BYTE_4_4:
 134       return sizeof(GLubyte);
 135    case GL_UNSIGNED_SHORT_5_6_5:
 136    case GL_UNSIGNED_SHORT_5_6_5_REV:
 137    case GL_UNSIGNED_SHORT_4_4_4_4:
 138    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 139    case GL_UNSIGNED_SHORT_5_5_5_1:
 140    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 141    case GL_UNSIGNED_SHORT_8_8_MESA:
 142    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 143       return sizeof(GLushort);
 144    case GL_UNSIGNED_INT_8_8_8_8:
 145    case GL_UNSIGNED_INT_8_8_8_8_REV:
 146    case GL_UNSIGNED_INT_10_10_10_2:
 147    case GL_UNSIGNED_INT_2_10_10_10_REV:
 148    case GL_UNSIGNED_INT_24_8_EXT:
 149    case GL_UNSIGNED_INT_5_9_9_9_REV:
 150    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 151       return sizeof(GLuint);
 152    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 153       return 8;
 154    default:
 155       return -1;
 156    }
 157 }
 158
 159
 160 /**
 161  * Get the number of components in a pixel format.
 162  *
 163  * \param format pixel format.
 164  *
 165  * \return the number of components in the given format, or -1 if a bad format.
 166  */
 167 GLint
 168 _mesa_components_in_format(GLenum format)
 169 {
 170    switch (format) {
 171    case GL_COLOR_INDEX:
 172    case GL_STENCIL_INDEX:
 173    case GL_DEPTH_COMPONENT:
 174    case GL_RED:
 175    case GL_RED_INTEGER_EXT:
 176    case GL_GREEN:
 177    case GL_GREEN_INTEGER_EXT:
 178    case GL_BLUE:
 179    case GL_BLUE_INTEGER_EXT:
 180    case GL_ALPHA:
 181    case GL_ALPHA_INTEGER_EXT:
 182    case GL_LUMINANCE:
 183    case GL_LUMINANCE_INTEGER_EXT:
 184    case GL_INTENSITY:
 185       return 1;
 186
 187    case GL_LUMINANCE_ALPHA:
 188    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 189    case GL_RG:
 190    case GL_YCBCR_MESA:
 191    case GL_DEPTH_STENCIL_EXT:
 192    case GL_DUDV_ATI:
 193    case GL_DU8DV8_ATI:
 194    case GL_RG_INTEGER:
 195       return 2;
 196
 197    case GL_RGB:
 198    case GL_BGR:
 199    case GL_RGB_INTEGER_EXT:
 200    case GL_BGR_INTEGER_EXT:
 201       return 3;
 202
 203    case GL_RGBA:
 204    case GL_BGRA:
 205    case GL_ABGR_EXT:
 206    case GL_RGBA_INTEGER_EXT:
 207    case GL_BGRA_INTEGER_EXT:
 208       return 4;
 209
 210    default:
 211       return -1;
 212    }
 213 }
 214
 215
 216 /**
 217  * Get the bytes per pixel of pixel format type pair.
 218  *
 219  * \param format pixel format.
 220  * \param type pixel type.
 221  *
 222  * \return bytes per pixel, or -1 if a bad format or type was given.
 223  */
 224 GLint
 225 _mesa_bytes_per_pixel(GLenum format, GLenum type)
 226 {
 227    GLint comps = _mesa_components_in_format(format);
 228    if (comps < 0)
 229       return -1;
 230
 231    switch (type) {
 232    case GL_BITMAP:
 233       return 0;  /* special case */
 234    case GL_BYTE:
 235    case GL_UNSIGNED_BYTE:
 236       return comps * sizeof(GLubyte);
 237    case GL_SHORT:
 238    case GL_UNSIGNED_SHORT:
 239       return comps * sizeof(GLshort);
 240    case GL_INT:
 241    case GL_UNSIGNED_INT:
 242       return comps * sizeof(GLint);
 243    case GL_FLOAT:
 244       return comps * sizeof(GLfloat);
 245    case GL_HALF_FLOAT_ARB:
 246       return comps * sizeof(GLhalfARB);
 247    case GL_UNSIGNED_BYTE_3_3_2:
 248    case GL_UNSIGNED_BYTE_2_3_3_REV:
 249       if (format == GL_RGB || format == GL_BGR ||
 250           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 251          return sizeof(GLubyte);
 252       else
 253          return -1;  /* error */
 254    case GL_UNSIGNED_SHORT_5_6_5:
 255    case GL_UNSIGNED_SHORT_5_6_5_REV:
 256       if (format == GL_RGB || format == GL_BGR ||
 257           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 258          return sizeof(GLushort);
 259       else
 260          return -1;  /* error */
 261    case GL_UNSIGNED_SHORT_4_4_4_4:
 262    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 263    case GL_UNSIGNED_SHORT_5_5_5_1:
 264    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 265       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 266           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
 267          return sizeof(GLushort);
 268       else
 269          return -1;
 270    case GL_UNSIGNED_INT_8_8_8_8:
 271    case GL_UNSIGNED_INT_8_8_8_8_REV:
 272    case GL_UNSIGNED_INT_10_10_10_2:
 273    case GL_UNSIGNED_INT_2_10_10_10_REV:
 274       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 275           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
 276           format == GL_RGB)
 277          return sizeof(GLuint);
 278       else
 279          return -1;
 280    case GL_UNSIGNED_SHORT_8_8_MESA:
 281    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 282       if (format == GL_YCBCR_MESA)
 283          return sizeof(GLushort);
 284       else
 285          return -1;
 286    case GL_UNSIGNED_INT_24_8_EXT:
 287       if (format == GL_DEPTH_STENCIL_EXT)
 288          return sizeof(GLuint);
 289       else
 290          return -1;
 291    case GL_UNSIGNED_INT_5_9_9_9_REV:
 292       if (format == GL_RGB)
 293          return sizeof(GLuint);
 294       else
 295          return -1;
 296    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 297       if (format == GL_RGB)
 298          return sizeof(GLuint);
 299       else
 300          return -1;
 301    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 302       if (format == GL_DEPTH_STENCIL)
 303          return 8;
 304       else
 305          return -1;
 306    default:
 307       return -1;
 308    }
 309 }
 310
 311
 312 /**
 313  * Get the number of bytes for a vertex attrib with the given number of
 314  * components and type.
 315  *
 316  * \param comps number of components.
 317  * \param type data type.
 318  *
 319  * \return bytes per attribute, or -1 if a bad comps/type combination was given.
 320  */
 321 GLint
 322 _mesa_bytes_per_vertex_attrib(GLint comps, GLenum type)
 323 {
 324    switch (type) {
 325    case GL_BYTE:
 326    case GL_UNSIGNED_BYTE:
 327       return comps * sizeof(GLubyte);
 328    case GL_SHORT:
 329    case GL_UNSIGNED_SHORT:
 330       return comps * sizeof(GLshort);
 331    case GL_INT:
 332    case GL_UNSIGNED_INT:
 333       return comps * sizeof(GLint);
 334    case GL_FLOAT:
 335       return comps * sizeof(GLfloat);
 336    case GL_HALF_FLOAT_ARB:
 337       return comps * sizeof(GLhalfARB);
 338    case GL_DOUBLE:
 339       return comps * sizeof(GLdouble);
 340    case GL_FIXED:
 341       return comps * sizeof(GLfixed);
 342    case GL_INT_2_10_10_10_REV:
 343    case GL_UNSIGNED_INT_2_10_10_10_REV:
 344       if (comps == 4)
 345          return sizeof(GLuint);
 346       else
 347          return -1;
 348    default:
 349       return -1;
 350    }
 351 }
 352
 353
 354 /**
 355  * Test if the given format is an integer (non-normalized) format.
 356  */
 357 GLboolean
 358 _mesa_is_enum_format_unsigned_int(GLenum format)
 359 {
 360    switch (format) {
 361    /* specific integer formats */
 362    case GL_RGBA32UI_EXT:
 363    case GL_RGB32UI_EXT:
 364    case GL_RG32UI:
 365    case GL_R32UI:
 366    case GL_ALPHA32UI_EXT:
 367    case GL_INTENSITY32UI_EXT:
 368    case GL_LUMINANCE32UI_EXT:
 369    case GL_LUMINANCE_ALPHA32UI_EXT:
 370    case GL_RGBA16UI_EXT:
 371    case GL_RGB16UI_EXT:
 372    case GL_RG16UI:
 373    case GL_R16UI:
 374    case GL_ALPHA16UI_EXT:
 375    case GL_INTENSITY16UI_EXT:
 376    case GL_LUMINANCE16UI_EXT:
 377    case GL_LUMINANCE_ALPHA16UI_EXT:
 378    case GL_RGBA8UI_EXT:
 379    case GL_RGB8UI_EXT:
 380    case GL_RG8UI:
 381    case GL_R8UI:
 382    case GL_ALPHA8UI_EXT:
 383    case GL_INTENSITY8UI_EXT:
 384    case GL_LUMINANCE8UI_EXT:
 385    case GL_LUMINANCE_ALPHA8UI_EXT:
 386    case GL_RGB10_A2UI:
 387       return GL_TRUE;
 388    default:
 389       return GL_FALSE;
 390    }
 391 }
 392
 393
 394 /**
 395  * Test if the given format is an integer (non-normalized) format.
 396  */
 397 GLboolean
 398 _mesa_is_enum_format_signed_int(GLenum format)
 399 {
 400    switch (format) {
 401    /* generic integer formats */
 402    case GL_RED_INTEGER_EXT:
 403    case GL_GREEN_INTEGER_EXT:
 404    case GL_BLUE_INTEGER_EXT:
 405    case GL_ALPHA_INTEGER_EXT:
 406    case GL_RGB_INTEGER_EXT:
 407    case GL_RGBA_INTEGER_EXT:
 408    case GL_BGR_INTEGER_EXT:
 409    case GL_BGRA_INTEGER_EXT:
 410    case GL_LUMINANCE_INTEGER_EXT:
 411    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 412    case GL_RG_INTEGER:
 413    /* specific integer formats */
 414    case GL_RGBA32I_EXT:
 415    case GL_RGB32I_EXT:
 416    case GL_RG32I:
 417    case GL_R32I:
 418    case GL_ALPHA32I_EXT:
 419    case GL_INTENSITY32I_EXT:
 420    case GL_LUMINANCE32I_EXT:
 421    case GL_LUMINANCE_ALPHA32I_EXT:
 422    case GL_RGBA16I_EXT:
 423    case GL_RGB16I_EXT:
 424    case GL_RG16I:
 425    case GL_R16I:
 426    case GL_ALPHA16I_EXT:
 427    case GL_INTENSITY16I_EXT:
 428    case GL_LUMINANCE16I_EXT:
 429    case GL_LUMINANCE_ALPHA16I_EXT:
 430    case GL_RGBA8I_EXT:
 431    case GL_RGB8I_EXT:
 432    case GL_RG8I:
 433    case GL_R8I:
 434    case GL_ALPHA8I_EXT:
 435    case GL_INTENSITY8I_EXT:
 436    case GL_LUMINANCE8I_EXT:
 437    case GL_LUMINANCE_ALPHA8I_EXT:
 438       return GL_TRUE;
 439    default:
 440       return GL_FALSE;
 441    }
 442 }
 443
 444
 445 /**
 446  * Test if the given format is an integer (non-normalized) format.
 447  */
 448 GLboolean
 449 _mesa_is_enum_format_integer(GLenum format)
 450 {
 451    return _mesa_is_enum_format_unsigned_int(format) ||
 452           _mesa_is_enum_format_signed_int(format);
 453 }
 454
 455
 456 /**
 457  * Test if the given type is an integer (non-normalized) format.
 458  */
 459 GLboolean
 460 _mesa_is_type_integer(GLenum type)
 461 {
 462    switch (type) {
 463    case GL_INT:
 464    case GL_UNSIGNED_INT:
 465    case GL_SHORT:
 466    case GL_UNSIGNED_SHORT:
 467    case GL_BYTE:
 468    case GL_UNSIGNED_BYTE:
 469       return GL_TRUE;
 470    default:
 471       return GL_FALSE;
 472    }
 473 }
 474
 475
 476 /**
 477  * Test if the given format or type is an integer (non-normalized) format.
 478  */
 479 extern GLboolean
 480 _mesa_is_enum_format_or_type_integer(GLenum format, GLenum type)
 481 {
 482    return _mesa_is_enum_format_integer(format) || _mesa_is_type_integer(type);
 483 }
 484
 485
 486 GLboolean
 487 _mesa_is_type_unsigned(GLenum type)
 488 {
 489    switch (type) {
 490    case GL_UNSIGNED_INT:
 491    case GL_UNSIGNED_INT_8_8_8_8:
 492    case GL_UNSIGNED_INT_8_8_8_8_REV:
 493    case GL_UNSIGNED_INT_10_10_10_2:
 494    case GL_UNSIGNED_INT_2_10_10_10_REV:
 495
 496    case GL_UNSIGNED_SHORT:
 497    case GL_UNSIGNED_SHORT_4_4_4_4:
 498    case GL_UNSIGNED_SHORT_5_5_5_1:
 499    case GL_UNSIGNED_SHORT_5_6_5:
 500    case GL_UNSIGNED_SHORT_5_6_5_REV:
 501    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 502    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 503    case GL_UNSIGNED_SHORT_8_8_MESA:
 504    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 505
 506    case GL_UNSIGNED_BYTE:
 507    case GL_UNSIGNED_BYTE_3_3_2:
 508    case GL_UNSIGNED_BYTE_2_3_3_REV:
 509       return GL_TRUE;
 510
 511    default:
 512       return GL_FALSE;
 513    }
 514 }
 515
 516
 517 /**
 518  * Test if the given image format is a color/RGBA format (i.e., not color
 519  * index, depth, stencil, etc).
 520  * \param format  the image format value (may by an internal texture format)
 521  * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
 522  */
 523 GLboolean
 524 _mesa_is_color_format(GLenum format)
 525 {
 526    switch (format) {
 527       case GL_RED:
 528       case GL_GREEN:
 529       case GL_BLUE:
 530       case GL_ALPHA:
 531       case GL_ALPHA4:
 532       case GL_ALPHA8:
 533       case GL_ALPHA12:
 534       case GL_ALPHA16:
 535       case 1:
 536       case GL_LUMINANCE:
 537       case GL_LUMINANCE4:
 538       case GL_LUMINANCE8:
 539       case GL_LUMINANCE12:
 540       case GL_LUMINANCE16:
 541       case 2:
 542       case GL_LUMINANCE_ALPHA:
 543       case GL_LUMINANCE4_ALPHA4:
 544       case GL_LUMINANCE6_ALPHA2:
 545       case GL_LUMINANCE8_ALPHA8:
 546       case GL_LUMINANCE12_ALPHA4:
 547       case GL_LUMINANCE12_ALPHA12:
 548       case GL_LUMINANCE16_ALPHA16:
 549       case GL_INTENSITY:
 550       case GL_INTENSITY4:
 551       case GL_INTENSITY8:
 552       case GL_INTENSITY12:
 553       case GL_INTENSITY16:
 554       case GL_R8:
 555       case GL_R16:
 556       case GL_RG:
 557       case GL_RG8:
 558       case GL_RG16:
 559       case 3:
 560       case GL_RGB:
 561       case GL_BGR:
 562       case GL_R3_G3_B2:
 563       case GL_RGB4:
 564       case GL_RGB5:
 565       case GL_RGB565:
 566       case GL_RGB8:
 567       case GL_RGB10:
 568       case GL_RGB12:
 569       case GL_RGB16:
 570       case 4:
 571       case GL_ABGR_EXT:
 572       case GL_RGBA:
 573       case GL_BGRA:
 574       case GL_RGBA2:
 575       case GL_RGBA4:
 576       case GL_RGB5_A1:
 577       case GL_RGBA8:
 578       case GL_RGB10_A2:
 579       case GL_RGBA12:
 580       case GL_RGBA16:
 581       /* float texture formats */
 582       case GL_ALPHA16F_ARB:
 583       case GL_ALPHA32F_ARB:
 584       case GL_LUMINANCE16F_ARB:
 585       case GL_LUMINANCE32F_ARB:
 586       case GL_LUMINANCE_ALPHA16F_ARB:
 587       case GL_LUMINANCE_ALPHA32F_ARB:
 588       case GL_INTENSITY16F_ARB:
 589       case GL_INTENSITY32F_ARB:
 590       case GL_R16F:
 591       case GL_R32F:
 592       case GL_RG16F:
 593       case GL_RG32F:
 594       case GL_RGB16F_ARB:
 595       case GL_RGB32F_ARB:
 596       case GL_RGBA16F_ARB:
 597       case GL_RGBA32F_ARB:
 598       /* compressed formats */
 599       case GL_COMPRESSED_ALPHA:
 600       case GL_COMPRESSED_LUMINANCE:
 601       case GL_COMPRESSED_LUMINANCE_ALPHA:
 602       case GL_COMPRESSED_INTENSITY:
 603       case GL_COMPRESSED_RED:
 604       case GL_COMPRESSED_RG:
 605       case GL_COMPRESSED_RGB:
 606       case GL_COMPRESSED_RGBA:
 607       case GL_RGB_S3TC:
 608       case GL_RGB4_S3TC:
 609       case GL_RGBA_S3TC:
 610       case GL_RGBA4_S3TC:
 611       case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 612       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 613       case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 614       case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 615       case GL_COMPRESSED_RGB_FXT1_3DFX:
 616       case GL_COMPRESSED_RGBA_FXT1_3DFX:
 617       case GL_SRGB_EXT:
 618       case GL_SRGB8_EXT:
 619       case GL_SRGB_ALPHA_EXT:
 620       case GL_SRGB8_ALPHA8_EXT:
 621       case GL_SLUMINANCE_ALPHA_EXT:
 622       case GL_SLUMINANCE8_ALPHA8_EXT:
 623       case GL_SLUMINANCE_EXT:
 624       case GL_SLUMINANCE8_EXT:
 625       case GL_COMPRESSED_SRGB_EXT:
 626       case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 627       case GL_COMPRESSED_SRGB_ALPHA_EXT:
 628       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 629       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 630       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 631       case GL_COMPRESSED_SLUMINANCE_EXT:
 632       case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 633       case GL_COMPRESSED_RED_RGTC1:
 634       case GL_COMPRESSED_SIGNED_RED_RGTC1:
 635       case GL_COMPRESSED_RG_RGTC2:
 636       case GL_COMPRESSED_SIGNED_RG_RGTC2:
 637       case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 638       case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 639       case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 640       case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 641       case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 642       case GL_ETC1_RGB8_OES:
 643       case GL_COMPRESSED_RGB8_ETC2:
 644       case GL_COMPRESSED_SRGB8_ETC2:
 645       case GL_COMPRESSED_RGBA8_ETC2_EAC:
 646       case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 647       case GL_COMPRESSED_R11_EAC:
 648       case GL_COMPRESSED_RG11_EAC:
 649       case GL_COMPRESSED_SIGNED_R11_EAC:
 650       case GL_COMPRESSED_SIGNED_RG11_EAC:
 651       case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 652       case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 653       /* generic integer formats */
 654       case GL_RED_INTEGER_EXT:
 655       case GL_GREEN_INTEGER_EXT:
 656       case GL_BLUE_INTEGER_EXT:
 657       case GL_ALPHA_INTEGER_EXT:
 658       case GL_RGB_INTEGER_EXT:
 659       case GL_RGBA_INTEGER_EXT:
 660       case GL_BGR_INTEGER_EXT:
 661       case GL_BGRA_INTEGER_EXT:
 662       case GL_RG_INTEGER:
 663       case GL_LUMINANCE_INTEGER_EXT:
 664       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 665       /* sized integer formats */
 666       case GL_RGBA32UI_EXT:
 667       case GL_RGB32UI_EXT:
 668       case GL_RG32UI:
 669       case GL_R32UI:
 670       case GL_ALPHA32UI_EXT:
 671       case GL_INTENSITY32UI_EXT:
 672       case GL_LUMINANCE32UI_EXT:
 673       case GL_LUMINANCE_ALPHA32UI_EXT:
 674       case GL_RGBA16UI_EXT:
 675       case GL_RGB16UI_EXT:
 676       case GL_RG16UI:
 677       case GL_R16UI:
 678       case GL_ALPHA16UI_EXT:
 679       case GL_INTENSITY16UI_EXT:
 680       case GL_LUMINANCE16UI_EXT:
 681       case GL_LUMINANCE_ALPHA16UI_EXT:
 682       case GL_RGBA8UI_EXT:
 683       case GL_RGB8UI_EXT:
 684       case GL_RG8UI:
 685       case GL_R8UI:
 686       case GL_ALPHA8UI_EXT:
 687       case GL_INTENSITY8UI_EXT:
 688       case GL_LUMINANCE8UI_EXT:
 689       case GL_LUMINANCE_ALPHA8UI_EXT:
 690       case GL_RGBA32I_EXT:
 691       case GL_RGB32I_EXT:
 692       case GL_RG32I:
 693       case GL_R32I:
 694       case GL_ALPHA32I_EXT:
 695       case GL_INTENSITY32I_EXT:
 696       case GL_LUMINANCE32I_EXT:
 697       case GL_LUMINANCE_ALPHA32I_EXT:
 698       case GL_RGBA16I_EXT:
 699       case GL_RGB16I_EXT:
 700       case GL_RG16I:
 701       case GL_R16I:
 702       case GL_ALPHA16I_EXT:
 703       case GL_INTENSITY16I_EXT:
 704       case GL_LUMINANCE16I_EXT:
 705       case GL_LUMINANCE_ALPHA16I_EXT:
 706       case GL_RGBA8I_EXT:
 707       case GL_RGB8I_EXT:
 708       case GL_RG8I:
 709       case GL_R8I:
 710       case GL_ALPHA8I_EXT:
 711       case GL_INTENSITY8I_EXT:
 712       case GL_LUMINANCE8I_EXT:
 713       case GL_LUMINANCE_ALPHA8I_EXT:
 714       /* signed, normalized texture formats */
 715       case GL_RED_SNORM:
 716       case GL_R8_SNORM:
 717       case GL_R16_SNORM:
 718       case GL_RG_SNORM:
 719       case GL_RG8_SNORM:
 720       case GL_RG16_SNORM:
 721       case GL_RGB_SNORM:
 722       case GL_RGB8_SNORM:
 723       case GL_RGB16_SNORM:
 724       case GL_RGBA_SNORM:
 725       case GL_RGBA8_SNORM:
 726       case GL_RGBA16_SNORM:
 727       case GL_ALPHA_SNORM:
 728       case GL_ALPHA8_SNORM:
 729       case GL_ALPHA16_SNORM:
 730       case GL_LUMINANCE_SNORM:
 731       case GL_LUMINANCE8_SNORM:
 732       case GL_LUMINANCE16_SNORM:
 733       case GL_LUMINANCE_ALPHA_SNORM:
 734       case GL_LUMINANCE8_ALPHA8_SNORM:
 735       case GL_LUMINANCE16_ALPHA16_SNORM:
 736       case GL_INTENSITY_SNORM:
 737       case GL_INTENSITY8_SNORM:
 738       case GL_INTENSITY16_SNORM:
 739       case GL_RGB9_E5:
 740       case GL_R11F_G11F_B10F:
 741       case GL_RGB10_A2UI:
 742          return GL_TRUE;
 743       case GL_YCBCR_MESA:  /* not considered to be RGB */
 744          /* fall-through */
 745       default:
 746          return GL_FALSE;
 747    }
 748 }
 749
 750
 751 /**
 752  * Test if the given image format is a depth component format.
 753  */
 754 GLboolean
 755 _mesa_is_depth_format(GLenum format)
 756 {
 757    switch (format) {
 758       case GL_DEPTH_COMPONENT:
 759       case GL_DEPTH_COMPONENT16:
 760       case GL_DEPTH_COMPONENT24:
 761       case GL_DEPTH_COMPONENT32:
 762       case GL_DEPTH_COMPONENT32F:
 763          return GL_TRUE;
 764       default:
 765          return GL_FALSE;
 766    }
 767 }
 768
 769
 770 /**
 771  * Test if the given image format is a stencil format.
 772  */
 773 GLboolean
 774 _mesa_is_stencil_format(GLenum format)
 775 {
 776    switch (format) {
 777       case GL_STENCIL_INDEX:
 778          return GL_TRUE;
 779       default:
 780          return GL_FALSE;
 781    }
 782 }
 783
 784
 785 /**
 786  * Test if the given image format is a YCbCr format.
 787  */
 788 GLboolean
 789 _mesa_is_ycbcr_format(GLenum format)
 790 {
 791    switch (format) {
 792       case GL_YCBCR_MESA:
 793          return GL_TRUE;
 794       default:
 795          return GL_FALSE;
 796    }
 797 }
 798
 799
 800 /**
 801  * Test if the given image format is a depth+stencil format.
 802  */
 803 GLboolean
 804 _mesa_is_depthstencil_format(GLenum format)
 805 {
 806    switch (format) {
 807       case GL_DEPTH24_STENCIL8_EXT:
 808       case GL_DEPTH_STENCIL_EXT:
 809       case GL_DEPTH32F_STENCIL8:
 810          return GL_TRUE;
 811       default:
 812          return GL_FALSE;
 813    }
 814 }
 815
 816
 817 /**
 818  * Test if the given image format is a depth or stencil format.
 819  */
 820 GLboolean
 821 _mesa_is_depth_or_stencil_format(GLenum format)
 822 {
 823    switch (format) {
 824       case GL_DEPTH_COMPONENT:
 825       case GL_DEPTH_COMPONENT16:
 826       case GL_DEPTH_COMPONENT24:
 827       case GL_DEPTH_COMPONENT32:
 828       case GL_STENCIL_INDEX:
 829       case GL_STENCIL_INDEX1_EXT:
 830       case GL_STENCIL_INDEX4_EXT:
 831       case GL_STENCIL_INDEX8_EXT:
 832       case GL_STENCIL_INDEX16_EXT:
 833       case GL_DEPTH_STENCIL_EXT:
 834       case GL_DEPTH24_STENCIL8_EXT:
 835       case GL_DEPTH_COMPONENT32F:
 836       case GL_DEPTH32F_STENCIL8:
 837          return GL_TRUE;
 838       default:
 839          return GL_FALSE;
 840    }
 841 }
 842
 843
 844 /**
 845  * Test if the given image format is a dudv format.
 846  */
 847 GLboolean
 848 _mesa_is_dudv_format(GLenum format)
 849 {
 850    switch (format) {
 851       case GL_DUDV_ATI:
 852       case GL_DU8DV8_ATI:
 853          return GL_TRUE;
 854       default:
 855          return GL_FALSE;
 856    }
 857 }
 858
 859
 860 /**
 861  * Test if an image format is a supported compressed format.
 862  * \param format the internal format token provided by the user.
 863  * \return GL_TRUE if compressed, GL_FALSE if uncompressed
 864  */
 865 GLboolean
 866 _mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
 867 {
 868    switch (format) {
 869    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 870    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 871    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 872    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 873       /* Assume that the ANGLE flag will always be set if the EXT flag is set.
 874        */
 875       return ctx->Extensions.ANGLE_texture_compression_dxt;
 876    case GL_RGB_S3TC:
 877    case GL_RGB4_S3TC:
 878    case GL_RGBA_S3TC:
 879    case GL_RGBA4_S3TC:
 880       return _mesa_is_desktop_gl(ctx) &&
 881          ctx->Extensions.ANGLE_texture_compression_dxt;
 882    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 883    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 884    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 885    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 886       return _mesa_is_desktop_gl(ctx)
 887          && ctx->Extensions.EXT_texture_sRGB
 888          && ctx->Extensions.EXT_texture_compression_s3tc;
 889    case GL_COMPRESSED_RGB_FXT1_3DFX:
 890    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 891       return _mesa_is_desktop_gl(ctx)
 892          && ctx->Extensions.TDFX_texture_compression_FXT1;
 893    case GL_COMPRESSED_RED_RGTC1:
 894    case GL_COMPRESSED_SIGNED_RED_RGTC1:
 895    case GL_COMPRESSED_RG_RGTC2:
 896    case GL_COMPRESSED_SIGNED_RG_RGTC2:
 897       return _mesa_is_desktop_gl(ctx)
 898          && ctx->Extensions.ARB_texture_compression_rgtc;
 899    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 900    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 901    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 902    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 903       return ctx->API == API_OPENGL_COMPAT
 904          && ctx->Extensions.EXT_texture_compression_latc;
 905    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 906       return ctx->API == API_OPENGL_COMPAT
 907          && ctx->Extensions.ATI_texture_compression_3dc;
 908    case GL_ETC1_RGB8_OES:
 909       return _mesa_is_gles(ctx)
 910          && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
 911    case GL_COMPRESSED_RGB8_ETC2:
 912    case GL_COMPRESSED_SRGB8_ETC2:
 913    case GL_COMPRESSED_RGBA8_ETC2_EAC:
 914    case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 915    case GL_COMPRESSED_R11_EAC:
 916    case GL_COMPRESSED_RG11_EAC:
 917    case GL_COMPRESSED_SIGNED_R11_EAC:
 918    case GL_COMPRESSED_SIGNED_RG11_EAC:
 919    case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 920    case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 921       return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility;
 922    case GL_PALETTE4_RGB8_OES:
 923    case GL_PALETTE4_RGBA8_OES:
 924    case GL_PALETTE4_R5_G6_B5_OES:
 925    case GL_PALETTE4_RGBA4_OES:
 926    case GL_PALETTE4_RGB5_A1_OES:
 927    case GL_PALETTE8_RGB8_OES:
 928    case GL_PALETTE8_RGBA8_OES:
 929    case GL_PALETTE8_R5_G6_B5_OES:
 930    case GL_PALETTE8_RGBA4_OES:
 931    case GL_PALETTE8_RGB5_A1_OES:
 932       return ctx->API == API_OPENGLES;
 933    default:
 934       return GL_FALSE;
 935    }
 936 }
 937
 938
 939 /**
 940  * Convert various base formats to the cooresponding integer format.
 941  */
 942 GLenum
 943 _mesa_base_format_to_integer_format(GLenum format)
 944 {
 945    switch(format) {
 946    case GL_RED:
 947       return GL_RED_INTEGER;
 948    case GL_GREEN:
 949       return GL_GREEN_INTEGER;
 950    case GL_BLUE:
 951       return GL_BLUE_INTEGER;
 952    case GL_RG:
 953       return GL_RG_INTEGER;
 954    case GL_RGB:
 955       return GL_RGB_INTEGER;
 956    case GL_RGBA:
 957       return GL_RGBA_INTEGER;
 958    case GL_BGR:
 959       return GL_BGR_INTEGER;
 960    case GL_BGRA:
 961       return GL_BGRA_INTEGER;
 962    case GL_ALPHA:
 963       return GL_ALPHA_INTEGER;
 964    case GL_LUMINANCE:
 965       return GL_LUMINANCE_INTEGER_EXT;
 966    case GL_LUMINANCE_ALPHA:
 967       return GL_LUMINANCE_ALPHA_INTEGER_EXT;
 968    }
 969
 970    return format;
 971 }
 972
 973
 974 /**
 975  * Does the given base texture/renderbuffer format have the channel
 976  * named by 'pname'?
 977  */
 978 GLboolean
 979 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
 980 {
 981    switch (pname) {
 982    case GL_TEXTURE_RED_SIZE:
 983    case GL_TEXTURE_RED_TYPE:
 984    case GL_RENDERBUFFER_RED_SIZE_EXT:
 985    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
 986       if (base_format == GL_RED ||
 987           base_format == GL_RG ||
 988           base_format == GL_RGB ||
 989           base_format == GL_RGBA) {
 990          return GL_TRUE;
 991       }
 992       return GL_FALSE;
 993    case GL_TEXTURE_GREEN_SIZE:
 994    case GL_TEXTURE_GREEN_TYPE:
 995    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
 996    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
 997       if (base_format == GL_RG ||
 998           base_format == GL_RGB ||
 999           base_format == GL_RGBA) {
1000          return GL_TRUE;
1001       }
1002       return GL_FALSE;
1003    case GL_TEXTURE_BLUE_SIZE:
1004    case GL_TEXTURE_BLUE_TYPE:
1005    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1006    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1007       if (base_format == GL_RGB ||
1008           base_format == GL_RGBA) {
1009          return GL_TRUE;
1010       }
1011       return GL_FALSE;
1012    case GL_TEXTURE_ALPHA_SIZE:
1013    case GL_TEXTURE_ALPHA_TYPE:
1014    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1015    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1016       if (base_format == GL_RGBA ||
1017           base_format == GL_ALPHA ||
1018           base_format == GL_LUMINANCE_ALPHA) {
1019          return GL_TRUE;
1020       }
1021       return GL_FALSE;
1022    case GL_TEXTURE_LUMINANCE_SIZE:
1023    case GL_TEXTURE_LUMINANCE_TYPE:
1024       if (base_format == GL_LUMINANCE ||
1025           base_format == GL_LUMINANCE_ALPHA) {
1026          return GL_TRUE;
1027       }
1028       return GL_FALSE;
1029    case GL_TEXTURE_INTENSITY_SIZE:
1030    case GL_TEXTURE_INTENSITY_TYPE:
1031       if (base_format == GL_INTENSITY) {
1032          return GL_TRUE;
1033       }
1034       return GL_FALSE;
1035    case GL_TEXTURE_DEPTH_SIZE:
1036    case GL_TEXTURE_DEPTH_TYPE:
1037    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1038    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1039       if (base_format == GL_DEPTH_STENCIL ||
1040           base_format == GL_DEPTH_COMPONENT) {
1041          return GL_TRUE;
1042       }
1043       return GL_FALSE;
1044    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1045    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1046       if (base_format == GL_DEPTH_STENCIL ||
1047           base_format == GL_STENCIL_INDEX) {
1048          return GL_TRUE;
1049       }
1050       return GL_FALSE;
1051    default:
1052       _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1053                     __FUNCTION__, pname);
1054       return GL_FALSE;
1055    }
1056
1057    return GL_FALSE;
1058 }
1059
1060
1061 /**
1062  * Returns the number of channels/components for a base format.
1063  */
1064 GLint
1065 _mesa_base_format_component_count(GLenum base_format)
1066 {
1067    switch (base_format) {
1068    case GL_RED:
1069    case GL_ALPHA:
1070    case GL_INTENSITY:
1071    case GL_DEPTH_COMPONENT:
1072       return 1;
1073    case GL_RG:
1074    case GL_LUMINANCE_ALPHA:
1075    case GL_DEPTH_STENCIL:
1076       return 2;
1077    case GL_RGB:
1078       return 3;
1079    case GL_RGBA:
1080       return 4;
1081    default:
1082       return -1;
1083    }
1084 }
1085
1086
1087 /**
1088  * If format is a generic compressed format, return the corresponding
1089  * non-compressed format.  For other formats, return the format as-is.
1090  */
1091 GLenum
1092 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1093 {
1094    switch (format) {
1095    case GL_COMPRESSED_RED:
1096       return GL_RED;
1097    case GL_COMPRESSED_RG:
1098       return GL_RG;
1099    case GL_COMPRESSED_RGB:
1100       return GL_RGB;
1101    case GL_COMPRESSED_RGBA:
1102       return GL_RGBA;
1103    case GL_COMPRESSED_ALPHA:
1104       return GL_ALPHA;
1105    case GL_COMPRESSED_LUMINANCE:
1106       return GL_LUMINANCE;
1107    case GL_COMPRESSED_LUMINANCE_ALPHA:
1108       return GL_LUMINANCE_ALPHA;
1109    case GL_COMPRESSED_INTENSITY:
1110       return GL_INTENSITY;
1111    /* sRGB formats */
1112    case GL_COMPRESSED_SRGB:
1113       return GL_SRGB;
1114    case GL_COMPRESSED_SRGB_ALPHA:
1115       return GL_SRGB_ALPHA;
1116    case GL_COMPRESSED_SLUMINANCE:
1117       return GL_SLUMINANCE;
1118    case GL_COMPRESSED_SLUMINANCE_ALPHA:
1119       return GL_SLUMINANCE_ALPHA;
1120    default:
1121       return format;
1122    }
1123 }
1124
1125
1126 /**
1127  * Return the equivalent non-generic internal format.
1128  * This is useful for comparing whether two internal formats are equivalent.
1129  */
1130 GLenum
1131 _mesa_get_nongeneric_internalformat(GLenum format)
1132 {
1133    switch (format) {
1134       /* GL 1.1 formats. */
1135       case 4:
1136       case GL_RGBA:
1137          return GL_RGBA8;
1138
1139       case 3:
1140       case GL_RGB:
1141          return GL_RGB8;
1142
1143       case 2:
1144       case GL_LUMINANCE_ALPHA:
1145          return GL_LUMINANCE8_ALPHA8;
1146
1147       case 1:
1148       case GL_LUMINANCE:
1149          return GL_LUMINANCE8;
1150
1151       case GL_ALPHA:
1152          return GL_ALPHA8;
1153
1154       case GL_INTENSITY:
1155          return GL_INTENSITY8;
1156
1157       /* GL_ARB_texture_rg */
1158       case GL_RED:
1159          return GL_R8;
1160
1161       case GL_RG:
1162          return GL_RG8;
1163
1164       /* GL_EXT_texture_sRGB */
1165       case GL_SRGB:
1166          return GL_SRGB8;
1167
1168       case GL_SRGB_ALPHA:
1169          return GL_SRGB8_ALPHA8;
1170
1171       case GL_SLUMINANCE:
1172          return GL_SLUMINANCE8;
1173
1174       case GL_SLUMINANCE_ALPHA:
1175          return GL_SLUMINANCE8_ALPHA8;
1176
1177       /* GL_EXT_texture_snorm */
1178       case GL_RGBA_SNORM:
1179          return GL_RGBA8_SNORM;
1180
1181       case GL_RGB_SNORM:
1182          return GL_RGB8_SNORM;
1183
1184       case GL_RG_SNORM:
1185          return GL_RG8_SNORM;
1186
1187       case GL_RED_SNORM:
1188          return GL_R8_SNORM;
1189
1190       case GL_LUMINANCE_ALPHA_SNORM:
1191          return GL_LUMINANCE8_ALPHA8_SNORM;
1192
1193       case GL_LUMINANCE_SNORM:
1194          return GL_LUMINANCE8_SNORM;
1195
1196       case GL_ALPHA_SNORM:
1197          return GL_ALPHA8_SNORM;
1198
1199       case GL_INTENSITY_SNORM:
1200          return GL_INTENSITY8_SNORM;
1201
1202       default:
1203          return format;
1204    }
1205 }
1206
1207
1208 /**
1209  * Convert an sRGB internal format to linear.
1210  */
1211 GLenum
1212 _mesa_get_linear_internalformat(GLenum format)
1213 {
1214    switch (format) {
1215    case GL_SRGB:
1216       return GL_RGB;
1217
1218    case GL_SRGB_ALPHA:
1219       return GL_RGBA;
1220
1221    case GL_SRGB8:
1222       return GL_RGB8;
1223
1224    case GL_SRGB8_ALPHA8:
1225       return GL_RGBA8;
1226
1227    case GL_SLUMINANCE:
1228       return GL_LUMINANCE8;
1229
1230    case GL_SLUMINANCE_ALPHA:
1231       return GL_LUMINANCE8_ALPHA8;
1232
1233    default:
1234       return format;
1235    }
1236 }
1237
1238
1239 /**
1240  * Do error checking of format/type combinations for glReadPixels,
1241  * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1242  * and type values, we may either generate GL_INVALID_OPERATION or
1243  * GL_INVALID_ENUM.
1244  *
1245  * \param format pixel format.
1246  * \param type pixel type.
1247  *
1248  * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1249  */
1250 GLenum
1251 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1252                                   GLenum format, GLenum type)
1253 {
1254    /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1255    switch (type) {
1256    case GL_BITMAP:
1257       if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1258          return GL_INVALID_ENUM;
1259       }
1260       break;
1261
1262    case GL_UNSIGNED_BYTE_3_3_2:
1263    case GL_UNSIGNED_BYTE_2_3_3_REV:
1264    case GL_UNSIGNED_SHORT_5_6_5:
1265    case GL_UNSIGNED_SHORT_5_6_5_REV:
1266       if (format == GL_RGB) {
1267          break; /* OK */
1268       }
1269       if (format == GL_RGB_INTEGER_EXT &&
1270           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1271          break; /* OK */
1272       }
1273       return GL_INVALID_OPERATION;
1274
1275    case GL_UNSIGNED_SHORT_4_4_4_4:
1276    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1277    case GL_UNSIGNED_SHORT_5_5_5_1:
1278    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1279    case GL_UNSIGNED_INT_8_8_8_8:
1280    case GL_UNSIGNED_INT_8_8_8_8_REV:
1281    case GL_UNSIGNED_INT_10_10_10_2:
1282    case GL_UNSIGNED_INT_2_10_10_10_REV:
1283       if (format == GL_RGBA ||
1284           format == GL_BGRA ||
1285           format == GL_ABGR_EXT) {
1286          break; /* OK */
1287       }
1288       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1289           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1290          break; /* OK */
1291       }
1292       if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1293           ctx->API == API_OPENGLES2) {
1294          break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1295       }
1296       return GL_INVALID_OPERATION;
1297
1298    case GL_UNSIGNED_INT_24_8:
1299       if (!ctx->Extensions.EXT_packed_depth_stencil) {
1300          return GL_INVALID_ENUM;
1301       }
1302       if (format != GL_DEPTH_STENCIL) {
1303          return GL_INVALID_OPERATION;
1304       }
1305       return GL_NO_ERROR;
1306
1307    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1308       if (!ctx->Extensions.ARB_depth_buffer_float) {
1309          return GL_INVALID_ENUM;
1310       }
1311       if (format != GL_DEPTH_STENCIL) {
1312          return GL_INVALID_OPERATION;
1313       }
1314       return GL_NO_ERROR;
1315
1316    case GL_UNSIGNED_INT_10F_11F_11F_REV:
1317       if (!ctx->Extensions.EXT_packed_float) {
1318          return GL_INVALID_ENUM;
1319       }
1320       if (format != GL_RGB) {
1321          return GL_INVALID_OPERATION;
1322       }
1323       return GL_NO_ERROR;
1324
1325    default:
1326       ; /* fall-through */
1327    }
1328
1329    /* now, for each format, check the type for compatibility */
1330    switch (format) {
1331       case GL_COLOR_INDEX:
1332       case GL_STENCIL_INDEX:
1333          switch (type) {
1334             case GL_BITMAP:
1335             case GL_BYTE:
1336             case GL_UNSIGNED_BYTE:
1337             case GL_SHORT:
1338             case GL_UNSIGNED_SHORT:
1339             case GL_INT:
1340             case GL_UNSIGNED_INT:
1341             case GL_FLOAT:
1342                return GL_NO_ERROR;
1343             case GL_HALF_FLOAT:
1344                return ctx->Extensions.ARB_half_float_pixel
1345                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1346             default:
1347                return GL_INVALID_ENUM;
1348          }
1349
1350       case GL_RED:
1351       case GL_GREEN:
1352       case GL_BLUE:
1353       case GL_ALPHA:
1354 #if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1355       case GL_INTENSITY:
1356 #endif
1357       case GL_LUMINANCE:
1358       case GL_LUMINANCE_ALPHA:
1359       case GL_DEPTH_COMPONENT:
1360          switch (type) {
1361             case GL_BYTE:
1362             case GL_UNSIGNED_BYTE:
1363             case GL_SHORT:
1364             case GL_UNSIGNED_SHORT:
1365             case GL_INT:
1366             case GL_UNSIGNED_INT:
1367             case GL_FLOAT:
1368                return GL_NO_ERROR;
1369             case GL_HALF_FLOAT:
1370                return ctx->Extensions.ARB_half_float_pixel
1371                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1372             default:
1373                return GL_INVALID_ENUM;
1374          }
1375
1376       case GL_RG:
1377          if (!ctx->Extensions.ARB_texture_rg)
1378             return GL_INVALID_ENUM;
1379          switch (type) {
1380             case GL_BYTE:
1381             case GL_UNSIGNED_BYTE:
1382             case GL_SHORT:
1383             case GL_UNSIGNED_SHORT:
1384             case GL_INT:
1385             case GL_UNSIGNED_INT:
1386             case GL_FLOAT:
1387                return GL_NO_ERROR;
1388             case GL_HALF_FLOAT:
1389                return ctx->Extensions.ARB_half_float_pixel
1390                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1391             default:
1392                return GL_INVALID_ENUM;
1393          }
1394
1395       case GL_RGB:
1396          switch (type) {
1397             case GL_BYTE:
1398             case GL_UNSIGNED_BYTE:
1399             case GL_SHORT:
1400             case GL_UNSIGNED_SHORT:
1401             case GL_INT:
1402             case GL_UNSIGNED_INT:
1403             case GL_FLOAT:
1404             case GL_UNSIGNED_BYTE_3_3_2:
1405             case GL_UNSIGNED_BYTE_2_3_3_REV:
1406             case GL_UNSIGNED_SHORT_5_6_5:
1407             case GL_UNSIGNED_SHORT_5_6_5_REV:
1408                return GL_NO_ERROR;
1409             case GL_UNSIGNED_INT_2_10_10_10_REV:
1410                /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1411                return (ctx->API == API_OPENGLES2)
1412                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1413             case GL_HALF_FLOAT:
1414                return ctx->Extensions.ARB_half_float_pixel
1415                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1416             case GL_UNSIGNED_INT_5_9_9_9_REV:
1417                return ctx->Extensions.EXT_texture_shared_exponent
1418                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1419             case GL_UNSIGNED_INT_10F_11F_11F_REV:
1420                return ctx->Extensions.EXT_packed_float
1421                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1422             default:
1423                return GL_INVALID_ENUM;
1424          }
1425
1426       case GL_BGR:
1427          switch (type) {
1428             /* NOTE: no packed types are supported with BGR.  That's
1429              * intentional, according to the GL spec.
1430              */
1431             case GL_BYTE:
1432             case GL_UNSIGNED_BYTE:
1433             case GL_SHORT:
1434             case GL_UNSIGNED_SHORT:
1435             case GL_INT:
1436             case GL_UNSIGNED_INT:
1437             case GL_FLOAT:
1438                return GL_NO_ERROR;
1439             case GL_HALF_FLOAT:
1440                return ctx->Extensions.ARB_half_float_pixel
1441                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1442             default:
1443                return GL_INVALID_ENUM;
1444          }
1445
1446       case GL_RGBA:
1447       case GL_BGRA:
1448       case GL_ABGR_EXT:
1449          switch (type) {
1450             case GL_BYTE:
1451             case GL_UNSIGNED_BYTE:
1452             case GL_SHORT:
1453             case GL_UNSIGNED_SHORT:
1454             case GL_INT:
1455             case GL_UNSIGNED_INT:
1456             case GL_FLOAT:
1457             case GL_UNSIGNED_SHORT_4_4_4_4:
1458             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1459             case GL_UNSIGNED_SHORT_5_5_5_1:
1460             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1461             case GL_UNSIGNED_INT_8_8_8_8:
1462             case GL_UNSIGNED_INT_8_8_8_8_REV:
1463             case GL_UNSIGNED_INT_10_10_10_2:
1464             case GL_UNSIGNED_INT_2_10_10_10_REV:
1465                return GL_NO_ERROR;
1466             case GL_HALF_FLOAT:
1467                return ctx->Extensions.ARB_half_float_pixel
1468                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1469             default:
1470                return GL_INVALID_ENUM;
1471          }
1472
1473       case GL_YCBCR_MESA:
1474          if (!ctx->Extensions.MESA_ycbcr_texture)
1475             return GL_INVALID_ENUM;
1476          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1477              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1478             return GL_NO_ERROR;
1479          else
1480             return GL_INVALID_OPERATION;
1481
1482       case GL_DEPTH_STENCIL_EXT:
1483          if (ctx->Extensions.EXT_packed_depth_stencil &&
1484              type == GL_UNSIGNED_INT_24_8)
1485             return GL_NO_ERROR;
1486          else if (ctx->Extensions.ARB_depth_buffer_float &&
1487              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1488             return GL_NO_ERROR;
1489          else
1490             return GL_INVALID_ENUM;
1491
1492       case GL_DUDV_ATI:
1493       case GL_DU8DV8_ATI:
1494          if (!ctx->Extensions.ATI_envmap_bumpmap)
1495             return GL_INVALID_ENUM;
1496          switch (type) {
1497             case GL_BYTE:
1498             case GL_UNSIGNED_BYTE:
1499             case GL_SHORT:
1500             case GL_UNSIGNED_SHORT:
1501             case GL_INT:
1502             case GL_UNSIGNED_INT:
1503             case GL_FLOAT:
1504                return GL_NO_ERROR;
1505             default:
1506                return GL_INVALID_ENUM;
1507          }
1508
1509       /* integer-valued formats */
1510       case GL_RED_INTEGER_EXT:
1511       case GL_GREEN_INTEGER_EXT:
1512       case GL_BLUE_INTEGER_EXT:
1513       case GL_ALPHA_INTEGER_EXT:
1514       case GL_RG_INTEGER:
1515          switch (type) {
1516             case GL_BYTE:
1517             case GL_UNSIGNED_BYTE:
1518             case GL_SHORT:
1519             case GL_UNSIGNED_SHORT:
1520             case GL_INT:
1521             case GL_UNSIGNED_INT:
1522                return (ctx->Version >= 30 ||
1523                        ctx->Extensions.EXT_texture_integer)
1524                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1525             default:
1526                return GL_INVALID_ENUM;
1527          }
1528
1529       case GL_RGB_INTEGER_EXT:
1530          switch (type) {
1531             case GL_BYTE:
1532             case GL_UNSIGNED_BYTE:
1533             case GL_SHORT:
1534             case GL_UNSIGNED_SHORT:
1535             case GL_INT:
1536             case GL_UNSIGNED_INT:
1537                return (ctx->Version >= 30 ||
1538                        ctx->Extensions.EXT_texture_integer)
1539                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1540             case GL_UNSIGNED_BYTE_3_3_2:
1541             case GL_UNSIGNED_BYTE_2_3_3_REV:
1542             case GL_UNSIGNED_SHORT_5_6_5:
1543             case GL_UNSIGNED_SHORT_5_6_5_REV:
1544                return ctx->Extensions.ARB_texture_rgb10_a2ui
1545                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1546             default:
1547                return GL_INVALID_ENUM;
1548          }
1549
1550       case GL_BGR_INTEGER_EXT:
1551          switch (type) {
1552             case GL_BYTE:
1553             case GL_UNSIGNED_BYTE:
1554             case GL_SHORT:
1555             case GL_UNSIGNED_SHORT:
1556             case GL_INT:
1557             case GL_UNSIGNED_INT:
1558             /* NOTE: no packed formats w/ BGR format */
1559                return (ctx->Version >= 30 ||
1560                        ctx->Extensions.EXT_texture_integer)
1561                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1562             default:
1563                return GL_INVALID_ENUM;
1564          }
1565
1566       case GL_RGBA_INTEGER_EXT:
1567       case GL_BGRA_INTEGER_EXT:
1568          switch (type) {
1569             case GL_BYTE:
1570             case GL_UNSIGNED_BYTE:
1571             case GL_SHORT:
1572             case GL_UNSIGNED_SHORT:
1573             case GL_INT:
1574             case GL_UNSIGNED_INT:
1575                return (ctx->Version >= 30 ||
1576                        ctx->Extensions.EXT_texture_integer)
1577                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1578             case GL_UNSIGNED_SHORT_4_4_4_4:
1579             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1580             case GL_UNSIGNED_SHORT_5_5_5_1:
1581             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1582             case GL_UNSIGNED_INT_8_8_8_8:
1583             case GL_UNSIGNED_INT_8_8_8_8_REV:
1584             case GL_UNSIGNED_INT_10_10_10_2:
1585             case GL_UNSIGNED_INT_2_10_10_10_REV:
1586                return ctx->Extensions.ARB_texture_rgb10_a2ui
1587                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1588             default:
1589                return GL_INVALID_ENUM;
1590          }
1591
1592       case GL_LUMINANCE_INTEGER_EXT:
1593       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1594          switch (type) {
1595             case GL_BYTE:
1596             case GL_UNSIGNED_BYTE:
1597             case GL_SHORT:
1598             case GL_UNSIGNED_SHORT:
1599             case GL_INT:
1600             case GL_UNSIGNED_INT:
1601                return ctx->Extensions.EXT_texture_integer
1602                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1603             default:
1604                return GL_INVALID_ENUM;
1605          }
1606
1607       default:
1608          return GL_INVALID_ENUM;
1609    }
1610    return GL_NO_ERROR;
1611 }
1612
1613
1614 /**
1615  * Do error checking of format/type combinations for OpenGL ES glReadPixels
1616  * and glTex[Sub]Image.
1617  * \return error code, or GL_NO_ERROR.
1618  */
1619 GLenum
1620 _mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1621                                      unsigned dimensions)
1622 {
1623    GLboolean type_valid = GL_TRUE;
1624
1625    switch (format) {
1626    case GL_ALPHA:
1627    case GL_LUMINANCE:
1628    case GL_LUMINANCE_ALPHA:
1629       type_valid = (type == GL_UNSIGNED_BYTE
1630                     || type == GL_FLOAT
1631                     || type == GL_HALF_FLOAT_OES);
1632       break;
1633
1634    case GL_RGB:
1635       type_valid = (type == GL_UNSIGNED_BYTE
1636                     || type == GL_UNSIGNED_SHORT_5_6_5
1637                     || type == GL_FLOAT
1638                     || type == GL_HALF_FLOAT_OES);
1639       break;
1640
1641    case GL_RGBA:
1642       type_valid = (type == GL_UNSIGNED_BYTE
1643                     || type == GL_UNSIGNED_SHORT_4_4_4_4
1644                     || type == GL_UNSIGNED_SHORT_5_5_5_1
1645                     || type == GL_FLOAT
1646                     || type == GL_HALF_FLOAT_OES
1647                     || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1648       break;
1649
1650    case GL_DEPTH_COMPONENT:
1651       /* This format is filtered against invalid dimensionalities elsewhere.
1652        */
1653       type_valid = (type == GL_UNSIGNED_SHORT
1654                     || type == GL_UNSIGNED_INT);
1655       break;
1656
1657    case GL_DEPTH_STENCIL:
1658       /* This format is filtered against invalid dimensionalities elsewhere.
1659        */
1660       type_valid = (type == GL_UNSIGNED_INT_24_8);
1661       break;
1662
1663    case GL_BGRA_EXT:
1664       type_valid = (type == GL_UNSIGNED_BYTE);
1665
1666       /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
1667        * the format does not appear to be allowed for 3D textures in OpenGL
1668        * ES.
1669        */
1670       if (dimensions != 2)
1671          return GL_INVALID_VALUE;
1672
1673       break;
1674
1675    default:
1676       return GL_INVALID_VALUE;
1677    }
1678
1679    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
1680 }
1681
1682
1683 /**
1684  * Do error checking of format/type combinations for OpenGL ES 3
1685  * glTex[Sub]Image.
1686  * \return error code, or GL_NO_ERROR.
1687  */
1688 GLenum
1689 _mesa_es3_error_check_format_and_type(GLenum format, GLenum type,
1690                                       GLenum internalFormat)
1691 {
1692    GLboolean type_valid = GL_TRUE;
1693
1694    switch (format) {
1695    case GL_RGBA:
1696       switch (type) {
1697       case GL_UNSIGNED_BYTE:
1698          switch (internalFormat) {
1699          case GL_RGBA:
1700          case GL_RGBA8:
1701          case GL_RGB5_A1:
1702          case GL_RGBA4:
1703          case GL_SRGB8_ALPHA8_EXT:
1704             break;
1705          default:
1706             return GL_INVALID_OPERATION;
1707          }
1708          break;
1709
1710       case GL_BYTE:
1711          if (internalFormat != GL_RGBA8_SNORM)
1712             return GL_INVALID_OPERATION;
1713          break;
1714
1715       case GL_UNSIGNED_SHORT_4_4_4_4:
1716          switch (internalFormat) {
1717          case GL_RGBA:
1718          case GL_RGBA4:
1719             break;
1720          default:
1721             return GL_INVALID_OPERATION;
1722          }
1723          break;
1724
1725       case GL_UNSIGNED_SHORT_5_5_5_1:
1726          switch (internalFormat) {
1727          case GL_RGBA:
1728          case GL_RGB5_A1:
1729             break;
1730          default:
1731             return GL_INVALID_OPERATION;
1732          }
1733          break;
1734
1735       case GL_UNSIGNED_INT_2_10_10_10_REV:
1736          switch (internalFormat) {
1737          case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
1738          case GL_RGB10_A2:
1739          case GL_RGB5_A1:
1740             break;
1741          default:
1742             return GL_INVALID_OPERATION;
1743          }
1744          break;
1745
1746       case GL_HALF_FLOAT:
1747          if (internalFormat != GL_RGBA16F)
1748             return GL_INVALID_OPERATION;
1749          break;
1750
1751       case GL_FLOAT:
1752          switch (internalFormat) {
1753          case GL_RGBA16F:
1754          case GL_RGBA32F:
1755             break;
1756          default:
1757             return GL_INVALID_OPERATION;
1758          }
1759          break;
1760
1761       default:
1762          return GL_INVALID_OPERATION;
1763       }
1764       break;
1765
1766    case GL_RGBA_INTEGER:
1767       switch (type) {
1768       case GL_UNSIGNED_BYTE:
1769          if (internalFormat != GL_RGBA8UI)
1770             return GL_INVALID_OPERATION;
1771          break;
1772
1773       case GL_BYTE:
1774          if (internalFormat != GL_RGBA8I)
1775             return GL_INVALID_OPERATION;
1776          break;
1777
1778       case GL_UNSIGNED_SHORT:
1779          if (internalFormat != GL_RGBA16UI)
1780             return GL_INVALID_OPERATION;
1781          break;
1782
1783       case GL_SHORT:
1784          if (internalFormat != GL_RGBA16I)
1785             return GL_INVALID_OPERATION;
1786          break;
1787
1788       case GL_UNSIGNED_INT:
1789          if (internalFormat != GL_RGBA32UI)
1790             return GL_INVALID_OPERATION;
1791          break;
1792
1793       case GL_INT:
1794          if (internalFormat != GL_RGBA32I)
1795             return GL_INVALID_OPERATION;
1796          break;
1797
1798       case GL_UNSIGNED_INT_2_10_10_10_REV:
1799          if (internalFormat != GL_RGB10_A2UI)
1800             return GL_INVALID_OPERATION;
1801          break;
1802
1803       default:
1804          return GL_INVALID_OPERATION;
1805       }
1806       break;
1807
1808    case GL_RGB:
1809       switch (type) {
1810       case GL_UNSIGNED_BYTE:
1811          switch (internalFormat) {
1812          case GL_RGB:
1813          case GL_RGB8:
1814          case GL_RGB565:
1815          case GL_SRGB8:
1816             break;
1817          default:
1818             return GL_INVALID_OPERATION;
1819          }
1820          break;
1821
1822       case GL_BYTE:
1823          if (internalFormat != GL_RGB8_SNORM)
1824             return GL_INVALID_OPERATION;
1825          break;
1826
1827       case GL_UNSIGNED_SHORT_5_6_5:
1828          switch (internalFormat) {
1829          case GL_RGB:
1830          case GL_RGB565:
1831             break;
1832          default:
1833             return GL_INVALID_OPERATION;
1834          }
1835          break;
1836
1837       case GL_UNSIGNED_INT_10F_11F_11F_REV:
1838          if (internalFormat != GL_R11F_G11F_B10F)
1839             return GL_INVALID_OPERATION;
1840          break;
1841
1842       case GL_UNSIGNED_INT_5_9_9_9_REV:
1843          if (internalFormat != GL_RGB9_E5)
1844             return GL_INVALID_OPERATION;
1845          break;
1846
1847       case GL_HALF_FLOAT:
1848          switch (internalFormat) {
1849          case GL_RGB16F:
1850          case GL_R11F_G11F_B10F:
1851          case GL_RGB9_E5:
1852             break;
1853          default:
1854             return GL_INVALID_OPERATION;
1855          }
1856          break;
1857
1858       case GL_FLOAT:
1859          switch (internalFormat) {
1860          case GL_RGB16F:
1861          case GL_RGB32F:
1862          case GL_R11F_G11F_B10F:
1863          case GL_RGB9_E5:
1864             break;
1865          default:
1866             return GL_INVALID_OPERATION;
1867          }
1868          break;
1869
1870       case GL_UNSIGNED_INT_2_10_10_10_REV:
1871          switch (internalFormat) {
1872          case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
1873             break;
1874          default:
1875             return GL_INVALID_OPERATION;
1876          }
1877          break;
1878
1879       default:
1880          return GL_INVALID_OPERATION;
1881       }
1882       break;
1883
1884    case GL_RGB_INTEGER:
1885       switch (type) {
1886       case GL_UNSIGNED_BYTE:
1887          if (internalFormat != GL_RGB8UI)
1888             return GL_INVALID_OPERATION;
1889          break;
1890
1891       case GL_BYTE:
1892          if (internalFormat != GL_RGB8I)
1893             return GL_INVALID_OPERATION;
1894          break;
1895
1896       case GL_UNSIGNED_SHORT:
1897          if (internalFormat != GL_RGB16UI)
1898             return GL_INVALID_OPERATION;
1899          break;
1900
1901       case GL_SHORT:
1902          if (internalFormat != GL_RGB16I)
1903             return GL_INVALID_OPERATION;
1904          break;
1905
1906       case GL_UNSIGNED_INT:
1907          if (internalFormat != GL_RGB32UI)
1908             return GL_INVALID_OPERATION;
1909          break;
1910
1911       case GL_INT:
1912          if (internalFormat != GL_RGB32I)
1913             return GL_INVALID_OPERATION;
1914          break;
1915
1916       default:
1917          return GL_INVALID_OPERATION;
1918       }
1919       break;
1920
1921    case GL_RG:
1922       switch (type) {
1923       case GL_UNSIGNED_BYTE:
1924          if (internalFormat != GL_RG8)
1925             return GL_INVALID_OPERATION;
1926          break;
1927
1928       case GL_BYTE:
1929          if (internalFormat != GL_RG8_SNORM)
1930             return GL_INVALID_OPERATION;
1931          break;
1932
1933       case GL_HALF_FLOAT:
1934          if (internalFormat != GL_RG16F)
1935             return GL_INVALID_OPERATION;
1936          break;
1937
1938       case GL_FLOAT:
1939          switch (internalFormat) {
1940          case GL_RG16F:
1941          case GL_RG32F:
1942             break;
1943          default:
1944             return GL_INVALID_OPERATION;
1945          }
1946          break;
1947
1948       default:
1949          return GL_INVALID_OPERATION;
1950       }
1951       break;
1952
1953    case GL_RG_INTEGER:
1954       switch (type) {
1955       case GL_UNSIGNED_BYTE:
1956          if (internalFormat != GL_RG8UI)
1957             return GL_INVALID_OPERATION;
1958          break;
1959
1960       case GL_BYTE:
1961          if (internalFormat != GL_RG8I)
1962             return GL_INVALID_OPERATION;
1963          break;
1964
1965       case GL_UNSIGNED_SHORT:
1966          if (internalFormat != GL_RG16UI)
1967             return GL_INVALID_OPERATION;
1968          break;
1969
1970       case GL_SHORT:
1971          if (internalFormat != GL_RG16I)
1972             return GL_INVALID_OPERATION;
1973          break;
1974
1975       case GL_UNSIGNED_INT:
1976          if (internalFormat != GL_RG32UI)
1977             return GL_INVALID_OPERATION;
1978          break;
1979
1980       case GL_INT:
1981          if (internalFormat != GL_RG32I)
1982             return GL_INVALID_OPERATION;
1983          break;
1984
1985       default:
1986          return GL_INVALID_OPERATION;
1987       }
1988       break;
1989
1990    case GL_RED:
1991       switch (type) {
1992       case GL_UNSIGNED_BYTE:
1993          if (internalFormat != GL_R8)
1994             return GL_INVALID_OPERATION;
1995          break;
1996
1997       case GL_BYTE:
1998          if (internalFormat != GL_R8_SNORM)
1999             return GL_INVALID_OPERATION;
2000          break;
2001
2002       case GL_HALF_FLOAT:
2003          if (internalFormat != GL_R16F)
2004             return GL_INVALID_OPERATION;
2005          break;
2006
2007       case GL_FLOAT:
2008          switch (internalFormat) {
2009          case GL_R16F:
2010          case GL_R32F:
2011             break;
2012          default:
2013             return GL_INVALID_OPERATION;
2014          }
2015          break;
2016
2017       default:
2018          return GL_INVALID_OPERATION;
2019       }
2020       break;
2021
2022    case GL_RED_INTEGER:
2023       switch (type) {
2024       case GL_UNSIGNED_BYTE:
2025          if (internalFormat != GL_R8UI)
2026             return GL_INVALID_OPERATION;
2027          break;
2028
2029       case GL_BYTE:
2030          if (internalFormat != GL_R8I)
2031             return GL_INVALID_OPERATION;
2032          break;
2033
2034       case GL_UNSIGNED_SHORT:
2035          if (internalFormat != GL_R16UI)
2036             return GL_INVALID_OPERATION;
2037          break;
2038
2039       case GL_SHORT:
2040          if (internalFormat != GL_R16I)
2041             return GL_INVALID_OPERATION;
2042          break;
2043
2044       case GL_UNSIGNED_INT:
2045          if (internalFormat != GL_R32UI)
2046             return GL_INVALID_OPERATION;
2047          break;
2048
2049       case GL_INT:
2050          if (internalFormat != GL_R32I)
2051             return GL_INVALID_OPERATION;
2052          break;
2053
2054       default:
2055          return GL_INVALID_OPERATION;
2056       }
2057       break;
2058
2059    case GL_DEPTH_COMPONENT:
2060       switch (type) {
2061       case GL_UNSIGNED_SHORT:
2062          if (internalFormat != GL_DEPTH_COMPONENT
2063              && internalFormat != GL_DEPTH_COMPONENT16)
2064             return GL_INVALID_OPERATION;
2065          break;
2066
2067       case GL_UNSIGNED_INT:
2068          switch (internalFormat) {
2069          case GL_DEPTH_COMPONENT:
2070          case GL_DEPTH_COMPONENT16:
2071          case GL_DEPTH_COMPONENT24:
2072             break;
2073          default:
2074             return GL_INVALID_OPERATION;
2075          }
2076          break;
2077
2078       case GL_FLOAT:
2079          if (internalFormat != GL_DEPTH_COMPONENT32F)
2080             return GL_INVALID_OPERATION;
2081          break;
2082
2083       default:
2084          return GL_INVALID_OPERATION;
2085       }
2086       break;
2087
2088    case GL_DEPTH_STENCIL:
2089       switch (type) {
2090       case GL_UNSIGNED_INT_24_8:
2091          if (internalFormat != GL_DEPTH_STENCIL
2092              && internalFormat != GL_DEPTH24_STENCIL8)
2093             return GL_INVALID_OPERATION;
2094          break;
2095
2096       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2097          if (internalFormat != GL_DEPTH32F_STENCIL8)
2098             return GL_INVALID_OPERATION;
2099          break;
2100
2101       default:
2102          return GL_INVALID_OPERATION;
2103       }
2104       break;
2105
2106    case GL_ALPHA:
2107    case GL_LUMINANCE:
2108    case GL_LUMINANCE_ALPHA:
2109       if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2110          return GL_INVALID_OPERATION;
2111       break;
2112    }
2113
2114    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2115 }