formats.c revision 01e04c3f
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 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27#include "errors.h" 28#include "imports.h" 29#include "formats.h" 30#include "macros.h" 31#include "glformats.h" 32#include "c11/threads.h" 33#include "util/hash_table.h" 34 35/** 36 * Information about texture formats. 37 */ 38struct gl_format_info 39{ 40 mesa_format Name; 41 42 /** text name for debugging */ 43 const char *StrName; 44 45 enum mesa_format_layout Layout; 46 47 /** 48 * Base format is one of GL_RED, GL_RG, GL_RGB, GL_RGBA, GL_ALPHA, 49 * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, GL_YCBCR_MESA, 50 * GL_DEPTH_COMPONENT, GL_STENCIL_INDEX, GL_DEPTH_STENCIL. 51 */ 52 GLenum BaseFormat; 53 54 /** 55 * Logical data type: one of GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, 56 * GL_UNSIGNED_INT, GL_INT, GL_FLOAT. 57 */ 58 GLenum DataType; 59 60 GLubyte RedBits; 61 GLubyte GreenBits; 62 GLubyte BlueBits; 63 GLubyte AlphaBits; 64 GLubyte LuminanceBits; 65 GLubyte IntensityBits; 66 GLubyte DepthBits; 67 GLubyte StencilBits; 68 69 bool IsSRGBFormat; 70 71 /** 72 * To describe compressed formats. If not compressed, Width=Height=Depth=1. 73 */ 74 GLubyte BlockWidth, BlockHeight, BlockDepth; 75 GLubyte BytesPerBlock; 76 77 uint8_t Swizzle[4]; 78 mesa_array_format ArrayFormat; 79}; 80 81#include "format_info.h" 82 83static const struct gl_format_info * 84_mesa_get_format_info(mesa_format format) 85{ 86 const struct gl_format_info *info = &format_info[format]; 87 STATIC_ASSERT(ARRAY_SIZE(format_info) == MESA_FORMAT_COUNT); 88 assert(info->Name == format); 89 return info; 90} 91 92 93/** Return string name of format (for debugging) */ 94const char * 95_mesa_get_format_name(mesa_format format) 96{ 97 const struct gl_format_info *info = _mesa_get_format_info(format); 98 return info->StrName; 99} 100 101 102 103/** 104 * Return bytes needed to store a block of pixels in the given format. 105 * Normally, a block is 1x1 (a single pixel). But for compressed formats 106 * a block may be 4x4 or 8x4, etc. 107 * 108 * Note: not GLuint, so as not to coerce math to unsigned. cf. fdo #37351 109 */ 110GLint 111_mesa_get_format_bytes(mesa_format format) 112{ 113 if (_mesa_format_is_mesa_array_format(format)) { 114 return _mesa_array_format_get_type_size(format) * 115 _mesa_array_format_get_num_channels(format); 116 } 117 118 const struct gl_format_info *info = _mesa_get_format_info(format); 119 assert(info->BytesPerBlock); 120 assert(info->BytesPerBlock <= MAX_PIXEL_BYTES || 121 _mesa_is_format_compressed(format)); 122 return info->BytesPerBlock; 123} 124 125 126/** 127 * Return bits per component for the given format. 128 * \param format one of MESA_FORMAT_x 129 * \param pname the component, such as GL_RED_BITS, GL_TEXTURE_BLUE_BITS, etc. 130 */ 131GLint 132_mesa_get_format_bits(mesa_format format, GLenum pname) 133{ 134 const struct gl_format_info *info = _mesa_get_format_info(format); 135 136 switch (pname) { 137 case GL_RED_BITS: 138 case GL_TEXTURE_RED_SIZE: 139 case GL_RENDERBUFFER_RED_SIZE_EXT: 140 case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: 141 case GL_INTERNALFORMAT_RED_SIZE: 142 return info->RedBits; 143 case GL_GREEN_BITS: 144 case GL_TEXTURE_GREEN_SIZE: 145 case GL_RENDERBUFFER_GREEN_SIZE_EXT: 146 case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: 147 case GL_INTERNALFORMAT_GREEN_SIZE: 148 return info->GreenBits; 149 case GL_BLUE_BITS: 150 case GL_TEXTURE_BLUE_SIZE: 151 case GL_RENDERBUFFER_BLUE_SIZE_EXT: 152 case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: 153 case GL_INTERNALFORMAT_BLUE_SIZE: 154 return info->BlueBits; 155 case GL_ALPHA_BITS: 156 case GL_TEXTURE_ALPHA_SIZE: 157 case GL_RENDERBUFFER_ALPHA_SIZE_EXT: 158 case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: 159 case GL_INTERNALFORMAT_ALPHA_SIZE: 160 return info->AlphaBits; 161 case GL_TEXTURE_INTENSITY_SIZE: 162 return info->IntensityBits; 163 case GL_TEXTURE_LUMINANCE_SIZE: 164 return info->LuminanceBits; 165 case GL_INDEX_BITS: 166 return 0; 167 case GL_DEPTH_BITS: 168 case GL_TEXTURE_DEPTH_SIZE_ARB: 169 case GL_RENDERBUFFER_DEPTH_SIZE_EXT: 170 case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: 171 case GL_INTERNALFORMAT_DEPTH_SIZE: 172 return info->DepthBits; 173 case GL_STENCIL_BITS: 174 case GL_TEXTURE_STENCIL_SIZE_EXT: 175 case GL_RENDERBUFFER_STENCIL_SIZE_EXT: 176 case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: 177 case GL_INTERNALFORMAT_STENCIL_SIZE: 178 return info->StencilBits; 179 default: 180 _mesa_problem(NULL, "bad pname in _mesa_get_format_bits()"); 181 return 0; 182 } 183} 184 185 186GLuint 187_mesa_get_format_max_bits(mesa_format format) 188{ 189 const struct gl_format_info *info = _mesa_get_format_info(format); 190 GLuint max = MAX2(info->RedBits, info->GreenBits); 191 max = MAX2(max, info->BlueBits); 192 max = MAX2(max, info->AlphaBits); 193 max = MAX2(max, info->LuminanceBits); 194 max = MAX2(max, info->IntensityBits); 195 max = MAX2(max, info->DepthBits); 196 max = MAX2(max, info->StencilBits); 197 return max; 198} 199 200 201/** 202 * Return the layout type of the given format. 203 */ 204extern enum mesa_format_layout 205_mesa_get_format_layout(mesa_format format) 206{ 207 const struct gl_format_info *info = _mesa_get_format_info(format); 208 return info->Layout; 209} 210 211 212/** 213 * Return the data type (or more specifically, the data representation) 214 * for the given format. 215 * The return value will be one of: 216 * GL_UNSIGNED_NORMALIZED = unsigned int representing [0,1] 217 * GL_SIGNED_NORMALIZED = signed int representing [-1, 1] 218 * GL_UNSIGNED_INT = an ordinary unsigned integer 219 * GL_INT = an ordinary signed integer 220 * GL_FLOAT = an ordinary float 221 */ 222GLenum 223_mesa_get_format_datatype(mesa_format format) 224{ 225 const struct gl_format_info *info = _mesa_get_format_info(format); 226 return info->DataType; 227} 228 229static GLenum 230get_base_format_for_array_format(mesa_array_format format) 231{ 232 uint8_t swizzle[4]; 233 int num_channels; 234 235 _mesa_array_format_get_swizzle(format, swizzle); 236 num_channels = _mesa_array_format_get_num_channels(format); 237 238 switch (num_channels) { 239 case 4: 240 /* FIXME: RGBX formats have 4 channels, but their base format is GL_RGB. 241 * This is not really a problem for now because we only create array 242 * formats from GL format/type combinations, and these cannot specify 243 * RGBX formats. 244 */ 245 return GL_RGBA; 246 case 3: 247 return GL_RGB; 248 case 2: 249 if (swizzle[0] == 0 && 250 swizzle[1] == 0 && 251 swizzle[2] == 0 && 252 swizzle[3] == 1) 253 return GL_LUMINANCE_ALPHA; 254 if (swizzle[0] == 1 && 255 swizzle[1] == 1 && 256 swizzle[2] == 1 && 257 swizzle[3] == 0) 258 return GL_LUMINANCE_ALPHA; 259 if (swizzle[0] == 0 && 260 swizzle[1] == 1 && 261 swizzle[2] == 4 && 262 swizzle[3] == 5) 263 return GL_RG; 264 if (swizzle[0] == 1 && 265 swizzle[1] == 0 && 266 swizzle[2] == 4 && 267 swizzle[3] == 5) 268 return GL_RG; 269 break; 270 case 1: 271 if (swizzle[0] == 0 && 272 swizzle[1] == 0 && 273 swizzle[2] == 0 && 274 swizzle[3] == 5) 275 return GL_LUMINANCE; 276 if (swizzle[0] == 0 && 277 swizzle[1] == 0 && 278 swizzle[2] == 0 && 279 swizzle[3] == 0) 280 return GL_INTENSITY; 281 if (swizzle[0] <= MESA_FORMAT_SWIZZLE_W) 282 return GL_RED; 283 if (swizzle[1] <= MESA_FORMAT_SWIZZLE_W) 284 return GL_GREEN; 285 if (swizzle[2] <= MESA_FORMAT_SWIZZLE_W) 286 return GL_BLUE; 287 if (swizzle[3] <= MESA_FORMAT_SWIZZLE_W) 288 return GL_ALPHA; 289 break; 290 } 291 292 unreachable("Unsupported format"); 293} 294 295/** 296 * Return the basic format for the given type. The result will be one of 297 * GL_RGB, GL_RGBA, GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_INTENSITY, 298 * GL_YCBCR_MESA, GL_DEPTH_COMPONENT, GL_STENCIL_INDEX, GL_DEPTH_STENCIL. 299 * This functions accepts a mesa_format or a mesa_array_format. 300 */ 301GLenum 302_mesa_get_format_base_format(uint32_t format) 303{ 304 if (!_mesa_format_is_mesa_array_format(format)) { 305 const struct gl_format_info *info = _mesa_get_format_info(format); 306 return info->BaseFormat; 307 } else { 308 return get_base_format_for_array_format(format); 309 } 310} 311 312 313/** 314 * Return the block size (in pixels) for the given format. Normally 315 * the block size is 1x1. But compressed formats will have block sizes 316 * of 4x4 or 8x4 pixels, etc. 317 * \param bw returns block width in pixels 318 * \param bh returns block height in pixels 319 */ 320void 321_mesa_get_format_block_size(mesa_format format, GLuint *bw, GLuint *bh) 322{ 323 const struct gl_format_info *info = _mesa_get_format_info(format); 324 /* Use _mesa_get_format_block_size_3d() for 3D blocks. */ 325 assert(info->BlockDepth == 1); 326 327 *bw = info->BlockWidth; 328 *bh = info->BlockHeight; 329} 330 331 332/** 333 * Return the block size (in pixels) for the given format. Normally 334 * the block size is 1x1x1. But compressed formats will have block 335 * sizes of 4x4x4, 3x3x3 pixels, etc. 336 * \param bw returns block width in pixels 337 * \param bh returns block height in pixels 338 * \param bd returns block depth in pixels 339 */ 340void 341_mesa_get_format_block_size_3d(mesa_format format, 342 GLuint *bw, 343 GLuint *bh, 344 GLuint *bd) 345{ 346 const struct gl_format_info *info = _mesa_get_format_info(format); 347 *bw = info->BlockWidth; 348 *bh = info->BlockHeight; 349 *bd = info->BlockDepth; 350} 351 352 353/** 354 * Returns the an array of four numbers representing the transformation 355 * from the RGBA or SZ colorspace to the given format. For array formats, 356 * the i'th RGBA component is given by: 357 * 358 * if (swizzle[i] <= MESA_FORMAT_SWIZZLE_W) 359 * comp = data[swizzle[i]]; 360 * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_ZERO) 361 * comp = 0; 362 * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_ONE) 363 * comp = 1; 364 * else if (swizzle[i] == MESA_FORMAT_SWIZZLE_NONE) 365 * // data does not contain a channel of this format 366 * 367 * For packed formats, the swizzle gives the number of components left of 368 * the least significant bit. 369 * 370 * Compressed formats have no swizzle. 371 */ 372void 373_mesa_get_format_swizzle(mesa_format format, uint8_t swizzle_out[4]) 374{ 375 const struct gl_format_info *info = _mesa_get_format_info(format); 376 memcpy(swizzle_out, info->Swizzle, sizeof(info->Swizzle)); 377} 378 379mesa_array_format 380_mesa_array_format_flip_channels(mesa_array_format format) 381{ 382 int num_channels; 383 uint8_t swizzle[4]; 384 385 num_channels = _mesa_array_format_get_num_channels(format); 386 _mesa_array_format_get_swizzle(format, swizzle); 387 388 if (num_channels == 1) 389 return format; 390 391 if (num_channels == 2) { 392 /* Assert that the swizzle makes sense for 2 channels */ 393 for (unsigned i = 0; i < 4; i++) 394 assert(swizzle[i] != 2 && swizzle[i] != 3); 395 396 static const uint8_t flip_xy[6] = { 1, 0, 2, 3, 4, 5 }; 397 _mesa_array_format_set_swizzle(&format, 398 flip_xy[swizzle[0]], flip_xy[swizzle[1]], 399 flip_xy[swizzle[2]], flip_xy[swizzle[3]]); 400 return format; 401 } 402 403 if (num_channels == 4) { 404 static const uint8_t flip[6] = { 3, 2, 1, 0, 4, 5 }; 405 _mesa_array_format_set_swizzle(&format, 406 flip[swizzle[0]], flip[swizzle[1]], 407 flip[swizzle[2]], flip[swizzle[3]]); 408 return format; 409 } 410 411 unreachable("Invalid array format"); 412} 413 414uint32_t 415_mesa_format_to_array_format(mesa_format format) 416{ 417 const struct gl_format_info *info = _mesa_get_format_info(format); 418 if (info->ArrayFormat && !_mesa_little_endian() && 419 info->Layout == MESA_FORMAT_LAYOUT_PACKED) 420 return _mesa_array_format_flip_channels(info->ArrayFormat); 421 else 422 return info->ArrayFormat; 423} 424 425static struct hash_table *format_array_format_table; 426static once_flag format_array_format_table_exists = ONCE_FLAG_INIT; 427 428static bool 429array_formats_equal(const void *a, const void *b) 430{ 431 return (intptr_t)a == (intptr_t)b; 432} 433 434static void 435format_array_format_table_init(void) 436{ 437 const struct gl_format_info *info; 438 mesa_array_format array_format; 439 unsigned f; 440 441 format_array_format_table = _mesa_hash_table_create(NULL, NULL, 442 array_formats_equal); 443 444 if (!format_array_format_table) { 445 _mesa_error_no_memory(__func__); 446 return; 447 } 448 449 for (f = 1; f < MESA_FORMAT_COUNT; ++f) { 450 info = _mesa_get_format_info(f); 451 if (!info->ArrayFormat) 452 continue; 453 454 if (_mesa_little_endian()) { 455 array_format = info->ArrayFormat; 456 } else { 457 array_format = _mesa_array_format_flip_channels(info->ArrayFormat); 458 } 459 460 /* This can happen and does for some of the BGR formats. Let's take 461 * the first one in the list. 462 */ 463 if (_mesa_hash_table_search_pre_hashed(format_array_format_table, 464 array_format, 465 (void *)(intptr_t)array_format)) 466 continue; 467 468 _mesa_hash_table_insert_pre_hashed(format_array_format_table, 469 array_format, 470 (void *)(intptr_t)array_format, 471 (void *)(intptr_t)f); 472 } 473} 474 475mesa_format 476_mesa_format_from_array_format(uint32_t array_format) 477{ 478 struct hash_entry *entry; 479 480 assert(_mesa_format_is_mesa_array_format(array_format)); 481 482 call_once(&format_array_format_table_exists, format_array_format_table_init); 483 484 if (!format_array_format_table) { 485 static const once_flag once_flag_init = ONCE_FLAG_INIT; 486 format_array_format_table_exists = once_flag_init; 487 return MESA_FORMAT_NONE; 488 } 489 490 entry = _mesa_hash_table_search_pre_hashed(format_array_format_table, 491 array_format, 492 (void *)(intptr_t)array_format); 493 if (entry) 494 return (intptr_t)entry->data; 495 else 496 return MESA_FORMAT_NONE; 497} 498 499/** Is the given format a compressed format? */ 500GLboolean 501_mesa_is_format_compressed(mesa_format format) 502{ 503 const struct gl_format_info *info = _mesa_get_format_info(format); 504 return info->BlockWidth > 1 || info->BlockHeight > 1; 505} 506 507 508/** 509 * Determine if the given format represents a packed depth/stencil buffer. 510 */ 511GLboolean 512_mesa_is_format_packed_depth_stencil(mesa_format format) 513{ 514 const struct gl_format_info *info = _mesa_get_format_info(format); 515 516 return info->BaseFormat == GL_DEPTH_STENCIL; 517} 518 519 520/** 521 * Is the given format a signed/unsigned integer color format? 522 */ 523GLboolean 524_mesa_is_format_integer_color(mesa_format format) 525{ 526 const struct gl_format_info *info = _mesa_get_format_info(format); 527 return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT) && 528 info->BaseFormat != GL_DEPTH_COMPONENT && 529 info->BaseFormat != GL_DEPTH_STENCIL && 530 info->BaseFormat != GL_STENCIL_INDEX; 531} 532 533 534/** 535 * Is the given format an unsigned integer format? 536 */ 537GLboolean 538_mesa_is_format_unsigned(mesa_format format) 539{ 540 const struct gl_format_info *info = _mesa_get_format_info(format); 541 return _mesa_is_type_unsigned(info->DataType); 542} 543 544 545/** 546 * Does the given format store signed values? 547 */ 548GLboolean 549_mesa_is_format_signed(mesa_format format) 550{ 551 if (format == MESA_FORMAT_R11G11B10_FLOAT || 552 format == MESA_FORMAT_R9G9B9E5_FLOAT) { 553 /* these packed float formats only store unsigned values */ 554 return GL_FALSE; 555 } 556 else { 557 const struct gl_format_info *info = _mesa_get_format_info(format); 558 return (info->DataType == GL_SIGNED_NORMALIZED || 559 info->DataType == GL_INT || 560 info->DataType == GL_FLOAT); 561 } 562} 563 564/** 565 * Is the given format an integer format? 566 */ 567GLboolean 568_mesa_is_format_integer(mesa_format format) 569{ 570 const struct gl_format_info *info = _mesa_get_format_info(format); 571 return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT); 572} 573 574 575/** 576 * Return true if the given format is a color format. 577 */ 578GLenum 579_mesa_is_format_color_format(mesa_format format) 580{ 581 const struct gl_format_info *info = _mesa_get_format_info(format); 582 switch (info->BaseFormat) { 583 case GL_DEPTH_COMPONENT: 584 case GL_STENCIL_INDEX: 585 case GL_DEPTH_STENCIL: 586 return false; 587 default: 588 return true; 589 } 590} 591 592 593/** 594 * Return color encoding for given format. 595 * \return GL_LINEAR or GL_SRGB 596 */ 597GLenum 598_mesa_get_format_color_encoding(mesa_format format) 599{ 600 const struct gl_format_info *info = _mesa_get_format_info(format); 601 return info->IsSRGBFormat ? GL_SRGB : GL_LINEAR; 602} 603 604 605/** 606 * Return TRUE if format is an ETC2 compressed format specified 607 * by GL_ARB_ES3_compatibility. 608 */ 609bool 610_mesa_is_format_etc2(mesa_format format) 611{ 612 switch (format) { 613 case MESA_FORMAT_ETC2_RGB8: 614 case MESA_FORMAT_ETC2_SRGB8: 615 case MESA_FORMAT_ETC2_RGBA8_EAC: 616 case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC: 617 case MESA_FORMAT_ETC2_R11_EAC: 618 case MESA_FORMAT_ETC2_RG11_EAC: 619 case MESA_FORMAT_ETC2_SIGNED_R11_EAC: 620 case MESA_FORMAT_ETC2_SIGNED_RG11_EAC: 621 case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: 622 case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: 623 return GL_TRUE; 624 default: 625 return GL_FALSE; 626 } 627} 628 629 630/** 631 * Return TRUE if format is an ASTC 2D compressed format. 632 */ 633bool 634_mesa_is_format_astc_2d(mesa_format format) 635{ 636 switch (format) { 637 case MESA_FORMAT_RGBA_ASTC_4x4: 638 case MESA_FORMAT_RGBA_ASTC_5x4: 639 case MESA_FORMAT_RGBA_ASTC_5x5: 640 case MESA_FORMAT_RGBA_ASTC_6x5: 641 case MESA_FORMAT_RGBA_ASTC_6x6: 642 case MESA_FORMAT_RGBA_ASTC_8x5: 643 case MESA_FORMAT_RGBA_ASTC_8x6: 644 case MESA_FORMAT_RGBA_ASTC_8x8: 645 case MESA_FORMAT_RGBA_ASTC_10x5: 646 case MESA_FORMAT_RGBA_ASTC_10x6: 647 case MESA_FORMAT_RGBA_ASTC_10x8: 648 case MESA_FORMAT_RGBA_ASTC_10x10: 649 case MESA_FORMAT_RGBA_ASTC_12x10: 650 case MESA_FORMAT_RGBA_ASTC_12x12: 651 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4: 652 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4: 653 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5: 654 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5: 655 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6: 656 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5: 657 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6: 658 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8: 659 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5: 660 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6: 661 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8: 662 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10: 663 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10: 664 case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12: 665 return true; 666 default: 667 return false; 668 } 669} 670 671 672/** 673 * If the given format is a compressed format, return a corresponding 674 * uncompressed format. 675 */ 676mesa_format 677_mesa_get_uncompressed_format(mesa_format format) 678{ 679 switch (format) { 680 case MESA_FORMAT_RGB_FXT1: 681 return MESA_FORMAT_BGR_UNORM8; 682 case MESA_FORMAT_RGBA_FXT1: 683 return MESA_FORMAT_A8B8G8R8_UNORM; 684 case MESA_FORMAT_RGB_DXT1: 685 case MESA_FORMAT_SRGB_DXT1: 686 return MESA_FORMAT_BGR_UNORM8; 687 case MESA_FORMAT_RGBA_DXT1: 688 case MESA_FORMAT_SRGBA_DXT1: 689 return MESA_FORMAT_A8B8G8R8_UNORM; 690 case MESA_FORMAT_RGBA_DXT3: 691 case MESA_FORMAT_SRGBA_DXT3: 692 return MESA_FORMAT_A8B8G8R8_UNORM; 693 case MESA_FORMAT_RGBA_DXT5: 694 case MESA_FORMAT_SRGBA_DXT5: 695 return MESA_FORMAT_A8B8G8R8_UNORM; 696 case MESA_FORMAT_R_RGTC1_UNORM: 697 return MESA_FORMAT_R_UNORM8; 698 case MESA_FORMAT_R_RGTC1_SNORM: 699 return MESA_FORMAT_R_SNORM8; 700 case MESA_FORMAT_RG_RGTC2_UNORM: 701 return MESA_FORMAT_R8G8_UNORM; 702 case MESA_FORMAT_RG_RGTC2_SNORM: 703 return MESA_FORMAT_R8G8_SNORM; 704 case MESA_FORMAT_L_LATC1_UNORM: 705 return MESA_FORMAT_L_UNORM8; 706 case MESA_FORMAT_L_LATC1_SNORM: 707 return MESA_FORMAT_L_SNORM8; 708 case MESA_FORMAT_LA_LATC2_UNORM: 709 return MESA_FORMAT_L8A8_UNORM; 710 case MESA_FORMAT_LA_LATC2_SNORM: 711 return MESA_FORMAT_L8A8_SNORM; 712 case MESA_FORMAT_ETC1_RGB8: 713 case MESA_FORMAT_ETC2_RGB8: 714 case MESA_FORMAT_ETC2_SRGB8: 715 return MESA_FORMAT_BGR_UNORM8; 716 case MESA_FORMAT_ETC2_RGBA8_EAC: 717 case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC: 718 case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: 719 case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: 720 return MESA_FORMAT_A8B8G8R8_UNORM; 721 case MESA_FORMAT_ETC2_R11_EAC: 722 case MESA_FORMAT_ETC2_SIGNED_R11_EAC: 723 return MESA_FORMAT_R_UNORM16; 724 case MESA_FORMAT_ETC2_RG11_EAC: 725 case MESA_FORMAT_ETC2_SIGNED_RG11_EAC: 726 return MESA_FORMAT_R16G16_UNORM; 727 case MESA_FORMAT_BPTC_RGBA_UNORM: 728 case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM: 729 return MESA_FORMAT_A8B8G8R8_UNORM; 730 case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT: 731 case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT: 732 return MESA_FORMAT_RGB_FLOAT32; 733 default: 734#ifdef DEBUG 735 assert(!_mesa_is_format_compressed(format)); 736#endif 737 return format; 738 } 739} 740 741 742GLuint 743_mesa_format_num_components(mesa_format format) 744{ 745 const struct gl_format_info *info = _mesa_get_format_info(format); 746 return ((info->RedBits > 0) + 747 (info->GreenBits > 0) + 748 (info->BlueBits > 0) + 749 (info->AlphaBits > 0) + 750 (info->LuminanceBits > 0) + 751 (info->IntensityBits > 0) + 752 (info->DepthBits > 0) + 753 (info->StencilBits > 0)); 754} 755 756 757/** 758 * Returns true if a color format has data stored in the R/G/B/A channels, 759 * given an index from 0 to 3. 760 */ 761bool 762_mesa_format_has_color_component(mesa_format format, int component) 763{ 764 const struct gl_format_info *info = _mesa_get_format_info(format); 765 766 assert(info->BaseFormat != GL_DEPTH_COMPONENT && 767 info->BaseFormat != GL_DEPTH_STENCIL && 768 info->BaseFormat != GL_STENCIL_INDEX); 769 770 switch (component) { 771 case 0: 772 return (info->RedBits + info->IntensityBits + info->LuminanceBits) > 0; 773 case 1: 774 return (info->GreenBits + info->IntensityBits + info->LuminanceBits) > 0; 775 case 2: 776 return (info->BlueBits + info->IntensityBits + info->LuminanceBits) > 0; 777 case 3: 778 return (info->AlphaBits + info->IntensityBits) > 0; 779 default: 780 assert(!"Invalid color component: must be 0..3"); 781 return false; 782 } 783} 784 785 786/** 787 * Return number of bytes needed to store an image of the given size 788 * in the given format. 789 */ 790GLuint 791_mesa_format_image_size(mesa_format format, GLsizei width, 792 GLsizei height, GLsizei depth) 793{ 794 const struct gl_format_info *info = _mesa_get_format_info(format); 795 GLuint sz; 796 /* Strictly speaking, a conditional isn't needed here */ 797 if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) { 798 /* compressed format (2D only for now) */ 799 const GLuint bw = info->BlockWidth; 800 const GLuint bh = info->BlockHeight; 801 const GLuint bd = info->BlockDepth; 802 const GLuint wblocks = (width + bw - 1) / bw; 803 const GLuint hblocks = (height + bh - 1) / bh; 804 const GLuint dblocks = (depth + bd - 1) / bd; 805 sz = wblocks * hblocks * dblocks * info->BytesPerBlock; 806 } else 807 /* non-compressed */ 808 sz = width * height * depth * info->BytesPerBlock; 809 810 return sz; 811} 812 813 814/** 815 * Same as _mesa_format_image_size() but returns a 64-bit value to 816 * accommodate very large textures. 817 */ 818uint64_t 819_mesa_format_image_size64(mesa_format format, GLsizei width, 820 GLsizei height, GLsizei depth) 821{ 822 const struct gl_format_info *info = _mesa_get_format_info(format); 823 uint64_t sz; 824 /* Strictly speaking, a conditional isn't needed here */ 825 if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) { 826 /* compressed format (2D only for now) */ 827 const uint64_t bw = info->BlockWidth; 828 const uint64_t bh = info->BlockHeight; 829 const uint64_t bd = info->BlockDepth; 830 const uint64_t wblocks = (width + bw - 1) / bw; 831 const uint64_t hblocks = (height + bh - 1) / bh; 832 const uint64_t dblocks = (depth + bd - 1) / bd; 833 sz = wblocks * hblocks * dblocks * info->BytesPerBlock; 834 } else 835 /* non-compressed */ 836 sz = ((uint64_t) width * (uint64_t) height * 837 (uint64_t) depth * info->BytesPerBlock); 838 839 return sz; 840} 841 842 843 844GLint 845_mesa_format_row_stride(mesa_format format, GLsizei width) 846{ 847 const struct gl_format_info *info = _mesa_get_format_info(format); 848 /* Strictly speaking, a conditional isn't needed here */ 849 if (info->BlockWidth > 1 || info->BlockHeight > 1) { 850 /* compressed format */ 851 const GLuint bw = info->BlockWidth; 852 const GLuint wblocks = (width + bw - 1) / bw; 853 const GLint stride = wblocks * info->BytesPerBlock; 854 return stride; 855 } 856 else { 857 const GLint stride = width * info->BytesPerBlock; 858 return stride; 859 } 860} 861 862 863 864/** 865 * Return datatype and number of components per texel for the given 866 * uncompressed mesa_format. Only used for mipmap generation code. 867 */ 868void 869_mesa_uncompressed_format_to_type_and_comps(mesa_format format, 870 GLenum *datatype, GLuint *comps) 871{ 872 switch (format) { 873 case MESA_FORMAT_A8B8G8R8_UNORM: 874 case MESA_FORMAT_R8G8B8A8_UNORM: 875 case MESA_FORMAT_B8G8R8A8_UNORM: 876 case MESA_FORMAT_A8R8G8B8_UNORM: 877 case MESA_FORMAT_X8B8G8R8_UNORM: 878 case MESA_FORMAT_R8G8B8X8_UNORM: 879 case MESA_FORMAT_B8G8R8X8_UNORM: 880 case MESA_FORMAT_X8R8G8B8_UNORM: 881 case MESA_FORMAT_A8B8G8R8_UINT: 882 case MESA_FORMAT_R8G8B8A8_UINT: 883 case MESA_FORMAT_B8G8R8A8_UINT: 884 case MESA_FORMAT_A8R8G8B8_UINT: 885 *datatype = GL_UNSIGNED_BYTE; 886 *comps = 4; 887 return; 888 case MESA_FORMAT_BGR_UNORM8: 889 case MESA_FORMAT_RGB_UNORM8: 890 *datatype = GL_UNSIGNED_BYTE; 891 *comps = 3; 892 return; 893 case MESA_FORMAT_B5G6R5_UNORM: 894 case MESA_FORMAT_R5G6B5_UNORM: 895 case MESA_FORMAT_B5G6R5_UINT: 896 case MESA_FORMAT_R5G6B5_UINT: 897 *datatype = GL_UNSIGNED_SHORT_5_6_5; 898 *comps = 3; 899 return; 900 901 case MESA_FORMAT_B4G4R4A4_UNORM: 902 case MESA_FORMAT_A4R4G4B4_UNORM: 903 case MESA_FORMAT_B4G4R4X4_UNORM: 904 case MESA_FORMAT_B4G4R4A4_UINT: 905 case MESA_FORMAT_A4R4G4B4_UINT: 906 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 907 *comps = 4; 908 return; 909 910 case MESA_FORMAT_B5G5R5A1_UNORM: 911 case MESA_FORMAT_A1R5G5B5_UNORM: 912 case MESA_FORMAT_B5G5R5X1_UNORM: 913 case MESA_FORMAT_B5G5R5A1_UINT: 914 case MESA_FORMAT_A1R5G5B5_UINT: 915 *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV; 916 *comps = 4; 917 return; 918 919 case MESA_FORMAT_B10G10R10A2_UNORM: 920 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 921 *comps = 4; 922 return; 923 924 case MESA_FORMAT_A1B5G5R5_UNORM: 925 case MESA_FORMAT_A1B5G5R5_UINT: 926 case MESA_FORMAT_X1B5G5R5_UNORM: 927 *datatype = GL_UNSIGNED_SHORT_5_5_5_1; 928 *comps = 4; 929 return; 930 931 case MESA_FORMAT_L4A4_UNORM: 932 *datatype = MESA_UNSIGNED_BYTE_4_4; 933 *comps = 2; 934 return; 935 936 case MESA_FORMAT_L8A8_UNORM: 937 case MESA_FORMAT_A8L8_UNORM: 938 case MESA_FORMAT_R8G8_UNORM: 939 case MESA_FORMAT_G8R8_UNORM: 940 *datatype = GL_UNSIGNED_BYTE; 941 *comps = 2; 942 return; 943 944 case MESA_FORMAT_L16A16_UNORM: 945 case MESA_FORMAT_A16L16_UNORM: 946 case MESA_FORMAT_R16G16_UNORM: 947 case MESA_FORMAT_G16R16_UNORM: 948 *datatype = GL_UNSIGNED_SHORT; 949 *comps = 2; 950 return; 951 952 case MESA_FORMAT_R_UNORM16: 953 case MESA_FORMAT_A_UNORM16: 954 case MESA_FORMAT_L_UNORM16: 955 case MESA_FORMAT_I_UNORM16: 956 *datatype = GL_UNSIGNED_SHORT; 957 *comps = 1; 958 return; 959 960 case MESA_FORMAT_R3G3B2_UNORM: 961 case MESA_FORMAT_R3G3B2_UINT: 962 *datatype = GL_UNSIGNED_BYTE_2_3_3_REV; 963 *comps = 3; 964 return; 965 case MESA_FORMAT_A4B4G4R4_UNORM: 966 case MESA_FORMAT_A4B4G4R4_UINT: 967 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 968 *comps = 4; 969 return; 970 971 case MESA_FORMAT_R4G4B4A4_UNORM: 972 case MESA_FORMAT_R4G4B4A4_UINT: 973 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 974 *comps = 4; 975 return; 976 case MESA_FORMAT_R5G5B5A1_UNORM: 977 case MESA_FORMAT_R5G5B5A1_UINT: 978 *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV; 979 *comps = 4; 980 return; 981 case MESA_FORMAT_A2B10G10R10_UNORM: 982 case MESA_FORMAT_A2B10G10R10_UINT: 983 *datatype = GL_UNSIGNED_INT_10_10_10_2; 984 *comps = 4; 985 return; 986 case MESA_FORMAT_A2R10G10B10_UNORM: 987 case MESA_FORMAT_A2R10G10B10_UINT: 988 *datatype = GL_UNSIGNED_INT_10_10_10_2; 989 *comps = 4; 990 return; 991 992 case MESA_FORMAT_B2G3R3_UNORM: 993 case MESA_FORMAT_B2G3R3_UINT: 994 *datatype = GL_UNSIGNED_BYTE_3_3_2; 995 *comps = 3; 996 return; 997 998 case MESA_FORMAT_A_UNORM8: 999 case MESA_FORMAT_L_UNORM8: 1000 case MESA_FORMAT_I_UNORM8: 1001 case MESA_FORMAT_R_UNORM8: 1002 case MESA_FORMAT_S_UINT8: 1003 *datatype = GL_UNSIGNED_BYTE; 1004 *comps = 1; 1005 return; 1006 1007 case MESA_FORMAT_YCBCR: 1008 case MESA_FORMAT_YCBCR_REV: 1009 *datatype = GL_UNSIGNED_SHORT; 1010 *comps = 2; 1011 return; 1012 1013 case MESA_FORMAT_S8_UINT_Z24_UNORM: 1014 *datatype = GL_UNSIGNED_INT_24_8_MESA; 1015 *comps = 2; 1016 return; 1017 1018 case MESA_FORMAT_Z24_UNORM_S8_UINT: 1019 *datatype = GL_UNSIGNED_INT_8_24_REV_MESA; 1020 *comps = 2; 1021 return; 1022 1023 case MESA_FORMAT_Z_UNORM16: 1024 *datatype = GL_UNSIGNED_SHORT; 1025 *comps = 1; 1026 return; 1027 1028 case MESA_FORMAT_Z24_UNORM_X8_UINT: 1029 *datatype = GL_UNSIGNED_INT; 1030 *comps = 1; 1031 return; 1032 1033 case MESA_FORMAT_X8_UINT_Z24_UNORM: 1034 *datatype = GL_UNSIGNED_INT; 1035 *comps = 1; 1036 return; 1037 1038 case MESA_FORMAT_Z_UNORM32: 1039 *datatype = GL_UNSIGNED_INT; 1040 *comps = 1; 1041 return; 1042 1043 case MESA_FORMAT_Z_FLOAT32: 1044 *datatype = GL_FLOAT; 1045 *comps = 1; 1046 return; 1047 1048 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 1049 *datatype = GL_FLOAT_32_UNSIGNED_INT_24_8_REV; 1050 *comps = 1; 1051 return; 1052 1053 case MESA_FORMAT_R_SNORM8: 1054 case MESA_FORMAT_A_SNORM8: 1055 case MESA_FORMAT_L_SNORM8: 1056 case MESA_FORMAT_I_SNORM8: 1057 *datatype = GL_BYTE; 1058 *comps = 1; 1059 return; 1060 case MESA_FORMAT_R8G8_SNORM: 1061 case MESA_FORMAT_L8A8_SNORM: 1062 case MESA_FORMAT_A8L8_SNORM: 1063 *datatype = GL_BYTE; 1064 *comps = 2; 1065 return; 1066 case MESA_FORMAT_A8B8G8R8_SNORM: 1067 case MESA_FORMAT_R8G8B8A8_SNORM: 1068 case MESA_FORMAT_X8B8G8R8_SNORM: 1069 *datatype = GL_BYTE; 1070 *comps = 4; 1071 return; 1072 1073 case MESA_FORMAT_RGBA_UNORM16: 1074 *datatype = GL_UNSIGNED_SHORT; 1075 *comps = 4; 1076 return; 1077 1078 case MESA_FORMAT_R_SNORM16: 1079 case MESA_FORMAT_A_SNORM16: 1080 case MESA_FORMAT_L_SNORM16: 1081 case MESA_FORMAT_I_SNORM16: 1082 *datatype = GL_SHORT; 1083 *comps = 1; 1084 return; 1085 case MESA_FORMAT_R16G16_SNORM: 1086 case MESA_FORMAT_LA_SNORM16: 1087 *datatype = GL_SHORT; 1088 *comps = 2; 1089 return; 1090 case MESA_FORMAT_RGB_SNORM16: 1091 *datatype = GL_SHORT; 1092 *comps = 3; 1093 return; 1094 case MESA_FORMAT_RGBA_SNORM16: 1095 *datatype = GL_SHORT; 1096 *comps = 4; 1097 return; 1098 1099 case MESA_FORMAT_BGR_SRGB8: 1100 *datatype = GL_UNSIGNED_BYTE; 1101 *comps = 3; 1102 return; 1103 case MESA_FORMAT_A8B8G8R8_SRGB: 1104 case MESA_FORMAT_B8G8R8A8_SRGB: 1105 case MESA_FORMAT_A8R8G8B8_SRGB: 1106 case MESA_FORMAT_R8G8B8A8_SRGB: 1107 *datatype = GL_UNSIGNED_BYTE; 1108 *comps = 4; 1109 return; 1110 case MESA_FORMAT_L_SRGB8: 1111 *datatype = GL_UNSIGNED_BYTE; 1112 *comps = 1; 1113 return; 1114 case MESA_FORMAT_L8A8_SRGB: 1115 case MESA_FORMAT_A8L8_SRGB: 1116 *datatype = GL_UNSIGNED_BYTE; 1117 *comps = 2; 1118 return; 1119 1120 case MESA_FORMAT_RGBA_FLOAT32: 1121 *datatype = GL_FLOAT; 1122 *comps = 4; 1123 return; 1124 case MESA_FORMAT_RGBA_FLOAT16: 1125 *datatype = GL_HALF_FLOAT_ARB; 1126 *comps = 4; 1127 return; 1128 case MESA_FORMAT_RGB_FLOAT32: 1129 *datatype = GL_FLOAT; 1130 *comps = 3; 1131 return; 1132 case MESA_FORMAT_RGB_FLOAT16: 1133 *datatype = GL_HALF_FLOAT_ARB; 1134 *comps = 3; 1135 return; 1136 case MESA_FORMAT_LA_FLOAT32: 1137 case MESA_FORMAT_RG_FLOAT32: 1138 *datatype = GL_FLOAT; 1139 *comps = 2; 1140 return; 1141 case MESA_FORMAT_LA_FLOAT16: 1142 case MESA_FORMAT_RG_FLOAT16: 1143 *datatype = GL_HALF_FLOAT_ARB; 1144 *comps = 2; 1145 return; 1146 case MESA_FORMAT_A_FLOAT32: 1147 case MESA_FORMAT_L_FLOAT32: 1148 case MESA_FORMAT_I_FLOAT32: 1149 case MESA_FORMAT_R_FLOAT32: 1150 *datatype = GL_FLOAT; 1151 *comps = 1; 1152 return; 1153 case MESA_FORMAT_A_FLOAT16: 1154 case MESA_FORMAT_L_FLOAT16: 1155 case MESA_FORMAT_I_FLOAT16: 1156 case MESA_FORMAT_R_FLOAT16: 1157 *datatype = GL_HALF_FLOAT_ARB; 1158 *comps = 1; 1159 return; 1160 1161 case MESA_FORMAT_A_UINT8: 1162 case MESA_FORMAT_L_UINT8: 1163 case MESA_FORMAT_I_UINT8: 1164 *datatype = GL_UNSIGNED_BYTE; 1165 *comps = 1; 1166 return; 1167 case MESA_FORMAT_LA_UINT8: 1168 *datatype = GL_UNSIGNED_BYTE; 1169 *comps = 2; 1170 return; 1171 1172 case MESA_FORMAT_A_UINT16: 1173 case MESA_FORMAT_L_UINT16: 1174 case MESA_FORMAT_I_UINT16: 1175 *datatype = GL_UNSIGNED_SHORT; 1176 *comps = 1; 1177 return; 1178 case MESA_FORMAT_LA_UINT16: 1179 *datatype = GL_UNSIGNED_SHORT; 1180 *comps = 2; 1181 return; 1182 case MESA_FORMAT_A_UINT32: 1183 case MESA_FORMAT_L_UINT32: 1184 case MESA_FORMAT_I_UINT32: 1185 *datatype = GL_UNSIGNED_INT; 1186 *comps = 1; 1187 return; 1188 case MESA_FORMAT_LA_UINT32: 1189 *datatype = GL_UNSIGNED_INT; 1190 *comps = 2; 1191 return; 1192 case MESA_FORMAT_A_SINT8: 1193 case MESA_FORMAT_L_SINT8: 1194 case MESA_FORMAT_I_SINT8: 1195 *datatype = GL_BYTE; 1196 *comps = 1; 1197 return; 1198 case MESA_FORMAT_LA_SINT8: 1199 *datatype = GL_BYTE; 1200 *comps = 2; 1201 return; 1202 1203 case MESA_FORMAT_A_SINT16: 1204 case MESA_FORMAT_L_SINT16: 1205 case MESA_FORMAT_I_SINT16: 1206 *datatype = GL_SHORT; 1207 *comps = 1; 1208 return; 1209 case MESA_FORMAT_LA_SINT16: 1210 *datatype = GL_SHORT; 1211 *comps = 2; 1212 return; 1213 1214 case MESA_FORMAT_A_SINT32: 1215 case MESA_FORMAT_L_SINT32: 1216 case MESA_FORMAT_I_SINT32: 1217 *datatype = GL_INT; 1218 *comps = 1; 1219 return; 1220 case MESA_FORMAT_LA_SINT32: 1221 *datatype = GL_INT; 1222 *comps = 2; 1223 return; 1224 1225 case MESA_FORMAT_R_SINT8: 1226 *datatype = GL_BYTE; 1227 *comps = 1; 1228 return; 1229 case MESA_FORMAT_RG_SINT8: 1230 *datatype = GL_BYTE; 1231 *comps = 2; 1232 return; 1233 case MESA_FORMAT_RGB_SINT8: 1234 *datatype = GL_BYTE; 1235 *comps = 3; 1236 return; 1237 case MESA_FORMAT_RGBA_SINT8: 1238 *datatype = GL_BYTE; 1239 *comps = 4; 1240 return; 1241 case MESA_FORMAT_R_SINT16: 1242 *datatype = GL_SHORT; 1243 *comps = 1; 1244 return; 1245 case MESA_FORMAT_RG_SINT16: 1246 *datatype = GL_SHORT; 1247 *comps = 2; 1248 return; 1249 case MESA_FORMAT_RGB_SINT16: 1250 *datatype = GL_SHORT; 1251 *comps = 3; 1252 return; 1253 case MESA_FORMAT_RGBA_SINT16: 1254 *datatype = GL_SHORT; 1255 *comps = 4; 1256 return; 1257 case MESA_FORMAT_R_SINT32: 1258 *datatype = GL_INT; 1259 *comps = 1; 1260 return; 1261 case MESA_FORMAT_RG_SINT32: 1262 *datatype = GL_INT; 1263 *comps = 2; 1264 return; 1265 case MESA_FORMAT_RGB_SINT32: 1266 *datatype = GL_INT; 1267 *comps = 3; 1268 return; 1269 case MESA_FORMAT_RGBA_SINT32: 1270 *datatype = GL_INT; 1271 *comps = 4; 1272 return; 1273 1274 /** 1275 * \name Non-normalized unsigned integer formats. 1276 */ 1277 case MESA_FORMAT_R_UINT8: 1278 *datatype = GL_UNSIGNED_BYTE; 1279 *comps = 1; 1280 return; 1281 case MESA_FORMAT_RG_UINT8: 1282 *datatype = GL_UNSIGNED_BYTE; 1283 *comps = 2; 1284 return; 1285 case MESA_FORMAT_RGB_UINT8: 1286 *datatype = GL_UNSIGNED_BYTE; 1287 *comps = 3; 1288 return; 1289 case MESA_FORMAT_RGBA_UINT8: 1290 *datatype = GL_UNSIGNED_BYTE; 1291 *comps = 4; 1292 return; 1293 case MESA_FORMAT_R_UINT16: 1294 *datatype = GL_UNSIGNED_SHORT; 1295 *comps = 1; 1296 return; 1297 case MESA_FORMAT_RG_UINT16: 1298 *datatype = GL_UNSIGNED_SHORT; 1299 *comps = 2; 1300 return; 1301 case MESA_FORMAT_RGB_UINT16: 1302 *datatype = GL_UNSIGNED_SHORT; 1303 *comps = 3; 1304 return; 1305 case MESA_FORMAT_RGBA_UINT16: 1306 *datatype = GL_UNSIGNED_SHORT; 1307 *comps = 4; 1308 return; 1309 case MESA_FORMAT_R_UINT32: 1310 *datatype = GL_UNSIGNED_INT; 1311 *comps = 1; 1312 return; 1313 case MESA_FORMAT_RG_UINT32: 1314 *datatype = GL_UNSIGNED_INT; 1315 *comps = 2; 1316 return; 1317 case MESA_FORMAT_RGB_UINT32: 1318 *datatype = GL_UNSIGNED_INT; 1319 *comps = 3; 1320 return; 1321 case MESA_FORMAT_RGBA_UINT32: 1322 *datatype = GL_UNSIGNED_INT; 1323 *comps = 4; 1324 return; 1325 1326 case MESA_FORMAT_R9G9B9E5_FLOAT: 1327 *datatype = GL_UNSIGNED_INT_5_9_9_9_REV; 1328 *comps = 3; 1329 return; 1330 1331 case MESA_FORMAT_R11G11B10_FLOAT: 1332 *datatype = GL_UNSIGNED_INT_10F_11F_11F_REV; 1333 *comps = 3; 1334 return; 1335 1336 case MESA_FORMAT_B10G10R10A2_UINT: 1337 case MESA_FORMAT_R10G10B10A2_UINT: 1338 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1339 *comps = 4; 1340 return; 1341 1342 case MESA_FORMAT_R8G8B8X8_SRGB: 1343 case MESA_FORMAT_X8B8G8R8_SRGB: 1344 case MESA_FORMAT_RGBX_UINT8: 1345 *datatype = GL_UNSIGNED_BYTE; 1346 *comps = 4; 1347 return; 1348 1349 case MESA_FORMAT_R8G8B8X8_SNORM: 1350 case MESA_FORMAT_RGBX_SINT8: 1351 *datatype = GL_BYTE; 1352 *comps = 4; 1353 return; 1354 1355 case MESA_FORMAT_B10G10R10X2_UNORM: 1356 case MESA_FORMAT_R10G10B10X2_UNORM: 1357 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1358 *comps = 4; 1359 return; 1360 1361 case MESA_FORMAT_RGBX_UNORM16: 1362 case MESA_FORMAT_RGBX_UINT16: 1363 *datatype = GL_UNSIGNED_SHORT; 1364 *comps = 4; 1365 return; 1366 1367 case MESA_FORMAT_RGBX_SNORM16: 1368 case MESA_FORMAT_RGBX_SINT16: 1369 *datatype = GL_SHORT; 1370 *comps = 4; 1371 return; 1372 1373 case MESA_FORMAT_RGBX_FLOAT16: 1374 *datatype = GL_HALF_FLOAT; 1375 *comps = 4; 1376 return; 1377 1378 case MESA_FORMAT_RGBX_FLOAT32: 1379 *datatype = GL_FLOAT; 1380 *comps = 4; 1381 return; 1382 1383 case MESA_FORMAT_RGBX_UINT32: 1384 *datatype = GL_UNSIGNED_INT; 1385 *comps = 4; 1386 return; 1387 1388 case MESA_FORMAT_RGBX_SINT32: 1389 *datatype = GL_INT; 1390 *comps = 4; 1391 return; 1392 1393 case MESA_FORMAT_R10G10B10A2_UNORM: 1394 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1395 *comps = 4; 1396 return; 1397 1398 case MESA_FORMAT_G8R8_SNORM: 1399 *datatype = GL_BYTE; 1400 *comps = 2; 1401 return; 1402 1403 case MESA_FORMAT_G16R16_SNORM: 1404 *datatype = GL_SHORT; 1405 *comps = 2; 1406 return; 1407 1408 case MESA_FORMAT_B8G8R8X8_SRGB: 1409 case MESA_FORMAT_X8R8G8B8_SRGB: 1410 *datatype = GL_UNSIGNED_BYTE; 1411 *comps = 4; 1412 return; 1413 1414 case MESA_FORMAT_COUNT: 1415 assert(0); 1416 return; 1417 default: 1418 /* Warn if any formats are not handled */ 1419 _mesa_problem(NULL, "bad format %s in _mesa_uncompressed_format_to_type_and_comps", 1420 _mesa_get_format_name(format)); 1421 assert(format == MESA_FORMAT_NONE || 1422 _mesa_is_format_compressed(format)); 1423 *datatype = 0; 1424 *comps = 1; 1425 } 1426} 1427 1428/** 1429 * Check if a mesa_format exactly matches a GL format/type combination 1430 * such that we can use memcpy() from one to the other. 1431 * \param mesa_format a MESA_FORMAT_x value 1432 * \param format the user-specified image format 1433 * \param type the user-specified image datatype 1434 * \param swapBytes typically the current pixel pack/unpack byteswap state 1435 * \param[out] error GL_NO_ERROR if format is an expected input. 1436 * GL_INVALID_ENUM if format is an unexpected input. 1437 * \return GL_TRUE if the formats match, GL_FALSE otherwise. 1438 */ 1439GLboolean 1440_mesa_format_matches_format_and_type(mesa_format mesa_format, 1441 GLenum format, GLenum type, 1442 GLboolean swapBytes, GLenum *error) 1443{ 1444 const GLboolean littleEndian = _mesa_little_endian(); 1445 if (error) 1446 *error = GL_NO_ERROR; 1447 1448 /* Note: When reading a GL format/type combination, the format lists channel 1449 * assignments from most significant channel in the type to least 1450 * significant. A type with _REV indicates that the assignments are 1451 * swapped, so they are listed from least significant to most significant. 1452 * 1453 * Compressed formats will fall through and return GL_FALSE. 1454 * 1455 * For sanity, please keep this switch statement ordered the same as the 1456 * enums in formats.h. 1457 */ 1458 1459 switch (mesa_format) { 1460 1461 case MESA_FORMAT_NONE: 1462 case MESA_FORMAT_COUNT: 1463 return GL_FALSE; 1464 1465 case MESA_FORMAT_A8B8G8R8_UNORM: 1466 case MESA_FORMAT_A8B8G8R8_SRGB: 1467 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 1468 return GL_TRUE; 1469 1470 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes) 1471 return GL_TRUE; 1472 1473 if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian) 1474 return GL_TRUE; 1475 1476 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV 1477 && !swapBytes) 1478 return GL_TRUE; 1479 1480 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 1481 && swapBytes) 1482 return GL_TRUE; 1483 1484 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian) 1485 return GL_TRUE; 1486 1487 return GL_FALSE; 1488 1489 case MESA_FORMAT_R8G8B8A8_UNORM: 1490 case MESA_FORMAT_R8G8B8A8_SRGB: 1491 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1492 !swapBytes) 1493 return GL_TRUE; 1494 1495 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 1496 return GL_TRUE; 1497 1498 if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian) 1499 return GL_TRUE; 1500 1501 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 && 1502 !swapBytes) 1503 return GL_TRUE; 1504 1505 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1506 swapBytes) 1507 return GL_TRUE; 1508 1509 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian) 1510 return GL_TRUE; 1511 1512 return GL_FALSE; 1513 1514 case MESA_FORMAT_B8G8R8A8_UNORM: 1515 case MESA_FORMAT_B8G8R8A8_SRGB: 1516 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1517 !swapBytes) 1518 return GL_TRUE; 1519 1520 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 1521 return GL_TRUE; 1522 1523 if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && littleEndian) 1524 return GL_TRUE; 1525 1526 return GL_FALSE; 1527 1528 case MESA_FORMAT_A8R8G8B8_UNORM: 1529 case MESA_FORMAT_A8R8G8B8_SRGB: 1530 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 1531 return GL_TRUE; 1532 1533 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1534 swapBytes) 1535 return GL_TRUE; 1536 1537 if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian) 1538 return GL_TRUE; 1539 1540 return GL_FALSE; 1541 1542 case MESA_FORMAT_X8B8G8R8_UNORM: 1543 case MESA_FORMAT_R8G8B8X8_UNORM: 1544 return GL_FALSE; 1545 1546 case MESA_FORMAT_B8G8R8X8_UNORM: 1547 case MESA_FORMAT_X8R8G8B8_UNORM: 1548 return GL_FALSE; 1549 1550 case MESA_FORMAT_BGR_UNORM8: 1551 case MESA_FORMAT_BGR_SRGB8: 1552 return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian; 1553 1554 case MESA_FORMAT_RGB_UNORM8: 1555 return format == GL_RGB && type == GL_UNSIGNED_BYTE && littleEndian; 1556 1557 case MESA_FORMAT_B5G6R5_UNORM: 1558 return ((format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) || 1559 (format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5_REV)) && 1560 !swapBytes; 1561 1562 case MESA_FORMAT_R5G6B5_UNORM: 1563 return ((format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5) || 1564 (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5_REV)) && 1565 !swapBytes; 1566 1567 case MESA_FORMAT_B4G4R4A4_UNORM: 1568 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && 1569 !swapBytes; 1570 1571 case MESA_FORMAT_A4R4G4B4_UNORM: 1572 return GL_FALSE; 1573 1574 case MESA_FORMAT_A1B5G5R5_UNORM: 1575 return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1576 !swapBytes; 1577 1578 case MESA_FORMAT_X1B5G5R5_UNORM: 1579 return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1580 !swapBytes; 1581 1582 case MESA_FORMAT_B5G5R5A1_UNORM: 1583 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV && 1584 !swapBytes; 1585 1586 case MESA_FORMAT_A1R5G5B5_UNORM: 1587 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1588 !swapBytes; 1589 1590 case MESA_FORMAT_L4A4_UNORM: 1591 return GL_FALSE; 1592 case MESA_FORMAT_L8A8_UNORM: 1593 case MESA_FORMAT_L8A8_SRGB: 1594 return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian; 1595 case MESA_FORMAT_A8L8_UNORM: 1596 case MESA_FORMAT_A8L8_SRGB: 1597 return GL_FALSE; 1598 1599 case MESA_FORMAT_L16A16_UNORM: 1600 return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_SHORT && littleEndian && !swapBytes; 1601 case MESA_FORMAT_A16L16_UNORM: 1602 return GL_FALSE; 1603 1604 case MESA_FORMAT_B2G3R3_UNORM: 1605 return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2; 1606 1607 case MESA_FORMAT_R3G3B2_UNORM: 1608 return format == GL_RGB && type == GL_UNSIGNED_BYTE_2_3_3_REV; 1609 1610 case MESA_FORMAT_A4B4G4R4_UNORM: 1611 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1612 return GL_TRUE; 1613 1614 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1615 return GL_TRUE; 1616 1617 return GL_FALSE; 1618 1619 case MESA_FORMAT_R4G4B4A4_UNORM: 1620 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1621 return GL_TRUE; 1622 1623 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes) 1624 return GL_TRUE; 1625 1626 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1627 return GL_TRUE; 1628 1629 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes) 1630 return GL_TRUE; 1631 1632 return GL_FALSE; 1633 1634 case MESA_FORMAT_R5G5B5A1_UNORM: 1635 return format == GL_RGBA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV; 1636 1637 case MESA_FORMAT_A2B10G10R10_UNORM: 1638 return format == GL_RGBA && type == GL_UNSIGNED_INT_10_10_10_2; 1639 1640 case MESA_FORMAT_A2B10G10R10_UINT: 1641 return format == GL_RGBA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2; 1642 1643 case MESA_FORMAT_A2R10G10B10_UNORM: 1644 return format == GL_BGRA && type == GL_UNSIGNED_INT_10_10_10_2; 1645 1646 case MESA_FORMAT_A2R10G10B10_UINT: 1647 return format == GL_BGRA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2; 1648 1649 case MESA_FORMAT_A_UNORM8: 1650 return format == GL_ALPHA && type == GL_UNSIGNED_BYTE; 1651 case MESA_FORMAT_A_UNORM16: 1652 return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes; 1653 case MESA_FORMAT_L_UNORM8: 1654 case MESA_FORMAT_L_SRGB8: 1655 return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE; 1656 case MESA_FORMAT_L_UNORM16: 1657 return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes; 1658 case MESA_FORMAT_I_UNORM8: 1659 return format == GL_RED && type == GL_UNSIGNED_BYTE; 1660 case MESA_FORMAT_I_UNORM16: 1661 return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes; 1662 1663 case MESA_FORMAT_YCBCR: 1664 return format == GL_YCBCR_MESA && 1665 ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian != swapBytes) || 1666 (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian == swapBytes)); 1667 case MESA_FORMAT_YCBCR_REV: 1668 return format == GL_YCBCR_MESA && 1669 ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) || 1670 (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes)); 1671 1672 case MESA_FORMAT_R_UNORM8: 1673 return format == GL_RED && type == GL_UNSIGNED_BYTE; 1674 case MESA_FORMAT_R8G8_UNORM: 1675 return format == GL_RG && type == GL_UNSIGNED_BYTE && littleEndian; 1676 case MESA_FORMAT_G8R8_UNORM: 1677 return GL_FALSE; 1678 1679 case MESA_FORMAT_R_UNORM16: 1680 return format == GL_RED && type == GL_UNSIGNED_SHORT && 1681 !swapBytes; 1682 case MESA_FORMAT_R16G16_UNORM: 1683 return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian && 1684 !swapBytes; 1685 case MESA_FORMAT_G16R16_UNORM: 1686 return GL_FALSE; 1687 1688 case MESA_FORMAT_B10G10R10A2_UNORM: 1689 return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV && 1690 !swapBytes; 1691 1692 case MESA_FORMAT_S8_UINT_Z24_UNORM: 1693 return format == GL_DEPTH_STENCIL && type == GL_UNSIGNED_INT_24_8 && 1694 !swapBytes; 1695 case MESA_FORMAT_X8_UINT_Z24_UNORM: 1696 case MESA_FORMAT_Z24_UNORM_S8_UINT: 1697 return GL_FALSE; 1698 1699 case MESA_FORMAT_Z_UNORM16: 1700 return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_SHORT && 1701 !swapBytes; 1702 1703 case MESA_FORMAT_Z24_UNORM_X8_UINT: 1704 return GL_FALSE; 1705 1706 case MESA_FORMAT_Z_UNORM32: 1707 return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT && 1708 !swapBytes; 1709 1710 case MESA_FORMAT_S_UINT8: 1711 return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE; 1712 1713 case MESA_FORMAT_RGBA_FLOAT32: 1714 return format == GL_RGBA && type == GL_FLOAT && !swapBytes; 1715 case MESA_FORMAT_RGBA_FLOAT16: 1716 return format == GL_RGBA && type == GL_HALF_FLOAT && !swapBytes; 1717 1718 case MESA_FORMAT_RGB_FLOAT32: 1719 return format == GL_RGB && type == GL_FLOAT && !swapBytes; 1720 case MESA_FORMAT_RGB_FLOAT16: 1721 return format == GL_RGB && type == GL_HALF_FLOAT && !swapBytes; 1722 1723 case MESA_FORMAT_A_FLOAT32: 1724 return format == GL_ALPHA && type == GL_FLOAT && !swapBytes; 1725 case MESA_FORMAT_A_FLOAT16: 1726 return format == GL_ALPHA && type == GL_HALF_FLOAT && !swapBytes; 1727 1728 case MESA_FORMAT_L_FLOAT32: 1729 return format == GL_LUMINANCE && type == GL_FLOAT && !swapBytes; 1730 case MESA_FORMAT_L_FLOAT16: 1731 return format == GL_LUMINANCE && type == GL_HALF_FLOAT && !swapBytes; 1732 1733 case MESA_FORMAT_LA_FLOAT32: 1734 return format == GL_LUMINANCE_ALPHA && type == GL_FLOAT && !swapBytes; 1735 case MESA_FORMAT_LA_FLOAT16: 1736 return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes; 1737 1738 case MESA_FORMAT_I_FLOAT32: 1739 return format == GL_RED && type == GL_FLOAT && !swapBytes; 1740 case MESA_FORMAT_I_FLOAT16: 1741 return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes; 1742 1743 case MESA_FORMAT_R_FLOAT32: 1744 return format == GL_RED && type == GL_FLOAT && !swapBytes; 1745 case MESA_FORMAT_R_FLOAT16: 1746 return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes; 1747 1748 case MESA_FORMAT_RG_FLOAT32: 1749 return format == GL_RG && type == GL_FLOAT && !swapBytes; 1750 case MESA_FORMAT_RG_FLOAT16: 1751 return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes; 1752 1753 case MESA_FORMAT_A_UINT8: 1754 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE; 1755 case MESA_FORMAT_A_UINT16: 1756 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT && 1757 !swapBytes; 1758 case MESA_FORMAT_A_UINT32: 1759 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT && 1760 !swapBytes; 1761 case MESA_FORMAT_A_SINT8: 1762 return format == GL_ALPHA_INTEGER && type == GL_BYTE; 1763 case MESA_FORMAT_A_SINT16: 1764 return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes; 1765 case MESA_FORMAT_A_SINT32: 1766 return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes; 1767 1768 case MESA_FORMAT_I_UINT8: 1769 return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE; 1770 case MESA_FORMAT_I_UINT16: 1771 return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes; 1772 case MESA_FORMAT_I_UINT32: 1773 return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1774 case MESA_FORMAT_I_SINT8: 1775 return format == GL_RED_INTEGER && type == GL_BYTE; 1776 case MESA_FORMAT_I_SINT16: 1777 return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes; 1778 case MESA_FORMAT_I_SINT32: 1779 return format == GL_RED_INTEGER && type == GL_INT && !swapBytes; 1780 1781 case MESA_FORMAT_L_UINT8: 1782 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE; 1783 case MESA_FORMAT_L_UINT16: 1784 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT && 1785 !swapBytes; 1786 case MESA_FORMAT_L_UINT32: 1787 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT && 1788 !swapBytes; 1789 case MESA_FORMAT_L_SINT8: 1790 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE; 1791 case MESA_FORMAT_L_SINT16: 1792 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT && 1793 !swapBytes; 1794 case MESA_FORMAT_L_SINT32: 1795 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes; 1796 1797 case MESA_FORMAT_LA_UINT8: 1798 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1799 type == GL_UNSIGNED_BYTE && !swapBytes; 1800 case MESA_FORMAT_LA_UINT16: 1801 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1802 type == GL_UNSIGNED_SHORT && !swapBytes; 1803 case MESA_FORMAT_LA_UINT32: 1804 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1805 type == GL_UNSIGNED_INT && !swapBytes; 1806 case MESA_FORMAT_LA_SINT8: 1807 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE && 1808 !swapBytes; 1809 case MESA_FORMAT_LA_SINT16: 1810 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT && 1811 !swapBytes; 1812 case MESA_FORMAT_LA_SINT32: 1813 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT && 1814 !swapBytes; 1815 1816 case MESA_FORMAT_R_SINT8: 1817 return format == GL_RED_INTEGER && type == GL_BYTE; 1818 case MESA_FORMAT_RG_SINT8: 1819 return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes; 1820 case MESA_FORMAT_RGB_SINT8: 1821 return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes; 1822 case MESA_FORMAT_RGBA_SINT8: 1823 return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes; 1824 case MESA_FORMAT_R_SINT16: 1825 return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes; 1826 case MESA_FORMAT_RG_SINT16: 1827 return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes; 1828 case MESA_FORMAT_RGB_SINT16: 1829 return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes; 1830 case MESA_FORMAT_RGBA_SINT16: 1831 return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes; 1832 case MESA_FORMAT_R_SINT32: 1833 return format == GL_RED_INTEGER && type == GL_INT && !swapBytes; 1834 case MESA_FORMAT_RG_SINT32: 1835 return format == GL_RG_INTEGER && type == GL_INT && !swapBytes; 1836 case MESA_FORMAT_RGB_SINT32: 1837 return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes; 1838 case MESA_FORMAT_RGBA_SINT32: 1839 return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes; 1840 1841 case MESA_FORMAT_R_UINT8: 1842 return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE; 1843 case MESA_FORMAT_RG_UINT8: 1844 return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes; 1845 case MESA_FORMAT_RGB_UINT8: 1846 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes; 1847 case MESA_FORMAT_RGBA_UINT8: 1848 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE && 1849 !swapBytes; 1850 case MESA_FORMAT_R_UINT16: 1851 return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && 1852 !swapBytes; 1853 case MESA_FORMAT_RG_UINT16: 1854 return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes; 1855 case MESA_FORMAT_RGB_UINT16: 1856 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT && 1857 !swapBytes; 1858 case MESA_FORMAT_RGBA_UINT16: 1859 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT && 1860 !swapBytes; 1861 case MESA_FORMAT_R_UINT32: 1862 return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1863 case MESA_FORMAT_RG_UINT32: 1864 return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1865 case MESA_FORMAT_RGB_UINT32: 1866 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1867 case MESA_FORMAT_RGBA_UINT32: 1868 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1869 1870 case MESA_FORMAT_R_SNORM8: 1871 return format == GL_RED && type == GL_BYTE; 1872 case MESA_FORMAT_R8G8_SNORM: 1873 return format == GL_RG && type == GL_BYTE && littleEndian && 1874 !swapBytes; 1875 case MESA_FORMAT_X8B8G8R8_SNORM: 1876 return GL_FALSE; 1877 1878 case MESA_FORMAT_A8B8G8R8_SNORM: 1879 if (format == GL_RGBA && type == GL_BYTE && !littleEndian) 1880 return GL_TRUE; 1881 1882 if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian) 1883 return GL_TRUE; 1884 1885 return GL_FALSE; 1886 1887 case MESA_FORMAT_R8G8B8A8_SNORM: 1888 if (format == GL_RGBA && type == GL_BYTE && littleEndian) 1889 return GL_TRUE; 1890 1891 if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian) 1892 return GL_TRUE; 1893 1894 return GL_FALSE; 1895 1896 case MESA_FORMAT_R_SNORM16: 1897 return format == GL_RED && type == GL_SHORT && 1898 !swapBytes; 1899 case MESA_FORMAT_R16G16_SNORM: 1900 return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes; 1901 case MESA_FORMAT_RGB_SNORM16: 1902 return format == GL_RGB && type == GL_SHORT && !swapBytes; 1903 case MESA_FORMAT_RGBA_SNORM16: 1904 return format == GL_RGBA && type == GL_SHORT && !swapBytes; 1905 case MESA_FORMAT_RGBA_UNORM16: 1906 return format == GL_RGBA && type == GL_UNSIGNED_SHORT && 1907 !swapBytes; 1908 1909 case MESA_FORMAT_A_SNORM8: 1910 return format == GL_ALPHA && type == GL_BYTE; 1911 case MESA_FORMAT_L_SNORM8: 1912 return format == GL_LUMINANCE && type == GL_BYTE; 1913 case MESA_FORMAT_L8A8_SNORM: 1914 return format == GL_LUMINANCE_ALPHA && type == GL_BYTE && 1915 littleEndian && !swapBytes; 1916 case MESA_FORMAT_A8L8_SNORM: 1917 return format == GL_LUMINANCE_ALPHA && type == GL_BYTE && 1918 !littleEndian && !swapBytes; 1919 case MESA_FORMAT_I_SNORM8: 1920 return format == GL_RED && type == GL_BYTE; 1921 case MESA_FORMAT_A_SNORM16: 1922 return format == GL_ALPHA && type == GL_SHORT && !swapBytes; 1923 case MESA_FORMAT_L_SNORM16: 1924 return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes; 1925 case MESA_FORMAT_LA_SNORM16: 1926 return format == GL_LUMINANCE_ALPHA && type == GL_SHORT && 1927 littleEndian && !swapBytes; 1928 case MESA_FORMAT_I_SNORM16: 1929 return format == GL_RED && type == GL_SHORT && littleEndian && 1930 !swapBytes; 1931 1932 case MESA_FORMAT_B10G10R10A2_UINT: 1933 return (format == GL_BGRA_INTEGER_EXT && 1934 type == GL_UNSIGNED_INT_2_10_10_10_REV && 1935 !swapBytes); 1936 1937 case MESA_FORMAT_R10G10B10A2_UINT: 1938 return (format == GL_RGBA_INTEGER_EXT && 1939 type == GL_UNSIGNED_INT_2_10_10_10_REV && 1940 !swapBytes); 1941 1942 case MESA_FORMAT_B5G6R5_UINT: 1943 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5; 1944 1945 case MESA_FORMAT_R5G6B5_UINT: 1946 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5_REV; 1947 1948 case MESA_FORMAT_B2G3R3_UINT: 1949 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_3_3_2; 1950 1951 case MESA_FORMAT_R3G3B2_UINT: 1952 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_2_3_3_REV; 1953 1954 case MESA_FORMAT_A4B4G4R4_UINT: 1955 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1956 return GL_TRUE; 1957 1958 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes) 1959 return GL_TRUE; 1960 return GL_FALSE; 1961 1962 case MESA_FORMAT_R4G4B4A4_UINT: 1963 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1964 return GL_TRUE; 1965 1966 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes) 1967 return GL_TRUE; 1968 1969 return GL_FALSE; 1970 1971 case MESA_FORMAT_B4G4R4A4_UINT: 1972 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && 1973 !swapBytes; 1974 1975 case MESA_FORMAT_A4R4G4B4_UINT: 1976 return GL_FALSE; 1977 1978 case MESA_FORMAT_A1B5G5R5_UINT: 1979 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1980 !swapBytes; 1981 1982 case MESA_FORMAT_B5G5R5A1_UINT: 1983 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV && 1984 !swapBytes; 1985 1986 case MESA_FORMAT_A1R5G5B5_UINT: 1987 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1988 !swapBytes; 1989 1990 case MESA_FORMAT_R5G5B5A1_UINT: 1991 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV; 1992 1993 case MESA_FORMAT_A8B8G8R8_UINT: 1994 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 1995 return GL_TRUE; 1996 1997 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes) 1998 return GL_TRUE; 1999 return GL_FALSE; 2000 2001 case MESA_FORMAT_A8R8G8B8_UINT: 2002 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && 2003 !swapBytes) 2004 return GL_TRUE; 2005 2006 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2007 swapBytes) 2008 return GL_TRUE; 2009 2010 return GL_FALSE; 2011 2012 case MESA_FORMAT_R8G8B8A8_UINT: 2013 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2014 !swapBytes) 2015 return GL_TRUE; 2016 2017 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 2018 return GL_TRUE; 2019 2020 return GL_FALSE; 2021 2022 case MESA_FORMAT_B8G8R8A8_UINT: 2023 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2024 !swapBytes) 2025 return GL_TRUE; 2026 2027 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 2028 return GL_TRUE; 2029 2030 return GL_FALSE; 2031 2032 case MESA_FORMAT_R9G9B9E5_FLOAT: 2033 return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV && 2034 !swapBytes; 2035 2036 case MESA_FORMAT_R11G11B10_FLOAT: 2037 return format == GL_RGB && type == GL_UNSIGNED_INT_10F_11F_11F_REV && 2038 !swapBytes; 2039 2040 case MESA_FORMAT_Z_FLOAT32: 2041 return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes; 2042 2043 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 2044 return format == GL_DEPTH_STENCIL && 2045 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes; 2046 2047 case MESA_FORMAT_B4G4R4X4_UNORM: 2048 case MESA_FORMAT_B5G5R5X1_UNORM: 2049 case MESA_FORMAT_R8G8B8X8_SNORM: 2050 case MESA_FORMAT_R8G8B8X8_SRGB: 2051 case MESA_FORMAT_X8B8G8R8_SRGB: 2052 case MESA_FORMAT_RGBX_UINT8: 2053 case MESA_FORMAT_RGBX_SINT8: 2054 case MESA_FORMAT_B10G10R10X2_UNORM: 2055 case MESA_FORMAT_RGBX_UNORM16: 2056 case MESA_FORMAT_RGBX_SNORM16: 2057 case MESA_FORMAT_RGBX_FLOAT16: 2058 case MESA_FORMAT_RGBX_UINT16: 2059 case MESA_FORMAT_RGBX_SINT16: 2060 case MESA_FORMAT_RGBX_FLOAT32: 2061 case MESA_FORMAT_RGBX_UINT32: 2062 case MESA_FORMAT_RGBX_SINT32: 2063 return GL_FALSE; 2064 2065 case MESA_FORMAT_R10G10B10X2_UNORM: 2066 return format == GL_RGB && type == GL_UNSIGNED_INT_2_10_10_10_REV && 2067 !swapBytes; 2068 case MESA_FORMAT_R10G10B10A2_UNORM: 2069 return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV && 2070 !swapBytes; 2071 2072 case MESA_FORMAT_G8R8_SNORM: 2073 return format == GL_RG && type == GL_BYTE && !littleEndian && 2074 !swapBytes; 2075 2076 case MESA_FORMAT_G16R16_SNORM: 2077 return format == GL_RG && type == GL_SHORT && !littleEndian && 2078 !swapBytes; 2079 2080 case MESA_FORMAT_B8G8R8X8_SRGB: 2081 case MESA_FORMAT_X8R8G8B8_SRGB: 2082 return GL_FALSE; 2083 default: 2084 assert(_mesa_is_format_compressed(mesa_format)); 2085 if (error) 2086 *error = GL_INVALID_ENUM; 2087 } 2088 return GL_FALSE; 2089} 2090 2091