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