formats.c revision b8e80941
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 case MESA_FORMAT_ATC_RGB: 716 return MESA_FORMAT_BGR_UNORM8; 717 case MESA_FORMAT_ETC2_RGBA8_EAC: 718 case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC: 719 case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: 720 case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: 721 case MESA_FORMAT_ATC_RGBA_EXPLICIT: 722 case MESA_FORMAT_ATC_RGBA_INTERPOLATED: 723 return MESA_FORMAT_A8B8G8R8_UNORM; 724 case MESA_FORMAT_ETC2_R11_EAC: 725 case MESA_FORMAT_ETC2_SIGNED_R11_EAC: 726 return MESA_FORMAT_R_UNORM16; 727 case MESA_FORMAT_ETC2_RG11_EAC: 728 case MESA_FORMAT_ETC2_SIGNED_RG11_EAC: 729 return MESA_FORMAT_R16G16_UNORM; 730 case MESA_FORMAT_BPTC_RGBA_UNORM: 731 case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM: 732 return MESA_FORMAT_A8B8G8R8_UNORM; 733 case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT: 734 case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT: 735 return MESA_FORMAT_RGB_FLOAT32; 736 default: 737#ifdef DEBUG 738 assert(!_mesa_is_format_compressed(format)); 739#endif 740 return format; 741 } 742} 743 744 745GLuint 746_mesa_format_num_components(mesa_format format) 747{ 748 const struct gl_format_info *info = _mesa_get_format_info(format); 749 return ((info->RedBits > 0) + 750 (info->GreenBits > 0) + 751 (info->BlueBits > 0) + 752 (info->AlphaBits > 0) + 753 (info->LuminanceBits > 0) + 754 (info->IntensityBits > 0) + 755 (info->DepthBits > 0) + 756 (info->StencilBits > 0)); 757} 758 759 760/** 761 * Returns true if a color format has data stored in the R/G/B/A channels, 762 * given an index from 0 to 3. 763 */ 764bool 765_mesa_format_has_color_component(mesa_format format, int component) 766{ 767 const struct gl_format_info *info = _mesa_get_format_info(format); 768 769 assert(info->BaseFormat != GL_DEPTH_COMPONENT && 770 info->BaseFormat != GL_DEPTH_STENCIL && 771 info->BaseFormat != GL_STENCIL_INDEX); 772 773 switch (component) { 774 case 0: 775 return (info->RedBits + info->IntensityBits + info->LuminanceBits) > 0; 776 case 1: 777 return (info->GreenBits + info->IntensityBits + info->LuminanceBits) > 0; 778 case 2: 779 return (info->BlueBits + info->IntensityBits + info->LuminanceBits) > 0; 780 case 3: 781 return (info->AlphaBits + info->IntensityBits) > 0; 782 default: 783 assert(!"Invalid color component: must be 0..3"); 784 return false; 785 } 786} 787 788 789/** 790 * Return number of bytes needed to store an image of the given size 791 * in the given format. 792 */ 793GLuint 794_mesa_format_image_size(mesa_format format, GLsizei width, 795 GLsizei height, GLsizei depth) 796{ 797 const struct gl_format_info *info = _mesa_get_format_info(format); 798 GLuint sz; 799 /* Strictly speaking, a conditional isn't needed here */ 800 if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) { 801 /* compressed format (2D only for now) */ 802 const GLuint bw = info->BlockWidth; 803 const GLuint bh = info->BlockHeight; 804 const GLuint bd = info->BlockDepth; 805 const GLuint wblocks = (width + bw - 1) / bw; 806 const GLuint hblocks = (height + bh - 1) / bh; 807 const GLuint dblocks = (depth + bd - 1) / bd; 808 sz = wblocks * hblocks * dblocks * info->BytesPerBlock; 809 } else 810 /* non-compressed */ 811 sz = width * height * depth * info->BytesPerBlock; 812 813 return sz; 814} 815 816 817/** 818 * Same as _mesa_format_image_size() but returns a 64-bit value to 819 * accommodate very large textures. 820 */ 821uint64_t 822_mesa_format_image_size64(mesa_format format, GLsizei width, 823 GLsizei height, GLsizei depth) 824{ 825 const struct gl_format_info *info = _mesa_get_format_info(format); 826 uint64_t sz; 827 /* Strictly speaking, a conditional isn't needed here */ 828 if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) { 829 /* compressed format (2D only for now) */ 830 const uint64_t bw = info->BlockWidth; 831 const uint64_t bh = info->BlockHeight; 832 const uint64_t bd = info->BlockDepth; 833 const uint64_t wblocks = (width + bw - 1) / bw; 834 const uint64_t hblocks = (height + bh - 1) / bh; 835 const uint64_t dblocks = (depth + bd - 1) / bd; 836 sz = wblocks * hblocks * dblocks * info->BytesPerBlock; 837 } else 838 /* non-compressed */ 839 sz = ((uint64_t) width * (uint64_t) height * 840 (uint64_t) depth * info->BytesPerBlock); 841 842 return sz; 843} 844 845 846 847GLint 848_mesa_format_row_stride(mesa_format format, GLsizei width) 849{ 850 const struct gl_format_info *info = _mesa_get_format_info(format); 851 /* Strictly speaking, a conditional isn't needed here */ 852 if (info->BlockWidth > 1 || info->BlockHeight > 1) { 853 /* compressed format */ 854 const GLuint bw = info->BlockWidth; 855 const GLuint wblocks = (width + bw - 1) / bw; 856 const GLint stride = wblocks * info->BytesPerBlock; 857 return stride; 858 } 859 else { 860 const GLint stride = width * info->BytesPerBlock; 861 return stride; 862 } 863} 864 865 866 867/** 868 * Return datatype and number of components per texel for the given 869 * uncompressed mesa_format. Only used for mipmap generation code. 870 */ 871void 872_mesa_uncompressed_format_to_type_and_comps(mesa_format format, 873 GLenum *datatype, GLuint *comps) 874{ 875 switch (format) { 876 case MESA_FORMAT_A8B8G8R8_UNORM: 877 case MESA_FORMAT_R8G8B8A8_UNORM: 878 case MESA_FORMAT_B8G8R8A8_UNORM: 879 case MESA_FORMAT_A8R8G8B8_UNORM: 880 case MESA_FORMAT_X8B8G8R8_UNORM: 881 case MESA_FORMAT_R8G8B8X8_UNORM: 882 case MESA_FORMAT_B8G8R8X8_UNORM: 883 case MESA_FORMAT_X8R8G8B8_UNORM: 884 case MESA_FORMAT_A8B8G8R8_UINT: 885 case MESA_FORMAT_R8G8B8A8_UINT: 886 case MESA_FORMAT_B8G8R8A8_UINT: 887 case MESA_FORMAT_A8R8G8B8_UINT: 888 *datatype = GL_UNSIGNED_BYTE; 889 *comps = 4; 890 return; 891 case MESA_FORMAT_BGR_UNORM8: 892 case MESA_FORMAT_RGB_UNORM8: 893 *datatype = GL_UNSIGNED_BYTE; 894 *comps = 3; 895 return; 896 case MESA_FORMAT_B5G6R5_UNORM: 897 case MESA_FORMAT_R5G6B5_UNORM: 898 case MESA_FORMAT_B5G6R5_UINT: 899 case MESA_FORMAT_R5G6B5_UINT: 900 *datatype = GL_UNSIGNED_SHORT_5_6_5; 901 *comps = 3; 902 return; 903 904 case MESA_FORMAT_B4G4R4A4_UNORM: 905 case MESA_FORMAT_A4R4G4B4_UNORM: 906 case MESA_FORMAT_B4G4R4X4_UNORM: 907 case MESA_FORMAT_B4G4R4A4_UINT: 908 case MESA_FORMAT_A4R4G4B4_UINT: 909 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 910 *comps = 4; 911 return; 912 913 case MESA_FORMAT_B5G5R5A1_UNORM: 914 case MESA_FORMAT_A1R5G5B5_UNORM: 915 case MESA_FORMAT_B5G5R5X1_UNORM: 916 case MESA_FORMAT_B5G5R5A1_UINT: 917 case MESA_FORMAT_A1R5G5B5_UINT: 918 *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV; 919 *comps = 4; 920 return; 921 922 case MESA_FORMAT_B10G10R10A2_UNORM: 923 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 924 *comps = 4; 925 return; 926 927 case MESA_FORMAT_A1B5G5R5_UNORM: 928 case MESA_FORMAT_A1B5G5R5_UINT: 929 case MESA_FORMAT_X1B5G5R5_UNORM: 930 *datatype = GL_UNSIGNED_SHORT_5_5_5_1; 931 *comps = 4; 932 return; 933 934 case MESA_FORMAT_L4A4_UNORM: 935 *datatype = MESA_UNSIGNED_BYTE_4_4; 936 *comps = 2; 937 return; 938 939 case MESA_FORMAT_L8A8_UNORM: 940 case MESA_FORMAT_A8L8_UNORM: 941 case MESA_FORMAT_R8G8_UNORM: 942 case MESA_FORMAT_G8R8_UNORM: 943 *datatype = GL_UNSIGNED_BYTE; 944 *comps = 2; 945 return; 946 947 case MESA_FORMAT_L16A16_UNORM: 948 case MESA_FORMAT_A16L16_UNORM: 949 case MESA_FORMAT_R16G16_UNORM: 950 case MESA_FORMAT_G16R16_UNORM: 951 *datatype = GL_UNSIGNED_SHORT; 952 *comps = 2; 953 return; 954 955 case MESA_FORMAT_R_UNORM16: 956 case MESA_FORMAT_A_UNORM16: 957 case MESA_FORMAT_L_UNORM16: 958 case MESA_FORMAT_I_UNORM16: 959 *datatype = GL_UNSIGNED_SHORT; 960 *comps = 1; 961 return; 962 963 case MESA_FORMAT_R3G3B2_UNORM: 964 case MESA_FORMAT_R3G3B2_UINT: 965 *datatype = GL_UNSIGNED_BYTE_2_3_3_REV; 966 *comps = 3; 967 return; 968 case MESA_FORMAT_A4B4G4R4_UNORM: 969 case MESA_FORMAT_A4B4G4R4_UINT: 970 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 971 *comps = 4; 972 return; 973 974 case MESA_FORMAT_R4G4B4A4_UNORM: 975 case MESA_FORMAT_R4G4B4A4_UINT: 976 *datatype = GL_UNSIGNED_SHORT_4_4_4_4; 977 *comps = 4; 978 return; 979 case MESA_FORMAT_R5G5B5A1_UNORM: 980 case MESA_FORMAT_R5G5B5A1_UINT: 981 *datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV; 982 *comps = 4; 983 return; 984 case MESA_FORMAT_A2B10G10R10_UNORM: 985 case MESA_FORMAT_A2B10G10R10_UINT: 986 *datatype = GL_UNSIGNED_INT_10_10_10_2; 987 *comps = 4; 988 return; 989 case MESA_FORMAT_A2R10G10B10_UNORM: 990 case MESA_FORMAT_A2R10G10B10_UINT: 991 *datatype = GL_UNSIGNED_INT_10_10_10_2; 992 *comps = 4; 993 return; 994 995 case MESA_FORMAT_B2G3R3_UNORM: 996 case MESA_FORMAT_B2G3R3_UINT: 997 *datatype = GL_UNSIGNED_BYTE_3_3_2; 998 *comps = 3; 999 return; 1000 1001 case MESA_FORMAT_A_UNORM8: 1002 case MESA_FORMAT_L_UNORM8: 1003 case MESA_FORMAT_I_UNORM8: 1004 case MESA_FORMAT_R_UNORM8: 1005 case MESA_FORMAT_S_UINT8: 1006 *datatype = GL_UNSIGNED_BYTE; 1007 *comps = 1; 1008 return; 1009 1010 case MESA_FORMAT_YCBCR: 1011 case MESA_FORMAT_YCBCR_REV: 1012 *datatype = GL_UNSIGNED_SHORT; 1013 *comps = 2; 1014 return; 1015 1016 case MESA_FORMAT_S8_UINT_Z24_UNORM: 1017 *datatype = GL_UNSIGNED_INT_24_8_MESA; 1018 *comps = 2; 1019 return; 1020 1021 case MESA_FORMAT_Z24_UNORM_S8_UINT: 1022 *datatype = GL_UNSIGNED_INT_8_24_REV_MESA; 1023 *comps = 2; 1024 return; 1025 1026 case MESA_FORMAT_Z_UNORM16: 1027 *datatype = GL_UNSIGNED_SHORT; 1028 *comps = 1; 1029 return; 1030 1031 case MESA_FORMAT_Z24_UNORM_X8_UINT: 1032 *datatype = GL_UNSIGNED_INT; 1033 *comps = 1; 1034 return; 1035 1036 case MESA_FORMAT_X8_UINT_Z24_UNORM: 1037 *datatype = GL_UNSIGNED_INT; 1038 *comps = 1; 1039 return; 1040 1041 case MESA_FORMAT_Z_UNORM32: 1042 *datatype = GL_UNSIGNED_INT; 1043 *comps = 1; 1044 return; 1045 1046 case MESA_FORMAT_Z_FLOAT32: 1047 *datatype = GL_FLOAT; 1048 *comps = 1; 1049 return; 1050 1051 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 1052 *datatype = GL_FLOAT_32_UNSIGNED_INT_24_8_REV; 1053 *comps = 1; 1054 return; 1055 1056 case MESA_FORMAT_R_SNORM8: 1057 case MESA_FORMAT_A_SNORM8: 1058 case MESA_FORMAT_L_SNORM8: 1059 case MESA_FORMAT_I_SNORM8: 1060 *datatype = GL_BYTE; 1061 *comps = 1; 1062 return; 1063 case MESA_FORMAT_R8G8_SNORM: 1064 case MESA_FORMAT_L8A8_SNORM: 1065 case MESA_FORMAT_A8L8_SNORM: 1066 *datatype = GL_BYTE; 1067 *comps = 2; 1068 return; 1069 case MESA_FORMAT_A8B8G8R8_SNORM: 1070 case MESA_FORMAT_R8G8B8A8_SNORM: 1071 case MESA_FORMAT_X8B8G8R8_SNORM: 1072 *datatype = GL_BYTE; 1073 *comps = 4; 1074 return; 1075 1076 case MESA_FORMAT_RGBA_UNORM16: 1077 *datatype = GL_UNSIGNED_SHORT; 1078 *comps = 4; 1079 return; 1080 1081 case MESA_FORMAT_R_SNORM16: 1082 case MESA_FORMAT_A_SNORM16: 1083 case MESA_FORMAT_L_SNORM16: 1084 case MESA_FORMAT_I_SNORM16: 1085 *datatype = GL_SHORT; 1086 *comps = 1; 1087 return; 1088 case MESA_FORMAT_R16G16_SNORM: 1089 case MESA_FORMAT_LA_SNORM16: 1090 *datatype = GL_SHORT; 1091 *comps = 2; 1092 return; 1093 case MESA_FORMAT_RGB_SNORM16: 1094 *datatype = GL_SHORT; 1095 *comps = 3; 1096 return; 1097 case MESA_FORMAT_RGBA_SNORM16: 1098 *datatype = GL_SHORT; 1099 *comps = 4; 1100 return; 1101 1102 case MESA_FORMAT_BGR_SRGB8: 1103 *datatype = GL_UNSIGNED_BYTE; 1104 *comps = 3; 1105 return; 1106 case MESA_FORMAT_A8B8G8R8_SRGB: 1107 case MESA_FORMAT_B8G8R8A8_SRGB: 1108 case MESA_FORMAT_A8R8G8B8_SRGB: 1109 case MESA_FORMAT_R8G8B8A8_SRGB: 1110 *datatype = GL_UNSIGNED_BYTE; 1111 *comps = 4; 1112 return; 1113 case MESA_FORMAT_L_SRGB8: 1114 case MESA_FORMAT_R_SRGB8: 1115 *datatype = GL_UNSIGNED_BYTE; 1116 *comps = 1; 1117 return; 1118 case MESA_FORMAT_L8A8_SRGB: 1119 case MESA_FORMAT_A8L8_SRGB: 1120 *datatype = GL_UNSIGNED_BYTE; 1121 *comps = 2; 1122 return; 1123 1124 case MESA_FORMAT_RGBA_FLOAT32: 1125 *datatype = GL_FLOAT; 1126 *comps = 4; 1127 return; 1128 case MESA_FORMAT_RGBA_FLOAT16: 1129 *datatype = GL_HALF_FLOAT_ARB; 1130 *comps = 4; 1131 return; 1132 case MESA_FORMAT_RGB_FLOAT32: 1133 *datatype = GL_FLOAT; 1134 *comps = 3; 1135 return; 1136 case MESA_FORMAT_RGB_FLOAT16: 1137 *datatype = GL_HALF_FLOAT_ARB; 1138 *comps = 3; 1139 return; 1140 case MESA_FORMAT_LA_FLOAT32: 1141 case MESA_FORMAT_RG_FLOAT32: 1142 *datatype = GL_FLOAT; 1143 *comps = 2; 1144 return; 1145 case MESA_FORMAT_LA_FLOAT16: 1146 case MESA_FORMAT_RG_FLOAT16: 1147 *datatype = GL_HALF_FLOAT_ARB; 1148 *comps = 2; 1149 return; 1150 case MESA_FORMAT_A_FLOAT32: 1151 case MESA_FORMAT_L_FLOAT32: 1152 case MESA_FORMAT_I_FLOAT32: 1153 case MESA_FORMAT_R_FLOAT32: 1154 *datatype = GL_FLOAT; 1155 *comps = 1; 1156 return; 1157 case MESA_FORMAT_A_FLOAT16: 1158 case MESA_FORMAT_L_FLOAT16: 1159 case MESA_FORMAT_I_FLOAT16: 1160 case MESA_FORMAT_R_FLOAT16: 1161 *datatype = GL_HALF_FLOAT_ARB; 1162 *comps = 1; 1163 return; 1164 1165 case MESA_FORMAT_A_UINT8: 1166 case MESA_FORMAT_L_UINT8: 1167 case MESA_FORMAT_I_UINT8: 1168 *datatype = GL_UNSIGNED_BYTE; 1169 *comps = 1; 1170 return; 1171 case MESA_FORMAT_LA_UINT8: 1172 *datatype = GL_UNSIGNED_BYTE; 1173 *comps = 2; 1174 return; 1175 1176 case MESA_FORMAT_A_UINT16: 1177 case MESA_FORMAT_L_UINT16: 1178 case MESA_FORMAT_I_UINT16: 1179 *datatype = GL_UNSIGNED_SHORT; 1180 *comps = 1; 1181 return; 1182 case MESA_FORMAT_LA_UINT16: 1183 *datatype = GL_UNSIGNED_SHORT; 1184 *comps = 2; 1185 return; 1186 case MESA_FORMAT_A_UINT32: 1187 case MESA_FORMAT_L_UINT32: 1188 case MESA_FORMAT_I_UINT32: 1189 *datatype = GL_UNSIGNED_INT; 1190 *comps = 1; 1191 return; 1192 case MESA_FORMAT_LA_UINT32: 1193 *datatype = GL_UNSIGNED_INT; 1194 *comps = 2; 1195 return; 1196 case MESA_FORMAT_A_SINT8: 1197 case MESA_FORMAT_L_SINT8: 1198 case MESA_FORMAT_I_SINT8: 1199 *datatype = GL_BYTE; 1200 *comps = 1; 1201 return; 1202 case MESA_FORMAT_LA_SINT8: 1203 *datatype = GL_BYTE; 1204 *comps = 2; 1205 return; 1206 1207 case MESA_FORMAT_A_SINT16: 1208 case MESA_FORMAT_L_SINT16: 1209 case MESA_FORMAT_I_SINT16: 1210 *datatype = GL_SHORT; 1211 *comps = 1; 1212 return; 1213 case MESA_FORMAT_LA_SINT16: 1214 *datatype = GL_SHORT; 1215 *comps = 2; 1216 return; 1217 1218 case MESA_FORMAT_A_SINT32: 1219 case MESA_FORMAT_L_SINT32: 1220 case MESA_FORMAT_I_SINT32: 1221 *datatype = GL_INT; 1222 *comps = 1; 1223 return; 1224 case MESA_FORMAT_LA_SINT32: 1225 *datatype = GL_INT; 1226 *comps = 2; 1227 return; 1228 1229 case MESA_FORMAT_R_SINT8: 1230 *datatype = GL_BYTE; 1231 *comps = 1; 1232 return; 1233 case MESA_FORMAT_RG_SINT8: 1234 *datatype = GL_BYTE; 1235 *comps = 2; 1236 return; 1237 case MESA_FORMAT_RGB_SINT8: 1238 *datatype = GL_BYTE; 1239 *comps = 3; 1240 return; 1241 case MESA_FORMAT_RGBA_SINT8: 1242 *datatype = GL_BYTE; 1243 *comps = 4; 1244 return; 1245 case MESA_FORMAT_R_SINT16: 1246 *datatype = GL_SHORT; 1247 *comps = 1; 1248 return; 1249 case MESA_FORMAT_RG_SINT16: 1250 *datatype = GL_SHORT; 1251 *comps = 2; 1252 return; 1253 case MESA_FORMAT_RGB_SINT16: 1254 *datatype = GL_SHORT; 1255 *comps = 3; 1256 return; 1257 case MESA_FORMAT_RGBA_SINT16: 1258 *datatype = GL_SHORT; 1259 *comps = 4; 1260 return; 1261 case MESA_FORMAT_R_SINT32: 1262 *datatype = GL_INT; 1263 *comps = 1; 1264 return; 1265 case MESA_FORMAT_RG_SINT32: 1266 *datatype = GL_INT; 1267 *comps = 2; 1268 return; 1269 case MESA_FORMAT_RGB_SINT32: 1270 *datatype = GL_INT; 1271 *comps = 3; 1272 return; 1273 case MESA_FORMAT_RGBA_SINT32: 1274 *datatype = GL_INT; 1275 *comps = 4; 1276 return; 1277 1278 /** 1279 * \name Non-normalized unsigned integer formats. 1280 */ 1281 case MESA_FORMAT_R_UINT8: 1282 *datatype = GL_UNSIGNED_BYTE; 1283 *comps = 1; 1284 return; 1285 case MESA_FORMAT_RG_UINT8: 1286 *datatype = GL_UNSIGNED_BYTE; 1287 *comps = 2; 1288 return; 1289 case MESA_FORMAT_RGB_UINT8: 1290 *datatype = GL_UNSIGNED_BYTE; 1291 *comps = 3; 1292 return; 1293 case MESA_FORMAT_RGBA_UINT8: 1294 *datatype = GL_UNSIGNED_BYTE; 1295 *comps = 4; 1296 return; 1297 case MESA_FORMAT_R_UINT16: 1298 *datatype = GL_UNSIGNED_SHORT; 1299 *comps = 1; 1300 return; 1301 case MESA_FORMAT_RG_UINT16: 1302 *datatype = GL_UNSIGNED_SHORT; 1303 *comps = 2; 1304 return; 1305 case MESA_FORMAT_RGB_UINT16: 1306 *datatype = GL_UNSIGNED_SHORT; 1307 *comps = 3; 1308 return; 1309 case MESA_FORMAT_RGBA_UINT16: 1310 *datatype = GL_UNSIGNED_SHORT; 1311 *comps = 4; 1312 return; 1313 case MESA_FORMAT_R_UINT32: 1314 *datatype = GL_UNSIGNED_INT; 1315 *comps = 1; 1316 return; 1317 case MESA_FORMAT_RG_UINT32: 1318 *datatype = GL_UNSIGNED_INT; 1319 *comps = 2; 1320 return; 1321 case MESA_FORMAT_RGB_UINT32: 1322 *datatype = GL_UNSIGNED_INT; 1323 *comps = 3; 1324 return; 1325 case MESA_FORMAT_RGBA_UINT32: 1326 *datatype = GL_UNSIGNED_INT; 1327 *comps = 4; 1328 return; 1329 1330 case MESA_FORMAT_R9G9B9E5_FLOAT: 1331 *datatype = GL_UNSIGNED_INT_5_9_9_9_REV; 1332 *comps = 3; 1333 return; 1334 1335 case MESA_FORMAT_R11G11B10_FLOAT: 1336 *datatype = GL_UNSIGNED_INT_10F_11F_11F_REV; 1337 *comps = 3; 1338 return; 1339 1340 case MESA_FORMAT_B10G10R10A2_UINT: 1341 case MESA_FORMAT_R10G10B10A2_UINT: 1342 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1343 *comps = 4; 1344 return; 1345 1346 case MESA_FORMAT_R8G8B8X8_SRGB: 1347 case MESA_FORMAT_X8B8G8R8_SRGB: 1348 case MESA_FORMAT_RGBX_UINT8: 1349 *datatype = GL_UNSIGNED_BYTE; 1350 *comps = 4; 1351 return; 1352 1353 case MESA_FORMAT_R8G8B8X8_SNORM: 1354 case MESA_FORMAT_RGBX_SINT8: 1355 *datatype = GL_BYTE; 1356 *comps = 4; 1357 return; 1358 1359 case MESA_FORMAT_B10G10R10X2_UNORM: 1360 case MESA_FORMAT_R10G10B10X2_UNORM: 1361 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1362 *comps = 4; 1363 return; 1364 1365 case MESA_FORMAT_RGBX_UNORM16: 1366 case MESA_FORMAT_RGBX_UINT16: 1367 *datatype = GL_UNSIGNED_SHORT; 1368 *comps = 4; 1369 return; 1370 1371 case MESA_FORMAT_RGBX_SNORM16: 1372 case MESA_FORMAT_RGBX_SINT16: 1373 *datatype = GL_SHORT; 1374 *comps = 4; 1375 return; 1376 1377 case MESA_FORMAT_RGBX_FLOAT16: 1378 *datatype = GL_HALF_FLOAT; 1379 *comps = 4; 1380 return; 1381 1382 case MESA_FORMAT_RGBX_FLOAT32: 1383 *datatype = GL_FLOAT; 1384 *comps = 4; 1385 return; 1386 1387 case MESA_FORMAT_RGBX_UINT32: 1388 *datatype = GL_UNSIGNED_INT; 1389 *comps = 4; 1390 return; 1391 1392 case MESA_FORMAT_RGBX_SINT32: 1393 *datatype = GL_INT; 1394 *comps = 4; 1395 return; 1396 1397 case MESA_FORMAT_R10G10B10A2_UNORM: 1398 *datatype = GL_UNSIGNED_INT_2_10_10_10_REV; 1399 *comps = 4; 1400 return; 1401 1402 case MESA_FORMAT_G8R8_SNORM: 1403 *datatype = GL_BYTE; 1404 *comps = 2; 1405 return; 1406 1407 case MESA_FORMAT_G16R16_SNORM: 1408 *datatype = GL_SHORT; 1409 *comps = 2; 1410 return; 1411 1412 case MESA_FORMAT_B8G8R8X8_SRGB: 1413 case MESA_FORMAT_X8R8G8B8_SRGB: 1414 *datatype = GL_UNSIGNED_BYTE; 1415 *comps = 4; 1416 return; 1417 1418 case MESA_FORMAT_COUNT: 1419 assert(0); 1420 return; 1421 default: 1422 /* Warn if any formats are not handled */ 1423 _mesa_problem(NULL, "bad format %s in _mesa_uncompressed_format_to_type_and_comps", 1424 _mesa_get_format_name(format)); 1425 assert(format == MESA_FORMAT_NONE || 1426 _mesa_is_format_compressed(format)); 1427 *datatype = 0; 1428 *comps = 1; 1429 } 1430} 1431 1432/** 1433 * Check if a mesa_format exactly matches a GL format/type combination 1434 * such that we can use memcpy() from one to the other. 1435 * \param mesa_format a MESA_FORMAT_x value 1436 * \param format the user-specified image format 1437 * \param type the user-specified image datatype 1438 * \param swapBytes typically the current pixel pack/unpack byteswap state 1439 * \param[out] error GL_NO_ERROR if format is an expected input. 1440 * GL_INVALID_ENUM if format is an unexpected input. 1441 * \return GL_TRUE if the formats match, GL_FALSE otherwise. 1442 */ 1443GLboolean 1444_mesa_format_matches_format_and_type(mesa_format mesa_format, 1445 GLenum format, GLenum type, 1446 GLboolean swapBytes, GLenum *error) 1447{ 1448 const GLboolean littleEndian = _mesa_little_endian(); 1449 if (error) 1450 *error = GL_NO_ERROR; 1451 1452 /* Note: When reading a GL format/type combination, the format lists channel 1453 * assignments from most significant channel in the type to least 1454 * significant. A type with _REV indicates that the assignments are 1455 * swapped, so they are listed from least significant to most significant. 1456 * 1457 * Compressed formats will fall through and return GL_FALSE. 1458 * 1459 * For sanity, please keep this switch statement ordered the same as the 1460 * enums in formats.h. 1461 */ 1462 1463 switch (mesa_format) { 1464 1465 case MESA_FORMAT_NONE: 1466 case MESA_FORMAT_COUNT: 1467 return GL_FALSE; 1468 1469 case MESA_FORMAT_A8B8G8R8_UNORM: 1470 case MESA_FORMAT_A8B8G8R8_SRGB: 1471 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 1472 return GL_TRUE; 1473 1474 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes) 1475 return GL_TRUE; 1476 1477 if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian) 1478 return GL_TRUE; 1479 1480 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV 1481 && !swapBytes) 1482 return GL_TRUE; 1483 1484 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 1485 && swapBytes) 1486 return GL_TRUE; 1487 1488 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian) 1489 return GL_TRUE; 1490 1491 return GL_FALSE; 1492 1493 case MESA_FORMAT_R8G8B8A8_UNORM: 1494 case MESA_FORMAT_R8G8B8A8_SRGB: 1495 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1496 !swapBytes) 1497 return GL_TRUE; 1498 1499 if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 1500 return GL_TRUE; 1501 1502 if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian) 1503 return GL_TRUE; 1504 1505 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 && 1506 !swapBytes) 1507 return GL_TRUE; 1508 1509 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1510 swapBytes) 1511 return GL_TRUE; 1512 1513 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian) 1514 return GL_TRUE; 1515 1516 return GL_FALSE; 1517 1518 case MESA_FORMAT_B8G8R8A8_UNORM: 1519 case MESA_FORMAT_B8G8R8A8_SRGB: 1520 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1521 !swapBytes) 1522 return GL_TRUE; 1523 1524 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 1525 return GL_TRUE; 1526 1527 if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && littleEndian) 1528 return GL_TRUE; 1529 1530 return GL_FALSE; 1531 1532 case MESA_FORMAT_A8R8G8B8_UNORM: 1533 case MESA_FORMAT_A8R8G8B8_SRGB: 1534 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 1535 return GL_TRUE; 1536 1537 if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV && 1538 swapBytes) 1539 return GL_TRUE; 1540 1541 if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian) 1542 return GL_TRUE; 1543 1544 return GL_FALSE; 1545 1546 case MESA_FORMAT_X8B8G8R8_UNORM: 1547 case MESA_FORMAT_R8G8B8X8_UNORM: 1548 return GL_FALSE; 1549 1550 case MESA_FORMAT_B8G8R8X8_UNORM: 1551 case MESA_FORMAT_X8R8G8B8_UNORM: 1552 return GL_FALSE; 1553 1554 case MESA_FORMAT_BGR_UNORM8: 1555 case MESA_FORMAT_BGR_SRGB8: 1556 return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian; 1557 1558 case MESA_FORMAT_RGB_UNORM8: 1559 return format == GL_RGB && type == GL_UNSIGNED_BYTE && littleEndian; 1560 1561 case MESA_FORMAT_B5G6R5_UNORM: 1562 return ((format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) || 1563 (format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5_REV)) && 1564 !swapBytes; 1565 1566 case MESA_FORMAT_R5G6B5_UNORM: 1567 return ((format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5) || 1568 (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5_REV)) && 1569 !swapBytes; 1570 1571 case MESA_FORMAT_B4G4R4A4_UNORM: 1572 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && 1573 !swapBytes; 1574 1575 case MESA_FORMAT_A4R4G4B4_UNORM: 1576 return GL_FALSE; 1577 1578 case MESA_FORMAT_A1B5G5R5_UNORM: 1579 return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1580 !swapBytes; 1581 1582 case MESA_FORMAT_X1B5G5R5_UNORM: 1583 return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1584 !swapBytes; 1585 1586 case MESA_FORMAT_B5G5R5A1_UNORM: 1587 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV && 1588 !swapBytes; 1589 1590 case MESA_FORMAT_A1R5G5B5_UNORM: 1591 return format == GL_BGRA && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1592 !swapBytes; 1593 1594 case MESA_FORMAT_L4A4_UNORM: 1595 return GL_FALSE; 1596 case MESA_FORMAT_L8A8_UNORM: 1597 case MESA_FORMAT_L8A8_SRGB: 1598 return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian; 1599 case MESA_FORMAT_A8L8_UNORM: 1600 case MESA_FORMAT_A8L8_SRGB: 1601 return GL_FALSE; 1602 1603 case MESA_FORMAT_L16A16_UNORM: 1604 return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_SHORT && littleEndian && !swapBytes; 1605 case MESA_FORMAT_A16L16_UNORM: 1606 return GL_FALSE; 1607 1608 case MESA_FORMAT_B2G3R3_UNORM: 1609 return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2; 1610 1611 case MESA_FORMAT_R3G3B2_UNORM: 1612 return format == GL_RGB && type == GL_UNSIGNED_BYTE_2_3_3_REV; 1613 1614 case MESA_FORMAT_A4B4G4R4_UNORM: 1615 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1616 return GL_TRUE; 1617 1618 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1619 return GL_TRUE; 1620 1621 return GL_FALSE; 1622 1623 case MESA_FORMAT_R4G4B4A4_UNORM: 1624 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1625 return GL_TRUE; 1626 1627 if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes) 1628 return GL_TRUE; 1629 1630 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1631 return GL_TRUE; 1632 1633 if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes) 1634 return GL_TRUE; 1635 1636 return GL_FALSE; 1637 1638 case MESA_FORMAT_R5G5B5A1_UNORM: 1639 return format == GL_RGBA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV; 1640 1641 case MESA_FORMAT_A2B10G10R10_UNORM: 1642 return format == GL_RGBA && type == GL_UNSIGNED_INT_10_10_10_2; 1643 1644 case MESA_FORMAT_A2B10G10R10_UINT: 1645 return format == GL_RGBA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2; 1646 1647 case MESA_FORMAT_A2R10G10B10_UNORM: 1648 return format == GL_BGRA && type == GL_UNSIGNED_INT_10_10_10_2; 1649 1650 case MESA_FORMAT_A2R10G10B10_UINT: 1651 return format == GL_BGRA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2; 1652 1653 case MESA_FORMAT_A_UNORM8: 1654 return format == GL_ALPHA && type == GL_UNSIGNED_BYTE; 1655 case MESA_FORMAT_A_UNORM16: 1656 return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes; 1657 case MESA_FORMAT_L_UNORM8: 1658 case MESA_FORMAT_L_SRGB8: 1659 return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE; 1660 case MESA_FORMAT_L_UNORM16: 1661 return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes; 1662 case MESA_FORMAT_I_UNORM8: 1663 return format == GL_RED && type == GL_UNSIGNED_BYTE; 1664 case MESA_FORMAT_I_UNORM16: 1665 return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes; 1666 1667 case MESA_FORMAT_YCBCR: 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 case MESA_FORMAT_YCBCR_REV: 1672 return format == GL_YCBCR_MESA && 1673 ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) || 1674 (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes)); 1675 1676 case MESA_FORMAT_R_UNORM8: 1677 case MESA_FORMAT_R_SRGB8: 1678 return format == GL_RED && type == GL_UNSIGNED_BYTE; 1679 case MESA_FORMAT_R8G8_UNORM: 1680 return format == GL_RG && type == GL_UNSIGNED_BYTE && littleEndian; 1681 case MESA_FORMAT_G8R8_UNORM: 1682 return GL_FALSE; 1683 1684 case MESA_FORMAT_R_UNORM16: 1685 return format == GL_RED && type == GL_UNSIGNED_SHORT && 1686 !swapBytes; 1687 case MESA_FORMAT_R16G16_UNORM: 1688 return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian && 1689 !swapBytes; 1690 case MESA_FORMAT_G16R16_UNORM: 1691 return GL_FALSE; 1692 1693 case MESA_FORMAT_B10G10R10A2_UNORM: 1694 return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV && 1695 !swapBytes; 1696 1697 case MESA_FORMAT_S8_UINT_Z24_UNORM: 1698 return format == GL_DEPTH_STENCIL && type == GL_UNSIGNED_INT_24_8 && 1699 !swapBytes; 1700 case MESA_FORMAT_X8_UINT_Z24_UNORM: 1701 case MESA_FORMAT_Z24_UNORM_S8_UINT: 1702 return GL_FALSE; 1703 1704 case MESA_FORMAT_Z_UNORM16: 1705 return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_SHORT && 1706 !swapBytes; 1707 1708 case MESA_FORMAT_Z24_UNORM_X8_UINT: 1709 return GL_FALSE; 1710 1711 case MESA_FORMAT_Z_UNORM32: 1712 return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT && 1713 !swapBytes; 1714 1715 case MESA_FORMAT_S_UINT8: 1716 return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE; 1717 1718 case MESA_FORMAT_RGBA_FLOAT32: 1719 return format == GL_RGBA && type == GL_FLOAT && !swapBytes; 1720 case MESA_FORMAT_RGBA_FLOAT16: 1721 return format == GL_RGBA && type == GL_HALF_FLOAT && !swapBytes; 1722 1723 case MESA_FORMAT_RGB_FLOAT32: 1724 return format == GL_RGB && type == GL_FLOAT && !swapBytes; 1725 case MESA_FORMAT_RGB_FLOAT16: 1726 return format == GL_RGB && type == GL_HALF_FLOAT && !swapBytes; 1727 1728 case MESA_FORMAT_A_FLOAT32: 1729 return format == GL_ALPHA && type == GL_FLOAT && !swapBytes; 1730 case MESA_FORMAT_A_FLOAT16: 1731 return format == GL_ALPHA && type == GL_HALF_FLOAT && !swapBytes; 1732 1733 case MESA_FORMAT_L_FLOAT32: 1734 return format == GL_LUMINANCE && type == GL_FLOAT && !swapBytes; 1735 case MESA_FORMAT_L_FLOAT16: 1736 return format == GL_LUMINANCE && type == GL_HALF_FLOAT && !swapBytes; 1737 1738 case MESA_FORMAT_LA_FLOAT32: 1739 return format == GL_LUMINANCE_ALPHA && type == GL_FLOAT && !swapBytes; 1740 case MESA_FORMAT_LA_FLOAT16: 1741 return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes; 1742 1743 case MESA_FORMAT_I_FLOAT32: 1744 return format == GL_RED && type == GL_FLOAT && !swapBytes; 1745 case MESA_FORMAT_I_FLOAT16: 1746 return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes; 1747 1748 case MESA_FORMAT_R_FLOAT32: 1749 return format == GL_RED && type == GL_FLOAT && !swapBytes; 1750 case MESA_FORMAT_R_FLOAT16: 1751 return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes; 1752 1753 case MESA_FORMAT_RG_FLOAT32: 1754 return format == GL_RG && type == GL_FLOAT && !swapBytes; 1755 case MESA_FORMAT_RG_FLOAT16: 1756 return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes; 1757 1758 case MESA_FORMAT_A_UINT8: 1759 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE; 1760 case MESA_FORMAT_A_UINT16: 1761 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT && 1762 !swapBytes; 1763 case MESA_FORMAT_A_UINT32: 1764 return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT && 1765 !swapBytes; 1766 case MESA_FORMAT_A_SINT8: 1767 return format == GL_ALPHA_INTEGER && type == GL_BYTE; 1768 case MESA_FORMAT_A_SINT16: 1769 return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes; 1770 case MESA_FORMAT_A_SINT32: 1771 return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes; 1772 1773 case MESA_FORMAT_I_UINT8: 1774 return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE; 1775 case MESA_FORMAT_I_UINT16: 1776 return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes; 1777 case MESA_FORMAT_I_UINT32: 1778 return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1779 case MESA_FORMAT_I_SINT8: 1780 return format == GL_RED_INTEGER && type == GL_BYTE; 1781 case MESA_FORMAT_I_SINT16: 1782 return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes; 1783 case MESA_FORMAT_I_SINT32: 1784 return format == GL_RED_INTEGER && type == GL_INT && !swapBytes; 1785 1786 case MESA_FORMAT_L_UINT8: 1787 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE; 1788 case MESA_FORMAT_L_UINT16: 1789 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT && 1790 !swapBytes; 1791 case MESA_FORMAT_L_UINT32: 1792 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT && 1793 !swapBytes; 1794 case MESA_FORMAT_L_SINT8: 1795 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE; 1796 case MESA_FORMAT_L_SINT16: 1797 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT && 1798 !swapBytes; 1799 case MESA_FORMAT_L_SINT32: 1800 return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes; 1801 1802 case MESA_FORMAT_LA_UINT8: 1803 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1804 type == GL_UNSIGNED_BYTE && !swapBytes; 1805 case MESA_FORMAT_LA_UINT16: 1806 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1807 type == GL_UNSIGNED_SHORT && !swapBytes; 1808 case MESA_FORMAT_LA_UINT32: 1809 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && 1810 type == GL_UNSIGNED_INT && !swapBytes; 1811 case MESA_FORMAT_LA_SINT8: 1812 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE && 1813 !swapBytes; 1814 case MESA_FORMAT_LA_SINT16: 1815 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT && 1816 !swapBytes; 1817 case MESA_FORMAT_LA_SINT32: 1818 return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT && 1819 !swapBytes; 1820 1821 case MESA_FORMAT_R_SINT8: 1822 return format == GL_RED_INTEGER && type == GL_BYTE; 1823 case MESA_FORMAT_RG_SINT8: 1824 return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes; 1825 case MESA_FORMAT_RGB_SINT8: 1826 return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes; 1827 case MESA_FORMAT_RGBA_SINT8: 1828 return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes; 1829 case MESA_FORMAT_R_SINT16: 1830 return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes; 1831 case MESA_FORMAT_RG_SINT16: 1832 return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes; 1833 case MESA_FORMAT_RGB_SINT16: 1834 return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes; 1835 case MESA_FORMAT_RGBA_SINT16: 1836 return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes; 1837 case MESA_FORMAT_R_SINT32: 1838 return format == GL_RED_INTEGER && type == GL_INT && !swapBytes; 1839 case MESA_FORMAT_RG_SINT32: 1840 return format == GL_RG_INTEGER && type == GL_INT && !swapBytes; 1841 case MESA_FORMAT_RGB_SINT32: 1842 return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes; 1843 case MESA_FORMAT_RGBA_SINT32: 1844 return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes; 1845 1846 case MESA_FORMAT_R_UINT8: 1847 return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE; 1848 case MESA_FORMAT_RG_UINT8: 1849 return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes; 1850 case MESA_FORMAT_RGB_UINT8: 1851 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes; 1852 case MESA_FORMAT_RGBA_UINT8: 1853 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE && 1854 !swapBytes; 1855 case MESA_FORMAT_R_UINT16: 1856 return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && 1857 !swapBytes; 1858 case MESA_FORMAT_RG_UINT16: 1859 return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes; 1860 case MESA_FORMAT_RGB_UINT16: 1861 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT && 1862 !swapBytes; 1863 case MESA_FORMAT_RGBA_UINT16: 1864 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT && 1865 !swapBytes; 1866 case MESA_FORMAT_R_UINT32: 1867 return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1868 case MESA_FORMAT_RG_UINT32: 1869 return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1870 case MESA_FORMAT_RGB_UINT32: 1871 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1872 case MESA_FORMAT_RGBA_UINT32: 1873 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes; 1874 1875 case MESA_FORMAT_R_SNORM8: 1876 return format == GL_RED && type == GL_BYTE; 1877 case MESA_FORMAT_R8G8_SNORM: 1878 return format == GL_RG && type == GL_BYTE && littleEndian && 1879 !swapBytes; 1880 case MESA_FORMAT_X8B8G8R8_SNORM: 1881 return GL_FALSE; 1882 1883 case MESA_FORMAT_A8B8G8R8_SNORM: 1884 if (format == GL_RGBA && type == GL_BYTE && !littleEndian) 1885 return GL_TRUE; 1886 1887 if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian) 1888 return GL_TRUE; 1889 1890 return GL_FALSE; 1891 1892 case MESA_FORMAT_R8G8B8A8_SNORM: 1893 if (format == GL_RGBA && type == GL_BYTE && littleEndian) 1894 return GL_TRUE; 1895 1896 if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian) 1897 return GL_TRUE; 1898 1899 return GL_FALSE; 1900 1901 case MESA_FORMAT_R_SNORM16: 1902 return format == GL_RED && type == GL_SHORT && 1903 !swapBytes; 1904 case MESA_FORMAT_R16G16_SNORM: 1905 return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes; 1906 case MESA_FORMAT_RGB_SNORM16: 1907 return format == GL_RGB && type == GL_SHORT && !swapBytes; 1908 case MESA_FORMAT_RGBA_SNORM16: 1909 return format == GL_RGBA && type == GL_SHORT && !swapBytes; 1910 case MESA_FORMAT_RGBA_UNORM16: 1911 return format == GL_RGBA && type == GL_UNSIGNED_SHORT && 1912 !swapBytes; 1913 1914 case MESA_FORMAT_A_SNORM8: 1915 return format == GL_ALPHA && type == GL_BYTE; 1916 case MESA_FORMAT_L_SNORM8: 1917 return format == GL_LUMINANCE && type == GL_BYTE; 1918 case MESA_FORMAT_L8A8_SNORM: 1919 return format == GL_LUMINANCE_ALPHA && type == GL_BYTE && 1920 littleEndian && !swapBytes; 1921 case MESA_FORMAT_A8L8_SNORM: 1922 return format == GL_LUMINANCE_ALPHA && type == GL_BYTE && 1923 !littleEndian && !swapBytes; 1924 case MESA_FORMAT_I_SNORM8: 1925 return format == GL_RED && type == GL_BYTE; 1926 case MESA_FORMAT_A_SNORM16: 1927 return format == GL_ALPHA && type == GL_SHORT && !swapBytes; 1928 case MESA_FORMAT_L_SNORM16: 1929 return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes; 1930 case MESA_FORMAT_LA_SNORM16: 1931 return format == GL_LUMINANCE_ALPHA && type == GL_SHORT && 1932 littleEndian && !swapBytes; 1933 case MESA_FORMAT_I_SNORM16: 1934 return format == GL_RED && type == GL_SHORT && littleEndian && 1935 !swapBytes; 1936 1937 case MESA_FORMAT_B10G10R10A2_UINT: 1938 return (format == GL_BGRA_INTEGER_EXT && 1939 type == GL_UNSIGNED_INT_2_10_10_10_REV && 1940 !swapBytes); 1941 1942 case MESA_FORMAT_R10G10B10A2_UINT: 1943 return (format == GL_RGBA_INTEGER_EXT && 1944 type == GL_UNSIGNED_INT_2_10_10_10_REV && 1945 !swapBytes); 1946 1947 case MESA_FORMAT_B5G6R5_UINT: 1948 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5; 1949 1950 case MESA_FORMAT_R5G6B5_UINT: 1951 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5_REV; 1952 1953 case MESA_FORMAT_B2G3R3_UINT: 1954 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_3_3_2; 1955 1956 case MESA_FORMAT_R3G3B2_UINT: 1957 return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_2_3_3_REV; 1958 1959 case MESA_FORMAT_A4B4G4R4_UINT: 1960 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes) 1961 return GL_TRUE; 1962 1963 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes) 1964 return GL_TRUE; 1965 return GL_FALSE; 1966 1967 case MESA_FORMAT_R4G4B4A4_UINT: 1968 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes) 1969 return GL_TRUE; 1970 1971 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes) 1972 return GL_TRUE; 1973 1974 return GL_FALSE; 1975 1976 case MESA_FORMAT_B4G4R4A4_UINT: 1977 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && 1978 !swapBytes; 1979 1980 case MESA_FORMAT_A4R4G4B4_UINT: 1981 return GL_FALSE; 1982 1983 case MESA_FORMAT_A1B5G5R5_UINT: 1984 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1985 !swapBytes; 1986 1987 case MESA_FORMAT_B5G5R5A1_UINT: 1988 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV && 1989 !swapBytes; 1990 1991 case MESA_FORMAT_A1R5G5B5_UINT: 1992 return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 && 1993 !swapBytes; 1994 1995 case MESA_FORMAT_R5G5B5A1_UINT: 1996 return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV; 1997 1998 case MESA_FORMAT_A8B8G8R8_UINT: 1999 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes) 2000 return GL_TRUE; 2001 2002 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes) 2003 return GL_TRUE; 2004 return GL_FALSE; 2005 2006 case MESA_FORMAT_A8R8G8B8_UINT: 2007 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && 2008 !swapBytes) 2009 return GL_TRUE; 2010 2011 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2012 swapBytes) 2013 return GL_TRUE; 2014 2015 return GL_FALSE; 2016 2017 case MESA_FORMAT_R8G8B8A8_UINT: 2018 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2019 !swapBytes) 2020 return GL_TRUE; 2021 2022 if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 2023 return GL_TRUE; 2024 2025 return GL_FALSE; 2026 2027 case MESA_FORMAT_B8G8R8A8_UINT: 2028 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && 2029 !swapBytes) 2030 return GL_TRUE; 2031 2032 if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes) 2033 return GL_TRUE; 2034 2035 return GL_FALSE; 2036 2037 case MESA_FORMAT_R9G9B9E5_FLOAT: 2038 return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV && 2039 !swapBytes; 2040 2041 case MESA_FORMAT_R11G11B10_FLOAT: 2042 return format == GL_RGB && type == GL_UNSIGNED_INT_10F_11F_11F_REV && 2043 !swapBytes; 2044 2045 case MESA_FORMAT_Z_FLOAT32: 2046 return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes; 2047 2048 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: 2049 return format == GL_DEPTH_STENCIL && 2050 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes; 2051 2052 case MESA_FORMAT_B4G4R4X4_UNORM: 2053 case MESA_FORMAT_B5G5R5X1_UNORM: 2054 case MESA_FORMAT_R8G8B8X8_SNORM: 2055 case MESA_FORMAT_R8G8B8X8_SRGB: 2056 case MESA_FORMAT_X8B8G8R8_SRGB: 2057 case MESA_FORMAT_RGBX_UINT8: 2058 case MESA_FORMAT_RGBX_SINT8: 2059 case MESA_FORMAT_B10G10R10X2_UNORM: 2060 case MESA_FORMAT_RGBX_UNORM16: 2061 case MESA_FORMAT_RGBX_SNORM16: 2062 case MESA_FORMAT_RGBX_FLOAT16: 2063 case MESA_FORMAT_RGBX_UINT16: 2064 case MESA_FORMAT_RGBX_SINT16: 2065 case MESA_FORMAT_RGBX_FLOAT32: 2066 case MESA_FORMAT_RGBX_UINT32: 2067 case MESA_FORMAT_RGBX_SINT32: 2068 return GL_FALSE; 2069 2070 case MESA_FORMAT_R10G10B10X2_UNORM: 2071 return format == GL_RGB && type == GL_UNSIGNED_INT_2_10_10_10_REV && 2072 !swapBytes; 2073 case MESA_FORMAT_R10G10B10A2_UNORM: 2074 return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV && 2075 !swapBytes; 2076 2077 case MESA_FORMAT_G8R8_SNORM: 2078 return format == GL_RG && type == GL_BYTE && !littleEndian && 2079 !swapBytes; 2080 2081 case MESA_FORMAT_G16R16_SNORM: 2082 return format == GL_RG && type == GL_SHORT && !littleEndian && 2083 !swapBytes; 2084 2085 case MESA_FORMAT_B8G8R8X8_SRGB: 2086 case MESA_FORMAT_X8R8G8B8_SRGB: 2087 return GL_FALSE; 2088 default: 2089 assert(_mesa_is_format_compressed(mesa_format)); 2090 if (error) 2091 *error = GL_INVALID_ENUM; 2092 } 2093 return GL_FALSE; 2094} 2095 2096