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