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:
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:
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:
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:
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:
377 case GL_GREEN:
378 case GL_GREEN_INTEGER:
379 case GL_BLUE:
380 case GL_BLUE_INTEGER:
381 case GL_ALPHA:
382 case GL_ALPHA_INTEGER:
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:
393 case GL_RG_INTEGER:
394 return 2;
395
396 case GL_RGB:
397 case GL_BGR:
398 case GL_RGB_INTEGER:
399 case GL_BGR_INTEGER:
400 return 3;
401
402 case GL_RGBA:
403 case GL_BGRA:
404 case GL_ABGR_EXT:
405 case GL_RGBA_INTEGER:
406 case GL_BGRA_INTEGER:
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:
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 || format == GL_BGR_INTEGER)
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 || format == GL_BGR_INTEGER)
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 || format == GL_BGRA_INTEGER)
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 || format == GL_BGRA_INTEGER)
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 || format == GL_BGRA_INTEGER ||
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 || format == GL_BGRA_INTEGER ||
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:
498 if (format == GL_DEPTH_COMPONENT ||
499 format == GL_DEPTH_STENCIL)
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:
698 case GL_RGB32UI:
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:
706 case GL_RGB16UI:
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:
714 case GL_RGB8UI:
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:
738 case GL_GREEN_INTEGER:
739 case GL_BLUE_INTEGER:
740 case GL_ALPHA_INTEGER:
741 case GL_RGB_INTEGER:
742 case GL_RGBA_INTEGER:
743 case GL_BGR_INTEGER:
744 case GL_BGRA_INTEGER:
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:
750 case GL_RGB32I:
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:
758 case GL_RGB16I:
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:
766 case GL_RGB8I:
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:
787 case GL_COMPRESSED_RGBA_ASTC_5x4:
788 case GL_COMPRESSED_RGBA_ASTC_5x5:
789 case GL_COMPRESSED_RGBA_ASTC_6x5:
790 case GL_COMPRESSED_RGBA_ASTC_6x6:
791 case GL_COMPRESSED_RGBA_ASTC_8x5:
792 case GL_COMPRESSED_RGBA_ASTC_8x6:
793 case GL_COMPRESSED_RGBA_ASTC_8x8:
794 case GL_COMPRESSED_RGBA_ASTC_10x5:
795 case GL_COMPRESSED_RGBA_ASTC_10x6:
796 case GL_COMPRESSED_RGBA_ASTC_10x8:
797 case GL_COMPRESSED_RGBA_ASTC_10x10:
798 case GL_COMPRESSED_RGBA_ASTC_12x10:
799 case GL_COMPRESSED_RGBA_ASTC_12x12:
800 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4:
801 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4:
802 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5:
803 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5:
804 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6:
805 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5:
806 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6:
807 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
808 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5:
809 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6:
810 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8:
811 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10:
812 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10:
813 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12:
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:
1031 case GL_SRGB8:
1032 case GL_SRGB_ALPHA:
1033 case GL_SRGB8_ALPHA8:
1034 case GL_SLUMINANCE_ALPHA:
1035 case GL_SLUMINANCE8_ALPHA8:
1036 case GL_SLUMINANCE:
1037 case GL_SLUMINANCE8:
1038 case GL_COMPRESSED_SRGB:
1039 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
1040 case GL_COMPRESSED_SRGB_ALPHA:
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:
1045 case GL_COMPRESSED_SLUMINANCE_ALPHA:
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:
1071 case GL_COMPRESSED_RGBA_ASTC_5x4:
1072 case GL_COMPRESSED_RGBA_ASTC_5x5:
1073 case GL_COMPRESSED_RGBA_ASTC_6x5:
1074 case GL_COMPRESSED_RGBA_ASTC_6x6:
1075 case GL_COMPRESSED_RGBA_ASTC_8x5:
1076 case GL_COMPRESSED_RGBA_ASTC_8x6:
1077 case GL_COMPRESSED_RGBA_ASTC_8x8:
1078 case GL_COMPRESSED_RGBA_ASTC_10x5:
1079 case GL_COMPRESSED_RGBA_ASTC_10x6:
1080 case GL_COMPRESSED_RGBA_ASTC_10x8:
1081 case GL_COMPRESSED_RGBA_ASTC_10x10:
1082 case GL_COMPRESSED_RGBA_ASTC_12x10:
1083 case GL_COMPRESSED_RGBA_ASTC_12x12:
1084 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4:
1085 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4:
1086 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5:
1087 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5:
1088 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6:
1089 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5:
1090 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6:
1091 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8:
1092 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5:
1093 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6:
1094 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8:
1095 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10:
1096 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10:
1097 case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12:
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:
1103 case GL_GREEN_INTEGER:
1104 case GL_BLUE_INTEGER:
1105 case GL_ALPHA_INTEGER:
1106 case GL_RGB_INTEGER:
1107 case GL_RGBA_INTEGER:
1108 case GL_BGR_INTEGER:
1109 case GL_BGRA_INTEGER:
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:
1115 case GL_RGB32UI:
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:
1123 case GL_RGB16UI:
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:
1131 case GL_RGB8UI:
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:
1139 case GL_RGB32I:
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:
1147 case GL_RGB16I:
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:
1155 case GL_RGB8I:
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:
1256 case GL_DEPTH_STENCIL:
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:
1278 case GL_STENCIL_INDEX4:
1279 case GL_STENCIL_INDEX8:
1280 case GL_STENCIL_INDEX16:
1281 case GL_DEPTH_STENCIL:
1282 case GL_DEPTH24_STENCIL8:
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_compatible(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:
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:
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:
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:
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:
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:
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 static bool
valid_texture_format_enum(const struct gl_context * ctx,GLenum format)1729 valid_texture_format_enum(const struct gl_context *ctx, GLenum format)
1730 {
1731 switch (format) {
1732 case GL_RGBA:
1733 case GL_RGB:
1734 case GL_RED:
1735 /* These are always supported */
1736 return true;
1737
1738 case GL_STENCIL_INDEX:
1739 return _mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx);
1740
1741 case GL_COLOR_INDEX:
1742 return _mesa_is_desktop_gl_compat(ctx);
1743
1744 case GL_RG:
1745 return _mesa_has_rg_textures(ctx);
1746
1747 case GL_GREEN:
1748 case GL_BLUE:
1749 return _mesa_is_desktop_gl(ctx);
1750
1751 case GL_BGR:
1752 case GL_BGRA:
1753 assert(_mesa_is_desktop_gl(ctx) ||
1754 _mesa_has_EXT_texture_format_BGRA8888(ctx));
1755 return true;
1756
1757 case GL_RED_INTEGER:
1758 case GL_GREEN_INTEGER:
1759 case GL_BLUE_INTEGER:
1760 case GL_RGB_INTEGER:
1761 case GL_RGBA_INTEGER:
1762 return _mesa_has_integer_textures(ctx);
1763
1764 case GL_RG_INTEGER:
1765 return (_mesa_has_EXT_texture_integer(ctx) &&
1766 _mesa_has_ARB_texture_rg(ctx)) ||
1767 _mesa_is_gles3(ctx);
1768
1769 case GL_BGR_INTEGER:
1770 case GL_BGRA_INTEGER:
1771 case GL_ALPHA_INTEGER:
1772 return _mesa_has_EXT_texture_integer(ctx);
1773
1774 case GL_LUMINANCE_INTEGER_EXT:
1775 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1776 return _mesa_is_desktop_gl_compat(ctx) &&
1777 _mesa_has_EXT_texture_integer(ctx);
1778
1779 case GL_DEPTH_COMPONENT:
1780 return _mesa_is_desktop_gl(ctx) ||
1781 _mesa_has_OES_depth_texture(ctx);
1782
1783 case GL_DEPTH_STENCIL:
1784 return _mesa_has_EXT_packed_depth_stencil(ctx) ||
1785 (_mesa_has_OES_packed_depth_stencil(ctx) &&
1786 _mesa_has_OES_depth_texture(ctx));
1787
1788 case GL_LUMINANCE_ALPHA:
1789 case GL_LUMINANCE:
1790 case GL_ALPHA:
1791 return _mesa_is_desktop_gl_compat(ctx) ||
1792 _mesa_has_ARB_ES3_compatibility(ctx) ||
1793 _mesa_is_gles(ctx);
1794
1795 case GL_ABGR_EXT:
1796 return _mesa_has_EXT_abgr(ctx);
1797
1798 case GL_YCBCR_MESA:
1799 return _mesa_has_MESA_ycbcr_texture(ctx);
1800
1801 default:
1802 return false;
1803 }
1804 }
1805
1806 static bool
valid_texture_type_enum(const struct gl_context * ctx,GLenum type)1807 valid_texture_type_enum(const struct gl_context *ctx, GLenum type)
1808 {
1809 switch (type) {
1810 case GL_UNSIGNED_BYTE:
1811 case GL_BYTE:
1812 case GL_UNSIGNED_SHORT:
1813 case GL_SHORT:
1814 case GL_UNSIGNED_INT:
1815 case GL_INT:
1816 case GL_UNSIGNED_SHORT_5_6_5:
1817 case GL_UNSIGNED_SHORT_4_4_4_4:
1818 case GL_UNSIGNED_SHORT_5_5_5_1:
1819 /* These are always supported */
1820 return true;
1821
1822 case GL_FLOAT:
1823 return _mesa_is_desktop_gl(ctx) || _mesa_has_OES_texture_float(ctx);
1824
1825 case GL_HALF_FLOAT:
1826 return _mesa_has_ARB_half_float_pixel(ctx) || _mesa_is_gles3(ctx);
1827
1828 case GL_HALF_FLOAT_OES:
1829 /* This is a different enum than the above, that only applies to this
1830 * extension
1831 */
1832 return _mesa_has_OES_texture_half_float(ctx);
1833
1834 case GL_BITMAP:
1835 return _mesa_is_desktop_gl_compat(ctx);
1836
1837 case GL_UNSIGNED_BYTE_3_3_2:
1838 case GL_UNSIGNED_BYTE_2_3_3_REV:
1839 case GL_UNSIGNED_SHORT_5_6_5_REV:
1840 case GL_UNSIGNED_INT_8_8_8_8:
1841 case GL_UNSIGNED_INT_8_8_8_8_REV:
1842 return _mesa_is_desktop_gl(ctx);
1843
1844 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1845 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1846 assert(_mesa_is_desktop_gl(ctx) || _mesa_has_EXT_read_format_bgra(ctx));
1847 return true;
1848
1849 case GL_UNSIGNED_INT_10_10_10_2:
1850 /* not supported in GLESv3, unlike GL_UNSIGNED_INT_2_10_10_10_REV */
1851 return _mesa_is_desktop_gl(ctx);
1852
1853 case GL_UNSIGNED_INT_2_10_10_10_REV:
1854 return _mesa_has_texture_type_2_10_10_10_REV(ctx);
1855
1856 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1857 return _mesa_has_packed_float(ctx);
1858
1859 case GL_UNSIGNED_INT_5_9_9_9_REV:
1860 return _mesa_has_texture_shared_exponent(ctx);
1861
1862 case GL_UNSIGNED_INT_24_8:
1863 assert(_mesa_has_EXT_packed_depth_stencil(ctx) ||
1864 _mesa_has_OES_packed_depth_stencil(ctx));
1865 return true;
1866
1867 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1868 return _mesa_has_float_depth_buffer(ctx);
1869
1870 default:
1871 return false;
1872 }
1873 }
1874
1875
1876 /**
1877 * Do error checking of format/type combinations for glReadPixels,
1878 * glDrawPixels and glTex[Sub]Image. Note that depending on the format
1879 * and type values, we may either generate GL_INVALID_OPERATION or
1880 * GL_INVALID_ENUM.
1881 *
1882 * \param format pixel format.
1883 * \param type pixel type.
1884 *
1885 * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1886 */
1887 GLenum
_mesa_error_check_format_and_type(const struct gl_context * ctx,GLenum format,GLenum type)1888 _mesa_error_check_format_and_type(const struct gl_context *ctx,
1889 GLenum format, GLenum type)
1890 {
1891
1892 if (!valid_texture_format_enum(ctx, format) ||
1893 !valid_texture_type_enum(ctx, type))
1894 return GL_INVALID_ENUM;
1895
1896 /* From OpenGL 3.3 spec, page 220:
1897 * "If the format is DEPTH_STENCIL, then values are taken from
1898 * both the depth buffer and the stencil buffer. If there is no
1899 * depth buffer or if there is no stencil buffer, then the error
1900 * INVALID_OPERATION occurs. If the type parameter is not
1901 * UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the
1902 * error INVALID_ENUM occurs."
1903 *
1904 * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels
1905 * cannot be used to read depth or stencil in that API.
1906 */
1907 if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL
1908 && type != GL_UNSIGNED_INT_24_8
1909 && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1910 return GL_INVALID_ENUM;
1911
1912 /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1913 switch (type) {
1914 case GL_BITMAP:
1915 if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1916 return GL_INVALID_ENUM;
1917 }
1918 break;
1919
1920 case GL_UNSIGNED_BYTE_3_3_2:
1921 case GL_UNSIGNED_BYTE_2_3_3_REV:
1922 case GL_UNSIGNED_SHORT_5_6_5:
1923 case GL_UNSIGNED_SHORT_5_6_5_REV:
1924 if (format == GL_RGB) {
1925 break; /* OK */
1926 }
1927 if (format == GL_RGB_INTEGER &&
1928 _mesa_has_ARB_texture_rgb10_a2ui(ctx)) {
1929 break; /* OK */
1930 }
1931 return GL_INVALID_OPERATION;
1932
1933 case GL_UNSIGNED_SHORT_4_4_4_4:
1934 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1935 case GL_UNSIGNED_INT_8_8_8_8:
1936 case GL_UNSIGNED_INT_8_8_8_8_REV:
1937 if (format == GL_RGBA ||
1938 format == GL_BGRA ||
1939 format == GL_ABGR_EXT) {
1940 break; /* OK */
1941 }
1942 if ((format == GL_RGBA_INTEGER || format == GL_BGRA_INTEGER) &&
1943 _mesa_has_ARB_texture_rgb10_a2ui(ctx)) {
1944 break; /* OK */
1945 }
1946 return GL_INVALID_OPERATION;
1947
1948 case GL_UNSIGNED_SHORT_5_5_5_1:
1949 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1950 case GL_UNSIGNED_INT_10_10_10_2:
1951 case GL_UNSIGNED_INT_2_10_10_10_REV:
1952 if (format == GL_RGBA ||
1953 format == GL_BGRA) {
1954 break; /* OK */
1955 }
1956 if ((format == GL_RGBA_INTEGER || format == GL_BGRA_INTEGER) &&
1957 _mesa_has_ARB_texture_rgb10_a2ui(ctx)) {
1958 break; /* OK */
1959 }
1960 if ((format == GL_RGBA_INTEGER || format == GL_BGRA_INTEGER) &&
1961 type == GL_UNSIGNED_INT_2_10_10_10_REV && _mesa_is_gles3(ctx)) {
1962 break; /* OK */
1963 }
1964 if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1965 _mesa_has_EXT_texture_type_2_10_10_10_REV(ctx)) {
1966 break; /* OK */
1967 }
1968 return GL_INVALID_OPERATION;
1969
1970 case GL_UNSIGNED_INT_24_8:
1971 /* Depth buffer OK to read in OpenGL ES (NV_read_depth). */
1972 if (_mesa_is_gles2(ctx) && format == GL_DEPTH_COMPONENT)
1973 return GL_NO_ERROR;
1974
1975 if (format != GL_DEPTH_STENCIL) {
1976 return GL_INVALID_OPERATION;
1977 }
1978 return GL_NO_ERROR;
1979
1980 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1981 if (format != GL_DEPTH_STENCIL) {
1982 return GL_INVALID_OPERATION;
1983 }
1984 return GL_NO_ERROR;
1985
1986 case GL_UNSIGNED_INT_10F_11F_11F_REV:
1987 if (format != GL_RGB) {
1988 return GL_INVALID_OPERATION;
1989 }
1990 return GL_NO_ERROR;
1991
1992 case GL_HALF_FLOAT_OES:
1993 switch (format) {
1994 case GL_RGBA:
1995 case GL_RGB:
1996 case GL_LUMINANCE_ALPHA:
1997 case GL_LUMINANCE:
1998 case GL_ALPHA:
1999 return GL_NO_ERROR;
2000 case GL_RG:
2001 case GL_RED:
2002 if (_mesa_has_EXT_texture_rg(ctx))
2003 return GL_NO_ERROR;
2004 FALLTHROUGH;
2005 default:
2006 return GL_INVALID_OPERATION;
2007 }
2008
2009 default:
2010 ; /* fall-through */
2011 }
2012
2013 /* now, for each format, check the type for compatibility */
2014 switch (format) {
2015 case GL_COLOR_INDEX:
2016 case GL_STENCIL_INDEX:
2017 switch (type) {
2018 case GL_BITMAP:
2019 case GL_BYTE:
2020 case GL_UNSIGNED_BYTE:
2021 case GL_SHORT:
2022 case GL_UNSIGNED_SHORT:
2023 case GL_INT:
2024 case GL_UNSIGNED_INT:
2025 case GL_FLOAT:
2026 case GL_HALF_FLOAT:
2027 return GL_NO_ERROR;
2028 default:
2029 return GL_INVALID_ENUM;
2030 }
2031
2032 case GL_RED:
2033 case GL_GREEN:
2034 case GL_BLUE:
2035 case GL_ALPHA:
2036 #if 0 /* not legal! see table 3.6 of the 1.5 spec */
2037 case GL_INTENSITY:
2038 #endif
2039 case GL_LUMINANCE:
2040 case GL_LUMINANCE_ALPHA:
2041 case GL_DEPTH_COMPONENT:
2042 switch (type) {
2043 case GL_BYTE:
2044 case GL_UNSIGNED_BYTE:
2045 case GL_SHORT:
2046 case GL_UNSIGNED_SHORT:
2047 case GL_INT:
2048 case GL_UNSIGNED_INT:
2049 case GL_FLOAT:
2050 case GL_HALF_FLOAT:
2051 return GL_NO_ERROR;
2052 default:
2053 return GL_INVALID_ENUM;
2054 }
2055
2056 case GL_RG:
2057 switch (type) {
2058 case GL_BYTE:
2059 case GL_UNSIGNED_BYTE:
2060 case GL_SHORT:
2061 case GL_UNSIGNED_SHORT:
2062 case GL_INT:
2063 case GL_UNSIGNED_INT:
2064 case GL_FLOAT:
2065 case GL_HALF_FLOAT:
2066 return GL_NO_ERROR;
2067 default:
2068 return GL_INVALID_ENUM;
2069 }
2070
2071 case GL_RGB:
2072 switch (type) {
2073 case GL_BYTE:
2074 case GL_UNSIGNED_BYTE:
2075 case GL_SHORT:
2076 case GL_UNSIGNED_SHORT:
2077 case GL_INT:
2078 case GL_UNSIGNED_INT:
2079 case GL_FLOAT:
2080 case GL_UNSIGNED_BYTE_3_3_2:
2081 case GL_UNSIGNED_BYTE_2_3_3_REV:
2082 case GL_UNSIGNED_SHORT_5_6_5:
2083 case GL_UNSIGNED_SHORT_5_6_5_REV:
2084 case GL_HALF_FLOAT:
2085 return GL_NO_ERROR;
2086 case GL_UNSIGNED_INT_2_10_10_10_REV:
2087 /* OK by GL_EXT_texture_type_2_10_10_10_REV */
2088 return _mesa_has_EXT_texture_type_2_10_10_10_REV(ctx)
2089 ? GL_NO_ERROR : GL_INVALID_ENUM;
2090 case GL_UNSIGNED_INT_5_9_9_9_REV:
2091 case GL_UNSIGNED_INT_10F_11F_11F_REV:
2092 return GL_NO_ERROR;
2093 default:
2094 return GL_INVALID_ENUM;
2095 }
2096
2097 case GL_BGR:
2098 switch (type) {
2099 /* NOTE: no packed types are supported with BGR. That's
2100 * intentional, according to the GL spec.
2101 */
2102 case GL_BYTE:
2103 case GL_UNSIGNED_BYTE:
2104 case GL_SHORT:
2105 case GL_UNSIGNED_SHORT:
2106 case GL_INT:
2107 case GL_UNSIGNED_INT:
2108 case GL_FLOAT:
2109 case GL_HALF_FLOAT:
2110 return GL_NO_ERROR;
2111 default:
2112 return GL_INVALID_ENUM;
2113 }
2114
2115 case GL_RGBA:
2116 case GL_BGRA:
2117 switch (type) {
2118 case GL_BYTE:
2119 case GL_UNSIGNED_BYTE:
2120 case GL_SHORT:
2121 case GL_UNSIGNED_SHORT:
2122 case GL_INT:
2123 case GL_UNSIGNED_INT:
2124 case GL_FLOAT:
2125 case GL_UNSIGNED_SHORT_4_4_4_4:
2126 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2127 case GL_UNSIGNED_SHORT_5_5_5_1:
2128 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2129 case GL_UNSIGNED_INT_8_8_8_8:
2130 case GL_UNSIGNED_INT_8_8_8_8_REV:
2131 case GL_UNSIGNED_INT_10_10_10_2:
2132 case GL_UNSIGNED_INT_2_10_10_10_REV:
2133 case GL_HALF_FLOAT:
2134 return GL_NO_ERROR;
2135 default:
2136 return GL_INVALID_ENUM;
2137 }
2138
2139 case GL_ABGR_EXT:
2140 switch (type) {
2141 case GL_BYTE:
2142 case GL_UNSIGNED_BYTE:
2143 case GL_SHORT:
2144 case GL_UNSIGNED_SHORT:
2145 case GL_INT:
2146 case GL_UNSIGNED_INT:
2147 case GL_FLOAT:
2148 case GL_UNSIGNED_SHORT_4_4_4_4:
2149 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2150 case GL_UNSIGNED_INT_8_8_8_8:
2151 case GL_UNSIGNED_INT_8_8_8_8_REV:
2152 case GL_HALF_FLOAT:
2153 return GL_NO_ERROR;
2154 default:
2155 return GL_INVALID_ENUM;
2156 }
2157
2158 case GL_YCBCR_MESA:
2159 if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
2160 type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
2161 return GL_NO_ERROR;
2162 else
2163 return GL_INVALID_OPERATION;
2164
2165 case GL_DEPTH_STENCIL:
2166 if (type == GL_UNSIGNED_INT_24_8 ||
2167 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
2168 return GL_NO_ERROR;
2169 else
2170 return GL_INVALID_ENUM;
2171
2172 /* integer-valued formats */
2173 case GL_RED_INTEGER:
2174 case GL_GREEN_INTEGER:
2175 case GL_BLUE_INTEGER:
2176 case GL_ALPHA_INTEGER:
2177 case GL_RG_INTEGER:
2178 switch (type) {
2179 case GL_BYTE:
2180 case GL_UNSIGNED_BYTE:
2181 case GL_SHORT:
2182 case GL_UNSIGNED_SHORT:
2183 case GL_INT:
2184 case GL_UNSIGNED_INT:
2185 return _mesa_has_integer_textures(ctx)
2186 ? GL_NO_ERROR : GL_INVALID_ENUM;
2187 default:
2188 return GL_INVALID_ENUM;
2189 }
2190
2191 case GL_RGB_INTEGER:
2192 switch (type) {
2193 case GL_BYTE:
2194 case GL_UNSIGNED_BYTE:
2195 case GL_SHORT:
2196 case GL_UNSIGNED_SHORT:
2197 case GL_INT:
2198 case GL_UNSIGNED_INT:
2199 return _mesa_has_integer_textures(ctx)
2200 ? GL_NO_ERROR : GL_INVALID_ENUM;
2201 case GL_UNSIGNED_BYTE_3_3_2:
2202 case GL_UNSIGNED_BYTE_2_3_3_REV:
2203 case GL_UNSIGNED_SHORT_5_6_5:
2204 case GL_UNSIGNED_SHORT_5_6_5_REV:
2205 return _mesa_has_ARB_texture_rgb10_a2ui(ctx)
2206 ? GL_NO_ERROR : GL_INVALID_ENUM;
2207 default:
2208 return GL_INVALID_ENUM;
2209 }
2210
2211 case GL_BGR_INTEGER:
2212 switch (type) {
2213 case GL_BYTE:
2214 case GL_UNSIGNED_BYTE:
2215 case GL_SHORT:
2216 case GL_UNSIGNED_SHORT:
2217 case GL_INT:
2218 case GL_UNSIGNED_INT:
2219 /* NOTE: no packed formats w/ BGR format */
2220 return _mesa_has_integer_textures(ctx)
2221 ? GL_NO_ERROR : GL_INVALID_ENUM;
2222 default:
2223 return GL_INVALID_ENUM;
2224 }
2225
2226 case GL_RGBA_INTEGER:
2227 case GL_BGRA_INTEGER:
2228 switch (type) {
2229 case GL_BYTE:
2230 case GL_UNSIGNED_BYTE:
2231 case GL_SHORT:
2232 case GL_UNSIGNED_SHORT:
2233 case GL_INT:
2234 case GL_UNSIGNED_INT:
2235 return _mesa_has_integer_textures(ctx)
2236 ? GL_NO_ERROR : GL_INVALID_ENUM;
2237 case GL_UNSIGNED_SHORT_4_4_4_4:
2238 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2239 case GL_UNSIGNED_SHORT_5_5_5_1:
2240 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2241 case GL_UNSIGNED_INT_8_8_8_8:
2242 case GL_UNSIGNED_INT_8_8_8_8_REV:
2243 case GL_UNSIGNED_INT_10_10_10_2:
2244 case GL_UNSIGNED_INT_2_10_10_10_REV:
2245 return _mesa_has_texture_rgb10_a2ui(ctx)
2246 ? GL_NO_ERROR : GL_INVALID_ENUM;
2247 default:
2248 return GL_INVALID_ENUM;
2249 }
2250
2251 case GL_LUMINANCE_INTEGER_EXT:
2252 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
2253 switch (type) {
2254 case GL_BYTE:
2255 case GL_UNSIGNED_BYTE:
2256 case GL_SHORT:
2257 case GL_UNSIGNED_SHORT:
2258 case GL_INT:
2259 case GL_UNSIGNED_INT:
2260 return _mesa_has_integer_textures(ctx)
2261 ? GL_NO_ERROR : GL_INVALID_ENUM;
2262 default:
2263 return GL_INVALID_ENUM;
2264 }
2265
2266 default:
2267 return GL_INVALID_ENUM;
2268 }
2269 return GL_NO_ERROR;
2270 }
2271
2272
2273 /**
2274 * Do error checking of format/type combinations for OpenGL ES glReadPixels
2275 * and glTex[Sub]Image.
2276 * \return error code, or GL_NO_ERROR.
2277 */
2278 GLenum
_mesa_es_error_check_format_and_type(const struct gl_context * ctx,GLenum format,GLenum type,unsigned dimensions)2279 _mesa_es_error_check_format_and_type(const struct gl_context *ctx,
2280 GLenum format, GLenum type,
2281 unsigned dimensions)
2282 {
2283 GLboolean type_valid = GL_TRUE;
2284
2285 switch (format) {
2286 case GL_RED:
2287 case GL_RG:
2288 if (!_mesa_has_rg_textures(ctx))
2289 return GL_INVALID_VALUE;
2290 FALLTHROUGH;
2291 case GL_ALPHA:
2292 case GL_LUMINANCE:
2293 case GL_LUMINANCE_ALPHA:
2294 type_valid = (type == GL_UNSIGNED_BYTE
2295 || type == GL_FLOAT
2296 || type == GL_HALF_FLOAT_OES);
2297 break;
2298
2299 case GL_RGB:
2300 type_valid = (type == GL_UNSIGNED_BYTE
2301 || type == GL_UNSIGNED_SHORT_5_6_5
2302 || type == GL_FLOAT
2303 || type == GL_HALF_FLOAT_OES);
2304 break;
2305
2306 case GL_RGBA:
2307 type_valid = (type == GL_UNSIGNED_BYTE
2308 || type == GL_UNSIGNED_SHORT_4_4_4_4
2309 || type == GL_UNSIGNED_SHORT_5_5_5_1
2310 || type == GL_FLOAT
2311 || type == GL_HALF_FLOAT_OES
2312 || (_mesa_has_texture_type_2_10_10_10_REV(ctx) &&
2313 type == GL_UNSIGNED_INT_2_10_10_10_REV));
2314 break;
2315
2316 case GL_DEPTH_COMPONENT:
2317 /* This format is filtered against invalid dimensionalities elsewhere.
2318 */
2319 type_valid = (type == GL_UNSIGNED_SHORT
2320 || type == GL_UNSIGNED_INT);
2321 break;
2322
2323 case GL_DEPTH_STENCIL:
2324 /* This format is filtered against invalid dimensionalities elsewhere.
2325 */
2326 type_valid = (type == GL_UNSIGNED_INT_24_8);
2327 break;
2328
2329 case GL_BGRA:
2330 type_valid = (type == GL_UNSIGNED_BYTE);
2331
2332 /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
2333 * the format does not appear to be allowed for 3D textures in OpenGL
2334 * ES.
2335 */
2336 if (dimensions != 2)
2337 return GL_INVALID_VALUE;
2338
2339 break;
2340
2341 default:
2342 return GL_INVALID_VALUE;
2343 }
2344
2345 return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2346 }
2347
2348 /**
2349 * Return the simple base format for a given internal texture format.
2350 * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA.
2351 *
2352 * \param ctx GL context.
2353 * \param internalFormat the internal texture format token or 1, 2, 3, or 4.
2354 *
2355 * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE,
2356 * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum.
2357 *
2358 * This is the format which is used during texture application (i.e. the
2359 * texture format and env mode determine the arithmetic used.
2360 */
2361 GLint
_mesa_base_tex_format(const struct gl_context * ctx,GLint internalFormat)2362 _mesa_base_tex_format(const struct gl_context *ctx, GLint internalFormat)
2363 {
2364 switch (internalFormat) {
2365 case GL_ALPHA:
2366 case GL_ALPHA4:
2367 case GL_ALPHA8:
2368 case GL_ALPHA12:
2369 case GL_ALPHA16:
2370 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2371 case 1:
2372 case GL_LUMINANCE:
2373 case GL_LUMINANCE4:
2374 case GL_LUMINANCE8:
2375 case GL_LUMINANCE12:
2376 case GL_LUMINANCE16:
2377 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2378 case 2:
2379 case GL_LUMINANCE_ALPHA:
2380 case GL_LUMINANCE4_ALPHA4:
2381 case GL_LUMINANCE6_ALPHA2:
2382 case GL_LUMINANCE8_ALPHA8:
2383 case GL_LUMINANCE12_ALPHA4:
2384 case GL_LUMINANCE12_ALPHA12:
2385 case GL_LUMINANCE16_ALPHA16:
2386 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2387 case GL_INTENSITY:
2388 case GL_INTENSITY4:
2389 case GL_INTENSITY8:
2390 case GL_INTENSITY12:
2391 case GL_INTENSITY16:
2392 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2393 case 3:
2394 return (ctx->API != API_OPENGL_CORE) ? GL_RGB : -1;
2395 case GL_RGB:
2396 case GL_R3_G3_B2:
2397 case GL_RGB4:
2398 case GL_RGB5:
2399 case GL_RGB8:
2400 case GL_RGB10:
2401 case GL_RGB12:
2402 case GL_RGB16:
2403 return GL_RGB;
2404 case 4:
2405 return (ctx->API != API_OPENGL_CORE) ? GL_RGBA : -1;
2406 case GL_RGBA:
2407 case GL_RGBA2:
2408 case GL_RGBA4:
2409 case GL_RGB5_A1:
2410 case GL_RGBA8:
2411 case GL_RGB10_A2:
2412 case GL_RGBA12:
2413 case GL_RGBA16:
2414 return GL_RGBA;
2415 case GL_BGRA:
2416 case GL_BGRA8_EXT:
2417 return GL_RGBA;
2418 default:
2419 ; /* fallthrough */
2420 }
2421
2422 if (_mesa_has_OES_framebuffer_object(ctx) ||
2423 _mesa_is_gles2_compatible(ctx)) {
2424 switch (internalFormat) {
2425 case GL_RGB565:
2426 return GL_RGB;
2427 default:
2428 ; /* fallthrough */
2429 }
2430 }
2431
2432 if (ctx->API != API_OPENGLES) {
2433 switch (internalFormat) {
2434 case GL_DEPTH_COMPONENT:
2435 case GL_DEPTH_COMPONENT16:
2436 case GL_DEPTH_COMPONENT24:
2437 case GL_DEPTH_COMPONENT32:
2438 return GL_DEPTH_COMPONENT;
2439 case GL_DEPTH_STENCIL:
2440 case GL_DEPTH24_STENCIL8:
2441 return GL_DEPTH_STENCIL;
2442 default:
2443 ; /* fallthrough */
2444 }
2445 }
2446
2447 if (_mesa_has_ARB_texture_stencil8(ctx) ||
2448 _mesa_has_OES_texture_stencil8(ctx)) {
2449 switch (internalFormat) {
2450 case GL_STENCIL_INDEX:
2451 case GL_STENCIL_INDEX1:
2452 case GL_STENCIL_INDEX4:
2453 case GL_STENCIL_INDEX8:
2454 case GL_STENCIL_INDEX16:
2455 return GL_STENCIL_INDEX;
2456 default:
2457 ; /* fallthrough */
2458 }
2459 }
2460
2461 switch (internalFormat) {
2462 case GL_COMPRESSED_ALPHA:
2463 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2464 case GL_COMPRESSED_LUMINANCE:
2465 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2466 case GL_COMPRESSED_LUMINANCE_ALPHA:
2467 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2468 case GL_COMPRESSED_INTENSITY:
2469 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2470 case GL_COMPRESSED_RGB:
2471 return GL_RGB;
2472 case GL_COMPRESSED_RGBA:
2473 return GL_RGBA;
2474 default:
2475 ; /* fallthrough */
2476 }
2477
2478 if (_mesa_is_compressed_format(ctx, internalFormat)) {
2479 GLenum base_compressed =
2480 _mesa_gl_compressed_format_base_format(internalFormat);
2481 if (base_compressed)
2482 return base_compressed;
2483 }
2484
2485 if ((_mesa_has_KHR_texture_compression_astc_ldr(ctx) &&
2486 is_astc_2d_format(internalFormat)) ||
2487 (_mesa_has_OES_texture_compression_astc(ctx) &&
2488 is_astc_3d_format(internalFormat)))
2489 return GL_RGBA;
2490
2491 if (_mesa_has_MESA_ycbcr_texture(ctx)) {
2492 if (internalFormat == GL_YCBCR_MESA)
2493 return GL_YCBCR_MESA;
2494 }
2495
2496 if (_mesa_has_half_float_textures(ctx)) {
2497 switch (internalFormat) {
2498 case GL_ALPHA16F_ARB:
2499 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2500 case GL_RGBA16F_ARB:
2501 return GL_RGBA;
2502 case GL_RGB16F_ARB:
2503 return GL_RGB;
2504 case GL_INTENSITY16F_ARB:
2505 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2506 case GL_LUMINANCE16F_ARB:
2507 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2508 case GL_LUMINANCE_ALPHA16F_ARB:
2509 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2510 }
2511 }
2512
2513 if (_mesa_has_float_textures(ctx)) {
2514 switch (internalFormat) {
2515 case GL_ALPHA32F_ARB:
2516 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2517 case GL_RGBA32F_ARB:
2518 return GL_RGBA;
2519 case GL_RGB32F_ARB:
2520 return GL_RGB;
2521 case GL_INTENSITY32F_ARB:
2522 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2523 case GL_LUMINANCE32F_ARB:
2524 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2525 case GL_LUMINANCE_ALPHA32F_ARB:
2526 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2527 }
2528 }
2529
2530 if (_mesa_has_EXT_texture_snorm(ctx) || _mesa_is_gles3(ctx)) {
2531 switch (internalFormat) {
2532 case GL_RED_SNORM:
2533 case GL_R8_SNORM:
2534 case GL_R16_SNORM:
2535 return GL_RED;
2536 case GL_RG_SNORM:
2537 case GL_RG8_SNORM:
2538 case GL_RG16_SNORM:
2539 return GL_RG;
2540 case GL_RGB_SNORM:
2541 case GL_RGB8_SNORM:
2542 case GL_RGB16_SNORM:
2543 return GL_RGB;
2544 case GL_RGBA_SNORM:
2545 case GL_RGBA8_SNORM:
2546 case GL_RGBA16_SNORM:
2547 return GL_RGBA;
2548 case GL_ALPHA_SNORM:
2549 case GL_ALPHA8_SNORM:
2550 case GL_ALPHA16_SNORM:
2551 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2552 case GL_LUMINANCE_SNORM:
2553 case GL_LUMINANCE8_SNORM:
2554 case GL_LUMINANCE16_SNORM:
2555 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2556 case GL_LUMINANCE_ALPHA_SNORM:
2557 case GL_LUMINANCE8_ALPHA8_SNORM:
2558 case GL_LUMINANCE16_ALPHA16_SNORM:
2559 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2560 case GL_INTENSITY_SNORM:
2561 case GL_INTENSITY8_SNORM:
2562 case GL_INTENSITY16_SNORM:
2563 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2564 default:
2565 ; /* fallthrough */
2566 }
2567 }
2568
2569 if (_mesa_has_EXT_texture_sRGB(ctx) || _mesa_is_gles3(ctx)) {
2570 switch (internalFormat) {
2571 case GL_SRGB:
2572 case GL_SRGB8:
2573 case GL_COMPRESSED_SRGB:
2574 return GL_RGB;
2575 case GL_SRGB_ALPHA:
2576 case GL_SRGB8_ALPHA8:
2577 case GL_COMPRESSED_SRGB_ALPHA:
2578 return GL_RGBA;
2579 case GL_SLUMINANCE_ALPHA:
2580 case GL_SLUMINANCE8_ALPHA8:
2581 case GL_COMPRESSED_SLUMINANCE_ALPHA:
2582 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2583 case GL_SLUMINANCE:
2584 case GL_SLUMINANCE8:
2585 case GL_COMPRESSED_SLUMINANCE:
2586 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2587 default:
2588 ; /* fallthrough */
2589 }
2590 }
2591
2592 if (_mesa_has_EXT_texture_sRGB_R8(ctx)) {
2593 switch (internalFormat) {
2594 case GL_SR8_EXT:
2595 return GL_RED;
2596 default:
2597 ; /* fallthrough */
2598 }
2599 }
2600
2601 if (_mesa_has_EXT_texture_sRGB_RG8(ctx)) {
2602 switch (internalFormat) {
2603 case GL_SRG8_EXT:
2604 return GL_RG;
2605 default:
2606 ; /* fallthrough */
2607 }
2608 }
2609
2610 if (_mesa_has_integer_textures(ctx)) {
2611 switch (internalFormat) {
2612 case GL_RGBA8UI:
2613 case GL_RGBA16UI:
2614 case GL_RGBA32UI:
2615 case GL_RGBA8I:
2616 case GL_RGBA16I:
2617 case GL_RGBA32I:
2618 return GL_RGBA;
2619 case GL_RGB8UI:
2620 case GL_RGB16UI:
2621 case GL_RGB32UI:
2622 case GL_RGB8I:
2623 case GL_RGB16I:
2624 case GL_RGB32I:
2625 return GL_RGB;
2626 }
2627 }
2628
2629 if (_mesa_has_texture_rgb10_a2ui(ctx)) {
2630 switch (internalFormat) {
2631 case GL_RGB10_A2UI:
2632 return GL_RGBA;
2633 }
2634 }
2635
2636 if (_mesa_has_integer_textures(ctx)) {
2637 switch (internalFormat) {
2638 case GL_ALPHA8UI_EXT:
2639 case GL_ALPHA16UI_EXT:
2640 case GL_ALPHA32UI_EXT:
2641 case GL_ALPHA8I_EXT:
2642 case GL_ALPHA16I_EXT:
2643 case GL_ALPHA32I_EXT:
2644 return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1;
2645 case GL_INTENSITY8UI_EXT:
2646 case GL_INTENSITY16UI_EXT:
2647 case GL_INTENSITY32UI_EXT:
2648 case GL_INTENSITY8I_EXT:
2649 case GL_INTENSITY16I_EXT:
2650 case GL_INTENSITY32I_EXT:
2651 return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1;
2652 case GL_LUMINANCE8UI_EXT:
2653 case GL_LUMINANCE16UI_EXT:
2654 case GL_LUMINANCE32UI_EXT:
2655 case GL_LUMINANCE8I_EXT:
2656 case GL_LUMINANCE16I_EXT:
2657 case GL_LUMINANCE32I_EXT:
2658 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1;
2659 case GL_LUMINANCE_ALPHA8UI_EXT:
2660 case GL_LUMINANCE_ALPHA16UI_EXT:
2661 case GL_LUMINANCE_ALPHA32UI_EXT:
2662 case GL_LUMINANCE_ALPHA8I_EXT:
2663 case GL_LUMINANCE_ALPHA16I_EXT:
2664 case GL_LUMINANCE_ALPHA32I_EXT:
2665 return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1;
2666 default:
2667 ; /* fallthrough */
2668 }
2669 }
2670
2671 if (_mesa_has_rg_textures(ctx)) {
2672 switch (internalFormat) {
2673 case GL_R16F:
2674 if (!_mesa_has_half_float_textures(ctx))
2675 break;
2676 return GL_RED;
2677 case GL_R32F:
2678 if (!_mesa_has_float_textures(ctx))
2679 break;
2680 return GL_RED;
2681 case GL_R8I:
2682 case GL_R8UI:
2683 case GL_R16I:
2684 case GL_R16UI:
2685 case GL_R32I:
2686 case GL_R32UI:
2687 if (!_mesa_has_integer_textures(ctx))
2688 break;
2689 FALLTHROUGH;
2690 case GL_R8:
2691 case GL_R16:
2692 case GL_RED:
2693 case GL_COMPRESSED_RED:
2694 return GL_RED;
2695
2696 case GL_RG16F:
2697 if (!_mesa_has_half_float_textures(ctx))
2698 break;
2699 return GL_RG;
2700 case GL_RG32F:
2701 if (!_mesa_has_float_textures(ctx))
2702 break;
2703 return GL_RG;
2704 case GL_RG8I:
2705 case GL_RG8UI:
2706 case GL_RG16I:
2707 case GL_RG16UI:
2708 case GL_RG32I:
2709 case GL_RG32UI:
2710 if (!_mesa_has_integer_textures(ctx))
2711 break;
2712 FALLTHROUGH;
2713 case GL_RG:
2714 case GL_RG8:
2715 case GL_RG16:
2716 case GL_COMPRESSED_RG:
2717 return GL_RG;
2718 default:
2719 ; /* fallthrough */
2720 }
2721 }
2722
2723 if (_mesa_has_texture_shared_exponent(ctx)) {
2724 switch (internalFormat) {
2725 case GL_RGB9_E5:
2726 return GL_RGB;
2727 default:
2728 ; /* fallthrough */
2729 }
2730 }
2731
2732 if (_mesa_has_packed_float(ctx)) {
2733 switch (internalFormat) {
2734 case GL_R11F_G11F_B10F:
2735 return GL_RGB;
2736 default:
2737 ; /* fallthrough */
2738 }
2739 }
2740
2741 if (_mesa_has_float_depth_buffer(ctx)) {
2742 switch (internalFormat) {
2743 case GL_DEPTH_COMPONENT32F:
2744 return GL_DEPTH_COMPONENT;
2745 case GL_DEPTH32F_STENCIL8:
2746 return GL_DEPTH_STENCIL;
2747 default:
2748 ; /* fallthrough */
2749 }
2750 }
2751
2752 return -1; /* error */
2753 }
2754
2755 /**
2756 * Returns the effective internal format from a texture format and type.
2757 * This is used by texture image operations internally for validation, when
2758 * the specified internal format is a base (unsized) format.
2759 *
2760 * This method will only return a valid effective internal format if the
2761 * combination of format, type and internal format in base form, is acceptable.
2762 *
2763 * If a single sized internal format is defined in the spec (OpenGL-ES 3.0.4) or
2764 * in extensions, to unambiguously correspond to the given base format, then
2765 * that internal format is returned as the effective. Otherwise, if the
2766 * combination is accepted but a single effective format is not defined, the
2767 * passed base format will be returned instead.
2768 *
2769 * \param format the texture format
2770 * \param type the texture type
2771 */
2772 static GLenum
gles_effective_internal_format_for_format_and_type(GLenum format,GLenum type)2773 gles_effective_internal_format_for_format_and_type(GLenum format,
2774 GLenum type)
2775 {
2776 switch (type) {
2777 case GL_UNSIGNED_BYTE:
2778 switch (format) {
2779 case GL_RGBA:
2780 return GL_RGBA8;
2781 case GL_RGB:
2782 return GL_RGB8;
2783 case GL_RG:
2784 return GL_RG8;
2785 case GL_RED:
2786 return GL_R8;
2787 /* Although LUMINANCE_ALPHA, LUMINANCE and ALPHA appear in table 3.12,
2788 * (section 3.8 Texturing, page 128 of the OpenGL-ES 3.0.4) as effective
2789 * internal formats, they do not correspond to GL constants, so the base
2790 * format is returned instead.
2791 */
2792 case GL_BGRA:
2793 case GL_LUMINANCE_ALPHA:
2794 case GL_LUMINANCE:
2795 case GL_ALPHA:
2796 return format;
2797 }
2798 break;
2799
2800 case GL_UNSIGNED_SHORT_4_4_4_4:
2801 if (format == GL_RGBA)
2802 return GL_RGBA4;
2803 break;
2804
2805 case GL_UNSIGNED_SHORT_5_5_5_1:
2806 if (format == GL_RGBA)
2807 return GL_RGB5_A1;
2808 break;
2809
2810 case GL_UNSIGNED_SHORT_5_6_5:
2811 if (format == GL_RGB)
2812 return GL_RGB565;
2813 break;
2814
2815 /* OES_packed_depth_stencil */
2816 case GL_UNSIGNED_INT_24_8:
2817 if (format == GL_DEPTH_STENCIL)
2818 return GL_DEPTH24_STENCIL8;
2819 break;
2820
2821 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2822 if (format == GL_DEPTH_STENCIL)
2823 return GL_DEPTH32F_STENCIL8;
2824 break;
2825
2826 case GL_UNSIGNED_SHORT:
2827 if (format == GL_DEPTH_COMPONENT)
2828 return GL_DEPTH_COMPONENT16;
2829 break;
2830
2831 case GL_UNSIGNED_INT:
2832 /* It can be DEPTH_COMPONENT16 or DEPTH_COMPONENT24, so just return
2833 * the format.
2834 */
2835 if (format == GL_DEPTH_COMPONENT)
2836 return format;
2837 break;
2838
2839 /* OES_texture_float and OES_texture_half_float */
2840 case GL_FLOAT:
2841 if (format == GL_DEPTH_COMPONENT)
2842 return GL_DEPTH_COMPONENT32F;
2843 FALLTHROUGH;
2844 case GL_HALF_FLOAT_OES:
2845 switch (format) {
2846 case GL_RGBA:
2847 case GL_RGB:
2848 case GL_LUMINANCE_ALPHA:
2849 case GL_LUMINANCE:
2850 case GL_ALPHA:
2851 case GL_RED:
2852 case GL_RG:
2853 return format;
2854 }
2855 break;
2856 case GL_HALF_FLOAT:
2857 switch (format) {
2858 case GL_RG:
2859 case GL_RED:
2860 return format;
2861 }
2862 break;
2863
2864 /* GL_EXT_texture_type_2_10_10_10_REV */
2865 case GL_UNSIGNED_INT_2_10_10_10_REV:
2866 switch (format) {
2867 case GL_RGBA:
2868 case GL_RGB:
2869 return format;
2870 }
2871 break;
2872
2873 default:
2874 /* fall through and return NONE */
2875 break;
2876 }
2877
2878 return GL_NONE;
2879 }
2880
2881 /**
2882 * Error checking if internalformat for glTex[Sub]Image is valid
2883 * within OpenGL ES 3.2 (or introduced by an ES extension).
2884 *
2885 * Note, further checks in _mesa_gles_error_check_format_and_type
2886 * are required for complete checking between format and type.
2887 */
2888 static GLenum
_mesa_gles_check_internalformat(struct gl_context * ctx,GLenum internalFormat)2889 _mesa_gles_check_internalformat(struct gl_context *ctx,
2890 GLenum internalFormat)
2891 {
2892 switch (internalFormat) {
2893 /* OpenGL ES 2.0 */
2894 case GL_ALPHA:
2895 case GL_LUMINANCE:
2896 case GL_LUMINANCE_ALPHA:
2897 case GL_RGB:
2898 case GL_RGBA:
2899
2900 /* GL_OES_depth_texture */
2901 case GL_DEPTH_COMPONENT:
2902
2903 /* GL_EXT_texture_format_BGRA8888 */
2904 case GL_BGRA:
2905 case GL_BGRA8_EXT:
2906
2907 /* GL_OES_required_internalformat */
2908 case GL_RGB565:
2909 case GL_RGB8:
2910 case GL_RGBA4:
2911 case GL_RGB5_A1:
2912 case GL_RGBA8:
2913 case GL_DEPTH_COMPONENT16:
2914 case GL_DEPTH_COMPONENT24:
2915 case GL_DEPTH_COMPONENT32:
2916 case GL_DEPTH24_STENCIL8:
2917 case GL_RGB10:
2918 case GL_RGB10_A2:
2919 case GL_ALPHA8:
2920 case GL_LUMINANCE8:
2921 case GL_LUMINANCE8_ALPHA8:
2922 case GL_LUMINANCE4_ALPHA4:
2923 return GL_NO_ERROR;
2924
2925 case GL_R8:
2926 case GL_RG8:
2927 case GL_RED:
2928 case GL_RG:
2929 if (!_mesa_has_rg_textures(ctx))
2930 return GL_INVALID_VALUE;
2931 return GL_NO_ERROR;
2932
2933 /* GL_OES_texture_stencil8 */
2934 case GL_STENCIL_INDEX8:
2935 if (!_mesa_has_OES_texture_stencil8(ctx))
2936 return GL_INVALID_VALUE;
2937 return GL_NO_ERROR;
2938
2939 case GL_COMPRESSED_RGBA_BPTC_UNORM:
2940 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
2941 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
2942 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
2943 if (!_mesa_has_EXT_texture_compression_bptc(ctx))
2944 return GL_INVALID_VALUE;
2945 return GL_NO_ERROR;
2946
2947 case GL_COMPRESSED_RED_RGTC1:
2948 case GL_COMPRESSED_SIGNED_RED_RGTC1:
2949 case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
2950 case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
2951 if (!_mesa_has_EXT_texture_compression_rgtc(ctx))
2952 return GL_INVALID_VALUE;
2953 return GL_NO_ERROR;
2954
2955 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
2956 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
2957 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
2958 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
2959 if (!_mesa_has_EXT_texture_compression_s3tc(ctx))
2960 return GL_INVALID_VALUE;
2961 return GL_NO_ERROR;
2962
2963 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
2964 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
2965 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
2966 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
2967 if (!_mesa_has_EXT_texture_compression_s3tc_srgb(ctx))
2968 return GL_INVALID_VALUE;
2969 return GL_NO_ERROR;
2970
2971 case GL_R16:
2972 case GL_RG16:
2973 case GL_RGB16:
2974 case GL_RGBA16:
2975 if (!_mesa_has_EXT_texture_norm16(ctx))
2976 return GL_INVALID_VALUE;
2977 return GL_NO_ERROR;
2978
2979 case GL_R16_SNORM:
2980 case GL_RG16_SNORM:
2981 case GL_RGB16_SNORM:
2982 case GL_RGBA16_SNORM:
2983 if (!_mesa_has_EXT_texture_norm16(ctx) &&
2984 !_mesa_has_EXT_texture_snorm(ctx))
2985 return GL_INVALID_VALUE;
2986 return GL_NO_ERROR;
2987
2988 case GL_SR8_EXT:
2989 if (!_mesa_has_EXT_texture_sRGB_R8(ctx))
2990 return GL_INVALID_VALUE;
2991 return GL_NO_ERROR;
2992
2993 case GL_SRG8_EXT:
2994 if (!_mesa_has_EXT_texture_sRGB_RG8(ctx))
2995 return GL_INVALID_VALUE;
2996 return GL_NO_ERROR;
2997
2998 /* OpenGL ES 3.0 */
2999 case GL_SRGB8_ALPHA8:
3000 case GL_RGBA8_SNORM:
3001 case GL_RGBA16F:
3002 case GL_RGBA32F:
3003 case GL_RGBA8UI:
3004 case GL_RGBA8I:
3005 case GL_RGBA16UI:
3006 case GL_RGBA16I:
3007 case GL_RGBA32UI:
3008 case GL_RGBA32I:
3009 case GL_RGB10_A2UI:
3010 case GL_SRGB8:
3011 case GL_RGB8_SNORM:
3012 case GL_R11F_G11F_B10F:
3013 case GL_RGB9_E5:
3014 case GL_RGB16F:
3015 case GL_RGB32F:
3016 case GL_RGB8UI:
3017 case GL_RGB8I:
3018 case GL_RGB16UI:
3019 case GL_RGB16I:
3020 case GL_RGB32UI:
3021 case GL_RGB32I:
3022 case GL_RG8_SNORM:
3023 case GL_RG16F:
3024 case GL_RG32F:
3025 case GL_RG8UI:
3026 case GL_RG8I:
3027 case GL_RG16UI:
3028 case GL_RG16I:
3029 case GL_RG32UI:
3030 case GL_RG32I:
3031 case GL_R8_SNORM:
3032 case GL_R16F:
3033 case GL_R32F:
3034 case GL_R8UI:
3035 case GL_R8I:
3036 case GL_R16UI:
3037 case GL_R16I:
3038 case GL_R32UI:
3039 case GL_R32I:
3040 case GL_DEPTH_COMPONENT32F:
3041 case GL_DEPTH32F_STENCIL8:
3042 if (!_mesa_is_gles3(ctx))
3043 return GL_INVALID_VALUE;
3044 return GL_NO_ERROR;
3045
3046 default:
3047 return GL_INVALID_VALUE;
3048 }
3049 }
3050
3051 /**
3052 * Do error checking of format/type combinations for OpenGL ES 3
3053 * glTex[Sub]Image, or ES1/ES2 with GL_OES_required_internalformat.
3054 * \return error code, or GL_NO_ERROR.
3055 */
3056 GLenum
_mesa_gles_error_check_format_and_type(struct gl_context * ctx,GLenum format,GLenum type,GLenum internalFormat)3057 _mesa_gles_error_check_format_and_type(struct gl_context *ctx,
3058 GLenum format, GLenum type,
3059 GLenum internalFormat)
3060 {
3061 /* If internalFormat is an unsized format, then the effective internal
3062 * format derived from format and type should be used instead. Page 127,
3063 * section "3.8 Texturing" of the GLES 3.0.4 spec states:
3064 *
3065 * "if internalformat is a base internal format, the effective
3066 * internal format is a sized internal format that is derived
3067 * from the format and type for internal use by the GL.
3068 * Table 3.12 specifies the mapping of format and type to effective
3069 * internal formats. The effective internal format is used by the GL
3070 * for purposes such as texture completeness or type checks for
3071 * CopyTex* commands. In these cases, the GL is required to operate
3072 * as if the effective internal format was used as the internalformat
3073 * when specifying the texture data."
3074 */
3075 if (_mesa_is_enum_format_unsized(internalFormat)) {
3076 GLenum effectiveInternalFormat =
3077 gles_effective_internal_format_for_format_and_type(format, type);
3078
3079 if (effectiveInternalFormat == GL_NONE)
3080 return GL_INVALID_OPERATION;
3081
3082 GLenum baseInternalFormat;
3083 if (internalFormat == GL_BGRA) {
3084 /* Unfortunately, _mesa_base_tex_format returns a base format of
3085 * GL_RGBA for GL_BGRA. This makes perfect sense if you're
3086 * asking the question, "what channels does this format have?"
3087 * However, if we're trying to determine if two internal formats
3088 * match in the ES3 sense, we actually want GL_BGRA.
3089 */
3090 baseInternalFormat = GL_BGRA;
3091 } else {
3092 baseInternalFormat =
3093 _mesa_base_tex_format(ctx, effectiveInternalFormat);
3094 }
3095
3096 if (internalFormat != baseInternalFormat)
3097 return GL_INVALID_OPERATION;
3098
3099 internalFormat = effectiveInternalFormat;
3100 }
3101
3102 /* The GLES variant of EXT_texture_compression_s3tc is very vague and
3103 * doesn't list valid types. Just do exactly what the spec says.
3104 */
3105 if (internalFormat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
3106 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
3107 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
3108 internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
3109 return format == GL_RGB || format == GL_RGBA ? GL_NO_ERROR :
3110 GL_INVALID_OPERATION;
3111
3112 /* Before checking for the combination, verify that
3113 * given internalformat is legal for OpenGL ES.
3114 */
3115 GLenum internal_format_error =
3116 _mesa_gles_check_internalformat(ctx, internalFormat);
3117
3118 if (internal_format_error != GL_NO_ERROR)
3119 return internal_format_error;
3120
3121 switch (format) {
3122 case GL_BGRA:
3123 if (type != GL_UNSIGNED_BYTE ||
3124 (internalFormat != GL_BGRA &&
3125 internalFormat != GL_RGBA8 &&
3126 internalFormat != GL_BGRA8_EXT &&
3127 internalFormat != GL_SRGB8_ALPHA8))
3128 return GL_INVALID_OPERATION;
3129 break;
3130
3131 case GL_BGR:
3132 if (type != GL_UNSIGNED_BYTE ||
3133 (internalFormat != GL_RGB8 &&
3134 internalFormat != GL_SRGB8))
3135 return GL_INVALID_OPERATION;
3136 break;
3137
3138 case GL_RGBA:
3139 switch (type) {
3140 case GL_UNSIGNED_BYTE:
3141 switch (internalFormat) {
3142 case GL_RGBA:
3143 case GL_RGBA8:
3144 case GL_RGB5_A1:
3145 case GL_RGBA4:
3146 break;
3147 case GL_SRGB8_ALPHA8:
3148 if (ctx->Version <= 20)
3149 return GL_INVALID_OPERATION;
3150 break;
3151 case GL_COMPRESSED_RGBA_BPTC_UNORM:
3152 case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
3153 break;
3154 default:
3155 return GL_INVALID_OPERATION;
3156 }
3157 break;
3158
3159 case GL_BYTE:
3160 if (ctx->Version <= 20 || internalFormat != GL_RGBA8_SNORM)
3161 return GL_INVALID_OPERATION;
3162 break;
3163
3164 case GL_UNSIGNED_SHORT:
3165 if (internalFormat != GL_RGBA16)
3166 return GL_INVALID_OPERATION;
3167 break;
3168
3169 case GL_SHORT:
3170 if (internalFormat != GL_RGBA16_SNORM)
3171 return GL_INVALID_OPERATION;
3172 break;
3173
3174 case GL_UNSIGNED_SHORT_4_4_4_4:
3175 switch (internalFormat) {
3176 case GL_RGBA:
3177 case GL_RGBA4:
3178 break;
3179 default:
3180 return GL_INVALID_OPERATION;
3181 }
3182 break;
3183
3184 case GL_UNSIGNED_SHORT_5_5_5_1:
3185 switch (internalFormat) {
3186 case GL_RGBA:
3187 case GL_RGB5_A1:
3188 break;
3189 default:
3190 return GL_INVALID_OPERATION;
3191 }
3192 break;
3193
3194 case GL_UNSIGNED_INT_2_10_10_10_REV:
3195 switch (internalFormat) {
3196 case GL_RGBA:
3197 case GL_RGB10_A2:
3198 case GL_RGB5_A1:
3199 if (!_mesa_has_texture_type_2_10_10_10_REV(ctx))
3200 return GL_INVALID_OPERATION;
3201 break;
3202 default:
3203 return GL_INVALID_OPERATION;
3204 }
3205 break;
3206
3207 case GL_HALF_FLOAT:
3208 if (ctx->Version <= 20 || internalFormat != GL_RGBA16F)
3209 return GL_INVALID_OPERATION;
3210 break;
3211
3212 case GL_FLOAT:
3213 switch (internalFormat) {
3214 case GL_RGBA16F:
3215 case GL_RGBA32F:
3216 if (ctx->Version <= 20)
3217 return GL_INVALID_OPERATION;
3218 break;
3219 case GL_RGBA:
3220 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3221 return GL_INVALID_OPERATION;
3222 break;
3223 default:
3224 return GL_INVALID_OPERATION;
3225 }
3226 break;
3227
3228 case GL_HALF_FLOAT_OES:
3229 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3230 return GL_INVALID_OPERATION;
3231 break;
3232 default:
3233 return GL_INVALID_OPERATION;
3234 }
3235 break;
3236
3237 case GL_RGBA_INTEGER:
3238 if (ctx->Version <= 20)
3239 return GL_INVALID_OPERATION;
3240 switch (type) {
3241 case GL_UNSIGNED_BYTE:
3242 if (internalFormat != GL_RGBA8UI)
3243 return GL_INVALID_OPERATION;
3244 break;
3245
3246 case GL_BYTE:
3247 if (internalFormat != GL_RGBA8I)
3248 return GL_INVALID_OPERATION;
3249 break;
3250
3251 case GL_UNSIGNED_SHORT:
3252 if (internalFormat != GL_RGBA16UI)
3253 return GL_INVALID_OPERATION;
3254 break;
3255
3256 case GL_SHORT:
3257 if (internalFormat != GL_RGBA16I)
3258 return GL_INVALID_OPERATION;
3259 break;
3260
3261 case GL_UNSIGNED_INT:
3262 if (internalFormat != GL_RGBA32UI)
3263 return GL_INVALID_OPERATION;
3264 break;
3265
3266 case GL_INT:
3267 if (internalFormat != GL_RGBA32I)
3268 return GL_INVALID_OPERATION;
3269 break;
3270
3271 case GL_UNSIGNED_INT_2_10_10_10_REV:
3272 if (internalFormat != GL_RGB10_A2UI)
3273 return GL_INVALID_OPERATION;
3274 break;
3275
3276 default:
3277 return GL_INVALID_OPERATION;
3278 }
3279 break;
3280
3281 case GL_RGB:
3282 switch (type) {
3283 case GL_UNSIGNED_BYTE:
3284 switch (internalFormat) {
3285 case GL_RGB:
3286 case GL_RGB8:
3287 case GL_RGB565:
3288 break;
3289 case GL_SRGB8:
3290 if (ctx->Version <= 20)
3291 return GL_INVALID_OPERATION;
3292 break;
3293 default:
3294 return GL_INVALID_OPERATION;
3295 }
3296 break;
3297
3298 case GL_BYTE:
3299 if (ctx->Version <= 20 || internalFormat != GL_RGB8_SNORM)
3300 return GL_INVALID_OPERATION;
3301 break;
3302
3303 case GL_UNSIGNED_SHORT:
3304 if (internalFormat != GL_RGB16)
3305 return GL_INVALID_OPERATION;
3306 break;
3307
3308 case GL_SHORT:
3309 if (internalFormat != GL_RGB16_SNORM)
3310 return GL_INVALID_OPERATION;
3311 break;
3312
3313 case GL_UNSIGNED_SHORT_5_6_5:
3314 switch (internalFormat) {
3315 case GL_RGB:
3316 case GL_RGB565:
3317 break;
3318 default:
3319 return GL_INVALID_OPERATION;
3320 }
3321 break;
3322
3323 case GL_UNSIGNED_INT_10F_11F_11F_REV:
3324 if (ctx->Version <= 20 || internalFormat != GL_R11F_G11F_B10F)
3325 return GL_INVALID_OPERATION;
3326 break;
3327
3328 case GL_UNSIGNED_INT_5_9_9_9_REV:
3329 if (internalFormat != GL_RGB9_E5)
3330 return GL_INVALID_OPERATION;
3331 break;
3332
3333 case GL_HALF_FLOAT:
3334 if (ctx->Version <= 20)
3335 return GL_INVALID_OPERATION;
3336 switch (internalFormat) {
3337 case GL_RGB16F:
3338 case GL_R11F_G11F_B10F:
3339 case GL_RGB9_E5:
3340 break;
3341 default:
3342 return GL_INVALID_OPERATION;
3343 }
3344 break;
3345
3346 case GL_FLOAT:
3347 switch (internalFormat) {
3348 case GL_RGB16F:
3349 case GL_RGB32F:
3350 case GL_R11F_G11F_B10F:
3351 case GL_RGB9_E5:
3352 if (ctx->Version <= 20)
3353 return GL_INVALID_OPERATION;
3354 break;
3355 case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
3356 case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
3357 break;
3358 case GL_RGB:
3359 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3360 return GL_INVALID_OPERATION;
3361 break;
3362 default:
3363 return GL_INVALID_OPERATION;
3364 }
3365 break;
3366
3367 case GL_HALF_FLOAT_OES:
3368 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3369 return GL_INVALID_OPERATION;
3370 break;
3371
3372 case GL_UNSIGNED_INT_2_10_10_10_REV:
3373 switch (internalFormat) {
3374 case GL_RGB:
3375 case GL_RGB10:
3376 case GL_RGB8:
3377 case GL_RGB565:
3378 /* GL_EXT_texture_type_2_10_10_10_REV allows GL_RGB even though
3379 * GLES3 doesn't, and GL_OES_required_internalformat extends that
3380 * to allow the sized RGB internalformats as well.
3381 */
3382 if (!_mesa_has_texture_type_2_10_10_10_REV(ctx))
3383 return GL_INVALID_OPERATION;
3384 break;
3385 default:
3386 return GL_INVALID_OPERATION;
3387 }
3388 break;
3389
3390 default:
3391 return GL_INVALID_OPERATION;
3392 }
3393 break;
3394
3395 case GL_RGB_INTEGER:
3396 if (ctx->Version <= 20)
3397 return GL_INVALID_OPERATION;
3398 switch (type) {
3399 case GL_UNSIGNED_BYTE:
3400 if (internalFormat != GL_RGB8UI)
3401 return GL_INVALID_OPERATION;
3402 break;
3403
3404 case GL_BYTE:
3405 if (internalFormat != GL_RGB8I)
3406 return GL_INVALID_OPERATION;
3407 break;
3408
3409 case GL_UNSIGNED_SHORT:
3410 if (internalFormat != GL_RGB16UI)
3411 return GL_INVALID_OPERATION;
3412 break;
3413
3414 case GL_SHORT:
3415 if (internalFormat != GL_RGB16I)
3416 return GL_INVALID_OPERATION;
3417 break;
3418
3419 case GL_UNSIGNED_INT:
3420 if (internalFormat != GL_RGB32UI)
3421 return GL_INVALID_OPERATION;
3422 break;
3423
3424 case GL_INT:
3425 if (internalFormat != GL_RGB32I)
3426 return GL_INVALID_OPERATION;
3427 break;
3428
3429 default:
3430 return GL_INVALID_OPERATION;
3431 }
3432 break;
3433
3434 case GL_RG:
3435 if (!_mesa_has_rg_textures(ctx))
3436 return GL_INVALID_OPERATION;
3437 switch (type) {
3438 case GL_UNSIGNED_BYTE:
3439 if (internalFormat != GL_RG8 &&
3440 internalFormat != GL_COMPRESSED_RED_GREEN_RGTC2_EXT &&
3441 internalFormat != GL_SRG8_EXT)
3442 return GL_INVALID_OPERATION;
3443 break;
3444
3445 case GL_BYTE:
3446 if (internalFormat != GL_RG8_SNORM &&
3447 internalFormat != GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT)
3448 return GL_INVALID_OPERATION;
3449 break;
3450
3451 case GL_UNSIGNED_SHORT:
3452 if (internalFormat != GL_RG16)
3453 return GL_INVALID_OPERATION;
3454 break;
3455
3456 case GL_SHORT:
3457 if (internalFormat != GL_RG16_SNORM)
3458 return GL_INVALID_OPERATION;
3459 break;
3460
3461 case GL_HALF_FLOAT:
3462 case GL_HALF_FLOAT_OES:
3463 switch (internalFormat) {
3464 case GL_RG16F:
3465 if (ctx->Version <= 20)
3466 return GL_INVALID_OPERATION;
3467 break;
3468 case GL_RG:
3469 if (!_mesa_has_OES_texture_half_float(ctx))
3470 return GL_INVALID_OPERATION;
3471 break;
3472 default:
3473 return GL_INVALID_OPERATION;
3474 }
3475 break;
3476
3477 case GL_FLOAT:
3478 switch (internalFormat) {
3479 case GL_RG16F:
3480 case GL_RG32F:
3481 break;
3482 case GL_RG:
3483 if (!_mesa_has_OES_texture_float(ctx))
3484 return GL_INVALID_OPERATION;
3485 break;
3486 default:
3487 return GL_INVALID_OPERATION;
3488 }
3489 break;
3490
3491 default:
3492 return GL_INVALID_OPERATION;
3493 }
3494 break;
3495
3496 case GL_RG_INTEGER:
3497 if (ctx->Version <= 20)
3498 return GL_INVALID_OPERATION;
3499 switch (type) {
3500 case GL_UNSIGNED_BYTE:
3501 if (internalFormat != GL_RG8UI)
3502 return GL_INVALID_OPERATION;
3503 break;
3504
3505 case GL_BYTE:
3506 if (internalFormat != GL_RG8I)
3507 return GL_INVALID_OPERATION;
3508 break;
3509
3510 case GL_UNSIGNED_SHORT:
3511 if (internalFormat != GL_RG16UI)
3512 return GL_INVALID_OPERATION;
3513 break;
3514
3515 case GL_SHORT:
3516 if (internalFormat != GL_RG16I)
3517 return GL_INVALID_OPERATION;
3518 break;
3519
3520 case GL_UNSIGNED_INT:
3521 if (internalFormat != GL_RG32UI)
3522 return GL_INVALID_OPERATION;
3523 break;
3524
3525 case GL_INT:
3526 if (internalFormat != GL_RG32I)
3527 return GL_INVALID_OPERATION;
3528 break;
3529
3530 default:
3531 return GL_INVALID_OPERATION;
3532 }
3533 break;
3534
3535 case GL_RED:
3536 if (!_mesa_has_rg_textures(ctx))
3537 return GL_INVALID_OPERATION;
3538 switch (type) {
3539 case GL_UNSIGNED_BYTE:
3540 if (internalFormat != GL_R8 &&
3541 internalFormat != GL_SR8_EXT &&
3542 internalFormat != GL_COMPRESSED_RED_RGTC1_EXT) {
3543 return GL_INVALID_OPERATION;
3544 }
3545 break;
3546
3547 case GL_BYTE:
3548 if (internalFormat != GL_R8_SNORM &&
3549 internalFormat != GL_COMPRESSED_SIGNED_RED_RGTC1_EXT)
3550 return GL_INVALID_OPERATION;
3551 break;
3552
3553 case GL_UNSIGNED_SHORT:
3554 if (internalFormat != GL_R16)
3555 return GL_INVALID_OPERATION;
3556 break;
3557
3558 case GL_SHORT:
3559 if (internalFormat != GL_R16_SNORM)
3560 return GL_INVALID_OPERATION;
3561 break;
3562
3563 case GL_HALF_FLOAT:
3564 case GL_HALF_FLOAT_OES:
3565 switch (internalFormat) {
3566 case GL_R16F:
3567 if (ctx->Version <= 20)
3568 return GL_INVALID_OPERATION;
3569 break;
3570 case GL_RG:
3571 case GL_RED:
3572 if (!_mesa_has_OES_texture_half_float(ctx))
3573 return GL_INVALID_OPERATION;
3574 break;
3575 default:
3576 return GL_INVALID_OPERATION;
3577 }
3578 break;
3579
3580 case GL_FLOAT:
3581 switch (internalFormat) {
3582 case GL_R16F:
3583 case GL_R32F:
3584 break;
3585 case GL_RED:
3586 if (!_mesa_has_OES_texture_float(ctx))
3587 return GL_INVALID_OPERATION;
3588 break;
3589 default:
3590 return GL_INVALID_OPERATION;
3591 }
3592 break;
3593
3594 default:
3595 return GL_INVALID_OPERATION;
3596 }
3597 break;
3598
3599 case GL_RED_INTEGER:
3600 if (ctx->Version <= 20)
3601 return GL_INVALID_OPERATION;
3602 switch (type) {
3603 case GL_UNSIGNED_BYTE:
3604 if (internalFormat != GL_R8UI)
3605 return GL_INVALID_OPERATION;
3606 break;
3607
3608 case GL_BYTE:
3609 if (internalFormat != GL_R8I)
3610 return GL_INVALID_OPERATION;
3611 break;
3612
3613 case GL_UNSIGNED_SHORT:
3614 if (internalFormat != GL_R16UI)
3615 return GL_INVALID_OPERATION;
3616 break;
3617
3618 case GL_SHORT:
3619 if (internalFormat != GL_R16I)
3620 return GL_INVALID_OPERATION;
3621 break;
3622
3623 case GL_UNSIGNED_INT:
3624 if (internalFormat != GL_R32UI)
3625 return GL_INVALID_OPERATION;
3626 break;
3627
3628 case GL_INT:
3629 if (internalFormat != GL_R32I)
3630 return GL_INVALID_OPERATION;
3631 break;
3632
3633 default:
3634 return GL_INVALID_OPERATION;
3635 }
3636 break;
3637
3638 case GL_DEPTH_COMPONENT:
3639 switch (type) {
3640 case GL_UNSIGNED_SHORT:
3641 if (internalFormat != GL_DEPTH_COMPONENT &&
3642 internalFormat != GL_DEPTH_COMPONENT16)
3643 return GL_INVALID_OPERATION;
3644 break;
3645
3646 case GL_UNSIGNED_INT:
3647 switch (internalFormat) {
3648 case GL_DEPTH_COMPONENT:
3649 case GL_DEPTH_COMPONENT16:
3650 case GL_DEPTH_COMPONENT24:
3651 break;
3652 default:
3653 return GL_INVALID_OPERATION;
3654 }
3655 break;
3656
3657 case GL_FLOAT:
3658 if (ctx->Version <= 20 || internalFormat != GL_DEPTH_COMPONENT32F)
3659 return GL_INVALID_OPERATION;
3660 break;
3661
3662 default:
3663 return GL_INVALID_OPERATION;
3664 }
3665 break;
3666
3667 case GL_DEPTH_STENCIL:
3668 switch (type) {
3669 case GL_UNSIGNED_INT_24_8:
3670 if (internalFormat != GL_DEPTH_STENCIL &&
3671 internalFormat != GL_DEPTH24_STENCIL8)
3672 return GL_INVALID_OPERATION;
3673 break;
3674
3675 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
3676 if (ctx->Version <= 20 || internalFormat != GL_DEPTH32F_STENCIL8)
3677 return GL_INVALID_OPERATION;
3678 break;
3679
3680 default:
3681 return GL_INVALID_OPERATION;
3682 }
3683 break;
3684
3685 case GL_STENCIL_INDEX:
3686 if (type != GL_UNSIGNED_BYTE ||
3687 internalFormat != GL_STENCIL_INDEX8) {
3688 return GL_INVALID_OPERATION;
3689 }
3690 break;
3691
3692 case GL_ALPHA:
3693 case GL_LUMINANCE:
3694 case GL_LUMINANCE_ALPHA:
3695 switch (type) {
3696 case GL_FLOAT:
3697 if (!_mesa_has_OES_texture_float(ctx) || internalFormat != format)
3698 return GL_INVALID_OPERATION;
3699 break;
3700 case GL_HALF_FLOAT_OES:
3701 if (!_mesa_has_OES_texture_half_float(ctx) || internalFormat != format)
3702 return GL_INVALID_OPERATION;
3703 break;
3704 case GL_UNSIGNED_BYTE:
3705 if (!(format == internalFormat ||
3706 (format == GL_ALPHA && internalFormat == GL_ALPHA8) ||
3707 (format == GL_LUMINANCE && internalFormat == GL_LUMINANCE8) ||
3708 (format == GL_LUMINANCE_ALPHA &&
3709 ((internalFormat == GL_LUMINANCE8_ALPHA8) ||
3710 (internalFormat == GL_LUMINANCE4_ALPHA4))))) {
3711 return GL_INVALID_OPERATION;
3712 }
3713 break;
3714 default:
3715 return GL_INVALID_OPERATION;
3716 }
3717 break;
3718 }
3719
3720 return GL_NO_ERROR;
3721 }
3722
3723 static void
set_swizzle(uint8_t * swizzle,int x,int y,int z,int w)3724 set_swizzle(uint8_t *swizzle, int x, int y, int z, int w)
3725 {
3726 swizzle[MESA_FORMAT_SWIZZLE_X] = x;
3727 swizzle[MESA_FORMAT_SWIZZLE_Y] = y;
3728 swizzle[MESA_FORMAT_SWIZZLE_Z] = z;
3729 swizzle[MESA_FORMAT_SWIZZLE_W] = w;
3730 }
3731
3732 static bool
get_swizzle_from_gl_format(GLenum format,uint8_t * swizzle)3733 get_swizzle_from_gl_format(GLenum format, uint8_t *swizzle)
3734 {
3735 switch (format) {
3736 case GL_RGBA:
3737 case GL_RGBA_INTEGER:
3738 set_swizzle(swizzle, 0, 1, 2, 3);
3739 return true;
3740 case GL_BGRA:
3741 case GL_BGRA_INTEGER:
3742 set_swizzle(swizzle, 2, 1, 0, 3);
3743 return true;
3744 case GL_ABGR_EXT:
3745 set_swizzle(swizzle, 3, 2, 1, 0);
3746 return true;
3747 case GL_RGB:
3748 case GL_RGB_INTEGER:
3749 set_swizzle(swizzle, 0, 1, 2, 5);
3750 return true;
3751 case GL_BGR:
3752 case GL_BGR_INTEGER:
3753 set_swizzle(swizzle, 2, 1, 0, 5);
3754 return true;
3755 case GL_LUMINANCE_ALPHA:
3756 case GL_LUMINANCE_ALPHA_INTEGER_EXT:
3757 set_swizzle(swizzle, 0, 0, 0, 1);
3758 return true;
3759 case GL_RG:
3760 case GL_RG_INTEGER:
3761 set_swizzle(swizzle, 0, 1, 4, 5);
3762 return true;
3763 case GL_RED:
3764 case GL_RED_INTEGER:
3765 set_swizzle(swizzle, 0, 4, 4, 5);
3766 return true;
3767 case GL_GREEN:
3768 case GL_GREEN_INTEGER:
3769 set_swizzle(swizzle, 4, 0, 4, 5);
3770 return true;
3771 case GL_BLUE:
3772 case GL_BLUE_INTEGER:
3773 set_swizzle(swizzle, 4, 4, 0, 5);
3774 return true;
3775 case GL_ALPHA:
3776 case GL_ALPHA_INTEGER:
3777 set_swizzle(swizzle, 4, 4, 4, 0);
3778 return true;
3779 case GL_LUMINANCE:
3780 case GL_LUMINANCE_INTEGER_EXT:
3781 set_swizzle(swizzle, 0, 0, 0, 5);
3782 return true;
3783 case GL_INTENSITY:
3784 set_swizzle(swizzle, 0, 0, 0, 0);
3785 return true;
3786 case GL_DEPTH_COMPONENT:
3787 set_swizzle(swizzle, 0, 6, 6, 6);
3788 return true;
3789 case GL_STENCIL_INDEX:
3790 set_swizzle(swizzle, 6, 0, 6, 6);
3791 return true;
3792 default:
3793 return false;
3794 }
3795 }
3796
3797 bool
_mesa_swap_bytes_in_type_enum(GLenum * type)3798 _mesa_swap_bytes_in_type_enum(GLenum *type)
3799 {
3800 switch (*type) {
3801 case GL_UNSIGNED_INT_8_8_8_8:
3802 *type = GL_UNSIGNED_INT_8_8_8_8_REV;
3803 return true;
3804 case GL_UNSIGNED_INT_8_8_8_8_REV:
3805 *type = GL_UNSIGNED_INT_8_8_8_8;
3806 return true;
3807 case GL_UNSIGNED_SHORT_8_8_MESA:
3808 *type = GL_UNSIGNED_SHORT_8_8_REV_MESA;
3809 return true;
3810 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
3811 *type = GL_UNSIGNED_SHORT_8_8_MESA;
3812 return true;
3813 case GL_BYTE:
3814 case GL_UNSIGNED_BYTE:
3815 /* format/types that are arrays of 8-bit values are unaffected by
3816 * swapBytes.
3817 */
3818 return true;
3819 default:
3820 /* swapping bytes on 4444, 1555, or >8 bit per channel types etc. will
3821 * never match a Mesa format.
3822 */
3823 return false;
3824 }
3825 }
3826
3827 /**
3828 * Take an OpenGL format (GL_RGB, GL_RGBA, etc), OpenGL data type (GL_INT,
3829 * GL_FOAT, etc) and return a matching mesa_array_format or a mesa_format
3830 * otherwise (for non-array formats).
3831 *
3832 * This function will typically be used to compute a mesa format from a GL type
3833 * so we can then call _mesa_format_convert. This function does
3834 * not consider byte swapping, so it returns types assuming that no byte
3835 * swapping is involved. If byte swapping is involved then clients are supposed
3836 * to handle that on their side before calling _mesa_format_convert.
3837 *
3838 * This function returns an uint32_t that can pack a mesa_format or a
3839 * mesa_array_format. Clients must check the mesa array format bit
3840 * (MESA_ARRAY_FORMAT_BIT) on the return value to know if the returned
3841 * format is a mesa_array_format or a mesa_format.
3842 */
3843 uint32_t
_mesa_format_from_format_and_type(GLenum format,GLenum type)3844 _mesa_format_from_format_and_type(GLenum format, GLenum type)
3845 {
3846 bool is_array_format = true;
3847 uint8_t swizzle[4];
3848 bool normalized = false, is_float = false, is_signed = false;
3849 int num_channels = 0, type_size = 0;
3850
3851 if (format == GL_COLOR_INDEX)
3852 return MESA_FORMAT_NONE;
3853
3854 /* Extract array format type information from the OpenGL data type */
3855 switch (type) {
3856 case GL_UNSIGNED_BYTE:
3857 type_size = 1;
3858 break;
3859 case GL_BYTE:
3860 type_size = 1;
3861 is_signed = true;
3862 break;
3863 case GL_UNSIGNED_SHORT:
3864 type_size = 2;
3865 break;
3866 case GL_SHORT:
3867 type_size = 2;
3868 is_signed = true;
3869 break;
3870 case GL_UNSIGNED_INT:
3871 type_size = 4;
3872 break;
3873 case GL_INT:
3874 type_size = 4;
3875 is_signed = true;
3876 break;
3877 case GL_HALF_FLOAT:
3878 case GL_HALF_FLOAT_OES:
3879 type_size = 2;
3880 is_signed = true;
3881 is_float = true;
3882 break;
3883 case GL_FLOAT:
3884 type_size = 4;
3885 is_signed = true;
3886 is_float = true;
3887 break;
3888 default:
3889 is_array_format = false;
3890 break;
3891 }
3892
3893 /* Extract array format swizzle information from the OpenGL format */
3894 if (is_array_format)
3895 is_array_format = get_swizzle_from_gl_format(format, swizzle);
3896
3897 /* If this is an array format type after checking data type and format,
3898 * create the array format
3899 */
3900 if (is_array_format) {
3901 enum mesa_array_format_base_format bf;
3902 switch (format) {
3903 case GL_DEPTH_COMPONENT:
3904 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_DEPTH;
3905 break;
3906 case GL_STENCIL_INDEX:
3907 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_STENCIL;
3908 break;
3909 default:
3910 bf = MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS;
3911 break;
3912 }
3913
3914 normalized = !(_mesa_is_enum_format_integer(format) ||
3915 format == GL_STENCIL_INDEX);
3916 num_channels = _mesa_components_in_format(format);
3917
3918 return MESA_ARRAY_FORMAT(bf, type_size, is_signed, is_float,
3919 normalized, num_channels,
3920 swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
3921 }
3922
3923 /* Otherwise this is not an array format, so return the mesa_format
3924 * matching the OpenGL format and data type
3925 */
3926 switch (type) {
3927 case GL_UNSIGNED_SHORT_5_6_5:
3928 if (format == GL_RGB)
3929 return MESA_FORMAT_B5G6R5_UNORM;
3930 else if (format == GL_BGR)
3931 return MESA_FORMAT_R5G6B5_UNORM;
3932 else if (format == GL_RGB_INTEGER)
3933 return MESA_FORMAT_B5G6R5_UINT;
3934 break;
3935 case GL_UNSIGNED_SHORT_5_6_5_REV:
3936 if (format == GL_RGB)
3937 return MESA_FORMAT_R5G6B5_UNORM;
3938 else if (format == GL_BGR)
3939 return MESA_FORMAT_B5G6R5_UNORM;
3940 else if (format == GL_RGB_INTEGER)
3941 return MESA_FORMAT_R5G6B5_UINT;
3942 break;
3943 case GL_UNSIGNED_SHORT_4_4_4_4:
3944 if (format == GL_RGBA)
3945 return MESA_FORMAT_A4B4G4R4_UNORM;
3946 else if (format == GL_BGRA)
3947 return MESA_FORMAT_A4R4G4B4_UNORM;
3948 else if (format == GL_ABGR_EXT)
3949 return MESA_FORMAT_R4G4B4A4_UNORM;
3950 else if (format == GL_RGBA_INTEGER)
3951 return MESA_FORMAT_A4B4G4R4_UINT;
3952 else if (format == GL_BGRA_INTEGER)
3953 return MESA_FORMAT_A4R4G4B4_UINT;
3954 break;
3955 case GL_UNSIGNED_SHORT_4_4_4_4_REV:
3956 if (format == GL_RGBA)
3957 return MESA_FORMAT_R4G4B4A4_UNORM;
3958 else if (format == GL_BGRA)
3959 return MESA_FORMAT_B4G4R4A4_UNORM;
3960 else if (format == GL_ABGR_EXT)
3961 return MESA_FORMAT_A4B4G4R4_UNORM;
3962 else if (format == GL_RGBA_INTEGER)
3963 return MESA_FORMAT_R4G4B4A4_UINT;
3964 else if (format == GL_BGRA_INTEGER)
3965 return MESA_FORMAT_B4G4R4A4_UINT;
3966 break;
3967 case GL_UNSIGNED_SHORT_5_5_5_1:
3968 if (format == GL_RGBA)
3969 return MESA_FORMAT_A1B5G5R5_UNORM;
3970 else if (format == GL_BGRA)
3971 return MESA_FORMAT_A1R5G5B5_UNORM;
3972 else if (format == GL_RGBA_INTEGER)
3973 return MESA_FORMAT_A1B5G5R5_UINT;
3974 else if (format == GL_BGRA_INTEGER)
3975 return MESA_FORMAT_A1R5G5B5_UINT;
3976 break;
3977 case GL_UNSIGNED_SHORT_1_5_5_5_REV:
3978 if (format == GL_RGBA)
3979 return MESA_FORMAT_R5G5B5A1_UNORM;
3980 else if (format == GL_BGRA)
3981 return MESA_FORMAT_B5G5R5A1_UNORM;
3982 else if (format == GL_RGBA_INTEGER)
3983 return MESA_FORMAT_R5G5B5A1_UINT;
3984 else if (format == GL_BGRA_INTEGER)
3985 return MESA_FORMAT_B5G5R5A1_UINT;
3986 break;
3987 case GL_UNSIGNED_BYTE_3_3_2:
3988 if (format == GL_RGB)
3989 return MESA_FORMAT_B2G3R3_UNORM;
3990 else if (format == GL_RGB_INTEGER)
3991 return MESA_FORMAT_B2G3R3_UINT;
3992 break;
3993 case GL_UNSIGNED_BYTE_2_3_3_REV:
3994 if (format == GL_RGB)
3995 return MESA_FORMAT_R3G3B2_UNORM;
3996 else if (format == GL_RGB_INTEGER)
3997 return MESA_FORMAT_R3G3B2_UINT;
3998 break;
3999 case GL_UNSIGNED_INT_5_9_9_9_REV:
4000 if (format == GL_RGB)
4001 return MESA_FORMAT_R9G9B9E5_FLOAT;
4002 break;
4003 case GL_UNSIGNED_INT_10_10_10_2:
4004 if (format == GL_RGBA)
4005 return MESA_FORMAT_A2B10G10R10_UNORM;
4006 else if (format == GL_RGBA_INTEGER)
4007 return MESA_FORMAT_A2B10G10R10_UINT;
4008 else if (format == GL_BGRA)
4009 return MESA_FORMAT_A2R10G10B10_UNORM;
4010 else if (format == GL_BGRA_INTEGER)
4011 return MESA_FORMAT_A2R10G10B10_UINT;
4012 break;
4013 case GL_UNSIGNED_INT_2_10_10_10_REV:
4014 if (format == GL_RGB)
4015 return MESA_FORMAT_R10G10B10X2_UNORM;
4016 if (format == GL_RGBA)
4017 return MESA_FORMAT_R10G10B10A2_UNORM;
4018 else if (format == GL_RGBA_INTEGER)
4019 return MESA_FORMAT_R10G10B10A2_UINT;
4020 else if (format == GL_BGRA)
4021 return MESA_FORMAT_B10G10R10A2_UNORM;
4022 else if (format == GL_BGRA_INTEGER)
4023 return MESA_FORMAT_B10G10R10A2_UINT;
4024 break;
4025 case GL_UNSIGNED_INT_8_8_8_8:
4026 if (format == GL_RGBA)
4027 return MESA_FORMAT_A8B8G8R8_UNORM;
4028 else if (format == GL_BGRA)
4029 return MESA_FORMAT_A8R8G8B8_UNORM;
4030 else if (format == GL_ABGR_EXT)
4031 return MESA_FORMAT_R8G8B8A8_UNORM;
4032 else if (format == GL_RGBA_INTEGER)
4033 return MESA_FORMAT_A8B8G8R8_UINT;
4034 else if (format == GL_BGRA_INTEGER)
4035 return MESA_FORMAT_A8R8G8B8_UINT;
4036 break;
4037 case GL_UNSIGNED_INT_8_8_8_8_REV:
4038 if (format == GL_RGBA)
4039 return MESA_FORMAT_R8G8B8A8_UNORM;
4040 else if (format == GL_BGRA)
4041 return MESA_FORMAT_B8G8R8A8_UNORM;
4042 else if (format == GL_ABGR_EXT)
4043 return MESA_FORMAT_A8B8G8R8_UNORM;
4044 else if (format == GL_RGBA_INTEGER)
4045 return MESA_FORMAT_R8G8B8A8_UINT;
4046 else if (format == GL_BGRA_INTEGER)
4047 return MESA_FORMAT_B8G8R8A8_UINT;
4048 break;
4049 case GL_UNSIGNED_SHORT_8_8_MESA:
4050 if (format == GL_YCBCR_MESA)
4051 return MESA_FORMAT_YCBCR;
4052 break;
4053 case GL_UNSIGNED_SHORT_8_8_REV_MESA:
4054 if (format == GL_YCBCR_MESA)
4055 return MESA_FORMAT_YCBCR_REV;
4056 break;
4057 case GL_UNSIGNED_INT_10F_11F_11F_REV:
4058 if (format == GL_RGB)
4059 return MESA_FORMAT_R11G11B10_FLOAT;
4060 break;
4061 case GL_FLOAT:
4062 if (format == GL_DEPTH_COMPONENT)
4063 return MESA_FORMAT_Z_FLOAT32;
4064 break;
4065 case GL_UNSIGNED_INT:
4066 if (format == GL_DEPTH_COMPONENT)
4067 return MESA_FORMAT_Z_UNORM32;
4068 break;
4069 case GL_UNSIGNED_SHORT:
4070 if (format == GL_DEPTH_COMPONENT)
4071 return MESA_FORMAT_Z_UNORM16;
4072 break;
4073 case GL_UNSIGNED_INT_24_8:
4074 if (format == GL_DEPTH_STENCIL)
4075 return MESA_FORMAT_S8_UINT_Z24_UNORM;
4076 else if (format == GL_DEPTH_COMPONENT)
4077 return MESA_FORMAT_X8_UINT_Z24_UNORM;
4078 break;
4079 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
4080 if (format == GL_DEPTH_STENCIL)
4081 return MESA_FORMAT_Z32_FLOAT_S8X24_UINT;
4082 break;
4083 default:
4084 break;
4085 }
4086
4087 fprintf(stderr, "Unsupported format/type: %s/%s\n",
4088 _mesa_enum_to_string(format),
4089 _mesa_enum_to_string(type));
4090
4091 /* If we got here it means that we could not find a Mesa format that
4092 * matches the GL format/type provided. We may need to add a new Mesa
4093 * format in that case.
4094 */
4095 unreachable("Unsupported format");
4096 }
4097
4098 uint32_t
_mesa_tex_format_from_format_and_type(const struct gl_context * ctx,GLenum gl_format,GLenum type)4099 _mesa_tex_format_from_format_and_type(const struct gl_context *ctx,
4100 GLenum gl_format, GLenum type)
4101 {
4102 mesa_format format = _mesa_format_from_format_and_type(gl_format, type);
4103
4104 if (_mesa_format_is_mesa_array_format(format))
4105 format = _mesa_format_from_array_format(format);
4106
4107 if (format == MESA_FORMAT_NONE || !ctx->TextureFormatSupported[format])
4108 return MESA_FORMAT_NONE;
4109
4110 return format;
4111 }
4112
4113 /**
4114 * Returns true if \p internal_format is a sized internal format that
4115 * is marked "Color Renderable" in Table 8.10 of the ES 3.2 specification.
4116 */
4117 bool
_mesa_is_es3_color_renderable(const struct gl_context * ctx,GLenum internal_format)4118 _mesa_is_es3_color_renderable(const struct gl_context *ctx,
4119 GLenum internal_format)
4120 {
4121 switch (internal_format) {
4122 case GL_R8:
4123 case GL_RG8:
4124 case GL_RGB8:
4125 case GL_RGB565:
4126 case GL_RGBA4:
4127 case GL_RGB5_A1:
4128 case GL_RGBA8:
4129 case GL_RGB10_A2:
4130 case GL_RGB10_A2UI:
4131 case GL_SRGB8_ALPHA8:
4132 case GL_R11F_G11F_B10F:
4133 case GL_R8I:
4134 case GL_R8UI:
4135 case GL_R16I:
4136 case GL_R16UI:
4137 case GL_R32I:
4138 case GL_R32UI:
4139 case GL_RG8I:
4140 case GL_RG8UI:
4141 case GL_RG16I:
4142 case GL_RG16UI:
4143 case GL_RG32I:
4144 case GL_RG32UI:
4145 case GL_RGBA8I:
4146 case GL_RGBA8UI:
4147 case GL_RGBA16I:
4148 case GL_RGBA16UI:
4149 case GL_RGBA32I:
4150 case GL_RGBA32UI:
4151 return true;
4152 case GL_R16F:
4153 case GL_RG16F:
4154 case GL_RGB16F:
4155 case GL_RGBA16F:
4156 return _mesa_has_EXT_color_buffer_half_float(ctx);
4157 case GL_R32F:
4158 case GL_RG32F:
4159 case GL_RGBA32F:
4160 return _mesa_has_EXT_color_buffer_float(ctx);
4161 case GL_R16:
4162 case GL_RG16:
4163 case GL_RGBA16:
4164 return _mesa_has_EXT_texture_norm16(ctx);
4165 case GL_R8_SNORM:
4166 case GL_RG8_SNORM:
4167 case GL_RGBA8_SNORM:
4168 return _mesa_has_EXT_render_snorm(ctx);
4169 case GL_R16_SNORM:
4170 case GL_RG16_SNORM:
4171 case GL_RGBA16_SNORM:
4172 return _mesa_has_EXT_texture_norm16(ctx) &&
4173 _mesa_has_EXT_render_snorm(ctx);
4174 case GL_BGRA:
4175 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx));
4176 return true;
4177 case GL_BGRA8_EXT:
4178 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx) &&
4179 _mesa_has_EXT_texture_storage(ctx));
4180 return true;
4181 default:
4182 return false;
4183 }
4184 }
4185
4186 /**
4187 * Returns true if \p internal_format is a sized internal format that
4188 * is marked "Texture Filterable" in Table 8.10 of the ES 3.2 specification.
4189 */
4190 bool
_mesa_is_es3_texture_filterable(const struct gl_context * ctx,GLenum internal_format)4191 _mesa_is_es3_texture_filterable(const struct gl_context *ctx,
4192 GLenum internal_format)
4193 {
4194 switch (internal_format) {
4195 case GL_R8:
4196 case GL_R8_SNORM:
4197 case GL_RG8:
4198 case GL_RG8_SNORM:
4199 case GL_RGB8:
4200 case GL_RGB8_SNORM:
4201 case GL_RGB565:
4202 case GL_RGBA4:
4203 case GL_RGB5_A1:
4204 case GL_RGBA8:
4205 case GL_RGBA8_SNORM:
4206 case GL_RGB10_A2:
4207 case GL_SRGB8:
4208 case GL_SRGB8_ALPHA8:
4209 case GL_R16F:
4210 case GL_RG16F:
4211 case GL_RGB16F:
4212 case GL_RGBA16F:
4213 case GL_R11F_G11F_B10F:
4214 case GL_RGB9_E5:
4215 return true;
4216 case GL_R16:
4217 case GL_R16_SNORM:
4218 case GL_RG16:
4219 case GL_RG16_SNORM:
4220 case GL_RGB16:
4221 case GL_RGB16_SNORM:
4222 case GL_RGBA16:
4223 case GL_RGBA16_SNORM:
4224 return _mesa_has_EXT_texture_norm16(ctx);
4225 case GL_R32F:
4226 case GL_RG32F:
4227 case GL_RGB32F:
4228 case GL_RGBA32F:
4229 /* The OES_texture_float_linear spec says:
4230 *
4231 * "When implemented against OpenGL ES 3.0 or later versions, sized
4232 * 32-bit floating-point formats become texture-filterable. This
4233 * should be noted by, for example, checking the ``TF'' column of
4234 * table 8.13 in the ES 3.1 Specification (``Correspondence of sized
4235 * internal formats to base internal formats ... and use cases ...'')
4236 * for the R32F, RG32F, RGB32F, and RGBA32F formats."
4237 */
4238 return _mesa_has_OES_texture_float_linear(ctx);
4239 case GL_BGRA:
4240 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx));
4241 return true;
4242 case GL_BGRA8_EXT:
4243 assert(_mesa_has_EXT_texture_format_BGRA8888(ctx) &&
4244 _mesa_has_EXT_texture_storage(ctx));
4245 return true;
4246 default:
4247 return false;
4248 }
4249 }
4250