projects / mesa.git / blob
? search:


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