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       return ctx->Extensions.EXT_texture_compression_s3tc;
 871    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 872    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 873       return (_mesa_is_desktop_gl(ctx) &&
 874               ctx->Extensions.EXT_texture_compression_s3tc) ||
 875              (ctx->API == API_OPENGLES2 &&
 876               ctx->Extensions.ANGLE_texture_compression_dxt);
 877    case GL_RGB_S3TC:
 878    case GL_RGB4_S3TC:
 879    case GL_RGBA_S3TC:
 880    case GL_RGBA4_S3TC:
 881       return _mesa_is_desktop_gl(ctx) &&
 882          ctx->Extensions.ANGLE_texture_compression_dxt;
 883    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 884    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 885    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 886    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 887       return _mesa_is_desktop_gl(ctx)
 888          && ctx->Extensions.EXT_texture_sRGB
 889          && ctx->Extensions.EXT_texture_compression_s3tc;
 890    case GL_COMPRESSED_RGB_FXT1_3DFX:
 891    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 892       return _mesa_is_desktop_gl(ctx)
 893          && ctx->Extensions.TDFX_texture_compression_FXT1;
 894    case GL_COMPRESSED_RED_RGTC1:
 895    case GL_COMPRESSED_SIGNED_RED_RGTC1:
 896    case GL_COMPRESSED_RG_RGTC2:
 897    case GL_COMPRESSED_SIGNED_RG_RGTC2:
 898       return _mesa_is_desktop_gl(ctx)
 899          && ctx->Extensions.ARB_texture_compression_rgtc;
 900    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 901    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 902    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 903    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 904       return ctx->API == API_OPENGL_COMPAT
 905          && ctx->Extensions.EXT_texture_compression_latc;
 906    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 907       return ctx->API == API_OPENGL_COMPAT
 908          && ctx->Extensions.ATI_texture_compression_3dc;
 909    case GL_ETC1_RGB8_OES:
 910       return _mesa_is_gles(ctx)
 911          && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
 912    case GL_COMPRESSED_RGB8_ETC2:
 913    case GL_COMPRESSED_SRGB8_ETC2:
 914    case GL_COMPRESSED_RGBA8_ETC2_EAC:
 915    case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 916    case GL_COMPRESSED_R11_EAC:
 917    case GL_COMPRESSED_RG11_EAC:
 918    case GL_COMPRESSED_SIGNED_R11_EAC:
 919    case GL_COMPRESSED_SIGNED_RG11_EAC:
 920    case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 921    case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 922       return _mesa_is_gles3(ctx);
 923    case GL_PALETTE4_RGB8_OES:
 924    case GL_PALETTE4_RGBA8_OES:
 925    case GL_PALETTE4_R5_G6_B5_OES:
 926    case GL_PALETTE4_RGBA4_OES:
 927    case GL_PALETTE4_RGB5_A1_OES:
 928    case GL_PALETTE8_RGB8_OES:
 929    case GL_PALETTE8_RGBA8_OES:
 930    case GL_PALETTE8_R5_G6_B5_OES:
 931    case GL_PALETTE8_RGBA4_OES:
 932    case GL_PALETTE8_RGB5_A1_OES:
 933       return ctx->API == API_OPENGLES;
 934    default:
 935       return GL_FALSE;
 936    }
 937 }
 938
 939
 940 /**
 941  * Convert various base formats to the cooresponding integer format.
 942  */
 943 GLenum
 944 _mesa_base_format_to_integer_format(GLenum format)
 945 {
 946    switch(format) {
 947    case GL_RED:
 948       return GL_RED_INTEGER;
 949    case GL_GREEN:
 950       return GL_GREEN_INTEGER;
 951    case GL_BLUE:
 952       return GL_BLUE_INTEGER;
 953    case GL_RG:
 954       return GL_RG_INTEGER;
 955    case GL_RGB:
 956       return GL_RGB_INTEGER;
 957    case GL_RGBA:
 958       return GL_RGBA_INTEGER;
 959    case GL_BGR:
 960       return GL_BGR_INTEGER;
 961    case GL_BGRA:
 962       return GL_BGRA_INTEGER;
 963    case GL_ALPHA:
 964       return GL_ALPHA_INTEGER;
 965    case GL_LUMINANCE:
 966       return GL_LUMINANCE_INTEGER_EXT;
 967    case GL_LUMINANCE_ALPHA:
 968       return GL_LUMINANCE_ALPHA_INTEGER_EXT;
 969    }
 970
 971    return format;
 972 }
 973
 974
 975 /**
 976  * Does the given base texture/renderbuffer format have the channel
 977  * named by 'pname'?
 978  */
 979 GLboolean
 980 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
 981 {
 982    switch (pname) {
 983    case GL_TEXTURE_RED_SIZE:
 984    case GL_TEXTURE_RED_TYPE:
 985    case GL_RENDERBUFFER_RED_SIZE_EXT:
 986    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
 987       if (base_format == GL_RED ||
 988           base_format == GL_RG ||
 989           base_format == GL_RGB ||
 990           base_format == GL_RGBA) {
 991          return GL_TRUE;
 992       }
 993       return GL_FALSE;
 994    case GL_TEXTURE_GREEN_SIZE:
 995    case GL_TEXTURE_GREEN_TYPE:
 996    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
 997    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
 998       if (base_format == GL_RG ||
 999           base_format == GL_RGB ||
1000           base_format == GL_RGBA) {
1001          return GL_TRUE;
1002       }
1003       return GL_FALSE;
1004    case GL_TEXTURE_BLUE_SIZE:
1005    case GL_TEXTURE_BLUE_TYPE:
1006    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1007    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1008       if (base_format == GL_RGB ||
1009           base_format == GL_RGBA) {
1010          return GL_TRUE;
1011       }
1012       return GL_FALSE;
1013    case GL_TEXTURE_ALPHA_SIZE:
1014    case GL_TEXTURE_ALPHA_TYPE:
1015    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1016    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1017       if (base_format == GL_RGBA ||
1018           base_format == GL_ALPHA ||
1019           base_format == GL_LUMINANCE_ALPHA) {
1020          return GL_TRUE;
1021       }
1022       return GL_FALSE;
1023    case GL_TEXTURE_LUMINANCE_SIZE:
1024    case GL_TEXTURE_LUMINANCE_TYPE:
1025       if (base_format == GL_LUMINANCE ||
1026           base_format == GL_LUMINANCE_ALPHA) {
1027          return GL_TRUE;
1028       }
1029       return GL_FALSE;
1030    case GL_TEXTURE_INTENSITY_SIZE:
1031    case GL_TEXTURE_INTENSITY_TYPE:
1032       if (base_format == GL_INTENSITY) {
1033          return GL_TRUE;
1034       }
1035       return GL_FALSE;
1036    case GL_TEXTURE_DEPTH_SIZE:
1037    case GL_TEXTURE_DEPTH_TYPE:
1038    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1039    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1040       if (base_format == GL_DEPTH_STENCIL ||
1041           base_format == GL_DEPTH_COMPONENT) {
1042          return GL_TRUE;
1043       }
1044       return GL_FALSE;
1045    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1046    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1047       if (base_format == GL_DEPTH_STENCIL ||
1048           base_format == GL_STENCIL_INDEX) {
1049          return GL_TRUE;
1050       }
1051       return GL_FALSE;
1052    default:
1053       _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1054                     __FUNCTION__, pname);
1055       return GL_FALSE;
1056    }
1057
1058    return GL_FALSE;
1059 }
1060
1061
1062 /**
1063  * Returns the number of channels/components for a base format.
1064  */
1065 GLint
1066 _mesa_base_format_component_count(GLenum base_format)
1067 {
1068    switch (base_format) {
1069    case GL_RED:
1070    case GL_ALPHA:
1071    case GL_INTENSITY:
1072    case GL_DEPTH_COMPONENT:
1073       return 1;
1074    case GL_RG:
1075    case GL_LUMINANCE_ALPHA:
1076    case GL_DEPTH_STENCIL:
1077       return 2;
1078    case GL_RGB:
1079       return 3;
1080    case GL_RGBA:
1081       return 4;
1082    default:
1083       return -1;
1084    }
1085 }
1086
1087
1088 /**
1089  * If format is a generic compressed format, return the corresponding
1090  * non-compressed format.  For other formats, return the format as-is.
1091  */
1092 GLenum
1093 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1094 {
1095    switch (format) {
1096    case GL_COMPRESSED_RED:
1097       return GL_RED;
1098    case GL_COMPRESSED_RG:
1099       return GL_RG;
1100    case GL_COMPRESSED_RGB:
1101       return GL_RGB;
1102    case GL_COMPRESSED_RGBA:
1103       return GL_RGBA;
1104    case GL_COMPRESSED_ALPHA:
1105       return GL_ALPHA;
1106    case GL_COMPRESSED_LUMINANCE:
1107       return GL_LUMINANCE;
1108    case GL_COMPRESSED_LUMINANCE_ALPHA:
1109       return GL_LUMINANCE_ALPHA;
1110    case GL_COMPRESSED_INTENSITY:
1111       return GL_INTENSITY;
1112    /* sRGB formats */
1113    case GL_COMPRESSED_SRGB:
1114       return GL_SRGB;
1115    case GL_COMPRESSED_SRGB_ALPHA:
1116       return GL_SRGB_ALPHA;
1117    case GL_COMPRESSED_SLUMINANCE:
1118       return GL_SLUMINANCE;
1119    case GL_COMPRESSED_SLUMINANCE_ALPHA:
1120       return GL_SLUMINANCE_ALPHA;
1121    default:
1122       return format;
1123    }
1124 }
1125
1126
1127 /**
1128  * Return the equivalent non-generic internal format.
1129  * This is useful for comparing whether two internal formats are equivalent.
1130  */
1131 GLenum
1132 _mesa_get_nongeneric_internalformat(GLenum format)
1133 {
1134    switch (format) {
1135       /* GL 1.1 formats. */
1136       case 4:
1137       case GL_RGBA:
1138          return GL_RGBA8;
1139
1140       case 3:
1141       case GL_RGB:
1142          return GL_RGB8;
1143
1144       case 2:
1145       case GL_LUMINANCE_ALPHA:
1146          return GL_LUMINANCE8_ALPHA8;
1147
1148       case 1:
1149       case GL_LUMINANCE:
1150          return GL_LUMINANCE8;
1151
1152       case GL_ALPHA:
1153          return GL_ALPHA8;
1154
1155       case GL_INTENSITY:
1156          return GL_INTENSITY8;
1157
1158       /* GL_ARB_texture_rg */
1159       case GL_RED:
1160          return GL_R8;
1161
1162       case GL_RG:
1163          return GL_RG8;
1164
1165       /* GL_EXT_texture_sRGB */
1166       case GL_SRGB:
1167          return GL_SRGB8;
1168
1169       case GL_SRGB_ALPHA:
1170          return GL_SRGB8_ALPHA8;
1171
1172       case GL_SLUMINANCE:
1173          return GL_SLUMINANCE8;
1174
1175       case GL_SLUMINANCE_ALPHA:
1176          return GL_SLUMINANCE8_ALPHA8;
1177
1178       /* GL_EXT_texture_snorm */
1179       case GL_RGBA_SNORM:
1180          return GL_RGBA8_SNORM;
1181
1182       case GL_RGB_SNORM:
1183          return GL_RGB8_SNORM;
1184
1185       case GL_RG_SNORM:
1186          return GL_RG8_SNORM;
1187
1188       case GL_RED_SNORM:
1189          return GL_R8_SNORM;
1190
1191       case GL_LUMINANCE_ALPHA_SNORM:
1192          return GL_LUMINANCE8_ALPHA8_SNORM;
1193
1194       case GL_LUMINANCE_SNORM:
1195          return GL_LUMINANCE8_SNORM;
1196
1197       case GL_ALPHA_SNORM:
1198          return GL_ALPHA8_SNORM;
1199
1200       case GL_INTENSITY_SNORM:
1201          return GL_INTENSITY8_SNORM;
1202
1203       default:
1204          return format;
1205    }
1206 }
1207
1208
1209 /**
1210  * Convert an sRGB internal format to linear.
1211  */
1212 GLenum
1213 _mesa_get_linear_internalformat(GLenum format)
1214 {
1215    switch (format) {
1216    case GL_SRGB:
1217       return GL_RGB;
1218
1219    case GL_SRGB_ALPHA:
1220       return GL_RGBA;
1221
1222    case GL_SRGB8:
1223       return GL_RGB8;
1224
1225    case GL_SRGB8_ALPHA8:
1226       return GL_RGBA8;
1227
1228    case GL_SLUMINANCE:
1229       return GL_LUMINANCE8;
1230
1231    case GL_SLUMINANCE_ALPHA:
1232       return GL_LUMINANCE8_ALPHA8;
1233
1234    default:
1235       return format;
1236    }
1237 }
1238
1239
1240 /**
1241  * Do error checking of format/type combinations for glReadPixels,
1242  * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1243  * and type values, we may either generate GL_INVALID_OPERATION or
1244  * GL_INVALID_ENUM.
1245  *
1246  * \param format pixel format.
1247  * \param type pixel type.
1248  *
1249  * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1250  */
1251 GLenum
1252 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1253                                   GLenum format, GLenum type)
1254 {
1255    /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1256    switch (type) {
1257    case GL_BITMAP:
1258       if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1259          return GL_INVALID_ENUM;
1260       }
1261       break;
1262
1263    case GL_UNSIGNED_BYTE_3_3_2:
1264    case GL_UNSIGNED_BYTE_2_3_3_REV:
1265    case GL_UNSIGNED_SHORT_5_6_5:
1266    case GL_UNSIGNED_SHORT_5_6_5_REV:
1267       if (format == GL_RGB) {
1268          break; /* OK */
1269       }
1270       if (format == GL_RGB_INTEGER_EXT &&
1271           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1272          break; /* OK */
1273       }
1274       return GL_INVALID_OPERATION;
1275
1276    case GL_UNSIGNED_SHORT_4_4_4_4:
1277    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1278    case GL_UNSIGNED_SHORT_5_5_5_1:
1279    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1280    case GL_UNSIGNED_INT_8_8_8_8:
1281    case GL_UNSIGNED_INT_8_8_8_8_REV:
1282    case GL_UNSIGNED_INT_10_10_10_2:
1283    case GL_UNSIGNED_INT_2_10_10_10_REV:
1284       if (format == GL_RGBA ||
1285           format == GL_BGRA ||
1286           format == GL_ABGR_EXT) {
1287          break; /* OK */
1288       }
1289       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1290           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1291          break; /* OK */
1292       }
1293       if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1294           ctx->API == API_OPENGLES2) {
1295          break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1296       }
1297       return GL_INVALID_OPERATION;
1298
1299    case GL_UNSIGNED_INT_24_8:
1300       if (!ctx->Extensions.EXT_packed_depth_stencil) {
1301          return GL_INVALID_ENUM;
1302       }
1303       if (format != GL_DEPTH_STENCIL) {
1304          return GL_INVALID_OPERATION;
1305       }
1306       return GL_NO_ERROR;
1307
1308    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1309       if (!ctx->Extensions.ARB_depth_buffer_float) {
1310          return GL_INVALID_ENUM;
1311       }
1312       if (format != GL_DEPTH_STENCIL) {
1313          return GL_INVALID_OPERATION;
1314       }
1315       return GL_NO_ERROR;
1316
1317    case GL_UNSIGNED_INT_10F_11F_11F_REV:
1318       if (!ctx->Extensions.EXT_packed_float) {
1319          return GL_INVALID_ENUM;
1320       }
1321       if (format != GL_RGB) {
1322          return GL_INVALID_OPERATION;
1323       }
1324       return GL_NO_ERROR;
1325
1326    default:
1327       ; /* fall-through */
1328    }
1329
1330    /* now, for each format, check the type for compatibility */
1331    switch (format) {
1332       case GL_COLOR_INDEX:
1333       case GL_STENCIL_INDEX:
1334          switch (type) {
1335             case GL_BITMAP:
1336             case GL_BYTE:
1337             case GL_UNSIGNED_BYTE:
1338             case GL_SHORT:
1339             case GL_UNSIGNED_SHORT:
1340             case GL_INT:
1341             case GL_UNSIGNED_INT:
1342             case GL_FLOAT:
1343                return GL_NO_ERROR;
1344             case GL_HALF_FLOAT:
1345                return ctx->Extensions.ARB_half_float_pixel
1346                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1347             default:
1348                return GL_INVALID_ENUM;
1349          }
1350
1351       case GL_RED:
1352       case GL_GREEN:
1353       case GL_BLUE:
1354       case GL_ALPHA:
1355 #if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1356       case GL_INTENSITY:
1357 #endif
1358       case GL_LUMINANCE:
1359       case GL_LUMINANCE_ALPHA:
1360       case GL_DEPTH_COMPONENT:
1361          switch (type) {
1362             case GL_BYTE:
1363             case GL_UNSIGNED_BYTE:
1364             case GL_SHORT:
1365             case GL_UNSIGNED_SHORT:
1366             case GL_INT:
1367             case GL_UNSIGNED_INT:
1368             case GL_FLOAT:
1369                return GL_NO_ERROR;
1370             case GL_HALF_FLOAT:
1371                return ctx->Extensions.ARB_half_float_pixel
1372                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1373             default:
1374                return GL_INVALID_ENUM;
1375          }
1376
1377       case GL_RG:
1378          if (!ctx->Extensions.ARB_texture_rg)
1379             return GL_INVALID_ENUM;
1380          switch (type) {
1381             case GL_BYTE:
1382             case GL_UNSIGNED_BYTE:
1383             case GL_SHORT:
1384             case GL_UNSIGNED_SHORT:
1385             case GL_INT:
1386             case GL_UNSIGNED_INT:
1387             case GL_FLOAT:
1388                return GL_NO_ERROR;
1389             case GL_HALF_FLOAT:
1390                return ctx->Extensions.ARB_half_float_pixel
1391                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1392             default:
1393                return GL_INVALID_ENUM;
1394          }
1395
1396       case GL_RGB:
1397          switch (type) {
1398             case GL_BYTE:
1399             case GL_UNSIGNED_BYTE:
1400             case GL_SHORT:
1401             case GL_UNSIGNED_SHORT:
1402             case GL_INT:
1403             case GL_UNSIGNED_INT:
1404             case GL_FLOAT:
1405             case GL_UNSIGNED_BYTE_3_3_2:
1406             case GL_UNSIGNED_BYTE_2_3_3_REV:
1407             case GL_UNSIGNED_SHORT_5_6_5:
1408             case GL_UNSIGNED_SHORT_5_6_5_REV:
1409                return GL_NO_ERROR;
1410             case GL_UNSIGNED_INT_2_10_10_10_REV:
1411                /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1412                return (ctx->API == API_OPENGLES2)
1413                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1414             case GL_HALF_FLOAT:
1415                return ctx->Extensions.ARB_half_float_pixel
1416                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1417             case GL_UNSIGNED_INT_5_9_9_9_REV:
1418                return ctx->Extensions.EXT_texture_shared_exponent
1419                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1420             case GL_UNSIGNED_INT_10F_11F_11F_REV:
1421                return ctx->Extensions.EXT_packed_float
1422                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1423             default:
1424                return GL_INVALID_ENUM;
1425          }
1426
1427       case GL_BGR:
1428          switch (type) {
1429             /* NOTE: no packed types are supported with BGR.  That's
1430              * intentional, according to the GL spec.
1431              */
1432             case GL_BYTE:
1433             case GL_UNSIGNED_BYTE:
1434             case GL_SHORT:
1435             case GL_UNSIGNED_SHORT:
1436             case GL_INT:
1437             case GL_UNSIGNED_INT:
1438             case GL_FLOAT:
1439                return GL_NO_ERROR;
1440             case GL_HALF_FLOAT:
1441                return ctx->Extensions.ARB_half_float_pixel
1442                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1443             default:
1444                return GL_INVALID_ENUM;
1445          }
1446
1447       case GL_RGBA:
1448       case GL_BGRA:
1449       case GL_ABGR_EXT:
1450          switch (type) {
1451             case GL_BYTE:
1452             case GL_UNSIGNED_BYTE:
1453             case GL_SHORT:
1454             case GL_UNSIGNED_SHORT:
1455             case GL_INT:
1456             case GL_UNSIGNED_INT:
1457             case GL_FLOAT:
1458             case GL_UNSIGNED_SHORT_4_4_4_4:
1459             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1460             case GL_UNSIGNED_SHORT_5_5_5_1:
1461             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1462             case GL_UNSIGNED_INT_8_8_8_8:
1463             case GL_UNSIGNED_INT_8_8_8_8_REV:
1464             case GL_UNSIGNED_INT_10_10_10_2:
1465             case GL_UNSIGNED_INT_2_10_10_10_REV:
1466                return GL_NO_ERROR;
1467             case GL_HALF_FLOAT:
1468                return ctx->Extensions.ARB_half_float_pixel
1469                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1470             default:
1471                return GL_INVALID_ENUM;
1472          }
1473
1474       case GL_YCBCR_MESA:
1475          if (!ctx->Extensions.MESA_ycbcr_texture)
1476             return GL_INVALID_ENUM;
1477          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1478              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1479             return GL_NO_ERROR;
1480          else
1481             return GL_INVALID_OPERATION;
1482
1483       case GL_DEPTH_STENCIL_EXT:
1484          if (ctx->Extensions.EXT_packed_depth_stencil &&
1485              type == GL_UNSIGNED_INT_24_8)
1486             return GL_NO_ERROR;
1487          else if (ctx->Extensions.ARB_depth_buffer_float &&
1488              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1489             return GL_NO_ERROR;
1490          switch (type) {
1491          case GL_BYTE:
1492          case GL_UNSIGNED_BYTE:
1493          case GL_SHORT:
1494          case GL_UNSIGNED_SHORT:
1495          case GL_INT:
1496          case GL_UNSIGNED_INT:
1497          case GL_FLOAT:
1498             return GL_INVALID_OPERATION;
1499          default:
1500             return GL_INVALID_ENUM;
1501          }
1502
1503       case GL_DUDV_ATI:
1504       case GL_DU8DV8_ATI:
1505          if (!ctx->Extensions.ATI_envmap_bumpmap)
1506             return GL_INVALID_ENUM;
1507          switch (type) {
1508             case GL_BYTE:
1509             case GL_UNSIGNED_BYTE:
1510             case GL_SHORT:
1511             case GL_UNSIGNED_SHORT:
1512             case GL_INT:
1513             case GL_UNSIGNED_INT:
1514             case GL_FLOAT:
1515                return GL_NO_ERROR;
1516             default:
1517                return GL_INVALID_ENUM;
1518          }
1519
1520       /* integer-valued formats */
1521       case GL_RED_INTEGER_EXT:
1522       case GL_GREEN_INTEGER_EXT:
1523       case GL_BLUE_INTEGER_EXT:
1524       case GL_ALPHA_INTEGER_EXT:
1525       case GL_RG_INTEGER:
1526          switch (type) {
1527             case GL_BYTE:
1528             case GL_UNSIGNED_BYTE:
1529             case GL_SHORT:
1530             case GL_UNSIGNED_SHORT:
1531             case GL_INT:
1532             case GL_UNSIGNED_INT:
1533                return (ctx->Version >= 30 ||
1534                        ctx->Extensions.EXT_texture_integer)
1535                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1536             default:
1537                return GL_INVALID_ENUM;
1538          }
1539
1540       case GL_RGB_INTEGER_EXT:
1541          switch (type) {
1542             case GL_BYTE:
1543             case GL_UNSIGNED_BYTE:
1544             case GL_SHORT:
1545             case GL_UNSIGNED_SHORT:
1546             case GL_INT:
1547             case GL_UNSIGNED_INT:
1548                return (ctx->Version >= 30 ||
1549                        ctx->Extensions.EXT_texture_integer)
1550                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1551             case GL_UNSIGNED_BYTE_3_3_2:
1552             case GL_UNSIGNED_BYTE_2_3_3_REV:
1553             case GL_UNSIGNED_SHORT_5_6_5:
1554             case GL_UNSIGNED_SHORT_5_6_5_REV:
1555                return ctx->Extensions.ARB_texture_rgb10_a2ui
1556                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1557             default:
1558                return GL_INVALID_ENUM;
1559          }
1560
1561       case GL_BGR_INTEGER_EXT:
1562          switch (type) {
1563             case GL_BYTE:
1564             case GL_UNSIGNED_BYTE:
1565             case GL_SHORT:
1566             case GL_UNSIGNED_SHORT:
1567             case GL_INT:
1568             case GL_UNSIGNED_INT:
1569             /* NOTE: no packed formats w/ BGR format */
1570                return (ctx->Version >= 30 ||
1571                        ctx->Extensions.EXT_texture_integer)
1572                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1573             default:
1574                return GL_INVALID_ENUM;
1575          }
1576
1577       case GL_RGBA_INTEGER_EXT:
1578       case GL_BGRA_INTEGER_EXT:
1579          switch (type) {
1580             case GL_BYTE:
1581             case GL_UNSIGNED_BYTE:
1582             case GL_SHORT:
1583             case GL_UNSIGNED_SHORT:
1584             case GL_INT:
1585             case GL_UNSIGNED_INT:
1586                return (ctx->Version >= 30 ||
1587                        ctx->Extensions.EXT_texture_integer)
1588                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1589             case GL_UNSIGNED_SHORT_4_4_4_4:
1590             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1591             case GL_UNSIGNED_SHORT_5_5_5_1:
1592             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1593             case GL_UNSIGNED_INT_8_8_8_8:
1594             case GL_UNSIGNED_INT_8_8_8_8_REV:
1595             case GL_UNSIGNED_INT_10_10_10_2:
1596             case GL_UNSIGNED_INT_2_10_10_10_REV:
1597                return ctx->Extensions.ARB_texture_rgb10_a2ui
1598                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1599             default:
1600                return GL_INVALID_ENUM;
1601          }
1602
1603       case GL_LUMINANCE_INTEGER_EXT:
1604       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1605          switch (type) {
1606             case GL_BYTE:
1607             case GL_UNSIGNED_BYTE:
1608             case GL_SHORT:
1609             case GL_UNSIGNED_SHORT:
1610             case GL_INT:
1611             case GL_UNSIGNED_INT:
1612                return ctx->Extensions.EXT_texture_integer
1613                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1614             default:
1615                return GL_INVALID_ENUM;
1616          }
1617
1618       default:
1619          return GL_INVALID_ENUM;
1620    }
1621    return GL_NO_ERROR;
1622 }
1623
1624
1625 /**
1626  * Do error checking of format/type combinations for OpenGL ES glReadPixels
1627  * and glTex[Sub]Image.
1628  * \return error code, or GL_NO_ERROR.
1629  */
1630 GLenum
1631 _mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1632                                      unsigned dimensions)
1633 {
1634    GLboolean type_valid = GL_TRUE;
1635
1636    switch (format) {
1637    case GL_ALPHA:
1638    case GL_LUMINANCE:
1639    case GL_LUMINANCE_ALPHA:
1640       type_valid = (type == GL_UNSIGNED_BYTE
1641                     || type == GL_FLOAT
1642                     || type == GL_HALF_FLOAT_OES);
1643       break;
1644
1645    case GL_RGB:
1646       type_valid = (type == GL_UNSIGNED_BYTE
1647                     || type == GL_UNSIGNED_SHORT_5_6_5
1648                     || type == GL_FLOAT
1649                     || type == GL_HALF_FLOAT_OES);
1650       break;
1651
1652    case GL_RGBA:
1653       type_valid = (type == GL_UNSIGNED_BYTE
1654                     || type == GL_UNSIGNED_SHORT_4_4_4_4
1655                     || type == GL_UNSIGNED_SHORT_5_5_5_1
1656                     || type == GL_FLOAT
1657                     || type == GL_HALF_FLOAT_OES
1658                     || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1659       break;
1660
1661    case GL_DEPTH_COMPONENT:
1662       /* This format is filtered against invalid dimensionalities elsewhere.
1663        */
1664       type_valid = (type == GL_UNSIGNED_SHORT
1665                     || type == GL_UNSIGNED_INT);
1666       break;
1667
1668    case GL_DEPTH_STENCIL:
1669       /* This format is filtered against invalid dimensionalities elsewhere.
1670        */
1671       type_valid = (type == GL_UNSIGNED_INT_24_8);
1672       break;
1673
1674    case GL_BGRA_EXT:
1675       type_valid = (type == GL_UNSIGNED_BYTE);
1676
1677       /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
1678        * the format does not appear to be allowed for 3D textures in OpenGL
1679        * ES.
1680        */
1681       if (dimensions != 2)
1682          return GL_INVALID_VALUE;
1683
1684       break;
1685
1686    default:
1687       return GL_INVALID_VALUE;
1688    }
1689
1690    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
1691 }
1692
1693
1694 /**
1695  * Do error checking of format/type combinations for OpenGL ES 3
1696  * glTex[Sub]Image.
1697  * \return error code, or GL_NO_ERROR.
1698  */
1699 GLenum
1700 _mesa_es3_error_check_format_and_type(GLenum format, GLenum type,
1701                                       GLenum internalFormat)
1702 {
1703    GLboolean type_valid = GL_TRUE;
1704
1705    switch (format) {
1706    case GL_RGBA:
1707       switch (type) {
1708       case GL_UNSIGNED_BYTE:
1709          switch (internalFormat) {
1710          case GL_RGBA:
1711          case GL_RGBA8:
1712          case GL_RGB5_A1:
1713          case GL_RGBA4:
1714          case GL_SRGB8_ALPHA8_EXT:
1715             break;
1716          default:
1717             return GL_INVALID_OPERATION;
1718          }
1719          break;
1720
1721       case GL_BYTE:
1722          if (internalFormat != GL_RGBA8_SNORM)
1723             return GL_INVALID_OPERATION;
1724          break;
1725
1726       case GL_UNSIGNED_SHORT_4_4_4_4:
1727          switch (internalFormat) {
1728          case GL_RGBA:
1729          case GL_RGBA4:
1730             break;
1731          default:
1732             return GL_INVALID_OPERATION;
1733          }
1734          break;
1735
1736       case GL_UNSIGNED_SHORT_5_5_5_1:
1737          switch (internalFormat) {
1738          case GL_RGBA:
1739          case GL_RGB5_A1:
1740             break;
1741          default:
1742             return GL_INVALID_OPERATION;
1743          }
1744          break;
1745
1746       case GL_UNSIGNED_INT_2_10_10_10_REV:
1747          switch (internalFormat) {
1748          case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
1749          case GL_RGB10_A2:
1750          case GL_RGB5_A1:
1751             break;
1752          default:
1753             return GL_INVALID_OPERATION;
1754          }
1755          break;
1756
1757       case GL_HALF_FLOAT:
1758          if (internalFormat != GL_RGBA16F)
1759             return GL_INVALID_OPERATION;
1760          break;
1761
1762       case GL_FLOAT:
1763          switch (internalFormat) {
1764          case GL_RGBA16F:
1765          case GL_RGBA32F:
1766             break;
1767          default:
1768             return GL_INVALID_OPERATION;
1769          }
1770          break;
1771
1772       default:
1773          return GL_INVALID_OPERATION;
1774       }
1775       break;
1776
1777    case GL_RGBA_INTEGER:
1778       switch (type) {
1779       case GL_UNSIGNED_BYTE:
1780          if (internalFormat != GL_RGBA8UI)
1781             return GL_INVALID_OPERATION;
1782          break;
1783
1784       case GL_BYTE:
1785          if (internalFormat != GL_RGBA8I)
1786             return GL_INVALID_OPERATION;
1787          break;
1788
1789       case GL_UNSIGNED_SHORT:
1790          if (internalFormat != GL_RGBA16UI)
1791             return GL_INVALID_OPERATION;
1792          break;
1793
1794       case GL_SHORT:
1795          if (internalFormat != GL_RGBA16I)
1796             return GL_INVALID_OPERATION;
1797          break;
1798
1799       case GL_UNSIGNED_INT:
1800          if (internalFormat != GL_RGBA32UI)
1801             return GL_INVALID_OPERATION;
1802          break;
1803
1804       case GL_INT:
1805          if (internalFormat != GL_RGBA32I)
1806             return GL_INVALID_OPERATION;
1807          break;
1808
1809       case GL_UNSIGNED_INT_2_10_10_10_REV:
1810          if (internalFormat != GL_RGB10_A2UI)
1811             return GL_INVALID_OPERATION;
1812          break;
1813
1814       default:
1815          return GL_INVALID_OPERATION;
1816       }
1817       break;
1818
1819    case GL_RGB:
1820       switch (type) {
1821       case GL_UNSIGNED_BYTE:
1822          switch (internalFormat) {
1823          case GL_RGB:
1824          case GL_RGB8:
1825          case GL_RGB565:
1826          case GL_SRGB8:
1827             break;
1828          default:
1829             return GL_INVALID_OPERATION;
1830          }
1831          break;
1832
1833       case GL_BYTE:
1834          if (internalFormat != GL_RGB8_SNORM)
1835             return GL_INVALID_OPERATION;
1836          break;
1837
1838       case GL_UNSIGNED_SHORT_5_6_5:
1839          switch (internalFormat) {
1840          case GL_RGB:
1841          case GL_RGB565:
1842             break;
1843          default:
1844             return GL_INVALID_OPERATION;
1845          }
1846          break;
1847
1848       case GL_UNSIGNED_INT_10F_11F_11F_REV:
1849          if (internalFormat != GL_R11F_G11F_B10F)
1850             return GL_INVALID_OPERATION;
1851          break;
1852
1853       case GL_UNSIGNED_INT_5_9_9_9_REV:
1854          if (internalFormat != GL_RGB9_E5)
1855             return GL_INVALID_OPERATION;
1856          break;
1857
1858       case GL_HALF_FLOAT:
1859          switch (internalFormat) {
1860          case GL_RGB16F:
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_FLOAT:
1870          switch (internalFormat) {
1871          case GL_RGB16F:
1872          case GL_RGB32F:
1873          case GL_R11F_G11F_B10F:
1874          case GL_RGB9_E5:
1875             break;
1876          default:
1877             return GL_INVALID_OPERATION;
1878          }
1879          break;
1880
1881       case GL_UNSIGNED_INT_2_10_10_10_REV:
1882          switch (internalFormat) {
1883          case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
1884             break;
1885          default:
1886             return GL_INVALID_OPERATION;
1887          }
1888          break;
1889
1890       default:
1891          return GL_INVALID_OPERATION;
1892       }
1893       break;
1894
1895    case GL_RGB_INTEGER:
1896       switch (type) {
1897       case GL_UNSIGNED_BYTE:
1898          if (internalFormat != GL_RGB8UI)
1899             return GL_INVALID_OPERATION;
1900          break;
1901
1902       case GL_BYTE:
1903          if (internalFormat != GL_RGB8I)
1904             return GL_INVALID_OPERATION;
1905          break;
1906
1907       case GL_UNSIGNED_SHORT:
1908          if (internalFormat != GL_RGB16UI)
1909             return GL_INVALID_OPERATION;
1910          break;
1911
1912       case GL_SHORT:
1913          if (internalFormat != GL_RGB16I)
1914             return GL_INVALID_OPERATION;
1915          break;
1916
1917       case GL_UNSIGNED_INT:
1918          if (internalFormat != GL_RGB32UI)
1919             return GL_INVALID_OPERATION;
1920          break;
1921
1922       case GL_INT:
1923          if (internalFormat != GL_RGB32I)
1924             return GL_INVALID_OPERATION;
1925          break;
1926
1927       default:
1928          return GL_INVALID_OPERATION;
1929       }
1930       break;
1931
1932    case GL_RG:
1933       switch (type) {
1934       case GL_UNSIGNED_BYTE:
1935          if (internalFormat != GL_RG8)
1936             return GL_INVALID_OPERATION;
1937          break;
1938
1939       case GL_BYTE:
1940          if (internalFormat != GL_RG8_SNORM)
1941             return GL_INVALID_OPERATION;
1942          break;
1943
1944       case GL_HALF_FLOAT:
1945          if (internalFormat != GL_RG16F)
1946             return GL_INVALID_OPERATION;
1947          break;
1948
1949       case GL_FLOAT:
1950          switch (internalFormat) {
1951          case GL_RG16F:
1952          case GL_RG32F:
1953             break;
1954          default:
1955             return GL_INVALID_OPERATION;
1956          }
1957          break;
1958
1959       default:
1960          return GL_INVALID_OPERATION;
1961       }
1962       break;
1963
1964    case GL_RG_INTEGER:
1965       switch (type) {
1966       case GL_UNSIGNED_BYTE:
1967          if (internalFormat != GL_RG8UI)
1968             return GL_INVALID_OPERATION;
1969          break;
1970
1971       case GL_BYTE:
1972          if (internalFormat != GL_RG8I)
1973             return GL_INVALID_OPERATION;
1974          break;
1975
1976       case GL_UNSIGNED_SHORT:
1977          if (internalFormat != GL_RG16UI)
1978             return GL_INVALID_OPERATION;
1979          break;
1980
1981       case GL_SHORT:
1982          if (internalFormat != GL_RG16I)
1983             return GL_INVALID_OPERATION;
1984          break;
1985
1986       case GL_UNSIGNED_INT:
1987          if (internalFormat != GL_RG32UI)
1988             return GL_INVALID_OPERATION;
1989          break;
1990
1991       case GL_INT:
1992          if (internalFormat != GL_RG32I)
1993             return GL_INVALID_OPERATION;
1994          break;
1995
1996       default:
1997          return GL_INVALID_OPERATION;
1998       }
1999       break;
2000
2001    case GL_RED:
2002       switch (type) {
2003       case GL_UNSIGNED_BYTE:
2004          if (internalFormat != GL_R8)
2005             return GL_INVALID_OPERATION;
2006          break;
2007
2008       case GL_BYTE:
2009          if (internalFormat != GL_R8_SNORM)
2010             return GL_INVALID_OPERATION;
2011          break;
2012
2013       case GL_HALF_FLOAT:
2014          if (internalFormat != GL_R16F)
2015             return GL_INVALID_OPERATION;
2016          break;
2017
2018       case GL_FLOAT:
2019          switch (internalFormat) {
2020          case GL_R16F:
2021          case GL_R32F:
2022             break;
2023          default:
2024             return GL_INVALID_OPERATION;
2025          }
2026          break;
2027
2028       default:
2029          return GL_INVALID_OPERATION;
2030       }
2031       break;
2032
2033    case GL_RED_INTEGER:
2034       switch (type) {
2035       case GL_UNSIGNED_BYTE:
2036          if (internalFormat != GL_R8UI)
2037             return GL_INVALID_OPERATION;
2038          break;
2039
2040       case GL_BYTE:
2041          if (internalFormat != GL_R8I)
2042             return GL_INVALID_OPERATION;
2043          break;
2044
2045       case GL_UNSIGNED_SHORT:
2046          if (internalFormat != GL_R16UI)
2047             return GL_INVALID_OPERATION;
2048          break;
2049
2050       case GL_SHORT:
2051          if (internalFormat != GL_R16I)
2052             return GL_INVALID_OPERATION;
2053          break;
2054
2055       case GL_UNSIGNED_INT:
2056          if (internalFormat != GL_R32UI)
2057             return GL_INVALID_OPERATION;
2058          break;
2059
2060       case GL_INT:
2061          if (internalFormat != GL_R32I)
2062             return GL_INVALID_OPERATION;
2063          break;
2064
2065       default:
2066          return GL_INVALID_OPERATION;
2067       }
2068       break;
2069
2070    case GL_DEPTH_COMPONENT:
2071       switch (type) {
2072       case GL_UNSIGNED_SHORT:
2073          if (internalFormat != GL_DEPTH_COMPONENT
2074              && internalFormat != GL_DEPTH_COMPONENT16)
2075             return GL_INVALID_OPERATION;
2076          break;
2077
2078       case GL_UNSIGNED_INT:
2079          switch (internalFormat) {
2080          case GL_DEPTH_COMPONENT:
2081          case GL_DEPTH_COMPONENT16:
2082          case GL_DEPTH_COMPONENT24:
2083             break;
2084          default:
2085             return GL_INVALID_OPERATION;
2086          }
2087          break;
2088
2089       case GL_FLOAT:
2090          if (internalFormat != GL_DEPTH_COMPONENT32F)
2091             return GL_INVALID_OPERATION;
2092          break;
2093
2094       default:
2095          return GL_INVALID_OPERATION;
2096       }
2097       break;
2098
2099    case GL_DEPTH_STENCIL:
2100       switch (type) {
2101       case GL_UNSIGNED_INT_24_8:
2102          if (internalFormat != GL_DEPTH_STENCIL
2103              && internalFormat != GL_DEPTH24_STENCIL8)
2104             return GL_INVALID_OPERATION;
2105          break;
2106
2107       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2108          if (internalFormat != GL_DEPTH32F_STENCIL8)
2109             return GL_INVALID_OPERATION;
2110          break;
2111
2112       default:
2113          return GL_INVALID_OPERATION;
2114       }
2115       break;
2116
2117    case GL_ALPHA:
2118    case GL_LUMINANCE:
2119    case GL_LUMINANCE_ALPHA:
2120       if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2121          return GL_INVALID_OPERATION;
2122       break;
2123    }
2124
2125    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2126 }