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