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    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 349       if (comps == 3)
 350          return sizeof(GLuint);
 351       else
 352          return -1;
 353    default:
 354       return -1;
 355    }
 356 }
 357
 358
 359 /**
 360  * Test if the given format is an integer (non-normalized) format.
 361  */
 362 GLboolean
 363 _mesa_is_enum_format_unsigned_int(GLenum format)
 364 {
 365    switch (format) {
 366    /* specific integer formats */
 367    case GL_RGBA32UI_EXT:
 368    case GL_RGB32UI_EXT:
 369    case GL_RG32UI:
 370    case GL_R32UI:
 371    case GL_ALPHA32UI_EXT:
 372    case GL_INTENSITY32UI_EXT:
 373    case GL_LUMINANCE32UI_EXT:
 374    case GL_LUMINANCE_ALPHA32UI_EXT:
 375    case GL_RGBA16UI_EXT:
 376    case GL_RGB16UI_EXT:
 377    case GL_RG16UI:
 378    case GL_R16UI:
 379    case GL_ALPHA16UI_EXT:
 380    case GL_INTENSITY16UI_EXT:
 381    case GL_LUMINANCE16UI_EXT:
 382    case GL_LUMINANCE_ALPHA16UI_EXT:
 383    case GL_RGBA8UI_EXT:
 384    case GL_RGB8UI_EXT:
 385    case GL_RG8UI:
 386    case GL_R8UI:
 387    case GL_ALPHA8UI_EXT:
 388    case GL_INTENSITY8UI_EXT:
 389    case GL_LUMINANCE8UI_EXT:
 390    case GL_LUMINANCE_ALPHA8UI_EXT:
 391    case GL_RGB10_A2UI:
 392       return GL_TRUE;
 393    default:
 394       return GL_FALSE;
 395    }
 396 }
 397
 398
 399 /**
 400  * Test if the given format is an integer (non-normalized) format.
 401  */
 402 GLboolean
 403 _mesa_is_enum_format_signed_int(GLenum format)
 404 {
 405    switch (format) {
 406    /* generic integer formats */
 407    case GL_RED_INTEGER_EXT:
 408    case GL_GREEN_INTEGER_EXT:
 409    case GL_BLUE_INTEGER_EXT:
 410    case GL_ALPHA_INTEGER_EXT:
 411    case GL_RGB_INTEGER_EXT:
 412    case GL_RGBA_INTEGER_EXT:
 413    case GL_BGR_INTEGER_EXT:
 414    case GL_BGRA_INTEGER_EXT:
 415    case GL_LUMINANCE_INTEGER_EXT:
 416    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 417    case GL_RG_INTEGER:
 418    /* specific integer formats */
 419    case GL_RGBA32I_EXT:
 420    case GL_RGB32I_EXT:
 421    case GL_RG32I:
 422    case GL_R32I:
 423    case GL_ALPHA32I_EXT:
 424    case GL_INTENSITY32I_EXT:
 425    case GL_LUMINANCE32I_EXT:
 426    case GL_LUMINANCE_ALPHA32I_EXT:
 427    case GL_RGBA16I_EXT:
 428    case GL_RGB16I_EXT:
 429    case GL_RG16I:
 430    case GL_R16I:
 431    case GL_ALPHA16I_EXT:
 432    case GL_INTENSITY16I_EXT:
 433    case GL_LUMINANCE16I_EXT:
 434    case GL_LUMINANCE_ALPHA16I_EXT:
 435    case GL_RGBA8I_EXT:
 436    case GL_RGB8I_EXT:
 437    case GL_RG8I:
 438    case GL_R8I:
 439    case GL_ALPHA8I_EXT:
 440    case GL_INTENSITY8I_EXT:
 441    case GL_LUMINANCE8I_EXT:
 442    case GL_LUMINANCE_ALPHA8I_EXT:
 443       return GL_TRUE;
 444    default:
 445       return GL_FALSE;
 446    }
 447 }
 448
 449
 450 /**
 451  * Test if the given format is an integer (non-normalized) format.
 452  */
 453 GLboolean
 454 _mesa_is_enum_format_integer(GLenum format)
 455 {
 456    return _mesa_is_enum_format_unsigned_int(format) ||
 457           _mesa_is_enum_format_signed_int(format);
 458 }
 459
 460
 461 GLboolean
 462 _mesa_is_type_unsigned(GLenum type)
 463 {
 464    switch (type) {
 465    case GL_UNSIGNED_INT:
 466    case GL_UNSIGNED_INT_8_8_8_8:
 467    case GL_UNSIGNED_INT_8_8_8_8_REV:
 468    case GL_UNSIGNED_INT_10_10_10_2:
 469    case GL_UNSIGNED_INT_2_10_10_10_REV:
 470
 471    case GL_UNSIGNED_SHORT:
 472    case GL_UNSIGNED_SHORT_4_4_4_4:
 473    case GL_UNSIGNED_SHORT_5_5_5_1:
 474    case GL_UNSIGNED_SHORT_5_6_5:
 475    case GL_UNSIGNED_SHORT_5_6_5_REV:
 476    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 477    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 478    case GL_UNSIGNED_SHORT_8_8_MESA:
 479    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 480
 481    case GL_UNSIGNED_BYTE:
 482    case GL_UNSIGNED_BYTE_3_3_2:
 483    case GL_UNSIGNED_BYTE_2_3_3_REV:
 484       return GL_TRUE;
 485
 486    default:
 487       return GL_FALSE;
 488    }
 489 }
 490
 491
 492 /**
 493  * Test if the given image format is a color/RGBA format (i.e., not color
 494  * index, depth, stencil, etc).
 495  * \param format  the image format value (may by an internal texture format)
 496  * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
 497  */
 498 GLboolean
 499 _mesa_is_color_format(GLenum format)
 500 {
 501    switch (format) {
 502       case GL_RED:
 503       case GL_GREEN:
 504       case GL_BLUE:
 505       case GL_ALPHA:
 506       case GL_ALPHA4:
 507       case GL_ALPHA8:
 508       case GL_ALPHA12:
 509       case GL_ALPHA16:
 510       case 1:
 511       case GL_LUMINANCE:
 512       case GL_LUMINANCE4:
 513       case GL_LUMINANCE8:
 514       case GL_LUMINANCE12:
 515       case GL_LUMINANCE16:
 516       case 2:
 517       case GL_LUMINANCE_ALPHA:
 518       case GL_LUMINANCE4_ALPHA4:
 519       case GL_LUMINANCE6_ALPHA2:
 520       case GL_LUMINANCE8_ALPHA8:
 521       case GL_LUMINANCE12_ALPHA4:
 522       case GL_LUMINANCE12_ALPHA12:
 523       case GL_LUMINANCE16_ALPHA16:
 524       case GL_INTENSITY:
 525       case GL_INTENSITY4:
 526       case GL_INTENSITY8:
 527       case GL_INTENSITY12:
 528       case GL_INTENSITY16:
 529       case GL_R8:
 530       case GL_R16:
 531       case GL_RG:
 532       case GL_RG8:
 533       case GL_RG16:
 534       case 3:
 535       case GL_RGB:
 536       case GL_BGR:
 537       case GL_R3_G3_B2:
 538       case GL_RGB4:
 539       case GL_RGB5:
 540       case GL_RGB565:
 541       case GL_RGB8:
 542       case GL_RGB10:
 543       case GL_RGB12:
 544       case GL_RGB16:
 545       case 4:
 546       case GL_ABGR_EXT:
 547       case GL_RGBA:
 548       case GL_BGRA:
 549       case GL_RGBA2:
 550       case GL_RGBA4:
 551       case GL_RGB5_A1:
 552       case GL_RGBA8:
 553       case GL_RGB10_A2:
 554       case GL_RGBA12:
 555       case GL_RGBA16:
 556       /* float texture formats */
 557       case GL_ALPHA16F_ARB:
 558       case GL_ALPHA32F_ARB:
 559       case GL_LUMINANCE16F_ARB:
 560       case GL_LUMINANCE32F_ARB:
 561       case GL_LUMINANCE_ALPHA16F_ARB:
 562       case GL_LUMINANCE_ALPHA32F_ARB:
 563       case GL_INTENSITY16F_ARB:
 564       case GL_INTENSITY32F_ARB:
 565       case GL_R16F:
 566       case GL_R32F:
 567       case GL_RG16F:
 568       case GL_RG32F:
 569       case GL_RGB16F_ARB:
 570       case GL_RGB32F_ARB:
 571       case GL_RGBA16F_ARB:
 572       case GL_RGBA32F_ARB:
 573       /* compressed formats */
 574       case GL_COMPRESSED_ALPHA:
 575       case GL_COMPRESSED_LUMINANCE:
 576       case GL_COMPRESSED_LUMINANCE_ALPHA:
 577       case GL_COMPRESSED_INTENSITY:
 578       case GL_COMPRESSED_RED:
 579       case GL_COMPRESSED_RG:
 580       case GL_COMPRESSED_RGB:
 581       case GL_COMPRESSED_RGBA:
 582       case GL_RGB_S3TC:
 583       case GL_RGB4_S3TC:
 584       case GL_RGBA_S3TC:
 585       case GL_RGBA4_S3TC:
 586       case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 587       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 588       case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 589       case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 590       case GL_COMPRESSED_RGB_FXT1_3DFX:
 591       case GL_COMPRESSED_RGBA_FXT1_3DFX:
 592       case GL_SRGB_EXT:
 593       case GL_SRGB8_EXT:
 594       case GL_SRGB_ALPHA_EXT:
 595       case GL_SRGB8_ALPHA8_EXT:
 596       case GL_SLUMINANCE_ALPHA_EXT:
 597       case GL_SLUMINANCE8_ALPHA8_EXT:
 598       case GL_SLUMINANCE_EXT:
 599       case GL_SLUMINANCE8_EXT:
 600       case GL_COMPRESSED_SRGB_EXT:
 601       case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 602       case GL_COMPRESSED_SRGB_ALPHA_EXT:
 603       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 604       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 605       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 606       case GL_COMPRESSED_SLUMINANCE_EXT:
 607       case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 608       case GL_COMPRESSED_RED_RGTC1:
 609       case GL_COMPRESSED_SIGNED_RED_RGTC1:
 610       case GL_COMPRESSED_RG_RGTC2:
 611       case GL_COMPRESSED_SIGNED_RG_RGTC2:
 612       case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 613       case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 614       case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 615       case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 616       case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 617       case GL_ETC1_RGB8_OES:
 618       case GL_COMPRESSED_RGB8_ETC2:
 619       case GL_COMPRESSED_SRGB8_ETC2:
 620       case GL_COMPRESSED_RGBA8_ETC2_EAC:
 621       case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 622       case GL_COMPRESSED_R11_EAC:
 623       case GL_COMPRESSED_RG11_EAC:
 624       case GL_COMPRESSED_SIGNED_R11_EAC:
 625       case GL_COMPRESSED_SIGNED_RG11_EAC:
 626       case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 627       case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 628       /* generic integer formats */
 629       case GL_RED_INTEGER_EXT:
 630       case GL_GREEN_INTEGER_EXT:
 631       case GL_BLUE_INTEGER_EXT:
 632       case GL_ALPHA_INTEGER_EXT:
 633       case GL_RGB_INTEGER_EXT:
 634       case GL_RGBA_INTEGER_EXT:
 635       case GL_BGR_INTEGER_EXT:
 636       case GL_BGRA_INTEGER_EXT:
 637       case GL_RG_INTEGER:
 638       case GL_LUMINANCE_INTEGER_EXT:
 639       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 640       /* sized integer formats */
 641       case GL_RGBA32UI_EXT:
 642       case GL_RGB32UI_EXT:
 643       case GL_RG32UI:
 644       case GL_R32UI:
 645       case GL_ALPHA32UI_EXT:
 646       case GL_INTENSITY32UI_EXT:
 647       case GL_LUMINANCE32UI_EXT:
 648       case GL_LUMINANCE_ALPHA32UI_EXT:
 649       case GL_RGBA16UI_EXT:
 650       case GL_RGB16UI_EXT:
 651       case GL_RG16UI:
 652       case GL_R16UI:
 653       case GL_ALPHA16UI_EXT:
 654       case GL_INTENSITY16UI_EXT:
 655       case GL_LUMINANCE16UI_EXT:
 656       case GL_LUMINANCE_ALPHA16UI_EXT:
 657       case GL_RGBA8UI_EXT:
 658       case GL_RGB8UI_EXT:
 659       case GL_RG8UI:
 660       case GL_R8UI:
 661       case GL_ALPHA8UI_EXT:
 662       case GL_INTENSITY8UI_EXT:
 663       case GL_LUMINANCE8UI_EXT:
 664       case GL_LUMINANCE_ALPHA8UI_EXT:
 665       case GL_RGBA32I_EXT:
 666       case GL_RGB32I_EXT:
 667       case GL_RG32I:
 668       case GL_R32I:
 669       case GL_ALPHA32I_EXT:
 670       case GL_INTENSITY32I_EXT:
 671       case GL_LUMINANCE32I_EXT:
 672       case GL_LUMINANCE_ALPHA32I_EXT:
 673       case GL_RGBA16I_EXT:
 674       case GL_RGB16I_EXT:
 675       case GL_RG16I:
 676       case GL_R16I:
 677       case GL_ALPHA16I_EXT:
 678       case GL_INTENSITY16I_EXT:
 679       case GL_LUMINANCE16I_EXT:
 680       case GL_LUMINANCE_ALPHA16I_EXT:
 681       case GL_RGBA8I_EXT:
 682       case GL_RGB8I_EXT:
 683       case GL_RG8I:
 684       case GL_R8I:
 685       case GL_ALPHA8I_EXT:
 686       case GL_INTENSITY8I_EXT:
 687       case GL_LUMINANCE8I_EXT:
 688       case GL_LUMINANCE_ALPHA8I_EXT:
 689       /* signed, normalized texture formats */
 690       case GL_RED_SNORM:
 691       case GL_R8_SNORM:
 692       case GL_R16_SNORM:
 693       case GL_RG_SNORM:
 694       case GL_RG8_SNORM:
 695       case GL_RG16_SNORM:
 696       case GL_RGB_SNORM:
 697       case GL_RGB8_SNORM:
 698       case GL_RGB16_SNORM:
 699       case GL_RGBA_SNORM:
 700       case GL_RGBA8_SNORM:
 701       case GL_RGBA16_SNORM:
 702       case GL_ALPHA_SNORM:
 703       case GL_ALPHA8_SNORM:
 704       case GL_ALPHA16_SNORM:
 705       case GL_LUMINANCE_SNORM:
 706       case GL_LUMINANCE8_SNORM:
 707       case GL_LUMINANCE16_SNORM:
 708       case GL_LUMINANCE_ALPHA_SNORM:
 709       case GL_LUMINANCE8_ALPHA8_SNORM:
 710       case GL_LUMINANCE16_ALPHA16_SNORM:
 711       case GL_INTENSITY_SNORM:
 712       case GL_INTENSITY8_SNORM:
 713       case GL_INTENSITY16_SNORM:
 714       case GL_RGB9_E5:
 715       case GL_R11F_G11F_B10F:
 716       case GL_RGB10_A2UI:
 717          return GL_TRUE;
 718       case GL_YCBCR_MESA:  /* not considered to be RGB */
 719          /* fall-through */
 720       default:
 721          return GL_FALSE;
 722    }
 723 }
 724
 725
 726 /**
 727  * Test if the given image format is a depth component format.
 728  */
 729 GLboolean
 730 _mesa_is_depth_format(GLenum format)
 731 {
 732    switch (format) {
 733       case GL_DEPTH_COMPONENT:
 734       case GL_DEPTH_COMPONENT16:
 735       case GL_DEPTH_COMPONENT24:
 736       case GL_DEPTH_COMPONENT32:
 737       case GL_DEPTH_COMPONENT32F:
 738          return GL_TRUE;
 739       default:
 740          return GL_FALSE;
 741    }
 742 }
 743
 744
 745 /**
 746  * Test if the given image format is a stencil format.
 747  */
 748 GLboolean
 749 _mesa_is_stencil_format(GLenum format)
 750 {
 751    switch (format) {
 752       case GL_STENCIL_INDEX:
 753          return GL_TRUE;
 754       default:
 755          return GL_FALSE;
 756    }
 757 }
 758
 759
 760 /**
 761  * Test if the given image format is a YCbCr format.
 762  */
 763 GLboolean
 764 _mesa_is_ycbcr_format(GLenum format)
 765 {
 766    switch (format) {
 767       case GL_YCBCR_MESA:
 768          return GL_TRUE;
 769       default:
 770          return GL_FALSE;
 771    }
 772 }
 773
 774
 775 /**
 776  * Test if the given image format is a depth+stencil format.
 777  */
 778 GLboolean
 779 _mesa_is_depthstencil_format(GLenum format)
 780 {
 781    switch (format) {
 782       case GL_DEPTH24_STENCIL8_EXT:
 783       case GL_DEPTH_STENCIL_EXT:
 784       case GL_DEPTH32F_STENCIL8:
 785          return GL_TRUE;
 786       default:
 787          return GL_FALSE;
 788    }
 789 }
 790
 791
 792 /**
 793  * Test if the given image format is a depth or stencil format.
 794  */
 795 GLboolean
 796 _mesa_is_depth_or_stencil_format(GLenum format)
 797 {
 798    switch (format) {
 799       case GL_DEPTH_COMPONENT:
 800       case GL_DEPTH_COMPONENT16:
 801       case GL_DEPTH_COMPONENT24:
 802       case GL_DEPTH_COMPONENT32:
 803       case GL_STENCIL_INDEX:
 804       case GL_STENCIL_INDEX1_EXT:
 805       case GL_STENCIL_INDEX4_EXT:
 806       case GL_STENCIL_INDEX8_EXT:
 807       case GL_STENCIL_INDEX16_EXT:
 808       case GL_DEPTH_STENCIL_EXT:
 809       case GL_DEPTH24_STENCIL8_EXT:
 810       case GL_DEPTH_COMPONENT32F:
 811       case GL_DEPTH32F_STENCIL8:
 812          return GL_TRUE;
 813       default:
 814          return GL_FALSE;
 815    }
 816 }
 817
 818
 819 /**
 820  * Test if the given image format is a dudv format.
 821  */
 822 GLboolean
 823 _mesa_is_dudv_format(GLenum format)
 824 {
 825    switch (format) {
 826       case GL_DUDV_ATI:
 827       case GL_DU8DV8_ATI:
 828          return GL_TRUE;
 829       default:
 830          return GL_FALSE;
 831    }
 832 }
 833
 834
 835 /**
 836  * Test if an image format is a supported compressed format.
 837  * \param format the internal format token provided by the user.
 838  * \return GL_TRUE if compressed, GL_FALSE if uncompressed
 839  */
 840 GLboolean
 841 _mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
 842 {
 843    switch (format) {
 844    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 845    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 846    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 847    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 848       /* Assume that the ANGLE flag will always be set if the EXT flag is set.
 849        */
 850       return ctx->Extensions.ANGLE_texture_compression_dxt;
 851    case GL_RGB_S3TC:
 852    case GL_RGB4_S3TC:
 853    case GL_RGBA_S3TC:
 854    case GL_RGBA4_S3TC:
 855       return _mesa_is_desktop_gl(ctx) &&
 856          ctx->Extensions.ANGLE_texture_compression_dxt;
 857    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 858    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 859    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 860    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 861       return _mesa_is_desktop_gl(ctx)
 862          && ctx->Extensions.EXT_texture_sRGB
 863          && ctx->Extensions.EXT_texture_compression_s3tc;
 864    case GL_COMPRESSED_RGB_FXT1_3DFX:
 865    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 866       return _mesa_is_desktop_gl(ctx)
 867          && ctx->Extensions.TDFX_texture_compression_FXT1;
 868    case GL_COMPRESSED_RED_RGTC1:
 869    case GL_COMPRESSED_SIGNED_RED_RGTC1:
 870    case GL_COMPRESSED_RG_RGTC2:
 871    case GL_COMPRESSED_SIGNED_RG_RGTC2:
 872       return _mesa_is_desktop_gl(ctx)
 873          && ctx->Extensions.ARB_texture_compression_rgtc;
 874    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 875    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 876    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 877    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 878       return ctx->API == API_OPENGL_COMPAT
 879          && ctx->Extensions.EXT_texture_compression_latc;
 880    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 881       return ctx->API == API_OPENGL_COMPAT
 882          && ctx->Extensions.ATI_texture_compression_3dc;
 883    case GL_ETC1_RGB8_OES:
 884       return _mesa_is_gles(ctx)
 885          && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
 886    case GL_COMPRESSED_RGB8_ETC2:
 887    case GL_COMPRESSED_SRGB8_ETC2:
 888    case GL_COMPRESSED_RGBA8_ETC2_EAC:
 889    case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 890    case GL_COMPRESSED_R11_EAC:
 891    case GL_COMPRESSED_RG11_EAC:
 892    case GL_COMPRESSED_SIGNED_R11_EAC:
 893    case GL_COMPRESSED_SIGNED_RG11_EAC:
 894    case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 895    case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 896       return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility;
 897    case GL_PALETTE4_RGB8_OES:
 898    case GL_PALETTE4_RGBA8_OES:
 899    case GL_PALETTE4_R5_G6_B5_OES:
 900    case GL_PALETTE4_RGBA4_OES:
 901    case GL_PALETTE4_RGB5_A1_OES:
 902    case GL_PALETTE8_RGB8_OES:
 903    case GL_PALETTE8_RGBA8_OES:
 904    case GL_PALETTE8_R5_G6_B5_OES:
 905    case GL_PALETTE8_RGBA4_OES:
 906    case GL_PALETTE8_RGB5_A1_OES:
 907       return ctx->API == API_OPENGLES;
 908    default:
 909       return GL_FALSE;
 910    }
 911 }
 912
 913
 914 /**
 915  * Convert various base formats to the cooresponding integer format.
 916  */
 917 GLenum
 918 _mesa_base_format_to_integer_format(GLenum format)
 919 {
 920    switch(format) {
 921    case GL_RED:
 922       return GL_RED_INTEGER;
 923    case GL_GREEN:
 924       return GL_GREEN_INTEGER;
 925    case GL_BLUE:
 926       return GL_BLUE_INTEGER;
 927    case GL_RG:
 928       return GL_RG_INTEGER;
 929    case GL_RGB:
 930       return GL_RGB_INTEGER;
 931    case GL_RGBA:
 932       return GL_RGBA_INTEGER;
 933    case GL_BGR:
 934       return GL_BGR_INTEGER;
 935    case GL_BGRA:
 936       return GL_BGRA_INTEGER;
 937    case GL_ALPHA:
 938       return GL_ALPHA_INTEGER;
 939    case GL_LUMINANCE:
 940       return GL_LUMINANCE_INTEGER_EXT;
 941    case GL_LUMINANCE_ALPHA:
 942       return GL_LUMINANCE_ALPHA_INTEGER_EXT;
 943    }
 944
 945    return format;
 946 }
 947
 948
 949 /**
 950  * Does the given base texture/renderbuffer format have the channel
 951  * named by 'pname'?
 952  */
 953 GLboolean
 954 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
 955 {
 956    switch (pname) {
 957    case GL_TEXTURE_RED_SIZE:
 958    case GL_TEXTURE_RED_TYPE:
 959    case GL_RENDERBUFFER_RED_SIZE_EXT:
 960    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
 961       if (base_format == GL_RED ||
 962           base_format == GL_RG ||
 963           base_format == GL_RGB ||
 964           base_format == GL_RGBA) {
 965          return GL_TRUE;
 966       }
 967       return GL_FALSE;
 968    case GL_TEXTURE_GREEN_SIZE:
 969    case GL_TEXTURE_GREEN_TYPE:
 970    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
 971    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
 972       if (base_format == GL_RG ||
 973           base_format == GL_RGB ||
 974           base_format == GL_RGBA) {
 975          return GL_TRUE;
 976       }
 977       return GL_FALSE;
 978    case GL_TEXTURE_BLUE_SIZE:
 979    case GL_TEXTURE_BLUE_TYPE:
 980    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
 981    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
 982       if (base_format == GL_RGB ||
 983           base_format == GL_RGBA) {
 984          return GL_TRUE;
 985       }
 986       return GL_FALSE;
 987    case GL_TEXTURE_ALPHA_SIZE:
 988    case GL_TEXTURE_ALPHA_TYPE:
 989    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
 990    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
 991       if (base_format == GL_RGBA ||
 992           base_format == GL_ALPHA ||
 993           base_format == GL_LUMINANCE_ALPHA) {
 994          return GL_TRUE;
 995       }
 996       return GL_FALSE;
 997    case GL_TEXTURE_LUMINANCE_SIZE:
 998    case GL_TEXTURE_LUMINANCE_TYPE:
 999       if (base_format == GL_LUMINANCE ||
1000           base_format == GL_LUMINANCE_ALPHA) {
1001          return GL_TRUE;
1002       }
1003       return GL_FALSE;
1004    case GL_TEXTURE_INTENSITY_SIZE:
1005    case GL_TEXTURE_INTENSITY_TYPE:
1006       if (base_format == GL_INTENSITY) {
1007          return GL_TRUE;
1008       }
1009       return GL_FALSE;
1010    case GL_TEXTURE_DEPTH_SIZE:
1011    case GL_TEXTURE_DEPTH_TYPE:
1012    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1013    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1014       if (base_format == GL_DEPTH_STENCIL ||
1015           base_format == GL_DEPTH_COMPONENT) {
1016          return GL_TRUE;
1017       }
1018       return GL_FALSE;
1019    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1020    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1021       if (base_format == GL_DEPTH_STENCIL ||
1022           base_format == GL_STENCIL_INDEX) {
1023          return GL_TRUE;
1024       }
1025       return GL_FALSE;
1026    default:
1027       _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1028                     __FUNCTION__, pname);
1029       return GL_FALSE;
1030    }
1031
1032    return GL_FALSE;
1033 }
1034
1035
1036 /**
1037  * Returns the number of channels/components for a base format.
1038  */
1039 GLint
1040 _mesa_base_format_component_count(GLenum base_format)
1041 {
1042    switch (base_format) {
1043    case GL_RED:
1044    case GL_ALPHA:
1045    case GL_INTENSITY:
1046    case GL_DEPTH_COMPONENT:
1047       return 1;
1048    case GL_RG:
1049    case GL_LUMINANCE_ALPHA:
1050    case GL_DEPTH_STENCIL:
1051       return 2;
1052    case GL_RGB:
1053       return 3;
1054    case GL_RGBA:
1055       return 4;
1056    default:
1057       return -1;
1058    }
1059 }
1060
1061
1062 /**
1063  * If format is a generic compressed format, return the corresponding
1064  * non-compressed format.  For other formats, return the format as-is.
1065  */
1066 GLenum
1067 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1068 {
1069    switch (format) {
1070    case GL_COMPRESSED_RED:
1071       return GL_RED;
1072    case GL_COMPRESSED_RG:
1073       return GL_RG;
1074    case GL_COMPRESSED_RGB:
1075       return GL_RGB;
1076    case GL_COMPRESSED_RGBA:
1077       return GL_RGBA;
1078    case GL_COMPRESSED_ALPHA:
1079       return GL_ALPHA;
1080    case GL_COMPRESSED_LUMINANCE:
1081       return GL_LUMINANCE;
1082    case GL_COMPRESSED_LUMINANCE_ALPHA:
1083       return GL_LUMINANCE_ALPHA;
1084    case GL_COMPRESSED_INTENSITY:
1085       return GL_INTENSITY;
1086    /* sRGB formats */
1087    case GL_COMPRESSED_SRGB:
1088       return GL_SRGB;
1089    case GL_COMPRESSED_SRGB_ALPHA:
1090       return GL_SRGB_ALPHA;
1091    case GL_COMPRESSED_SLUMINANCE:
1092       return GL_SLUMINANCE;
1093    case GL_COMPRESSED_SLUMINANCE_ALPHA:
1094       return GL_SLUMINANCE_ALPHA;
1095    default:
1096       return format;
1097    }
1098 }
1099
1100
1101 /**
1102  * Return the equivalent non-generic internal format.
1103  * This is useful for comparing whether two internal formats are equivalent.
1104  */
1105 GLenum
1106 _mesa_get_nongeneric_internalformat(GLenum format)
1107 {
1108    switch (format) {
1109    /* GL 1.1 formats. */
1110    case 4:
1111    case GL_RGBA:
1112       return GL_RGBA8;
1113    case 3:
1114    case GL_RGB:
1115       return GL_RGB8;
1116    case 2:
1117    case GL_LUMINANCE_ALPHA:
1118       return GL_LUMINANCE8_ALPHA8;
1119    case 1:
1120    case GL_LUMINANCE:
1121       return GL_LUMINANCE8;
1122    case GL_ALPHA:
1123       return GL_ALPHA8;
1124    case GL_INTENSITY:
1125       return GL_INTENSITY8;
1126
1127    /* GL_ARB_texture_rg */
1128    case GL_RED:
1129       return GL_R8;
1130    case GL_RG:
1131       return GL_RG8;
1132
1133    /* GL_EXT_texture_sRGB */
1134    case GL_SRGB:
1135       return GL_SRGB8;
1136    case GL_SRGB_ALPHA:
1137       return GL_SRGB8_ALPHA8;
1138    case GL_SLUMINANCE:
1139       return GL_SLUMINANCE8;
1140    case GL_SLUMINANCE_ALPHA:
1141       return GL_SLUMINANCE8_ALPHA8;
1142
1143    /* GL_EXT_texture_snorm */
1144    case GL_RGBA_SNORM:
1145       return GL_RGBA8_SNORM;
1146    case GL_RGB_SNORM:
1147       return GL_RGB8_SNORM;
1148    case GL_RG_SNORM:
1149       return GL_RG8_SNORM;
1150    case GL_RED_SNORM:
1151       return GL_R8_SNORM;
1152    case GL_LUMINANCE_ALPHA_SNORM:
1153       return GL_LUMINANCE8_ALPHA8_SNORM;
1154    case GL_LUMINANCE_SNORM:
1155       return GL_LUMINANCE8_SNORM;
1156    case GL_ALPHA_SNORM:
1157       return GL_ALPHA8_SNORM;
1158    case GL_INTENSITY_SNORM:
1159       return GL_INTENSITY8_SNORM;
1160
1161    default:
1162       return format;
1163    }
1164 }
1165
1166
1167 /**
1168  * Convert an sRGB internal format to linear.
1169  */
1170 GLenum
1171 _mesa_get_linear_internalformat(GLenum format)
1172 {
1173    switch (format) {
1174    case GL_SRGB:
1175       return GL_RGB;
1176    case GL_SRGB_ALPHA:
1177       return GL_RGBA;
1178    case GL_SRGB8:
1179       return GL_RGB8;
1180    case GL_SRGB8_ALPHA8:
1181       return GL_RGBA8;
1182    case GL_SLUMINANCE8:
1183       return GL_LUMINANCE8;
1184    case GL_SLUMINANCE:
1185       return GL_LUMINANCE;
1186    case GL_SLUMINANCE_ALPHA:
1187       return GL_LUMINANCE_ALPHA;
1188    case GL_SLUMINANCE8_ALPHA8:
1189       return GL_LUMINANCE8_ALPHA8;
1190    default:
1191       return format;
1192    }
1193 }
1194
1195
1196 /**
1197  * Do error checking of format/type combinations for glReadPixels,
1198  * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1199  * and type values, we may either generate GL_INVALID_OPERATION or
1200  * GL_INVALID_ENUM.
1201  *
1202  * \param format pixel format.
1203  * \param type pixel type.
1204  *
1205  * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1206  */
1207 GLenum
1208 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1209                                   GLenum format, GLenum type)
1210 {
1211    /* From OpenGL 3.3 spec, page 220:
1212     *    "If the format is DEPTH_STENCIL, then values are taken from
1213     *    both the depth buffer and the stencil buffer. If there is no
1214     *    depth buffer or if there is no stencil buffer, then the error
1215     *    INVALID_OPERATION occurs. If the type parameter is not
1216     *    UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the
1217     *    error INVALID_ENUM occurs."
1218     *
1219     * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels
1220     * cannot be used to read depth or stencil in that API.
1221     */
1222    if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL
1223        && type != GL_UNSIGNED_INT_24_8
1224        && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1225       return GL_INVALID_ENUM;
1226
1227    /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1228    switch (type) {
1229    case GL_BITMAP:
1230       if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1231          return GL_INVALID_ENUM;
1232       }
1233       break;
1234
1235    case GL_UNSIGNED_BYTE_3_3_2:
1236    case GL_UNSIGNED_BYTE_2_3_3_REV:
1237    case GL_UNSIGNED_SHORT_5_6_5:
1238    case GL_UNSIGNED_SHORT_5_6_5_REV:
1239       if (format == GL_RGB) {
1240          break; /* OK */
1241       }
1242       if (format == GL_RGB_INTEGER_EXT &&
1243           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1244          break; /* OK */
1245       }
1246       return GL_INVALID_OPERATION;
1247
1248    case GL_UNSIGNED_SHORT_4_4_4_4:
1249    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1250    case GL_UNSIGNED_SHORT_5_5_5_1:
1251    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1252    case GL_UNSIGNED_INT_8_8_8_8:
1253    case GL_UNSIGNED_INT_8_8_8_8_REV:
1254    case GL_UNSIGNED_INT_10_10_10_2:
1255    case GL_UNSIGNED_INT_2_10_10_10_REV:
1256       if (format == GL_RGBA ||
1257           format == GL_BGRA ||
1258           format == GL_ABGR_EXT) {
1259          break; /* OK */
1260       }
1261       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1262           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1263          break; /* OK */
1264       }
1265       if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1266           ctx->API == API_OPENGLES2) {
1267          break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1268       }
1269       return GL_INVALID_OPERATION;
1270
1271    case GL_UNSIGNED_INT_24_8:
1272       if (format != GL_DEPTH_STENCIL) {
1273          return GL_INVALID_OPERATION;
1274       }
1275       return GL_NO_ERROR;
1276
1277    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1278       if (!ctx->Extensions.ARB_depth_buffer_float) {
1279          return GL_INVALID_ENUM;
1280       }
1281       if (format != GL_DEPTH_STENCIL) {
1282          return GL_INVALID_OPERATION;
1283       }
1284       return GL_NO_ERROR;
1285
1286    case GL_UNSIGNED_INT_10F_11F_11F_REV:
1287       if (!ctx->Extensions.EXT_packed_float) {
1288          return GL_INVALID_ENUM;
1289       }
1290       if (format != GL_RGB) {
1291          return GL_INVALID_OPERATION;
1292       }
1293       return GL_NO_ERROR;
1294
1295    default:
1296       ; /* fall-through */
1297    }
1298
1299    /* now, for each format, check the type for compatibility */
1300    switch (format) {
1301       case GL_COLOR_INDEX:
1302       case GL_STENCIL_INDEX:
1303          switch (type) {
1304             case GL_BITMAP:
1305             case GL_BYTE:
1306             case GL_UNSIGNED_BYTE:
1307             case GL_SHORT:
1308             case GL_UNSIGNED_SHORT:
1309             case GL_INT:
1310             case GL_UNSIGNED_INT:
1311             case GL_FLOAT:
1312             case GL_HALF_FLOAT:
1313                return GL_NO_ERROR;
1314             default:
1315                return GL_INVALID_ENUM;
1316          }
1317
1318       case GL_RED:
1319       case GL_GREEN:
1320       case GL_BLUE:
1321       case GL_ALPHA:
1322 #if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1323       case GL_INTENSITY:
1324 #endif
1325       case GL_LUMINANCE:
1326       case GL_LUMINANCE_ALPHA:
1327       case GL_DEPTH_COMPONENT:
1328          switch (type) {
1329             case GL_BYTE:
1330             case GL_UNSIGNED_BYTE:
1331             case GL_SHORT:
1332             case GL_UNSIGNED_SHORT:
1333             case GL_INT:
1334             case GL_UNSIGNED_INT:
1335             case GL_FLOAT:
1336             case GL_HALF_FLOAT:
1337                return GL_NO_ERROR;
1338             default:
1339                return GL_INVALID_ENUM;
1340          }
1341
1342       case GL_RG:
1343          if (!ctx->Extensions.ARB_texture_rg)
1344             return GL_INVALID_ENUM;
1345          switch (type) {
1346             case GL_BYTE:
1347             case GL_UNSIGNED_BYTE:
1348             case GL_SHORT:
1349             case GL_UNSIGNED_SHORT:
1350             case GL_INT:
1351             case GL_UNSIGNED_INT:
1352             case GL_FLOAT:
1353             case GL_HALF_FLOAT:
1354                return GL_NO_ERROR;
1355             default:
1356                return GL_INVALID_ENUM;
1357          }
1358
1359       case GL_RGB:
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             case GL_UNSIGNED_BYTE_3_3_2:
1369             case GL_UNSIGNED_BYTE_2_3_3_REV:
1370             case GL_UNSIGNED_SHORT_5_6_5:
1371             case GL_UNSIGNED_SHORT_5_6_5_REV:
1372             case GL_HALF_FLOAT:
1373                return GL_NO_ERROR;
1374             case GL_UNSIGNED_INT_2_10_10_10_REV:
1375                /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1376                return (ctx->API == API_OPENGLES2)
1377                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1378             case GL_UNSIGNED_INT_5_9_9_9_REV:
1379                return ctx->Extensions.EXT_texture_shared_exponent
1380                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1381             case GL_UNSIGNED_INT_10F_11F_11F_REV:
1382                return ctx->Extensions.EXT_packed_float
1383                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1384             default:
1385                return GL_INVALID_ENUM;
1386          }
1387
1388       case GL_BGR:
1389          switch (type) {
1390             /* NOTE: no packed types are supported with BGR.  That's
1391              * intentional, according to the GL spec.
1392              */
1393             case GL_BYTE:
1394             case GL_UNSIGNED_BYTE:
1395             case GL_SHORT:
1396             case GL_UNSIGNED_SHORT:
1397             case GL_INT:
1398             case GL_UNSIGNED_INT:
1399             case GL_FLOAT:
1400             case GL_HALF_FLOAT:
1401                return GL_NO_ERROR;
1402             default:
1403                return GL_INVALID_ENUM;
1404          }
1405
1406       case GL_RGBA:
1407       case GL_BGRA:
1408       case GL_ABGR_EXT:
1409          switch (type) {
1410             case GL_BYTE:
1411             case GL_UNSIGNED_BYTE:
1412             case GL_SHORT:
1413             case GL_UNSIGNED_SHORT:
1414             case GL_INT:
1415             case GL_UNSIGNED_INT:
1416             case GL_FLOAT:
1417             case GL_UNSIGNED_SHORT_4_4_4_4:
1418             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1419             case GL_UNSIGNED_SHORT_5_5_5_1:
1420             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1421             case GL_UNSIGNED_INT_8_8_8_8:
1422             case GL_UNSIGNED_INT_8_8_8_8_REV:
1423             case GL_UNSIGNED_INT_10_10_10_2:
1424             case GL_UNSIGNED_INT_2_10_10_10_REV:
1425             case GL_HALF_FLOAT:
1426                return GL_NO_ERROR;
1427             default:
1428                return GL_INVALID_ENUM;
1429          }
1430
1431       case GL_YCBCR_MESA:
1432          if (!ctx->Extensions.MESA_ycbcr_texture)
1433             return GL_INVALID_ENUM;
1434          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1435              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1436             return GL_NO_ERROR;
1437          else
1438             return GL_INVALID_OPERATION;
1439
1440       case GL_DEPTH_STENCIL:
1441          if (type == GL_UNSIGNED_INT_24_8)
1442             return GL_NO_ERROR;
1443          else if (ctx->Extensions.ARB_depth_buffer_float &&
1444              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1445             return GL_NO_ERROR;
1446          else
1447             return GL_INVALID_ENUM;
1448
1449       case GL_DUDV_ATI:
1450       case GL_DU8DV8_ATI:
1451          if (!ctx->Extensions.ATI_envmap_bumpmap)
1452             return GL_INVALID_ENUM;
1453          switch (type) {
1454             case GL_BYTE:
1455             case GL_UNSIGNED_BYTE:
1456             case GL_SHORT:
1457             case GL_UNSIGNED_SHORT:
1458             case GL_INT:
1459             case GL_UNSIGNED_INT:
1460             case GL_FLOAT:
1461                return GL_NO_ERROR;
1462             default:
1463                return GL_INVALID_ENUM;
1464          }
1465
1466       /* integer-valued formats */
1467       case GL_RED_INTEGER_EXT:
1468       case GL_GREEN_INTEGER_EXT:
1469       case GL_BLUE_INTEGER_EXT:
1470       case GL_ALPHA_INTEGER_EXT:
1471       case GL_RG_INTEGER:
1472          switch (type) {
1473             case GL_BYTE:
1474             case GL_UNSIGNED_BYTE:
1475             case GL_SHORT:
1476             case GL_UNSIGNED_SHORT:
1477             case GL_INT:
1478             case GL_UNSIGNED_INT:
1479                return (ctx->Version >= 30 ||
1480                        ctx->Extensions.EXT_texture_integer)
1481                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1482             default:
1483                return GL_INVALID_ENUM;
1484          }
1485
1486       case GL_RGB_INTEGER_EXT:
1487          switch (type) {
1488             case GL_BYTE:
1489             case GL_UNSIGNED_BYTE:
1490             case GL_SHORT:
1491             case GL_UNSIGNED_SHORT:
1492             case GL_INT:
1493             case GL_UNSIGNED_INT:
1494                return (ctx->Version >= 30 ||
1495                        ctx->Extensions.EXT_texture_integer)
1496                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1497             case GL_UNSIGNED_BYTE_3_3_2:
1498             case GL_UNSIGNED_BYTE_2_3_3_REV:
1499             case GL_UNSIGNED_SHORT_5_6_5:
1500             case GL_UNSIGNED_SHORT_5_6_5_REV:
1501                return ctx->Extensions.ARB_texture_rgb10_a2ui
1502                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1503             default:
1504                return GL_INVALID_ENUM;
1505          }
1506
1507       case GL_BGR_INTEGER_EXT:
1508          switch (type) {
1509             case GL_BYTE:
1510             case GL_UNSIGNED_BYTE:
1511             case GL_SHORT:
1512             case GL_UNSIGNED_SHORT:
1513             case GL_INT:
1514             case GL_UNSIGNED_INT:
1515             /* NOTE: no packed formats w/ BGR format */
1516                return (ctx->Version >= 30 ||
1517                        ctx->Extensions.EXT_texture_integer)
1518                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1519             default:
1520                return GL_INVALID_ENUM;
1521          }
1522
1523       case GL_RGBA_INTEGER_EXT:
1524       case GL_BGRA_INTEGER_EXT:
1525          switch (type) {
1526             case GL_BYTE:
1527             case GL_UNSIGNED_BYTE:
1528             case GL_SHORT:
1529             case GL_UNSIGNED_SHORT:
1530             case GL_INT:
1531             case GL_UNSIGNED_INT:
1532                return (ctx->Version >= 30 ||
1533                        ctx->Extensions.EXT_texture_integer)
1534                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1535             case GL_UNSIGNED_SHORT_4_4_4_4:
1536             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1537             case GL_UNSIGNED_SHORT_5_5_5_1:
1538             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1539             case GL_UNSIGNED_INT_8_8_8_8:
1540             case GL_UNSIGNED_INT_8_8_8_8_REV:
1541             case GL_UNSIGNED_INT_10_10_10_2:
1542             case GL_UNSIGNED_INT_2_10_10_10_REV:
1543                return ctx->Extensions.ARB_texture_rgb10_a2ui
1544                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1545             default:
1546                return GL_INVALID_ENUM;
1547          }
1548
1549       case GL_LUMINANCE_INTEGER_EXT:
1550       case GL_LUMINANCE_ALPHA_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                return ctx->Extensions.EXT_texture_integer
1559                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1560             default:
1561                return GL_INVALID_ENUM;
1562          }
1563
1564       default:
1565          return GL_INVALID_ENUM;
1566    }
1567    return GL_NO_ERROR;
1568 }
1569
1570
1571 /**
1572  * Do error checking of format/type combinations for OpenGL ES glReadPixels
1573  * and glTex[Sub]Image.
1574  * \return error code, or GL_NO_ERROR.
1575  */
1576 GLenum
1577 _mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1578                                      unsigned dimensions)
1579 {
1580    GLboolean type_valid = GL_TRUE;
1581
1582    switch (format) {
1583    case GL_ALPHA:
1584    case GL_LUMINANCE:
1585    case GL_LUMINANCE_ALPHA:
1586       type_valid = (type == GL_UNSIGNED_BYTE
1587                     || type == GL_FLOAT
1588                     || type == GL_HALF_FLOAT_OES);
1589       break;
1590
1591    case GL_RGB:
1592       type_valid = (type == GL_UNSIGNED_BYTE
1593                     || type == GL_UNSIGNED_SHORT_5_6_5
1594                     || type == GL_FLOAT
1595                     || type == GL_HALF_FLOAT_OES);
1596       break;
1597
1598    case GL_RGBA:
1599       type_valid = (type == GL_UNSIGNED_BYTE
1600                     || type == GL_UNSIGNED_SHORT_4_4_4_4
1601                     || type == GL_UNSIGNED_SHORT_5_5_5_1
1602                     || type == GL_FLOAT
1603                     || type == GL_HALF_FLOAT_OES
1604                     || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1605       break;
1606
1607    case GL_DEPTH_COMPONENT:
1608       /* This format is filtered against invalid dimensionalities elsewhere.
1609        */
1610       type_valid = (type == GL_UNSIGNED_SHORT
1611                     || type == GL_UNSIGNED_INT);
1612       break;
1613
1614    case GL_DEPTH_STENCIL:
1615       /* This format is filtered against invalid dimensionalities elsewhere.
1616        */
1617       type_valid = (type == GL_UNSIGNED_INT_24_8);
1618       break;
1619
1620    case GL_BGRA_EXT:
1621       type_valid = (type == GL_UNSIGNED_BYTE);
1622
1623       /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
1624        * the format does not appear to be allowed for 3D textures in OpenGL
1625        * ES.
1626        */
1627       if (dimensions != 2)
1628          return GL_INVALID_VALUE;
1629
1630       break;
1631
1632    default:
1633       return GL_INVALID_VALUE;
1634    }
1635
1636    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
1637 }
1638
1639
1640 /**
1641  * Do error checking of format/type combinations for OpenGL ES 3
1642  * glTex[Sub]Image.
1643  * \return error code, or GL_NO_ERROR.
1644  */
1645 GLenum
1646 _mesa_es3_error_check_format_and_type(GLenum format, GLenum type,
1647                                       GLenum internalFormat)
1648 {
1649    switch (format) {
1650    case GL_RGBA:
1651       switch (type) {
1652       case GL_UNSIGNED_BYTE:
1653          switch (internalFormat) {
1654          case GL_RGBA:
1655          case GL_RGBA8:
1656          case GL_RGB5_A1:
1657          case GL_RGBA4:
1658          case GL_SRGB8_ALPHA8_EXT:
1659             break;
1660          default:
1661             return GL_INVALID_OPERATION;
1662          }
1663          break;
1664
1665       case GL_BYTE:
1666          if (internalFormat != GL_RGBA8_SNORM)
1667             return GL_INVALID_OPERATION;
1668          break;
1669
1670       case GL_UNSIGNED_SHORT_4_4_4_4:
1671          switch (internalFormat) {
1672          case GL_RGBA:
1673          case GL_RGBA4:
1674             break;
1675          default:
1676             return GL_INVALID_OPERATION;
1677          }
1678          break;
1679
1680       case GL_UNSIGNED_SHORT_5_5_5_1:
1681          switch (internalFormat) {
1682          case GL_RGBA:
1683          case GL_RGB5_A1:
1684             break;
1685          default:
1686             return GL_INVALID_OPERATION;
1687          }
1688          break;
1689
1690       case GL_UNSIGNED_INT_2_10_10_10_REV:
1691          switch (internalFormat) {
1692          case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
1693          case GL_RGB10_A2:
1694          case GL_RGB5_A1:
1695             break;
1696          default:
1697             return GL_INVALID_OPERATION;
1698          }
1699          break;
1700
1701       case GL_HALF_FLOAT:
1702          if (internalFormat != GL_RGBA16F)
1703             return GL_INVALID_OPERATION;
1704          break;
1705
1706       case GL_FLOAT:
1707          switch (internalFormat) {
1708          case GL_RGBA16F:
1709          case GL_RGBA32F:
1710             break;
1711          default:
1712             return GL_INVALID_OPERATION;
1713          }
1714          break;
1715
1716       default:
1717          return GL_INVALID_OPERATION;
1718       }
1719       break;
1720
1721    case GL_RGBA_INTEGER:
1722       switch (type) {
1723       case GL_UNSIGNED_BYTE:
1724          if (internalFormat != GL_RGBA8UI)
1725             return GL_INVALID_OPERATION;
1726          break;
1727
1728       case GL_BYTE:
1729          if (internalFormat != GL_RGBA8I)
1730             return GL_INVALID_OPERATION;
1731          break;
1732
1733       case GL_UNSIGNED_SHORT:
1734          if (internalFormat != GL_RGBA16UI)
1735             return GL_INVALID_OPERATION;
1736          break;
1737
1738       case GL_SHORT:
1739          if (internalFormat != GL_RGBA16I)
1740             return GL_INVALID_OPERATION;
1741          break;
1742
1743       case GL_UNSIGNED_INT:
1744          if (internalFormat != GL_RGBA32UI)
1745             return GL_INVALID_OPERATION;
1746          break;
1747
1748       case GL_INT:
1749          if (internalFormat != GL_RGBA32I)
1750             return GL_INVALID_OPERATION;
1751          break;
1752
1753       case GL_UNSIGNED_INT_2_10_10_10_REV:
1754          if (internalFormat != GL_RGB10_A2UI)
1755             return GL_INVALID_OPERATION;
1756          break;
1757
1758       default:
1759          return GL_INVALID_OPERATION;
1760       }
1761       break;
1762
1763    case GL_RGB:
1764       switch (type) {
1765       case GL_UNSIGNED_BYTE:
1766          switch (internalFormat) {
1767          case GL_RGB:
1768          case GL_RGB8:
1769          case GL_RGB565:
1770          case GL_SRGB8:
1771             break;
1772          default:
1773             return GL_INVALID_OPERATION;
1774          }
1775          break;
1776
1777       case GL_BYTE:
1778          if (internalFormat != GL_RGB8_SNORM)
1779             return GL_INVALID_OPERATION;
1780          break;
1781
1782       case GL_UNSIGNED_SHORT_5_6_5:
1783          switch (internalFormat) {
1784          case GL_RGB:
1785          case GL_RGB565:
1786             break;
1787          default:
1788             return GL_INVALID_OPERATION;
1789          }
1790          break;
1791
1792       case GL_UNSIGNED_INT_10F_11F_11F_REV:
1793          if (internalFormat != GL_R11F_G11F_B10F)
1794             return GL_INVALID_OPERATION;
1795          break;
1796
1797       case GL_UNSIGNED_INT_5_9_9_9_REV:
1798          if (internalFormat != GL_RGB9_E5)
1799             return GL_INVALID_OPERATION;
1800          break;
1801
1802       case GL_HALF_FLOAT:
1803          switch (internalFormat) {
1804          case GL_RGB16F:
1805          case GL_R11F_G11F_B10F:
1806          case GL_RGB9_E5:
1807             break;
1808          default:
1809             return GL_INVALID_OPERATION;
1810          }
1811          break;
1812
1813       case GL_FLOAT:
1814          switch (internalFormat) {
1815          case GL_RGB16F:
1816          case GL_RGB32F:
1817          case GL_R11F_G11F_B10F:
1818          case GL_RGB9_E5:
1819             break;
1820          default:
1821             return GL_INVALID_OPERATION;
1822          }
1823          break;
1824
1825       case GL_UNSIGNED_INT_2_10_10_10_REV:
1826          switch (internalFormat) {
1827          case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
1828             break;
1829          default:
1830             return GL_INVALID_OPERATION;
1831          }
1832          break;
1833
1834       default:
1835          return GL_INVALID_OPERATION;
1836       }
1837       break;
1838
1839    case GL_RGB_INTEGER:
1840       switch (type) {
1841       case GL_UNSIGNED_BYTE:
1842          if (internalFormat != GL_RGB8UI)
1843             return GL_INVALID_OPERATION;
1844          break;
1845
1846       case GL_BYTE:
1847          if (internalFormat != GL_RGB8I)
1848             return GL_INVALID_OPERATION;
1849          break;
1850
1851       case GL_UNSIGNED_SHORT:
1852          if (internalFormat != GL_RGB16UI)
1853             return GL_INVALID_OPERATION;
1854          break;
1855
1856       case GL_SHORT:
1857          if (internalFormat != GL_RGB16I)
1858             return GL_INVALID_OPERATION;
1859          break;
1860
1861       case GL_UNSIGNED_INT:
1862          if (internalFormat != GL_RGB32UI)
1863             return GL_INVALID_OPERATION;
1864          break;
1865
1866       case GL_INT:
1867          if (internalFormat != GL_RGB32I)
1868             return GL_INVALID_OPERATION;
1869          break;
1870
1871       default:
1872          return GL_INVALID_OPERATION;
1873       }
1874       break;
1875
1876    case GL_RG:
1877       switch (type) {
1878       case GL_UNSIGNED_BYTE:
1879          if (internalFormat != GL_RG8)
1880             return GL_INVALID_OPERATION;
1881          break;
1882
1883       case GL_BYTE:
1884          if (internalFormat != GL_RG8_SNORM)
1885             return GL_INVALID_OPERATION;
1886          break;
1887
1888       case GL_HALF_FLOAT:
1889          if (internalFormat != GL_RG16F)
1890             return GL_INVALID_OPERATION;
1891          break;
1892
1893       case GL_FLOAT:
1894          switch (internalFormat) {
1895          case GL_RG16F:
1896          case GL_RG32F:
1897             break;
1898          default:
1899             return GL_INVALID_OPERATION;
1900          }
1901          break;
1902
1903       default:
1904          return GL_INVALID_OPERATION;
1905       }
1906       break;
1907
1908    case GL_RG_INTEGER:
1909       switch (type) {
1910       case GL_UNSIGNED_BYTE:
1911          if (internalFormat != GL_RG8UI)
1912             return GL_INVALID_OPERATION;
1913          break;
1914
1915       case GL_BYTE:
1916          if (internalFormat != GL_RG8I)
1917             return GL_INVALID_OPERATION;
1918          break;
1919
1920       case GL_UNSIGNED_SHORT:
1921          if (internalFormat != GL_RG16UI)
1922             return GL_INVALID_OPERATION;
1923          break;
1924
1925       case GL_SHORT:
1926          if (internalFormat != GL_RG16I)
1927             return GL_INVALID_OPERATION;
1928          break;
1929
1930       case GL_UNSIGNED_INT:
1931          if (internalFormat != GL_RG32UI)
1932             return GL_INVALID_OPERATION;
1933          break;
1934
1935       case GL_INT:
1936          if (internalFormat != GL_RG32I)
1937             return GL_INVALID_OPERATION;
1938          break;
1939
1940       default:
1941          return GL_INVALID_OPERATION;
1942       }
1943       break;
1944
1945    case GL_RED:
1946       switch (type) {
1947       case GL_UNSIGNED_BYTE:
1948          if (internalFormat != GL_R8)
1949             return GL_INVALID_OPERATION;
1950          break;
1951
1952       case GL_BYTE:
1953          if (internalFormat != GL_R8_SNORM)
1954             return GL_INVALID_OPERATION;
1955          break;
1956
1957       case GL_HALF_FLOAT:
1958          if (internalFormat != GL_R16F)
1959             return GL_INVALID_OPERATION;
1960          break;
1961
1962       case GL_FLOAT:
1963          switch (internalFormat) {
1964          case GL_R16F:
1965          case GL_R32F:
1966             break;
1967          default:
1968             return GL_INVALID_OPERATION;
1969          }
1970          break;
1971
1972       default:
1973          return GL_INVALID_OPERATION;
1974       }
1975       break;
1976
1977    case GL_RED_INTEGER:
1978       switch (type) {
1979       case GL_UNSIGNED_BYTE:
1980          if (internalFormat != GL_R8UI)
1981             return GL_INVALID_OPERATION;
1982          break;
1983
1984       case GL_BYTE:
1985          if (internalFormat != GL_R8I)
1986             return GL_INVALID_OPERATION;
1987          break;
1988
1989       case GL_UNSIGNED_SHORT:
1990          if (internalFormat != GL_R16UI)
1991             return GL_INVALID_OPERATION;
1992          break;
1993
1994       case GL_SHORT:
1995          if (internalFormat != GL_R16I)
1996             return GL_INVALID_OPERATION;
1997          break;
1998
1999       case GL_UNSIGNED_INT:
2000          if (internalFormat != GL_R32UI)
2001             return GL_INVALID_OPERATION;
2002          break;
2003
2004       case GL_INT:
2005          if (internalFormat != GL_R32I)
2006             return GL_INVALID_OPERATION;
2007          break;
2008
2009       default:
2010          return GL_INVALID_OPERATION;
2011       }
2012       break;
2013
2014    case GL_DEPTH_COMPONENT:
2015       switch (type) {
2016       case GL_UNSIGNED_SHORT:
2017          if (internalFormat != GL_DEPTH_COMPONENT
2018              && internalFormat != GL_DEPTH_COMPONENT16)
2019             return GL_INVALID_OPERATION;
2020          break;
2021
2022       case GL_UNSIGNED_INT:
2023          switch (internalFormat) {
2024          case GL_DEPTH_COMPONENT:
2025          case GL_DEPTH_COMPONENT16:
2026          case GL_DEPTH_COMPONENT24:
2027             break;
2028          default:
2029             return GL_INVALID_OPERATION;
2030          }
2031          break;
2032
2033       case GL_FLOAT:
2034          if (internalFormat != GL_DEPTH_COMPONENT32F)
2035             return GL_INVALID_OPERATION;
2036          break;
2037
2038       default:
2039          return GL_INVALID_OPERATION;
2040       }
2041       break;
2042
2043    case GL_DEPTH_STENCIL:
2044       switch (type) {
2045       case GL_UNSIGNED_INT_24_8:
2046          if (internalFormat != GL_DEPTH_STENCIL
2047              && internalFormat != GL_DEPTH24_STENCIL8)
2048             return GL_INVALID_OPERATION;
2049          break;
2050
2051       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2052          if (internalFormat != GL_DEPTH32F_STENCIL8)
2053             return GL_INVALID_OPERATION;
2054          break;
2055
2056       default:
2057          return GL_INVALID_OPERATION;
2058       }
2059       break;
2060
2061    case GL_ALPHA:
2062    case GL_LUMINANCE:
2063    case GL_LUMINANCE_ALPHA:
2064       if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2065          return GL_INVALID_OPERATION;
2066       break;
2067    }
2068
2069    return GL_NO_ERROR;
2070 }