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 #include "formats.h"
  31 #include "enums.h"
  32
  33 enum {
  34    ZERO = 4,
  35    ONE = 5
  36 };
  37
  38 enum {
  39    IDX_LUMINANCE = 0,
  40    IDX_ALPHA,
  41    IDX_INTENSITY,
  42    IDX_LUMINANCE_ALPHA,
  43    IDX_RGB,
  44    IDX_RGBA,
  45    IDX_RED,
  46    IDX_GREEN,
  47    IDX_BLUE,
  48    IDX_BGR,
  49    IDX_BGRA,
  50    IDX_ABGR,
  51    IDX_RG,
  52    MAX_IDX
  53 };
  54
  55 #define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
  56 #define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
  57 #define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
  58 #define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
  59
  60 static const struct {
  61    GLubyte format_idx;
  62    GLubyte to_rgba[6];
  63    GLubyte from_rgba[6];
  64 } mappings[MAX_IDX] =
  65 {
  66    {
  67       IDX_LUMINANCE,
  68       MAP4(0,0,0,ONE),
  69       MAP1(0)
  70    },
  71
  72    {
  73       IDX_ALPHA,
  74       MAP4(ZERO, ZERO, ZERO, 0),
  75       MAP1(3)
  76    },
  77
  78    {
  79       IDX_INTENSITY,
  80       MAP4(0, 0, 0, 0),
  81       MAP1(0),
  82    },
  83
  84    {
  85       IDX_LUMINANCE_ALPHA,
  86       MAP4(0,0,0,1),
  87       MAP2(0,3)
  88    },
  89
  90    {
  91       IDX_RGB,
  92       MAP4(0,1,2,ONE),
  93       MAP3(0,1,2)
  94    },
  95
  96    {
  97       IDX_RGBA,
  98       MAP4(0,1,2,3),
  99       MAP4(0,1,2,3),
 100    },
 101
 102    {
 103       IDX_RED,
 104       MAP4(0, ZERO, ZERO, ONE),
 105       MAP1(0),
 106    },
 107
 108    {
 109       IDX_GREEN,
 110       MAP4(ZERO, 0, ZERO, ONE),
 111       MAP1(1),
 112    },
 113
 114    {
 115       IDX_BLUE,
 116       MAP4(ZERO, ZERO, 0, ONE),
 117       MAP1(2),
 118    },
 119
 120    {
 121       IDX_BGR,
 122       MAP4(2,1,0,ONE),
 123       MAP3(2,1,0)
 124    },
 125
 126    {
 127       IDX_BGRA,
 128       MAP4(2,1,0,3),
 129       MAP4(2,1,0,3)
 130    },
 131
 132    {
 133       IDX_ABGR,
 134       MAP4(3,2,1,0),
 135       MAP4(3,2,1,0)
 136    },
 137
 138    {
 139       IDX_RG,
 140       MAP4(0, 1, ZERO, ONE),
 141       MAP2(0, 1)
 142    },
 143 };
 144
 145 /**
 146  * Convert a GL image format enum to an IDX_* value (see above).
 147  */
 148 static int
 149 get_map_idx(GLenum value)
 150 {
 151    switch (value) {
 152    case GL_LUMINANCE:
 153    case GL_LUMINANCE_INTEGER_EXT:
 154       return IDX_LUMINANCE;
 155    case GL_ALPHA:
 156    case GL_ALPHA_INTEGER:
 157       return IDX_ALPHA;
 158    case GL_INTENSITY:
 159       return IDX_INTENSITY;
 160    case GL_LUMINANCE_ALPHA:
 161    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 162       return IDX_LUMINANCE_ALPHA;
 163    case GL_RGB:
 164    case GL_RGB_INTEGER:
 165       return IDX_RGB;
 166    case GL_RGBA:
 167    case GL_RGBA_INTEGER:
 168       return IDX_RGBA;
 169    case GL_RED:
 170    case GL_RED_INTEGER:
 171       return IDX_RED;
 172    case GL_GREEN:
 173       return IDX_GREEN;
 174    case GL_BLUE:
 175       return IDX_BLUE;
 176    case GL_BGR:
 177    case GL_BGR_INTEGER:
 178       return IDX_BGR;
 179    case GL_BGRA:
 180    case GL_BGRA_INTEGER:
 181       return IDX_BGRA;
 182    case GL_ABGR_EXT:
 183       return IDX_ABGR;
 184    case GL_RG:
 185    case GL_RG_INTEGER:
 186       return IDX_RG;
 187    default:
 188       _mesa_problem(NULL, "Unexpected inFormat %s",
 189                     _mesa_lookup_enum_by_nr(value));
 190       return 0;
 191    }
 192 }
 193
 194 /**
 195  * When promoting texture formats (see below) we need to compute the
 196  * mapping of dest components back to source components.
 197  * This function does that.
 198  * \param inFormat  the incoming format of the texture
 199  * \param outFormat  the final texture format
 200  * \return map[6]  a full 6-component map
 201  */
 202 void
 203 _mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map)
 204 {
 205    const int inFmt = get_map_idx(inFormat);
 206    const int outFmt = get_map_idx(outFormat);
 207    const GLubyte *in2rgba = mappings[inFmt].to_rgba;
 208    const GLubyte *rgba2out = mappings[outFmt].from_rgba;
 209    int i;
 210
 211    for (i = 0; i < 4; i++)
 212       map[i] = in2rgba[rgba2out[i]];
 213
 214    map[ZERO] = ZERO;
 215    map[ONE] = ONE;
 216
 217 #if 0
 218    printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
 219           inFormat, _mesa_lookup_enum_by_nr(inFormat),
 220           outFormat, _mesa_lookup_enum_by_nr(outFormat),
 221           map[0],
 222           map[1],
 223           map[2],
 224           map[3],
 225           map[4],
 226           map[5]);
 227 #endif
 228 }
 229
 230 /**
 231  * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
 232  */
 233 GLboolean
 234 _mesa_type_is_packed(GLenum type)
 235 {
 236    switch (type) {
 237    case GL_UNSIGNED_BYTE_3_3_2:
 238    case GL_UNSIGNED_BYTE_2_3_3_REV:
 239    case MESA_UNSIGNED_BYTE_4_4:
 240    case GL_UNSIGNED_SHORT_5_6_5:
 241    case GL_UNSIGNED_SHORT_5_6_5_REV:
 242    case GL_UNSIGNED_SHORT_4_4_4_4:
 243    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 244    case GL_UNSIGNED_SHORT_5_5_5_1:
 245    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 246    case GL_UNSIGNED_INT_8_8_8_8:
 247    case GL_UNSIGNED_INT_8_8_8_8_REV:
 248    case GL_UNSIGNED_INT_10_10_10_2:
 249    case GL_UNSIGNED_INT_2_10_10_10_REV:
 250    case GL_UNSIGNED_SHORT_8_8_MESA:
 251    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 252    case GL_UNSIGNED_INT_24_8_EXT:
 253    case GL_UNSIGNED_INT_5_9_9_9_REV:
 254    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 255    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 256       return GL_TRUE;
 257    }
 258
 259    return GL_FALSE;
 260 }
 261
 262
 263 /**
 264  * Get the size of a GL data type.
 265  *
 266  * \param type GL data type.
 267  *
 268  * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
 269  * if an invalid type enum.
 270  */
 271 GLint
 272 _mesa_sizeof_type(GLenum type)
 273 {
 274    switch (type) {
 275    case GL_BITMAP:
 276       return 0;
 277    case GL_UNSIGNED_BYTE:
 278       return sizeof(GLubyte);
 279    case GL_BYTE:
 280       return sizeof(GLbyte);
 281    case GL_UNSIGNED_SHORT:
 282       return sizeof(GLushort);
 283    case GL_SHORT:
 284       return sizeof(GLshort);
 285    case GL_UNSIGNED_INT:
 286       return sizeof(GLuint);
 287    case GL_INT:
 288       return sizeof(GLint);
 289    case GL_FLOAT:
 290       return sizeof(GLfloat);
 291    case GL_DOUBLE:
 292       return sizeof(GLdouble);
 293    case GL_HALF_FLOAT_ARB:
 294    case GL_HALF_FLOAT_OES:
 295       return sizeof(GLhalfARB);
 296    case GL_FIXED:
 297       return sizeof(GLfixed);
 298    default:
 299       return -1;
 300    }
 301 }
 302
 303
 304 /**
 305  * Same as _mesa_sizeof_type() but also accepting the packed pixel
 306  * format data types.
 307  */
 308 GLint
 309 _mesa_sizeof_packed_type(GLenum type)
 310 {
 311    switch (type) {
 312    case GL_BITMAP:
 313       return 0;
 314    case GL_UNSIGNED_BYTE:
 315       return sizeof(GLubyte);
 316    case GL_BYTE:
 317       return sizeof(GLbyte);
 318    case GL_UNSIGNED_SHORT:
 319       return sizeof(GLushort);
 320    case GL_SHORT:
 321       return sizeof(GLshort);
 322    case GL_UNSIGNED_INT:
 323       return sizeof(GLuint);
 324    case GL_INT:
 325       return sizeof(GLint);
 326    case GL_HALF_FLOAT_ARB:
 327    case GL_HALF_FLOAT_OES:
 328       return sizeof(GLhalfARB);
 329    case GL_FLOAT:
 330       return sizeof(GLfloat);
 331    case GL_UNSIGNED_BYTE_3_3_2:
 332    case GL_UNSIGNED_BYTE_2_3_3_REV:
 333    case MESA_UNSIGNED_BYTE_4_4:
 334       return sizeof(GLubyte);
 335    case GL_UNSIGNED_SHORT_5_6_5:
 336    case GL_UNSIGNED_SHORT_5_6_5_REV:
 337    case GL_UNSIGNED_SHORT_4_4_4_4:
 338    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 339    case GL_UNSIGNED_SHORT_5_5_5_1:
 340    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 341    case GL_UNSIGNED_SHORT_8_8_MESA:
 342    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 343       return sizeof(GLushort);
 344    case GL_UNSIGNED_INT_8_8_8_8:
 345    case GL_UNSIGNED_INT_8_8_8_8_REV:
 346    case GL_UNSIGNED_INT_10_10_10_2:
 347    case GL_UNSIGNED_INT_2_10_10_10_REV:
 348    case GL_UNSIGNED_INT_24_8_EXT:
 349    case GL_UNSIGNED_INT_5_9_9_9_REV:
 350    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 351       return sizeof(GLuint);
 352    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 353       return 8;
 354    default:
 355       return -1;
 356    }
 357 }
 358
 359
 360 /**
 361  * Get the number of components in a pixel format.
 362  *
 363  * \param format pixel format.
 364  *
 365  * \return the number of components in the given format, or -1 if a bad format.
 366  */
 367 GLint
 368 _mesa_components_in_format(GLenum format)
 369 {
 370    switch (format) {
 371    case GL_COLOR_INDEX:
 372    case GL_STENCIL_INDEX:
 373    case GL_DEPTH_COMPONENT:
 374    case GL_RED:
 375    case GL_RED_INTEGER_EXT:
 376    case GL_GREEN:
 377    case GL_GREEN_INTEGER_EXT:
 378    case GL_BLUE:
 379    case GL_BLUE_INTEGER_EXT:
 380    case GL_ALPHA:
 381    case GL_ALPHA_INTEGER_EXT:
 382    case GL_LUMINANCE:
 383    case GL_LUMINANCE_INTEGER_EXT:
 384    case GL_INTENSITY:
 385       return 1;
 386
 387    case GL_LUMINANCE_ALPHA:
 388    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 389    case GL_RG:
 390    case GL_YCBCR_MESA:
 391    case GL_DEPTH_STENCIL_EXT:
 392    case GL_RG_INTEGER:
 393       return 2;
 394
 395    case GL_RGB:
 396    case GL_BGR:
 397    case GL_RGB_INTEGER_EXT:
 398    case GL_BGR_INTEGER_EXT:
 399       return 3;
 400
 401    case GL_RGBA:
 402    case GL_BGRA:
 403    case GL_ABGR_EXT:
 404    case GL_RGBA_INTEGER_EXT:
 405    case GL_BGRA_INTEGER_EXT:
 406       return 4;
 407
 408    default:
 409       return -1;
 410    }
 411 }
 412
 413
 414 /**
 415  * Get the bytes per pixel of pixel format type pair.
 416  *
 417  * \param format pixel format.
 418  * \param type pixel type.
 419  *
 420  * \return bytes per pixel, or -1 if a bad format or type was given.
 421  */
 422 GLint
 423 _mesa_bytes_per_pixel(GLenum format, GLenum type)
 424 {
 425    GLint comps = _mesa_components_in_format(format);
 426    if (comps < 0)
 427       return -1;
 428
 429    switch (type) {
 430    case GL_BITMAP:
 431       return 0;  /* special case */
 432    case GL_BYTE:
 433    case GL_UNSIGNED_BYTE:
 434       return comps * sizeof(GLubyte);
 435    case GL_SHORT:
 436    case GL_UNSIGNED_SHORT:
 437       return comps * sizeof(GLshort);
 438    case GL_INT:
 439    case GL_UNSIGNED_INT:
 440       return comps * sizeof(GLint);
 441    case GL_FLOAT:
 442       return comps * sizeof(GLfloat);
 443    case GL_HALF_FLOAT_ARB:
 444    case GL_HALF_FLOAT_OES:
 445       return comps * sizeof(GLhalfARB);
 446    case GL_UNSIGNED_BYTE_3_3_2:
 447    case GL_UNSIGNED_BYTE_2_3_3_REV:
 448       if (format == GL_RGB || format == GL_BGR ||
 449           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 450          return sizeof(GLubyte);
 451       else
 452          return -1;  /* error */
 453    case GL_UNSIGNED_SHORT_5_6_5:
 454    case GL_UNSIGNED_SHORT_5_6_5_REV:
 455       if (format == GL_RGB || format == GL_BGR ||
 456           format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
 457          return sizeof(GLushort);
 458       else
 459          return -1;  /* error */
 460    case GL_UNSIGNED_SHORT_4_4_4_4:
 461    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 462       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 463           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
 464          return sizeof(GLushort);
 465       else
 466          return -1;
 467    case GL_UNSIGNED_SHORT_5_5_5_1:
 468    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 469       if (format == GL_RGBA || format == GL_BGRA ||
 470           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
 471          return sizeof(GLushort);
 472       else
 473          return -1;
 474    case GL_UNSIGNED_INT_8_8_8_8:
 475    case GL_UNSIGNED_INT_8_8_8_8_REV:
 476       if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
 477           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
 478           format == GL_RGB)
 479          return sizeof(GLuint);
 480       else
 481          return -1;
 482    case GL_UNSIGNED_INT_10_10_10_2:
 483    case GL_UNSIGNED_INT_2_10_10_10_REV:
 484       if (format == GL_RGBA || format == GL_BGRA ||
 485           format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
 486           format == GL_RGB)
 487          return sizeof(GLuint);
 488       else
 489          return -1;
 490    case GL_UNSIGNED_SHORT_8_8_MESA:
 491    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 492       if (format == GL_YCBCR_MESA)
 493          return sizeof(GLushort);
 494       else
 495          return -1;
 496    case GL_UNSIGNED_INT_24_8_EXT:
 497       if (format == GL_DEPTH_STENCIL_EXT)
 498          return sizeof(GLuint);
 499       else
 500          return -1;
 501    case GL_UNSIGNED_INT_5_9_9_9_REV:
 502       if (format == GL_RGB)
 503          return sizeof(GLuint);
 504       else
 505          return -1;
 506    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 507       if (format == GL_RGB)
 508          return sizeof(GLuint);
 509       else
 510          return -1;
 511    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 512       if (format == GL_DEPTH_STENCIL)
 513          return 8;
 514       else
 515          return -1;
 516    default:
 517       return -1;
 518    }
 519 }
 520
 521
 522 /**
 523  * Get the number of bytes for a vertex attrib with the given number of
 524  * components and type.
 525  *
 526  * \param comps number of components.
 527  * \param type data type.
 528  *
 529  * \return bytes per attribute, or -1 if a bad comps/type combination was given.
 530  */
 531 GLint
 532 _mesa_bytes_per_vertex_attrib(GLint comps, GLenum type)
 533 {
 534    switch (type) {
 535    case GL_BYTE:
 536    case GL_UNSIGNED_BYTE:
 537       return comps * sizeof(GLubyte);
 538    case GL_SHORT:
 539    case GL_UNSIGNED_SHORT:
 540       return comps * sizeof(GLshort);
 541    case GL_INT:
 542    case GL_UNSIGNED_INT:
 543       return comps * sizeof(GLint);
 544    case GL_FLOAT:
 545       return comps * sizeof(GLfloat);
 546    case GL_HALF_FLOAT_ARB:
 547       return comps * sizeof(GLhalfARB);
 548    case GL_DOUBLE:
 549       return comps * sizeof(GLdouble);
 550    case GL_FIXED:
 551       return comps * sizeof(GLfixed);
 552    case GL_INT_2_10_10_10_REV:
 553    case GL_UNSIGNED_INT_2_10_10_10_REV:
 554       if (comps == 4)
 555          return sizeof(GLuint);
 556       else
 557          return -1;
 558    case GL_UNSIGNED_INT_10F_11F_11F_REV:
 559       if (comps == 3)
 560          return sizeof(GLuint);
 561       else
 562          return -1;
 563    default:
 564       return -1;
 565    }
 566 }
 567
 568 /**
 569  * Test if the given format is unsized.
 570  */
 571 GLboolean
 572 _mesa_is_enum_format_unsized(GLenum format)
 573 {
 574    switch (format) {
 575    case GL_RGBA:
 576    case GL_BGRA:
 577    case GL_ABGR_EXT:
 578    case GL_RGB:
 579    case GL_BGR:
 580    case GL_RG:
 581    case GL_RED:
 582    case GL_GREEN:
 583    case GL_BLUE:
 584    case GL_ALPHA:
 585    case GL_INTENSITY:
 586    case GL_LUMINANCE:
 587    case GL_LUMINANCE_ALPHA:
 588
 589    case GL_SRGB:
 590    case GL_SRGB_ALPHA:
 591    case GL_SLUMINANCE:
 592    case GL_SLUMINANCE_ALPHA:
 593
 594    case GL_RGBA_SNORM:
 595    case GL_RGB_SNORM:
 596    case GL_RG_SNORM:
 597    case GL_RED_SNORM:
 598    case GL_ALPHA_SNORM:
 599    case GL_INTENSITY_SNORM:
 600    case GL_LUMINANCE_SNORM:
 601    case GL_LUMINANCE_ALPHA_SNORM:
 602
 603    case GL_RED_INTEGER:
 604    case GL_GREEN_INTEGER:
 605    case GL_BLUE_INTEGER:
 606    case GL_ALPHA_INTEGER:
 607    case GL_RGB_INTEGER:
 608    case GL_RGBA_INTEGER:
 609    case GL_BGR_INTEGER:
 610    case GL_BGRA_INTEGER:
 611    case GL_RG_INTEGER:
 612    case GL_LUMINANCE_INTEGER_EXT:
 613    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 614
 615    case GL_DEPTH_COMPONENT:
 616    case GL_DEPTH_STENCIL:
 617    case GL_STENCIL_INDEX:
 618       return GL_TRUE;
 619    default:
 620       return GL_FALSE;
 621    }
 622 }
 623
 624 /**
 625  * Test if the given format is a UNORM (unsigned-normalized) format.
 626  */
 627 GLboolean
 628 _mesa_is_enum_format_unorm(GLenum format)
 629 {
 630       switch(format) {
 631       case GL_RED:
 632       case GL_GREEN:
 633       case GL_BLUE:
 634       case GL_ALPHA:
 635       case GL_ALPHA4:
 636       case GL_ALPHA8:
 637       case GL_ALPHA12:
 638       case GL_ALPHA16:
 639       case 1:
 640       case GL_LUMINANCE:
 641       case GL_SLUMINANCE:
 642       case GL_LUMINANCE4:
 643       case GL_LUMINANCE8:
 644       case GL_LUMINANCE12:
 645       case GL_LUMINANCE16:
 646       case 2:
 647       case GL_LUMINANCE_ALPHA:
 648       case GL_SLUMINANCE_ALPHA:
 649       case GL_LUMINANCE4_ALPHA4:
 650       case GL_LUMINANCE6_ALPHA2:
 651       case GL_LUMINANCE8_ALPHA8:
 652       case GL_LUMINANCE12_ALPHA4:
 653       case GL_LUMINANCE12_ALPHA12:
 654       case GL_LUMINANCE16_ALPHA16:
 655       case GL_INTENSITY:
 656       case GL_INTENSITY4:
 657       case GL_INTENSITY8:
 658       case GL_INTENSITY12:
 659       case GL_INTENSITY16:
 660       case GL_R8:
 661       case GL_R16:
 662       case GL_RG:
 663       case GL_RG8:
 664       case GL_RG16:
 665       case 3:
 666       case GL_RGB:
 667       case GL_BGR:
 668       case GL_SRGB:
 669       case GL_R3_G3_B2:
 670       case GL_RGB4:
 671       case GL_RGB5:
 672       case GL_RGB565:
 673       case GL_RGB8:
 674       case GL_RGB10:
 675       case GL_RGB12:
 676       case GL_RGB16:
 677       case 4:
 678       case GL_ABGR_EXT:
 679       case GL_RGBA:
 680       case GL_BGRA:
 681       case GL_SRGB_ALPHA:
 682       case GL_RGBA2:
 683       case GL_RGBA4:
 684       case GL_RGB5_A1:
 685       case GL_RGBA8:
 686       case GL_RGB10_A2:
 687       case GL_RGBA12:
 688       case GL_RGBA16:
 689          return GL_TRUE;
 690       default:
 691          return GL_FALSE;
 692    }
 693 }
 694
 695 /**
 696  * Test if the given format is a SNORM (signed-normalized) format.
 697  */
 698 GLboolean
 699 _mesa_is_enum_format_snorm(GLenum format)
 700 {
 701    switch (format) {
 702    /* signed, normalized texture formats */
 703    case GL_RED_SNORM:
 704    case GL_R8_SNORM:
 705    case GL_R16_SNORM:
 706    case GL_RG_SNORM:
 707    case GL_RG8_SNORM:
 708    case GL_RG16_SNORM:
 709    case GL_RGB_SNORM:
 710    case GL_RGB8_SNORM:
 711    case GL_RGB16_SNORM:
 712    case GL_RGBA_SNORM:
 713    case GL_RGBA8_SNORM:
 714    case GL_RGBA16_SNORM:
 715    case GL_ALPHA_SNORM:
 716    case GL_ALPHA8_SNORM:
 717    case GL_ALPHA16_SNORM:
 718    case GL_LUMINANCE_SNORM:
 719    case GL_LUMINANCE8_SNORM:
 720    case GL_LUMINANCE16_SNORM:
 721    case GL_LUMINANCE_ALPHA_SNORM:
 722    case GL_LUMINANCE8_ALPHA8_SNORM:
 723    case GL_LUMINANCE16_ALPHA16_SNORM:
 724    case GL_INTENSITY_SNORM:
 725    case GL_INTENSITY8_SNORM:
 726    case GL_INTENSITY16_SNORM:
 727       return GL_TRUE;
 728    default:
 729       return GL_FALSE;
 730    }
 731 }
 732
 733 /**
 734  * Test if the given format is an integer (non-normalized) format.
 735  */
 736 GLboolean
 737 _mesa_is_enum_format_unsigned_int(GLenum format)
 738 {
 739    switch (format) {
 740    /* specific integer formats */
 741    case GL_RGBA32UI_EXT:
 742    case GL_RGB32UI_EXT:
 743    case GL_RG32UI:
 744    case GL_R32UI:
 745    case GL_ALPHA32UI_EXT:
 746    case GL_INTENSITY32UI_EXT:
 747    case GL_LUMINANCE32UI_EXT:
 748    case GL_LUMINANCE_ALPHA32UI_EXT:
 749    case GL_RGBA16UI_EXT:
 750    case GL_RGB16UI_EXT:
 751    case GL_RG16UI:
 752    case GL_R16UI:
 753    case GL_ALPHA16UI_EXT:
 754    case GL_INTENSITY16UI_EXT:
 755    case GL_LUMINANCE16UI_EXT:
 756    case GL_LUMINANCE_ALPHA16UI_EXT:
 757    case GL_RGBA8UI_EXT:
 758    case GL_RGB8UI_EXT:
 759    case GL_RG8UI:
 760    case GL_R8UI:
 761    case GL_ALPHA8UI_EXT:
 762    case GL_INTENSITY8UI_EXT:
 763    case GL_LUMINANCE8UI_EXT:
 764    case GL_LUMINANCE_ALPHA8UI_EXT:
 765    case GL_RGB10_A2UI:
 766       return GL_TRUE;
 767    default:
 768       return GL_FALSE;
 769    }
 770 }
 771
 772
 773 /**
 774  * Test if the given format is an integer (non-normalized) format.
 775  */
 776 GLboolean
 777 _mesa_is_enum_format_signed_int(GLenum format)
 778 {
 779    switch (format) {
 780    /* generic integer formats */
 781    case GL_RED_INTEGER_EXT:
 782    case GL_GREEN_INTEGER_EXT:
 783    case GL_BLUE_INTEGER_EXT:
 784    case GL_ALPHA_INTEGER_EXT:
 785    case GL_RGB_INTEGER_EXT:
 786    case GL_RGBA_INTEGER_EXT:
 787    case GL_BGR_INTEGER_EXT:
 788    case GL_BGRA_INTEGER_EXT:
 789    case GL_LUMINANCE_INTEGER_EXT:
 790    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 791    case GL_RG_INTEGER:
 792    /* specific integer formats */
 793    case GL_RGBA32I_EXT:
 794    case GL_RGB32I_EXT:
 795    case GL_RG32I:
 796    case GL_R32I:
 797    case GL_ALPHA32I_EXT:
 798    case GL_INTENSITY32I_EXT:
 799    case GL_LUMINANCE32I_EXT:
 800    case GL_LUMINANCE_ALPHA32I_EXT:
 801    case GL_RGBA16I_EXT:
 802    case GL_RGB16I_EXT:
 803    case GL_RG16I:
 804    case GL_R16I:
 805    case GL_ALPHA16I_EXT:
 806    case GL_INTENSITY16I_EXT:
 807    case GL_LUMINANCE16I_EXT:
 808    case GL_LUMINANCE_ALPHA16I_EXT:
 809    case GL_RGBA8I_EXT:
 810    case GL_RGB8I_EXT:
 811    case GL_RG8I:
 812    case GL_R8I:
 813    case GL_ALPHA8I_EXT:
 814    case GL_INTENSITY8I_EXT:
 815    case GL_LUMINANCE8I_EXT:
 816    case GL_LUMINANCE_ALPHA8I_EXT:
 817       return GL_TRUE;
 818    default:
 819       return GL_FALSE;
 820    }
 821 }
 822
 823
 824 /**
 825  * Test if the given format is an integer (non-normalized) format.
 826  */
 827 GLboolean
 828 _mesa_is_enum_format_integer(GLenum format)
 829 {
 830    return _mesa_is_enum_format_unsigned_int(format) ||
 831           _mesa_is_enum_format_signed_int(format);
 832 }
 833
 834
 835 GLboolean
 836 _mesa_is_type_unsigned(GLenum type)
 837 {
 838    switch (type) {
 839    case GL_UNSIGNED_INT:
 840    case GL_UNSIGNED_INT_8_8_8_8:
 841    case GL_UNSIGNED_INT_8_8_8_8_REV:
 842    case GL_UNSIGNED_INT_10_10_10_2:
 843    case GL_UNSIGNED_INT_2_10_10_10_REV:
 844
 845    case GL_UNSIGNED_SHORT:
 846    case GL_UNSIGNED_SHORT_4_4_4_4:
 847    case GL_UNSIGNED_SHORT_5_5_5_1:
 848    case GL_UNSIGNED_SHORT_5_6_5:
 849    case GL_UNSIGNED_SHORT_5_6_5_REV:
 850    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 851    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 852    case GL_UNSIGNED_SHORT_8_8_MESA:
 853    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 854
 855    case GL_UNSIGNED_BYTE:
 856    case GL_UNSIGNED_BYTE_3_3_2:
 857    case GL_UNSIGNED_BYTE_2_3_3_REV:
 858       return GL_TRUE;
 859
 860    default:
 861       return GL_FALSE;
 862    }
 863 }
 864
 865
 866 /**
 867  * Test if the given image format is a color/RGBA format (i.e., not color
 868  * index, depth, stencil, etc).
 869  * \param format  the image format value (may by an internal texture format)
 870  * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
 871  */
 872 GLboolean
 873 _mesa_is_color_format(GLenum format)
 874 {
 875    switch (format) {
 876       case GL_RED:
 877       case GL_GREEN:
 878       case GL_BLUE:
 879       case GL_ALPHA:
 880       case GL_ALPHA4:
 881       case GL_ALPHA8:
 882       case GL_ALPHA12:
 883       case GL_ALPHA16:
 884       case 1:
 885       case GL_LUMINANCE:
 886       case GL_LUMINANCE4:
 887       case GL_LUMINANCE8:
 888       case GL_LUMINANCE12:
 889       case GL_LUMINANCE16:
 890       case 2:
 891       case GL_LUMINANCE_ALPHA:
 892       case GL_LUMINANCE4_ALPHA4:
 893       case GL_LUMINANCE6_ALPHA2:
 894       case GL_LUMINANCE8_ALPHA8:
 895       case GL_LUMINANCE12_ALPHA4:
 896       case GL_LUMINANCE12_ALPHA12:
 897       case GL_LUMINANCE16_ALPHA16:
 898       case GL_INTENSITY:
 899       case GL_INTENSITY4:
 900       case GL_INTENSITY8:
 901       case GL_INTENSITY12:
 902       case GL_INTENSITY16:
 903       case GL_R8:
 904       case GL_R16:
 905       case GL_RG:
 906       case GL_RG8:
 907       case GL_RG16:
 908       case 3:
 909       case GL_RGB:
 910       case GL_BGR:
 911       case GL_R3_G3_B2:
 912       case GL_RGB4:
 913       case GL_RGB5:
 914       case GL_RGB565:
 915       case GL_RGB8:
 916       case GL_RGB10:
 917       case GL_RGB12:
 918       case GL_RGB16:
 919       case 4:
 920       case GL_ABGR_EXT:
 921       case GL_RGBA:
 922       case GL_BGRA:
 923       case GL_RGBA2:
 924       case GL_RGBA4:
 925       case GL_RGB5_A1:
 926       case GL_RGBA8:
 927       case GL_RGB10_A2:
 928       case GL_RGBA12:
 929       case GL_RGBA16:
 930       /* float texture formats */
 931       case GL_ALPHA16F_ARB:
 932       case GL_ALPHA32F_ARB:
 933       case GL_LUMINANCE16F_ARB:
 934       case GL_LUMINANCE32F_ARB:
 935       case GL_LUMINANCE_ALPHA16F_ARB:
 936       case GL_LUMINANCE_ALPHA32F_ARB:
 937       case GL_INTENSITY16F_ARB:
 938       case GL_INTENSITY32F_ARB:
 939       case GL_R16F:
 940       case GL_R32F:
 941       case GL_RG16F:
 942       case GL_RG32F:
 943       case GL_RGB16F_ARB:
 944       case GL_RGB32F_ARB:
 945       case GL_RGBA16F_ARB:
 946       case GL_RGBA32F_ARB:
 947       /* compressed formats */
 948       case GL_COMPRESSED_ALPHA:
 949       case GL_COMPRESSED_LUMINANCE:
 950       case GL_COMPRESSED_LUMINANCE_ALPHA:
 951       case GL_COMPRESSED_INTENSITY:
 952       case GL_COMPRESSED_RED:
 953       case GL_COMPRESSED_RG:
 954       case GL_COMPRESSED_RGB:
 955       case GL_COMPRESSED_RGBA:
 956       case GL_RGB_S3TC:
 957       case GL_RGB4_S3TC:
 958       case GL_RGBA_S3TC:
 959       case GL_RGBA4_S3TC:
 960       case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 961       case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 962       case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 963       case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 964       case GL_COMPRESSED_RGB_FXT1_3DFX:
 965       case GL_COMPRESSED_RGBA_FXT1_3DFX:
 966       case GL_SRGB_EXT:
 967       case GL_SRGB8_EXT:
 968       case GL_SRGB_ALPHA_EXT:
 969       case GL_SRGB8_ALPHA8_EXT:
 970       case GL_SLUMINANCE_ALPHA_EXT:
 971       case GL_SLUMINANCE8_ALPHA8_EXT:
 972       case GL_SLUMINANCE_EXT:
 973       case GL_SLUMINANCE8_EXT:
 974       case GL_COMPRESSED_SRGB_EXT:
 975       case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 976       case GL_COMPRESSED_SRGB_ALPHA_EXT:
 977       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 978       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 979       case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 980       case GL_COMPRESSED_SLUMINANCE_EXT:
 981       case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 982       case GL_COMPRESSED_RED_RGTC1:
 983       case GL_COMPRESSED_SIGNED_RED_RGTC1:
 984       case GL_COMPRESSED_RG_RGTC2:
 985       case GL_COMPRESSED_SIGNED_RG_RGTC2:
 986       case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 987       case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 988       case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 989       case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 990       case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 991       case GL_ETC1_RGB8_OES:
 992       case GL_COMPRESSED_RGB8_ETC2:
 993       case GL_COMPRESSED_SRGB8_ETC2:
 994       case GL_COMPRESSED_RGBA8_ETC2_EAC:
 995       case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 996       case GL_COMPRESSED_R11_EAC:
 997       case GL_COMPRESSED_RG11_EAC:
 998       case GL_COMPRESSED_SIGNED_R11_EAC:
 999       case GL_COMPRESSED_SIGNED_RG11_EAC:
1000       case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1001       case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1002       case GL_COMPRESSED_RGBA_BPTC_UNORM:
1003       case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
1004       case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
1005       case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
1006       /* generic integer formats */
1007       case GL_RED_INTEGER_EXT:
1008       case GL_GREEN_INTEGER_EXT:
1009       case GL_BLUE_INTEGER_EXT:
1010       case GL_ALPHA_INTEGER_EXT:
1011       case GL_RGB_INTEGER_EXT:
1012       case GL_RGBA_INTEGER_EXT:
1013       case GL_BGR_INTEGER_EXT:
1014       case GL_BGRA_INTEGER_EXT:
1015       case GL_RG_INTEGER:
1016       case GL_LUMINANCE_INTEGER_EXT:
1017       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1018       /* sized integer formats */
1019       case GL_RGBA32UI_EXT:
1020       case GL_RGB32UI_EXT:
1021       case GL_RG32UI:
1022       case GL_R32UI:
1023       case GL_ALPHA32UI_EXT:
1024       case GL_INTENSITY32UI_EXT:
1025       case GL_LUMINANCE32UI_EXT:
1026       case GL_LUMINANCE_ALPHA32UI_EXT:
1027       case GL_RGBA16UI_EXT:
1028       case GL_RGB16UI_EXT:
1029       case GL_RG16UI:
1030       case GL_R16UI:
1031       case GL_ALPHA16UI_EXT:
1032       case GL_INTENSITY16UI_EXT:
1033       case GL_LUMINANCE16UI_EXT:
1034       case GL_LUMINANCE_ALPHA16UI_EXT:
1035       case GL_RGBA8UI_EXT:
1036       case GL_RGB8UI_EXT:
1037       case GL_RG8UI:
1038       case GL_R8UI:
1039       case GL_ALPHA8UI_EXT:
1040       case GL_INTENSITY8UI_EXT:
1041       case GL_LUMINANCE8UI_EXT:
1042       case GL_LUMINANCE_ALPHA8UI_EXT:
1043       case GL_RGBA32I_EXT:
1044       case GL_RGB32I_EXT:
1045       case GL_RG32I:
1046       case GL_R32I:
1047       case GL_ALPHA32I_EXT:
1048       case GL_INTENSITY32I_EXT:
1049       case GL_LUMINANCE32I_EXT:
1050       case GL_LUMINANCE_ALPHA32I_EXT:
1051       case GL_RGBA16I_EXT:
1052       case GL_RGB16I_EXT:
1053       case GL_RG16I:
1054       case GL_R16I:
1055       case GL_ALPHA16I_EXT:
1056       case GL_INTENSITY16I_EXT:
1057       case GL_LUMINANCE16I_EXT:
1058       case GL_LUMINANCE_ALPHA16I_EXT:
1059       case GL_RGBA8I_EXT:
1060       case GL_RGB8I_EXT:
1061       case GL_RG8I:
1062       case GL_R8I:
1063       case GL_ALPHA8I_EXT:
1064       case GL_INTENSITY8I_EXT:
1065       case GL_LUMINANCE8I_EXT:
1066       case GL_LUMINANCE_ALPHA8I_EXT:
1067       /* signed, normalized texture formats */
1068       case GL_RED_SNORM:
1069       case GL_R8_SNORM:
1070       case GL_R16_SNORM:
1071       case GL_RG_SNORM:
1072       case GL_RG8_SNORM:
1073       case GL_RG16_SNORM:
1074       case GL_RGB_SNORM:
1075       case GL_RGB8_SNORM:
1076       case GL_RGB16_SNORM:
1077       case GL_RGBA_SNORM:
1078       case GL_RGBA8_SNORM:
1079       case GL_RGBA16_SNORM:
1080       case GL_ALPHA_SNORM:
1081       case GL_ALPHA8_SNORM:
1082       case GL_ALPHA16_SNORM:
1083       case GL_LUMINANCE_SNORM:
1084       case GL_LUMINANCE8_SNORM:
1085       case GL_LUMINANCE16_SNORM:
1086       case GL_LUMINANCE_ALPHA_SNORM:
1087       case GL_LUMINANCE8_ALPHA8_SNORM:
1088       case GL_LUMINANCE16_ALPHA16_SNORM:
1089       case GL_INTENSITY_SNORM:
1090       case GL_INTENSITY8_SNORM:
1091       case GL_INTENSITY16_SNORM:
1092       case GL_RGB9_E5:
1093       case GL_R11F_G11F_B10F:
1094       case GL_RGB10_A2UI:
1095          return GL_TRUE;
1096       case GL_YCBCR_MESA:  /* not considered to be RGB */
1097          /* fall-through */
1098       default:
1099          return GL_FALSE;
1100    }
1101 }
1102
1103
1104 /**
1105  * Test if the given image format is a depth component format.
1106  */
1107 GLboolean
1108 _mesa_is_depth_format(GLenum format)
1109 {
1110    switch (format) {
1111       case GL_DEPTH_COMPONENT:
1112       case GL_DEPTH_COMPONENT16:
1113       case GL_DEPTH_COMPONENT24:
1114       case GL_DEPTH_COMPONENT32:
1115       case GL_DEPTH_COMPONENT32F:
1116          return GL_TRUE;
1117       default:
1118          return GL_FALSE;
1119    }
1120 }
1121
1122
1123 /**
1124  * Test if the given image format is a stencil format.
1125  */
1126 GLboolean
1127 _mesa_is_stencil_format(GLenum format)
1128 {
1129    switch (format) {
1130       case GL_STENCIL_INDEX:
1131          return GL_TRUE;
1132       default:
1133          return GL_FALSE;
1134    }
1135 }
1136
1137
1138 /**
1139  * Test if the given image format is a YCbCr format.
1140  */
1141 GLboolean
1142 _mesa_is_ycbcr_format(GLenum format)
1143 {
1144    switch (format) {
1145       case GL_YCBCR_MESA:
1146          return GL_TRUE;
1147       default:
1148          return GL_FALSE;
1149    }
1150 }
1151
1152
1153 /**
1154  * Test if the given image format is a depth+stencil format.
1155  */
1156 GLboolean
1157 _mesa_is_depthstencil_format(GLenum format)
1158 {
1159    switch (format) {
1160       case GL_DEPTH24_STENCIL8_EXT:
1161       case GL_DEPTH_STENCIL_EXT:
1162       case GL_DEPTH32F_STENCIL8:
1163          return GL_TRUE;
1164       default:
1165          return GL_FALSE;
1166    }
1167 }
1168
1169
1170 /**
1171  * Test if the given image format is a depth or stencil format.
1172  */
1173 GLboolean
1174 _mesa_is_depth_or_stencil_format(GLenum format)
1175 {
1176    switch (format) {
1177       case GL_DEPTH_COMPONENT:
1178       case GL_DEPTH_COMPONENT16:
1179       case GL_DEPTH_COMPONENT24:
1180       case GL_DEPTH_COMPONENT32:
1181       case GL_STENCIL_INDEX:
1182       case GL_STENCIL_INDEX1_EXT:
1183       case GL_STENCIL_INDEX4_EXT:
1184       case GL_STENCIL_INDEX8_EXT:
1185       case GL_STENCIL_INDEX16_EXT:
1186       case GL_DEPTH_STENCIL_EXT:
1187       case GL_DEPTH24_STENCIL8_EXT:
1188       case GL_DEPTH_COMPONENT32F:
1189       case GL_DEPTH32F_STENCIL8:
1190          return GL_TRUE;
1191       default:
1192          return GL_FALSE;
1193    }
1194 }
1195
1196
1197 /**
1198  * Test if an image format is a supported compressed format.
1199  * \param format the internal format token provided by the user.
1200  * \return GL_TRUE if compressed, GL_FALSE if uncompressed
1201  */
1202 GLboolean
1203 _mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
1204 {
1205    switch (format) {
1206    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1207    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1208    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
1209    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
1210       /* Assume that the ANGLE flag will always be set if the EXT flag is set.
1211        */
1212       return ctx->Extensions.ANGLE_texture_compression_dxt;
1213    case GL_RGB_S3TC:
1214    case GL_RGB4_S3TC:
1215    case GL_RGBA_S3TC:
1216    case GL_RGBA4_S3TC:
1217       return _mesa_is_desktop_gl(ctx) &&
1218          ctx->Extensions.ANGLE_texture_compression_dxt;
1219    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
1220    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
1221    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
1222    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
1223       return _mesa_is_desktop_gl(ctx)
1224          && ctx->Extensions.EXT_texture_sRGB
1225          && ctx->Extensions.EXT_texture_compression_s3tc;
1226    case GL_COMPRESSED_RGB_FXT1_3DFX:
1227    case GL_COMPRESSED_RGBA_FXT1_3DFX:
1228       return _mesa_is_desktop_gl(ctx)
1229          && ctx->Extensions.TDFX_texture_compression_FXT1;
1230    case GL_COMPRESSED_RED_RGTC1:
1231    case GL_COMPRESSED_SIGNED_RED_RGTC1:
1232    case GL_COMPRESSED_RG_RGTC2:
1233    case GL_COMPRESSED_SIGNED_RG_RGTC2:
1234       return _mesa_is_desktop_gl(ctx)
1235          && ctx->Extensions.ARB_texture_compression_rgtc;
1236    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
1237    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
1238    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
1239    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
1240       return ctx->API == API_OPENGL_COMPAT
1241          && ctx->Extensions.EXT_texture_compression_latc;
1242    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
1243       return ctx->API == API_OPENGL_COMPAT
1244          && ctx->Extensions.ATI_texture_compression_3dc;
1245    case GL_ETC1_RGB8_OES:
1246       return _mesa_is_gles(ctx)
1247          && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
1248    case GL_COMPRESSED_RGB8_ETC2:
1249    case GL_COMPRESSED_SRGB8_ETC2:
1250    case GL_COMPRESSED_RGBA8_ETC2_EAC:
1251    case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
1252    case GL_COMPRESSED_R11_EAC:
1253    case GL_COMPRESSED_RG11_EAC:
1254    case GL_COMPRESSED_SIGNED_R11_EAC:
1255    case GL_COMPRESSED_SIGNED_RG11_EAC:
1256    case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1257    case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1258       return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility;
1259    case GL_COMPRESSED_RGBA_BPTC_UNORM:
1260    case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
1261    case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
1262    case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
1263       return _mesa_is_desktop_gl(ctx) &&
1264          ctx->Extensions.ARB_texture_compression_bptc;
1265    case GL_PALETTE4_RGB8_OES:
1266    case GL_PALETTE4_RGBA8_OES:
1267    case GL_PALETTE4_R5_G6_B5_OES:
1268    case GL_PALETTE4_RGBA4_OES:
1269    case GL_PALETTE4_RGB5_A1_OES:
1270    case GL_PALETTE8_RGB8_OES:
1271    case GL_PALETTE8_RGBA8_OES:
1272    case GL_PALETTE8_R5_G6_B5_OES:
1273    case GL_PALETTE8_RGBA4_OES:
1274    case GL_PALETTE8_RGB5_A1_OES:
1275       return ctx->API == API_OPENGLES;
1276    default:
1277       return GL_FALSE;
1278    }
1279 }
1280
1281
1282 /**
1283  * Convert various base formats to the cooresponding integer format.
1284  */
1285 GLenum
1286 _mesa_base_format_to_integer_format(GLenum format)
1287 {
1288    switch(format) {
1289    case GL_RED:
1290       return GL_RED_INTEGER;
1291    case GL_GREEN:
1292       return GL_GREEN_INTEGER;
1293    case GL_BLUE:
1294       return GL_BLUE_INTEGER;
1295    case GL_RG:
1296       return GL_RG_INTEGER;
1297    case GL_RGB:
1298       return GL_RGB_INTEGER;
1299    case GL_RGBA:
1300       return GL_RGBA_INTEGER;
1301    case GL_BGR:
1302       return GL_BGR_INTEGER;
1303    case GL_BGRA:
1304       return GL_BGRA_INTEGER;
1305    case GL_ALPHA:
1306       return GL_ALPHA_INTEGER;
1307    case GL_LUMINANCE:
1308       return GL_LUMINANCE_INTEGER_EXT;
1309    case GL_LUMINANCE_ALPHA:
1310       return GL_LUMINANCE_ALPHA_INTEGER_EXT;
1311    }
1312
1313    return format;
1314 }
1315
1316
1317 /**
1318  * Does the given base texture/renderbuffer format have the channel
1319  * named by 'pname'?
1320  */
1321 GLboolean
1322 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
1323 {
1324    switch (pname) {
1325    case GL_TEXTURE_RED_SIZE:
1326    case GL_TEXTURE_RED_TYPE:
1327    case GL_RENDERBUFFER_RED_SIZE_EXT:
1328    case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
1329       if (base_format == GL_RED ||
1330           base_format == GL_RG ||
1331           base_format == GL_RGB ||
1332           base_format == GL_RGBA) {
1333          return GL_TRUE;
1334       }
1335       return GL_FALSE;
1336    case GL_TEXTURE_GREEN_SIZE:
1337    case GL_TEXTURE_GREEN_TYPE:
1338    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
1339    case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
1340       if (base_format == GL_RG ||
1341           base_format == GL_RGB ||
1342           base_format == GL_RGBA) {
1343          return GL_TRUE;
1344       }
1345       return GL_FALSE;
1346    case GL_TEXTURE_BLUE_SIZE:
1347    case GL_TEXTURE_BLUE_TYPE:
1348    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1349    case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1350       if (base_format == GL_RGB ||
1351           base_format == GL_RGBA) {
1352          return GL_TRUE;
1353       }
1354       return GL_FALSE;
1355    case GL_TEXTURE_ALPHA_SIZE:
1356    case GL_TEXTURE_ALPHA_TYPE:
1357    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1358    case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1359       if (base_format == GL_RGBA ||
1360           base_format == GL_ALPHA ||
1361           base_format == GL_LUMINANCE_ALPHA) {
1362          return GL_TRUE;
1363       }
1364       return GL_FALSE;
1365    case GL_TEXTURE_LUMINANCE_SIZE:
1366    case GL_TEXTURE_LUMINANCE_TYPE:
1367       if (base_format == GL_LUMINANCE ||
1368           base_format == GL_LUMINANCE_ALPHA) {
1369          return GL_TRUE;
1370       }
1371       return GL_FALSE;
1372    case GL_TEXTURE_INTENSITY_SIZE:
1373    case GL_TEXTURE_INTENSITY_TYPE:
1374       if (base_format == GL_INTENSITY) {
1375          return GL_TRUE;
1376       }
1377       return GL_FALSE;
1378    case GL_TEXTURE_DEPTH_SIZE:
1379    case GL_TEXTURE_DEPTH_TYPE:
1380    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1381    case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1382       if (base_format == GL_DEPTH_STENCIL ||
1383           base_format == GL_DEPTH_COMPONENT) {
1384          return GL_TRUE;
1385       }
1386       return GL_FALSE;
1387    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1388    case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1389       if (base_format == GL_DEPTH_STENCIL ||
1390           base_format == GL_STENCIL_INDEX) {
1391          return GL_TRUE;
1392       }
1393       return GL_FALSE;
1394    default:
1395       _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1396                     __func__, pname);
1397       return GL_FALSE;
1398    }
1399
1400    return GL_FALSE;
1401 }
1402
1403
1404 /**
1405  * Returns the number of channels/components for a base format.
1406  */
1407 GLint
1408 _mesa_base_format_component_count(GLenum base_format)
1409 {
1410    switch (base_format) {
1411    case GL_RED:
1412    case GL_ALPHA:
1413    case GL_INTENSITY:
1414    case GL_DEPTH_COMPONENT:
1415       return 1;
1416    case GL_RG:
1417    case GL_LUMINANCE_ALPHA:
1418    case GL_DEPTH_STENCIL:
1419       return 2;
1420    case GL_RGB:
1421       return 3;
1422    case GL_RGBA:
1423       return 4;
1424    default:
1425       return -1;
1426    }
1427 }
1428
1429
1430 /**
1431  * If format is a generic compressed format, return the corresponding
1432  * non-compressed format.  For other formats, return the format as-is.
1433  */
1434 GLenum
1435 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1436 {
1437    switch (format) {
1438    case GL_COMPRESSED_RED:
1439       return GL_RED;
1440    case GL_COMPRESSED_RG:
1441       return GL_RG;
1442    case GL_COMPRESSED_RGB:
1443       return GL_RGB;
1444    case GL_COMPRESSED_RGBA:
1445       return GL_RGBA;
1446    case GL_COMPRESSED_ALPHA:
1447       return GL_ALPHA;
1448    case GL_COMPRESSED_LUMINANCE:
1449       return GL_LUMINANCE;
1450    case GL_COMPRESSED_LUMINANCE_ALPHA:
1451       return GL_LUMINANCE_ALPHA;
1452    case GL_COMPRESSED_INTENSITY:
1453       return GL_INTENSITY;
1454    /* sRGB formats */
1455    case GL_COMPRESSED_SRGB:
1456       return GL_SRGB;
1457    case GL_COMPRESSED_SRGB_ALPHA:
1458       return GL_SRGB_ALPHA;
1459    case GL_COMPRESSED_SLUMINANCE:
1460       return GL_SLUMINANCE;
1461    case GL_COMPRESSED_SLUMINANCE_ALPHA:
1462       return GL_SLUMINANCE_ALPHA;
1463    default:
1464       return format;
1465    }
1466 }
1467
1468
1469 /**
1470  * Return the equivalent non-generic internal format.
1471  * This is useful for comparing whether two internal formats are equivalent.
1472  */
1473 GLenum
1474 _mesa_get_nongeneric_internalformat(GLenum format)
1475 {
1476    switch (format) {
1477    /* GL 1.1 formats. */
1478    case 4:
1479    case GL_RGBA:
1480       return GL_RGBA8;
1481    case 3:
1482    case GL_RGB:
1483       return GL_RGB8;
1484    case 2:
1485    case GL_LUMINANCE_ALPHA:
1486       return GL_LUMINANCE8_ALPHA8;
1487    case 1:
1488    case GL_LUMINANCE:
1489       return GL_LUMINANCE8;
1490    case GL_ALPHA:
1491       return GL_ALPHA8;
1492    case GL_INTENSITY:
1493       return GL_INTENSITY8;
1494
1495    /* GL_ARB_texture_rg */
1496    case GL_RED:
1497       return GL_R8;
1498    case GL_RG:
1499       return GL_RG8;
1500
1501    /* GL_EXT_texture_sRGB */
1502    case GL_SRGB:
1503       return GL_SRGB8;
1504    case GL_SRGB_ALPHA:
1505       return GL_SRGB8_ALPHA8;
1506    case GL_SLUMINANCE:
1507       return GL_SLUMINANCE8;
1508    case GL_SLUMINANCE_ALPHA:
1509       return GL_SLUMINANCE8_ALPHA8;
1510
1511    /* GL_EXT_texture_snorm */
1512    case GL_RGBA_SNORM:
1513       return GL_RGBA8_SNORM;
1514    case GL_RGB_SNORM:
1515       return GL_RGB8_SNORM;
1516    case GL_RG_SNORM:
1517       return GL_RG8_SNORM;
1518    case GL_RED_SNORM:
1519       return GL_R8_SNORM;
1520    case GL_LUMINANCE_ALPHA_SNORM:
1521       return GL_LUMINANCE8_ALPHA8_SNORM;
1522    case GL_LUMINANCE_SNORM:
1523       return GL_LUMINANCE8_SNORM;
1524    case GL_ALPHA_SNORM:
1525       return GL_ALPHA8_SNORM;
1526    case GL_INTENSITY_SNORM:
1527       return GL_INTENSITY8_SNORM;
1528
1529    default:
1530       return format;
1531    }
1532 }
1533
1534
1535 /**
1536  * Convert an sRGB internal format to linear.
1537  */
1538 GLenum
1539 _mesa_get_linear_internalformat(GLenum format)
1540 {
1541    switch (format) {
1542    case GL_SRGB:
1543       return GL_RGB;
1544    case GL_SRGB_ALPHA:
1545       return GL_RGBA;
1546    case GL_SRGB8:
1547       return GL_RGB8;
1548    case GL_SRGB8_ALPHA8:
1549       return GL_RGBA8;
1550    case GL_SLUMINANCE8:
1551       return GL_LUMINANCE8;
1552    case GL_SLUMINANCE:
1553       return GL_LUMINANCE;
1554    case GL_SLUMINANCE_ALPHA:
1555       return GL_LUMINANCE_ALPHA;
1556    case GL_SLUMINANCE8_ALPHA8:
1557       return GL_LUMINANCE8_ALPHA8;
1558    default:
1559       return format;
1560    }
1561 }
1562
1563
1564 /**
1565  * Do error checking of format/type combinations for glReadPixels,
1566  * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1567  * and type values, we may either generate GL_INVALID_OPERATION or
1568  * GL_INVALID_ENUM.
1569  *
1570  * \param format pixel format.
1571  * \param type pixel type.
1572  *
1573  * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1574  */
1575 GLenum
1576 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1577                                   GLenum format, GLenum type)
1578 {
1579    /* From OpenGL 3.3 spec, page 220:
1580     *    "If the format is DEPTH_STENCIL, then values are taken from
1581     *    both the depth buffer and the stencil buffer. If there is no
1582     *    depth buffer or if there is no stencil buffer, then the error
1583     *    INVALID_OPERATION occurs. If the type parameter is not
1584     *    UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the
1585     *    error INVALID_ENUM occurs."
1586     *
1587     * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels
1588     * cannot be used to read depth or stencil in that API.
1589     */
1590    if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL
1591        && type != GL_UNSIGNED_INT_24_8
1592        && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1593       return GL_INVALID_ENUM;
1594
1595    /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1596    switch (type) {
1597    case GL_BITMAP:
1598       if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1599          return GL_INVALID_ENUM;
1600       }
1601       break;
1602
1603    case GL_UNSIGNED_BYTE_3_3_2:
1604    case GL_UNSIGNED_BYTE_2_3_3_REV:
1605    case GL_UNSIGNED_SHORT_5_6_5:
1606    case GL_UNSIGNED_SHORT_5_6_5_REV:
1607       if (format == GL_RGB) {
1608          break; /* OK */
1609       }
1610       if (format == GL_RGB_INTEGER_EXT &&
1611           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1612          break; /* OK */
1613       }
1614       return GL_INVALID_OPERATION;
1615
1616    case GL_UNSIGNED_SHORT_4_4_4_4:
1617    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1618    case GL_UNSIGNED_INT_8_8_8_8:
1619    case GL_UNSIGNED_INT_8_8_8_8_REV:
1620       if (format == GL_RGBA ||
1621           format == GL_BGRA ||
1622           format == GL_ABGR_EXT) {
1623          break; /* OK */
1624       }
1625       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1626           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1627          break; /* OK */
1628       }
1629       return GL_INVALID_OPERATION;
1630
1631    case GL_UNSIGNED_SHORT_5_5_5_1:
1632    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1633    case GL_UNSIGNED_INT_10_10_10_2:
1634    case GL_UNSIGNED_INT_2_10_10_10_REV:
1635       if (format == GL_RGBA ||
1636           format == GL_BGRA) {
1637          break; /* OK */
1638       }
1639       if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1640           ctx->Extensions.ARB_texture_rgb10_a2ui) {
1641          break; /* OK */
1642       }
1643       if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1644           ctx->API == API_OPENGLES2) {
1645          break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1646       }
1647       return GL_INVALID_OPERATION;
1648
1649    case GL_UNSIGNED_INT_24_8:
1650       if (format != GL_DEPTH_STENCIL) {
1651          return GL_INVALID_OPERATION;
1652       }
1653       return GL_NO_ERROR;
1654
1655    case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1656       if (!ctx->Extensions.ARB_depth_buffer_float) {
1657          return GL_INVALID_ENUM;
1658       }
1659       if (format != GL_DEPTH_STENCIL) {
1660          return GL_INVALID_OPERATION;
1661       }
1662       return GL_NO_ERROR;
1663
1664    case GL_UNSIGNED_INT_10F_11F_11F_REV:
1665       if (!ctx->Extensions.EXT_packed_float) {
1666          return GL_INVALID_ENUM;
1667       }
1668       if (format != GL_RGB) {
1669          return GL_INVALID_OPERATION;
1670       }
1671       return GL_NO_ERROR;
1672
1673    case GL_HALF_FLOAT_OES:
1674       switch (format) {
1675       case GL_RGBA:
1676       case GL_RGB:
1677       case GL_LUMINANCE_ALPHA:
1678       case GL_LUMINANCE:
1679       case GL_ALPHA:
1680          return GL_NO_ERROR;
1681       default:
1682          return GL_INVALID_OPERATION;
1683       }
1684
1685    default:
1686       ; /* fall-through */
1687    }
1688
1689    /* now, for each format, check the type for compatibility */
1690    switch (format) {
1691       case GL_COLOR_INDEX:
1692       case GL_STENCIL_INDEX:
1693          switch (type) {
1694             case GL_BITMAP:
1695             case GL_BYTE:
1696             case GL_UNSIGNED_BYTE:
1697             case GL_SHORT:
1698             case GL_UNSIGNED_SHORT:
1699             case GL_INT:
1700             case GL_UNSIGNED_INT:
1701             case GL_FLOAT:
1702             case GL_HALF_FLOAT:
1703                return GL_NO_ERROR;
1704             default:
1705                return GL_INVALID_ENUM;
1706          }
1707
1708       case GL_RED:
1709       case GL_GREEN:
1710       case GL_BLUE:
1711       case GL_ALPHA:
1712 #if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1713       case GL_INTENSITY:
1714 #endif
1715       case GL_LUMINANCE:
1716       case GL_LUMINANCE_ALPHA:
1717       case GL_DEPTH_COMPONENT:
1718          switch (type) {
1719             case GL_BYTE:
1720             case GL_UNSIGNED_BYTE:
1721             case GL_SHORT:
1722             case GL_UNSIGNED_SHORT:
1723             case GL_INT:
1724             case GL_UNSIGNED_INT:
1725             case GL_FLOAT:
1726             case GL_HALF_FLOAT:
1727                return GL_NO_ERROR;
1728             default:
1729                return GL_INVALID_ENUM;
1730          }
1731
1732       case GL_RG:
1733          if (!ctx->Extensions.ARB_texture_rg)
1734             return GL_INVALID_ENUM;
1735          switch (type) {
1736             case GL_BYTE:
1737             case GL_UNSIGNED_BYTE:
1738             case GL_SHORT:
1739             case GL_UNSIGNED_SHORT:
1740             case GL_INT:
1741             case GL_UNSIGNED_INT:
1742             case GL_FLOAT:
1743             case GL_HALF_FLOAT:
1744                return GL_NO_ERROR;
1745             default:
1746                return GL_INVALID_ENUM;
1747          }
1748
1749       case GL_RGB:
1750          switch (type) {
1751             case GL_BYTE:
1752             case GL_UNSIGNED_BYTE:
1753             case GL_SHORT:
1754             case GL_UNSIGNED_SHORT:
1755             case GL_INT:
1756             case GL_UNSIGNED_INT:
1757             case GL_FLOAT:
1758             case GL_UNSIGNED_BYTE_3_3_2:
1759             case GL_UNSIGNED_BYTE_2_3_3_REV:
1760             case GL_UNSIGNED_SHORT_5_6_5:
1761             case GL_UNSIGNED_SHORT_5_6_5_REV:
1762             case GL_HALF_FLOAT:
1763                return GL_NO_ERROR;
1764             case GL_UNSIGNED_INT_2_10_10_10_REV:
1765                /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1766                return (ctx->API == API_OPENGLES2)
1767                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1768             case GL_UNSIGNED_INT_5_9_9_9_REV:
1769                return ctx->Extensions.EXT_texture_shared_exponent
1770                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1771             case GL_UNSIGNED_INT_10F_11F_11F_REV:
1772                return ctx->Extensions.EXT_packed_float
1773                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1774             default:
1775                return GL_INVALID_ENUM;
1776          }
1777
1778       case GL_BGR:
1779          switch (type) {
1780             /* NOTE: no packed types are supported with BGR.  That's
1781              * intentional, according to the GL spec.
1782              */
1783             case GL_BYTE:
1784             case GL_UNSIGNED_BYTE:
1785             case GL_SHORT:
1786             case GL_UNSIGNED_SHORT:
1787             case GL_INT:
1788             case GL_UNSIGNED_INT:
1789             case GL_FLOAT:
1790             case GL_HALF_FLOAT:
1791                return GL_NO_ERROR;
1792             default:
1793                return GL_INVALID_ENUM;
1794          }
1795
1796       case GL_RGBA:
1797       case GL_BGRA:
1798          switch (type) {
1799             case GL_BYTE:
1800             case GL_UNSIGNED_BYTE:
1801             case GL_SHORT:
1802             case GL_UNSIGNED_SHORT:
1803             case GL_INT:
1804             case GL_UNSIGNED_INT:
1805             case GL_FLOAT:
1806             case GL_UNSIGNED_SHORT_4_4_4_4:
1807             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1808             case GL_UNSIGNED_SHORT_5_5_5_1:
1809             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1810             case GL_UNSIGNED_INT_8_8_8_8:
1811             case GL_UNSIGNED_INT_8_8_8_8_REV:
1812             case GL_UNSIGNED_INT_10_10_10_2:
1813             case GL_UNSIGNED_INT_2_10_10_10_REV:
1814             case GL_HALF_FLOAT:
1815                return GL_NO_ERROR;
1816             default:
1817                return GL_INVALID_ENUM;
1818          }
1819
1820       case GL_ABGR_EXT:
1821          switch (type) {
1822             case GL_BYTE:
1823             case GL_UNSIGNED_BYTE:
1824             case GL_SHORT:
1825             case GL_UNSIGNED_SHORT:
1826             case GL_INT:
1827             case GL_UNSIGNED_INT:
1828             case GL_FLOAT:
1829             case GL_UNSIGNED_SHORT_4_4_4_4:
1830             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1831             case GL_UNSIGNED_INT_8_8_8_8:
1832             case GL_UNSIGNED_INT_8_8_8_8_REV:
1833             case GL_HALF_FLOAT:
1834                return GL_NO_ERROR;
1835             default:
1836                return GL_INVALID_ENUM;
1837          }
1838
1839       case GL_YCBCR_MESA:
1840          if (!ctx->Extensions.MESA_ycbcr_texture)
1841             return GL_INVALID_ENUM;
1842          if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1843              type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1844             return GL_NO_ERROR;
1845          else
1846             return GL_INVALID_OPERATION;
1847
1848       case GL_DEPTH_STENCIL:
1849          if (type == GL_UNSIGNED_INT_24_8)
1850             return GL_NO_ERROR;
1851          else if (ctx->Extensions.ARB_depth_buffer_float &&
1852              type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1853             return GL_NO_ERROR;
1854          else
1855             return GL_INVALID_ENUM;
1856
1857       /* integer-valued formats */
1858       case GL_RED_INTEGER_EXT:
1859       case GL_GREEN_INTEGER_EXT:
1860       case GL_BLUE_INTEGER_EXT:
1861       case GL_ALPHA_INTEGER_EXT:
1862       case GL_RG_INTEGER:
1863          switch (type) {
1864             case GL_BYTE:
1865             case GL_UNSIGNED_BYTE:
1866             case GL_SHORT:
1867             case GL_UNSIGNED_SHORT:
1868             case GL_INT:
1869             case GL_UNSIGNED_INT:
1870                return (ctx->Version >= 30 ||
1871                        ctx->Extensions.EXT_texture_integer)
1872                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1873             default:
1874                return GL_INVALID_ENUM;
1875          }
1876
1877       case GL_RGB_INTEGER_EXT:
1878          switch (type) {
1879             case GL_BYTE:
1880             case GL_UNSIGNED_BYTE:
1881             case GL_SHORT:
1882             case GL_UNSIGNED_SHORT:
1883             case GL_INT:
1884             case GL_UNSIGNED_INT:
1885                return (ctx->Version >= 30 ||
1886                        ctx->Extensions.EXT_texture_integer)
1887                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1888             case GL_UNSIGNED_BYTE_3_3_2:
1889             case GL_UNSIGNED_BYTE_2_3_3_REV:
1890             case GL_UNSIGNED_SHORT_5_6_5:
1891             case GL_UNSIGNED_SHORT_5_6_5_REV:
1892                return ctx->Extensions.ARB_texture_rgb10_a2ui
1893                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1894             default:
1895                return GL_INVALID_ENUM;
1896          }
1897
1898       case GL_BGR_INTEGER_EXT:
1899          switch (type) {
1900             case GL_BYTE:
1901             case GL_UNSIGNED_BYTE:
1902             case GL_SHORT:
1903             case GL_UNSIGNED_SHORT:
1904             case GL_INT:
1905             case GL_UNSIGNED_INT:
1906             /* NOTE: no packed formats w/ BGR format */
1907                return (ctx->Version >= 30 ||
1908                        ctx->Extensions.EXT_texture_integer)
1909                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1910             default:
1911                return GL_INVALID_ENUM;
1912          }
1913
1914       case GL_RGBA_INTEGER_EXT:
1915       case GL_BGRA_INTEGER_EXT:
1916          switch (type) {
1917             case GL_BYTE:
1918             case GL_UNSIGNED_BYTE:
1919             case GL_SHORT:
1920             case GL_UNSIGNED_SHORT:
1921             case GL_INT:
1922             case GL_UNSIGNED_INT:
1923                return (ctx->Version >= 30 ||
1924                        ctx->Extensions.EXT_texture_integer)
1925                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1926             case GL_UNSIGNED_SHORT_4_4_4_4:
1927             case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1928             case GL_UNSIGNED_SHORT_5_5_5_1:
1929             case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1930             case GL_UNSIGNED_INT_8_8_8_8:
1931             case GL_UNSIGNED_INT_8_8_8_8_REV:
1932             case GL_UNSIGNED_INT_10_10_10_2:
1933             case GL_UNSIGNED_INT_2_10_10_10_REV:
1934                return ctx->Extensions.ARB_texture_rgb10_a2ui
1935                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1936             default:
1937                return GL_INVALID_ENUM;
1938          }
1939
1940       case GL_LUMINANCE_INTEGER_EXT:
1941       case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1942          switch (type) {
1943             case GL_BYTE:
1944             case GL_UNSIGNED_BYTE:
1945             case GL_SHORT:
1946             case GL_UNSIGNED_SHORT:
1947             case GL_INT:
1948             case GL_UNSIGNED_INT:
1949                return ctx->Extensions.EXT_texture_integer
1950                   ? GL_NO_ERROR : GL_INVALID_ENUM;
1951             default:
1952                return GL_INVALID_ENUM;
1953          }
1954
1955       default:
1956          return GL_INVALID_ENUM;
1957    }
1958    return GL_NO_ERROR;
1959 }
1960
1961
1962 /**
1963  * Do error checking of format/type combinations for OpenGL ES glReadPixels
1964  * and glTex[Sub]Image.
1965  * \return error code, or GL_NO_ERROR.
1966  */
1967 GLenum
1968 _mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1969                                      unsigned dimensions)
1970 {
1971    GLboolean type_valid = GL_TRUE;
1972
1973    switch (format) {
1974    case GL_ALPHA:
1975    case GL_LUMINANCE:
1976    case GL_LUMINANCE_ALPHA:
1977       type_valid = (type == GL_UNSIGNED_BYTE
1978                     || type == GL_FLOAT
1979                     || type == GL_HALF_FLOAT_OES);
1980       break;
1981
1982    case GL_RGB:
1983       type_valid = (type == GL_UNSIGNED_BYTE
1984                     || type == GL_UNSIGNED_SHORT_5_6_5
1985                     || type == GL_FLOAT
1986                     || type == GL_HALF_FLOAT_OES);
1987       break;
1988
1989    case GL_RGBA:
1990       type_valid = (type == GL_UNSIGNED_BYTE
1991                     || type == GL_UNSIGNED_SHORT_4_4_4_4
1992                     || type == GL_UNSIGNED_SHORT_5_5_5_1
1993                     || type == GL_FLOAT
1994                     || type == GL_HALF_FLOAT_OES
1995                     || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1996       break;
1997
1998    case GL_DEPTH_COMPONENT:
1999       /* This format is filtered against invalid dimensionalities elsewhere.
2000        */
2001       type_valid = (type == GL_UNSIGNED_SHORT
2002                     || type == GL_UNSIGNED_INT);
2003       break;
2004
2005    case GL_DEPTH_STENCIL:
2006       /* This format is filtered against invalid dimensionalities elsewhere.
2007        */
2008       type_valid = (type == GL_UNSIGNED_INT_24_8);
2009       break;
2010
2011    case GL_BGRA_EXT:
2012       type_valid = (type == GL_UNSIGNED_BYTE);
2013
2014       /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
2015        * the format does not appear to be allowed for 3D textures in OpenGL
2016        * ES.
2017        */
2018       if (dimensions != 2)
2019          return GL_INVALID_VALUE;
2020
2021       break;
2022
2023    default:
2024       return GL_INVALID_VALUE;
2025    }
2026
2027    return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2028 }
2029
2030
2031 /**
2032  * Do error checking of format/type combinations for OpenGL ES 3
2033  * glTex[Sub]Image.
2034  * \return error code, or GL_NO_ERROR.
2035  */
2036 GLenum
2037 _mesa_es3_error_check_format_and_type(const struct gl_context *ctx,
2038                                       GLenum format, GLenum type,
2039                                       GLenum internalFormat)
2040 {
2041    switch (format) {
2042    case GL_RGBA:
2043       switch (type) {
2044       case GL_UNSIGNED_BYTE:
2045          switch (internalFormat) {
2046          case GL_RGBA:
2047          case GL_RGBA8:
2048          case GL_RGB5_A1:
2049          case GL_RGBA4:
2050          case GL_SRGB8_ALPHA8_EXT:
2051             break;
2052          default:
2053             return GL_INVALID_OPERATION;
2054          }
2055          break;
2056
2057       case GL_BYTE:
2058          if (internalFormat != GL_RGBA8_SNORM)
2059             return GL_INVALID_OPERATION;
2060          break;
2061
2062       case GL_UNSIGNED_SHORT_4_4_4_4:
2063          switch (internalFormat) {
2064          case GL_RGBA:
2065          case GL_RGBA4:
2066             break;
2067          default:
2068             return GL_INVALID_OPERATION;
2069          }
2070          break;
2071
2072       case GL_UNSIGNED_SHORT_5_5_5_1:
2073          switch (internalFormat) {
2074          case GL_RGBA:
2075          case GL_RGB5_A1:
2076             break;
2077          default:
2078             return GL_INVALID_OPERATION;
2079          }
2080          break;
2081
2082       case GL_UNSIGNED_INT_2_10_10_10_REV:
2083          switch (internalFormat) {
2084          case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
2085          case GL_RGB10_A2:
2086          case GL_RGB5_A1:
2087             break;
2088          default:
2089             return GL_INVALID_OPERATION;
2090          }
2091          break;
2092
2093       case GL_HALF_FLOAT:
2094          if (internalFormat != GL_RGBA16F)
2095             return GL_INVALID_OPERATION;
2096          break;
2097
2098       case GL_FLOAT:
2099          switch (internalFormat) {
2100          case GL_RGBA16F:
2101          case GL_RGBA32F:
2102             break;
2103          case GL_RGBA:
2104             if (ctx->Extensions.OES_texture_float && internalFormat == format)
2105                break;
2106          default:
2107             return GL_INVALID_OPERATION;
2108          }
2109          break;
2110
2111       case GL_HALF_FLOAT_OES:
2112          if (ctx->Extensions.OES_texture_half_float && internalFormat == format)
2113             break;
2114       default:
2115          return GL_INVALID_OPERATION;
2116       }
2117       break;
2118
2119    case GL_RGBA_INTEGER:
2120       switch (type) {
2121       case GL_UNSIGNED_BYTE:
2122          if (internalFormat != GL_RGBA8UI)
2123             return GL_INVALID_OPERATION;
2124          break;
2125
2126       case GL_BYTE:
2127          if (internalFormat != GL_RGBA8I)
2128             return GL_INVALID_OPERATION;
2129          break;
2130
2131       case GL_UNSIGNED_SHORT:
2132          if (internalFormat != GL_RGBA16UI)
2133             return GL_INVALID_OPERATION;
2134          break;
2135
2136       case GL_SHORT:
2137          if (internalFormat != GL_RGBA16I)
2138             return GL_INVALID_OPERATION;
2139          break;
2140
2141       case GL_UNSIGNED_INT:
2142          if (internalFormat != GL_RGBA32UI)
2143             return GL_INVALID_OPERATION;
2144          break;
2145
2146       case GL_INT:
2147          if (internalFormat != GL_RGBA32I)
2148             return GL_INVALID_OPERATION;
2149          break;
2150
2151       case GL_UNSIGNED_INT_2_10_10_10_REV:
2152          if (internalFormat != GL_RGB10_A2UI)
2153             return GL_INVALID_OPERATION;
2154          break;
2155
2156       default:
2157          return GL_INVALID_OPERATION;
2158       }
2159       break;
2160
2161    case GL_RGB:
2162       switch (type) {
2163       case GL_UNSIGNED_BYTE:
2164          switch (internalFormat) {
2165          case GL_RGB:
2166          case GL_RGB8:
2167          case GL_RGB565:
2168          case GL_SRGB8:
2169             break;
2170          default:
2171             return GL_INVALID_OPERATION;
2172          }
2173          break;
2174
2175       case GL_BYTE:
2176          if (internalFormat != GL_RGB8_SNORM)
2177             return GL_INVALID_OPERATION;
2178          break;
2179
2180       case GL_UNSIGNED_SHORT_5_6_5:
2181          switch (internalFormat) {
2182          case GL_RGB:
2183          case GL_RGB565:
2184             break;
2185          default:
2186             return GL_INVALID_OPERATION;
2187          }
2188          break;
2189
2190       case GL_UNSIGNED_INT_10F_11F_11F_REV:
2191          if (internalFormat != GL_R11F_G11F_B10F)
2192             return GL_INVALID_OPERATION;
2193          break;
2194
2195       case GL_UNSIGNED_INT_5_9_9_9_REV:
2196          if (internalFormat != GL_RGB9_E5)
2197             return GL_INVALID_OPERATION;
2198          break;
2199
2200       case GL_HALF_FLOAT:
2201          switch (internalFormat) {
2202          case GL_RGB16F:
2203          case GL_R11F_G11F_B10F:
2204          case GL_RGB9_E5:
2205             break;
2206          default:
2207             return GL_INVALID_OPERATION;
2208          }
2209          break;
2210
2211       case GL_FLOAT:
2212          switch (internalFormat) {
2213          case GL_RGB16F:
2214          case GL_RGB32F:
2215          case GL_R11F_G11F_B10F:
2216          case GL_RGB9_E5:
2217             break;
2218          case GL_RGB:
2219             if (ctx->Extensions.OES_texture_float && internalFormat == format)
2220                break;
2221          default:
2222             return GL_INVALID_OPERATION;
2223          }
2224          break;
2225
2226       case GL_HALF_FLOAT_OES:
2227          if (!ctx->Extensions.OES_texture_half_float || internalFormat != format)
2228             return GL_INVALID_OPERATION;
2229          break;
2230
2231       case GL_UNSIGNED_INT_2_10_10_10_REV:
2232          switch (internalFormat) {
2233          case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
2234             break;
2235          default:
2236             return GL_INVALID_OPERATION;
2237          }
2238          break;
2239
2240       default:
2241          return GL_INVALID_OPERATION;
2242       }
2243       break;
2244
2245    case GL_RGB_INTEGER:
2246       switch (type) {
2247       case GL_UNSIGNED_BYTE:
2248          if (internalFormat != GL_RGB8UI)
2249             return GL_INVALID_OPERATION;
2250          break;
2251
2252       case GL_BYTE:
2253          if (internalFormat != GL_RGB8I)
2254             return GL_INVALID_OPERATION;
2255          break;
2256
2257       case GL_UNSIGNED_SHORT:
2258          if (internalFormat != GL_RGB16UI)
2259             return GL_INVALID_OPERATION;
2260          break;
2261
2262       case GL_SHORT:
2263          if (internalFormat != GL_RGB16I)
2264             return GL_INVALID_OPERATION;
2265          break;
2266
2267       case GL_UNSIGNED_INT:
2268          if (internalFormat != GL_RGB32UI)
2269             return GL_INVALID_OPERATION;
2270          break;
2271
2272       case GL_INT:
2273          if (internalFormat != GL_RGB32I)
2274             return GL_INVALID_OPERATION;
2275          break;
2276
2277       default:
2278          return GL_INVALID_OPERATION;
2279       }
2280       break;
2281
2282    case GL_RG:
2283       switch (type) {
2284       case GL_UNSIGNED_BYTE:
2285          if (internalFormat != GL_RG8)
2286             return GL_INVALID_OPERATION;
2287          break;
2288
2289       case GL_BYTE:
2290          if (internalFormat != GL_RG8_SNORM)
2291             return GL_INVALID_OPERATION;
2292          break;
2293
2294       case GL_HALF_FLOAT:
2295          if (internalFormat != GL_RG16F)
2296             return GL_INVALID_OPERATION;
2297          break;
2298
2299       case GL_FLOAT:
2300          switch (internalFormat) {
2301          case GL_RG16F:
2302          case GL_RG32F:
2303             break;
2304          default:
2305             return GL_INVALID_OPERATION;
2306          }
2307          break;
2308
2309       default:
2310          return GL_INVALID_OPERATION;
2311       }
2312       break;
2313
2314    case GL_RG_INTEGER:
2315       switch (type) {
2316       case GL_UNSIGNED_BYTE:
2317          if (internalFormat != GL_RG8UI)
2318             return GL_INVALID_OPERATION;
2319          break;
2320
2321       case GL_BYTE:
2322          if (internalFormat != GL_RG8I)
2323             return GL_INVALID_OPERATION;
2324          break;
2325
2326       case GL_UNSIGNED_SHORT:
2327          if (internalFormat != GL_RG16UI)
2328             return GL_INVALID_OPERATION;
2329          break;
2330
2331       case GL_SHORT:
2332          if (internalFormat != GL_RG16I)
2333             return GL_INVALID_OPERATION;
2334          break;
2335
2336       case GL_UNSIGNED_INT:
2337          if (internalFormat != GL_RG32UI)
2338             return GL_INVALID_OPERATION;
2339          break;
2340
2341       case GL_INT:
2342          if (internalFormat != GL_RG32I)
2343             return GL_INVALID_OPERATION;
2344          break;
2345
2346       default:
2347          return GL_INVALID_OPERATION;
2348       }
2349       break;
2350
2351    case GL_RED:
2352       switch (type) {
2353       case GL_UNSIGNED_BYTE:
2354          if (internalFormat != GL_R8)
2355             return GL_INVALID_OPERATION;
2356          break;
2357
2358       case GL_BYTE:
2359          if (internalFormat != GL_R8_SNORM)
2360             return GL_INVALID_OPERATION;
2361          break;
2362
2363       case GL_HALF_FLOAT:
2364          if (internalFormat != GL_R16F)
2365             return GL_INVALID_OPERATION;
2366          break;
2367
2368       case GL_FLOAT:
2369          switch (internalFormat) {
2370          case GL_R16F:
2371          case GL_R32F:
2372             break;
2373          default:
2374             return GL_INVALID_OPERATION;
2375          }
2376          break;
2377
2378       default:
2379          return GL_INVALID_OPERATION;
2380       }
2381       break;
2382
2383    case GL_RED_INTEGER:
2384       switch (type) {
2385       case GL_UNSIGNED_BYTE:
2386          if (internalFormat != GL_R8UI)
2387             return GL_INVALID_OPERATION;
2388          break;
2389
2390       case GL_BYTE:
2391          if (internalFormat != GL_R8I)
2392             return GL_INVALID_OPERATION;
2393          break;
2394
2395       case GL_UNSIGNED_SHORT:
2396          if (internalFormat != GL_R16UI)
2397             return GL_INVALID_OPERATION;
2398          break;
2399
2400       case GL_SHORT:
2401          if (internalFormat != GL_R16I)
2402             return GL_INVALID_OPERATION;
2403          break;
2404
2405       case GL_UNSIGNED_INT:
2406          if (internalFormat != GL_R32UI)
2407             return GL_INVALID_OPERATION;
2408          break;
2409
2410       case GL_INT:
2411          if (internalFormat != GL_R32I)
2412             return GL_INVALID_OPERATION;
2413          break;
2414
2415       default:
2416          return GL_INVALID_OPERATION;
2417       }
2418       break;
2419
2420    case GL_DEPTH_COMPONENT:
2421       switch (type) {
2422       case GL_UNSIGNED_SHORT:
2423          if (internalFormat != GL_DEPTH_COMPONENT
2424              && internalFormat != GL_DEPTH_COMPONENT16)
2425             return GL_INVALID_OPERATION;
2426          break;
2427
2428       case GL_UNSIGNED_INT:
2429          switch (internalFormat) {
2430          case GL_DEPTH_COMPONENT:
2431          case GL_DEPTH_COMPONENT16:
2432          case GL_DEPTH_COMPONENT24:
2433             break;
2434          default:
2435             return GL_INVALID_OPERATION;
2436          }
2437          break;
2438
2439       case GL_FLOAT:
2440          if (internalFormat != GL_DEPTH_COMPONENT32F)
2441             return GL_INVALID_OPERATION;
2442          break;
2443
2444       default:
2445          return GL_INVALID_OPERATION;
2446       }
2447       break;
2448
2449    case GL_DEPTH_STENCIL:
2450       switch (type) {
2451       case GL_UNSIGNED_INT_24_8:
2452          if (internalFormat != GL_DEPTH_STENCIL
2453              && internalFormat != GL_DEPTH24_STENCIL8)
2454             return GL_INVALID_OPERATION;
2455          break;
2456
2457       case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2458          if (internalFormat != GL_DEPTH32F_STENCIL8)
2459             return GL_INVALID_OPERATION;
2460          break;
2461
2462       default:
2463          return GL_INVALID_OPERATION;
2464       }
2465       break;
2466
2467    case GL_ALPHA:
2468    case GL_LUMINANCE:
2469    case GL_LUMINANCE_ALPHA:
2470       switch (type) {
2471       case GL_FLOAT:
2472          if (ctx->Extensions.OES_texture_float && internalFormat == format)
2473             break;
2474       case GL_HALF_FLOAT_OES:
2475          if (ctx->Extensions.OES_texture_half_float && internalFormat == format)
2476             break;
2477       default:
2478          if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2479             return GL_INVALID_OPERATION;
2480       }
2481    }
2482
2483    return GL_NO_ERROR;
2484 }
2485
2486 static void
2487 set_swizzle(uint8_t *swizzle, int x, int y, int z, int w)
2488 {
2489    swizzle[MESA_FORMAT_SWIZZLE_X] = x;
2490    swizzle[MESA_FORMAT_SWIZZLE_Y] = y;
2491    swizzle[MESA_FORMAT_SWIZZLE_Z] = z;
2492    swizzle[MESA_FORMAT_SWIZZLE_W] = w;
2493 }
2494
2495 static bool
2496 get_swizzle_from_gl_format(GLenum format, uint8_t *swizzle)
2497 {
2498    switch (format) {
2499    case GL_RGBA:
2500    case GL_RGBA_INTEGER_EXT:
2501       set_swizzle(swizzle, 0, 1, 2, 3);
2502       return true;
2503    case GL_BGRA:
2504    case GL_BGRA_INTEGER_EXT:
2505       set_swizzle(swizzle, 2, 1, 0, 3);
2506       return true;
2507    case GL_ABGR_EXT:
2508       set_swizzle(swizzle, 3, 2, 1, 0);
2509       return true;
2510    case GL_RGB:
2511    case GL_RGB_INTEGER_EXT:
2512       set_swizzle(swizzle, 0, 1, 2, 5);
2513       return true;
2514    case GL_BGR:
2515    case GL_BGR_INTEGER_EXT:
2516       set_swizzle(swizzle, 2, 1, 0, 5);
2517       return true;
2518    case GL_LUMINANCE_ALPHA:
2519    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2520       set_swizzle(swizzle, 0, 0, 0, 1);
2521       return true;
2522    case GL_RG:
2523    case GL_RG_INTEGER:
2524       set_swizzle(swizzle, 0, 1, 4, 5);
2525       return true;
2526    case GL_RED:
2527    case GL_RED_INTEGER_EXT:
2528       set_swizzle(swizzle, 0, 4, 4, 5);
2529       return true;
2530    case GL_GREEN:
2531    case GL_GREEN_INTEGER_EXT:
2532       set_swizzle(swizzle, 4, 0, 4, 5);
2533       return true;
2534    case GL_BLUE:
2535    case GL_BLUE_INTEGER_EXT:
2536       set_swizzle(swizzle, 4, 4, 0, 5);
2537       return true;
2538    case GL_ALPHA:
2539    case GL_ALPHA_INTEGER_EXT:
2540       set_swizzle(swizzle, 4, 4, 4, 0);
2541       return true;
2542    case GL_LUMINANCE:
2543    case GL_LUMINANCE_INTEGER_EXT:
2544       set_swizzle(swizzle, 0, 0, 0, 5);
2545       return true;
2546    case GL_INTENSITY:
2547       set_swizzle(swizzle, 0, 0, 0, 0);
2548       return true;
2549    default:
2550       return false;
2551    }
2552 }
2553
2554 /**
2555 * Take an OpenGL format (GL_RGB, GL_RGBA, etc), OpenGL data type (GL_INT,
2556 * GL_FOAT, etc) and return a matching mesa_array_format or a mesa_format
2557 * otherwise (for non-array formats).
2558 *
2559 * This function will typically be used to compute a mesa format from a GL type
2560 * so we can then call _mesa_format_convert. This function does
2561 * not consider byte swapping, so it returns types assuming that no byte
2562 * swapping is involved. If byte swapping is involved then clients are supposed
2563 * to handle that on their side before calling _mesa_format_convert.
2564 *
2565 * This function returns an uint32_t that can pack a mesa_format or a
2566 * mesa_array_format. Clients must check the mesa array format bit
2567 * (MESA_ARRAY_FORMAT_BIT) on the return value to know if the returned
2568 * format is a mesa_array_format or a mesa_format.
2569 */
2570 uint32_t
2571 _mesa_format_from_format_and_type(GLenum format, GLenum type)
2572 {
2573    mesa_array_format array_format;
2574
2575    bool is_array_format = true;
2576    uint8_t swizzle[4];
2577    bool normalized = false, is_float = false, is_signed = false;
2578    int num_channels = 0, type_size = 0;
2579
2580    /* Extract array format type information from the OpenGL data type */
2581    switch (type) {
2582    case GL_UNSIGNED_BYTE:
2583       type_size = 1;
2584       break;
2585    case GL_BYTE:
2586       type_size = 1;
2587       is_signed = true;
2588       break;
2589    case GL_UNSIGNED_SHORT:
2590       type_size = 2;
2591       break;
2592    case GL_SHORT:
2593       type_size = 2;
2594       is_signed = true;
2595       break;
2596    case GL_UNSIGNED_INT:
2597       type_size = 4;
2598       break;
2599    case GL_INT:
2600       type_size = 4;
2601       is_signed = true;
2602       break;
2603    case GL_HALF_FLOAT:
2604    case GL_HALF_FLOAT_OES:
2605       type_size = 2;
2606       is_signed = true;
2607       is_float = true;
2608       break;
2609    case GL_FLOAT:
2610       type_size = 4;
2611       is_signed = true;
2612       is_float = true;
2613       break;
2614    default:
2615       is_array_format = false;
2616       break;
2617    }
2618
2619    /* Extract array format swizzle information from the OpenGL format */
2620    if (is_array_format)
2621       is_array_format = get_swizzle_from_gl_format(format, swizzle);
2622
2623    /* If this is an array format type after checking data type and format,
2624     * create the array format
2625     */
2626    if (is_array_format) {
2627       normalized = !_mesa_is_enum_format_integer(format);
2628       num_channels = _mesa_components_in_format(format);
2629
2630       array_format =
2631          MESA_ARRAY_FORMAT(type_size, is_signed, is_float,
2632                            normalized, num_channels,
2633                            swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
2634
2635       if (!_mesa_little_endian())
2636          array_format = _mesa_array_format_flip_channels(array_format);
2637
2638       return array_format;
2639    }
2640
2641    /* Otherwise this is not an array format, so return the mesa_format
2642     * matching the OpenGL format and data type
2643     */
2644    switch (type) {
2645    case GL_UNSIGNED_SHORT_5_6_5:
2646      if (format == GL_RGB)
2647          return MESA_FORMAT_B5G6R5_UNORM;
2648       else if (format == GL_BGR)
2649          return MESA_FORMAT_R5G6B5_UNORM;
2650       break;
2651    case GL_UNSIGNED_SHORT_5_6_5_REV:
2652       if (format == GL_RGB)
2653          return MESA_FORMAT_R5G6B5_UNORM;
2654       else if (format == GL_BGR)
2655          return MESA_FORMAT_B5G6R5_UNORM;
2656       break;
2657    case GL_UNSIGNED_SHORT_4_4_4_4:
2658       if (format == GL_RGBA)
2659          return MESA_FORMAT_A4B4G4R4_UNORM;
2660       else if (format == GL_BGRA)
2661          return MESA_FORMAT_A4R4G4B4_UNORM;
2662       else if (format == GL_ABGR_EXT)
2663          return MESA_FORMAT_R4G4B4A4_UNORM;
2664       break;
2665    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2666       if (format == GL_RGBA)
2667          return MESA_FORMAT_R4G4B4A4_UNORM;
2668       else if (format == GL_BGRA)
2669          return MESA_FORMAT_B4G4R4A4_UNORM;
2670       else if (format == GL_ABGR_EXT)
2671          return MESA_FORMAT_A4B4G4R4_UNORM;
2672       break;
2673    case GL_UNSIGNED_SHORT_5_5_5_1:
2674       if (format == GL_RGBA)
2675          return MESA_FORMAT_A1B5G5R5_UNORM;
2676       else if (format == GL_BGRA)
2677          return MESA_FORMAT_A1R5G5B5_UNORM;
2678       break;
2679    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2680       if (format == GL_RGBA)
2681          return MESA_FORMAT_R5G5B5A1_UNORM;
2682       else if (format == GL_BGRA)
2683          return MESA_FORMAT_B5G5R5A1_UNORM;
2684       break;
2685    case GL_UNSIGNED_BYTE_3_3_2:
2686       if (format == GL_RGB)
2687          return MESA_FORMAT_B2G3R3_UNORM;
2688       break;
2689    case GL_UNSIGNED_BYTE_2_3_3_REV:
2690       if (format == GL_RGB)
2691          return MESA_FORMAT_R3G3B2_UNORM;
2692       break;
2693    case GL_UNSIGNED_INT_5_9_9_9_REV:
2694       if (format == GL_RGB)
2695          return MESA_FORMAT_R9G9B9E5_FLOAT;
2696       break;
2697    case GL_UNSIGNED_INT_10_10_10_2:
2698       if (format == GL_RGBA)
2699          return MESA_FORMAT_A2B10G10R10_UNORM;
2700       else if (format == GL_RGBA_INTEGER)
2701          return MESA_FORMAT_A2B10G10R10_UINT;
2702       else if (format == GL_BGRA)
2703          return MESA_FORMAT_A2R10G10B10_UNORM;
2704       else if (format == GL_BGRA_INTEGER)
2705          return MESA_FORMAT_A2R10G10B10_UINT;
2706       break;
2707    case GL_UNSIGNED_INT_2_10_10_10_REV:
2708       if (format == GL_RGB)
2709          return MESA_FORMAT_R10G10B10X2_UNORM;
2710       if (format == GL_RGBA)
2711          return MESA_FORMAT_R10G10B10A2_UNORM;
2712       else if (format == GL_RGBA_INTEGER)
2713          return MESA_FORMAT_R10G10B10A2_UINT;
2714       else if (format == GL_BGRA)
2715          return MESA_FORMAT_B10G10R10A2_UNORM;
2716       else if (format == GL_BGRA_INTEGER)
2717          return MESA_FORMAT_B10G10R10A2_UINT;
2718       break;
2719    case GL_UNSIGNED_INT_8_8_8_8:
2720       if (format == GL_RGBA)
2721          return MESA_FORMAT_A8B8G8R8_UNORM;
2722       else if (format == GL_BGRA)
2723          return MESA_FORMAT_A8R8G8B8_UNORM;
2724       else if (format == GL_ABGR_EXT)
2725          return MESA_FORMAT_R8G8B8A8_UNORM;
2726       break;
2727    case GL_UNSIGNED_INT_8_8_8_8_REV:
2728       if (format == GL_RGBA)
2729          return MESA_FORMAT_R8G8B8A8_UNORM;
2730       else if (format == GL_BGRA)
2731          return MESA_FORMAT_B8G8R8A8_UNORM;
2732       else if (format == GL_ABGR_EXT)
2733          return MESA_FORMAT_A8B8G8R8_UNORM;
2734       break;
2735    case GL_UNSIGNED_SHORT_8_8_MESA:
2736       if (format == GL_YCBCR_MESA)
2737          return MESA_FORMAT_YCBCR;
2738       break;
2739    case GL_UNSIGNED_SHORT_8_8_REV_MESA:
2740       if (format == GL_YCBCR_MESA)
2741          return MESA_FORMAT_YCBCR_REV;
2742       break;
2743    case GL_UNSIGNED_INT_10F_11F_11F_REV:
2744       if (format == GL_RGB)
2745          return MESA_FORMAT_R11G11B10_FLOAT;
2746    default:
2747       break;
2748    }
2749
2750    /* If we got here it means that we could not find a Mesa format that
2751     * matches the GL format/type provided. We may need to add a new Mesa
2752     * format in that case.
2753     */
2754    unreachable("Unsupported format");
2755 }