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 * Copyright (c) 2012 Intel Corporation
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #include "context.h"
29 #include "glformats.h"
30 #include "formats.h"
31 #include "texcompress.h"
32 #include "enums.h"
33
34 enum {
35 ZERO = 4,
36 ONE = 5
37 };
38
39 enum {
40 IDX_LUMINANCE = 0,
41 IDX_ALPHA,
42 IDX_INTENSITY,
43 IDX_LUMINANCE_ALPHA,
44 IDX_RGB,
45 IDX_RGBA,
46 IDX_RED,
47 IDX_GREEN,
48 IDX_BLUE,
49 IDX_BGR,
50 IDX_BGRA,
51 IDX_ABGR,
52 IDX_RG,
53 MAX_IDX
54 };
55
56 #define MAP1(x) MAP4(x, ZERO, ZERO, ZERO)
57 #define MAP2(x,y) MAP4(x, y, ZERO, ZERO)
58 #define MAP3(x,y,z) MAP4(x, y, z, ZERO)
59 #define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
60
61 static const struct {
62 GLubyte format_idx;
63 GLubyte to_rgba[6];
64 GLubyte from_rgba[6];
65 } mappings[MAX_IDX] =
66 {
67 {
68 IDX_LUMINANCE,
69 MAP4(0,0,0,ONE),
70 MAP1(0)
71 },
72
73 {
74 IDX_ALPHA,
75 MAP4(ZERO, ZERO, ZERO, 0),
76 MAP1(3)
77 },
78
79 {
80 IDX_INTENSITY,
81 MAP4(0, 0, 0, 0),
82 MAP1(0),
83 },
84
85 {
86 IDX_LUMINANCE_ALPHA,
87 MAP4(0,0,0,1),
88 MAP2(0,3)
89 },
90
91 {
92 IDX_RGB,
93 MAP4(0,1,2,ONE),
94 MAP3(0,1,2)
95 },
96
97 {
98 IDX_RGBA,
99 MAP4(0,1,2,3),
100 MAP4(0,1,2,3),
101 },
102
103 {
104 IDX_RED,
105 MAP4(0, ZERO, ZERO, ONE),
106 MAP1(0),
107 },
108
109 {
110 IDX_GREEN,
111 MAP4(ZERO, 0, ZERO, ONE),
112 MAP1(1),
113 },
114
115 {
116 IDX_BLUE,
117 MAP4(ZERO, ZERO, 0, ONE),
118 MAP1(2),
119 },
120
121 {
122 IDX_BGR,
123 MAP4(2,1,0,ONE),
124 MAP3(2,1,0)
125 },
126
127 {
128 IDX_BGRA,
129 MAP4(2,1,0,3),
130 MAP4(2,1,0,3)
131 },
132
133 {
134 IDX_ABGR,
135 MAP4(3,2,1,0),
136 MAP4(3,2,1,0)
137 },
138
139 {
140 IDX_RG,
141 MAP4(0, 1, ZERO, ONE),
142 MAP2(0, 1)
143 },
144 };
145
146 /**
147 * Convert a GL image format enum to an IDX_* value (see above).
148 */
149 static int
get_map_idx(GLenum value)150 get_map_idx(GLenum value)
151 {
152 switch (value) {
153 case GL_LUMINANCE:
154 case GL_LUMINANCE_INTEGER_EXT:
155 return IDX_LUMINANCE;
156 case GL_ALPHA:
157 case GL_ALPHA_INTEGER:
158 return IDX_ALPHA;
159 case GL_INTENSITY:
160 return IDX_INTENSITY;
161 case GL_LUMINANCE_ALPHA:
162 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
163 return IDX_LUMINANCE_ALPHA;
164 case GL_RGB:
165 case GL_RGB_INTEGER:
166 return IDX_RGB;
167 case GL_RGBA:
168 case GL_RGBA_INTEGER:
169 return IDX_RGBA;
170 case GL_RED:
171 case GL_RED_INTEGER:
172 return IDX_RED;
173 case GL_GREEN:
174 return IDX_GREEN;
175 case GL_BLUE:
176 return IDX_BLUE;
177 case GL_BGR:
178 case GL_BGR_INTEGER:
179 return IDX_BGR;
180 case GL_BGRA:
181 case GL_BGRA_INTEGER:
182 return IDX_BGRA;
183 case GL_ABGR_EXT:
184 return IDX_ABGR;
185 case GL_RG:
186 case GL_RG_INTEGER:
187 return IDX_RG;
188 default:
189 _mesa_problem(NULL, "Unexpected inFormat %s",
190 _mesa_enum_to_string(value));
191 return 0;
192 }
193 }
194
195 /**
196 * When promoting texture formats (see below) we need to compute the
197 * mapping of dest components back to source components.
198 * This function does that.
199 * \param inFormat the incoming format of the texture
200 * \param outFormat the final texture format
201 * \return map[6] a full 6-component map
202 */
203 void
_mesa_compute_component_mapping(GLenum inFormat,GLenum outFormat,GLubyte * map)204 _mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map)
205 {
206 const int inFmt = get_map_idx(inFormat);
207 const int outFmt = get_map_idx(outFormat);
208 const GLubyte *in2rgba = mappings[inFmt].to_rgba;
209 const GLubyte *rgba2out = mappings[outFmt].from_rgba;
210 int i;
211
212 for (i = 0; i < 4; i++)
213 map[i] = in2rgba[rgba2out[i]];
214
215 map[ZERO] = ZERO;
216 map[ONE] = ONE;
217
218 #if 0
219 printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
220 inFormat, _mesa_enum_to_string(inFormat),
221 outFormat, _mesa_enum_to_string(outFormat),
222 map[0],
223 map[1],
224 map[2],
225 map[3],
226 map[4],
227 map[5]);
228 #endif
229 }
230
231 /**
232 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
233 */
234 GLboolean
_mesa_type_is_packed(GLenum type)235 _mesa_type_is_packed(GLenum type)
236 {
237 switch (type) {
238 case GL_UNSIGNED_BYTE_3_3_2:
239 case GL_UNSIGNED_BYTE_2_3_3_REV:
240 case MESA_UNSIGNED_BYTE_4_4:
241 case GL_UNSIGNED_SHORT_5_6_5:
242 case GL_UNSIGNED_SHORT_5_6_5_REV:
243 case GL_UNSIGNED_SHORT_4_4_4_4:
244 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
245 case GL_UNSIGNED_SHORT_5_5_5_1:
246 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
247 case GL_UNSIGNED_INT_8_8_8_8:
248 case GL_UNSIGNED_INT_8_8_8_8_REV:
249 case GL_UNSIGNED_INT_10_10_10_2:
250 case GL_UNSIGNED_INT_2_10_10_10_REV:
251 case GL_UNSIGNED_SHORT_8_8_MESA:
252 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
253 case GL_UNSIGNED_INT_24_8_EXT:
254 case GL_UNSIGNED_INT_5_9_9_9_REV:
255 case GL_UNSIGNED_INT_10F_11F_11F_REV:
256 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
257 return GL_TRUE;
258 }
259
260 return GL_FALSE;
261 }
262
263
264 /**
265 * Get the size of a GL data type.
266 *
267 * \param type GL data type.
268 *
269 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
270 * if an invalid type enum.
271 */
272 GLint
_mesa_sizeof_type(GLenum type)273 _mesa_sizeof_type(GLenum type)
274 {
275 switch (type) {
276 case GL_BITMAP:
277 return 0;
278 case GL_UNSIGNED_BYTE:
279 return sizeof(GLubyte);
280 case GL_BYTE:
281 return sizeof(GLbyte);
282 case GL_UNSIGNED_SHORT:
283 return sizeof(GLushort);
284 case GL_SHORT:
285 return sizeof(GLshort);
286 case GL_UNSIGNED_INT:
287 return sizeof(GLuint);
288 case GL_INT:
289 return sizeof(GLint);
290 case GL_FLOAT:
291 return sizeof(GLfloat);
292 case GL_DOUBLE:
293 return sizeof(GLdouble);
294 case GL_HALF_FLOAT_ARB:
295 case GL_HALF_FLOAT_OES:
296 return sizeof(GLhalfARB);
297 case GL_FIXED:
298 return sizeof(GLfixed);
299 default:
300 return -1;
301 }
302 }
303
304
305 /**
306 * Same as _mesa_sizeof_type() but also accepting the packed pixel
307 * format data types.
308 */
309 GLint
_mesa_sizeof_packed_type(GLenum type)310 _mesa_sizeof_packed_type(GLenum type)
311 {
312 switch (type) {
313 case GL_BITMAP:
314 return 0;
315 case GL_UNSIGNED_BYTE:
316 return sizeof(GLubyte);
317 case GL_BYTE:
318 return sizeof(GLbyte);
319 case GL_UNSIGNED_SHORT:
320 return sizeof(GLushort);
321 case GL_SHORT:
322 return sizeof(GLshort);
323 case GL_UNSIGNED_INT:
324 return sizeof(GLuint);
325 case GL_INT:
326 return sizeof(GLint);
327 case GL_HALF_FLOAT_ARB:
328 case GL_HALF_FLOAT_OES:
329 return sizeof(GLhalfARB);
330 case GL_FLOAT:
331 return sizeof(GLfloat);
332 case GL_UNSIGNED_BYTE_3_3_2:
333 case GL_UNSIGNED_BYTE_2_3_3_REV:
334 case MESA_UNSIGNED_BYTE_4_4:
335 return sizeof(GLubyte);
336 case GL_UNSIGNED_SHORT_5_6_5:
337 case GL_UNSIGNED_SHORT_5_6_5_REV:
338 case GL_UNSIGNED_SHORT_4_4_4_4:
339 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
340 case GL_UNSIGNED_SHORT_5_5_5_1:
341 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
342 case GL_UNSIGNED_SHORT_8_8_MESA:
343 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
344 return sizeof(GLushort);
345 case GL_UNSIGNED_INT_8_8_8_8:
346 case GL_UNSIGNED_INT_8_8_8_8_REV:
347 case GL_UNSIGNED_INT_10_10_10_2:
348 case GL_UNSIGNED_INT_2_10_10_10_REV:
349 case GL_UNSIGNED_INT_24_8_EXT:
350 case GL_UNSIGNED_INT_5_9_9_9_REV:
351 case GL_UNSIGNED_INT_10F_11F_11F_REV:
352 return sizeof(GLuint);
353 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
354 return 8;
355 default:
356 return -1;
357 }
358 }
359
360
361 /**
362 * Get the number of components in a pixel format.
363 *
364 * \param format pixel format.
365 *
366 * \return the number of components in the given format, or -1 if a bad format.
367 */
368 GLint
_mesa_components_in_format(GLenum format)369 _mesa_components_in_format(GLenum format)
370 {
371 switch (format) {
372 case GL_COLOR_INDEX:
373 case GL_STENCIL_INDEX:
374 case GL_DEPTH_COMPONENT:
375 case GL_RED:
376 case GL_RED_INTEGER_EXT:
377 case GL_GREEN:
378 case GL_GREEN_INTEGER_EXT:
379 case GL_BLUE:
380 case GL_BLUE_INTEGER_EXT:
381 case GL_ALPHA:
382 case GL_ALPHA_INTEGER_EXT:
383 case GL_LUMINANCE:
384 case GL_LUMINANCE_INTEGER_EXT:
385 case GL_INTENSITY:
386 return 1;
387
388 case GL_LUMINANCE_ALPHA:
389 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
390 case GL_RG:
391 case GL_YCBCR_MESA:
392 case GL_DEPTH_STENCIL_EXT:
393 case GL_RG_INTEGER:
394 return 2;
395
396 case GL_RGB:
397 case GL_BGR:
398 case GL_RGB_INTEGER_EXT:
399 case GL_BGR_INTEGER_EXT:
400 return 3;
401
402 case GL_RGBA:
403 case GL_BGRA:
404 case GL_ABGR_EXT:
405 case GL_RGBA_INTEGER_EXT:
406 case GL_BGRA_INTEGER_EXT:
407 return 4;
408
409 default:
410 return -1;
411 }
412 }
413
414
415 /**
416 * Get the bytes per pixel of pixel format type pair.
417 *
418 * \param format pixel format.
419 * \param type pixel type.
420 *
421 * \return bytes per pixel, or -1 if a bad format or type was given.
422 */
423 GLint
_mesa_bytes_per_pixel(GLenum format,GLenum type)424 _mesa_bytes_per_pixel(GLenum format, GLenum type)
425 {
426 GLint comps = _mesa_components_in_format(format);
427 if (comps < 0)
428 return -1;
429
430 switch (type) {
431 case GL_BITMAP:
432 return 0; /* special case */
433 case GL_BYTE:
434 case GL_UNSIGNED_BYTE:
435 return comps * sizeof(GLubyte);
436 case GL_SHORT:
437 case GL_UNSIGNED_SHORT:
438 return comps * sizeof(GLshort);
439 case GL_INT:
440 case GL_UNSIGNED_INT:
441 return comps * sizeof(GLint);
442 case GL_FLOAT:
443 return comps * sizeof(GLfloat);
444 case GL_HALF_FLOAT_ARB:
445 case GL_HALF_FLOAT_OES:
446 return comps * sizeof(GLhalfARB);
447 case GL_UNSIGNED_BYTE_3_3_2:
448 case GL_UNSIGNED_BYTE_2_3_3_REV:
449 if (format == GL_RGB || format == GL_BGR ||
450 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
451 return sizeof(GLubyte);
452 else
453 return -1; /* error */
454 case GL_UNSIGNED_SHORT_5_6_5:
455 case GL_UNSIGNED_SHORT_5_6_5_REV:
456 if (format == GL_RGB || format == GL_BGR ||
457 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
458 return sizeof(GLushort);
459 else
460 return -1; /* error */
461 case GL_UNSIGNED_SHORT_4_4_4_4:
462 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
463 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
464 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
465 return sizeof(GLushort);
466 else
467 return -1;
468 case GL_UNSIGNED_SHORT_5_5_5_1:
469 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
470 if (format == GL_RGBA || format == GL_BGRA ||
471 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
472 return sizeof(GLushort);
473 else
474 return -1;
475 case GL_UNSIGNED_INT_8_8_8_8:
476 case GL_UNSIGNED_INT_8_8_8_8_REV:
477 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
478 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
479 format == GL_RGB)
480 return sizeof(GLuint);
481 else
482 return -1;
483 case GL_UNSIGNED_INT_10_10_10_2:
484 case GL_UNSIGNED_INT_2_10_10_10_REV:
485 if (format == GL_RGBA || format == GL_BGRA ||
486 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
487 format == GL_RGB)
488 return sizeof(GLuint);
489 else
490 return -1;
491 case GL_UNSIGNED_SHORT_8_8_MESA:
492 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
493 if (format == GL_YCBCR_MESA)
494 return sizeof(GLushort);
495 else
496 return -1;
497 case GL_UNSIGNED_INT_24_8_EXT:
498 if (format == GL_DEPTH_COMPONENT ||
499 format == GL_DEPTH_STENCIL_EXT)
500 return sizeof(GLuint);
501 else
502 return -1;
503 case GL_UNSIGNED_INT_5_9_9_9_REV:
504 if (format == GL_RGB)
505 return sizeof(GLuint);
506 else
507 return -1;
508 case GL_UNSIGNED_INT_10F_11F_11F_REV:
509 if (format == GL_RGB)
510 return sizeof(GLuint);
511 else
512 return -1;
513 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
514 if (format == GL_DEPTH_STENCIL)
515 return 8;
516 else
517 return -1;
518 default:
519 return -1;
520 }
521 }
522
523
524 /**
525 * Test if the given format is unsized.
526 */
527 GLboolean
_mesa_is_enum_format_unsized(GLenum format)528 _mesa_is_enum_format_unsized(GLenum format)
529 {
530 switch (format) {
531 case GL_RGBA:
532 case GL_BGRA:
533 case GL_ABGR_EXT:
534 case GL_RGB:
535 case GL_BGR:
536 case GL_RG:
537 case GL_RED:
538 case GL_GREEN:
539 case GL_BLUE:
540 case GL_ALPHA:
541 case GL_INTENSITY:
542 case GL_LUMINANCE:
543 case GL_LUMINANCE_ALPHA:
544
545 case GL_SRGB:
546 case GL_SRGB_ALPHA:
547 case GL_SLUMINANCE:
548 case GL_SLUMINANCE_ALPHA:
549
550 case GL_RGBA_SNORM:
551 case GL_RGB_SNORM:
552 case GL_RG_SNORM:
553 case GL_RED_SNORM:
554 case GL_ALPHA_SNORM:
555 case GL_INTENSITY_SNORM:
556 case GL_LUMINANCE_SNORM:
557 case GL_LUMINANCE_ALPHA_SNORM:
558
559 case GL_RED_INTEGER:
560 case GL_GREEN_INTEGER:
561 case GL_BLUE_INTEGER:
562 case GL_ALPHA_INTEGER:
563 case GL_RGB_INTEGER:
564 case GL_RGBA_INTEGER:
565 case GL_BGR_INTEGER:
566 case GL_BGRA_INTEGER:
567 case GL_RG_INTEGER:
568 case GL_LUMINANCE_INTEGER_EXT:
569 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
570
571 case GL_DEPTH_COMPONENT:
572 case GL_DEPTH_STENCIL:
573 case GL_STENCIL_INDEX:
574 return GL_TRUE;
575 default:
576 return GL_FALSE;
577 }
578 }
579
580 /**
581 * Test if the given format is a UNORM (unsigned-normalized) format.
582 */
583 GLboolean
_mesa_is_enum_format_unorm(GLenum format)584 _mesa_is_enum_format_unorm(GLenum format)
585 {
586 switch(format) {
587 case GL_RED:
588 case GL_GREEN:
589 case GL_BLUE:
590 case GL_ALPHA:
591 case GL_ALPHA4:
592 case GL_ALPHA8:
593 case GL_ALPHA12:
594 case GL_ALPHA16:
595 case 1:
596 case GL_LUMINANCE:
597 case GL_SLUMINANCE:
598 case GL_LUMINANCE4:
599 case GL_LUMINANCE8:
600 case GL_LUMINANCE12:
601 case GL_LUMINANCE16:
602 case 2:
603 case GL_LUMINANCE_ALPHA:
604 case GL_SLUMINANCE_ALPHA:
605 case GL_LUMINANCE4_ALPHA4:
606 case GL_LUMINANCE6_ALPHA2:
607 case GL_LUMINANCE8_ALPHA8:
608 case GL_LUMINANCE12_ALPHA4:
609 case GL_LUMINANCE12_ALPHA12:
610 case GL_LUMINANCE16_ALPHA16:
611 case GL_INTENSITY:
612 case GL_INTENSITY4:
613 case GL_INTENSITY8:
614 case GL_INTENSITY12:
615 case GL_INTENSITY16:
616 case GL_R8:
617 case GL_R16:
618 case GL_RG:
619 case GL_RG8:
620 case GL_RG16:
621 case 3:
622 case GL_RGB:
623 case GL_BGR:
624 case GL_SRGB:
625 case GL_R3_G3_B2:
626 case GL_RGB4:
627 case GL_RGB5:
628 case GL_RGB565:
629 case GL_RGB8:
630 case GL_RGB10:
631 case GL_RGB12:
632 case GL_RGB16:
633 case 4:
634 case GL_ABGR_EXT:
635 case GL_RGBA:
636 case GL_BGRA:
637 case GL_SRGB_ALPHA:
638 case GL_RGBA2:
639 case GL_RGBA4:
640 case GL_RGB5_A1:
641 case GL_RGBA8:
642 case GL_RGB10_A2:
643 case GL_RGBA12:
644 case GL_RGBA16:
645 return GL_TRUE;
646 default:
647 return GL_FALSE;
648 }
649 }
650
651 /**
652 * Test if the given format is a SNORM (signed-normalized) format.
653 */
654 GLboolean
_mesa_is_enum_format_snorm(GLenum format)655 _mesa_is_enum_format_snorm(GLenum format)
656 {
657 switch (format) {
658 /* signed, normalized texture formats */
659 case GL_RED_SNORM:
660 case GL_R8_SNORM:
661 case GL_R16_SNORM:
662 case GL_RG_SNORM:
663 case GL_RG8_SNORM:
664 case GL_RG16_SNORM:
665 case GL_RGB_SNORM:
666 case GL_RGB8_SNORM:
667 case GL_RGB16_SNORM:
668 case GL_RGBA_SNORM:
669 case GL_RGBA8_SNORM:
670 case GL_RGBA16_SNORM:
671 case GL_ALPHA_SNORM:
672 case GL_ALPHA8_SNORM:
673 case GL_ALPHA16_SNORM:
674 case GL_LUMINANCE_SNORM:
675 case GL_LUMINANCE8_SNORM:
676 case GL_LUMINANCE16_SNORM:
677 case GL_LUMINANCE_ALPHA_SNORM:
678 case GL_LUMINANCE8_ALPHA8_SNORM:
679 case GL_LUMINANCE16_ALPHA16_SNORM:
680 case GL_INTENSITY_SNORM:
681 case GL_INTENSITY8_SNORM:
682 case GL_INTENSITY16_SNORM:
683 return GL_TRUE;
684 default:
685 return GL_FALSE;
686 }
687 }
688
689 /**
690 * Test if the given format is an integer (non-normalized) format.
691 */
692 GLboolean
_mesa_is_enum_format_unsigned_int(GLenum format)693 _mesa_is_enum_format_unsigned_int(GLenum format)
694 {
695 switch (format) {
696 /* specific integer formats */
697 case GL_RGBA32UI_EXT:
698 case GL_RGB32UI_EXT:
699 case GL_RG32UI:
700 case GL_R32UI:
701 case GL_ALPHA32UI_EXT:
702 case GL_INTENSITY32UI_EXT:
703 case GL_LUMINANCE32UI_EXT:
704 case GL_LUMINANCE_ALPHA32UI_EXT:
705 case GL_RGBA16UI_EXT:
706 case GL_RGB16UI_EXT:
707 case GL_RG16UI:
708 case GL_R16UI:
709 case GL_ALPHA16UI_EXT:
710 case GL_INTENSITY16UI_EXT:
711 case GL_LUMINANCE16UI_EXT:
712 case GL_LUMINANCE_ALPHA16UI_EXT:
713 case GL_RGBA8UI_EXT:
714 case GL_RGB8UI_EXT:
715 case GL_RG8UI:
716 case GL_R8UI:
717 case GL_ALPHA8UI_EXT:
718 case GL_INTENSITY8UI_EXT:
719 case GL_LUMINANCE8UI_EXT:
720 case GL_LUMINANCE_ALPHA8UI_EXT:
721 case GL_RGB10_A2UI:
722 return GL_TRUE;
723 default:
724 return GL_FALSE;
725 }
726 }
727
728
729 /**
730 * Test if the given format is an integer (non-normalized) format.
731 */
732 GLboolean
_mesa_is_enum_format_signed_int(GLenum format)733 _mesa_is_enum_format_signed_int(GLenum format)
734 {
735 switch (format) {
736 /* generic integer formats */
737 case GL_RED_INTEGER_EXT:
738 case GL_GREEN_INTEGER_EXT:
739 case GL_BLUE_INTEGER_EXT:
740 case GL_ALPHA_INTEGER_EXT:
741 case GL_RGB_INTEGER_EXT:
742 case GL_RGBA_INTEGER_EXT:
743 case GL_BGR_INTEGER_EXT:
744 case GL_BGRA_INTEGER_EXT:
745 case GL_LUMINANCE_INTEGER_EXT:
746 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
747 case GL_RG_INTEGER:
748 /* specific integer formats */
749 case GL_RGBA32I_EXT:
750 case GL_RGB32I_EXT:
751 case GL_RG32I:
752 case GL_R32I:
753 case GL_ALPHA32I_EXT:
754 case GL_INTENSITY32I_EXT:
755 case GL_LUMINANCE32I_EXT:
756 case GL_LUMINANCE_ALPHA32I_EXT:
757 case GL_RGBA16I_EXT:
758 case GL_RGB16I_EXT:
759 case GL_RG16I:
760 case GL_R16I:
761 case GL_ALPHA16I_EXT:
762 case GL_INTENSITY16I_EXT:
763 case GL_LUMINANCE16I_EXT:
764 case GL_LUMINANCE_ALPHA16I_EXT:
765 case GL_RGBA8I_EXT:
766 case GL_RGB8I_EXT:
767 case GL_RG8I:
768 case GL_R8I:
769 case GL_ALPHA8I_EXT:
770 case GL_INTENSITY8I_EXT:
771 case GL_LUMINANCE8I_EXT:
772 case GL_LUMINANCE_ALPHA8I_EXT:
773 return GL_TRUE;
774 default:
775 return GL_FALSE;
776 }
777 }
778
779 /**
780 * Test if the given format is an ASTC 2D format.
781 */
782 static bool
is_astc_2d_format(GLenum internalFormat)783 is_astc_2d_format(GLenum internalFormat)
784 {
785 switch (internalFormat) {
786 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
787 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
788 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
789 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
790 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
791 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
792 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
793 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
794 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
795 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
796 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
797 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
798 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
799 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
800 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
801 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
802 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
803 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
804 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
805 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
806 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
807 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
808 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
809 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
810 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
811 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
812 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
813 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
814 return true;
815 default:
816 return false;
817 }
818 }
819
820 /**
821 * Test if the given format is an ASTC 3D format.
822 */
823 static bool
is_astc_3d_format(GLenum internalFormat)824 is_astc_3d_format(GLenum internalFormat)
825 {
826 switch (internalFormat) {
827 case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES:
828 case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
829 case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
830 case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES:
831 case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
832 case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
833 case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
834 case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
835 case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES:
836 case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES:
837 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES:
838 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES:
839 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES:
840 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES:
841 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES:
842 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES:
843 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES:
844 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES:
845 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES:
846 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES:
847 return true;
848 default:
849 return false;
850 }
851 }
852
853 /**
854 * Test if the given format is an ASTC format.
855 */
856 GLboolean
_mesa_is_astc_format(GLenum internalFormat)857 _mesa_is_astc_format(GLenum internalFormat)
858 {
859 return is_astc_2d_format(internalFormat) ||
860 is_astc_3d_format(internalFormat);
861 }
862
863 /**
864 * Test if the given format is an ETC2 format.
865 */
866 GLboolean
_mesa_is_etc2_format(GLenum internalFormat)867 _mesa_is_etc2_format(GLenum internalFormat)
868 {
869 switch (internalFormat) {
870 case GL_COMPRESSED_RGB8_ETC2:
871 case GL_COMPRESSED_SRGB8_ETC2:
872 case GL_COMPRESSED_RGBA8_ETC2_EAC:
873 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
874 case GL_COMPRESSED_R11_EAC:
875 case GL_COMPRESSED_RG11_EAC:
876 case GL_COMPRESSED_SIGNED_R11_EAC:
877 case GL_COMPRESSED_SIGNED_RG11_EAC:
878 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
879 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
880 return true;
881 default:
882 return false;
883 }
884 }
885
886 /**
887 * Test if the given format is an integer (non-normalized) format.
888 */
889 GLboolean
_mesa_is_enum_format_integer(GLenum format)890 _mesa_is_enum_format_integer(GLenum format)
891 {
892 return _mesa_is_enum_format_unsigned_int(format) ||
893 _mesa_is_enum_format_signed_int(format);
894 }
895
896
897 GLboolean
_mesa_is_type_unsigned(GLenum type)898 _mesa_is_type_unsigned(GLenum type)
899 {
900 switch (type) {
901 case GL_UNSIGNED_INT:
902 case GL_UNSIGNED_INT_8_8_8_8:
903 case GL_UNSIGNED_INT_8_8_8_8_REV:
904 case GL_UNSIGNED_INT_10_10_10_2:
905 case GL_UNSIGNED_INT_2_10_10_10_REV:
906
907 case GL_UNSIGNED_SHORT:
908 case GL_UNSIGNED_SHORT_4_4_4_4:
909 case GL_UNSIGNED_SHORT_5_5_5_1:
910 case GL_UNSIGNED_SHORT_5_6_5:
911 case GL_UNSIGNED_SHORT_5_6_5_REV:
912 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
913 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
914 case GL_UNSIGNED_SHORT_8_8_MESA:
915 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
916
917 case GL_UNSIGNED_BYTE:
918 case GL_UNSIGNED_BYTE_3_3_2:
919 case GL_UNSIGNED_BYTE_2_3_3_REV:
920 return GL_TRUE;
921
922 default:
923 return GL_FALSE;
924 }
925 }
926
927
928 /**
929 * Test if the given image format is a color/RGBA format (i.e., not color
930 * index, depth, stencil, etc).
931 * \param format the image format value (may by an internal texture format)
932 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
933 */
934 GLboolean
_mesa_is_color_format(GLenum format)935 _mesa_is_color_format(GLenum format)
936 {
937 switch (format) {
938 case GL_RED:
939 case GL_GREEN:
940 case GL_BLUE:
941 case GL_ALPHA:
942 case GL_ALPHA4:
943 case GL_ALPHA8:
944 case GL_ALPHA12:
945 case GL_ALPHA16:
946 case 1:
947 case GL_LUMINANCE:
948 case GL_LUMINANCE4:
949 case GL_LUMINANCE8:
950 case GL_LUMINANCE12:
951 case GL_LUMINANCE16:
952 case 2:
953 case GL_LUMINANCE_ALPHA:
954 case GL_LUMINANCE4_ALPHA4:
955 case GL_LUMINANCE6_ALPHA2:
956 case GL_LUMINANCE8_ALPHA8:
957 case GL_LUMINANCE12_ALPHA4:
958 case GL_LUMINANCE12_ALPHA12:
959 case GL_LUMINANCE16_ALPHA16:
960 case GL_INTENSITY:
961 case GL_INTENSITY4:
962 case GL_INTENSITY8:
963 case GL_INTENSITY12:
964 case GL_INTENSITY16:
965 case GL_R8:
966 case GL_R16:
967 case GL_RG:
968 case GL_RG8:
969 case GL_RG16:
970 case 3:
971 case GL_RGB:
972 case GL_BGR:
973 case GL_R3_G3_B2:
974 case GL_RGB4:
975 case GL_RGB5:
976 case GL_RGB565:
977 case GL_RGB8:
978 case GL_RGB10:
979 case GL_RGB12:
980 case GL_RGB16:
981 case 4:
982 case GL_ABGR_EXT:
983 case GL_RGBA:
984 case GL_BGRA:
985 case GL_RGBA2:
986 case GL_RGBA4:
987 case GL_RGB5_A1:
988 case GL_RGBA8:
989 case GL_RGB10_A2:
990 case GL_RGBA12:
991 case GL_RGBA16:
992 /* float texture formats */
993 case GL_ALPHA16F_ARB:
994 case GL_ALPHA32F_ARB:
995 case GL_LUMINANCE16F_ARB:
996 case GL_LUMINANCE32F_ARB:
997 case GL_LUMINANCE_ALPHA16F_ARB:
998 case GL_LUMINANCE_ALPHA32F_ARB:
999 case GL_INTENSITY16F_ARB:
1000 case GL_INTENSITY32F_ARB:
1001 case GL_R16F:
1002 case GL_R32F:
1003 case GL_RG16F:
1004 case GL_RG32F:
1005 case GL_RGB16F_ARB:
1006 case GL_RGB32F_ARB:
1007 case GL_RGBA16F_ARB:
1008 case GL_RGBA32F_ARB:
1009 /* compressed formats */
1010 case GL_COMPRESSED_ALPHA:
1011 case GL_COMPRESSED_LUMINANCE:
1012 case GL_COMPRESSED_LUMINANCE_ALPHA:
1013 case GL_COMPRESSED_INTENSITY:
1014 case GL_COMPRESSED_RED:
1015 case GL_COMPRESSED_RG:
1016 case GL_COMPRESSED_RGB:
1017 case GL_COMPRESSED_RGBA:
1018 case GL_RGB_S3TC:
1019 case GL_RGB4_S3TC:
1020 case GL_RGBA_S3TC:
1021 case GL_RGBA4_S3TC:
1022 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1023 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1024 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
1025 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
1026 case GL_COMPRESSED_RGB_FXT1_3DFX:
1027 case GL_COMPRESSED_RGBA_FXT1_3DFX:
1028 case GL_SR8_EXT:
1029 case GL_SRG8_EXT:
1030 case GL_SRGB_EXT:
1031 case GL_SRGB8_EXT:
1032 case GL_SRGB_ALPHA_EXT:
1033 case GL_SRGB8_ALPHA8_EXT:
1034 case GL_SLUMINANCE_ALPHA_EXT:
1035 case GL_SLUMINANCE8_ALPHA8_EXT:
1036 case GL_SLUMINANCE_EXT:
1037 case GL_SLUMINANCE8_EXT:
1038 case GL_COMPRESSED_SRGB_EXT:
1039 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
1040 case GL_COMPRESSED_SRGB_ALPHA_EXT:
1041 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
1042 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
1043 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
1044 case GL_COMPRESSED_SLUMINANCE_EXT:
1045 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
1046 case GL_COMPRESSED_RED_RGTC1:
1047 case GL_COMPRESSED_SIGNED_RED_RGTC1:
1048 case GL_COMPRESSED_RG_RGTC2:
1049 case GL_COMPRESSED_SIGNED_RG_RGTC2:
1050 case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
1051 case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
1052 case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
1053 case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
1054 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
1055 case GL_ETC1_RGB8_OES:
1056 case GL_COMPRESSED_RGB8_ETC2:
1057 case GL_COMPRESSED_SRGB8_ETC2:
1058 case GL_COMPRESSED_RGBA8_ETC2_EAC:
1059 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
1060 case GL_COMPRESSED_R11_EAC:
1061 case GL_COMPRESSED_RG11_EAC:
1062 case GL_COMPRESSED_SIGNED_R11_EAC:
1063 case GL_COMPRESSED_SIGNED_RG11_EAC:
1064 case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1065 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1066 case GL_COMPRESSED_RGBA_BPTC_UNORM:
1067 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
1068 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
1069 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
1070 case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
1071 case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
1072 case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
1073 case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
1074 case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
1075 case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
1076 case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
1077 case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
1078 case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
1079 case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
1080 case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
1081 case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
1082 case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
1083 case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
1084 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
1085 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
1086 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
1087 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
1088 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
1089 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
1090 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
1091 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
1092 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
1093 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
1094 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
1095 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
1096 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
1097 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
1098 case GL_ATC_RGB_AMD:
1099 case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD:
1100 case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
1101 /* generic integer formats */
1102 case GL_RED_INTEGER_EXT:
1103 case GL_GREEN_INTEGER_EXT:
1104 case GL_BLUE_INTEGER_EXT:
1105 case GL_ALPHA_INTEGER_EXT:
1106 case GL_RGB_INTEGER_EXT:
1107 case GL_RGBA_INTEGER_EXT:
1108 case GL_BGR_INTEGER_EXT:
1109 case GL_BGRA_INTEGER_EXT:
1110 case GL_RG_INTEGER:
1111 case GL_LUMINANCE_INTEGER_EXT:
1112 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1113 /* sized integer formats */
1114 case GL_RGBA32UI_EXT:
1115 case GL_RGB32UI_EXT:
1116 case GL_RG32UI:
1117 case GL_R32UI:
1118 case GL_ALPHA32UI_EXT:
1119 case GL_INTENSITY32UI_EXT:
1120 case GL_LUMINANCE32UI_EXT:
1121 case GL_LUMINANCE_ALPHA32UI_EXT:
1122 case GL_RGBA16UI_EXT:
1123 case GL_RGB16UI_EXT:
1124 case GL_RG16UI:
1125 case GL_R16UI:
1126 case GL_ALPHA16UI_EXT:
1127 case GL_INTENSITY16UI_EXT:
1128 case GL_LUMINANCE16UI_EXT:
1129 case GL_LUMINANCE_ALPHA16UI_EXT:
1130 case GL_RGBA8UI_EXT:
1131 case GL_RGB8UI_EXT:
1132 case GL_RG8UI:
1133 case GL_R8UI:
1134 case GL_ALPHA8UI_EXT:
1135 case GL_INTENSITY8UI_EXT:
1136 case GL_LUMINANCE8UI_EXT:
1137 case GL_LUMINANCE_ALPHA8UI_EXT:
1138 case GL_RGBA32I_EXT:
1139 case GL_RGB32I_EXT:
1140 case GL_RG32I:
1141 case GL_R32I:
1142 case GL_ALPHA32I_EXT:
1143 case GL_INTENSITY32I_EXT:
1144 case GL_LUMINANCE32I_EXT:
1145 case GL_LUMINANCE_ALPHA32I_EXT:
1146 case GL_RGBA16I_EXT:
1147 case GL_RGB16I_EXT:
1148 case GL_RG16I:
1149 case GL_R16I:
1150 case GL_ALPHA16I_EXT:
1151 case GL_INTENSITY16I_EXT:
1152 case GL_LUMINANCE16I_EXT:
1153 case GL_LUMINANCE_ALPHA16I_EXT:
1154 case GL_RGBA8I_EXT:
1155 case GL_RGB8I_EXT:
1156 case GL_RG8I:
1157 case GL_R8I:
1158 case GL_ALPHA8I_EXT:
1159 case GL_INTENSITY8I_EXT:
1160 case GL_LUMINANCE8I_EXT:
1161 case GL_LUMINANCE_ALPHA8I_EXT:
1162 /* signed, normalized texture formats */
1163 case GL_RED_SNORM:
1164 case GL_R8_SNORM:
1165 case GL_R16_SNORM:
1166 case GL_RG_SNORM:
1167 case GL_RG8_SNORM:
1168 case GL_RG16_SNORM:
1169 case GL_RGB_SNORM:
1170 case GL_RGB8_SNORM:
1171 case GL_RGB16_SNORM:
1172 case GL_RGBA_SNORM:
1173 case GL_RGBA8_SNORM:
1174 case GL_RGBA16_SNORM:
1175 case GL_ALPHA_SNORM:
1176 case GL_ALPHA8_SNORM:
1177 case GL_ALPHA16_SNORM:
1178 case GL_LUMINANCE_SNORM:
1179 case GL_LUMINANCE8_SNORM:
1180 case GL_LUMINANCE16_SNORM:
1181 case GL_LUMINANCE_ALPHA_SNORM:
1182 case GL_LUMINANCE8_ALPHA8_SNORM:
1183 case GL_LUMINANCE16_ALPHA16_SNORM:
1184 case GL_INTENSITY_SNORM:
1185 case GL_INTENSITY8_SNORM:
1186 case GL_INTENSITY16_SNORM:
1187 case GL_RGB9_E5:
1188 case GL_R11F_G11F_B10F:
1189 case GL_RGB10_A2UI:
1190 return GL_TRUE;
1191 case GL_YCBCR_MESA: /* not considered to be RGB */
1192 FALLTHROUGH;
1193 default:
1194 return GL_FALSE;
1195 }
1196 }
1197
1198
1199 /**
1200 * Test if the given image format is a depth component format.
1201 */
1202 GLboolean
_mesa_is_depth_format(GLenum format)1203 _mesa_is_depth_format(GLenum format)
1204 {
1205 switch (format) {
1206 case GL_DEPTH_COMPONENT:
1207 case GL_DEPTH_COMPONENT16:
1208 case GL_DEPTH_COMPONENT24:
1209 case GL_DEPTH_COMPONENT32:
1210 case GL_DEPTH_COMPONENT32F:
1211 return GL_TRUE;
1212 default:
1213 return GL_FALSE;
1214 }
1215 }
1216
1217
1218 /**
1219 * Test if the given image format is a stencil format.
1220 */
1221 GLboolean
_mesa_is_stencil_format(GLenum format)1222 _mesa_is_stencil_format(GLenum format)
1223 {
1224 switch (format) {
1225 case GL_STENCIL_INDEX:
1226 return GL_TRUE;
1227 default:
1228 return GL_FALSE;
1229 }
1230 }
1231
1232
1233 /**
1234 * Test if the given image format is a YCbCr format.
1235 */
1236 GLboolean
_mesa_is_ycbcr_format(GLenum format)1237 _mesa_is_ycbcr_format(GLenum format)
1238 {
1239 switch (format) {
1240 case GL_YCBCR_MESA:
1241 return GL_TRUE;
1242 default:
1243 return GL_FALSE;
1244 }
1245 }
1246
1247
1248 /**
1249 * Test if the given image format is a depth+stencil format.
1250 */
1251 GLboolean
_mesa_is_depthstencil_format(GLenum format)1252 _mesa_is_depthstencil_format(GLenum format)
1253 {
1254 switch (format) {
1255 case GL_DEPTH24_STENCIL8_EXT:
1256 case GL_DEPTH_STENCIL_EXT:
1257 case GL_DEPTH32F_STENCIL8:
1258 return GL_TRUE;
1259 default:
1260 return GL_FALSE;
1261 }
1262 }
1263
1264
1265 /**
1266 * Test if the given image format is a depth or stencil format.
1267 */
1268 GLboolean
_mesa_is_depth_or_stencil_format(GLenum format)1269 _mesa_is_depth_or_stencil_format(GLenum format)
1270 {
1271 switch (format) {
1272 case GL_DEPTH_COMPONENT:
1273 case GL_DEPTH_COMPONENT16:
1274 case GL_DEPTH_COMPONENT24:
1275 case GL_DEPTH_COMPONENT32:
1276 case GL_STENCIL_INDEX:
1277 case GL_STENCIL_INDEX1_EXT:
1278 case GL_STENCIL_INDEX4_EXT:
1279 case GL_STENCIL_INDEX8_EXT:
1280 case GL_STENCIL_INDEX16_EXT:
1281 case GL_DEPTH_STENCIL_EXT:
1282 case GL_DEPTH24_STENCIL8_EXT:
1283 case GL_DEPTH_COMPONENT32F:
1284 case GL_DEPTH32F_STENCIL8:
1285 return GL_TRUE;
1286 default:
1287 return GL_FALSE;
1288 }
1289 }
1290
1291 /**
1292 * Test if the given image format has a floating-point depth component.
1293 */
1294 GLboolean
_mesa_has_depth_float_channel(GLenum internalFormat)1295 _mesa_has_depth_float_channel(GLenum internalFormat)
1296 {
1297 return internalFormat == GL_DEPTH32F_STENCIL8 ||
1298 internalFormat == GL_DEPTH_COMPONENT32F;
1299 }
1300
1301 /**
1302 * Test if an image format is a supported compressed format.
1303 * \param format the internal format token provided by the user.
1304 * \return GL_TRUE if compressed, GL_FALSE if uncompressed
1305 */
1306 GLboolean
_mesa_is_compressed_format(const struct gl_context * ctx,GLenum format)1307 _mesa_is_compressed_format(const struct gl_context *ctx, GLenum format)
1308 {
1309 mesa_format m_format = _mesa_glenum_to_compressed_format(format);
1310
1311 /* Some formats in this switch have an equivalent mesa_format_layout
1312 * to the compressed formats in the layout switch below and thus
1313 * must be handled first.
1314 */
1315 switch (format) {
1316 case GL_RGB_S3TC:
1317 case GL_RGB4_S3TC:
1318 case GL_RGBA_S3TC:
1319 case GL_RGBA4_S3TC:
1320 return _mesa_has_S3_s3tc(ctx);
1321 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
1322 return _mesa_has_ATI_texture_compression_3dc(ctx);
1323 case GL_PALETTE4_RGB8_OES:
1324 case GL_PALETTE4_RGBA8_OES:
1325 case GL_PALETTE4_R5_G6_B5_OES:
1326 case GL_PALETTE4_RGBA4_OES:
1327 case GL_PALETTE4_RGB5_A1_OES:
1328 case GL_PALETTE8_RGB8_OES:
1329 case GL_PALETTE8_RGBA8_OES:
1330 case GL_PALETTE8_R5_G6_B5_OES:
1331 case GL_PALETTE8_RGBA4_OES:
1332 case GL_PALETTE8_RGB5_A1_OES:
1333 return _mesa_is_gles1(ctx);
1334 }
1335
1336 switch (_mesa_get_format_layout(m_format)) {
1337 case MESA_FORMAT_LAYOUT_S3TC:
1338 if (!_mesa_is_format_srgb(m_format)) {
1339 return _mesa_has_EXT_texture_compression_s3tc(ctx);
1340 } else {
1341 return (_mesa_has_EXT_texture_sRGB(ctx) ||
1342 _mesa_has_EXT_texture_compression_s3tc_srgb(ctx)) &&
1343 _mesa_has_EXT_texture_compression_s3tc(ctx);
1344 }
1345 case MESA_FORMAT_LAYOUT_FXT1:
1346 return _mesa_has_3DFX_texture_compression_FXT1(ctx);
1347 case MESA_FORMAT_LAYOUT_RGTC:
1348 return _mesa_has_ARB_texture_compression_rgtc(ctx) ||
1349 _mesa_has_EXT_texture_compression_rgtc(ctx);
1350 case MESA_FORMAT_LAYOUT_LATC:
1351 return _mesa_has_EXT_texture_compression_latc(ctx);
1352 case MESA_FORMAT_LAYOUT_ETC1:
1353 return _mesa_has_OES_compressed_ETC1_RGB8_texture(ctx);
1354 case MESA_FORMAT_LAYOUT_ETC2:
1355 return _mesa_is_gles3(ctx) || _mesa_has_ARB_ES3_compatibility(ctx);
1356 case MESA_FORMAT_LAYOUT_BPTC:
1357 return _mesa_has_ARB_texture_compression_bptc(ctx) ||
1358 _mesa_has_EXT_texture_compression_bptc(ctx);
1359 case MESA_FORMAT_LAYOUT_ASTC:
1360 return _mesa_has_KHR_texture_compression_astc_ldr(ctx);
1361 case MESA_FORMAT_LAYOUT_ATC:
1362 return _mesa_has_AMD_compressed_ATC_texture(ctx);
1363 default:
1364 return GL_FALSE;
1365 }
1366 }
1367
1368 /**
1369 * Test if the given format represents an sRGB format.
1370 * \param format the GL format (can be an internal format)
1371 * \return GL_TRUE if format is sRGB, GL_FALSE otherwise
1372 */
1373 GLboolean
_mesa_is_srgb_format(GLenum format)1374 _mesa_is_srgb_format(GLenum format)
1375 {
1376 switch (format) {
1377 case GL_SR8_EXT:
1378 case GL_SRG8_EXT:
1379 case GL_SRGB:
1380 case GL_SRGB8:
1381 case GL_SRGB_ALPHA:
1382 case GL_SRGB8_ALPHA8:
1383 case GL_COMPRESSED_SRGB:
1384 case GL_COMPRESSED_SRGB_ALPHA:
1385 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
1386 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
1387 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
1388 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
1389 case GL_COMPRESSED_SRGB8_ETC2:
1390 case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
1391 case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
1392 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
1393 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
1394 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
1395 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
1396 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
1397 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
1398 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
1399 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
1400 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
1401 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
1402 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
1403 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
1404 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
1405 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
1406 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
1407 return GL_TRUE;
1408 default:
1409 break;
1410 }
1411
1412 return GL_FALSE;
1413 }
1414
1415 /**
1416 * Convert various unpack formats to the corresponding base format.
1417 */
1418 GLenum
_mesa_unpack_format_to_base_format(GLenum format)1419 _mesa_unpack_format_to_base_format(GLenum format)
1420 {
1421 switch(format) {
1422 case GL_RED_INTEGER:
1423 return GL_RED;
1424 case GL_GREEN_INTEGER:
1425 return GL_GREEN;
1426 case GL_BLUE_INTEGER:
1427 return GL_BLUE;
1428 case GL_ALPHA_INTEGER:
1429 return GL_ALPHA;
1430 case GL_RG_INTEGER:
1431 return GL_RG;
1432 case GL_RGB_INTEGER:
1433 return GL_RGB;
1434 case GL_RGBA_INTEGER:
1435 return GL_RGBA;
1436 case GL_BGR_INTEGER:
1437 return GL_BGR;
1438 case GL_BGRA_INTEGER:
1439 return GL_BGRA;
1440 case GL_LUMINANCE_INTEGER_EXT:
1441 return GL_LUMINANCE;
1442 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1443 return GL_LUMINANCE_ALPHA;
1444 case GL_RED:
1445 case GL_GREEN:
1446 case GL_BLUE:
1447 case GL_RG:
1448 case GL_RGB:
1449 case GL_RGBA:
1450 case GL_BGR:
1451 case GL_BGRA:
1452 case GL_ALPHA:
1453 case GL_LUMINANCE:
1454 case GL_LUMINANCE_ALPHA:
1455 default:
1456 return format;
1457 }
1458 }
1459
1460 /**
1461 * Convert various base formats to the corresponding integer format.
1462 */
1463 GLenum
_mesa_base_format_to_integer_format(GLenum format)1464 _mesa_base_format_to_integer_format(GLenum format)
1465 {
1466 switch(format) {
1467 case GL_RED:
1468 return GL_RED_INTEGER;
1469 case GL_GREEN:
1470 return GL_GREEN_INTEGER;
1471 case GL_BLUE:
1472 return GL_BLUE_INTEGER;
1473 case GL_RG:
1474 return GL_RG_INTEGER;
1475 case GL_RGB:
1476 return GL_RGB_INTEGER;
1477 case GL_RGBA:
1478 return GL_RGBA_INTEGER;
1479 case GL_BGR:
1480 return GL_BGR_INTEGER;
1481 case GL_BGRA:
1482 return GL_BGRA_INTEGER;
1483 case GL_ALPHA:
1484 return GL_ALPHA_INTEGER;
1485 case GL_LUMINANCE:
1486 return GL_LUMINANCE_INTEGER_EXT;
1487 case GL_LUMINANCE_ALPHA:
1488 return GL_LUMINANCE_ALPHA_INTEGER_EXT;
1489 }
1490
1491 return format;
1492 }
1493
1494
1495 /**
1496 * Does the given base texture/renderbuffer format have the channel
1497 * named by 'pname'?
1498 */
1499 GLboolean
_mesa_base_format_has_channel(GLenum base_format,GLenum pname)1500 _mesa_base_format_has_channel(GLenum base_format, GLenum pname)
1501 {
1502 switch (pname) {
1503 case GL_TEXTURE_RED_SIZE:
1504 case GL_TEXTURE_RED_TYPE:
1505 case GL_RENDERBUFFER_RED_SIZE_EXT:
1506 case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
1507 case GL_INTERNALFORMAT_RED_SIZE:
1508 case GL_INTERNALFORMAT_RED_TYPE:
1509 if (base_format == GL_RED ||
1510 base_format == GL_RG ||
1511 base_format == GL_RGB ||
1512 base_format == GL_RGBA) {
1513 return GL_TRUE;
1514 }
1515 return GL_FALSE;
1516 case GL_TEXTURE_GREEN_SIZE:
1517 case GL_TEXTURE_GREEN_TYPE:
1518 case GL_RENDERBUFFER_GREEN_SIZE_EXT:
1519 case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
1520 case GL_INTERNALFORMAT_GREEN_SIZE:
1521 case GL_INTERNALFORMAT_GREEN_TYPE:
1522 if (base_format == GL_RG ||
1523 base_format == GL_RGB ||
1524 base_format == GL_RGBA) {
1525 return GL_TRUE;
1526 }
1527 return GL_FALSE;
1528 case GL_TEXTURE_BLUE_SIZE:
1529 case GL_TEXTURE_BLUE_TYPE:
1530 case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1531 case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1532 case GL_INTERNALFORMAT_BLUE_SIZE:
1533 case GL_INTERNALFORMAT_BLUE_TYPE:
1534 if (base_format == GL_RGB ||
1535 base_format == GL_RGBA) {
1536 return GL_TRUE;
1537 }
1538 return GL_FALSE;
1539 case GL_TEXTURE_ALPHA_SIZE:
1540 case GL_TEXTURE_ALPHA_TYPE:
1541 case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1542 case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1543 case GL_INTERNALFORMAT_ALPHA_SIZE:
1544 case GL_INTERNALFORMAT_ALPHA_TYPE:
1545 if (base_format == GL_RGBA ||
1546 base_format == GL_ALPHA ||
1547 base_format == GL_LUMINANCE_ALPHA) {
1548 return GL_TRUE;
1549 }
1550 return GL_FALSE;
1551 case GL_TEXTURE_LUMINANCE_SIZE:
1552 case GL_TEXTURE_LUMINANCE_TYPE:
1553 if (base_format == GL_LUMINANCE ||
1554 base_format == GL_LUMINANCE_ALPHA) {
1555 return GL_TRUE;
1556 }
1557 return GL_FALSE;
1558 case GL_TEXTURE_INTENSITY_SIZE:
1559 case GL_TEXTURE_INTENSITY_TYPE:
1560 if (base_format == GL_INTENSITY) {
1561 return GL_TRUE;
1562 }
1563 return GL_FALSE;
1564 case GL_TEXTURE_DEPTH_SIZE:
1565 case GL_TEXTURE_DEPTH_TYPE:
1566 case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1567 case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1568 case GL_INTERNALFORMAT_DEPTH_SIZE:
1569 case GL_INTERNALFORMAT_DEPTH_TYPE:
1570 if (base_format == GL_DEPTH_STENCIL ||
1571 base_format == GL_DEPTH_COMPONENT) {
1572 return GL_TRUE;
1573 }
1574 return GL_FALSE;
1575 case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1576 case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1577 case GL_INTERNALFORMAT_STENCIL_SIZE:
1578 case GL_INTERNALFORMAT_STENCIL_TYPE:
1579 if (base_format == GL_DEPTH_STENCIL ||
1580 base_format == GL_STENCIL_INDEX) {
1581 return GL_TRUE;
1582 }
1583 return GL_FALSE;
1584 default:
1585 _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1586 __func__, pname);
1587 return GL_FALSE;
1588 }
1589
1590 return GL_FALSE;
1591 }
1592
1593
1594 /**
1595 * If format is a generic compressed format, return the corresponding
1596 * non-compressed format. For other formats, return the format as-is.
1597 */
1598 GLenum
_mesa_generic_compressed_format_to_uncompressed_format(GLenum format)1599 _mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1600 {
1601 switch (format) {
1602 case GL_COMPRESSED_RED:
1603 return GL_RED;
1604 case GL_COMPRESSED_RG:
1605 return GL_RG;
1606 case GL_COMPRESSED_RGB:
1607 return GL_RGB;
1608 case GL_COMPRESSED_RGBA:
1609 return GL_RGBA;
1610 case GL_COMPRESSED_ALPHA:
1611 return GL_ALPHA;
1612 case GL_COMPRESSED_LUMINANCE:
1613 return GL_LUMINANCE;
1614 case GL_COMPRESSED_LUMINANCE_ALPHA:
1615 return GL_LUMINANCE_ALPHA;
1616 case GL_COMPRESSED_INTENSITY:
1617 return GL_INTENSITY;
1618 /* sRGB formats */
1619 case GL_COMPRESSED_SRGB:
1620 return GL_SRGB;
1621 case GL_COMPRESSED_SRGB_ALPHA:
1622 return GL_SRGB_ALPHA;
1623 case GL_COMPRESSED_SLUMINANCE:
1624 return GL_SLUMINANCE;
1625 case GL_COMPRESSED_SLUMINANCE_ALPHA:
1626 return GL_SLUMINANCE_ALPHA;
1627 default:
1628 return format;
1629 }
1630 }
1631
1632
1633 /**
1634 * Return the equivalent non-generic internal format.
1635 * This is useful for comparing whether two internal formats are equivalent.
1636 */
1637 GLenum
_mesa_get_nongeneric_internalformat(GLenum format)1638 _mesa_get_nongeneric_internalformat(GLenum format)
1639 {
1640 switch (format) {
1641 /* GL 1.1 formats. */
1642 case 4:
1643 case GL_RGBA:
1644 return GL_RGBA8;
1645 case 3:
1646 case GL_RGB:
1647 return GL_RGB8;
1648 case 2:
1649 case GL_LUMINANCE_ALPHA:
1650 return GL_LUMINANCE8_ALPHA8;
1651 case 1:
1652 case GL_LUMINANCE:
1653 return GL_LUMINANCE8;
1654 case GL_ALPHA:
1655 return GL_ALPHA8;
1656 case GL_INTENSITY:
1657 return GL_INTENSITY8;
1658
1659 /* GL_ARB_texture_rg */
1660 case GL_RED:
1661 return GL_R8;
1662 case GL_RG:
1663 return GL_RG8;
1664
1665 /* GL_EXT_texture_sRGB */
1666 case GL_SRGB:
1667 return GL_SRGB8;
1668 case GL_SRGB_ALPHA:
1669 return GL_SRGB8_ALPHA8;
1670 case GL_SLUMINANCE:
1671 return GL_SLUMINANCE8;
1672 case GL_SLUMINANCE_ALPHA:
1673 return GL_SLUMINANCE8_ALPHA8;
1674
1675 /* GL_EXT_texture_snorm */
1676 case GL_RGBA_SNORM:
1677 return GL_RGBA8_SNORM;
1678 case GL_RGB_SNORM:
1679 return GL_RGB8_SNORM;
1680 case GL_RG_SNORM:
1681 return GL_RG8_SNORM;
1682 case GL_RED_SNORM:
1683 return GL_R8_SNORM;
1684 case GL_LUMINANCE_ALPHA_SNORM:
1685 return GL_LUMINANCE8_ALPHA8_SNORM;
1686 case GL_LUMINANCE_SNORM:
1687 return GL_LUMINANCE8_SNORM;
1688 case GL_ALPHA_SNORM:
1689 return GL_ALPHA8_SNORM;
1690 case GL_INTENSITY_SNORM:
1691 return GL_INTENSITY8_SNORM;
1692
1693 default:
1694 return format;
1695 }
1696 }
1697
1698
1699 /**
1700 * Convert an sRGB internal format to linear.
1701 */
1702 GLenum
_mesa_get_linear_internalformat(GLenum format)1703 _mesa_get_linear_internalformat(GLenum format)
1704 {
1705 switch (format) {
1706 case GL_SRGB:
1707 return GL_RGB;
1708 case GL_SRGB_ALPHA:
1709 return GL_RGBA;
1710 case GL_SRGB8:
1711 return GL_RGB8;
1712 case GL_SRGB8_ALPHA8:
1713 return GL_RGBA8;
1714 case GL_SLUMINANCE8:
1715 return GL_LUMINANCE8;
1716 case GL_SLUMINANCE:
1717 return GL_LUMINANCE;
1718 case GL_SLUMINANCE_ALPHA:
1719 return GL_LUMINANCE_ALPHA;
1720 case GL_SLUMINANCE8_ALPHA8:
1721 return GL_LUMINANCE8_ALPHA8;
1722 default:
1723 return format;
1724 }
1725 }
1726
1727
1728 /**
1729 * Do error checking of format/type combinations for glReadPixels,
1730 * glDrawPixels and glTex[Sub]Image. Note that depending on the format
1731 * and type values, we may either generate GL_INVALID_OPERATION or
1732 * GL_INVALID_ENUM.
1733 *
1734 * \param format pixel format.
1735 * \param type pixel type.
1736 *
1737 * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1738 */
1739 GLenum
_mesa_error_check_format_and_type(const struct gl_context * ctx,GLenum format,GLenum type)1740 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1741 GLenum format, GLenum type)
1742 {
1743 /* From OpenGL 3.3 spec, page 220:
1744 * "If the format is DEPTH_STENCIL, then values are taken from
1745 * both the depth buffer and the stencil buffer. If there is no
1746 * depth buffer or if there is no stencil buffer, then the error
1747 * INVALID_OPERATION occurs. If the type parameter is not
1748 * UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the
1749 * error INVALID_ENUM occurs."
1750 *
1751 * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels
1752 * cannot be used to read depth or stencil in that API.
1753 */
1754 if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL
1755 && type != GL_UNSIGNED_INT_24_8
1756 && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1757 return GL_INVALID_ENUM;
1758
1759 /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1760 switch (type) {
1761 case GL_BITMAP:
1762 if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1763 return GL_INVALID_ENUM;
1764 }
1765 break;
1766
1767 case GL_UNSIGNED_BYTE_3_3_2:
1768 case GL_UNSIGNED_BYTE_2_3_3_REV:
1769 case GL_UNSIGNED_SHORT_5_6_5:
1770 case GL_UNSIGNED_SHORT_5_6_5_REV:
1771 if (format == GL_RGB) {
1772 break; /* OK */
1773 }
1774 if (format == GL_RGB_INTEGER_EXT &&
1775 _mesa_has_texture_rgb10_a2ui(ctx)) {
1776 break; /* OK */
1777 }
1778 return GL_INVALID_OPERATION;
1779
1780 case GL_UNSIGNED_SHORT_4_4_4_4:
1781 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1782 case GL_UNSIGNED_INT_8_8_8_8:
1783 case GL_UNSIGNED_INT_8_8_8_8_REV:
1784 if (format == GL_RGBA ||
1785 format == GL_BGRA ||
1786 format == GL_ABGR_EXT) {
1787 break; /* OK */
1788 }
1789 if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1790 _mesa_has_texture_rgb10_a2ui(ctx)) {
1791 break; /* OK */
1792 }
1793 return GL_INVALID_OPERATION;
1794
1795 case GL_UNSIGNED_SHORT_5_5_5_1:
1796 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1797 case GL_UNSIGNED_INT_10_10_10_2:
1798 case GL_UNSIGNED_INT_2_10_10_10_REV:
1799 if (format == GL_RGBA ||
1800 format == GL_BGRA) {
1801 break; /* OK */
1802 }
1803 if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1804 _mesa_has_texture_rgb10_a2ui(ctx)) {
1805 break; /* OK */
1806 }
1807 if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1808 _mesa_is_gles2(ctx)) {
1809 break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1810 }
1811 return GL_INVALID_OPERATION;
1812
1813 case GL_UNSIGNED_INT_24_8:
1814 /* Depth buffer OK to read in OpenGL ES (NV_read_depth). */
1815 if (_mesa_is_gles2(ctx) && format == GL_DEPTH_COMPONENT)
1816 return GL_NO_ERROR;
1817
1818 if (format != GL_DEPTH_STENCIL) {
1819 return GL_INVALID_OPERATION;
1820 }
1821 return GL_NO_ERROR;
1822
1823 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1824 if (!_mesa_has_float_depth_buffer(ctx)) {
1825 return GL_INVALID_ENUM;
1826 }
1827 if (format != GL_DEPTH_STENCIL) {
1828 return GL_INVALID_OPERATION;
1829 }
1830 return GL_NO_ERROR;
1831
1832 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1833 if (!_mesa_has_packed_float(ctx)) {
1834 return GL_INVALID_ENUM;
1835 }
1836 if (format != GL_RGB) {
1837 return GL_INVALID_OPERATION;
1838 }
1839 return GL_NO_ERROR;
1840
1841 case GL_HALF_FLOAT_OES:
1842 switch (format) {
1843 case GL_RGBA:
1844 case GL_RGB:
1845 case GL_LUMINANCE_ALPHA:
1846 case GL_LUMINANCE:
1847 case GL_ALPHA:
1848 return GL_NO_ERROR;
1849 case GL_RG:
1850 case GL_RED:
1851 if (_mesa_has_rg_textures(ctx))
1852 return GL_NO_ERROR;
1853 FALLTHROUGH;
1854 default:
1855 return GL_INVALID_OPERATION;
1856 }
1857
1858 default:
1859 ; /* fall-through */
1860 }
1861
1862 /* now, for each format, check the type for compatibility */
1863 switch (format) {
1864 case GL_COLOR_INDEX:
1865 case GL_STENCIL_INDEX:
1866 switch (type) {
1867 case GL_BITMAP:
1868 case GL_BYTE:
1869 case GL_UNSIGNED_BYTE:
1870 case GL_SHORT:
1871 case GL_UNSIGNED_SHORT:
1872 case GL_INT:
1873 case GL_UNSIGNED_INT:
1874 case GL_FLOAT:
1875 case GL_HALF_FLOAT:
1876 return GL_NO_ERROR;
1877 default:
1878 return GL_INVALID_ENUM;
1879 }
1880
1881 case GL_RED:
1882 case GL_GREEN:
1883 case GL_BLUE:
1884 case GL_ALPHA:
1885 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
1886 case GL_INTENSITY:
1887 #endif
1888 case GL_LUMINANCE:
1889 case GL_LUMINANCE_ALPHA:
1890 case GL_DEPTH_COMPONENT:
1891 switch (type) {
1892 case GL_BYTE:
1893 case GL_UNSIGNED_BYTE:
1894 case GL_SHORT:
1895 case GL_UNSIGNED_SHORT:
1896 case GL_INT:
1897 case GL_UNSIGNED_INT:
1898 case GL_FLOAT:
1899 case GL_HALF_FLOAT:
1900 return GL_NO_ERROR;
1901 default:
1902 return GL_INVALID_ENUM;
1903 }
1904
1905 case GL_RG:
1906 if (!_mesa_has_rg_textures(ctx))
1907 return GL_INVALID_ENUM;
1908 switch (type) {
1909 case GL_BYTE:
1910 case GL_UNSIGNED_BYTE:
1911 case GL_SHORT:
1912 case GL_UNSIGNED_SHORT:
1913 case GL_INT:
1914 case GL_UNSIGNED_INT:
1915 case GL_FLOAT:
1916 case GL_HALF_FLOAT:
1917 return GL_NO_ERROR;
1918 default:
1919 return GL_INVALID_ENUM;
1920 }
1921
1922 case GL_RGB:
1923 switch (type) {
1924 case GL_BYTE:
1925 case GL_UNSIGNED_BYTE:
1926 case GL_SHORT:
1927 case GL_UNSIGNED_SHORT:
1928 case GL_INT:
1929 case GL_UNSIGNED_INT:
1930 case GL_FLOAT:
1931 case GL_UNSIGNED_BYTE_3_3_2:
1932 case GL_UNSIGNED_BYTE_2_3_3_REV:
1933 case GL_UNSIGNED_SHORT_5_6_5:
1934 case GL_UNSIGNED_SHORT_5_6_5_REV:
1935 case GL_HALF_FLOAT:
1936 return GL_NO_ERROR;
1937 case GL_UNSIGNED_INT_2_10_10_10_REV:
1938 /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1939 return _mesa_is_gles2(ctx)
1940 ? GL_NO_ERROR : GL_INVALID_ENUM;
1941 case GL_UNSIGNED_INT_5_9_9_9_REV:
1942 return _mesa_has_texture_shared_exponent(ctx)
1943 ? GL_NO_ERROR : GL_INVALID_ENUM;
1944 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1945 return _mesa_has_packed_float(ctx)
1946 ? GL_NO_ERROR : GL_INVALID_ENUM;
1947 default:
1948 return GL_INVALID_ENUM;
1949 }
1950
1951 case GL_BGR:
1952 switch (type) {
1953 /* NOTE: no packed types are supported with BGR. That's
1954 * intentional, according to the GL spec.
1955 */
1956 case GL_BYTE:
1957 case GL_UNSIGNED_BYTE:
1958 case GL_SHORT:
1959 case GL_UNSIGNED_SHORT:
1960 case GL_INT:
1961 case GL_UNSIGNED_INT:
1962 case GL_FLOAT:
1963 case GL_HALF_FLOAT:
1964 return GL_NO_ERROR;
1965 default:
1966 return GL_INVALID_ENUM;
1967 }
1968
1969 case GL_RGBA:
1970 case GL_BGRA:
1971 switch (type) {
1972 case GL_BYTE:
1973 case GL_UNSIGNED_BYTE:
1974 case GL_SHORT:
1975 case GL_UNSIGNED_SHORT:
1976 case GL_INT:
1977 case GL_UNSIGNED_INT:
1978 case GL_FLOAT:
1979 case GL_UNSIGNED_SHORT_4_4_4_4:
1980 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1981 case GL_UNSIGNED_SHORT_5_5_5_1:
1982 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1983 case GL_UNSIGNED_INT_8_8_8_8:
1984 case GL_UNSIGNED_INT_8_8_8_8_REV:
1985 case GL_UNSIGNED_INT_10_10_10_2:
1986 case GL_UNSIGNED_INT_2_10_10_10_REV:
1987 case GL_HALF_FLOAT:
1988 return GL_NO_ERROR;
1989 default:
1990 return GL_INVALID_ENUM;
1991 }
1992
1993 case GL_ABGR_EXT:
1994 switch (type) {
1995 case GL_BYTE:
1996 case GL_UNSIGNED_BYTE:
1997 case GL_SHORT:
1998 case GL_UNSIGNED_SHORT:
1999 case GL_INT:
2000 case GL_UNSIGNED_INT:
2001 case GL_FLOAT:
2002 case GL_UNSIGNED_SHORT_4_4_4_4:
2003 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2004 case GL_UNSIGNED_INT_8_8_8_8:
2005 case GL_UNSIGNED_INT_8_8_8_8_REV:
2006 case GL_HALF_FLOAT:
2007 return GL_NO_ERROR;
2008 default:
2009 return GL_INVALID_ENUM;
2010 }
2011
2012 case GL_YCBCR_MESA:
2013 if (!_mesa_has_MESA_ycbcr_texture(ctx))
2014 return GL_INVALID_ENUM;
2015 if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
2016 type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
2017 return GL_NO_ERROR;
2018 else
2019 return GL_INVALID_OPERATION;
2020
2021 case GL_DEPTH_STENCIL:
2022 if (type == GL_UNSIGNED_INT_24_8)
2023 return GL_NO_ERROR;
2024 else if (_mesa_has_float_depth_buffer(ctx) &&
2025 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
2026 return GL_NO_ERROR;
2027 else
2028 return GL_INVALID_ENUM;
2029
2030 /* integer-valued formats */
2031 case GL_RED_INTEGER_EXT:
2032 case GL_GREEN_INTEGER_EXT:
2033 case GL_BLUE_INTEGER_EXT:
2034 case GL_ALPHA_INTEGER_EXT:
2035 case GL_RG_INTEGER:
2036 switch (type) {
2037 case GL_BYTE:
2038 case GL_UNSIGNED_BYTE:
2039 case GL_SHORT:
2040 case GL_UNSIGNED_SHORT:
2041 case GL_INT:
2042 case GL_UNSIGNED_INT:
2043 return _mesa_has_integer_textures(ctx)
2044 ? GL_NO_ERROR : GL_INVALID_ENUM;
2045 default:
2046 return GL_INVALID_ENUM;
2047 }
2048
2049 case GL_RGB_INTEGER_EXT:
2050 switch (type) {
2051 case GL_BYTE:
2052 case GL_UNSIGNED_BYTE:
2053 case GL_SHORT:
2054 case GL_UNSIGNED_SHORT:
2055 case GL_INT:
2056 case GL_UNSIGNED_INT:
2057 return _mesa_has_integer_textures(ctx)
2058 ? GL_NO_ERROR : GL_INVALID_ENUM;
2059 case GL_UNSIGNED_BYTE_3_3_2:
2060 case GL_UNSIGNED_BYTE_2_3_3_REV:
2061 case GL_UNSIGNED_SHORT_5_6_5:
2062 case GL_UNSIGNED_SHORT_5_6_5_REV:
2063 return _mesa_has_texture_rgb10_a2ui(ctx)
2064 ? GL_NO_ERROR : GL_INVALID_ENUM;
2065 default:
2066 return GL_INVALID_ENUM;
2067 }
2068
2069 case GL_BGR_INTEGER_EXT:
2070 switch (type) {
2071 case GL_BYTE:
2072 case GL_UNSIGNED_BYTE:
2073 case GL_SHORT:
2074 case GL_UNSIGNED_SHORT:
2075 case GL_INT:
2076 case GL_UNSIGNED_INT:
2077 /* NOTE: no packed formats w/ BGR format */
2078 return _mesa_has_integer_textures(ctx)
2079 ? GL_NO_ERROR : GL_INVALID_ENUM;
2080 default:
2081 return GL_INVALID_ENUM;
2082 }
2083
2084 case GL_RGBA_INTEGER_EXT:
2085 case GL_BGRA_INTEGER_EXT:
2086 switch (type) {
2087 case GL_BYTE:
2088 case GL_UNSIGNED_BYTE:
2089 case GL_SHORT:
2090 case GL_UNSIGNED_SHORT:
2091 case GL_INT:
2092 case GL_UNSIGNED_INT:
2093 return _mesa_has_integer_textures(ctx)
2094 ? GL_NO_ERROR : GL_INVALID_ENUM;
2095 case GL_UNSIGNED_SHORT_4_4_4_4:
2096 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2097 case GL_UNSIGNED_SHORT_5_5_5_1:
2098 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2099 case GL_UNSIGNED_INT_8_8_8_8:
2100 case GL_UNSIGNED_INT_8_8_8_8_REV:
2101 case GL_UNSIGNED_INT_10_10_10_2:
2102 case GL_UNSIGNED_INT_2_10_10_10_REV:
2103 return _mesa_has_texture_rgb10_a2ui(ctx)
2104 ? GL_NO_ERROR : GL_INVALID_ENUM;
2105 default:
2106 return GL_INVALID_ENUM;
2107 }
2108
2109 case GL_LUMINANCE_INTEGER_EXT:
2110 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2111 switch (type) {
2112 case GL_BYTE:
2113 case GL_UNSIGNED_BYTE:
2114 case GL_SHORT:
2115 case GL_UNSIGNED_SHORT:
2116 case GL_INT:
2117 case GL_UNSIGNED_INT:
2118 return _mesa_has_integer_textures(ctx)
2119 ? GL_NO_ERROR : GL_INVALID_ENUM;
2120 default:
2121 return GL_INVALID_ENUM;
2122 }
2123
2124 default:
2125 return GL_INVALID_ENUM;
2126 }
2127 return GL_NO_ERROR;
2128 }
2129
2130
2131 /**
2132 * Do error checking of format/type combinations for OpenGL ES glReadPixels
2133 * and glTex[Sub]Image.
2134 * \return error code, or GL_NO_ERROR.
2135 */
2136 GLenum
_mesa_es_error_check_format_and_type(const struct gl_context * ctx,GLenum format,GLenum type,unsigned dimensions)2137 _mesa_es_error_check_format_and_type(const struct gl_context *ctx,
2138 GLenum format, GLenum type,
2139 unsigned dimensions)
2140 {
2141 GLboolean type_valid = GL_TRUE;
2142
2143 switch (format) {
2144 case GL_RED:
2145 case GL_RG:
2146 if (!_mesa_has_rg_textures(ctx))
2147 return GL_INVALID_VALUE;
2148 FALLTHROUGH;
2149 case GL_ALPHA:
2150 case GL_LUMINANCE:
2151 case GL_LUMINANCE_ALPHA:
2152 type_valid = (type == GL_UNSIGNED_BYTE
2153 || type == GL_FLOAT
2154 || type == GL_HALF_FLOAT_OES);
2155 break;
2156
2157 case GL_RGB:
2158 type_valid = (type == GL_UNSIGNED_BYTE
2159 || type == GL_UNSIGNED_SHORT_5_6_5
2160 || type == GL_FLOAT
2161 || type == GL_HALF_FLOAT_OES);
2162 break;
2163
2164 case GL_RGBA:
2165 type_valid = (type == GL_UNSIGNED_BYTE
2166 || type == GL_UNSIGNED_SHORT_4_4_4_4
2167 || type == GL_UNSIGNED_SHORT_5_5_5_1
2168 || type == GL_FLOAT
2169 || type == GL_HALF_FLOAT_OES
2170 || (_mesa_has_texture_type_2_10_10_10_REV(ctx) &&
2171 type == GL_UNSIGNED_INT_2_10_10_10_REV));
2172 break;
2173
2174 case GL_DEPTH_COMPONENT:
2175 /* This format is filtered against invalid dimensionalities elsewhere.
2176 */
2177 type_valid = (type == GL_UNSIGNED_SHORT
2178 || type == GL_UNSIGNED_INT);
2179 break;
2180
2181 case GL_DEPTH_STENCIL:
2182 /* This format is filtered against invalid dimensionalities elsewhere.
2183 */
2184 type_valid = (type == GL_UNSIGNED_INT_24_8);
2185 break;
2186
2187 case GL_BGRA_EXT:
2188 type_valid = (type == GL_UNSIGNED_BYTE);
2189
2190 /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
2191 * the format does not appear to be allowed for 3D textures in OpenGL
2192 * ES.
2193 */
2194 if (dimensions != 2)
2195 return GL_INVALID_VALUE;
2196
2197 break;
2198
2199 default:
2200 return GL_INVALID_VALUE;
2201 }
2202
2203 return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2204 }
2205
2206 /**
2207 * Return the simple base format for a given internal texture format.
2208 * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.
2209 *
2210 * \param ctx GL context.
2211 * \param internalFormat the internal texture format token or 1, 2, 3, or 4.
2212 *
2213 * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,
2214 * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.
2215 *
2216 * This is the format which is used during texture application (i.e. the
2217 * texture format and env mode determine the arithmetic used.
2218 */
2219 GLint
_mesa_base_tex_format(const struct gl_context * ctx,GLint internalFormat)2220 _mesa_base_tex_format(const struct gl_context *ctx, GLint internalFormat)
2221 {
2222 switch (internalFormat) {
2223 case GL_ALPHA:
2224 case GL_ALPHA4:
2225 case GL_ALPHA8:
2226 case GL_ALPHA12:
2227 case GL_ALPHA16:
2228 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2229 case 1:
2230 case GL_LUMINANCE:
2231 case GL_LUMINANCE4:
2232 case GL_LUMINANCE8:
2233 case GL_LUMINANCE12:
2234 case GL_LUMINANCE16:
2235 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2236 case 2:
2237 case GL_LUMINANCE_ALPHA:
2238 case GL_LUMINANCE4_ALPHA4:
2239 case GL_LUMINANCE6_ALPHA2:
2240 case GL_LUMINANCE8_ALPHA8:
2241 case GL_LUMINANCE12_ALPHA4:
2242 case GL_LUMINANCE12_ALPHA12:
2243 case GL_LUMINANCE16_ALPHA16:
2244 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2245 case GL_INTENSITY:
2246 case GL_INTENSITY4:
2247 case GL_INTENSITY8:
2248 case GL_INTENSITY12:
2249 case GL_INTENSITY16:
2250 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2251 case 3:
2252 return (ctx->API != API_OPENGL_CORE) ? GL_RGB : -1;
2253 case GL_RGB:
2254 case GL_R3_G3_B2:
2255 case GL_RGB4:
2256 case GL_RGB5:
2257 case GL_RGB8:
2258 case GL_RGB10:
2259 case GL_RGB12:
2260 case GL_RGB16:
2261 return GL_RGB;
2262 case 4:
2263 return (ctx->API != API_OPENGL_CORE) ? GL_RGBA : -1;
2264 case GL_RGBA:
2265 case GL_RGBA2:
2266 case GL_RGBA4:
2267 case GL_RGB5_A1:
2268 case GL_RGBA8:
2269 case GL_RGB10_A2:
2270 case GL_RGBA12:
2271 case GL_RGBA16:
2272 return GL_RGBA;
2273 case GL_BGRA:
2274 case GL_BGRA8_EXT:
2275 return GL_RGBA;
2276 default:
2277 ; /* fallthrough */
2278 }
2279
2280 if (_mesa_has_ARB_ES2_compatibility(ctx) ||
2281 _mesa_has_OES_framebuffer_object(ctx) ||
2282 _mesa_is_gles2(ctx)) {
2283 switch (internalFormat) {
2284 case GL_RGB565:
2285 return GL_RGB;
2286 default:
2287 ; /* fallthrough */
2288 }
2289 }
2290
2291 if (ctx->API != API_OPENGLES) {
2292 switch (internalFormat) {
2293 case GL_DEPTH_COMPONENT:
2294 case GL_DEPTH_COMPONENT16:
2295 case GL_DEPTH_COMPONENT24:
2296 case GL_DEPTH_COMPONENT32:
2297 return GL_DEPTH_COMPONENT;
2298 case GL_DEPTH_STENCIL:
2299 case GL_DEPTH24_STENCIL8:
2300 return GL_DEPTH_STENCIL;
2301 default:
2302 ; /* fallthrough */
2303 }
2304 }
2305
2306 if (_mesa_has_ARB_texture_stencil8(ctx) ||
2307 _mesa_has_OES_texture_stencil8(ctx)) {
2308 switch (internalFormat) {
2309 case GL_STENCIL_INDEX:
2310 case GL_STENCIL_INDEX1:
2311 case GL_STENCIL_INDEX4:
2312 case GL_STENCIL_INDEX8:
2313 case GL_STENCIL_INDEX16:
2314 return GL_STENCIL_INDEX;
2315 default:
2316 ; /* fallthrough */
2317 }
2318 }
2319
2320 switch (internalFormat) {
2321 case GL_COMPRESSED_ALPHA:
2322 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2323 case GL_COMPRESSED_LUMINANCE:
2324 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2325 case GL_COMPRESSED_LUMINANCE_ALPHA:
2326 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2327 case GL_COMPRESSED_INTENSITY:
2328 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2329 case GL_COMPRESSED_RGB:
2330 return GL_RGB;
2331 case GL_COMPRESSED_RGBA:
2332 return GL_RGBA;
2333 default:
2334 ; /* fallthrough */
2335 }
2336
2337 if (_mesa_is_compressed_format(ctx, internalFormat)) {
2338 GLenum base_compressed =
2339 _mesa_gl_compressed_format_base_format(internalFormat);
2340 if (base_compressed)
2341 return base_compressed;
2342 }
2343
2344 if ((_mesa_has_KHR_texture_compression_astc_ldr(ctx) &&
2345 is_astc_2d_format(internalFormat)) ||
2346 (_mesa_has_OES_texture_compression_astc(ctx) &&
2347 is_astc_3d_format(internalFormat)))
2348 return GL_RGBA;
2349
2350 if (_mesa_has_MESA_ycbcr_texture(ctx)) {
2351 if (internalFormat == GL_YCBCR_MESA)
2352 return GL_YCBCR_MESA;
2353 }
2354
2355 if (_mesa_has_half_float_textures(ctx)) {
2356 switch (internalFormat) {
2357 case GL_ALPHA16F_ARB:
2358 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2359 case GL_RGBA16F_ARB:
2360 return GL_RGBA;
2361 case GL_RGB16F_ARB:
2362 return GL_RGB;
2363 case GL_INTENSITY16F_ARB:
2364 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2365 case GL_LUMINANCE16F_ARB:
2366 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2367 case GL_LUMINANCE_ALPHA16F_ARB:
2368 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2369 }
2370 }
2371
2372 if (_mesa_has_float_textures(ctx)) {
2373 switch (internalFormat) {
2374 case GL_ALPHA32F_ARB:
2375 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2376 case GL_RGBA32F_ARB:
2377 return GL_RGBA;
2378 case GL_RGB32F_ARB:
2379 return GL_RGB;
2380 case GL_INTENSITY32F_ARB:
2381 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2382 case GL_LUMINANCE32F_ARB:
2383 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2384 case GL_LUMINANCE_ALPHA32F_ARB:
2385 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2386 }
2387 }
2388
2389 if (_mesa_has_EXT_texture_snorm(ctx) || _mesa_is_gles3(ctx)) {
2390 switch (internalFormat) {
2391 case GL_RED_SNORM:
2392 case GL_R8_SNORM:
2393 case GL_R16_SNORM:
2394 return GL_RED;
2395 case GL_RG_SNORM:
2396 case GL_RG8_SNORM:
2397 case GL_RG16_SNORM:
2398 return GL_RG;
2399 case GL_RGB_SNORM:
2400 case GL_RGB8_SNORM:
2401 case GL_RGB16_SNORM:
2402 return GL_RGB;
2403 case GL_RGBA_SNORM:
2404 case GL_RGBA8_SNORM:
2405 case GL_RGBA16_SNORM:
2406 return GL_RGBA;
2407 case GL_ALPHA_SNORM:
2408 case GL_ALPHA8_SNORM:
2409 case GL_ALPHA16_SNORM:
2410 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2411 case GL_LUMINANCE_SNORM:
2412 case GL_LUMINANCE8_SNORM:
2413 case GL_LUMINANCE16_SNORM:
2414 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2415 case GL_LUMINANCE_ALPHA_SNORM:
2416 case GL_LUMINANCE8_ALPHA8_SNORM:
2417 case GL_LUMINANCE16_ALPHA16_SNORM:
2418 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2419 case GL_INTENSITY_SNORM:
2420 case GL_INTENSITY8_SNORM:
2421 case GL_INTENSITY16_SNORM:
2422 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2423 default:
2424 ; /* fallthrough */
2425 }
2426 }
2427
2428 if (_mesa_has_EXT_texture_sRGB(ctx) || _mesa_is_gles3(ctx)) {
2429 switch (internalFormat) {
2430 case GL_SRGB_EXT:
2431 case GL_SRGB8_EXT:
2432 case GL_COMPRESSED_SRGB_EXT:
2433 return GL_RGB;
2434 case GL_SRGB_ALPHA_EXT:
2435 case GL_SRGB8_ALPHA8_EXT:
2436 case GL_COMPRESSED_SRGB_ALPHA_EXT:
2437 return GL_RGBA;
2438 case GL_SLUMINANCE_ALPHA_EXT:
2439 case GL_SLUMINANCE8_ALPHA8_EXT:
2440 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
2441 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2442 case GL_SLUMINANCE_EXT:
2443 case GL_SLUMINANCE8_EXT:
2444 case GL_COMPRESSED_SLUMINANCE_EXT:
2445 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2446 default:
2447 ; /* fallthrough */
2448 }
2449 }
2450
2451 if (_mesa_has_EXT_texture_sRGB_R8(ctx)) {
2452 switch (internalFormat) {
2453 case GL_SR8_EXT:
2454 return GL_RED;
2455 default:
2456 ; /* fallthrough */
2457 }
2458 }
2459
2460 if (_mesa_has_EXT_texture_sRGB_RG8(ctx)) {
2461 switch (internalFormat) {
2462 case GL_SRG8_EXT:
2463 return GL_RG;
2464 default:
2465 ; /* fallthrough */
2466 }
2467 }
2468
2469 if (_mesa_has_integer_textures(ctx)) {
2470 switch (internalFormat) {
2471 case GL_RGBA8UI_EXT:
2472 case GL_RGBA16UI_EXT:
2473 case GL_RGBA32UI_EXT:
2474 case GL_RGBA8I_EXT:
2475 case GL_RGBA16I_EXT:
2476 case GL_RGBA32I_EXT:
2477 return GL_RGBA;
2478 case GL_RGB8UI_EXT:
2479 case GL_RGB16UI_EXT:
2480 case GL_RGB32UI_EXT:
2481 case GL_RGB8I_EXT:
2482 case GL_RGB16I_EXT:
2483 case GL_RGB32I_EXT:
2484 return GL_RGB;
2485 }
2486 }
2487
2488 if (_mesa_has_texture_rgb10_a2ui(ctx)) {
2489 switch (internalFormat) {
2490 case GL_RGB10_A2UI:
2491 return GL_RGBA;
2492 }
2493 }
2494
2495 if (_mesa_has_integer_textures(ctx)) {
2496 switch (internalFormat) {
2497 case GL_ALPHA8UI_EXT:
2498 case GL_ALPHA16UI_EXT:
2499 case GL_ALPHA32UI_EXT:
2500 case GL_ALPHA8I_EXT:
2501 case GL_ALPHA16I_EXT:
2502 case GL_ALPHA32I_EXT:
2503 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2504 case GL_INTENSITY8UI_EXT:
2505 case GL_INTENSITY16UI_EXT:
2506 case GL_INTENSITY32UI_EXT:
2507 case GL_INTENSITY8I_EXT:
2508 case GL_INTENSITY16I_EXT:
2509 case GL_INTENSITY32I_EXT:
2510 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2511 case GL_LUMINANCE8UI_EXT:
2512 case GL_LUMINANCE16UI_EXT:
2513 case GL_LUMINANCE32UI_EXT:
2514 case GL_LUMINANCE8I_EXT:
2515 case GL_LUMINANCE16I_EXT:
2516 case GL_LUMINANCE32I_EXT:
2517 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2518 case GL_LUMINANCE_ALPHA8UI_EXT:
2519 case GL_LUMINANCE_ALPHA16UI_EXT:
2520 case GL_LUMINANCE_ALPHA32UI_EXT:
2521 case GL_LUMINANCE_ALPHA8I_EXT:
2522 case GL_LUMINANCE_ALPHA16I_EXT:
2523 case GL_LUMINANCE_ALPHA32I_EXT:
2524 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2525 default:
2526 ; /* fallthrough */
2527 }
2528 }
2529
2530 if (_mesa_has_rg_textures(ctx)) {
2531 switch (internalFormat) {
2532 case GL_R16F:
2533 if (!_mesa_has_half_float_textures(ctx))
2534 break;
2535 return GL_RED;
2536 case GL_R32F:
2537 if (!_mesa_has_float_textures(ctx))
2538 break;
2539 return GL_RED;
2540 case GL_R8I:
2541 case GL_R8UI:
2542 case GL_R16I:
2543 case GL_R16UI:
2544 case GL_R32I:
2545 case GL_R32UI:
2546 if (!_mesa_has_integer_textures(ctx))
2547 break;
2548 FALLTHROUGH;
2549 case GL_R8:
2550 case GL_R16:
2551 case GL_RED:
2552 case GL_COMPRESSED_RED:
2553 return GL_RED;
2554
2555 case GL_RG16F:
2556 if (!_mesa_has_half_float_textures(ctx))
2557 break;
2558 return GL_RG;
2559 case GL_RG32F:
2560 if (!_mesa_has_float_textures(ctx))
2561 break;
2562 return GL_RG;
2563 case GL_RG8I:
2564 case GL_RG8UI:
2565 case GL_RG16I:
2566 case GL_RG16UI:
2567 case GL_RG32I:
2568 case GL_RG32UI:
2569 if (!_mesa_has_integer_textures(ctx))
2570 break;
2571 FALLTHROUGH;
2572 case GL_RG:
2573 case GL_RG8:
2574 case GL_RG16:
2575 case GL_COMPRESSED_RG:
2576 return GL_RG;
2577 default:
2578 ; /* fallthrough */
2579 }
2580 }
2581
2582 if (_mesa_has_texture_shared_exponent(ctx)) {
2583 switch (internalFormat) {
2584 case GL_RGB9_E5_EXT:
2585 return GL_RGB;
2586 default:
2587 ; /* fallthrough */
2588 }
2589 }
2590
2591 if (_mesa_has_packed_float(ctx)) {
2592 switch (internalFormat) {
2593 case GL_R11F_G11F_B10F_EXT:
2594 return GL_RGB;
2595 default:
2596 ; /* fallthrough */
2597 }
2598 }
2599
2600 if (_mesa_has_float_depth_buffer(ctx)) {
2601 switch (internalFormat) {
2602 case GL_DEPTH_COMPONENT32F:
2603 return GL_DEPTH_COMPONENT;
2604 case GL_DEPTH32F_STENCIL8:
2605 return GL_DEPTH_STENCIL;
2606 default:
2607 ; /* fallthrough */
2608 }
2609 }
2610
2611 return -1; /* error */
2612 }
2613
2614 /**
2615 * Returns the effective internal format from a texture format and type.
2616 * This is used by texture image operations internally for validation, when
2617 * the specified internal format is a base (unsized) format.
2618 *
2619 * This method will only return a valid effective internal format if the
2620 * combination of format, type and internal format in base form, is acceptable.
2621 *
2622 * If a single sized internal format is defined in the spec (OpenGL-ES 3.0.4) or
2623 * in extensions, to unambiguously correspond to the given base format, then
2624 * that internal format is returned as the effective. Otherwise, if the
2625 * combination is accepted but a single effective format is not defined, the
2626 * passed base format will be returned instead.
2627 *
2628 * \param format the texture format
2629 * \param type the texture type
2630 */
2631 static GLenum
gles_effective_internal_format_for_format_and_type(GLenum format,GLenum type)2632 gles_effective_internal_format_for_format_and_type(GLenum format,
2633 GLenum type)
2634 {
2635 switch (type) {
2636 case GL_UNSIGNED_BYTE:
2637 switch (format) {
2638 case GL_RGBA:
2639 return GL_RGBA8;
2640 case GL_RGB:
2641 return GL_RGB8;
2642 case GL_RG:
2643 return GL_RG8;
2644 case GL_RED:
2645 return GL_R8;
2646 /* Although LUMINANCE_ALPHA, LUMINANCE and ALPHA appear in table 3.12,
2647 * (section 3.8 Texturing, page 128 of the OpenGL-ES 3.0.4) as effective
2648 * internal formats, they do not correspond to GL constants, so the base
2649 * format is returned instead.
2650 */
2651 case GL_BGRA_EXT:
2652 case GL_LUMINANCE_ALPHA:
2653 case GL_LUMINANCE:
2654 case GL_ALPHA:
2655 return format;
2656 }
2657 break;
2658
2659 case GL_UNSIGNED_SHORT_4_4_4_4:
2660 if (format == GL_RGBA)
2661 return GL_RGBA4;
2662 break;
2663
2664 case GL_UNSIGNED_SHORT_5_5_5_1:
2665 if (format == GL_RGBA)
2666 return GL_RGB5_A1;
2667 break;
2668
2669 case GL_UNSIGNED_SHORT_5_6_5:
2670 if (format == GL_RGB)
2671 return GL_RGB565;
2672 break;
2673
2674 /* OES_packed_depth_stencil */
2675 case GL_UNSIGNED_INT_24_8:
2676 if (format == GL_DEPTH_STENCIL)
2677 return GL_DEPTH24_STENCIL8;
2678 break;
2679
2680 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2681 if (format == GL_DEPTH_STENCIL)
2682 return GL_DEPTH32F_STENCIL8;
2683 break;
2684
2685 case GL_UNSIGNED_SHORT:
2686 if (format == GL_DEPTH_COMPONENT)
2687 return GL_DEPTH_COMPONENT16;
2688 break;
2689
2690 case GL_UNSIGNED_INT:
2691 /* It can be DEPTH_COMPONENT16 or DEPTH_COMPONENT24, so just return
2692 * the format.
2693 */
2694 if (format == GL_DEPTH_COMPONENT)
2695 return format;
2696 break;
2697
2698 /* OES_texture_float and OES_texture_half_float */
2699 case GL_FLOAT:
2700 if (format == GL_DEPTH_COMPONENT)
2701 return GL_DEPTH_COMPONENT32F;
2702 FALLTHROUGH;
2703 case GL_HALF_FLOAT_OES:
2704 switch (format) {
2705 case GL_RGBA:
2706 case GL_RGB:
2707 case GL_LUMINANCE_ALPHA:
2708 case GL_LUMINANCE:
2709 case GL_ALPHA:
2710 case GL_RED:
2711 case GL_RG:
2712 return format;
2713 }
2714 break;
2715 case GL_HALF_FLOAT:
2716 switch (format) {
2717 case GL_RG:
2718 case GL_RED:
2719 return format;
2720 }
2721 break;
2722
2723 /* GL_EXT_texture_type_2_10_10_10_REV */
2724 case GL_UNSIGNED_INT_2_10_10_10_REV:
2725 switch (format) {
2726 case GL_RGBA:
2727 case GL_RGB:
2728 return format;
2729 }
2730 break;
2731
2732 default:
2733 /* fall through and return NONE */
2734 break;
2735 }
2736
2737 return GL_NONE;
2738 }
2739
2740 /**
2741 * Error checking if internalformat for glTex[Sub]Image is valid
2742 * within OpenGL ES 3.2 (or introduced by an ES extension).
2743 *
2744 * Note, further checks in _mesa_gles_error_check_format_and_type
2745 * are required for complete checking between format and type.
2746 */
2747 static GLenum
_mesa_gles_check_internalformat(struct gl_context * ctx,GLenum internalFormat)2748 _mesa_gles_check_internalformat(struct gl_context *ctx,
2749 GLenum internalFormat)
2750 {
2751 switch (internalFormat) {
2752 /* OpenGL ES 2.0 */
2753 case GL_ALPHA:
2754 case GL_LUMINANCE:
2755 case GL_LUMINANCE_ALPHA:
2756 case GL_RGB:
2757 case GL_RGBA:
2758
2759 /* GL_OES_depth_texture */
2760 case GL_DEPTH_COMPONENT:
2761
2762 /* GL_EXT_texture_format_BGRA8888 */
2763 case GL_BGRA:
2764
2765 /* GL_OES_required_internalformat */
2766 case GL_RGB565:
2767 case GL_RGB8:
2768 case GL_RGBA4:
2769 case GL_RGB5_A1:
2770 case GL_RGBA8:
2771 case GL_DEPTH_COMPONENT16:
2772 case GL_DEPTH_COMPONENT24:
2773 case GL_DEPTH_COMPONENT32:
2774 case GL_DEPTH24_STENCIL8:
2775 case GL_RGB10_EXT:
2776 case GL_RGB10_A2_EXT:
2777 case GL_ALPHA8:
2778 case GL_LUMINANCE8:
2779 case GL_LUMINANCE8_ALPHA8:
2780 case GL_LUMINANCE4_ALPHA4:
2781 return GL_NO_ERROR;
2782
2783 case GL_R8:
2784 case GL_RG8:
2785 case GL_RED:
2786 case GL_RG:
2787 if (!_mesa_has_rg_textures(ctx))
2788 return GL_INVALID_VALUE;
2789 return GL_NO_ERROR;
2790
2791 /* GL_OES_texture_stencil8 */
2792 case GL_STENCIL_INDEX8:
2793 if (!_mesa_has_OES_texture_stencil8(ctx))
2794 return GL_INVALID_VALUE;
2795 return GL_NO_ERROR;
2796
2797 case GL_COMPRESSED_RGBA_BPTC_UNORM:
2798 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
2799 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
2800 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
2801 if (!_mesa_has_EXT_texture_compression_bptc(ctx))
2802 return GL_INVALID_VALUE;
2803 return GL_NO_ERROR;
2804
2805 case GL_COMPRESSED_RED_RGTC1:
2806 case GL_COMPRESSED_SIGNED_RED_RGTC1:
2807 case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
2808 case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
2809 if (!_mesa_has_EXT_texture_compression_rgtc(ctx))
2810 return GL_INVALID_VALUE;
2811 return GL_NO_ERROR;
2812
2813 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
2814 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
2815 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
2816 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
2817 if (!_mesa_has_EXT_texture_compression_s3tc(ctx))
2818 return GL_INVALID_VALUE;
2819 return GL_NO_ERROR;
2820
2821 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
2822 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
2823 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
2824 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
2825 if (!_mesa_has_EXT_texture_compression_s3tc_srgb(ctx))
2826 return GL_INVALID_VALUE;
2827 return GL_NO_ERROR;
2828
2829 case GL_R16:
2830 case GL_RG16:
2831 case GL_RGB16:
2832 case GL_RGBA16:
2833 if (!_mesa_has_EXT_texture_norm16(ctx))
2834 return GL_INVALID_VALUE;
2835 return GL_NO_ERROR;
2836
2837 case GL_R16_SNORM:
2838 case GL_RG16_SNORM:
2839 case GL_RGB16_SNORM:
2840 case GL_RGBA16_SNORM:
2841 if (!_mesa_has_EXT_texture_norm16(ctx) &&
2842 !_mesa_has_EXT_texture_snorm(ctx))
2843 return GL_INVALID_VALUE;
2844 return GL_NO_ERROR;
2845
2846 case GL_SR8_EXT:
2847 if (!_mesa_has_EXT_texture_sRGB_R8(ctx))
2848 return GL_INVALID_VALUE;
2849 return GL_NO_ERROR;
2850
2851 case GL_SRG8_EXT:
2852 if (!_mesa_has_EXT_texture_sRGB_RG8(ctx))
2853 return GL_INVALID_VALUE;
2854 return GL_NO_ERROR;
2855
2856 /* OpenGL ES 3.0 */
2857 case GL_SRGB8_ALPHA8:
2858 case GL_RGBA8_SNORM:
2859 case GL_RGBA16F:
2860 case GL_RGBA32F:
2861 case GL_RGBA8UI:
2862 case GL_RGBA8I:
2863 case GL_RGBA16UI:
2864 case GL_RGBA16I:
2865 case GL_RGBA32UI:
2866 case GL_RGBA32I:
2867 case GL_RGB10_A2UI:
2868 case GL_SRGB8:
2869 case GL_RGB8_SNORM:
2870 case GL_R11F_G11F_B10F:
2871 case GL_RGB9_E5:
2872 case GL_RGB16F:
2873 case GL_RGB32F:
2874 case GL_RGB8UI:
2875 case GL_RGB8I:
2876 case GL_RGB16UI:
2877 case GL_RGB16I:
2878 case GL_RGB32UI:
2879 case GL_RGB32I:
2880 case GL_RG8_SNORM:
2881 case GL_RG16F:
2882 case GL_RG32F:
2883 case GL_RG8UI:
2884 case GL_RG8I:
2885 case GL_RG16UI:
2886 case GL_RG16I:
2887 case GL_RG32UI:
2888 case GL_RG32I:
2889 case GL_R8_SNORM:
2890 case GL_R16F:
2891 case GL_R32F:
2892 case GL_R8UI:
2893 case GL_R8I:
2894 case GL_R16UI:
2895 case GL_R16I:
2896 case GL_R32UI:
2897 case GL_R32I:
2898 case GL_DEPTH_COMPONENT32F:
2899 case GL_DEPTH32F_STENCIL8:
2900 if (!_mesa_is_gles3(ctx))
2901 return GL_INVALID_VALUE;
2902 return GL_NO_ERROR;
2903
2904 case GL_BGRA8_EXT: {
2905 /* This is technically speaking out-of-spec. But too many
2906 * applications seems to depend on it, so let's allow it
2907 * together with a small complaint */
2908 static bool warned = false;
2909 if (!warned) {
2910 _mesa_warning(ctx,
2911 "internalformat = GL_BGRA8_EXT invalid by spec, but too many "
2912 "applications depend on it to error. Please fix the software "
2913 "that causes this problem.");
2914 warned = true;
2915 }
2916 return GL_NO_ERROR;
2917 }
2918
2919 default:
2920 return GL_INVALID_VALUE;
2921 }
2922 }
2923
2924 /**
2925 * Do error checking of format/type combinations for OpenGL ES 3
2926 * glTex[Sub]Image, or ES1/ES2 with GL_OES_required_internalformat.
2927 * \return error code, or GL_NO_ERROR.
2928 */
2929 GLenum
_mesa_gles_error_check_format_and_type(struct gl_context * ctx,GLenum format,GLenum type,GLenum internalFormat)2930 _mesa_gles_error_check_format_and_type(struct gl_context *ctx,
2931 GLenum format, GLenum type,
2932 GLenum internalFormat)
2933 {
2934 /* If internalFormat is an unsized format, then the effective internal
2935 * format derived from format and type should be used instead. Page 127,
2936 * section "3.8 Texturing" of the GLES 3.0.4 spec states:
2937 *
2938 * "if internalformat is a base internal format, the effective
2939 * internal format is a sized internal format that is derived
2940 * from the format and type for internal use by the GL.
2941 * Table 3.12 specifies the mapping of format and type to effective
2942 * internal formats. The effective internal format is used by the GL
2943 * for purposes such as texture completeness or type checks for
2944 * CopyTex* commands. In these cases, the GL is required to operate
2945 * as if the effective internal format was used as the internalformat
2946 * when specifying the texture data."
2947 */
2948 if (_mesa_is_enum_format_unsized(internalFormat)) {
2949 GLenum effectiveInternalFormat =
2950 gles_effective_internal_format_for_format_and_type(format, type);
2951
2952 if (effectiveInternalFormat == GL_NONE)
2953 return GL_INVALID_OPERATION;
2954
2955 GLenum baseInternalFormat;
2956 if (internalFormat == GL_BGRA_EXT) {
2957 /* Unfortunately, _mesa_base_tex_format returns a base format of
2958 * GL_RGBA for GL_BGRA_EXT. This makes perfect sense if you're
2959 * asking the question, "what channels does this format have?"
2960 * However, if we're trying to determine if two internal formats
2961 * match in the ES3 sense, we actually want GL_BGRA.
2962 */
2963 baseInternalFormat = GL_BGRA_EXT;
2964 } else {
2965 baseInternalFormat =
2966 _mesa_base_tex_format(ctx, effectiveInternalFormat);
2967 }
2968
2969 if (internalFormat != baseInternalFormat)
2970 return GL_INVALID_OPERATION;
2971
2972 internalFormat = effectiveInternalFormat;
2973 }
2974
2975 /* The GLES variant of EXT_texture_compression_s3tc is very vague and
2976 * doesn't list valid types. Just do exactly what the spec says.
2977 */
2978 if (internalFormat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
2979 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
2980 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
2981 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
2982 return format == GL_RGB || format == GL_RGBA ? GL_NO_ERROR :
2983 GL_INVALID_OPERATION;
2984
2985 /* Before checking for the combination, verify that
2986 * given internalformat is legal for OpenGL ES.
2987 */
2988 GLenum internal_format_error =
2989 _mesa_gles_check_internalformat(ctx, internalFormat);
2990
2991 if (internal_format_error != GL_NO_ERROR)
2992 return internal_format_error;
2993
2994 switch (format) {
2995 case GL_BGRA_EXT:
2996 if (type != GL_UNSIGNED_BYTE ||
2997 (internalFormat != GL_BGRA &&
2998 internalFormat != GL_RGBA8 &&
2999 internalFormat != GL_BGRA8_EXT &&
3000 internalFormat != GL_SRGB8_ALPHA8))
3001 return GL_INVALID_OPERATION;
3002 break;
3003
3004 case GL_BGR_EXT:
3005 if (type != GL_UNSIGNED_BYTE ||
3006 (internalFormat != GL_RGB8 &&
3007 internalFormat != GL_SRGB8))
3008 return GL_INVALID_OPERATION;
3009 break;
3010
3011 case GL_RGBA:
3012 switch (type) {
3013 case GL_UNSIGNED_BYTE:
3014 switch (internalFormat) {
3015 case GL_RGBA:
3016 case GL_RGBA8:
3017 case GL_RGB5_A1:
3018 case GL_RGBA4:
3019 break;
3020 case GL_SRGB8_ALPHA8_EXT:
3021 if (ctx->Version <= 20)
3022 return GL_INVALID_OPERATION;
3023 break;
3024 case GL_COMPRESSED_RGBA_BPTC_UNORM:
3025 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
3026 break;
3027 default:
3028 return GL_INVALID_OPERATION;
3029 }
3030 break;
3031
3032 case GL_BYTE:
3033 if (ctx->Version <= 20 || internalFormat != GL_RGBA8_SNORM)
3034 return GL_INVALID_OPERATION;
3035 break;
3036
3037 case GL_UNSIGNED_SHORT:
3038 if (internalFormat != GL_RGBA16)
3039 return GL_INVALID_OPERATION;
3040 break;
3041
3042 case GL_SHORT:
3043 if (internalFormat != GL_RGBA16_SNORM)
3044 return GL_INVALID_OPERATION;
3045 break;
3046
3047 case GL_UNSIGNED_SHORT_4_4_4_4:
3048 switch (internalFormat) {
3049 case GL_RGBA:
3050 case GL_RGBA4:
3051 break;
3052 default:
3053 return GL_INVALID_OPERATION;
3054 }
3055 break;
3056
3057 case GL_UNSIGNED_SHORT_5_5_5_1:
3058 switch (internalFormat) {
3059 case GL_RGBA:
3060 case GL_RGB5_A1:
3061 break;
3062 default:
3063 return GL_INVALID_OPERATION;
3064 }
3065 break;
3066
3067 case GL_UNSIGNED_INT_2_10_10_10_REV:
3068 switch (internalFormat) {
3069 case GL_RGBA:
3070 case GL_RGB10_A2:
3071 case GL_RGB5_A1:
3072 if (!_mesa_has_texture_type_2_10_10_10_REV(ctx))
3073 return GL_INVALID_OPERATION;
3074 break;
3075 default:
3076 return GL_INVALID_OPERATION;
3077 }
3078 break;
3079
3080 case GL_HALF_FLOAT:
3081 if (ctx->Version <= 20 || internalFormat != GL_RGBA16F)
3082 return GL_INVALID_OPERATION;
3083 break;
3084
3085 case GL_FLOAT:
3086 switch (internalFormat) {
3087 case GL_RGBA16F:
3088 case GL_RGBA32F:
3089 if (ctx->Version <= 20)
3090 return GL_INVALID_OPERATION;
3091 break;
3092 case GL_RGBA:
3093 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3094 return GL_INVALID_OPERATION;
3095 break;
3096 default:
3097 return GL_INVALID_OPERATION;
3098 }
3099 break;
3100
3101 case GL_HALF_FLOAT_OES:
3102 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3103 return GL_INVALID_OPERATION;
3104 break;
3105 default:
3106 return GL_INVALID_OPERATION;
3107 }
3108 break;
3109
3110 case GL_RGBA_INTEGER:
3111 if (ctx->Version <= 20)
3112 return GL_INVALID_OPERATION;
3113 switch (type) {
3114 case GL_UNSIGNED_BYTE:
3115 if (internalFormat != GL_RGBA8UI)
3116 return GL_INVALID_OPERATION;
3117 break;
3118
3119 case GL_BYTE:
3120 if (internalFormat != GL_RGBA8I)
3121 return GL_INVALID_OPERATION;
3122 break;
3123
3124 case GL_UNSIGNED_SHORT:
3125 if (internalFormat != GL_RGBA16UI)
3126 return GL_INVALID_OPERATION;
3127 break;
3128
3129 case GL_SHORT:
3130 if (internalFormat != GL_RGBA16I)
3131 return GL_INVALID_OPERATION;
3132 break;
3133
3134 case GL_UNSIGNED_INT:
3135 if (internalFormat != GL_RGBA32UI)
3136 return GL_INVALID_OPERATION;
3137 break;
3138
3139 case GL_INT:
3140 if (internalFormat != GL_RGBA32I)
3141 return GL_INVALID_OPERATION;
3142 break;
3143
3144 case GL_UNSIGNED_INT_2_10_10_10_REV:
3145 if (internalFormat != GL_RGB10_A2UI)
3146 return GL_INVALID_OPERATION;
3147 break;
3148
3149 default:
3150 return GL_INVALID_OPERATION;
3151 }
3152 break;
3153
3154 case GL_RGB:
3155 switch (type) {
3156 case GL_UNSIGNED_BYTE:
3157 switch (internalFormat) {
3158 case GL_RGB:
3159 case GL_RGB8:
3160 case GL_RGB565:
3161 break;
3162 case GL_SRGB8:
3163 if (ctx->Version <= 20)
3164 return GL_INVALID_OPERATION;
3165 break;
3166 default:
3167 return GL_INVALID_OPERATION;
3168 }
3169 break;
3170
3171 case GL_BYTE:
3172 if (ctx->Version <= 20 || internalFormat != GL_RGB8_SNORM)
3173 return GL_INVALID_OPERATION;
3174 break;
3175
3176 case GL_UNSIGNED_SHORT:
3177 if (internalFormat != GL_RGB16)
3178 return GL_INVALID_OPERATION;
3179 break;
3180
3181 case GL_SHORT:
3182 if (internalFormat != GL_RGB16_SNORM)
3183 return GL_INVALID_OPERATION;
3184 break;
3185
3186 case GL_UNSIGNED_SHORT_5_6_5:
3187 switch (internalFormat) {
3188 case GL_RGB:
3189 case GL_RGB565:
3190 break;
3191 default:
3192 return GL_INVALID_OPERATION;
3193 }
3194 break;
3195
3196 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3197 if (ctx->Version <= 20 || internalFormat != GL_R11F_G11F_B10F)
3198 return GL_INVALID_OPERATION;
3199 break;
3200
3201 case GL_UNSIGNED_INT_5_9_9_9_REV:
3202 if (ctx->Version <= 20 || internalFormat != GL_RGB9_E5)
3203 return GL_INVALID_OPERATION;
3204 break;
3205
3206 case GL_HALF_FLOAT:
3207 if (ctx->Version <= 20)
3208 return GL_INVALID_OPERATION;
3209 switch (internalFormat) {
3210 case GL_RGB16F:
3211 case GL_R11F_G11F_B10F:
3212 case GL_RGB9_E5:
3213 break;
3214 default:
3215 return GL_INVALID_OPERATION;
3216 }
3217 break;
3218
3219 case GL_FLOAT:
3220 switch (internalFormat) {
3221 case GL_RGB16F:
3222 case GL_RGB32F:
3223 case GL_R11F_G11F_B10F:
3224 case GL_RGB9_E5:
3225 if (ctx->Version <= 20)
3226 return GL_INVALID_OPERATION;
3227 break;
3228 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
3229 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
3230 break;
3231 case GL_RGB:
3232 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3233 return GL_INVALID_OPERATION;
3234 break;
3235 default:
3236 return GL_INVALID_OPERATION;
3237 }
3238 break;
3239
3240 case GL_HALF_FLOAT_OES:
3241 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3242 return GL_INVALID_OPERATION;
3243 break;
3244
3245 case GL_UNSIGNED_INT_2_10_10_10_REV:
3246 switch (internalFormat) {
3247 case GL_RGB:
3248 case GL_RGB10:
3249 case GL_RGB8:
3250 case GL_RGB565:
3251 /* GL_EXT_texture_type_2_10_10_10_REV allows GL_RGB even though
3252 * GLES3 doesn't, and GL_OES_required_internalformat extends that
3253 * to allow the sized RGB internalformats as well.
3254 */
3255 if (!_mesa_has_texture_type_2_10_10_10_REV(ctx))
3256 return GL_INVALID_OPERATION;
3257 break;
3258 default:
3259 return GL_INVALID_OPERATION;
3260 }
3261 break;
3262
3263 default:
3264 return GL_INVALID_OPERATION;
3265 }
3266 break;
3267
3268 case GL_RGB_INTEGER:
3269 if (ctx->Version <= 20)
3270 return GL_INVALID_OPERATION;
3271 switch (type) {
3272 case GL_UNSIGNED_BYTE:
3273 if (internalFormat != GL_RGB8UI)
3274 return GL_INVALID_OPERATION;
3275 break;
3276
3277 case GL_BYTE:
3278 if (internalFormat != GL_RGB8I)
3279 return GL_INVALID_OPERATION;
3280 break;
3281
3282 case GL_UNSIGNED_SHORT:
3283 if (internalFormat != GL_RGB16UI)
3284 return GL_INVALID_OPERATION;
3285 break;
3286
3287 case GL_SHORT:
3288 if (internalFormat != GL_RGB16I)
3289 return GL_INVALID_OPERATION;
3290 break;
3291
3292 case GL_UNSIGNED_INT:
3293 if (internalFormat != GL_RGB32UI)
3294 return GL_INVALID_OPERATION;
3295 break;
3296
3297 case GL_INT:
3298 if (internalFormat != GL_RGB32I)
3299 return GL_INVALID_OPERATION;
3300 break;
3301
3302 default:
3303 return GL_INVALID_OPERATION;
3304 }
3305 break;
3306
3307 case GL_RG:
3308 if (!_mesa_has_rg_textures(ctx))
3309 return GL_INVALID_OPERATION;
3310 switch (type) {
3311 case GL_UNSIGNED_BYTE:
3312 if (internalFormat != GL_RG8 &&
3313 internalFormat != GL_COMPRESSED_RED_GREEN_RGTC2_EXT &&
3314 internalFormat != GL_SRG8_EXT)
3315 return GL_INVALID_OPERATION;
3316 break;
3317
3318 case GL_BYTE:
3319 if (internalFormat != GL_RG8_SNORM &&
3320 internalFormat != GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT)
3321 return GL_INVALID_OPERATION;
3322 break;
3323
3324 case GL_UNSIGNED_SHORT:
3325 if (internalFormat != GL_RG16)
3326 return GL_INVALID_OPERATION;
3327 break;
3328
3329 case GL_SHORT:
3330 if (internalFormat != GL_RG16_SNORM)
3331 return GL_INVALID_OPERATION;
3332 break;
3333
3334 case GL_HALF_FLOAT:
3335 case GL_HALF_FLOAT_OES:
3336 switch (internalFormat) {
3337 case GL_RG16F:
3338 if (ctx->Version <= 20)
3339 return GL_INVALID_OPERATION;
3340 break;
3341 case GL_RG:
3342 if (!_mesa_has_OES_texture_half_float(ctx))
3343 return GL_INVALID_OPERATION;
3344 break;
3345 default:
3346 return GL_INVALID_OPERATION;
3347 }
3348 break;
3349
3350 case GL_FLOAT:
3351 switch (internalFormat) {
3352 case GL_RG16F:
3353 case GL_RG32F:
3354 break;
3355 case GL_RG:
3356 if (!_mesa_has_OES_texture_float(ctx))
3357 return GL_INVALID_OPERATION;
3358 break;
3359 default:
3360 return GL_INVALID_OPERATION;
3361 }
3362 break;
3363
3364 default:
3365 return GL_INVALID_OPERATION;
3366 }
3367 break;
3368
3369 case GL_RG_INTEGER:
3370 if (ctx->Version <= 20)
3371 return GL_INVALID_OPERATION;
3372 switch (type) {
3373 case GL_UNSIGNED_BYTE:
3374 if (internalFormat != GL_RG8UI)
3375 return GL_INVALID_OPERATION;
3376 break;
3377
3378 case GL_BYTE:
3379 if (internalFormat != GL_RG8I)
3380 return GL_INVALID_OPERATION;
3381 break;
3382
3383 case GL_UNSIGNED_SHORT:
3384 if (internalFormat != GL_RG16UI)
3385 return GL_INVALID_OPERATION;
3386 break;
3387
3388 case GL_SHORT:
3389 if (internalFormat != GL_RG16I)
3390 return GL_INVALID_OPERATION;
3391 break;
3392
3393 case GL_UNSIGNED_INT:
3394 if (internalFormat != GL_RG32UI)
3395 return GL_INVALID_OPERATION;
3396 break;
3397
3398 case GL_INT:
3399 if (internalFormat != GL_RG32I)
3400 return GL_INVALID_OPERATION;
3401 break;
3402
3403 default:
3404 return GL_INVALID_OPERATION;
3405 }
3406 break;
3407
3408 case GL_RED:
3409 if (!_mesa_has_rg_textures(ctx))
3410 return GL_INVALID_OPERATION;
3411 switch (type) {
3412 case GL_UNSIGNED_BYTE:
3413 if (internalFormat != GL_R8 &&
3414 internalFormat != GL_SR8_EXT &&
3415 internalFormat != GL_COMPRESSED_RED_RGTC1_EXT) {
3416 return GL_INVALID_OPERATION;
3417 }
3418 break;
3419
3420 case GL_BYTE:
3421 if (internalFormat != GL_R8_SNORM &&
3422 internalFormat != GL_COMPRESSED_SIGNED_RED_RGTC1_EXT)
3423 return GL_INVALID_OPERATION;
3424 break;
3425
3426 case GL_UNSIGNED_SHORT:
3427 if (internalFormat != GL_R16)
3428 return GL_INVALID_OPERATION;
3429 break;
3430
3431 case GL_SHORT:
3432 if (internalFormat != GL_R16_SNORM)
3433 return GL_INVALID_OPERATION;
3434 break;
3435
3436 case GL_HALF_FLOAT:
3437 case GL_HALF_FLOAT_OES:
3438 switch (internalFormat) {
3439 case GL_R16F:
3440 if (ctx->Version <= 20)
3441 return GL_INVALID_OPERATION;
3442 break;
3443 case GL_RG:
3444 case GL_RED:
3445 if (!_mesa_has_OES_texture_half_float(ctx))
3446 return GL_INVALID_OPERATION;
3447 break;
3448 default:
3449 return GL_INVALID_OPERATION;
3450 }
3451 break;
3452
3453 case GL_FLOAT:
3454 switch (internalFormat) {
3455 case GL_R16F:
3456 case GL_R32F:
3457 break;
3458 case GL_RED:
3459 if (!_mesa_has_OES_texture_float(ctx))
3460 return GL_INVALID_OPERATION;
3461 break;
3462 default:
3463 return GL_INVALID_OPERATION;
3464 }
3465 break;
3466
3467 default:
3468 return GL_INVALID_OPERATION;
3469 }
3470 break;
3471
3472 case GL_RED_INTEGER:
3473 if (ctx->Version <= 20)
3474 return GL_INVALID_OPERATION;
3475 switch (type) {
3476 case GL_UNSIGNED_BYTE:
3477 if (internalFormat != GL_R8UI)
3478 return GL_INVALID_OPERATION;
3479 break;
3480
3481 case GL_BYTE:
3482 if (internalFormat != GL_R8I)
3483 return GL_INVALID_OPERATION;
3484 break;
3485
3486 case GL_UNSIGNED_SHORT:
3487 if (internalFormat != GL_R16UI)
3488 return GL_INVALID_OPERATION;
3489 break;
3490
3491 case GL_SHORT:
3492 if (internalFormat != GL_R16I)
3493 return GL_INVALID_OPERATION;
3494 break;
3495
3496 case GL_UNSIGNED_INT:
3497 if (internalFormat != GL_R32UI)
3498 return GL_INVALID_OPERATION;
3499 break;
3500
3501 case GL_INT:
3502 if (internalFormat != GL_R32I)
3503 return GL_INVALID_OPERATION;
3504 break;
3505
3506 default:
3507 return GL_INVALID_OPERATION;
3508 }
3509 break;
3510
3511 case GL_DEPTH_COMPONENT:
3512 switch (type) {
3513 case GL_UNSIGNED_SHORT:
3514 if (internalFormat != GL_DEPTH_COMPONENT &&
3515 internalFormat != GL_DEPTH_COMPONENT16)
3516 return GL_INVALID_OPERATION;
3517 break;
3518
3519 case GL_UNSIGNED_INT:
3520 switch (internalFormat) {
3521 case GL_DEPTH_COMPONENT:
3522 case GL_DEPTH_COMPONENT16:
3523 case GL_DEPTH_COMPONENT24:
3524 break;
3525 default:
3526 return GL_INVALID_OPERATION;
3527 }
3528 break;
3529
3530 case GL_FLOAT:
3531 if (ctx->Version <= 20 || internalFormat != GL_DEPTH_COMPONENT32F)
3532 return GL_INVALID_OPERATION;
3533 break;
3534
3535 default:
3536 return GL_INVALID_OPERATION;
3537 }
3538 break;
3539
3540 case GL_DEPTH_STENCIL:
3541 switch (type) {
3542 case GL_UNSIGNED_INT_24_8:
3543 if (internalFormat != GL_DEPTH_STENCIL &&
3544 internalFormat != GL_DEPTH24_STENCIL8)
3545 return GL_INVALID_OPERATION;
3546 break;
3547
3548 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3549 if (ctx->Version <= 20 || internalFormat != GL_DEPTH32F_STENCIL8)
3550 return GL_INVALID_OPERATION;
3551 break;
3552
3553 default:
3554 return GL_INVALID_OPERATION;
3555 }
3556 break;
3557
3558 case GL_STENCIL_INDEX:
3559 if (type != GL_UNSIGNED_BYTE ||
3560 internalFormat != GL_STENCIL_INDEX8) {
3561 return GL_INVALID_OPERATION;
3562 }
3563 break;
3564
3565 case GL_ALPHA:
3566 case GL_LUMINANCE:
3567 case GL_LUMINANCE_ALPHA:
3568 switch (type) {
3569 case GL_FLOAT:
3570 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3571 return GL_INVALID_OPERATION;
3572 break;
3573 case GL_HALF_FLOAT_OES:
3574 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3575 return GL_INVALID_OPERATION;
3576 break;
3577 case GL_UNSIGNED_BYTE:
3578 if (!(format == internalFormat ||
3579 (format == GL_ALPHA && internalFormat == GL_ALPHA8) ||
3580 (format == GL_LUMINANCE && internalFormat == GL_LUMINANCE8) ||
3581 (format == GL_LUMINANCE_ALPHA &&
3582 ((internalFormat == GL_LUMINANCE8_ALPHA8) ||
3583 (internalFormat == GL_LUMINANCE4_ALPHA4))))) {
3584 return GL_INVALID_OPERATION;
3585 }
3586 break;
3587 default:
3588 return GL_INVALID_OPERATION;
3589 }
3590 break;
3591 }
3592
3593 return GL_NO_ERROR;
3594 }
3595
3596 static void
set_swizzle(uint8_t * swizzle,int x,int y,int z,int w)3597 set_swizzle(uint8_t *swizzle, int x, int y, int z, int w)
3598 {
3599 swizzle[MESA_FORMAT_SWIZZLE_X] = x;
3600 swizzle[MESA_FORMAT_SWIZZLE_Y] = y;
3601 swizzle[MESA_FORMAT_SWIZZLE_Z] = z;
3602 swizzle[MESA_FORMAT_SWIZZLE_W] = w;
3603 }
3604
3605 static bool
get_swizzle_from_gl_format(GLenum format,uint8_t * swizzle)3606 get_swizzle_from_gl_format(GLenum format, uint8_t *swizzle)
3607 {
3608 switch (format) {
3609 case GL_RGBA:
3610 case GL_RGBA_INTEGER_EXT:
3611 set_swizzle(swizzle, 0, 1, 2, 3);
3612 return true;
3613 case GL_BGRA:
3614 case GL_BGRA_INTEGER_EXT:
3615 set_swizzle(swizzle, 2, 1, 0, 3);
3616 return true;
3617 case GL_ABGR_EXT:
3618 set_swizzle(swizzle, 3, 2, 1, 0);
3619 return true;
3620 case GL_RGB:
3621 case GL_RGB_INTEGER_EXT:
3622 set_swizzle(swizzle, 0, 1, 2, 5);
3623 return true;
3624 case GL_BGR:
3625 case GL_BGR_INTEGER_EXT:
3626 set_swizzle(swizzle, 2, 1, 0, 5);
3627 return true;
3628 case GL_LUMINANCE_ALPHA:
3629 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
3630 set_swizzle(swizzle, 0, 0, 0, 1);
3631 return true;
3632 case GL_RG:
3633 case GL_RG_INTEGER:
3634 set_swizzle(swizzle, 0, 1, 4, 5);
3635 return true;
3636 case GL_RED:
3637 case GL_RED_INTEGER_EXT:
3638 set_swizzle(swizzle, 0, 4, 4, 5);
3639 return true;
3640 case GL_GREEN:
3641 case GL_GREEN_INTEGER_EXT:
3642 set_swizzle(swizzle, 4, 0, 4, 5);
3643 return true;
3644 case GL_BLUE:
3645 case GL_BLUE_INTEGER_EXT:
3646 set_swizzle(swizzle, 4, 4, 0, 5);
3647 return true;
3648 case GL_ALPHA:
3649 case GL_ALPHA_INTEGER_EXT:
3650 set_swizzle(swizzle, 4, 4, 4, 0);
3651 return true;
3652 case GL_LUMINANCE:
3653 case GL_LUMINANCE_INTEGER_EXT:
3654 set_swizzle(swizzle, 0, 0, 0, 5);
3655 return true;
3656 case GL_INTENSITY:
3657 set_swizzle(swizzle, 0, 0, 0, 0);
3658 return true;
3659 case GL_DEPTH_COMPONENT:
3660 set_swizzle(swizzle, 0, 6, 6, 6);
3661 return true;
3662 case GL_STENCIL_INDEX:
3663 set_swizzle(swizzle, 6, 0, 6, 6);
3664 return true;
3665 default:
3666 return false;
3667 }
3668 }
3669
3670 bool
_mesa_swap_bytes_in_type_enum(GLenum * type)3671 _mesa_swap_bytes_in_type_enum(GLenum *type)
3672 {
3673 switch (*type) {
3674 case GL_UNSIGNED_INT_8_8_8_8:
3675 *type = GL_UNSIGNED_INT_8_8_8_8_REV;
3676 return true;
3677 case GL_UNSIGNED_INT_8_8_8_8_REV:
3678 *type = GL_UNSIGNED_INT_8_8_8_8;
3679 return true;
3680 case GL_UNSIGNED_SHORT_8_8_MESA:
3681 *type = GL_UNSIGNED_SHORT_8_8_REV_MESA;
3682 return true;
3683 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
3684 *type = GL_UNSIGNED_SHORT_8_8_MESA;
3685 return true;
3686 case GL_BYTE:
3687 case GL_UNSIGNED_BYTE:
3688 /* format/types that are arrays of 8-bit values are unaffected by
3689 * swapBytes.
3690 */
3691 return true;
3692 default:
3693 /* swapping bytes on 4444, 1555, or >8 bit per channel types etc. will
3694 * never match a Mesa format.
3695 */
3696 return false;
3697 }
3698 }
3699
3700 /**
3701 * Take an OpenGL format (GL_RGB, GL_RGBA, etc), OpenGL data type (GL_INT,
3702 * GL_FOAT, etc) and return a matching mesa_array_format or a mesa_format
3703 * otherwise (for non-array formats).
3704 *
3705 * This function will typically be used to compute a mesa format from a GL type
3706 * so we can then call _mesa_format_convert. This function does
3707 * not consider byte swapping, so it returns types assuming that no byte
3708 * swapping is involved. If byte swapping is involved then clients are supposed
3709 * to handle that on their side before calling _mesa_format_convert.
3710 *
3711 * This function returns an uint32_t that can pack a mesa_format or a
3712 * mesa_array_format. Clients must check the mesa array format bit
3713 * (MESA_ARRAY_FORMAT_BIT) on the return value to know if the returned
3714 * format is a mesa_array_format or a mesa_format.
3715 */
3716 uint32_t
_mesa_format_from_format_and_type(GLenum format,GLenum type)3717 _mesa_format_from_format_and_type(GLenum format, GLenum type)
3718 {
3719 bool is_array_format = true;
3720 uint8_t swizzle[4];
3721 bool normalized = false, is_float = false, is_signed = false;
3722 int num_channels = 0, type_size = 0;
3723
3724 if (format == GL_COLOR_INDEX)
3725 return MESA_FORMAT_NONE;
3726
3727 /* Extract array format type information from the OpenGL data type */
3728 switch (type) {
3729 case GL_UNSIGNED_BYTE:
3730 type_size = 1;
3731 break;
3732 case GL_BYTE:
3733 type_size = 1;
3734 is_signed = true;
3735 break;
3736 case GL_UNSIGNED_SHORT:
3737 type_size = 2;
3738 break;
3739 case GL_SHORT:
3740 type_size = 2;
3741 is_signed = true;
3742 break;
3743 case GL_UNSIGNED_INT:
3744 type_size = 4;
3745 break;
3746 case GL_INT:
3747 type_size = 4;
3748 is_signed = true;
3749 break;
3750 case GL_HALF_FLOAT:
3751 case GL_HALF_FLOAT_OES:
3752 type_size = 2;
3753 is_signed = true;
3754 is_float = true;
3755 break;
3756 case GL_FLOAT:
3757 type_size = 4;
3758 is_signed = true;
3759 is_float = true;
3760 break;
3761 default:
3762 is_array_format = false;
3763 break;
3764 }
3765
3766 /* Extract array format swizzle information from the OpenGL format */
3767 if (is_array_format)
3768 is_array_format = get_swizzle_from_gl_format(format, swizzle);
3769
3770 /* If this is an array format type after checking data type and format,
3771 * create the array format
3772 */
3773 if (is_array_format) {
3774 enum mesa_array_format_base_format bf;
3775 switch (format) {
3776 case GL_DEPTH_COMPONENT:
3777 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_DEPTH;
3778 break;
3779 case GL_STENCIL_INDEX:
3780 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_STENCIL;
3781 break;
3782 default:
3783 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS;
3784 break;
3785 }
3786
3787 normalized = !(_mesa_is_enum_format_integer(format) ||
3788 format == GL_STENCIL_INDEX);
3789 num_channels = _mesa_components_in_format(format);
3790
3791 return MESA_ARRAY_FORMAT(bf, type_size, is_signed, is_float,
3792 normalized, num_channels,
3793 swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
3794 }
3795
3796 /* Otherwise this is not an array format, so return the mesa_format
3797 * matching the OpenGL format and data type
3798 */
3799 switch (type) {
3800 case GL_UNSIGNED_SHORT_5_6_5:
3801 if (format == GL_RGB)
3802 return MESA_FORMAT_B5G6R5_UNORM;
3803 else if (format == GL_BGR)
3804 return MESA_FORMAT_R5G6B5_UNORM;
3805 else if (format == GL_RGB_INTEGER)
3806 return MESA_FORMAT_B5G6R5_UINT;
3807 break;
3808 case GL_UNSIGNED_SHORT_5_6_5_REV:
3809 if (format == GL_RGB)
3810 return MESA_FORMAT_R5G6B5_UNORM;
3811 else if (format == GL_BGR)
3812 return MESA_FORMAT_B5G6R5_UNORM;
3813 else if (format == GL_RGB_INTEGER)
3814 return MESA_FORMAT_R5G6B5_UINT;
3815 break;
3816 case GL_UNSIGNED_SHORT_4_4_4_4:
3817 if (format == GL_RGBA)
3818 return MESA_FORMAT_A4B4G4R4_UNORM;
3819 else if (format == GL_BGRA)
3820 return MESA_FORMAT_A4R4G4B4_UNORM;
3821 else if (format == GL_ABGR_EXT)
3822 return MESA_FORMAT_R4G4B4A4_UNORM;
3823 else if (format == GL_RGBA_INTEGER)
3824 return MESA_FORMAT_A4B4G4R4_UINT;
3825 else if (format == GL_BGRA_INTEGER)
3826 return MESA_FORMAT_A4R4G4B4_UINT;
3827 break;
3828 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3829 if (format == GL_RGBA)
3830 return MESA_FORMAT_R4G4B4A4_UNORM;
3831 else if (format == GL_BGRA)
3832 return MESA_FORMAT_B4G4R4A4_UNORM;
3833 else if (format == GL_ABGR_EXT)
3834 return MESA_FORMAT_A4B4G4R4_UNORM;
3835 else if (format == GL_RGBA_INTEGER)
3836 return MESA_FORMAT_R4G4B4A4_UINT;
3837 else if (format == GL_BGRA_INTEGER)
3838 return MESA_FORMAT_B4G4R4A4_UINT;
3839 break;
3840 case GL_UNSIGNED_SHORT_5_5_5_1:
3841 if (format == GL_RGBA)
3842 return MESA_FORMAT_A1B5G5R5_UNORM;
3843 else if (format == GL_BGRA)
3844 return MESA_FORMAT_A1R5G5B5_UNORM;
3845 else if (format == GL_RGBA_INTEGER)
3846 return MESA_FORMAT_A1B5G5R5_UINT;
3847 else if (format == GL_BGRA_INTEGER)
3848 return MESA_FORMAT_A1R5G5B5_UINT;
3849 break;
3850 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3851 if (format == GL_RGBA)
3852 return MESA_FORMAT_R5G5B5A1_UNORM;
3853 else if (format == GL_BGRA)
3854 return MESA_FORMAT_B5G5R5A1_UNORM;
3855 else if (format == GL_RGBA_INTEGER)
3856 return MESA_FORMAT_R5G5B5A1_UINT;
3857 else if (format == GL_BGRA_INTEGER)
3858 return MESA_FORMAT_B5G5R5A1_UINT;
3859 break;
3860 case GL_UNSIGNED_BYTE_3_3_2:
3861 if (format == GL_RGB)
3862 return MESA_FORMAT_B2G3R3_UNORM;
3863 else if (format == GL_RGB_INTEGER)
3864 return MESA_FORMAT_B2G3R3_UINT;
3865 break;
3866 case GL_UNSIGNED_BYTE_2_3_3_REV:
3867 if (format == GL_RGB)
3868 return MESA_FORMAT_R3G3B2_UNORM;
3869 else if (format == GL_RGB_INTEGER)
3870 return MESA_FORMAT_R3G3B2_UINT;
3871 break;
3872 case GL_UNSIGNED_INT_5_9_9_9_REV:
3873 if (format == GL_RGB)
3874 return MESA_FORMAT_R9G9B9E5_FLOAT;
3875 break;
3876 case GL_UNSIGNED_INT_10_10_10_2:
3877 if (format == GL_RGBA)
3878 return MESA_FORMAT_A2B10G10R10_UNORM;
3879 else if (format == GL_RGBA_INTEGER)
3880 return MESA_FORMAT_A2B10G10R10_UINT;
3881 else if (format == GL_BGRA)
3882 return MESA_FORMAT_A2R10G10B10_UNORM;
3883 else if (format == GL_BGRA_INTEGER)
3884 return MESA_FORMAT_A2R10G10B10_UINT;
3885 break;
3886 case GL_UNSIGNED_INT_2_10_10_10_REV:
3887 if (format == GL_RGB)
3888 return MESA_FORMAT_R10G10B10X2_UNORM;
3889 if (format == GL_RGBA)
3890 return MESA_FORMAT_R10G10B10A2_UNORM;
3891 else if (format == GL_RGBA_INTEGER)
3892 return MESA_FORMAT_R10G10B10A2_UINT;
3893 else if (format == GL_BGRA)
3894 return MESA_FORMAT_B10G10R10A2_UNORM;
3895 else if (format == GL_BGRA_INTEGER)
3896 return MESA_FORMAT_B10G10R10A2_UINT;
3897 break;
3898 case GL_UNSIGNED_INT_8_8_8_8:
3899 if (format == GL_RGBA)
3900 return MESA_FORMAT_A8B8G8R8_UNORM;
3901 else if (format == GL_BGRA)
3902 return MESA_FORMAT_A8R8G8B8_UNORM;
3903 else if (format == GL_ABGR_EXT)
3904 return MESA_FORMAT_R8G8B8A8_UNORM;
3905 else if (format == GL_RGBA_INTEGER)
3906 return MESA_FORMAT_A8B8G8R8_UINT;
3907 else if (format == GL_BGRA_INTEGER)
3908 return MESA_FORMAT_A8R8G8B8_UINT;
3909 break;
3910 case GL_UNSIGNED_INT_8_8_8_8_REV:
3911 if (format == GL_RGBA)
3912 return MESA_FORMAT_R8G8B8A8_UNORM;
3913 else if (format == GL_BGRA)
3914 return MESA_FORMAT_B8G8R8A8_UNORM;
3915 else if (format == GL_ABGR_EXT)
3916 return MESA_FORMAT_A8B8G8R8_UNORM;
3917 else if (format == GL_RGBA_INTEGER)
3918 return MESA_FORMAT_R8G8B8A8_UINT;
3919 else if (format == GL_BGRA_INTEGER)
3920 return MESA_FORMAT_B8G8R8A8_UINT;
3921 break;
3922 case GL_UNSIGNED_SHORT_8_8_MESA:
3923 if (format == GL_YCBCR_MESA)
3924 return MESA_FORMAT_YCBCR;
3925 break;
3926 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
3927 if (format == GL_YCBCR_MESA)
3928 return MESA_FORMAT_YCBCR_REV;
3929 break;
3930 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3931 if (format == GL_RGB)
3932 return MESA_FORMAT_R11G11B10_FLOAT;
3933 break;
3934 case GL_FLOAT:
3935 if (format == GL_DEPTH_COMPONENT)
3936 return MESA_FORMAT_Z_FLOAT32;
3937 break;
3938 case GL_UNSIGNED_INT:
3939 if (format == GL_DEPTH_COMPONENT)
3940 return MESA_FORMAT_Z_UNORM32;
3941 break;
3942 case GL_UNSIGNED_SHORT:
3943 if (format == GL_DEPTH_COMPONENT)
3944 return MESA_FORMAT_Z_UNORM16;
3945 break;
3946 case GL_UNSIGNED_INT_24_8:
3947 if (format == GL_DEPTH_STENCIL)
3948 return MESA_FORMAT_S8_UINT_Z24_UNORM;
3949 else if (format == GL_DEPTH_COMPONENT)
3950 return MESA_FORMAT_X8_UINT_Z24_UNORM;
3951 break;
3952 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3953 if (format == GL_DEPTH_STENCIL)
3954 return MESA_FORMAT_Z32_FLOAT_S8X24_UINT;
3955 break;
3956 default:
3957 break;
3958 }
3959
3960 fprintf(stderr, "Unsupported format/type: %s/%s\n",
3961 _mesa_enum_to_string(format),
3962 _mesa_enum_to_string(type));
3963
3964 /* If we got here it means that we could not find a Mesa format that
3965 * matches the GL format/type provided. We may need to add a new Mesa
3966 * format in that case.
3967 */
3968 unreachable("Unsupported format");
3969 }
3970
3971 uint32_t
_mesa_tex_format_from_format_and_type(const struct gl_context * ctx,GLenum gl_format,GLenum type)3972 _mesa_tex_format_from_format_and_type(const struct gl_context *ctx,
3973 GLenum gl_format, GLenum type)
3974 {
3975 mesa_format format = _mesa_format_from_format_and_type(gl_format, type);
3976
3977 if (_mesa_format_is_mesa_array_format(format))
3978 format = _mesa_format_from_array_format(format);
3979
3980 if (format == MESA_FORMAT_NONE || !ctx->TextureFormatSupported[format])
3981 return MESA_FORMAT_NONE;
3982
3983 return format;
3984 }
3985
3986 /**
3987 * Returns true if \p internal_format is a sized internal format that
3988 * is marked "Color Renderable" in Table 8.10 of the ES 3.2 specification.
3989 */
3990 bool
_mesa_is_es3_color_renderable(const struct gl_context * ctx,GLenum internal_format)3991 _mesa_is_es3_color_renderable(const struct gl_context *ctx,
3992 GLenum internal_format)
3993 {
3994 switch (internal_format) {
3995 case GL_R8:
3996 case GL_RG8:
3997 case GL_RGB8:
3998 case GL_RGB565:
3999 case GL_RGBA4:
4000 case GL_RGB5_A1:
4001 case GL_RGBA8:
4002 case GL_RGB10_A2:
4003 case GL_RGB10_A2UI:
4004 case GL_SRGB8_ALPHA8:
4005 case GL_R11F_G11F_B10F:
4006 case GL_R8I:
4007 case GL_R8UI:
4008 case GL_R16I:
4009 case GL_R16UI:
4010 case GL_R32I:
4011 case GL_R32UI:
4012 case GL_RG8I:
4013 case GL_RG8UI:
4014 case GL_RG16I:
4015 case GL_RG16UI:
4016 case GL_RG32I:
4017 case GL_RG32UI:
4018 case GL_RGBA8I:
4019 case GL_RGBA8UI:
4020 case GL_RGBA16I:
4021 case GL_RGBA16UI:
4022 case GL_RGBA32I:
4023 case GL_RGBA32UI:
4024 return true;
4025 case GL_R16F:
4026 case GL_RG16F:
4027 case GL_RGB16F:
4028 case GL_RGBA16F:
4029 return _mesa_has_EXT_color_buffer_half_float(ctx);
4030 case GL_R32F:
4031 case GL_RG32F:
4032 case GL_RGBA32F:
4033 return _mesa_has_EXT_color_buffer_float(ctx);
4034 case GL_R16:
4035 case GL_RG16:
4036 case GL_RGBA16:
4037 return _mesa_has_EXT_texture_norm16(ctx);
4038 case GL_R8_SNORM:
4039 case GL_RG8_SNORM:
4040 case GL_RGBA8_SNORM:
4041 return _mesa_has_EXT_render_snorm(ctx);
4042 case GL_R16_SNORM:
4043 case GL_RG16_SNORM:
4044 case GL_RGBA16_SNORM:
4045 return _mesa_has_EXT_texture_norm16(ctx) &&
4046 _mesa_has_EXT_render_snorm(ctx);
4047 case GL_BGRA:
4048 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx));
4049 return true;
4050 case GL_BGRA8_EXT:
4051 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx) &&
4052 _mesa_has_EXT_texture_storage(ctx));
4053 return true;
4054 default:
4055 return false;
4056 }
4057 }
4058
4059 /**
4060 * Returns true if \p internal_format is a sized internal format that
4061 * is marked "Texture Filterable" in Table 8.10 of the ES 3.2 specification.
4062 */
4063 bool
_mesa_is_es3_texture_filterable(const struct gl_context * ctx,GLenum internal_format)4064 _mesa_is_es3_texture_filterable(const struct gl_context *ctx,
4065 GLenum internal_format)
4066 {
4067 switch (internal_format) {
4068 case GL_R8:
4069 case GL_R8_SNORM:
4070 case GL_RG8:
4071 case GL_RG8_SNORM:
4072 case GL_RGB8:
4073 case GL_RGB8_SNORM:
4074 case GL_RGB565:
4075 case GL_RGBA4:
4076 case GL_RGB5_A1:
4077 case GL_RGBA8:
4078 case GL_RGBA8_SNORM:
4079 case GL_RGB10_A2:
4080 case GL_SRGB8:
4081 case GL_SRGB8_ALPHA8:
4082 case GL_R16F:
4083 case GL_RG16F:
4084 case GL_RGB16F:
4085 case GL_RGBA16F:
4086 case GL_R11F_G11F_B10F:
4087 case GL_RGB9_E5:
4088 return true;
4089 case GL_R16:
4090 case GL_R16_SNORM:
4091 case GL_RG16:
4092 case GL_RG16_SNORM:
4093 case GL_RGB16:
4094 case GL_RGB16_SNORM:
4095 case GL_RGBA16:
4096 case GL_RGBA16_SNORM:
4097 return _mesa_has_EXT_texture_norm16(ctx);
4098 case GL_R32F:
4099 case GL_RG32F:
4100 case GL_RGB32F:
4101 case GL_RGBA32F:
4102 /* The OES_texture_float_linear spec says:
4103 *
4104 * "When implemented against OpenGL ES 3.0 or later versions, sized
4105 * 32-bit floating-point formats become texture-filterable. This
4106 * should be noted by, for example, checking the ``TF'' column of
4107 * table 8.13 in the ES 3.1 Specification (``Correspondence of sized
4108 * internal formats to base internal formats ... and use cases ...'')
4109 * for the R32F, RG32F, RGB32F, and RGBA32F formats."
4110 */
4111 return _mesa_has_OES_texture_float_linear(ctx);
4112 case GL_BGRA:
4113 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx));
4114 return true;
4115 case GL_BGRA8_EXT:
4116 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx) &&
4117 _mesa_has_EXT_texture_storage(ctx));
4118 return true;
4119 default:
4120 return false;
4121 }
4122 }
4123