src/mesa/main/glformats.c

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