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