glformats.c revision 36347c8d6f265fb9b8ebcd598b189d3b43d6b513
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 "texcompress.h" 32#include "enums.h" 33 34enum { 35 ZERO = 4, 36 ONE = 5 37}; 38 39enum { 40 IDX_LUMINANCE = 0, 41 IDX_ALPHA, 42 IDX_INTENSITY, 43 IDX_LUMINANCE_ALPHA, 44 IDX_RGB, 45 IDX_RGBA, 46 IDX_RED, 47 IDX_GREEN, 48 IDX_BLUE, 49 IDX_BGR, 50 IDX_BGRA, 51 IDX_ABGR, 52 IDX_RG, 53 MAX_IDX 54}; 55 56#define MAP1(x) MAP4(x, ZERO, ZERO, ZERO) 57#define MAP2(x,y) MAP4(x, y, ZERO, ZERO) 58#define MAP3(x,y,z) MAP4(x, y, z, ZERO) 59#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE } 60 61static const struct { 62 GLubyte format_idx; 63 GLubyte to_rgba[6]; 64 GLubyte from_rgba[6]; 65} mappings[MAX_IDX] = 66{ 67 { 68 IDX_LUMINANCE, 69 MAP4(0,0,0,ONE), 70 MAP1(0) 71 }, 72 73 { 74 IDX_ALPHA, 75 MAP4(ZERO, ZERO, ZERO, 0), 76 MAP1(3) 77 }, 78 79 { 80 IDX_INTENSITY, 81 MAP4(0, 0, 0, 0), 82 MAP1(0), 83 }, 84 85 { 86 IDX_LUMINANCE_ALPHA, 87 MAP4(0,0,0,1), 88 MAP2(0,3) 89 }, 90 91 { 92 IDX_RGB, 93 MAP4(0,1,2,ONE), 94 MAP3(0,1,2) 95 }, 96 97 { 98 IDX_RGBA, 99 MAP4(0,1,2,3), 100 MAP4(0,1,2,3), 101 }, 102 103 { 104 IDX_RED, 105 MAP4(0, ZERO, ZERO, ONE), 106 MAP1(0), 107 }, 108 109 { 110 IDX_GREEN, 111 MAP4(ZERO, 0, ZERO, ONE), 112 MAP1(1), 113 }, 114 115 { 116 IDX_BLUE, 117 MAP4(ZERO, ZERO, 0, ONE), 118 MAP1(2), 119 }, 120 121 { 122 IDX_BGR, 123 MAP4(2,1,0,ONE), 124 MAP3(2,1,0) 125 }, 126 127 { 128 IDX_BGRA, 129 MAP4(2,1,0,3), 130 MAP4(2,1,0,3) 131 }, 132 133 { 134 IDX_ABGR, 135 MAP4(3,2,1,0), 136 MAP4(3,2,1,0) 137 }, 138 139 { 140 IDX_RG, 141 MAP4(0, 1, ZERO, ONE), 142 MAP2(0, 1) 143 }, 144}; 145 146/** 147 * Convert a GL image format enum to an IDX_* value (see above). 148 */ 149static int 150get_map_idx(GLenum value) 151{ 152 switch (value) { 153 case GL_LUMINANCE: 154 case GL_LUMINANCE_INTEGER_EXT: 155 return IDX_LUMINANCE; 156 case GL_ALPHA: 157 case GL_ALPHA_INTEGER: 158 return IDX_ALPHA; 159 case GL_INTENSITY: 160 return IDX_INTENSITY; 161 case GL_LUMINANCE_ALPHA: 162 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 163 return IDX_LUMINANCE_ALPHA; 164 case GL_RGB: 165 case GL_RGB_INTEGER: 166 return IDX_RGB; 167 case GL_RGBA: 168 case GL_RGBA_INTEGER: 169 return IDX_RGBA; 170 case GL_RED: 171 case GL_RED_INTEGER: 172 return IDX_RED; 173 case GL_GREEN: 174 return IDX_GREEN; 175 case GL_BLUE: 176 return IDX_BLUE; 177 case GL_BGR: 178 case GL_BGR_INTEGER: 179 return IDX_BGR; 180 case GL_BGRA: 181 case GL_BGRA_INTEGER: 182 return IDX_BGRA; 183 case GL_ABGR_EXT: 184 return IDX_ABGR; 185 case GL_RG: 186 case GL_RG_INTEGER: 187 return IDX_RG; 188 default: 189 _mesa_problem(NULL, "Unexpected inFormat %s", 190 _mesa_enum_to_string(value)); 191 return 0; 192 } 193} 194 195/** 196 * When promoting texture formats (see below) we need to compute the 197 * mapping of dest components back to source components. 198 * This function does that. 199 * \param inFormat the incoming format of the texture 200 * \param outFormat the final texture format 201 * \return map[6] a full 6-component map 202 */ 203void 204_mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map) 205{ 206 const int inFmt = get_map_idx(inFormat); 207 const int outFmt = get_map_idx(outFormat); 208 const GLubyte *in2rgba = mappings[inFmt].to_rgba; 209 const GLubyte *rgba2out = mappings[outFmt].from_rgba; 210 int i; 211 212 for (i = 0; i < 4; i++) 213 map[i] = in2rgba[rgba2out[i]]; 214 215 map[ZERO] = ZERO; 216 map[ONE] = ONE; 217 218#if 0 219 printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n", 220 inFormat, _mesa_enum_to_string(inFormat), 221 outFormat, _mesa_enum_to_string(outFormat), 222 map[0], 223 map[1], 224 map[2], 225 map[3], 226 map[4], 227 map[5]); 228#endif 229} 230 231/** 232 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. 233 */ 234GLboolean 235_mesa_type_is_packed(GLenum type) 236{ 237 switch (type) { 238 case GL_UNSIGNED_BYTE_3_3_2: 239 case GL_UNSIGNED_BYTE_2_3_3_REV: 240 case MESA_UNSIGNED_BYTE_4_4: 241 case GL_UNSIGNED_SHORT_5_6_5: 242 case GL_UNSIGNED_SHORT_5_6_5_REV: 243 case GL_UNSIGNED_SHORT_4_4_4_4: 244 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 245 case GL_UNSIGNED_SHORT_5_5_5_1: 246 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 247 case GL_UNSIGNED_INT_8_8_8_8: 248 case GL_UNSIGNED_INT_8_8_8_8_REV: 249 case GL_UNSIGNED_INT_10_10_10_2: 250 case GL_UNSIGNED_INT_2_10_10_10_REV: 251 case GL_UNSIGNED_SHORT_8_8_MESA: 252 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 253 case GL_UNSIGNED_INT_24_8_EXT: 254 case GL_UNSIGNED_INT_5_9_9_9_REV: 255 case GL_UNSIGNED_INT_10F_11F_11F_REV: 256 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 257 return GL_TRUE; 258 } 259 260 return GL_FALSE; 261} 262 263 264/** 265 * Get the size of a GL data type. 266 * 267 * \param type GL data type. 268 * 269 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 270 * if an invalid type enum. 271 */ 272GLint 273_mesa_sizeof_type(GLenum type) 274{ 275 switch (type) { 276 case GL_BITMAP: 277 return 0; 278 case GL_UNSIGNED_BYTE: 279 return sizeof(GLubyte); 280 case GL_BYTE: 281 return sizeof(GLbyte); 282 case GL_UNSIGNED_SHORT: 283 return sizeof(GLushort); 284 case GL_SHORT: 285 return sizeof(GLshort); 286 case GL_UNSIGNED_INT: 287 return sizeof(GLuint); 288 case GL_INT: 289 return sizeof(GLint); 290 case GL_FLOAT: 291 return sizeof(GLfloat); 292 case GL_DOUBLE: 293 return sizeof(GLdouble); 294 case GL_HALF_FLOAT_ARB: 295 case GL_HALF_FLOAT_OES: 296 return sizeof(GLhalfARB); 297 case GL_FIXED: 298 return sizeof(GLfixed); 299 default: 300 return -1; 301 } 302} 303 304 305/** 306 * Same as _mesa_sizeof_type() but also accepting the packed pixel 307 * format data types. 308 */ 309GLint 310_mesa_sizeof_packed_type(GLenum type) 311{ 312 switch (type) { 313 case GL_BITMAP: 314 return 0; 315 case GL_UNSIGNED_BYTE: 316 return sizeof(GLubyte); 317 case GL_BYTE: 318 return sizeof(GLbyte); 319 case GL_UNSIGNED_SHORT: 320 return sizeof(GLushort); 321 case GL_SHORT: 322 return sizeof(GLshort); 323 case GL_UNSIGNED_INT: 324 return sizeof(GLuint); 325 case GL_INT: 326 return sizeof(GLint); 327 case GL_HALF_FLOAT_ARB: 328 case GL_HALF_FLOAT_OES: 329 return sizeof(GLhalfARB); 330 case GL_FLOAT: 331 return sizeof(GLfloat); 332 case GL_UNSIGNED_BYTE_3_3_2: 333 case GL_UNSIGNED_BYTE_2_3_3_REV: 334 case MESA_UNSIGNED_BYTE_4_4: 335 return sizeof(GLubyte); 336 case GL_UNSIGNED_SHORT_5_6_5: 337 case GL_UNSIGNED_SHORT_5_6_5_REV: 338 case GL_UNSIGNED_SHORT_4_4_4_4: 339 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 340 case GL_UNSIGNED_SHORT_5_5_5_1: 341 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 342 case GL_UNSIGNED_SHORT_8_8_MESA: 343 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 344 return sizeof(GLushort); 345 case GL_UNSIGNED_INT_8_8_8_8: 346 case GL_UNSIGNED_INT_8_8_8_8_REV: 347 case GL_UNSIGNED_INT_10_10_10_2: 348 case GL_UNSIGNED_INT_2_10_10_10_REV: 349 case GL_UNSIGNED_INT_24_8_EXT: 350 case GL_UNSIGNED_INT_5_9_9_9_REV: 351 case GL_UNSIGNED_INT_10F_11F_11F_REV: 352 return sizeof(GLuint); 353 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 354 return 8; 355 default: 356 return -1; 357 } 358} 359 360 361/** 362 * Get the number of components in a pixel format. 363 * 364 * \param format pixel format. 365 * 366 * \return the number of components in the given format, or -1 if a bad format. 367 */ 368GLint 369_mesa_components_in_format(GLenum format) 370{ 371 switch (format) { 372 case GL_COLOR_INDEX: 373 case GL_STENCIL_INDEX: 374 case GL_DEPTH_COMPONENT: 375 case GL_RED: 376 case GL_RED_INTEGER_EXT: 377 case GL_GREEN: 378 case GL_GREEN_INTEGER_EXT: 379 case GL_BLUE: 380 case GL_BLUE_INTEGER_EXT: 381 case GL_ALPHA: 382 case GL_ALPHA_INTEGER_EXT: 383 case GL_LUMINANCE: 384 case GL_LUMINANCE_INTEGER_EXT: 385 case GL_INTENSITY: 386 return 1; 387 388 case GL_LUMINANCE_ALPHA: 389 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 390 case GL_RG: 391 case GL_YCBCR_MESA: 392 case GL_DEPTH_STENCIL_EXT: 393 case GL_RG_INTEGER: 394 return 2; 395 396 case GL_RGB: 397 case GL_BGR: 398 case GL_RGB_INTEGER_EXT: 399 case GL_BGR_INTEGER_EXT: 400 return 3; 401 402 case GL_RGBA: 403 case GL_BGRA: 404 case GL_ABGR_EXT: 405 case GL_RGBA_INTEGER_EXT: 406 case GL_BGRA_INTEGER_EXT: 407 return 4; 408 409 default: 410 return -1; 411 } 412} 413 414 415/** 416 * Get the bytes per pixel of pixel format type pair. 417 * 418 * \param format pixel format. 419 * \param type pixel type. 420 * 421 * \return bytes per pixel, or -1 if a bad format or type was given. 422 */ 423GLint 424_mesa_bytes_per_pixel(GLenum format, GLenum type) 425{ 426 GLint comps = _mesa_components_in_format(format); 427 if (comps < 0) 428 return -1; 429 430 switch (type) { 431 case GL_BITMAP: 432 return 0; /* special case */ 433 case GL_BYTE: 434 case GL_UNSIGNED_BYTE: 435 return comps * sizeof(GLubyte); 436 case GL_SHORT: 437 case GL_UNSIGNED_SHORT: 438 return comps * sizeof(GLshort); 439 case GL_INT: 440 case GL_UNSIGNED_INT: 441 return comps * sizeof(GLint); 442 case GL_FLOAT: 443 return comps * sizeof(GLfloat); 444 case GL_HALF_FLOAT_ARB: 445 case GL_HALF_FLOAT_OES: 446 return comps * sizeof(GLhalfARB); 447 case GL_UNSIGNED_BYTE_3_3_2: 448 case GL_UNSIGNED_BYTE_2_3_3_REV: 449 if (format == GL_RGB || format == GL_BGR || 450 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) 451 return sizeof(GLubyte); 452 else 453 return -1; /* error */ 454 case GL_UNSIGNED_SHORT_5_6_5: 455 case GL_UNSIGNED_SHORT_5_6_5_REV: 456 if (format == GL_RGB || format == GL_BGR || 457 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) 458 return sizeof(GLushort); 459 else 460 return -1; /* error */ 461 case GL_UNSIGNED_SHORT_4_4_4_4: 462 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 463 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || 464 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) 465 return sizeof(GLushort); 466 else 467 return -1; 468 case GL_UNSIGNED_SHORT_5_5_5_1: 469 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 470 if (format == GL_RGBA || format == GL_BGRA || 471 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) 472 return sizeof(GLushort); 473 else 474 return -1; 475 case GL_UNSIGNED_INT_8_8_8_8: 476 case GL_UNSIGNED_INT_8_8_8_8_REV: 477 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || 478 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT || 479 format == GL_RGB) 480 return sizeof(GLuint); 481 else 482 return -1; 483 case GL_UNSIGNED_INT_10_10_10_2: 484 case GL_UNSIGNED_INT_2_10_10_10_REV: 485 if (format == GL_RGBA || format == GL_BGRA || 486 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT || 487 format == GL_RGB) 488 return sizeof(GLuint); 489 else 490 return -1; 491 case GL_UNSIGNED_SHORT_8_8_MESA: 492 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 493 if (format == GL_YCBCR_MESA) 494 return sizeof(GLushort); 495 else 496 return -1; 497 case GL_UNSIGNED_INT_24_8_EXT: 498 if (format == GL_DEPTH_COMPONENT || 499 format == GL_DEPTH_STENCIL_EXT) 500 return sizeof(GLuint); 501 else 502 return -1; 503 case GL_UNSIGNED_INT_5_9_9_9_REV: 504 if (format == GL_RGB) 505 return sizeof(GLuint); 506 else 507 return -1; 508 case GL_UNSIGNED_INT_10F_11F_11F_REV: 509 if (format == GL_RGB) 510 return sizeof(GLuint); 511 else 512 return -1; 513 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 514 if (format == GL_DEPTH_STENCIL) 515 return 8; 516 else 517 return -1; 518 default: 519 return -1; 520 } 521} 522 523 524/** 525 * Get the number of bytes for a vertex attrib with the given number of 526 * components and type. 527 * 528 * \param comps number of components. 529 * \param type data type. 530 * 531 * \return bytes per attribute, or -1 if a bad comps/type combination was given. 532 */ 533GLint 534_mesa_bytes_per_vertex_attrib(GLint comps, GLenum type) 535{ 536 switch (type) { 537 case GL_BYTE: 538 case GL_UNSIGNED_BYTE: 539 return comps * sizeof(GLubyte); 540 case GL_SHORT: 541 case GL_UNSIGNED_SHORT: 542 return comps * sizeof(GLshort); 543 case GL_INT: 544 case GL_UNSIGNED_INT: 545 return comps * sizeof(GLint); 546 case GL_FLOAT: 547 return comps * sizeof(GLfloat); 548 case GL_HALF_FLOAT_ARB: 549 return comps * sizeof(GLhalfARB); 550 case GL_DOUBLE: 551 return comps * sizeof(GLdouble); 552 case GL_FIXED: 553 return comps * sizeof(GLfixed); 554 case GL_INT_2_10_10_10_REV: 555 case GL_UNSIGNED_INT_2_10_10_10_REV: 556 if (comps == 4) 557 return sizeof(GLuint); 558 else 559 return -1; 560 case GL_UNSIGNED_INT_10F_11F_11F_REV: 561 if (comps == 3) 562 return sizeof(GLuint); 563 else 564 return -1; 565 default: 566 return -1; 567 } 568} 569 570/** 571 * Test if the given format is unsized. 572 */ 573GLboolean 574_mesa_is_enum_format_unsized(GLenum format) 575{ 576 switch (format) { 577 case GL_RGBA: 578 case GL_BGRA: 579 case GL_ABGR_EXT: 580 case GL_RGB: 581 case GL_BGR: 582 case GL_RG: 583 case GL_RED: 584 case GL_GREEN: 585 case GL_BLUE: 586 case GL_ALPHA: 587 case GL_INTENSITY: 588 case GL_LUMINANCE: 589 case GL_LUMINANCE_ALPHA: 590 591 case GL_SRGB: 592 case GL_SRGB_ALPHA: 593 case GL_SLUMINANCE: 594 case GL_SLUMINANCE_ALPHA: 595 596 case GL_RGBA_SNORM: 597 case GL_RGB_SNORM: 598 case GL_RG_SNORM: 599 case GL_RED_SNORM: 600 case GL_ALPHA_SNORM: 601 case GL_INTENSITY_SNORM: 602 case GL_LUMINANCE_SNORM: 603 case GL_LUMINANCE_ALPHA_SNORM: 604 605 case GL_RED_INTEGER: 606 case GL_GREEN_INTEGER: 607 case GL_BLUE_INTEGER: 608 case GL_ALPHA_INTEGER: 609 case GL_RGB_INTEGER: 610 case GL_RGBA_INTEGER: 611 case GL_BGR_INTEGER: 612 case GL_BGRA_INTEGER: 613 case GL_RG_INTEGER: 614 case GL_LUMINANCE_INTEGER_EXT: 615 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 616 617 case GL_DEPTH_COMPONENT: 618 case GL_DEPTH_STENCIL: 619 case GL_STENCIL_INDEX: 620 return GL_TRUE; 621 default: 622 return GL_FALSE; 623 } 624} 625 626/** 627 * Test if the given format is a UNORM (unsigned-normalized) format. 628 */ 629GLboolean 630_mesa_is_enum_format_unorm(GLenum format) 631{ 632 switch(format) { 633 case GL_RED: 634 case GL_GREEN: 635 case GL_BLUE: 636 case GL_ALPHA: 637 case GL_ALPHA4: 638 case GL_ALPHA8: 639 case GL_ALPHA12: 640 case GL_ALPHA16: 641 case 1: 642 case GL_LUMINANCE: 643 case GL_SLUMINANCE: 644 case GL_LUMINANCE4: 645 case GL_LUMINANCE8: 646 case GL_LUMINANCE12: 647 case GL_LUMINANCE16: 648 case 2: 649 case GL_LUMINANCE_ALPHA: 650 case GL_SLUMINANCE_ALPHA: 651 case GL_LUMINANCE4_ALPHA4: 652 case GL_LUMINANCE6_ALPHA2: 653 case GL_LUMINANCE8_ALPHA8: 654 case GL_LUMINANCE12_ALPHA4: 655 case GL_LUMINANCE12_ALPHA12: 656 case GL_LUMINANCE16_ALPHA16: 657 case GL_INTENSITY: 658 case GL_INTENSITY4: 659 case GL_INTENSITY8: 660 case GL_INTENSITY12: 661 case GL_INTENSITY16: 662 case GL_R8: 663 case GL_R16: 664 case GL_RG: 665 case GL_RG8: 666 case GL_RG16: 667 case 3: 668 case GL_RGB: 669 case GL_BGR: 670 case GL_SRGB: 671 case GL_R3_G3_B2: 672 case GL_RGB4: 673 case GL_RGB5: 674 case GL_RGB565: 675 case GL_RGB8: 676 case GL_RGB10: 677 case GL_RGB12: 678 case GL_RGB16: 679 case 4: 680 case GL_ABGR_EXT: 681 case GL_RGBA: 682 case GL_BGRA: 683 case GL_SRGB_ALPHA: 684 case GL_RGBA2: 685 case GL_RGBA4: 686 case GL_RGB5_A1: 687 case GL_RGBA8: 688 case GL_RGB10_A2: 689 case GL_RGBA12: 690 case GL_RGBA16: 691 return GL_TRUE; 692 default: 693 return GL_FALSE; 694 } 695} 696 697/** 698 * Test if the given format is a SNORM (signed-normalized) format. 699 */ 700GLboolean 701_mesa_is_enum_format_snorm(GLenum format) 702{ 703 switch (format) { 704 /* signed, normalized texture formats */ 705 case GL_RED_SNORM: 706 case GL_R8_SNORM: 707 case GL_R16_SNORM: 708 case GL_RG_SNORM: 709 case GL_RG8_SNORM: 710 case GL_RG16_SNORM: 711 case GL_RGB_SNORM: 712 case GL_RGB8_SNORM: 713 case GL_RGB16_SNORM: 714 case GL_RGBA_SNORM: 715 case GL_RGBA8_SNORM: 716 case GL_RGBA16_SNORM: 717 case GL_ALPHA_SNORM: 718 case GL_ALPHA8_SNORM: 719 case GL_ALPHA16_SNORM: 720 case GL_LUMINANCE_SNORM: 721 case GL_LUMINANCE8_SNORM: 722 case GL_LUMINANCE16_SNORM: 723 case GL_LUMINANCE_ALPHA_SNORM: 724 case GL_LUMINANCE8_ALPHA8_SNORM: 725 case GL_LUMINANCE16_ALPHA16_SNORM: 726 case GL_INTENSITY_SNORM: 727 case GL_INTENSITY8_SNORM: 728 case GL_INTENSITY16_SNORM: 729 return GL_TRUE; 730 default: 731 return GL_FALSE; 732 } 733} 734 735/** 736 * Test if the given format is an integer (non-normalized) format. 737 */ 738GLboolean 739_mesa_is_enum_format_unsigned_int(GLenum format) 740{ 741 switch (format) { 742 /* specific integer formats */ 743 case GL_RGBA32UI_EXT: 744 case GL_RGB32UI_EXT: 745 case GL_RG32UI: 746 case GL_R32UI: 747 case GL_ALPHA32UI_EXT: 748 case GL_INTENSITY32UI_EXT: 749 case GL_LUMINANCE32UI_EXT: 750 case GL_LUMINANCE_ALPHA32UI_EXT: 751 case GL_RGBA16UI_EXT: 752 case GL_RGB16UI_EXT: 753 case GL_RG16UI: 754 case GL_R16UI: 755 case GL_ALPHA16UI_EXT: 756 case GL_INTENSITY16UI_EXT: 757 case GL_LUMINANCE16UI_EXT: 758 case GL_LUMINANCE_ALPHA16UI_EXT: 759 case GL_RGBA8UI_EXT: 760 case GL_RGB8UI_EXT: 761 case GL_RG8UI: 762 case GL_R8UI: 763 case GL_ALPHA8UI_EXT: 764 case GL_INTENSITY8UI_EXT: 765 case GL_LUMINANCE8UI_EXT: 766 case GL_LUMINANCE_ALPHA8UI_EXT: 767 case GL_RGB10_A2UI: 768 return GL_TRUE; 769 default: 770 return GL_FALSE; 771 } 772} 773 774 775/** 776 * Test if the given format is an integer (non-normalized) format. 777 */ 778GLboolean 779_mesa_is_enum_format_signed_int(GLenum format) 780{ 781 switch (format) { 782 /* generic integer formats */ 783 case GL_RED_INTEGER_EXT: 784 case GL_GREEN_INTEGER_EXT: 785 case GL_BLUE_INTEGER_EXT: 786 case GL_ALPHA_INTEGER_EXT: 787 case GL_RGB_INTEGER_EXT: 788 case GL_RGBA_INTEGER_EXT: 789 case GL_BGR_INTEGER_EXT: 790 case GL_BGRA_INTEGER_EXT: 791 case GL_LUMINANCE_INTEGER_EXT: 792 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 793 case GL_RG_INTEGER: 794 /* specific integer formats */ 795 case GL_RGBA32I_EXT: 796 case GL_RGB32I_EXT: 797 case GL_RG32I: 798 case GL_R32I: 799 case GL_ALPHA32I_EXT: 800 case GL_INTENSITY32I_EXT: 801 case GL_LUMINANCE32I_EXT: 802 case GL_LUMINANCE_ALPHA32I_EXT: 803 case GL_RGBA16I_EXT: 804 case GL_RGB16I_EXT: 805 case GL_RG16I: 806 case GL_R16I: 807 case GL_ALPHA16I_EXT: 808 case GL_INTENSITY16I_EXT: 809 case GL_LUMINANCE16I_EXT: 810 case GL_LUMINANCE_ALPHA16I_EXT: 811 case GL_RGBA8I_EXT: 812 case GL_RGB8I_EXT: 813 case GL_RG8I: 814 case GL_R8I: 815 case GL_ALPHA8I_EXT: 816 case GL_INTENSITY8I_EXT: 817 case GL_LUMINANCE8I_EXT: 818 case GL_LUMINANCE_ALPHA8I_EXT: 819 return GL_TRUE; 820 default: 821 return GL_FALSE; 822 } 823} 824 825/** 826 * Test if the given format is an ASTC 2D format. 827 */ 828static bool 829is_astc_2d_format(GLenum internalFormat) 830{ 831 switch (internalFormat) { 832 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: 833 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: 834 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: 835 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: 836 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: 837 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: 838 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: 839 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: 840 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: 841 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: 842 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: 843 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: 844 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: 845 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: 846 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 847 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 848 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 849 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 850 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 851 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 852 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 853 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 854 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 855 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 856 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 857 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 858 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 859 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 860 return true; 861 default: 862 return false; 863 } 864} 865 866/** 867 * Test if the given format is an ASTC 3D format. 868 */ 869static bool 870is_astc_3d_format(GLenum internalFormat) 871{ 872 switch (internalFormat) { 873 case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES: 874 case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES: 875 case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES: 876 case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES: 877 case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES: 878 case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES: 879 case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES: 880 case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES: 881 case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES: 882 case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES: 883 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES: 884 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES: 885 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES: 886 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES: 887 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES: 888 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES: 889 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES: 890 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES: 891 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES: 892 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES: 893 return true; 894 default: 895 return false; 896 } 897} 898 899/** 900 * Test if the given format is an ASTC format. 901 */ 902GLboolean 903_mesa_is_astc_format(GLenum internalFormat) 904{ 905 return is_astc_2d_format(internalFormat) || 906 is_astc_3d_format(internalFormat); 907} 908 909/** 910 * Test if the given format is an ETC2 format. 911 */ 912GLboolean 913_mesa_is_etc2_format(GLenum internalFormat) 914{ 915 switch (internalFormat) { 916 case GL_COMPRESSED_RGB8_ETC2: 917 case GL_COMPRESSED_SRGB8_ETC2: 918 case GL_COMPRESSED_RGBA8_ETC2_EAC: 919 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 920 case GL_COMPRESSED_R11_EAC: 921 case GL_COMPRESSED_RG11_EAC: 922 case GL_COMPRESSED_SIGNED_R11_EAC: 923 case GL_COMPRESSED_SIGNED_RG11_EAC: 924 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 925 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 926 return true; 927 default: 928 return false; 929 } 930} 931 932/** 933 * Test if the given format is an integer (non-normalized) format. 934 */ 935GLboolean 936_mesa_is_enum_format_integer(GLenum format) 937{ 938 return _mesa_is_enum_format_unsigned_int(format) || 939 _mesa_is_enum_format_signed_int(format); 940} 941 942 943GLboolean 944_mesa_is_type_unsigned(GLenum type) 945{ 946 switch (type) { 947 case GL_UNSIGNED_INT: 948 case GL_UNSIGNED_INT_8_8_8_8: 949 case GL_UNSIGNED_INT_8_8_8_8_REV: 950 case GL_UNSIGNED_INT_10_10_10_2: 951 case GL_UNSIGNED_INT_2_10_10_10_REV: 952 953 case GL_UNSIGNED_SHORT: 954 case GL_UNSIGNED_SHORT_4_4_4_4: 955 case GL_UNSIGNED_SHORT_5_5_5_1: 956 case GL_UNSIGNED_SHORT_5_6_5: 957 case GL_UNSIGNED_SHORT_5_6_5_REV: 958 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 959 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 960 case GL_UNSIGNED_SHORT_8_8_MESA: 961 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 962 963 case GL_UNSIGNED_BYTE: 964 case GL_UNSIGNED_BYTE_3_3_2: 965 case GL_UNSIGNED_BYTE_2_3_3_REV: 966 return GL_TRUE; 967 968 default: 969 return GL_FALSE; 970 } 971} 972 973 974/** 975 * Test if the given image format is a color/RGBA format (i.e., not color 976 * index, depth, stencil, etc). 977 * \param format the image format value (may by an internal texture format) 978 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. 979 */ 980GLboolean 981_mesa_is_color_format(GLenum format) 982{ 983 switch (format) { 984 case GL_RED: 985 case GL_GREEN: 986 case GL_BLUE: 987 case GL_ALPHA: 988 case GL_ALPHA4: 989 case GL_ALPHA8: 990 case GL_ALPHA12: 991 case GL_ALPHA16: 992 case 1: 993 case GL_LUMINANCE: 994 case GL_LUMINANCE4: 995 case GL_LUMINANCE8: 996 case GL_LUMINANCE12: 997 case GL_LUMINANCE16: 998 case 2: 999 case GL_LUMINANCE_ALPHA: 1000 case GL_LUMINANCE4_ALPHA4: 1001 case GL_LUMINANCE6_ALPHA2: 1002 case GL_LUMINANCE8_ALPHA8: 1003 case GL_LUMINANCE12_ALPHA4: 1004 case GL_LUMINANCE12_ALPHA12: 1005 case GL_LUMINANCE16_ALPHA16: 1006 case GL_INTENSITY: 1007 case GL_INTENSITY4: 1008 case GL_INTENSITY8: 1009 case GL_INTENSITY12: 1010 case GL_INTENSITY16: 1011 case GL_R8: 1012 case GL_R16: 1013 case GL_RG: 1014 case GL_RG8: 1015 case GL_RG16: 1016 case 3: 1017 case GL_RGB: 1018 case GL_BGR: 1019 case GL_R3_G3_B2: 1020 case GL_RGB4: 1021 case GL_RGB5: 1022 case GL_RGB565: 1023 case GL_RGB8: 1024 case GL_RGB10: 1025 case GL_RGB12: 1026 case GL_RGB16: 1027 case 4: 1028 case GL_ABGR_EXT: 1029 case GL_RGBA: 1030 case GL_BGRA: 1031 case GL_RGBA2: 1032 case GL_RGBA4: 1033 case GL_RGB5_A1: 1034 case GL_RGBA8: 1035 case GL_RGB10_A2: 1036 case GL_RGBA12: 1037 case GL_RGBA16: 1038 /* float texture formats */ 1039 case GL_ALPHA16F_ARB: 1040 case GL_ALPHA32F_ARB: 1041 case GL_LUMINANCE16F_ARB: 1042 case GL_LUMINANCE32F_ARB: 1043 case GL_LUMINANCE_ALPHA16F_ARB: 1044 case GL_LUMINANCE_ALPHA32F_ARB: 1045 case GL_INTENSITY16F_ARB: 1046 case GL_INTENSITY32F_ARB: 1047 case GL_R16F: 1048 case GL_R32F: 1049 case GL_RG16F: 1050 case GL_RG32F: 1051 case GL_RGB16F_ARB: 1052 case GL_RGB32F_ARB: 1053 case GL_RGBA16F_ARB: 1054 case GL_RGBA32F_ARB: 1055 /* compressed formats */ 1056 case GL_COMPRESSED_ALPHA: 1057 case GL_COMPRESSED_LUMINANCE: 1058 case GL_COMPRESSED_LUMINANCE_ALPHA: 1059 case GL_COMPRESSED_INTENSITY: 1060 case GL_COMPRESSED_RED: 1061 case GL_COMPRESSED_RG: 1062 case GL_COMPRESSED_RGB: 1063 case GL_COMPRESSED_RGBA: 1064 case GL_RGB_S3TC: 1065 case GL_RGB4_S3TC: 1066 case GL_RGBA_S3TC: 1067 case GL_RGBA4_S3TC: 1068 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 1069 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 1070 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: 1071 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: 1072 case GL_COMPRESSED_RGB_FXT1_3DFX: 1073 case GL_COMPRESSED_RGBA_FXT1_3DFX: 1074 case GL_SRGB_EXT: 1075 case GL_SRGB8_EXT: 1076 case GL_SRGB_ALPHA_EXT: 1077 case GL_SRGB8_ALPHA8_EXT: 1078 case GL_SLUMINANCE_ALPHA_EXT: 1079 case GL_SLUMINANCE8_ALPHA8_EXT: 1080 case GL_SLUMINANCE_EXT: 1081 case GL_SLUMINANCE8_EXT: 1082 case GL_COMPRESSED_SRGB_EXT: 1083 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: 1084 case GL_COMPRESSED_SRGB_ALPHA_EXT: 1085 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 1086 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 1087 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 1088 case GL_COMPRESSED_SLUMINANCE_EXT: 1089 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: 1090 case GL_COMPRESSED_RED_RGTC1: 1091 case GL_COMPRESSED_SIGNED_RED_RGTC1: 1092 case GL_COMPRESSED_RG_RGTC2: 1093 case GL_COMPRESSED_SIGNED_RG_RGTC2: 1094 case GL_COMPRESSED_LUMINANCE_LATC1_EXT: 1095 case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: 1096 case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: 1097 case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: 1098 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: 1099 case GL_ETC1_RGB8_OES: 1100 case GL_COMPRESSED_RGB8_ETC2: 1101 case GL_COMPRESSED_SRGB8_ETC2: 1102 case GL_COMPRESSED_RGBA8_ETC2_EAC: 1103 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 1104 case GL_COMPRESSED_R11_EAC: 1105 case GL_COMPRESSED_RG11_EAC: 1106 case GL_COMPRESSED_SIGNED_R11_EAC: 1107 case GL_COMPRESSED_SIGNED_RG11_EAC: 1108 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 1109 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 1110 case GL_COMPRESSED_RGBA_BPTC_UNORM: 1111 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM: 1112 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT: 1113 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: 1114 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: 1115 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: 1116 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: 1117 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: 1118 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: 1119 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: 1120 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: 1121 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: 1122 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: 1123 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: 1124 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: 1125 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: 1126 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: 1127 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: 1128 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 1129 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 1130 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 1131 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 1132 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 1133 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 1134 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 1135 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 1136 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 1137 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 1138 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 1139 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 1140 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 1141 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 1142 /* generic integer formats */ 1143 case GL_RED_INTEGER_EXT: 1144 case GL_GREEN_INTEGER_EXT: 1145 case GL_BLUE_INTEGER_EXT: 1146 case GL_ALPHA_INTEGER_EXT: 1147 case GL_RGB_INTEGER_EXT: 1148 case GL_RGBA_INTEGER_EXT: 1149 case GL_BGR_INTEGER_EXT: 1150 case GL_BGRA_INTEGER_EXT: 1151 case GL_RG_INTEGER: 1152 case GL_LUMINANCE_INTEGER_EXT: 1153 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 1154 /* sized integer formats */ 1155 case GL_RGBA32UI_EXT: 1156 case GL_RGB32UI_EXT: 1157 case GL_RG32UI: 1158 case GL_R32UI: 1159 case GL_ALPHA32UI_EXT: 1160 case GL_INTENSITY32UI_EXT: 1161 case GL_LUMINANCE32UI_EXT: 1162 case GL_LUMINANCE_ALPHA32UI_EXT: 1163 case GL_RGBA16UI_EXT: 1164 case GL_RGB16UI_EXT: 1165 case GL_RG16UI: 1166 case GL_R16UI: 1167 case GL_ALPHA16UI_EXT: 1168 case GL_INTENSITY16UI_EXT: 1169 case GL_LUMINANCE16UI_EXT: 1170 case GL_LUMINANCE_ALPHA16UI_EXT: 1171 case GL_RGBA8UI_EXT: 1172 case GL_RGB8UI_EXT: 1173 case GL_RG8UI: 1174 case GL_R8UI: 1175 case GL_ALPHA8UI_EXT: 1176 case GL_INTENSITY8UI_EXT: 1177 case GL_LUMINANCE8UI_EXT: 1178 case GL_LUMINANCE_ALPHA8UI_EXT: 1179 case GL_RGBA32I_EXT: 1180 case GL_RGB32I_EXT: 1181 case GL_RG32I: 1182 case GL_R32I: 1183 case GL_ALPHA32I_EXT: 1184 case GL_INTENSITY32I_EXT: 1185 case GL_LUMINANCE32I_EXT: 1186 case GL_LUMINANCE_ALPHA32I_EXT: 1187 case GL_RGBA16I_EXT: 1188 case GL_RGB16I_EXT: 1189 case GL_RG16I: 1190 case GL_R16I: 1191 case GL_ALPHA16I_EXT: 1192 case GL_INTENSITY16I_EXT: 1193 case GL_LUMINANCE16I_EXT: 1194 case GL_LUMINANCE_ALPHA16I_EXT: 1195 case GL_RGBA8I_EXT: 1196 case GL_RGB8I_EXT: 1197 case GL_RG8I: 1198 case GL_R8I: 1199 case GL_ALPHA8I_EXT: 1200 case GL_INTENSITY8I_EXT: 1201 case GL_LUMINANCE8I_EXT: 1202 case GL_LUMINANCE_ALPHA8I_EXT: 1203 /* signed, normalized texture formats */ 1204 case GL_RED_SNORM: 1205 case GL_R8_SNORM: 1206 case GL_R16_SNORM: 1207 case GL_RG_SNORM: 1208 case GL_RG8_SNORM: 1209 case GL_RG16_SNORM: 1210 case GL_RGB_SNORM: 1211 case GL_RGB8_SNORM: 1212 case GL_RGB16_SNORM: 1213 case GL_RGBA_SNORM: 1214 case GL_RGBA8_SNORM: 1215 case GL_RGBA16_SNORM: 1216 case GL_ALPHA_SNORM: 1217 case GL_ALPHA8_SNORM: 1218 case GL_ALPHA16_SNORM: 1219 case GL_LUMINANCE_SNORM: 1220 case GL_LUMINANCE8_SNORM: 1221 case GL_LUMINANCE16_SNORM: 1222 case GL_LUMINANCE_ALPHA_SNORM: 1223 case GL_LUMINANCE8_ALPHA8_SNORM: 1224 case GL_LUMINANCE16_ALPHA16_SNORM: 1225 case GL_INTENSITY_SNORM: 1226 case GL_INTENSITY8_SNORM: 1227 case GL_INTENSITY16_SNORM: 1228 case GL_RGB9_E5: 1229 case GL_R11F_G11F_B10F: 1230 case GL_RGB10_A2UI: 1231 return GL_TRUE; 1232 case GL_YCBCR_MESA: /* not considered to be RGB */ 1233 /* fall-through */ 1234 default: 1235 return GL_FALSE; 1236 } 1237} 1238 1239 1240/** 1241 * Test if the given image format is a depth component format. 1242 */ 1243GLboolean 1244_mesa_is_depth_format(GLenum format) 1245{ 1246 switch (format) { 1247 case GL_DEPTH_COMPONENT: 1248 case GL_DEPTH_COMPONENT16: 1249 case GL_DEPTH_COMPONENT24: 1250 case GL_DEPTH_COMPONENT32: 1251 case GL_DEPTH_COMPONENT32F: 1252 return GL_TRUE; 1253 default: 1254 return GL_FALSE; 1255 } 1256} 1257 1258 1259/** 1260 * Test if the given image format is a stencil format. 1261 */ 1262GLboolean 1263_mesa_is_stencil_format(GLenum format) 1264{ 1265 switch (format) { 1266 case GL_STENCIL_INDEX: 1267 return GL_TRUE; 1268 default: 1269 return GL_FALSE; 1270 } 1271} 1272 1273 1274/** 1275 * Test if the given image format is a YCbCr format. 1276 */ 1277GLboolean 1278_mesa_is_ycbcr_format(GLenum format) 1279{ 1280 switch (format) { 1281 case GL_YCBCR_MESA: 1282 return GL_TRUE; 1283 default: 1284 return GL_FALSE; 1285 } 1286} 1287 1288 1289/** 1290 * Test if the given image format is a depth+stencil format. 1291 */ 1292GLboolean 1293_mesa_is_depthstencil_format(GLenum format) 1294{ 1295 switch (format) { 1296 case GL_DEPTH24_STENCIL8_EXT: 1297 case GL_DEPTH_STENCIL_EXT: 1298 case GL_DEPTH32F_STENCIL8: 1299 return GL_TRUE; 1300 default: 1301 return GL_FALSE; 1302 } 1303} 1304 1305 1306/** 1307 * Test if the given image format is a depth or stencil format. 1308 */ 1309GLboolean 1310_mesa_is_depth_or_stencil_format(GLenum format) 1311{ 1312 switch (format) { 1313 case GL_DEPTH_COMPONENT: 1314 case GL_DEPTH_COMPONENT16: 1315 case GL_DEPTH_COMPONENT24: 1316 case GL_DEPTH_COMPONENT32: 1317 case GL_STENCIL_INDEX: 1318 case GL_STENCIL_INDEX1_EXT: 1319 case GL_STENCIL_INDEX4_EXT: 1320 case GL_STENCIL_INDEX8_EXT: 1321 case GL_STENCIL_INDEX16_EXT: 1322 case GL_DEPTH_STENCIL_EXT: 1323 case GL_DEPTH24_STENCIL8_EXT: 1324 case GL_DEPTH_COMPONENT32F: 1325 case GL_DEPTH32F_STENCIL8: 1326 return GL_TRUE; 1327 default: 1328 return GL_FALSE; 1329 } 1330} 1331 1332 1333/** 1334 * Test if an image format is a supported compressed format. 1335 * \param format the internal format token provided by the user. 1336 * \return GL_TRUE if compressed, GL_FALSE if uncompressed 1337 */ 1338GLboolean 1339_mesa_is_compressed_format(const struct gl_context *ctx, GLenum format) 1340{ 1341 mesa_format m_format = _mesa_glenum_to_compressed_format(format); 1342 1343 /* Some formats in this switch have an equivalent mesa_format_layout 1344 * to the compressed formats in the layout switch below and thus 1345 * must be handled first. 1346 */ 1347 switch (format) { 1348 case GL_RGB_S3TC: 1349 case GL_RGB4_S3TC: 1350 case GL_RGBA_S3TC: 1351 case GL_RGBA4_S3TC: 1352 return _mesa_is_desktop_gl(ctx) && 1353 ctx->Extensions.ANGLE_texture_compression_dxt; 1354 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: 1355 return ctx->API == API_OPENGL_COMPAT 1356 && ctx->Extensions.ATI_texture_compression_3dc; 1357 case GL_PALETTE4_RGB8_OES: 1358 case GL_PALETTE4_RGBA8_OES: 1359 case GL_PALETTE4_R5_G6_B5_OES: 1360 case GL_PALETTE4_RGBA4_OES: 1361 case GL_PALETTE4_RGB5_A1_OES: 1362 case GL_PALETTE8_RGB8_OES: 1363 case GL_PALETTE8_RGBA8_OES: 1364 case GL_PALETTE8_R5_G6_B5_OES: 1365 case GL_PALETTE8_RGBA4_OES: 1366 case GL_PALETTE8_RGB5_A1_OES: 1367 return ctx->API == API_OPENGLES; 1368 } 1369 1370 switch (_mesa_get_format_layout(m_format)) { 1371 case MESA_FORMAT_LAYOUT_S3TC: 1372 if (_mesa_get_format_color_encoding(m_format) == GL_LINEAR) { 1373 /* Assume that the ANGLE flag will always be set if the 1374 * EXT flag is set. 1375 */ 1376 return ctx->Extensions.ANGLE_texture_compression_dxt; 1377 } else { 1378 return _mesa_is_desktop_gl(ctx) 1379 && ctx->Extensions.EXT_texture_sRGB 1380 && ctx->Extensions.EXT_texture_compression_s3tc; 1381 } 1382 case MESA_FORMAT_LAYOUT_FXT1: 1383 return _mesa_is_desktop_gl(ctx) 1384 && ctx->Extensions.TDFX_texture_compression_FXT1; 1385 case MESA_FORMAT_LAYOUT_RGTC: 1386 return _mesa_is_desktop_gl(ctx) 1387 && ctx->Extensions.ARB_texture_compression_rgtc; 1388 case MESA_FORMAT_LAYOUT_LATC: 1389 return ctx->API == API_OPENGL_COMPAT 1390 && ctx->Extensions.EXT_texture_compression_latc; 1391 case MESA_FORMAT_LAYOUT_ETC1: 1392 return _mesa_is_gles(ctx) 1393 && ctx->Extensions.OES_compressed_ETC1_RGB8_texture; 1394 case MESA_FORMAT_LAYOUT_ETC2: 1395 return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility; 1396 case MESA_FORMAT_LAYOUT_BPTC: 1397 return _mesa_is_desktop_gl(ctx) && 1398 ctx->Extensions.ARB_texture_compression_bptc; 1399 case MESA_FORMAT_LAYOUT_ASTC: 1400 return ctx->Extensions.KHR_texture_compression_astc_ldr; 1401 default: 1402 return GL_FALSE; 1403 } 1404} 1405 1406/** 1407 * Test if the given format represents an sRGB format. 1408 * \param format the GL format (can be an internal format) 1409 * \return GL_TRUE if format is sRGB, GL_FALSE otherwise 1410 */ 1411GLboolean 1412_mesa_is_srgb_format(GLenum format) 1413{ 1414 switch (format) { 1415 case GL_SRGB: 1416 case GL_SRGB8: 1417 case GL_SRGB_ALPHA: 1418 case GL_SRGB8_ALPHA8: 1419 case GL_COMPRESSED_SRGB: 1420 case GL_COMPRESSED_SRGB_ALPHA: 1421 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: 1422 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 1423 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 1424 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 1425 case GL_COMPRESSED_SRGB8_ETC2: 1426 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 1427 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 1428 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM: 1429 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: 1430 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: 1431 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: 1432 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: 1433 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: 1434 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: 1435 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: 1436 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: 1437 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: 1438 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: 1439 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: 1440 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: 1441 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: 1442 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: 1443 return GL_TRUE; 1444 default: 1445 break; 1446 } 1447 1448 return GL_FALSE; 1449} 1450 1451/** 1452 * Convert various unpack formats to the corresponding base format. 1453 */ 1454GLenum 1455_mesa_unpack_format_to_base_format(GLenum format) 1456{ 1457 switch(format) { 1458 case GL_RED_INTEGER: 1459 return GL_RED; 1460 case GL_GREEN_INTEGER: 1461 return GL_GREEN; 1462 case GL_BLUE_INTEGER: 1463 return GL_BLUE; 1464 case GL_ALPHA_INTEGER: 1465 return GL_ALPHA; 1466 case GL_RG_INTEGER: 1467 return GL_RG; 1468 case GL_RGB_INTEGER: 1469 return GL_RGB; 1470 case GL_RGBA_INTEGER: 1471 return GL_RGBA; 1472 case GL_BGR_INTEGER: 1473 return GL_BGR; 1474 case GL_BGRA_INTEGER: 1475 return GL_BGRA; 1476 case GL_LUMINANCE_INTEGER_EXT: 1477 return GL_LUMINANCE; 1478 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 1479 return GL_LUMINANCE_ALPHA; 1480 case GL_RED: 1481 case GL_GREEN: 1482 case GL_BLUE: 1483 case GL_RG: 1484 case GL_RGB: 1485 case GL_RGBA: 1486 case GL_BGR: 1487 case GL_BGRA: 1488 case GL_ALPHA: 1489 case GL_LUMINANCE: 1490 case GL_LUMINANCE_ALPHA: 1491 default: 1492 return format; 1493 } 1494} 1495 1496/** 1497 * Convert various base formats to the corresponding integer format. 1498 */ 1499GLenum 1500_mesa_base_format_to_integer_format(GLenum format) 1501{ 1502 switch(format) { 1503 case GL_RED: 1504 return GL_RED_INTEGER; 1505 case GL_GREEN: 1506 return GL_GREEN_INTEGER; 1507 case GL_BLUE: 1508 return GL_BLUE_INTEGER; 1509 case GL_RG: 1510 return GL_RG_INTEGER; 1511 case GL_RGB: 1512 return GL_RGB_INTEGER; 1513 case GL_RGBA: 1514 return GL_RGBA_INTEGER; 1515 case GL_BGR: 1516 return GL_BGR_INTEGER; 1517 case GL_BGRA: 1518 return GL_BGRA_INTEGER; 1519 case GL_ALPHA: 1520 return GL_ALPHA_INTEGER; 1521 case GL_LUMINANCE: 1522 return GL_LUMINANCE_INTEGER_EXT; 1523 case GL_LUMINANCE_ALPHA: 1524 return GL_LUMINANCE_ALPHA_INTEGER_EXT; 1525 } 1526 1527 return format; 1528} 1529 1530 1531/** 1532 * Does the given base texture/renderbuffer format have the channel 1533 * named by 'pname'? 1534 */ 1535GLboolean 1536_mesa_base_format_has_channel(GLenum base_format, GLenum pname) 1537{ 1538 switch (pname) { 1539 case GL_TEXTURE_RED_SIZE: 1540 case GL_TEXTURE_RED_TYPE: 1541 case GL_RENDERBUFFER_RED_SIZE_EXT: 1542 case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: 1543 case GL_INTERNALFORMAT_RED_SIZE: 1544 case GL_INTERNALFORMAT_RED_TYPE: 1545 if (base_format == GL_RED || 1546 base_format == GL_RG || 1547 base_format == GL_RGB || 1548 base_format == GL_RGBA) { 1549 return GL_TRUE; 1550 } 1551 return GL_FALSE; 1552 case GL_TEXTURE_GREEN_SIZE: 1553 case GL_TEXTURE_GREEN_TYPE: 1554 case GL_RENDERBUFFER_GREEN_SIZE_EXT: 1555 case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 1556 case GL_INTERNALFORMAT_GREEN_SIZE: 1557 case GL_INTERNALFORMAT_GREEN_TYPE: 1558 if (base_format == GL_RG || 1559 base_format == GL_RGB || 1560 base_format == GL_RGBA) { 1561 return GL_TRUE; 1562 } 1563 return GL_FALSE; 1564 case GL_TEXTURE_BLUE_SIZE: 1565 case GL_TEXTURE_BLUE_TYPE: 1566 case GL_RENDERBUFFER_BLUE_SIZE_EXT: 1567 case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 1568 case GL_INTERNALFORMAT_BLUE_SIZE: 1569 case GL_INTERNALFORMAT_BLUE_TYPE: 1570 if (base_format == GL_RGB || 1571 base_format == GL_RGBA) { 1572 return GL_TRUE; 1573 } 1574 return GL_FALSE; 1575 case GL_TEXTURE_ALPHA_SIZE: 1576 case GL_TEXTURE_ALPHA_TYPE: 1577 case GL_RENDERBUFFER_ALPHA_SIZE_EXT: 1578 case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 1579 case GL_INTERNALFORMAT_ALPHA_SIZE: 1580 case GL_INTERNALFORMAT_ALPHA_TYPE: 1581 if (base_format == GL_RGBA || 1582 base_format == GL_ALPHA || 1583 base_format == GL_LUMINANCE_ALPHA) { 1584 return GL_TRUE; 1585 } 1586 return GL_FALSE; 1587 case GL_TEXTURE_LUMINANCE_SIZE: 1588 case GL_TEXTURE_LUMINANCE_TYPE: 1589 if (base_format == GL_LUMINANCE || 1590 base_format == GL_LUMINANCE_ALPHA) { 1591 return GL_TRUE; 1592 } 1593 return GL_FALSE; 1594 case GL_TEXTURE_INTENSITY_SIZE: 1595 case GL_TEXTURE_INTENSITY_TYPE: 1596 if (base_format == GL_INTENSITY) { 1597 return GL_TRUE; 1598 } 1599 return GL_FALSE; 1600 case GL_TEXTURE_DEPTH_SIZE: 1601 case GL_TEXTURE_DEPTH_TYPE: 1602 case GL_RENDERBUFFER_DEPTH_SIZE_EXT: 1603 case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 1604 case GL_INTERNALFORMAT_DEPTH_SIZE: 1605 case GL_INTERNALFORMAT_DEPTH_TYPE: 1606 if (base_format == GL_DEPTH_STENCIL || 1607 base_format == GL_DEPTH_COMPONENT) { 1608 return GL_TRUE; 1609 } 1610 return GL_FALSE; 1611 case GL_RENDERBUFFER_STENCIL_SIZE_EXT: 1612 case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 1613 case GL_INTERNALFORMAT_STENCIL_SIZE: 1614 case GL_INTERNALFORMAT_STENCIL_TYPE: 1615 if (base_format == GL_DEPTH_STENCIL || 1616 base_format == GL_STENCIL_INDEX) { 1617 return GL_TRUE; 1618 } 1619 return GL_FALSE; 1620 default: 1621 _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n", 1622 __func__, pname); 1623 return GL_FALSE; 1624 } 1625 1626 return GL_FALSE; 1627} 1628 1629 1630/** 1631 * Returns the number of channels/components for a base format. 1632 */ 1633GLint 1634_mesa_base_format_component_count(GLenum base_format) 1635{ 1636 switch (base_format) { 1637 case GL_LUMINANCE: 1638 case GL_RED: 1639 case GL_ALPHA: 1640 case GL_INTENSITY: 1641 case GL_DEPTH_COMPONENT: 1642 return 1; 1643 case GL_RG: 1644 case GL_LUMINANCE_ALPHA: 1645 case GL_DEPTH_STENCIL: 1646 return 2; 1647 case GL_RGB: 1648 return 3; 1649 case GL_RGBA: 1650 return 4; 1651 default: 1652 return -1; 1653 } 1654} 1655 1656 1657/** 1658 * If format is a generic compressed format, return the corresponding 1659 * non-compressed format. For other formats, return the format as-is. 1660 */ 1661GLenum 1662_mesa_generic_compressed_format_to_uncompressed_format(GLenum format) 1663{ 1664 switch (format) { 1665 case GL_COMPRESSED_RED: 1666 return GL_RED; 1667 case GL_COMPRESSED_RG: 1668 return GL_RG; 1669 case GL_COMPRESSED_RGB: 1670 return GL_RGB; 1671 case GL_COMPRESSED_RGBA: 1672 return GL_RGBA; 1673 case GL_COMPRESSED_ALPHA: 1674 return GL_ALPHA; 1675 case GL_COMPRESSED_LUMINANCE: 1676 return GL_LUMINANCE; 1677 case GL_COMPRESSED_LUMINANCE_ALPHA: 1678 return GL_LUMINANCE_ALPHA; 1679 case GL_COMPRESSED_INTENSITY: 1680 return GL_INTENSITY; 1681 /* sRGB formats */ 1682 case GL_COMPRESSED_SRGB: 1683 return GL_SRGB; 1684 case GL_COMPRESSED_SRGB_ALPHA: 1685 return GL_SRGB_ALPHA; 1686 case GL_COMPRESSED_SLUMINANCE: 1687 return GL_SLUMINANCE; 1688 case GL_COMPRESSED_SLUMINANCE_ALPHA: 1689 return GL_SLUMINANCE_ALPHA; 1690 default: 1691 return format; 1692 } 1693} 1694 1695 1696/** 1697 * Return the equivalent non-generic internal format. 1698 * This is useful for comparing whether two internal formats are equivalent. 1699 */ 1700GLenum 1701_mesa_get_nongeneric_internalformat(GLenum format) 1702{ 1703 switch (format) { 1704 /* GL 1.1 formats. */ 1705 case 4: 1706 case GL_RGBA: 1707 return GL_RGBA8; 1708 case 3: 1709 case GL_RGB: 1710 return GL_RGB8; 1711 case 2: 1712 case GL_LUMINANCE_ALPHA: 1713 return GL_LUMINANCE8_ALPHA8; 1714 case 1: 1715 case GL_LUMINANCE: 1716 return GL_LUMINANCE8; 1717 case GL_ALPHA: 1718 return GL_ALPHA8; 1719 case GL_INTENSITY: 1720 return GL_INTENSITY8; 1721 1722 /* GL_ARB_texture_rg */ 1723 case GL_RED: 1724 return GL_R8; 1725 case GL_RG: 1726 return GL_RG8; 1727 1728 /* GL_EXT_texture_sRGB */ 1729 case GL_SRGB: 1730 return GL_SRGB8; 1731 case GL_SRGB_ALPHA: 1732 return GL_SRGB8_ALPHA8; 1733 case GL_SLUMINANCE: 1734 return GL_SLUMINANCE8; 1735 case GL_SLUMINANCE_ALPHA: 1736 return GL_SLUMINANCE8_ALPHA8; 1737 1738 /* GL_EXT_texture_snorm */ 1739 case GL_RGBA_SNORM: 1740 return GL_RGBA8_SNORM; 1741 case GL_RGB_SNORM: 1742 return GL_RGB8_SNORM; 1743 case GL_RG_SNORM: 1744 return GL_RG8_SNORM; 1745 case GL_RED_SNORM: 1746 return GL_R8_SNORM; 1747 case GL_LUMINANCE_ALPHA_SNORM: 1748 return GL_LUMINANCE8_ALPHA8_SNORM; 1749 case GL_LUMINANCE_SNORM: 1750 return GL_LUMINANCE8_SNORM; 1751 case GL_ALPHA_SNORM: 1752 return GL_ALPHA8_SNORM; 1753 case GL_INTENSITY_SNORM: 1754 return GL_INTENSITY8_SNORM; 1755 1756 default: 1757 return format; 1758 } 1759} 1760 1761 1762/** 1763 * Convert an sRGB internal format to linear. 1764 */ 1765GLenum 1766_mesa_get_linear_internalformat(GLenum format) 1767{ 1768 switch (format) { 1769 case GL_SRGB: 1770 return GL_RGB; 1771 case GL_SRGB_ALPHA: 1772 return GL_RGBA; 1773 case GL_SRGB8: 1774 return GL_RGB8; 1775 case GL_SRGB8_ALPHA8: 1776 return GL_RGBA8; 1777 case GL_SLUMINANCE8: 1778 return GL_LUMINANCE8; 1779 case GL_SLUMINANCE: 1780 return GL_LUMINANCE; 1781 case GL_SLUMINANCE_ALPHA: 1782 return GL_LUMINANCE_ALPHA; 1783 case GL_SLUMINANCE8_ALPHA8: 1784 return GL_LUMINANCE8_ALPHA8; 1785 default: 1786 return format; 1787 } 1788} 1789 1790 1791/** 1792 * Do error checking of format/type combinations for glReadPixels, 1793 * glDrawPixels and glTex[Sub]Image. Note that depending on the format 1794 * and type values, we may either generate GL_INVALID_OPERATION or 1795 * GL_INVALID_ENUM. 1796 * 1797 * \param format pixel format. 1798 * \param type pixel type. 1799 * 1800 * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR 1801 */ 1802GLenum 1803_mesa_error_check_format_and_type(const struct gl_context *ctx, 1804 GLenum format, GLenum type) 1805{ 1806 /* From OpenGL 3.3 spec, page 220: 1807 * "If the format is DEPTH_STENCIL, then values are taken from 1808 * both the depth buffer and the stencil buffer. If there is no 1809 * depth buffer or if there is no stencil buffer, then the error 1810 * INVALID_OPERATION occurs. If the type parameter is not 1811 * UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the 1812 * error INVALID_ENUM occurs." 1813 * 1814 * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels 1815 * cannot be used to read depth or stencil in that API. 1816 */ 1817 if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL 1818 && type != GL_UNSIGNED_INT_24_8 1819 && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV) 1820 return GL_INVALID_ENUM; 1821 1822 /* special type-based checks (see glReadPixels, glDrawPixels error lists) */ 1823 switch (type) { 1824 case GL_BITMAP: 1825 if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) { 1826 return GL_INVALID_ENUM; 1827 } 1828 break; 1829 1830 case GL_UNSIGNED_BYTE_3_3_2: 1831 case GL_UNSIGNED_BYTE_2_3_3_REV: 1832 case GL_UNSIGNED_SHORT_5_6_5: 1833 case GL_UNSIGNED_SHORT_5_6_5_REV: 1834 if (format == GL_RGB) { 1835 break; /* OK */ 1836 } 1837 if (format == GL_RGB_INTEGER_EXT && 1838 ctx->Extensions.ARB_texture_rgb10_a2ui) { 1839 break; /* OK */ 1840 } 1841 return GL_INVALID_OPERATION; 1842 1843 case GL_UNSIGNED_SHORT_4_4_4_4: 1844 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 1845 case GL_UNSIGNED_INT_8_8_8_8: 1846 case GL_UNSIGNED_INT_8_8_8_8_REV: 1847 if (format == GL_RGBA || 1848 format == GL_BGRA || 1849 format == GL_ABGR_EXT) { 1850 break; /* OK */ 1851 } 1852 if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && 1853 ctx->Extensions.ARB_texture_rgb10_a2ui) { 1854 break; /* OK */ 1855 } 1856 return GL_INVALID_OPERATION; 1857 1858 case GL_UNSIGNED_SHORT_5_5_5_1: 1859 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 1860 case GL_UNSIGNED_INT_10_10_10_2: 1861 case GL_UNSIGNED_INT_2_10_10_10_REV: 1862 if (format == GL_RGBA || 1863 format == GL_BGRA) { 1864 break; /* OK */ 1865 } 1866 if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && 1867 ctx->Extensions.ARB_texture_rgb10_a2ui) { 1868 break; /* OK */ 1869 } 1870 if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB && 1871 ctx->API == API_OPENGLES2) { 1872 break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */ 1873 } 1874 return GL_INVALID_OPERATION; 1875 1876 case GL_UNSIGNED_INT_24_8: 1877 /* Depth buffer OK to read in OpenGL ES (NV_read_depth). */ 1878 if (ctx->API == API_OPENGLES2 && format == GL_DEPTH_COMPONENT) 1879 return GL_NO_ERROR; 1880 1881 if (format != GL_DEPTH_STENCIL) { 1882 return GL_INVALID_OPERATION; 1883 } 1884 return GL_NO_ERROR; 1885 1886 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 1887 if (!ctx->Extensions.ARB_depth_buffer_float) { 1888 return GL_INVALID_ENUM; 1889 } 1890 if (format != GL_DEPTH_STENCIL) { 1891 return GL_INVALID_OPERATION; 1892 } 1893 return GL_NO_ERROR; 1894 1895 case GL_UNSIGNED_INT_10F_11F_11F_REV: 1896 if (!ctx->Extensions.EXT_packed_float) { 1897 return GL_INVALID_ENUM; 1898 } 1899 if (format != GL_RGB) { 1900 return GL_INVALID_OPERATION; 1901 } 1902 return GL_NO_ERROR; 1903 1904 case GL_HALF_FLOAT_OES: 1905 switch (format) { 1906 case GL_RGBA: 1907 case GL_RGB: 1908 case GL_LUMINANCE_ALPHA: 1909 case GL_LUMINANCE: 1910 case GL_ALPHA: 1911 return GL_NO_ERROR; 1912 case GL_RG: 1913 case GL_RED: 1914 if (_mesa_is_gles3(ctx) || ctx->Extensions.ARB_texture_rg) 1915 return GL_NO_ERROR; 1916 default: 1917 return GL_INVALID_OPERATION; 1918 } 1919 1920 default: 1921 ; /* fall-through */ 1922 } 1923 1924 /* now, for each format, check the type for compatibility */ 1925 switch (format) { 1926 case GL_COLOR_INDEX: 1927 case GL_STENCIL_INDEX: 1928 switch (type) { 1929 case GL_BITMAP: 1930 case GL_BYTE: 1931 case GL_UNSIGNED_BYTE: 1932 case GL_SHORT: 1933 case GL_UNSIGNED_SHORT: 1934 case GL_INT: 1935 case GL_UNSIGNED_INT: 1936 case GL_FLOAT: 1937 case GL_HALF_FLOAT: 1938 return GL_NO_ERROR; 1939 default: 1940 return GL_INVALID_ENUM; 1941 } 1942 1943 case GL_RED: 1944 case GL_GREEN: 1945 case GL_BLUE: 1946 case GL_ALPHA: 1947#if 0 /* not legal! see table 3.6 of the 1.5 spec */ 1948 case GL_INTENSITY: 1949#endif 1950 case GL_LUMINANCE: 1951 case GL_LUMINANCE_ALPHA: 1952 case GL_DEPTH_COMPONENT: 1953 switch (type) { 1954 case GL_BYTE: 1955 case GL_UNSIGNED_BYTE: 1956 case GL_SHORT: 1957 case GL_UNSIGNED_SHORT: 1958 case GL_INT: 1959 case GL_UNSIGNED_INT: 1960 case GL_FLOAT: 1961 case GL_HALF_FLOAT: 1962 return GL_NO_ERROR; 1963 default: 1964 return GL_INVALID_ENUM; 1965 } 1966 1967 case GL_RG: 1968 if (!ctx->Extensions.ARB_texture_rg) 1969 return GL_INVALID_ENUM; 1970 switch (type) { 1971 case GL_BYTE: 1972 case GL_UNSIGNED_BYTE: 1973 case GL_SHORT: 1974 case GL_UNSIGNED_SHORT: 1975 case GL_INT: 1976 case GL_UNSIGNED_INT: 1977 case GL_FLOAT: 1978 case GL_HALF_FLOAT: 1979 return GL_NO_ERROR; 1980 default: 1981 return GL_INVALID_ENUM; 1982 } 1983 1984 case GL_RGB: 1985 switch (type) { 1986 case GL_BYTE: 1987 case GL_UNSIGNED_BYTE: 1988 case GL_SHORT: 1989 case GL_UNSIGNED_SHORT: 1990 case GL_INT: 1991 case GL_UNSIGNED_INT: 1992 case GL_FLOAT: 1993 case GL_UNSIGNED_BYTE_3_3_2: 1994 case GL_UNSIGNED_BYTE_2_3_3_REV: 1995 case GL_UNSIGNED_SHORT_5_6_5: 1996 case GL_UNSIGNED_SHORT_5_6_5_REV: 1997 case GL_HALF_FLOAT: 1998 return GL_NO_ERROR; 1999 case GL_UNSIGNED_INT_2_10_10_10_REV: 2000 /* OK by GL_EXT_texture_type_2_10_10_10_REV */ 2001 return (ctx->API == API_OPENGLES2) 2002 ? GL_NO_ERROR : GL_INVALID_ENUM; 2003 case GL_UNSIGNED_INT_5_9_9_9_REV: 2004 return ctx->Extensions.EXT_texture_shared_exponent 2005 ? GL_NO_ERROR : GL_INVALID_ENUM; 2006 case GL_UNSIGNED_INT_10F_11F_11F_REV: 2007 return ctx->Extensions.EXT_packed_float 2008 ? GL_NO_ERROR : GL_INVALID_ENUM; 2009 default: 2010 return GL_INVALID_ENUM; 2011 } 2012 2013 case GL_BGR: 2014 switch (type) { 2015 /* NOTE: no packed types are supported with BGR. That's 2016 * intentional, according to the GL spec. 2017 */ 2018 case GL_BYTE: 2019 case GL_UNSIGNED_BYTE: 2020 case GL_SHORT: 2021 case GL_UNSIGNED_SHORT: 2022 case GL_INT: 2023 case GL_UNSIGNED_INT: 2024 case GL_FLOAT: 2025 case GL_HALF_FLOAT: 2026 return GL_NO_ERROR; 2027 default: 2028 return GL_INVALID_ENUM; 2029 } 2030 2031 case GL_RGBA: 2032 case GL_BGRA: 2033 switch (type) { 2034 case GL_BYTE: 2035 case GL_UNSIGNED_BYTE: 2036 case GL_SHORT: 2037 case GL_UNSIGNED_SHORT: 2038 case GL_INT: 2039 case GL_UNSIGNED_INT: 2040 case GL_FLOAT: 2041 case GL_UNSIGNED_SHORT_4_4_4_4: 2042 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2043 case GL_UNSIGNED_SHORT_5_5_5_1: 2044 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 2045 case GL_UNSIGNED_INT_8_8_8_8: 2046 case GL_UNSIGNED_INT_8_8_8_8_REV: 2047 case GL_UNSIGNED_INT_10_10_10_2: 2048 case GL_UNSIGNED_INT_2_10_10_10_REV: 2049 case GL_HALF_FLOAT: 2050 return GL_NO_ERROR; 2051 default: 2052 return GL_INVALID_ENUM; 2053 } 2054 2055 case GL_ABGR_EXT: 2056 switch (type) { 2057 case GL_BYTE: 2058 case GL_UNSIGNED_BYTE: 2059 case GL_SHORT: 2060 case GL_UNSIGNED_SHORT: 2061 case GL_INT: 2062 case GL_UNSIGNED_INT: 2063 case GL_FLOAT: 2064 case GL_UNSIGNED_SHORT_4_4_4_4: 2065 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2066 case GL_UNSIGNED_INT_8_8_8_8: 2067 case GL_UNSIGNED_INT_8_8_8_8_REV: 2068 case GL_HALF_FLOAT: 2069 return GL_NO_ERROR; 2070 default: 2071 return GL_INVALID_ENUM; 2072 } 2073 2074 case GL_YCBCR_MESA: 2075 if (!ctx->Extensions.MESA_ycbcr_texture) 2076 return GL_INVALID_ENUM; 2077 if (type == GL_UNSIGNED_SHORT_8_8_MESA || 2078 type == GL_UNSIGNED_SHORT_8_8_REV_MESA) 2079 return GL_NO_ERROR; 2080 else 2081 return GL_INVALID_OPERATION; 2082 2083 case GL_DEPTH_STENCIL: 2084 if (type == GL_UNSIGNED_INT_24_8) 2085 return GL_NO_ERROR; 2086 else if (ctx->Extensions.ARB_depth_buffer_float && 2087 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) 2088 return GL_NO_ERROR; 2089 else 2090 return GL_INVALID_ENUM; 2091 2092 /* integer-valued formats */ 2093 case GL_RED_INTEGER_EXT: 2094 case GL_GREEN_INTEGER_EXT: 2095 case GL_BLUE_INTEGER_EXT: 2096 case GL_ALPHA_INTEGER_EXT: 2097 case GL_RG_INTEGER: 2098 switch (type) { 2099 case GL_BYTE: 2100 case GL_UNSIGNED_BYTE: 2101 case GL_SHORT: 2102 case GL_UNSIGNED_SHORT: 2103 case GL_INT: 2104 case GL_UNSIGNED_INT: 2105 return (ctx->Version >= 30 || 2106 ctx->Extensions.EXT_texture_integer) 2107 ? GL_NO_ERROR : GL_INVALID_ENUM; 2108 default: 2109 return GL_INVALID_ENUM; 2110 } 2111 2112 case GL_RGB_INTEGER_EXT: 2113 switch (type) { 2114 case GL_BYTE: 2115 case GL_UNSIGNED_BYTE: 2116 case GL_SHORT: 2117 case GL_UNSIGNED_SHORT: 2118 case GL_INT: 2119 case GL_UNSIGNED_INT: 2120 return (ctx->Version >= 30 || 2121 ctx->Extensions.EXT_texture_integer) 2122 ? GL_NO_ERROR : GL_INVALID_ENUM; 2123 case GL_UNSIGNED_BYTE_3_3_2: 2124 case GL_UNSIGNED_BYTE_2_3_3_REV: 2125 case GL_UNSIGNED_SHORT_5_6_5: 2126 case GL_UNSIGNED_SHORT_5_6_5_REV: 2127 return ctx->Extensions.ARB_texture_rgb10_a2ui 2128 ? GL_NO_ERROR : GL_INVALID_ENUM; 2129 default: 2130 return GL_INVALID_ENUM; 2131 } 2132 2133 case GL_BGR_INTEGER_EXT: 2134 switch (type) { 2135 case GL_BYTE: 2136 case GL_UNSIGNED_BYTE: 2137 case GL_SHORT: 2138 case GL_UNSIGNED_SHORT: 2139 case GL_INT: 2140 case GL_UNSIGNED_INT: 2141 /* NOTE: no packed formats w/ BGR format */ 2142 return (ctx->Version >= 30 || 2143 ctx->Extensions.EXT_texture_integer) 2144 ? GL_NO_ERROR : GL_INVALID_ENUM; 2145 default: 2146 return GL_INVALID_ENUM; 2147 } 2148 2149 case GL_RGBA_INTEGER_EXT: 2150 case GL_BGRA_INTEGER_EXT: 2151 switch (type) { 2152 case GL_BYTE: 2153 case GL_UNSIGNED_BYTE: 2154 case GL_SHORT: 2155 case GL_UNSIGNED_SHORT: 2156 case GL_INT: 2157 case GL_UNSIGNED_INT: 2158 return (ctx->Version >= 30 || 2159 ctx->Extensions.EXT_texture_integer) 2160 ? GL_NO_ERROR : GL_INVALID_ENUM; 2161 case GL_UNSIGNED_SHORT_4_4_4_4: 2162 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 2163 case GL_UNSIGNED_SHORT_5_5_5_1: 2164 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 2165 case GL_UNSIGNED_INT_8_8_8_8: 2166 case GL_UNSIGNED_INT_8_8_8_8_REV: 2167 case GL_UNSIGNED_INT_10_10_10_2: 2168 case GL_UNSIGNED_INT_2_10_10_10_REV: 2169 return ctx->Extensions.ARB_texture_rgb10_a2ui 2170 ? GL_NO_ERROR : GL_INVALID_ENUM; 2171 default: 2172 return GL_INVALID_ENUM; 2173 } 2174 2175 case GL_LUMINANCE_INTEGER_EXT: 2176 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 2177 switch (type) { 2178 case GL_BYTE: 2179 case GL_UNSIGNED_BYTE: 2180 case GL_SHORT: 2181 case GL_UNSIGNED_SHORT: 2182 case GL_INT: 2183 case GL_UNSIGNED_INT: 2184 return ctx->Extensions.EXT_texture_integer 2185 ? GL_NO_ERROR : GL_INVALID_ENUM; 2186 default: 2187 return GL_INVALID_ENUM; 2188 } 2189 2190 default: 2191 return GL_INVALID_ENUM; 2192 } 2193 return GL_NO_ERROR; 2194} 2195 2196 2197/** 2198 * Do error checking of format/type combinations for OpenGL ES glReadPixels 2199 * and glTex[Sub]Image. 2200 * \return error code, or GL_NO_ERROR. 2201 */ 2202GLenum 2203_mesa_es_error_check_format_and_type(const struct gl_context *ctx, 2204 GLenum format, GLenum type, 2205 unsigned dimensions) 2206{ 2207 GLboolean type_valid = GL_TRUE; 2208 2209 switch (format) { 2210 case GL_RED: 2211 case GL_RG: 2212 if (ctx->API == API_OPENGLES || !ctx->Extensions.ARB_texture_rg) 2213 return GL_INVALID_VALUE; 2214 /* fallthrough */ 2215 case GL_ALPHA: 2216 case GL_LUMINANCE: 2217 case GL_LUMINANCE_ALPHA: 2218 type_valid = (type == GL_UNSIGNED_BYTE 2219 || type == GL_FLOAT 2220 || type == GL_HALF_FLOAT_OES); 2221 break; 2222 2223 case GL_RGB: 2224 type_valid = (type == GL_UNSIGNED_BYTE 2225 || type == GL_UNSIGNED_SHORT_5_6_5 2226 || type == GL_FLOAT 2227 || type == GL_HALF_FLOAT_OES); 2228 break; 2229 2230 case GL_RGBA: 2231 type_valid = (type == GL_UNSIGNED_BYTE 2232 || type == GL_UNSIGNED_SHORT_4_4_4_4 2233 || type == GL_UNSIGNED_SHORT_5_5_5_1 2234 || type == GL_FLOAT 2235 || type == GL_HALF_FLOAT_OES 2236 || type == GL_UNSIGNED_INT_2_10_10_10_REV); 2237 break; 2238 2239 case GL_DEPTH_COMPONENT: 2240 /* This format is filtered against invalid dimensionalities elsewhere. 2241 */ 2242 type_valid = (type == GL_UNSIGNED_SHORT 2243 || type == GL_UNSIGNED_INT); 2244 break; 2245 2246 case GL_DEPTH_STENCIL: 2247 /* This format is filtered against invalid dimensionalities elsewhere. 2248 */ 2249 type_valid = (type == GL_UNSIGNED_INT_24_8); 2250 break; 2251 2252 case GL_BGRA_EXT: 2253 type_valid = (type == GL_UNSIGNED_BYTE); 2254 2255 /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but 2256 * the format does not appear to be allowed for 3D textures in OpenGL 2257 * ES. 2258 */ 2259 if (dimensions != 2) 2260 return GL_INVALID_VALUE; 2261 2262 break; 2263 2264 default: 2265 return GL_INVALID_VALUE; 2266 } 2267 2268 return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION; 2269} 2270 2271/** 2272 * Return the simple base format for a given internal texture format. 2273 * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA. 2274 * 2275 * \param ctx GL context. 2276 * \param internalFormat the internal texture format token or 1, 2, 3, or 4. 2277 * 2278 * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE, 2279 * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum. 2280 * 2281 * This is the format which is used during texture application (i.e. the 2282 * texture format and env mode determine the arithmetic used. 2283 */ 2284GLint 2285_mesa_base_tex_format(const struct gl_context *ctx, GLint internalFormat) 2286{ 2287 switch (internalFormat) { 2288 case GL_ALPHA: 2289 case GL_ALPHA4: 2290 case GL_ALPHA8: 2291 case GL_ALPHA12: 2292 case GL_ALPHA16: 2293 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1; 2294 case 1: 2295 case GL_LUMINANCE: 2296 case GL_LUMINANCE4: 2297 case GL_LUMINANCE8: 2298 case GL_LUMINANCE12: 2299 case GL_LUMINANCE16: 2300 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1; 2301 case 2: 2302 case GL_LUMINANCE_ALPHA: 2303 case GL_LUMINANCE4_ALPHA4: 2304 case GL_LUMINANCE6_ALPHA2: 2305 case GL_LUMINANCE8_ALPHA8: 2306 case GL_LUMINANCE12_ALPHA4: 2307 case GL_LUMINANCE12_ALPHA12: 2308 case GL_LUMINANCE16_ALPHA16: 2309 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1; 2310 case GL_INTENSITY: 2311 case GL_INTENSITY4: 2312 case GL_INTENSITY8: 2313 case GL_INTENSITY12: 2314 case GL_INTENSITY16: 2315 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1; 2316 case 3: 2317 return (ctx->API != API_OPENGL_CORE) ? GL_RGB : -1; 2318 case GL_RGB: 2319 case GL_R3_G3_B2: 2320 case GL_RGB4: 2321 case GL_RGB5: 2322 case GL_RGB8: 2323 case GL_RGB10: 2324 case GL_RGB12: 2325 case GL_RGB16: 2326 return GL_RGB; 2327 case 4: 2328 return (ctx->API != API_OPENGL_CORE) ? GL_RGBA : -1; 2329 case GL_RGBA: 2330 case GL_RGBA2: 2331 case GL_RGBA4: 2332 case GL_RGB5_A1: 2333 case GL_RGBA8: 2334 case GL_RGB10_A2: 2335 case GL_RGBA12: 2336 case GL_RGBA16: 2337 return GL_RGBA; 2338 default: 2339 ; /* fallthrough */ 2340 } 2341 2342 /* GL_BGRA can be an internal format *only* in OpenGL ES (1.x or 2.0). 2343 */ 2344 if (_mesa_is_gles(ctx)) { 2345 switch (internalFormat) { 2346 case GL_BGRA: 2347 return GL_RGBA; 2348 default: 2349 ; /* fallthrough */ 2350 } 2351 } 2352 2353 if (ctx->Extensions.ARB_ES2_compatibility) { 2354 switch (internalFormat) { 2355 case GL_RGB565: 2356 return GL_RGB; 2357 default: 2358 ; /* fallthrough */ 2359 } 2360 } 2361 2362 if (ctx->Extensions.ARB_depth_texture) { 2363 switch (internalFormat) { 2364 case GL_DEPTH_COMPONENT: 2365 case GL_DEPTH_COMPONENT16: 2366 case GL_DEPTH_COMPONENT24: 2367 case GL_DEPTH_COMPONENT32: 2368 return GL_DEPTH_COMPONENT; 2369 case GL_DEPTH_STENCIL: 2370 case GL_DEPTH24_STENCIL8: 2371 return GL_DEPTH_STENCIL; 2372 default: 2373 ; /* fallthrough */ 2374 } 2375 } 2376 2377 if (ctx->Extensions.ARB_texture_stencil8) { 2378 switch (internalFormat) { 2379 case GL_STENCIL_INDEX: 2380 case GL_STENCIL_INDEX1: 2381 case GL_STENCIL_INDEX4: 2382 case GL_STENCIL_INDEX8: 2383 case GL_STENCIL_INDEX16: 2384 return GL_STENCIL_INDEX; 2385 default: 2386 ; /* fallthrough */ 2387 } 2388 } 2389 2390 switch (internalFormat) { 2391 case GL_COMPRESSED_ALPHA: 2392 return GL_ALPHA; 2393 case GL_COMPRESSED_LUMINANCE: 2394 return GL_LUMINANCE; 2395 case GL_COMPRESSED_LUMINANCE_ALPHA: 2396 return GL_LUMINANCE_ALPHA; 2397 case GL_COMPRESSED_INTENSITY: 2398 return GL_INTENSITY; 2399 case GL_COMPRESSED_RGB: 2400 return GL_RGB; 2401 case GL_COMPRESSED_RGBA: 2402 return GL_RGBA; 2403 default: 2404 ; /* fallthrough */ 2405 } 2406 2407 if (_mesa_is_compressed_format(ctx, internalFormat)) { 2408 GLenum base_compressed = 2409 _mesa_gl_compressed_format_base_format(internalFormat); 2410 if (base_compressed) 2411 return base_compressed; 2412 } 2413 2414 if ((ctx->Extensions.KHR_texture_compression_astc_ldr && 2415 is_astc_2d_format(internalFormat)) || 2416 (ctx->Extensions.OES_texture_compression_astc && 2417 is_astc_3d_format(internalFormat))) 2418 return GL_RGBA; 2419 2420 if (ctx->Extensions.MESA_ycbcr_texture) { 2421 if (internalFormat == GL_YCBCR_MESA) 2422 return GL_YCBCR_MESA; 2423 } 2424 2425 if (ctx->Extensions.ARB_texture_float) { 2426 switch (internalFormat) { 2427 case GL_ALPHA16F_ARB: 2428 case GL_ALPHA32F_ARB: 2429 return GL_ALPHA; 2430 case GL_RGBA16F_ARB: 2431 case GL_RGBA32F_ARB: 2432 return GL_RGBA; 2433 case GL_RGB16F_ARB: 2434 case GL_RGB32F_ARB: 2435 return GL_RGB; 2436 case GL_INTENSITY16F_ARB: 2437 case GL_INTENSITY32F_ARB: 2438 return GL_INTENSITY; 2439 case GL_LUMINANCE16F_ARB: 2440 case GL_LUMINANCE32F_ARB: 2441 return GL_LUMINANCE; 2442 case GL_LUMINANCE_ALPHA16F_ARB: 2443 case GL_LUMINANCE_ALPHA32F_ARB: 2444 return GL_LUMINANCE_ALPHA; 2445 default: 2446 ; /* fallthrough */ 2447 } 2448 } 2449 2450 if (ctx->Extensions.EXT_texture_snorm) { 2451 switch (internalFormat) { 2452 case GL_RED_SNORM: 2453 case GL_R8_SNORM: 2454 case GL_R16_SNORM: 2455 return GL_RED; 2456 case GL_RG_SNORM: 2457 case GL_RG8_SNORM: 2458 case GL_RG16_SNORM: 2459 return GL_RG; 2460 case GL_RGB_SNORM: 2461 case GL_RGB8_SNORM: 2462 case GL_RGB16_SNORM: 2463 return GL_RGB; 2464 case GL_RGBA_SNORM: 2465 case GL_RGBA8_SNORM: 2466 case GL_RGBA16_SNORM: 2467 return GL_RGBA; 2468 case GL_ALPHA_SNORM: 2469 case GL_ALPHA8_SNORM: 2470 case GL_ALPHA16_SNORM: 2471 return GL_ALPHA; 2472 case GL_LUMINANCE_SNORM: 2473 case GL_LUMINANCE8_SNORM: 2474 case GL_LUMINANCE16_SNORM: 2475 return GL_LUMINANCE; 2476 case GL_LUMINANCE_ALPHA_SNORM: 2477 case GL_LUMINANCE8_ALPHA8_SNORM: 2478 case GL_LUMINANCE16_ALPHA16_SNORM: 2479 return GL_LUMINANCE_ALPHA; 2480 case GL_INTENSITY_SNORM: 2481 case GL_INTENSITY8_SNORM: 2482 case GL_INTENSITY16_SNORM: 2483 return GL_INTENSITY; 2484 default: 2485 ; /* fallthrough */ 2486 } 2487 } 2488 2489 if (ctx->Extensions.EXT_texture_sRGB) { 2490 switch (internalFormat) { 2491 case GL_SRGB_EXT: 2492 case GL_SRGB8_EXT: 2493 case GL_COMPRESSED_SRGB_EXT: 2494 return GL_RGB; 2495 case GL_SRGB_ALPHA_EXT: 2496 case GL_SRGB8_ALPHA8_EXT: 2497 case GL_COMPRESSED_SRGB_ALPHA_EXT: 2498 return GL_RGBA; 2499 case GL_SLUMINANCE_ALPHA_EXT: 2500 case GL_SLUMINANCE8_ALPHA8_EXT: 2501 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: 2502 return GL_LUMINANCE_ALPHA; 2503 case GL_SLUMINANCE_EXT: 2504 case GL_SLUMINANCE8_EXT: 2505 case GL_COMPRESSED_SLUMINANCE_EXT: 2506 return GL_LUMINANCE; 2507 default: 2508 ; /* fallthrough */ 2509 } 2510 } 2511 2512 if (ctx->Version >= 30 || 2513 ctx->Extensions.EXT_texture_integer) { 2514 switch (internalFormat) { 2515 case GL_RGBA8UI_EXT: 2516 case GL_RGBA16UI_EXT: 2517 case GL_RGBA32UI_EXT: 2518 case GL_RGBA8I_EXT: 2519 case GL_RGBA16I_EXT: 2520 case GL_RGBA32I_EXT: 2521 return GL_RGBA; 2522 case GL_RGB8UI_EXT: 2523 case GL_RGB16UI_EXT: 2524 case GL_RGB32UI_EXT: 2525 case GL_RGB8I_EXT: 2526 case GL_RGB16I_EXT: 2527 case GL_RGB32I_EXT: 2528 return GL_RGB; 2529 } 2530 } 2531 2532 if (ctx->Extensions.ARB_texture_rgb10_a2ui) { 2533 switch (internalFormat) { 2534 case GL_RGB10_A2UI: 2535 return GL_RGBA; 2536 } 2537 } 2538 2539 if (ctx->Extensions.EXT_texture_integer) { 2540 switch (internalFormat) { 2541 case GL_ALPHA8UI_EXT: 2542 case GL_ALPHA16UI_EXT: 2543 case GL_ALPHA32UI_EXT: 2544 case GL_ALPHA8I_EXT: 2545 case GL_ALPHA16I_EXT: 2546 case GL_ALPHA32I_EXT: 2547 return GL_ALPHA; 2548 case GL_INTENSITY8UI_EXT: 2549 case GL_INTENSITY16UI_EXT: 2550 case GL_INTENSITY32UI_EXT: 2551 case GL_INTENSITY8I_EXT: 2552 case GL_INTENSITY16I_EXT: 2553 case GL_INTENSITY32I_EXT: 2554 return GL_INTENSITY; 2555 case GL_LUMINANCE8UI_EXT: 2556 case GL_LUMINANCE16UI_EXT: 2557 case GL_LUMINANCE32UI_EXT: 2558 case GL_LUMINANCE8I_EXT: 2559 case GL_LUMINANCE16I_EXT: 2560 case GL_LUMINANCE32I_EXT: 2561 return GL_LUMINANCE; 2562 case GL_LUMINANCE_ALPHA8UI_EXT: 2563 case GL_LUMINANCE_ALPHA16UI_EXT: 2564 case GL_LUMINANCE_ALPHA32UI_EXT: 2565 case GL_LUMINANCE_ALPHA8I_EXT: 2566 case GL_LUMINANCE_ALPHA16I_EXT: 2567 case GL_LUMINANCE_ALPHA32I_EXT: 2568 return GL_LUMINANCE_ALPHA; 2569 default: 2570 ; /* fallthrough */ 2571 } 2572 } 2573 2574 if (ctx->Extensions.ARB_texture_rg) { 2575 switch (internalFormat) { 2576 case GL_R16F: 2577 case GL_R32F: 2578 if (!ctx->Extensions.ARB_texture_float) 2579 break; 2580 return GL_RED; 2581 case GL_R8I: 2582 case GL_R8UI: 2583 case GL_R16I: 2584 case GL_R16UI: 2585 case GL_R32I: 2586 case GL_R32UI: 2587 if (ctx->Version < 30 && !ctx->Extensions.EXT_texture_integer) 2588 break; 2589 /* FALLTHROUGH */ 2590 case GL_R8: 2591 case GL_R16: 2592 case GL_RED: 2593 case GL_COMPRESSED_RED: 2594 return GL_RED; 2595 2596 case GL_RG16F: 2597 case GL_RG32F: 2598 if (!ctx->Extensions.ARB_texture_float) 2599 break; 2600 return GL_RG; 2601 case GL_RG8I: 2602 case GL_RG8UI: 2603 case GL_RG16I: 2604 case GL_RG16UI: 2605 case GL_RG32I: 2606 case GL_RG32UI: 2607 if (ctx->Version < 30 && !ctx->Extensions.EXT_texture_integer) 2608 break; 2609 /* FALLTHROUGH */ 2610 case GL_RG: 2611 case GL_RG8: 2612 case GL_RG16: 2613 case GL_COMPRESSED_RG: 2614 return GL_RG; 2615 default: 2616 ; /* fallthrough */ 2617 } 2618 } 2619 2620 if (ctx->Extensions.EXT_texture_shared_exponent) { 2621 switch (internalFormat) { 2622 case GL_RGB9_E5_EXT: 2623 return GL_RGB; 2624 default: 2625 ; /* fallthrough */ 2626 } 2627 } 2628 2629 if (ctx->Extensions.EXT_packed_float) { 2630 switch (internalFormat) { 2631 case GL_R11F_G11F_B10F_EXT: 2632 return GL_RGB; 2633 default: 2634 ; /* fallthrough */ 2635 } 2636 } 2637 2638 if (ctx->Extensions.ARB_depth_buffer_float) { 2639 switch (internalFormat) { 2640 case GL_DEPTH_COMPONENT32F: 2641 return GL_DEPTH_COMPONENT; 2642 case GL_DEPTH32F_STENCIL8: 2643 return GL_DEPTH_STENCIL; 2644 default: 2645 ; /* fallthrough */ 2646 } 2647 } 2648 2649 return -1; /* error */ 2650} 2651 2652/** 2653 * Returns the effective internal format from a texture format and type. 2654 * This is used by texture image operations internally for validation, when 2655 * the specified internal format is a base (unsized) format. 2656 * 2657 * This method will only return a valid effective internal format if the 2658 * combination of format, type and internal format in base form, is acceptable. 2659 * 2660 * If a single sized internal format is defined in the spec (OpenGL-ES 3.0.4) or 2661 * in extensions, to unambiguously correspond to the given base format, then 2662 * that internal format is returned as the effective. Otherwise, if the 2663 * combination is accepted but a single effective format is not defined, the 2664 * passed base format will be returned instead. 2665 * 2666 * \param format the texture format 2667 * \param type the texture type 2668 */ 2669static GLenum 2670_mesa_es3_effective_internal_format_for_format_and_type(GLenum format, 2671 GLenum type) 2672{ 2673 switch (type) { 2674 case GL_UNSIGNED_BYTE: 2675 switch (format) { 2676 case GL_RGBA: 2677 return GL_RGBA8; 2678 case GL_RGB: 2679 return GL_RGB8; 2680 case GL_RG: 2681 return GL_RG8; 2682 case GL_RED: 2683 return GL_R8; 2684 /* Although LUMINANCE_ALPHA, LUMINANCE and ALPHA appear in table 3.12, 2685 * (section 3.8 Texturing, page 128 of the OpenGL-ES 3.0.4) as effective 2686 * internal formats, they do not correspond to GL constants, so the base 2687 * format is returned instead. 2688 */ 2689 case GL_BGRA_EXT: 2690 case GL_LUMINANCE_ALPHA: 2691 case GL_LUMINANCE: 2692 case GL_ALPHA: 2693 return format; 2694 } 2695 break; 2696 2697 case GL_UNSIGNED_SHORT_4_4_4_4: 2698 if (format == GL_RGBA) 2699 return GL_RGBA4; 2700 break; 2701 2702 case GL_UNSIGNED_SHORT_5_5_5_1: 2703 if (format == GL_RGBA) 2704 return GL_RGB5_A1; 2705 break; 2706 2707 case GL_UNSIGNED_SHORT_5_6_5: 2708 if (format == GL_RGB) 2709 return GL_RGB565; 2710 break; 2711 2712 /* OES_packed_depth_stencil */ 2713 case GL_UNSIGNED_INT_24_8: 2714 if (format == GL_DEPTH_STENCIL) 2715 return GL_DEPTH24_STENCIL8; 2716 break; 2717 2718 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 2719 if (format == GL_DEPTH_STENCIL) 2720 return GL_DEPTH32F_STENCIL8; 2721 break; 2722 2723 case GL_UNSIGNED_SHORT: 2724 if (format == GL_DEPTH_COMPONENT) 2725 return GL_DEPTH_COMPONENT16; 2726 break; 2727 2728 case GL_UNSIGNED_INT: 2729 /* It can be DEPTH_COMPONENT16 or DEPTH_COMPONENT24, so just return 2730 * the format. 2731 */ 2732 if (format == GL_DEPTH_COMPONENT) 2733 return format; 2734 break; 2735 2736 /* OES_texture_float and OES_texture_half_float */ 2737 case GL_FLOAT: 2738 if (format == GL_DEPTH_COMPONENT) 2739 return GL_DEPTH_COMPONENT32F; 2740 /* fall through */ 2741 case GL_HALF_FLOAT_OES: 2742 switch (format) { 2743 case GL_RGBA: 2744 case GL_RGB: 2745 case GL_LUMINANCE_ALPHA: 2746 case GL_LUMINANCE: 2747 case GL_ALPHA: 2748 case GL_RED: 2749 case GL_RG: 2750 return format; 2751 } 2752 break; 2753 case GL_HALF_FLOAT: 2754 switch (format) { 2755 case GL_RG: 2756 case GL_RED: 2757 return format; 2758 } 2759 break; 2760 2761 /* GL_EXT_texture_type_2_10_10_10_REV */ 2762 case GL_UNSIGNED_INT_2_10_10_10_REV: 2763 switch (format) { 2764 case GL_RGBA: 2765 case GL_RGB: 2766 return format; 2767 } 2768 break; 2769 2770 default: 2771 /* fall through and return NONE */ 2772 break; 2773 } 2774 2775 return GL_NONE; 2776} 2777 2778/** 2779 * Do error checking of format/type combinations for OpenGL ES 3 2780 * glTex[Sub]Image. 2781 * \return error code, or GL_NO_ERROR. 2782 */ 2783GLenum 2784_mesa_es3_error_check_format_and_type(const struct gl_context *ctx, 2785 GLenum format, GLenum type, 2786 GLenum internalFormat) 2787{ 2788 /* If internalFormat is an unsized format, then the effective internal 2789 * format derived from format and type should be used instead. Page 127, 2790 * section "3.8 Texturing" of the GLES 3.0.4 spec states: 2791 * 2792 * "if internalformat is a base internal format, the effective 2793 * internal format is a sized internal format that is derived 2794 * from the format and type for internal use by the GL. 2795 * Table 3.12 specifies the mapping of format and type to effective 2796 * internal formats. The effective internal format is used by the GL 2797 * for purposes such as texture completeness or type checks for 2798 * CopyTex* commands. In these cases, the GL is required to operate 2799 * as if the effective internal format was used as the internalformat 2800 * when specifying the texture data." 2801 */ 2802 if (_mesa_is_enum_format_unsized(internalFormat)) { 2803 GLenum effectiveInternalFormat = 2804 _mesa_es3_effective_internal_format_for_format_and_type(format, type); 2805 2806 if (effectiveInternalFormat == GL_NONE) 2807 return GL_INVALID_OPERATION; 2808 2809 GLenum baseInternalFormat; 2810 if (internalFormat == GL_BGRA_EXT) { 2811 /* Unfortunately, _mesa_base_tex_format returns a base format of 2812 * GL_RGBA for GL_BGRA_EXT. This makes perfect sense if you're 2813 * asking the question, "what channels does this format have?" 2814 * However, if we're trying to determine if two internal formats 2815 * match in the ES3 sense, we actually want GL_BGRA. 2816 */ 2817 baseInternalFormat = GL_BGRA_EXT; 2818 } else { 2819 baseInternalFormat = 2820 _mesa_base_tex_format(ctx, effectiveInternalFormat); 2821 } 2822 2823 if (internalFormat != baseInternalFormat) 2824 return GL_INVALID_OPERATION; 2825 2826 internalFormat = effectiveInternalFormat; 2827 } 2828 2829 switch (format) { 2830 case GL_BGRA_EXT: 2831 if (type != GL_UNSIGNED_BYTE || internalFormat != GL_BGRA) 2832 return GL_INVALID_OPERATION; 2833 break; 2834 2835 case GL_RGBA: 2836 switch (type) { 2837 case GL_UNSIGNED_BYTE: 2838 switch (internalFormat) { 2839 case GL_RGBA: 2840 case GL_RGBA8: 2841 case GL_RGB5_A1: 2842 case GL_RGBA4: 2843 case GL_SRGB8_ALPHA8_EXT: 2844 break; 2845 default: 2846 return GL_INVALID_OPERATION; 2847 } 2848 break; 2849 2850 case GL_BYTE: 2851 if (internalFormat != GL_RGBA8_SNORM) 2852 return GL_INVALID_OPERATION; 2853 break; 2854 2855 case GL_UNSIGNED_SHORT_4_4_4_4: 2856 switch (internalFormat) { 2857 case GL_RGBA: 2858 case GL_RGBA4: 2859 break; 2860 default: 2861 return GL_INVALID_OPERATION; 2862 } 2863 break; 2864 2865 case GL_UNSIGNED_SHORT_5_5_5_1: 2866 switch (internalFormat) { 2867 case GL_RGBA: 2868 case GL_RGB5_A1: 2869 break; 2870 default: 2871 return GL_INVALID_OPERATION; 2872 } 2873 break; 2874 2875 case GL_UNSIGNED_INT_2_10_10_10_REV: 2876 switch (internalFormat) { 2877 case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */ 2878 case GL_RGB10_A2: 2879 case GL_RGB5_A1: 2880 break; 2881 default: 2882 return GL_INVALID_OPERATION; 2883 } 2884 break; 2885 2886 case GL_HALF_FLOAT: 2887 if (internalFormat != GL_RGBA16F) 2888 return GL_INVALID_OPERATION; 2889 break; 2890 2891 case GL_FLOAT: 2892 switch (internalFormat) { 2893 case GL_RGBA16F: 2894 case GL_RGBA32F: 2895 break; 2896 case GL_RGBA: 2897 if (ctx->Extensions.OES_texture_float && internalFormat == format) 2898 break; 2899 default: 2900 return GL_INVALID_OPERATION; 2901 } 2902 break; 2903 2904 case GL_HALF_FLOAT_OES: 2905 if (ctx->Extensions.OES_texture_half_float && internalFormat == format) 2906 break; 2907 default: 2908 return GL_INVALID_OPERATION; 2909 } 2910 break; 2911 2912 case GL_RGBA_INTEGER: 2913 switch (type) { 2914 case GL_UNSIGNED_BYTE: 2915 if (internalFormat != GL_RGBA8UI) 2916 return GL_INVALID_OPERATION; 2917 break; 2918 2919 case GL_BYTE: 2920 if (internalFormat != GL_RGBA8I) 2921 return GL_INVALID_OPERATION; 2922 break; 2923 2924 case GL_UNSIGNED_SHORT: 2925 if (internalFormat != GL_RGBA16UI) 2926 return GL_INVALID_OPERATION; 2927 break; 2928 2929 case GL_SHORT: 2930 if (internalFormat != GL_RGBA16I) 2931 return GL_INVALID_OPERATION; 2932 break; 2933 2934 case GL_UNSIGNED_INT: 2935 if (internalFormat != GL_RGBA32UI) 2936 return GL_INVALID_OPERATION; 2937 break; 2938 2939 case GL_INT: 2940 if (internalFormat != GL_RGBA32I) 2941 return GL_INVALID_OPERATION; 2942 break; 2943 2944 case GL_UNSIGNED_INT_2_10_10_10_REV: 2945 if (internalFormat != GL_RGB10_A2UI) 2946 return GL_INVALID_OPERATION; 2947 break; 2948 2949 default: 2950 return GL_INVALID_OPERATION; 2951 } 2952 break; 2953 2954 case GL_RGB: 2955 switch (type) { 2956 case GL_UNSIGNED_BYTE: 2957 switch (internalFormat) { 2958 case GL_RGB: 2959 case GL_RGB8: 2960 case GL_RGB565: 2961 case GL_SRGB8: 2962 break; 2963 default: 2964 return GL_INVALID_OPERATION; 2965 } 2966 break; 2967 2968 case GL_BYTE: 2969 if (internalFormat != GL_RGB8_SNORM) 2970 return GL_INVALID_OPERATION; 2971 break; 2972 2973 case GL_UNSIGNED_SHORT_5_6_5: 2974 switch (internalFormat) { 2975 case GL_RGB: 2976 case GL_RGB565: 2977 break; 2978 default: 2979 return GL_INVALID_OPERATION; 2980 } 2981 break; 2982 2983 case GL_UNSIGNED_INT_10F_11F_11F_REV: 2984 if (internalFormat != GL_R11F_G11F_B10F) 2985 return GL_INVALID_OPERATION; 2986 break; 2987 2988 case GL_UNSIGNED_INT_5_9_9_9_REV: 2989 if (internalFormat != GL_RGB9_E5) 2990 return GL_INVALID_OPERATION; 2991 break; 2992 2993 case GL_HALF_FLOAT: 2994 switch (internalFormat) { 2995 case GL_RGB16F: 2996 case GL_R11F_G11F_B10F: 2997 case GL_RGB9_E5: 2998 break; 2999 default: 3000 return GL_INVALID_OPERATION; 3001 } 3002 break; 3003 3004 case GL_FLOAT: 3005 switch (internalFormat) { 3006 case GL_RGB16F: 3007 case GL_RGB32F: 3008 case GL_R11F_G11F_B10F: 3009 case GL_RGB9_E5: 3010 break; 3011 case GL_RGB: 3012 if (ctx->Extensions.OES_texture_float && internalFormat == format) 3013 break; 3014 default: 3015 return GL_INVALID_OPERATION; 3016 } 3017 break; 3018 3019 case GL_HALF_FLOAT_OES: 3020 if (!ctx->Extensions.OES_texture_half_float || internalFormat != format) 3021 return GL_INVALID_OPERATION; 3022 break; 3023 3024 case GL_UNSIGNED_INT_2_10_10_10_REV: 3025 switch (internalFormat) { 3026 case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */ 3027 break; 3028 default: 3029 return GL_INVALID_OPERATION; 3030 } 3031 break; 3032 3033 default: 3034 return GL_INVALID_OPERATION; 3035 } 3036 break; 3037 3038 case GL_RGB_INTEGER: 3039 switch (type) { 3040 case GL_UNSIGNED_BYTE: 3041 if (internalFormat != GL_RGB8UI) 3042 return GL_INVALID_OPERATION; 3043 break; 3044 3045 case GL_BYTE: 3046 if (internalFormat != GL_RGB8I) 3047 return GL_INVALID_OPERATION; 3048 break; 3049 3050 case GL_UNSIGNED_SHORT: 3051 if (internalFormat != GL_RGB16UI) 3052 return GL_INVALID_OPERATION; 3053 break; 3054 3055 case GL_SHORT: 3056 if (internalFormat != GL_RGB16I) 3057 return GL_INVALID_OPERATION; 3058 break; 3059 3060 case GL_UNSIGNED_INT: 3061 if (internalFormat != GL_RGB32UI) 3062 return GL_INVALID_OPERATION; 3063 break; 3064 3065 case GL_INT: 3066 if (internalFormat != GL_RGB32I) 3067 return GL_INVALID_OPERATION; 3068 break; 3069 3070 default: 3071 return GL_INVALID_OPERATION; 3072 } 3073 break; 3074 3075 case GL_RG: 3076 switch (type) { 3077 case GL_UNSIGNED_BYTE: 3078 if (internalFormat != GL_RG8) 3079 return GL_INVALID_OPERATION; 3080 break; 3081 3082 case GL_BYTE: 3083 if (internalFormat != GL_RG8_SNORM) 3084 return GL_INVALID_OPERATION; 3085 break; 3086 3087 case GL_HALF_FLOAT: 3088 case GL_HALF_FLOAT_OES: 3089 switch (internalFormat) { 3090 case GL_RG16F: 3091 break; 3092 case GL_RG: 3093 if (ctx->Extensions.ARB_texture_rg && 3094 ctx->Extensions.OES_texture_half_float) 3095 break; 3096 /* fallthrough */ 3097 default: 3098 return GL_INVALID_OPERATION; 3099 } 3100 break; 3101 3102 case GL_FLOAT: 3103 switch (internalFormat) { 3104 case GL_RG16F: 3105 case GL_RG32F: 3106 break; 3107 case GL_RG: 3108 if (ctx->Extensions.ARB_texture_rg && 3109 ctx->Extensions.OES_texture_float) 3110 break; 3111 /* fallthrough */ 3112 default: 3113 return GL_INVALID_OPERATION; 3114 } 3115 break; 3116 3117 default: 3118 return GL_INVALID_OPERATION; 3119 } 3120 break; 3121 3122 case GL_RG_INTEGER: 3123 switch (type) { 3124 case GL_UNSIGNED_BYTE: 3125 if (internalFormat != GL_RG8UI) 3126 return GL_INVALID_OPERATION; 3127 break; 3128 3129 case GL_BYTE: 3130 if (internalFormat != GL_RG8I) 3131 return GL_INVALID_OPERATION; 3132 break; 3133 3134 case GL_UNSIGNED_SHORT: 3135 if (internalFormat != GL_RG16UI) 3136 return GL_INVALID_OPERATION; 3137 break; 3138 3139 case GL_SHORT: 3140 if (internalFormat != GL_RG16I) 3141 return GL_INVALID_OPERATION; 3142 break; 3143 3144 case GL_UNSIGNED_INT: 3145 if (internalFormat != GL_RG32UI) 3146 return GL_INVALID_OPERATION; 3147 break; 3148 3149 case GL_INT: 3150 if (internalFormat != GL_RG32I) 3151 return GL_INVALID_OPERATION; 3152 break; 3153 3154 default: 3155 return GL_INVALID_OPERATION; 3156 } 3157 break; 3158 3159 case GL_RED: 3160 switch (type) { 3161 case GL_UNSIGNED_BYTE: 3162 if (internalFormat != GL_R8) 3163 return GL_INVALID_OPERATION; 3164 break; 3165 3166 case GL_BYTE: 3167 if (internalFormat != GL_R8_SNORM) 3168 return GL_INVALID_OPERATION; 3169 break; 3170 3171 case GL_HALF_FLOAT: 3172 case GL_HALF_FLOAT_OES: 3173 switch (internalFormat) { 3174 case GL_R16F: 3175 break; 3176 case GL_RG: 3177 case GL_RED: 3178 if (ctx->Extensions.ARB_texture_rg && 3179 ctx->Extensions.OES_texture_half_float) 3180 break; 3181 /* fallthrough */ 3182 default: 3183 return GL_INVALID_OPERATION; 3184 } 3185 break; 3186 3187 case GL_FLOAT: 3188 switch (internalFormat) { 3189 case GL_R16F: 3190 case GL_R32F: 3191 break; 3192 case GL_RED: 3193 if (ctx->Extensions.ARB_texture_rg && 3194 ctx->Extensions.OES_texture_float) 3195 break; 3196 /* fallthrough */ 3197 default: 3198 return GL_INVALID_OPERATION; 3199 } 3200 break; 3201 3202 default: 3203 return GL_INVALID_OPERATION; 3204 } 3205 break; 3206 3207 case GL_RED_INTEGER: 3208 switch (type) { 3209 case GL_UNSIGNED_BYTE: 3210 if (internalFormat != GL_R8UI) 3211 return GL_INVALID_OPERATION; 3212 break; 3213 3214 case GL_BYTE: 3215 if (internalFormat != GL_R8I) 3216 return GL_INVALID_OPERATION; 3217 break; 3218 3219 case GL_UNSIGNED_SHORT: 3220 if (internalFormat != GL_R16UI) 3221 return GL_INVALID_OPERATION; 3222 break; 3223 3224 case GL_SHORT: 3225 if (internalFormat != GL_R16I) 3226 return GL_INVALID_OPERATION; 3227 break; 3228 3229 case GL_UNSIGNED_INT: 3230 if (internalFormat != GL_R32UI) 3231 return GL_INVALID_OPERATION; 3232 break; 3233 3234 case GL_INT: 3235 if (internalFormat != GL_R32I) 3236 return GL_INVALID_OPERATION; 3237 break; 3238 3239 default: 3240 return GL_INVALID_OPERATION; 3241 } 3242 break; 3243 3244 case GL_DEPTH_COMPONENT: 3245 switch (type) { 3246 case GL_UNSIGNED_SHORT: 3247 if (internalFormat != GL_DEPTH_COMPONENT 3248 && internalFormat != GL_DEPTH_COMPONENT16) 3249 return GL_INVALID_OPERATION; 3250 break; 3251 3252 case GL_UNSIGNED_INT: 3253 switch (internalFormat) { 3254 case GL_DEPTH_COMPONENT: 3255 case GL_DEPTH_COMPONENT16: 3256 case GL_DEPTH_COMPONENT24: 3257 break; 3258 default: 3259 return GL_INVALID_OPERATION; 3260 } 3261 break; 3262 3263 case GL_FLOAT: 3264 if (internalFormat != GL_DEPTH_COMPONENT32F) 3265 return GL_INVALID_OPERATION; 3266 break; 3267 3268 default: 3269 return GL_INVALID_OPERATION; 3270 } 3271 break; 3272 3273 case GL_DEPTH_STENCIL: 3274 switch (type) { 3275 case GL_UNSIGNED_INT_24_8: 3276 if (internalFormat != GL_DEPTH_STENCIL 3277 && internalFormat != GL_DEPTH24_STENCIL8) 3278 return GL_INVALID_OPERATION; 3279 break; 3280 3281 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 3282 if (internalFormat != GL_DEPTH32F_STENCIL8) 3283 return GL_INVALID_OPERATION; 3284 break; 3285 3286 default: 3287 return GL_INVALID_OPERATION; 3288 } 3289 break; 3290 3291 case GL_STENCIL_INDEX: 3292 if (!_mesa_has_OES_texture_stencil8(ctx) || 3293 type != GL_UNSIGNED_BYTE || 3294 internalFormat != GL_STENCIL_INDEX8) { 3295 return GL_INVALID_OPERATION; 3296 } 3297 break; 3298 3299 case GL_ALPHA: 3300 case GL_LUMINANCE: 3301 case GL_LUMINANCE_ALPHA: 3302 switch (type) { 3303 case GL_FLOAT: 3304 if (ctx->Extensions.OES_texture_float && internalFormat == format) 3305 break; 3306 case GL_HALF_FLOAT_OES: 3307 if (ctx->Extensions.OES_texture_half_float && internalFormat == format) 3308 break; 3309 default: 3310 if (type != GL_UNSIGNED_BYTE || format != internalFormat) 3311 return GL_INVALID_OPERATION; 3312 } 3313 } 3314 3315 return GL_NO_ERROR; 3316} 3317 3318static void 3319set_swizzle(uint8_t *swizzle, int x, int y, int z, int w) 3320{ 3321 swizzle[MESA_FORMAT_SWIZZLE_X] = x; 3322 swizzle[MESA_FORMAT_SWIZZLE_Y] = y; 3323 swizzle[MESA_FORMAT_SWIZZLE_Z] = z; 3324 swizzle[MESA_FORMAT_SWIZZLE_W] = w; 3325} 3326 3327static bool 3328get_swizzle_from_gl_format(GLenum format, uint8_t *swizzle) 3329{ 3330 switch (format) { 3331 case GL_RGBA: 3332 case GL_RGBA_INTEGER_EXT: 3333 set_swizzle(swizzle, 0, 1, 2, 3); 3334 return true; 3335 case GL_BGRA: 3336 case GL_BGRA_INTEGER_EXT: 3337 set_swizzle(swizzle, 2, 1, 0, 3); 3338 return true; 3339 case GL_ABGR_EXT: 3340 set_swizzle(swizzle, 3, 2, 1, 0); 3341 return true; 3342 case GL_RGB: 3343 case GL_RGB_INTEGER_EXT: 3344 set_swizzle(swizzle, 0, 1, 2, 5); 3345 return true; 3346 case GL_BGR: 3347 case GL_BGR_INTEGER_EXT: 3348 set_swizzle(swizzle, 2, 1, 0, 5); 3349 return true; 3350 case GL_LUMINANCE_ALPHA: 3351 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 3352 set_swizzle(swizzle, 0, 0, 0, 1); 3353 return true; 3354 case GL_RG: 3355 case GL_RG_INTEGER: 3356 set_swizzle(swizzle, 0, 1, 4, 5); 3357 return true; 3358 case GL_RED: 3359 case GL_RED_INTEGER_EXT: 3360 set_swizzle(swizzle, 0, 4, 4, 5); 3361 return true; 3362 case GL_GREEN: 3363 case GL_GREEN_INTEGER_EXT: 3364 set_swizzle(swizzle, 4, 0, 4, 5); 3365 return true; 3366 case GL_BLUE: 3367 case GL_BLUE_INTEGER_EXT: 3368 set_swizzle(swizzle, 4, 4, 0, 5); 3369 return true; 3370 case GL_ALPHA: 3371 case GL_ALPHA_INTEGER_EXT: 3372 set_swizzle(swizzle, 4, 4, 4, 0); 3373 return true; 3374 case GL_LUMINANCE: 3375 case GL_LUMINANCE_INTEGER_EXT: 3376 set_swizzle(swizzle, 0, 0, 0, 5); 3377 return true; 3378 case GL_INTENSITY: 3379 set_swizzle(swizzle, 0, 0, 0, 0); 3380 return true; 3381 default: 3382 return false; 3383 } 3384} 3385 3386/** 3387* Take an OpenGL format (GL_RGB, GL_RGBA, etc), OpenGL data type (GL_INT, 3388* GL_FOAT, etc) and return a matching mesa_array_format or a mesa_format 3389* otherwise (for non-array formats). 3390* 3391* This function will typically be used to compute a mesa format from a GL type 3392* so we can then call _mesa_format_convert. This function does 3393* not consider byte swapping, so it returns types assuming that no byte 3394* swapping is involved. If byte swapping is involved then clients are supposed 3395* to handle that on their side before calling _mesa_format_convert. 3396* 3397* This function returns an uint32_t that can pack a mesa_format or a 3398* mesa_array_format. Clients must check the mesa array format bit 3399* (MESA_ARRAY_FORMAT_BIT) on the return value to know if the returned 3400* format is a mesa_array_format or a mesa_format. 3401*/ 3402uint32_t 3403_mesa_format_from_format_and_type(GLenum format, GLenum type) 3404{ 3405 bool is_array_format = true; 3406 uint8_t swizzle[4]; 3407 bool normalized = false, is_float = false, is_signed = false; 3408 int num_channels = 0, type_size = 0; 3409 3410 /* Extract array format type information from the OpenGL data type */ 3411 switch (type) { 3412 case GL_UNSIGNED_BYTE: 3413 type_size = 1; 3414 break; 3415 case GL_BYTE: 3416 type_size = 1; 3417 is_signed = true; 3418 break; 3419 case GL_UNSIGNED_SHORT: 3420 type_size = 2; 3421 break; 3422 case GL_SHORT: 3423 type_size = 2; 3424 is_signed = true; 3425 break; 3426 case GL_UNSIGNED_INT: 3427 type_size = 4; 3428 break; 3429 case GL_INT: 3430 type_size = 4; 3431 is_signed = true; 3432 break; 3433 case GL_HALF_FLOAT: 3434 case GL_HALF_FLOAT_OES: 3435 type_size = 2; 3436 is_signed = true; 3437 is_float = true; 3438 break; 3439 case GL_FLOAT: 3440 type_size = 4; 3441 is_signed = true; 3442 is_float = true; 3443 break; 3444 default: 3445 is_array_format = false; 3446 break; 3447 } 3448 3449 /* Extract array format swizzle information from the OpenGL format */ 3450 if (is_array_format) 3451 is_array_format = get_swizzle_from_gl_format(format, swizzle); 3452 3453 /* If this is an array format type after checking data type and format, 3454 * create the array format 3455 */ 3456 if (is_array_format) { 3457 normalized = !_mesa_is_enum_format_integer(format); 3458 num_channels = _mesa_components_in_format(format); 3459 3460 return MESA_ARRAY_FORMAT(type_size, is_signed, is_float, 3461 normalized, num_channels, 3462 swizzle[0], swizzle[1], swizzle[2], swizzle[3]); 3463 } 3464 3465 /* Otherwise this is not an array format, so return the mesa_format 3466 * matching the OpenGL format and data type 3467 */ 3468 switch (type) { 3469 case GL_UNSIGNED_SHORT_5_6_5: 3470 if (format == GL_RGB) 3471 return MESA_FORMAT_B5G6R5_UNORM; 3472 else if (format == GL_BGR) 3473 return MESA_FORMAT_R5G6B5_UNORM; 3474 else if (format == GL_RGB_INTEGER) 3475 return MESA_FORMAT_B5G6R5_UINT; 3476 break; 3477 case GL_UNSIGNED_SHORT_5_6_5_REV: 3478 if (format == GL_RGB) 3479 return MESA_FORMAT_R5G6B5_UNORM; 3480 else if (format == GL_BGR) 3481 return MESA_FORMAT_B5G6R5_UNORM; 3482 else if (format == GL_RGB_INTEGER) 3483 return MESA_FORMAT_R5G6B5_UINT; 3484 break; 3485 case GL_UNSIGNED_SHORT_4_4_4_4: 3486 if (format == GL_RGBA) 3487 return MESA_FORMAT_A4B4G4R4_UNORM; 3488 else if (format == GL_BGRA) 3489 return MESA_FORMAT_A4R4G4B4_UNORM; 3490 else if (format == GL_ABGR_EXT) 3491 return MESA_FORMAT_R4G4B4A4_UNORM; 3492 else if (format == GL_RGBA_INTEGER) 3493 return MESA_FORMAT_A4B4G4R4_UINT; 3494 else if (format == GL_BGRA_INTEGER) 3495 return MESA_FORMAT_A4R4G4B4_UINT; 3496 break; 3497 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 3498 if (format == GL_RGBA) 3499 return MESA_FORMAT_R4G4B4A4_UNORM; 3500 else if (format == GL_BGRA) 3501 return MESA_FORMAT_B4G4R4A4_UNORM; 3502 else if (format == GL_ABGR_EXT) 3503 return MESA_FORMAT_A4B4G4R4_UNORM; 3504 else if (format == GL_RGBA_INTEGER) 3505 return MESA_FORMAT_R4G4B4A4_UINT; 3506 else if (format == GL_BGRA_INTEGER) 3507 return MESA_FORMAT_B4G4R4A4_UINT; 3508 break; 3509 case GL_UNSIGNED_SHORT_5_5_5_1: 3510 if (format == GL_RGBA) 3511 return MESA_FORMAT_A1B5G5R5_UNORM; 3512 else if (format == GL_BGRA) 3513 return MESA_FORMAT_A1R5G5B5_UNORM; 3514 else if (format == GL_RGBA_INTEGER) 3515 return MESA_FORMAT_A1B5G5R5_UINT; 3516 else if (format == GL_BGRA_INTEGER) 3517 return MESA_FORMAT_A1R5G5B5_UINT; 3518 break; 3519 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 3520 if (format == GL_RGBA) 3521 return MESA_FORMAT_R5G5B5A1_UNORM; 3522 else if (format == GL_BGRA) 3523 return MESA_FORMAT_B5G5R5A1_UNORM; 3524 else if (format == GL_RGBA_INTEGER) 3525 return MESA_FORMAT_R5G5B5A1_UINT; 3526 else if (format == GL_BGRA_INTEGER) 3527 return MESA_FORMAT_B5G5R5A1_UINT; 3528 break; 3529 case GL_UNSIGNED_BYTE_3_3_2: 3530 if (format == GL_RGB) 3531 return MESA_FORMAT_B2G3R3_UNORM; 3532 else if (format == GL_RGB_INTEGER) 3533 return MESA_FORMAT_B2G3R3_UINT; 3534 break; 3535 case GL_UNSIGNED_BYTE_2_3_3_REV: 3536 if (format == GL_RGB) 3537 return MESA_FORMAT_R3G3B2_UNORM; 3538 else if (format == GL_RGB_INTEGER) 3539 return MESA_FORMAT_R3G3B2_UINT; 3540 break; 3541 case GL_UNSIGNED_INT_5_9_9_9_REV: 3542 if (format == GL_RGB) 3543 return MESA_FORMAT_R9G9B9E5_FLOAT; 3544 break; 3545 case GL_UNSIGNED_INT_10_10_10_2: 3546 if (format == GL_RGBA) 3547 return MESA_FORMAT_A2B10G10R10_UNORM; 3548 else if (format == GL_RGBA_INTEGER) 3549 return MESA_FORMAT_A2B10G10R10_UINT; 3550 else if (format == GL_BGRA) 3551 return MESA_FORMAT_A2R10G10B10_UNORM; 3552 else if (format == GL_BGRA_INTEGER) 3553 return MESA_FORMAT_A2R10G10B10_UINT; 3554 break; 3555 case GL_UNSIGNED_INT_2_10_10_10_REV: 3556 if (format == GL_RGB) 3557 return MESA_FORMAT_R10G10B10X2_UNORM; 3558 if (format == GL_RGBA) 3559 return MESA_FORMAT_R10G10B10A2_UNORM; 3560 else if (format == GL_RGBA_INTEGER) 3561 return MESA_FORMAT_R10G10B10A2_UINT; 3562 else if (format == GL_BGRA) 3563 return MESA_FORMAT_B10G10R10A2_UNORM; 3564 else if (format == GL_BGRA_INTEGER) 3565 return MESA_FORMAT_B10G10R10A2_UINT; 3566 break; 3567 case GL_UNSIGNED_INT_8_8_8_8: 3568 if (format == GL_RGBA) 3569 return MESA_FORMAT_A8B8G8R8_UNORM; 3570 else if (format == GL_BGRA) 3571 return MESA_FORMAT_A8R8G8B8_UNORM; 3572 else if (format == GL_ABGR_EXT) 3573 return MESA_FORMAT_R8G8B8A8_UNORM; 3574 else if (format == GL_RGBA_INTEGER) 3575 return MESA_FORMAT_A8B8G8R8_UINT; 3576 else if (format == GL_BGRA_INTEGER) 3577 return MESA_FORMAT_A8R8G8B8_UINT; 3578 break; 3579 case GL_UNSIGNED_INT_8_8_8_8_REV: 3580 if (format == GL_RGBA) 3581 return MESA_FORMAT_R8G8B8A8_UNORM; 3582 else if (format == GL_BGRA) 3583 return MESA_FORMAT_B8G8R8A8_UNORM; 3584 else if (format == GL_ABGR_EXT) 3585 return MESA_FORMAT_A8B8G8R8_UNORM; 3586 else if (format == GL_RGBA_INTEGER) 3587 return MESA_FORMAT_R8G8B8A8_UINT; 3588 else if (format == GL_BGRA_INTEGER) 3589 return MESA_FORMAT_B8G8R8A8_UINT; 3590 break; 3591 case GL_UNSIGNED_SHORT_8_8_MESA: 3592 if (format == GL_YCBCR_MESA) 3593 return MESA_FORMAT_YCBCR; 3594 break; 3595 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 3596 if (format == GL_YCBCR_MESA) 3597 return MESA_FORMAT_YCBCR_REV; 3598 break; 3599 case GL_UNSIGNED_INT_10F_11F_11F_REV: 3600 if (format == GL_RGB) 3601 return MESA_FORMAT_R11G11B10_FLOAT; 3602 break; 3603 case GL_FLOAT: 3604 if (format == GL_DEPTH_COMPONENT) 3605 return MESA_FORMAT_Z_FLOAT32; 3606 break; 3607 case GL_UNSIGNED_INT: 3608 if (format == GL_DEPTH_COMPONENT) 3609 return MESA_FORMAT_Z_UNORM32; 3610 break; 3611 case GL_UNSIGNED_SHORT: 3612 if (format == GL_DEPTH_COMPONENT) 3613 return MESA_FORMAT_Z_UNORM16; 3614 break; 3615 case GL_UNSIGNED_INT_24_8: 3616 if (format == GL_DEPTH_STENCIL) 3617 return MESA_FORMAT_Z24_UNORM_S8_UINT; 3618 break; 3619 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 3620 if (format == GL_DEPTH_STENCIL) 3621 return MESA_FORMAT_Z32_FLOAT_S8X24_UINT; 3622 break; 3623 default: 3624 break; 3625 } 3626 3627 /* If we got here it means that we could not find a Mesa format that 3628 * matches the GL format/type provided. We may need to add a new Mesa 3629 * format in that case. 3630 */ 3631 unreachable("Unsupported format"); 3632} 3633 3634/** 3635 * Returns true if \p internal_format is a sized internal format that 3636 * is marked "Color Renderable" in Table 8.10 of the ES 3.2 specification. 3637 */ 3638bool 3639_mesa_is_es3_color_renderable(GLenum internal_format) 3640{ 3641 switch (internal_format) { 3642 case GL_R8: 3643 case GL_RG8: 3644 case GL_RGB8: 3645 case GL_RGB565: 3646 case GL_RGBA4: 3647 case GL_RGB5_A1: 3648 case GL_RGBA8: 3649 case GL_RGB10_A2: 3650 case GL_RGB10_A2UI: 3651 case GL_SRGB8_ALPHA8: 3652 case GL_R16F: 3653 case GL_RG16F: 3654 case GL_RGBA16F: 3655 case GL_R32F: 3656 case GL_RG32F: 3657 case GL_RGBA32F: 3658 case GL_R11F_G11F_B10F: 3659 case GL_R8I: 3660 case GL_R8UI: 3661 case GL_R16I: 3662 case GL_R16UI: 3663 case GL_R32I: 3664 case GL_R32UI: 3665 case GL_RG8I: 3666 case GL_RG8UI: 3667 case GL_RG16I: 3668 case GL_RG16UI: 3669 case GL_RG32I: 3670 case GL_RG32UI: 3671 case GL_RGBA8I: 3672 case GL_RGBA8UI: 3673 case GL_RGBA16I: 3674 case GL_RGBA16UI: 3675 case GL_RGBA32I: 3676 case GL_RGBA32UI: 3677 return true; 3678 default: 3679 return false; 3680 } 3681} 3682 3683/** 3684 * Returns true if \p internal_format is a sized internal format that 3685 * is marked "Texture Filterable" in Table 8.10 of the ES 3.2 specification. 3686 */ 3687bool 3688_mesa_is_es3_texture_filterable(const struct gl_context *ctx, 3689 GLenum internal_format) 3690{ 3691 switch (internal_format) { 3692 case GL_R8: 3693 case GL_R8_SNORM: 3694 case GL_RG8: 3695 case GL_RG8_SNORM: 3696 case GL_RGB8: 3697 case GL_RGB8_SNORM: 3698 case GL_RGB565: 3699 case GL_RGBA4: 3700 case GL_RGB5_A1: 3701 case GL_RGBA8: 3702 case GL_RGBA8_SNORM: 3703 case GL_RGB10_A2: 3704 case GL_SRGB8: 3705 case GL_SRGB8_ALPHA8: 3706 case GL_R16F: 3707 case GL_RG16F: 3708 case GL_RGB16F: 3709 case GL_RGBA16F: 3710 case GL_R11F_G11F_B10F: 3711 case GL_RGB9_E5: 3712 return true; 3713 case GL_R32F: 3714 case GL_RG32F: 3715 case GL_RGB32F: 3716 case GL_RGBA32F: 3717 /* The OES_texture_float_linear spec says: 3718 * 3719 * "When implemented against OpenGL ES 3.0 or later versions, sized 3720 * 32-bit floating-point formats become texture-filterable. This 3721 * should be noted by, for example, checking the ``TF'' column of 3722 * table 8.13 in the ES 3.1 Specification (``Correspondence of sized 3723 * internal formats to base internal formats ... and use cases ...'') 3724 * for the R32F, RG32F, RGB32F, and RGBA32F formats." 3725 */ 3726 return ctx->Extensions.OES_texture_float_linear; 3727 default: 3728 return false; 3729 } 3730} 3731