projects / mesa.git / blob
? search:


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