projects / mesa.git / blob
? search:


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