glformats.c revision fa14f8afa05eda26f45e4162878e387e4713e488 
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
31
32/**
33 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise.
34 */
35GLboolean
36_mesa_type_is_packed(GLenum type)
37{
38   switch (type) {
39   case GL_UNSIGNED_BYTE_3_3_2:
40   case GL_UNSIGNED_BYTE_2_3_3_REV:
41   case MESA_UNSIGNED_BYTE_4_4:
42   case GL_UNSIGNED_SHORT_5_6_5:
43   case GL_UNSIGNED_SHORT_5_6_5_REV:
44   case GL_UNSIGNED_SHORT_4_4_4_4:
45   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
46   case GL_UNSIGNED_SHORT_5_5_5_1:
47   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
48   case GL_UNSIGNED_INT_8_8_8_8:
49   case GL_UNSIGNED_INT_8_8_8_8_REV:
50   case GL_UNSIGNED_INT_10_10_10_2:
51   case GL_UNSIGNED_INT_2_10_10_10_REV:
52   case GL_UNSIGNED_SHORT_8_8_MESA:
53   case GL_UNSIGNED_SHORT_8_8_REV_MESA:
54   case GL_UNSIGNED_INT_24_8_EXT:
55   case GL_UNSIGNED_INT_5_9_9_9_REV:
56   case GL_UNSIGNED_INT_10F_11F_11F_REV:
57   case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
58      return GL_TRUE;
59   }
60
61   return GL_FALSE;
62}
63
64
65/**
66 * Get the size of a GL data type.
67 *
68 * \param type GL data type.
69 *
70 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1
71 * if an invalid type enum.
72 */
73GLint
74_mesa_sizeof_type(GLenum type)
75{
76   switch (type) {
77   case GL_BITMAP:
78      return 0;
79   case GL_UNSIGNED_BYTE:
80      return sizeof(GLubyte);
81   case GL_BYTE:
82      return sizeof(GLbyte);
83   case GL_UNSIGNED_SHORT:
84      return sizeof(GLushort);
85   case GL_SHORT:
86      return sizeof(GLshort);
87   case GL_UNSIGNED_INT:
88      return sizeof(GLuint);
89   case GL_INT:
90      return sizeof(GLint);
91   case GL_FLOAT:
92      return sizeof(GLfloat);
93   case GL_DOUBLE:
94      return sizeof(GLdouble);
95   case GL_HALF_FLOAT_ARB:
96      return sizeof(GLhalfARB);
97   case GL_FIXED:
98      return sizeof(GLfixed);
99   default:
100      return -1;
101   }
102}
103
104
105/**
106 * Same as _mesa_sizeof_type() but also accepting the packed pixel
107 * format data types.
108 */
109GLint
110_mesa_sizeof_packed_type(GLenum type)
111{
112   switch (type) {
113   case GL_BITMAP:
114      return 0;
115   case GL_UNSIGNED_BYTE:
116      return sizeof(GLubyte);
117   case GL_BYTE:
118      return sizeof(GLbyte);
119   case GL_UNSIGNED_SHORT:
120      return sizeof(GLushort);
121   case GL_SHORT:
122      return sizeof(GLshort);
123   case GL_UNSIGNED_INT:
124      return sizeof(GLuint);
125   case GL_INT:
126      return sizeof(GLint);
127   case GL_HALF_FLOAT_ARB:
128      return sizeof(GLhalfARB);
129   case GL_FLOAT:
130      return sizeof(GLfloat);
131   case GL_UNSIGNED_BYTE_3_3_2:
132   case GL_UNSIGNED_BYTE_2_3_3_REV:
133   case MESA_UNSIGNED_BYTE_4_4:
134      return sizeof(GLubyte);
135   case GL_UNSIGNED_SHORT_5_6_5:
136   case GL_UNSIGNED_SHORT_5_6_5_REV:
137   case GL_UNSIGNED_SHORT_4_4_4_4:
138   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
139   case GL_UNSIGNED_SHORT_5_5_5_1:
140   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
141   case GL_UNSIGNED_SHORT_8_8_MESA:
142   case GL_UNSIGNED_SHORT_8_8_REV_MESA:
143      return sizeof(GLushort);
144   case GL_UNSIGNED_INT_8_8_8_8:
145   case GL_UNSIGNED_INT_8_8_8_8_REV:
146   case GL_UNSIGNED_INT_10_10_10_2:
147   case GL_UNSIGNED_INT_2_10_10_10_REV:
148   case GL_UNSIGNED_INT_24_8_EXT:
149   case GL_UNSIGNED_INT_5_9_9_9_REV:
150   case GL_UNSIGNED_INT_10F_11F_11F_REV:
151      return sizeof(GLuint);
152   case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
153      return 8;
154   default:
155      return -1;
156   }
157}
158
159
160/**
161 * Get the number of components in a pixel format.
162 *
163 * \param format pixel format.
164 *
165 * \return the number of components in the given format, or -1 if a bad format.
166 */
167GLint
168_mesa_components_in_format(GLenum format)
169{
170   switch (format) {
171   case GL_COLOR_INDEX:
172   case GL_STENCIL_INDEX:
173   case GL_DEPTH_COMPONENT:
174   case GL_RED:
175   case GL_RED_INTEGER_EXT:
176   case GL_GREEN:
177   case GL_GREEN_INTEGER_EXT:
178   case GL_BLUE:
179   case GL_BLUE_INTEGER_EXT:
180   case GL_ALPHA:
181   case GL_ALPHA_INTEGER_EXT:
182   case GL_LUMINANCE:
183   case GL_LUMINANCE_INTEGER_EXT:
184   case GL_INTENSITY:
185      return 1;
186
187   case GL_LUMINANCE_ALPHA:
188   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
189   case GL_RG:
190   case GL_YCBCR_MESA:
191   case GL_DEPTH_STENCIL_EXT:
192   case GL_DUDV_ATI:
193   case GL_DU8DV8_ATI:
194   case GL_RG_INTEGER:
195      return 2;
196
197   case GL_RGB:
198   case GL_BGR:
199   case GL_RGB_INTEGER_EXT:
200   case GL_BGR_INTEGER_EXT:
201      return 3;
202
203   case GL_RGBA:
204   case GL_BGRA:
205   case GL_ABGR_EXT:
206   case GL_RGBA_INTEGER_EXT:
207   case GL_BGRA_INTEGER_EXT:
208      return 4;
209
210   default:
211      return -1;
212   }
213}
214
215
216/**
217 * Get the bytes per pixel of pixel format type pair.
218 *
219 * \param format pixel format.
220 * \param type pixel type.
221 *
222 * \return bytes per pixel, or -1 if a bad format or type was given.
223 */
224GLint
225_mesa_bytes_per_pixel(GLenum format, GLenum type)
226{
227   GLint comps = _mesa_components_in_format(format);
228   if (comps < 0)
229      return -1;
230
231   switch (type) {
232   case GL_BITMAP:
233      return 0;  /* special case */
234   case GL_BYTE:
235   case GL_UNSIGNED_BYTE:
236      return comps * sizeof(GLubyte);
237   case GL_SHORT:
238   case GL_UNSIGNED_SHORT:
239      return comps * sizeof(GLshort);
240   case GL_INT:
241   case GL_UNSIGNED_INT:
242      return comps * sizeof(GLint);
243   case GL_FLOAT:
244      return comps * sizeof(GLfloat);
245   case GL_HALF_FLOAT_ARB:
246      return comps * sizeof(GLhalfARB);
247   case GL_UNSIGNED_BYTE_3_3_2:
248   case GL_UNSIGNED_BYTE_2_3_3_REV:
249      if (format == GL_RGB || format == GL_BGR ||
250          format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
251         return sizeof(GLubyte);
252      else
253         return -1;  /* error */
254   case GL_UNSIGNED_SHORT_5_6_5:
255   case GL_UNSIGNED_SHORT_5_6_5_REV:
256      if (format == GL_RGB || format == GL_BGR ||
257          format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT)
258         return sizeof(GLushort);
259      else
260         return -1;  /* error */
261   case GL_UNSIGNED_SHORT_4_4_4_4:
262   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
263   case GL_UNSIGNED_SHORT_5_5_5_1:
264   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
265      if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
266          format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT)
267         return sizeof(GLushort);
268      else
269         return -1;
270   case GL_UNSIGNED_INT_8_8_8_8:
271   case GL_UNSIGNED_INT_8_8_8_8_REV:
272   case GL_UNSIGNED_INT_10_10_10_2:
273   case GL_UNSIGNED_INT_2_10_10_10_REV:
274      if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT ||
275          format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT ||
276          format == GL_RGB)
277         return sizeof(GLuint);
278      else
279         return -1;
280   case GL_UNSIGNED_SHORT_8_8_MESA:
281   case GL_UNSIGNED_SHORT_8_8_REV_MESA:
282      if (format == GL_YCBCR_MESA)
283         return sizeof(GLushort);
284      else
285         return -1;
286   case GL_UNSIGNED_INT_24_8_EXT:
287      if (format == GL_DEPTH_STENCIL_EXT)
288         return sizeof(GLuint);
289      else
290         return -1;
291   case GL_UNSIGNED_INT_5_9_9_9_REV:
292      if (format == GL_RGB)
293         return sizeof(GLuint);
294      else
295         return -1;
296   case GL_UNSIGNED_INT_10F_11F_11F_REV:
297      if (format == GL_RGB)
298         return sizeof(GLuint);
299      else
300         return -1;
301   case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
302      if (format == GL_DEPTH_STENCIL)
303         return 8;
304      else
305         return -1;
306   default:
307      return -1;
308   }
309}
310
311
312/**
313 * Get the number of bytes for a vertex attrib with the given number of
314 * components and type.
315 *
316 * \param comps number of components.
317 * \param type data type.
318 *
319 * \return bytes per attribute, or -1 if a bad comps/type combination was given.
320 */
321GLint
322_mesa_bytes_per_vertex_attrib(GLint comps, GLenum type)
323{
324   switch (type) {
325   case GL_BYTE:
326   case GL_UNSIGNED_BYTE:
327      return comps * sizeof(GLubyte);
328   case GL_SHORT:
329   case GL_UNSIGNED_SHORT:
330      return comps * sizeof(GLshort);
331   case GL_INT:
332   case GL_UNSIGNED_INT:
333      return comps * sizeof(GLint);
334   case GL_FLOAT:
335      return comps * sizeof(GLfloat);
336   case GL_HALF_FLOAT_ARB:
337      return comps * sizeof(GLhalfARB);
338   case GL_DOUBLE:
339      return comps * sizeof(GLdouble);
340   case GL_FIXED:
341      return comps * sizeof(GLfixed);
342   case GL_INT_2_10_10_10_REV:
343   case GL_UNSIGNED_INT_2_10_10_10_REV:
344      if (comps == 4)
345         return sizeof(GLuint);
346      else
347         return -1;
348   case GL_UNSIGNED_INT_10F_11F_11F_REV:
349      if (comps == 3)
350         return sizeof(GLuint);
351      else
352         return -1;
353   default:
354      return -1;
355   }
356}
357
358
359/**
360 * Test if the given format is an integer (non-normalized) format.
361 */
362GLboolean
363_mesa_is_enum_format_unsigned_int(GLenum format)
364{
365   switch (format) {
366   /* specific integer formats */
367   case GL_RGBA32UI_EXT:
368   case GL_RGB32UI_EXT:
369   case GL_RG32UI:
370   case GL_R32UI:
371   case GL_ALPHA32UI_EXT:
372   case GL_INTENSITY32UI_EXT:
373   case GL_LUMINANCE32UI_EXT:
374   case GL_LUMINANCE_ALPHA32UI_EXT:
375   case GL_RGBA16UI_EXT:
376   case GL_RGB16UI_EXT:
377   case GL_RG16UI:
378   case GL_R16UI:
379   case GL_ALPHA16UI_EXT:
380   case GL_INTENSITY16UI_EXT:
381   case GL_LUMINANCE16UI_EXT:
382   case GL_LUMINANCE_ALPHA16UI_EXT:
383   case GL_RGBA8UI_EXT:
384   case GL_RGB8UI_EXT:
385   case GL_RG8UI:
386   case GL_R8UI:
387   case GL_ALPHA8UI_EXT:
388   case GL_INTENSITY8UI_EXT:
389   case GL_LUMINANCE8UI_EXT:
390   case GL_LUMINANCE_ALPHA8UI_EXT:
391   case GL_RGB10_A2UI:
392      return GL_TRUE;
393   default:
394      return GL_FALSE;
395   }
396}
397
398
399/**
400 * Test if the given format is an integer (non-normalized) format.
401 */
402GLboolean
403_mesa_is_enum_format_signed_int(GLenum format)
404{
405   switch (format) {
406   /* generic integer formats */
407   case GL_RED_INTEGER_EXT:
408   case GL_GREEN_INTEGER_EXT:
409   case GL_BLUE_INTEGER_EXT:
410   case GL_ALPHA_INTEGER_EXT:
411   case GL_RGB_INTEGER_EXT:
412   case GL_RGBA_INTEGER_EXT:
413   case GL_BGR_INTEGER_EXT:
414   case GL_BGRA_INTEGER_EXT:
415   case GL_LUMINANCE_INTEGER_EXT:
416   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
417   case GL_RG_INTEGER:
418   /* specific integer formats */
419   case GL_RGBA32I_EXT:
420   case GL_RGB32I_EXT:
421   case GL_RG32I:
422   case GL_R32I:
423   case GL_ALPHA32I_EXT:
424   case GL_INTENSITY32I_EXT:
425   case GL_LUMINANCE32I_EXT:
426   case GL_LUMINANCE_ALPHA32I_EXT:
427   case GL_RGBA16I_EXT:
428   case GL_RGB16I_EXT:
429   case GL_RG16I:
430   case GL_R16I:
431   case GL_ALPHA16I_EXT:
432   case GL_INTENSITY16I_EXT:
433   case GL_LUMINANCE16I_EXT:
434   case GL_LUMINANCE_ALPHA16I_EXT:
435   case GL_RGBA8I_EXT:
436   case GL_RGB8I_EXT:
437   case GL_RG8I:
438   case GL_R8I:
439   case GL_ALPHA8I_EXT:
440   case GL_INTENSITY8I_EXT:
441   case GL_LUMINANCE8I_EXT:
442   case GL_LUMINANCE_ALPHA8I_EXT:
443      return GL_TRUE;
444   default:
445      return GL_FALSE;
446   }
447}
448
449
450/**
451 * Test if the given format is an integer (non-normalized) format.
452 */
453GLboolean
454_mesa_is_enum_format_integer(GLenum format)
455{
456   return _mesa_is_enum_format_unsigned_int(format) ||
457          _mesa_is_enum_format_signed_int(format);
458}
459
460
461/**
462 * Test if the given type is an integer (non-normalized) format.
463 */
464GLboolean
465_mesa_is_type_integer(GLenum type)
466{
467   switch (type) {
468   case GL_INT:
469   case GL_UNSIGNED_INT:
470   case GL_SHORT:
471   case GL_UNSIGNED_SHORT:
472   case GL_BYTE:
473   case GL_UNSIGNED_BYTE:
474      return GL_TRUE;
475   default:
476      return GL_FALSE;
477   }
478}
479
480
481/**
482 * Test if the given format or type is an integer (non-normalized) format.
483 */
484extern GLboolean
485_mesa_is_enum_format_or_type_integer(GLenum format, GLenum type)
486{
487   return _mesa_is_enum_format_integer(format) || _mesa_is_type_integer(type);
488}
489
490
491GLboolean
492_mesa_is_type_unsigned(GLenum type)
493{
494   switch (type) {
495   case GL_UNSIGNED_INT:
496   case GL_UNSIGNED_INT_8_8_8_8:
497   case GL_UNSIGNED_INT_8_8_8_8_REV:
498   case GL_UNSIGNED_INT_10_10_10_2:
499   case GL_UNSIGNED_INT_2_10_10_10_REV:
500
501   case GL_UNSIGNED_SHORT:
502   case GL_UNSIGNED_SHORT_4_4_4_4:
503   case GL_UNSIGNED_SHORT_5_5_5_1:
504   case GL_UNSIGNED_SHORT_5_6_5:
505   case GL_UNSIGNED_SHORT_5_6_5_REV:
506   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
507   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
508   case GL_UNSIGNED_SHORT_8_8_MESA:
509   case GL_UNSIGNED_SHORT_8_8_REV_MESA:
510
511   case GL_UNSIGNED_BYTE:
512   case GL_UNSIGNED_BYTE_3_3_2:
513   case GL_UNSIGNED_BYTE_2_3_3_REV:
514      return GL_TRUE;
515
516   default:
517      return GL_FALSE;
518   }
519}
520
521
522/**
523 * Test if the given image format is a color/RGBA format (i.e., not color
524 * index, depth, stencil, etc).
525 * \param format  the image format value (may by an internal texture format)
526 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
527 */
528GLboolean
529_mesa_is_color_format(GLenum format)
530{
531   switch (format) {
532      case GL_RED:
533      case GL_GREEN:
534      case GL_BLUE:
535      case GL_ALPHA:
536      case GL_ALPHA4:
537      case GL_ALPHA8:
538      case GL_ALPHA12:
539      case GL_ALPHA16:
540      case 1:
541      case GL_LUMINANCE:
542      case GL_LUMINANCE4:
543      case GL_LUMINANCE8:
544      case GL_LUMINANCE12:
545      case GL_LUMINANCE16:
546      case 2:
547      case GL_LUMINANCE_ALPHA:
548      case GL_LUMINANCE4_ALPHA4:
549      case GL_LUMINANCE6_ALPHA2:
550      case GL_LUMINANCE8_ALPHA8:
551      case GL_LUMINANCE12_ALPHA4:
552      case GL_LUMINANCE12_ALPHA12:
553      case GL_LUMINANCE16_ALPHA16:
554      case GL_INTENSITY:
555      case GL_INTENSITY4:
556      case GL_INTENSITY8:
557      case GL_INTENSITY12:
558      case GL_INTENSITY16:
559      case GL_R8:
560      case GL_R16:
561      case GL_RG:
562      case GL_RG8:
563      case GL_RG16:
564      case 3:
565      case GL_RGB:
566      case GL_BGR:
567      case GL_R3_G3_B2:
568      case GL_RGB4:
569      case GL_RGB5:
570      case GL_RGB565:
571      case GL_RGB8:
572      case GL_RGB10:
573      case GL_RGB12:
574      case GL_RGB16:
575      case 4:
576      case GL_ABGR_EXT:
577      case GL_RGBA:
578      case GL_BGRA:
579      case GL_RGBA2:
580      case GL_RGBA4:
581      case GL_RGB5_A1:
582      case GL_RGBA8:
583      case GL_RGB10_A2:
584      case GL_RGBA12:
585      case GL_RGBA16:
586      /* float texture formats */
587      case GL_ALPHA16F_ARB:
588      case GL_ALPHA32F_ARB:
589      case GL_LUMINANCE16F_ARB:
590      case GL_LUMINANCE32F_ARB:
591      case GL_LUMINANCE_ALPHA16F_ARB:
592      case GL_LUMINANCE_ALPHA32F_ARB:
593      case GL_INTENSITY16F_ARB:
594      case GL_INTENSITY32F_ARB:
595      case GL_R16F:
596      case GL_R32F:
597      case GL_RG16F:
598      case GL_RG32F:
599      case GL_RGB16F_ARB:
600      case GL_RGB32F_ARB:
601      case GL_RGBA16F_ARB:
602      case GL_RGBA32F_ARB:
603      /* compressed formats */
604      case GL_COMPRESSED_ALPHA:
605      case GL_COMPRESSED_LUMINANCE:
606      case GL_COMPRESSED_LUMINANCE_ALPHA:
607      case GL_COMPRESSED_INTENSITY:
608      case GL_COMPRESSED_RED:
609      case GL_COMPRESSED_RG:
610      case GL_COMPRESSED_RGB:
611      case GL_COMPRESSED_RGBA:
612      case GL_RGB_S3TC:
613      case GL_RGB4_S3TC:
614      case GL_RGBA_S3TC:
615      case GL_RGBA4_S3TC:
616      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
617      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
618      case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
619      case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
620      case GL_COMPRESSED_RGB_FXT1_3DFX:
621      case GL_COMPRESSED_RGBA_FXT1_3DFX:
622      case GL_SRGB_EXT:
623      case GL_SRGB8_EXT:
624      case GL_SRGB_ALPHA_EXT:
625      case GL_SRGB8_ALPHA8_EXT:
626      case GL_SLUMINANCE_ALPHA_EXT:
627      case GL_SLUMINANCE8_ALPHA8_EXT:
628      case GL_SLUMINANCE_EXT:
629      case GL_SLUMINANCE8_EXT:
630      case GL_COMPRESSED_SRGB_EXT:
631      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
632      case GL_COMPRESSED_SRGB_ALPHA_EXT:
633      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
634      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
635      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
636      case GL_COMPRESSED_SLUMINANCE_EXT:
637      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
638      case GL_COMPRESSED_RED_RGTC1:
639      case GL_COMPRESSED_SIGNED_RED_RGTC1:
640      case GL_COMPRESSED_RG_RGTC2:
641      case GL_COMPRESSED_SIGNED_RG_RGTC2:
642      case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
643      case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
644      case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
645      case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
646      case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
647      case GL_ETC1_RGB8_OES:
648      case GL_COMPRESSED_RGB8_ETC2:
649      case GL_COMPRESSED_SRGB8_ETC2:
650      case GL_COMPRESSED_RGBA8_ETC2_EAC:
651      case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
652      case GL_COMPRESSED_R11_EAC:
653      case GL_COMPRESSED_RG11_EAC:
654      case GL_COMPRESSED_SIGNED_R11_EAC:
655      case GL_COMPRESSED_SIGNED_RG11_EAC:
656      case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
657      case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
658      /* generic integer formats */
659      case GL_RED_INTEGER_EXT:
660      case GL_GREEN_INTEGER_EXT:
661      case GL_BLUE_INTEGER_EXT:
662      case GL_ALPHA_INTEGER_EXT:
663      case GL_RGB_INTEGER_EXT:
664      case GL_RGBA_INTEGER_EXT:
665      case GL_BGR_INTEGER_EXT:
666      case GL_BGRA_INTEGER_EXT:
667      case GL_RG_INTEGER:
668      case GL_LUMINANCE_INTEGER_EXT:
669      case GL_LUMINANCE_ALPHA_INTEGER_EXT:
670      /* sized integer formats */
671      case GL_RGBA32UI_EXT:
672      case GL_RGB32UI_EXT:
673      case GL_RG32UI:
674      case GL_R32UI:
675      case GL_ALPHA32UI_EXT:
676      case GL_INTENSITY32UI_EXT:
677      case GL_LUMINANCE32UI_EXT:
678      case GL_LUMINANCE_ALPHA32UI_EXT:
679      case GL_RGBA16UI_EXT:
680      case GL_RGB16UI_EXT:
681      case GL_RG16UI:
682      case GL_R16UI:
683      case GL_ALPHA16UI_EXT:
684      case GL_INTENSITY16UI_EXT:
685      case GL_LUMINANCE16UI_EXT:
686      case GL_LUMINANCE_ALPHA16UI_EXT:
687      case GL_RGBA8UI_EXT:
688      case GL_RGB8UI_EXT:
689      case GL_RG8UI:
690      case GL_R8UI:
691      case GL_ALPHA8UI_EXT:
692      case GL_INTENSITY8UI_EXT:
693      case GL_LUMINANCE8UI_EXT:
694      case GL_LUMINANCE_ALPHA8UI_EXT:
695      case GL_RGBA32I_EXT:
696      case GL_RGB32I_EXT:
697      case GL_RG32I:
698      case GL_R32I:
699      case GL_ALPHA32I_EXT:
700      case GL_INTENSITY32I_EXT:
701      case GL_LUMINANCE32I_EXT:
702      case GL_LUMINANCE_ALPHA32I_EXT:
703      case GL_RGBA16I_EXT:
704      case GL_RGB16I_EXT:
705      case GL_RG16I:
706      case GL_R16I:
707      case GL_ALPHA16I_EXT:
708      case GL_INTENSITY16I_EXT:
709      case GL_LUMINANCE16I_EXT:
710      case GL_LUMINANCE_ALPHA16I_EXT:
711      case GL_RGBA8I_EXT:
712      case GL_RGB8I_EXT:
713      case GL_RG8I:
714      case GL_R8I:
715      case GL_ALPHA8I_EXT:
716      case GL_INTENSITY8I_EXT:
717      case GL_LUMINANCE8I_EXT:
718      case GL_LUMINANCE_ALPHA8I_EXT:
719      /* signed, normalized texture formats */
720      case GL_RED_SNORM:
721      case GL_R8_SNORM:
722      case GL_R16_SNORM:
723      case GL_RG_SNORM:
724      case GL_RG8_SNORM:
725      case GL_RG16_SNORM:
726      case GL_RGB_SNORM:
727      case GL_RGB8_SNORM:
728      case GL_RGB16_SNORM:
729      case GL_RGBA_SNORM:
730      case GL_RGBA8_SNORM:
731      case GL_RGBA16_SNORM:
732      case GL_ALPHA_SNORM:
733      case GL_ALPHA8_SNORM:
734      case GL_ALPHA16_SNORM:
735      case GL_LUMINANCE_SNORM:
736      case GL_LUMINANCE8_SNORM:
737      case GL_LUMINANCE16_SNORM:
738      case GL_LUMINANCE_ALPHA_SNORM:
739      case GL_LUMINANCE8_ALPHA8_SNORM:
740      case GL_LUMINANCE16_ALPHA16_SNORM:
741      case GL_INTENSITY_SNORM:
742      case GL_INTENSITY8_SNORM:
743      case GL_INTENSITY16_SNORM:
744      case GL_RGB9_E5:
745      case GL_R11F_G11F_B10F:
746      case GL_RGB10_A2UI:
747         return GL_TRUE;
748      case GL_YCBCR_MESA:  /* not considered to be RGB */
749         /* fall-through */
750      default:
751         return GL_FALSE;
752   }
753}
754
755
756/**
757 * Test if the given image format is a depth component format.
758 */
759GLboolean
760_mesa_is_depth_format(GLenum format)
761{
762   switch (format) {
763      case GL_DEPTH_COMPONENT:
764      case GL_DEPTH_COMPONENT16:
765      case GL_DEPTH_COMPONENT24:
766      case GL_DEPTH_COMPONENT32:
767      case GL_DEPTH_COMPONENT32F:
768         return GL_TRUE;
769      default:
770         return GL_FALSE;
771   }
772}
773
774
775/**
776 * Test if the given image format is a stencil format.
777 */
778GLboolean
779_mesa_is_stencil_format(GLenum format)
780{
781   switch (format) {
782      case GL_STENCIL_INDEX:
783         return GL_TRUE;
784      default:
785         return GL_FALSE;
786   }
787}
788
789
790/**
791 * Test if the given image format is a YCbCr format.
792 */
793GLboolean
794_mesa_is_ycbcr_format(GLenum format)
795{
796   switch (format) {
797      case GL_YCBCR_MESA:
798         return GL_TRUE;
799      default:
800         return GL_FALSE;
801   }
802}
803
804
805/**
806 * Test if the given image format is a depth+stencil format.
807 */
808GLboolean
809_mesa_is_depthstencil_format(GLenum format)
810{
811   switch (format) {
812      case GL_DEPTH24_STENCIL8_EXT:
813      case GL_DEPTH_STENCIL_EXT:
814      case GL_DEPTH32F_STENCIL8:
815         return GL_TRUE;
816      default:
817         return GL_FALSE;
818   }
819}
820
821
822/**
823 * Test if the given image format is a depth or stencil format.
824 */
825GLboolean
826_mesa_is_depth_or_stencil_format(GLenum format)
827{
828   switch (format) {
829      case GL_DEPTH_COMPONENT:
830      case GL_DEPTH_COMPONENT16:
831      case GL_DEPTH_COMPONENT24:
832      case GL_DEPTH_COMPONENT32:
833      case GL_STENCIL_INDEX:
834      case GL_STENCIL_INDEX1_EXT:
835      case GL_STENCIL_INDEX4_EXT:
836      case GL_STENCIL_INDEX8_EXT:
837      case GL_STENCIL_INDEX16_EXT:
838      case GL_DEPTH_STENCIL_EXT:
839      case GL_DEPTH24_STENCIL8_EXT:
840      case GL_DEPTH_COMPONENT32F:
841      case GL_DEPTH32F_STENCIL8:
842         return GL_TRUE;
843      default:
844         return GL_FALSE;
845   }
846}
847
848
849/**
850 * Test if the given image format is a dudv format.
851 */
852GLboolean
853_mesa_is_dudv_format(GLenum format)
854{
855   switch (format) {
856      case GL_DUDV_ATI:
857      case GL_DU8DV8_ATI:
858         return GL_TRUE;
859      default:
860         return GL_FALSE;
861   }
862}
863
864
865/**
866 * Test if an image format is a supported compressed format.
867 * \param format the internal format token provided by the user.
868 * \return GL_TRUE if compressed, GL_FALSE if uncompressed
869 */
870GLboolean
871_mesa_is_compressed_format(struct gl_context *ctx, GLenum format)
872{
873   switch (format) {
874   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
875   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
876   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
877   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
878      /* Assume that the ANGLE flag will always be set if the EXT flag is set.
879       */
880      return ctx->Extensions.ANGLE_texture_compression_dxt;
881   case GL_RGB_S3TC:
882   case GL_RGB4_S3TC:
883   case GL_RGBA_S3TC:
884   case GL_RGBA4_S3TC:
885      return _mesa_is_desktop_gl(ctx) &&
886         ctx->Extensions.ANGLE_texture_compression_dxt;
887   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
888   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
889   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
890   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
891      return _mesa_is_desktop_gl(ctx)
892         && ctx->Extensions.EXT_texture_sRGB
893         && ctx->Extensions.EXT_texture_compression_s3tc;
894   case GL_COMPRESSED_RGB_FXT1_3DFX:
895   case GL_COMPRESSED_RGBA_FXT1_3DFX:
896      return _mesa_is_desktop_gl(ctx)
897         && ctx->Extensions.TDFX_texture_compression_FXT1;
898   case GL_COMPRESSED_RED_RGTC1:
899   case GL_COMPRESSED_SIGNED_RED_RGTC1:
900   case GL_COMPRESSED_RG_RGTC2:
901   case GL_COMPRESSED_SIGNED_RG_RGTC2:
902      return _mesa_is_desktop_gl(ctx)
903         && ctx->Extensions.ARB_texture_compression_rgtc;
904   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
905   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
906   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
907   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
908      return ctx->API == API_OPENGL_COMPAT
909         && ctx->Extensions.EXT_texture_compression_latc;
910   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
911      return ctx->API == API_OPENGL_COMPAT
912         && ctx->Extensions.ATI_texture_compression_3dc;
913   case GL_ETC1_RGB8_OES:
914      return _mesa_is_gles(ctx)
915         && ctx->Extensions.OES_compressed_ETC1_RGB8_texture;
916   case GL_COMPRESSED_RGB8_ETC2:
917   case GL_COMPRESSED_SRGB8_ETC2:
918   case GL_COMPRESSED_RGBA8_ETC2_EAC:
919   case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
920   case GL_COMPRESSED_R11_EAC:
921   case GL_COMPRESSED_RG11_EAC:
922   case GL_COMPRESSED_SIGNED_R11_EAC:
923   case GL_COMPRESSED_SIGNED_RG11_EAC:
924   case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
925   case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
926      return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility;
927   case GL_PALETTE4_RGB8_OES:
928   case GL_PALETTE4_RGBA8_OES:
929   case GL_PALETTE4_R5_G6_B5_OES:
930   case GL_PALETTE4_RGBA4_OES:
931   case GL_PALETTE4_RGB5_A1_OES:
932   case GL_PALETTE8_RGB8_OES:
933   case GL_PALETTE8_RGBA8_OES:
934   case GL_PALETTE8_R5_G6_B5_OES:
935   case GL_PALETTE8_RGBA4_OES:
936   case GL_PALETTE8_RGB5_A1_OES:
937      return ctx->API == API_OPENGLES;
938   default:
939      return GL_FALSE;
940   }
941}
942
943
944/**
945 * Convert various base formats to the cooresponding integer format.
946 */
947GLenum
948_mesa_base_format_to_integer_format(GLenum format)
949{
950   switch(format) {
951   case GL_RED:
952      return GL_RED_INTEGER;
953   case GL_GREEN:
954      return GL_GREEN_INTEGER;
955   case GL_BLUE:
956      return GL_BLUE_INTEGER;
957   case GL_RG:
958      return GL_RG_INTEGER;
959   case GL_RGB:
960      return GL_RGB_INTEGER;
961   case GL_RGBA:
962      return GL_RGBA_INTEGER;
963   case GL_BGR:
964      return GL_BGR_INTEGER;
965   case GL_BGRA:
966      return GL_BGRA_INTEGER;
967   case GL_ALPHA:
968      return GL_ALPHA_INTEGER;
969   case GL_LUMINANCE:
970      return GL_LUMINANCE_INTEGER_EXT;
971   case GL_LUMINANCE_ALPHA:
972      return GL_LUMINANCE_ALPHA_INTEGER_EXT;
973   }
974
975   return format;
976}
977
978
979/**
980 * Does the given base texture/renderbuffer format have the channel
981 * named by 'pname'?
982 */
983GLboolean
984_mesa_base_format_has_channel(GLenum base_format, GLenum pname)
985{
986   switch (pname) {
987   case GL_TEXTURE_RED_SIZE:
988   case GL_TEXTURE_RED_TYPE:
989   case GL_RENDERBUFFER_RED_SIZE_EXT:
990   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
991      if (base_format == GL_RED ||
992	  base_format == GL_RG ||
993	  base_format == GL_RGB ||
994	  base_format == GL_RGBA) {
995	 return GL_TRUE;
996      }
997      return GL_FALSE;
998   case GL_TEXTURE_GREEN_SIZE:
999   case GL_TEXTURE_GREEN_TYPE:
1000   case GL_RENDERBUFFER_GREEN_SIZE_EXT:
1001   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
1002      if (base_format == GL_RG ||
1003	  base_format == GL_RGB ||
1004	  base_format == GL_RGBA) {
1005	 return GL_TRUE;
1006      }
1007      return GL_FALSE;
1008   case GL_TEXTURE_BLUE_SIZE:
1009   case GL_TEXTURE_BLUE_TYPE:
1010   case GL_RENDERBUFFER_BLUE_SIZE_EXT:
1011   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
1012      if (base_format == GL_RGB ||
1013	  base_format == GL_RGBA) {
1014	 return GL_TRUE;
1015      }
1016      return GL_FALSE;
1017   case GL_TEXTURE_ALPHA_SIZE:
1018   case GL_TEXTURE_ALPHA_TYPE:
1019   case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
1020   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
1021      if (base_format == GL_RGBA ||
1022	  base_format == GL_ALPHA ||
1023	  base_format == GL_LUMINANCE_ALPHA) {
1024	 return GL_TRUE;
1025      }
1026      return GL_FALSE;
1027   case GL_TEXTURE_LUMINANCE_SIZE:
1028   case GL_TEXTURE_LUMINANCE_TYPE:
1029      if (base_format == GL_LUMINANCE ||
1030	  base_format == GL_LUMINANCE_ALPHA) {
1031	 return GL_TRUE;
1032      }
1033      return GL_FALSE;
1034   case GL_TEXTURE_INTENSITY_SIZE:
1035   case GL_TEXTURE_INTENSITY_TYPE:
1036      if (base_format == GL_INTENSITY) {
1037	 return GL_TRUE;
1038      }
1039      return GL_FALSE;
1040   case GL_TEXTURE_DEPTH_SIZE:
1041   case GL_TEXTURE_DEPTH_TYPE:
1042   case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
1043   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
1044      if (base_format == GL_DEPTH_STENCIL ||
1045	  base_format == GL_DEPTH_COMPONENT) {
1046	 return GL_TRUE;
1047      }
1048      return GL_FALSE;
1049   case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
1050   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
1051      if (base_format == GL_DEPTH_STENCIL ||
1052	  base_format == GL_STENCIL_INDEX) {
1053	 return GL_TRUE;
1054      }
1055      return GL_FALSE;
1056   default:
1057      _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n",
1058		    __FUNCTION__, pname);
1059      return GL_FALSE;
1060   }
1061
1062   return GL_FALSE;
1063}
1064
1065
1066/**
1067 * Returns the number of channels/components for a base format.
1068 */
1069GLint
1070_mesa_base_format_component_count(GLenum base_format)
1071{
1072   switch (base_format) {
1073   case GL_RED:
1074   case GL_ALPHA:
1075   case GL_INTENSITY:
1076   case GL_DEPTH_COMPONENT:
1077      return 1;
1078   case GL_RG:
1079   case GL_LUMINANCE_ALPHA:
1080   case GL_DEPTH_STENCIL:
1081      return 2;
1082   case GL_RGB:
1083      return 3;
1084   case GL_RGBA:
1085      return 4;
1086   default:
1087      return -1;
1088   }
1089}
1090
1091
1092/**
1093 * If format is a generic compressed format, return the corresponding
1094 * non-compressed format.  For other formats, return the format as-is.
1095 */
1096GLenum
1097_mesa_generic_compressed_format_to_uncompressed_format(GLenum format)
1098{
1099   switch (format) {
1100   case GL_COMPRESSED_RED:
1101      return GL_RED;
1102   case GL_COMPRESSED_RG:
1103      return GL_RG;
1104   case GL_COMPRESSED_RGB:
1105      return GL_RGB;
1106   case GL_COMPRESSED_RGBA:
1107      return GL_RGBA;
1108   case GL_COMPRESSED_ALPHA:
1109      return GL_ALPHA;
1110   case GL_COMPRESSED_LUMINANCE:
1111      return GL_LUMINANCE;
1112   case GL_COMPRESSED_LUMINANCE_ALPHA:
1113      return GL_LUMINANCE_ALPHA;
1114   case GL_COMPRESSED_INTENSITY:
1115      return GL_INTENSITY;
1116   /* sRGB formats */
1117   case GL_COMPRESSED_SRGB:
1118      return GL_SRGB;
1119   case GL_COMPRESSED_SRGB_ALPHA:
1120      return GL_SRGB_ALPHA;
1121   case GL_COMPRESSED_SLUMINANCE:
1122      return GL_SLUMINANCE;
1123   case GL_COMPRESSED_SLUMINANCE_ALPHA:
1124      return GL_SLUMINANCE_ALPHA;
1125   default:
1126      return format;
1127   }
1128}
1129
1130
1131/**
1132 * Return the equivalent non-generic internal format.
1133 * This is useful for comparing whether two internal formats are equivalent.
1134 */
1135GLenum
1136_mesa_get_nongeneric_internalformat(GLenum format)
1137{
1138   switch (format) {
1139      /* GL 1.1 formats. */
1140      case 4:
1141      case GL_RGBA:
1142         return GL_RGBA8;
1143
1144      case 3:
1145      case GL_RGB:
1146         return GL_RGB8;
1147
1148      case 2:
1149      case GL_LUMINANCE_ALPHA:
1150         return GL_LUMINANCE8_ALPHA8;
1151
1152      case 1:
1153      case GL_LUMINANCE:
1154         return GL_LUMINANCE8;
1155
1156      case GL_ALPHA:
1157         return GL_ALPHA8;
1158
1159      case GL_INTENSITY:
1160         return GL_INTENSITY8;
1161
1162      /* GL_ARB_texture_rg */
1163      case GL_RED:
1164         return GL_R8;
1165
1166      case GL_RG:
1167         return GL_RG8;
1168
1169      /* GL_EXT_texture_sRGB */
1170      case GL_SRGB:
1171         return GL_SRGB8;
1172
1173      case GL_SRGB_ALPHA:
1174         return GL_SRGB8_ALPHA8;
1175
1176      case GL_SLUMINANCE:
1177         return GL_SLUMINANCE8;
1178
1179      case GL_SLUMINANCE_ALPHA:
1180         return GL_SLUMINANCE8_ALPHA8;
1181
1182      /* GL_EXT_texture_snorm */
1183      case GL_RGBA_SNORM:
1184         return GL_RGBA8_SNORM;
1185
1186      case GL_RGB_SNORM:
1187         return GL_RGB8_SNORM;
1188
1189      case GL_RG_SNORM:
1190         return GL_RG8_SNORM;
1191
1192      case GL_RED_SNORM:
1193         return GL_R8_SNORM;
1194
1195      case GL_LUMINANCE_ALPHA_SNORM:
1196         return GL_LUMINANCE8_ALPHA8_SNORM;
1197
1198      case GL_LUMINANCE_SNORM:
1199         return GL_LUMINANCE8_SNORM;
1200
1201      case GL_ALPHA_SNORM:
1202         return GL_ALPHA8_SNORM;
1203
1204      case GL_INTENSITY_SNORM:
1205         return GL_INTENSITY8_SNORM;
1206
1207      default:
1208         return format;
1209   }
1210}
1211
1212
1213/**
1214 * Convert an sRGB internal format to linear.
1215 */
1216GLenum
1217_mesa_get_linear_internalformat(GLenum format)
1218{
1219   switch (format) {
1220   case GL_SRGB:
1221      return GL_RGB;
1222
1223   case GL_SRGB_ALPHA:
1224      return GL_RGBA;
1225
1226   case GL_SRGB8:
1227      return GL_RGB8;
1228
1229   case GL_SRGB8_ALPHA8:
1230      return GL_RGBA8;
1231
1232   case GL_SLUMINANCE:
1233      return GL_LUMINANCE8;
1234
1235   case GL_SLUMINANCE_ALPHA:
1236      return GL_LUMINANCE8_ALPHA8;
1237
1238   default:
1239      return format;
1240   }
1241}
1242
1243
1244/**
1245 * Do error checking of format/type combinations for glReadPixels,
1246 * glDrawPixels and glTex[Sub]Image.  Note that depending on the format
1247 * and type values, we may either generate GL_INVALID_OPERATION or
1248 * GL_INVALID_ENUM.
1249 *
1250 * \param format pixel format.
1251 * \param type pixel type.
1252 *
1253 * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR
1254 */
1255GLenum
1256_mesa_error_check_format_and_type(const struct gl_context *ctx,
1257                                  GLenum format, GLenum type)
1258{
1259   /* special type-based checks (see glReadPixels, glDrawPixels error lists) */
1260   switch (type) {
1261   case GL_BITMAP:
1262      if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) {
1263         return GL_INVALID_ENUM;
1264      }
1265      break;
1266
1267   case GL_UNSIGNED_BYTE_3_3_2:
1268   case GL_UNSIGNED_BYTE_2_3_3_REV:
1269   case GL_UNSIGNED_SHORT_5_6_5:
1270   case GL_UNSIGNED_SHORT_5_6_5_REV:
1271      if (format == GL_RGB) {
1272         break; /* OK */
1273      }
1274      if (format == GL_RGB_INTEGER_EXT &&
1275          ctx->Extensions.ARB_texture_rgb10_a2ui) {
1276         break; /* OK */
1277      }
1278      return GL_INVALID_OPERATION;
1279
1280   case GL_UNSIGNED_SHORT_4_4_4_4:
1281   case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1282   case GL_UNSIGNED_SHORT_5_5_5_1:
1283   case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1284   case GL_UNSIGNED_INT_8_8_8_8:
1285   case GL_UNSIGNED_INT_8_8_8_8_REV:
1286   case GL_UNSIGNED_INT_10_10_10_2:
1287   case GL_UNSIGNED_INT_2_10_10_10_REV:
1288      if (format == GL_RGBA ||
1289          format == GL_BGRA ||
1290          format == GL_ABGR_EXT) {
1291         break; /* OK */
1292      }
1293      if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) &&
1294          ctx->Extensions.ARB_texture_rgb10_a2ui) {
1295         break; /* OK */
1296      }
1297      if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB &&
1298          ctx->API == API_OPENGLES2) {
1299         break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1300      }
1301      return GL_INVALID_OPERATION;
1302
1303   case GL_UNSIGNED_INT_24_8:
1304      if (!ctx->Extensions.EXT_packed_depth_stencil) {
1305         return GL_INVALID_ENUM;
1306      }
1307      if (format != GL_DEPTH_STENCIL) {
1308         return GL_INVALID_OPERATION;
1309      }
1310      return GL_NO_ERROR;
1311
1312   case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
1313      if (!ctx->Extensions.ARB_depth_buffer_float) {
1314         return GL_INVALID_ENUM;
1315      }
1316      if (format != GL_DEPTH_STENCIL) {
1317         return GL_INVALID_OPERATION;
1318      }
1319      return GL_NO_ERROR;
1320
1321   case GL_UNSIGNED_INT_10F_11F_11F_REV:
1322      if (!ctx->Extensions.EXT_packed_float) {
1323         return GL_INVALID_ENUM;
1324      }
1325      if (format != GL_RGB) {
1326         return GL_INVALID_OPERATION;
1327      }
1328      return GL_NO_ERROR;
1329
1330   default:
1331      ; /* fall-through */
1332   }
1333
1334   /* now, for each format, check the type for compatibility */
1335   switch (format) {
1336      case GL_COLOR_INDEX:
1337      case GL_STENCIL_INDEX:
1338         switch (type) {
1339            case GL_BITMAP:
1340            case GL_BYTE:
1341            case GL_UNSIGNED_BYTE:
1342            case GL_SHORT:
1343            case GL_UNSIGNED_SHORT:
1344            case GL_INT:
1345            case GL_UNSIGNED_INT:
1346            case GL_FLOAT:
1347               return GL_NO_ERROR;
1348            case GL_HALF_FLOAT:
1349               return ctx->Extensions.ARB_half_float_pixel
1350                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1351            default:
1352               return GL_INVALID_ENUM;
1353         }
1354
1355      case GL_RED:
1356      case GL_GREEN:
1357      case GL_BLUE:
1358      case GL_ALPHA:
1359#if 0 /* not legal!  see table 3.6 of the 1.5 spec */
1360      case GL_INTENSITY:
1361#endif
1362      case GL_LUMINANCE:
1363      case GL_LUMINANCE_ALPHA:
1364      case GL_DEPTH_COMPONENT:
1365         switch (type) {
1366            case GL_BYTE:
1367            case GL_UNSIGNED_BYTE:
1368            case GL_SHORT:
1369            case GL_UNSIGNED_SHORT:
1370            case GL_INT:
1371            case GL_UNSIGNED_INT:
1372            case GL_FLOAT:
1373               return GL_NO_ERROR;
1374            case GL_HALF_FLOAT:
1375               return ctx->Extensions.ARB_half_float_pixel
1376                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1377            default:
1378               return GL_INVALID_ENUM;
1379         }
1380
1381      case GL_RG:
1382	 if (!ctx->Extensions.ARB_texture_rg)
1383	    return GL_INVALID_ENUM;
1384         switch (type) {
1385            case GL_BYTE:
1386            case GL_UNSIGNED_BYTE:
1387            case GL_SHORT:
1388            case GL_UNSIGNED_SHORT:
1389            case GL_INT:
1390            case GL_UNSIGNED_INT:
1391            case GL_FLOAT:
1392               return GL_NO_ERROR;
1393            case GL_HALF_FLOAT:
1394               return ctx->Extensions.ARB_half_float_pixel
1395                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1396            default:
1397               return GL_INVALID_ENUM;
1398         }
1399
1400      case GL_RGB:
1401         switch (type) {
1402            case GL_BYTE:
1403            case GL_UNSIGNED_BYTE:
1404            case GL_SHORT:
1405            case GL_UNSIGNED_SHORT:
1406            case GL_INT:
1407            case GL_UNSIGNED_INT:
1408            case GL_FLOAT:
1409            case GL_UNSIGNED_BYTE_3_3_2:
1410            case GL_UNSIGNED_BYTE_2_3_3_REV:
1411            case GL_UNSIGNED_SHORT_5_6_5:
1412            case GL_UNSIGNED_SHORT_5_6_5_REV:
1413               return GL_NO_ERROR;
1414            case GL_UNSIGNED_INT_2_10_10_10_REV:
1415               /* OK by GL_EXT_texture_type_2_10_10_10_REV */
1416               return (ctx->API == API_OPENGLES2)
1417                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1418            case GL_HALF_FLOAT:
1419               return ctx->Extensions.ARB_half_float_pixel
1420                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1421            case GL_UNSIGNED_INT_5_9_9_9_REV:
1422               return ctx->Extensions.EXT_texture_shared_exponent
1423                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1424            case GL_UNSIGNED_INT_10F_11F_11F_REV:
1425               return ctx->Extensions.EXT_packed_float
1426                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1427            default:
1428               return GL_INVALID_ENUM;
1429         }
1430
1431      case GL_BGR:
1432         switch (type) {
1433            /* NOTE: no packed types are supported with BGR.  That's
1434             * intentional, according to the GL spec.
1435             */
1436            case GL_BYTE:
1437            case GL_UNSIGNED_BYTE:
1438            case GL_SHORT:
1439            case GL_UNSIGNED_SHORT:
1440            case GL_INT:
1441            case GL_UNSIGNED_INT:
1442            case GL_FLOAT:
1443               return GL_NO_ERROR;
1444            case GL_HALF_FLOAT:
1445               return ctx->Extensions.ARB_half_float_pixel
1446                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1447            default:
1448               return GL_INVALID_ENUM;
1449         }
1450
1451      case GL_RGBA:
1452      case GL_BGRA:
1453      case GL_ABGR_EXT:
1454         switch (type) {
1455            case GL_BYTE:
1456            case GL_UNSIGNED_BYTE:
1457            case GL_SHORT:
1458            case GL_UNSIGNED_SHORT:
1459            case GL_INT:
1460            case GL_UNSIGNED_INT:
1461            case GL_FLOAT:
1462            case GL_UNSIGNED_SHORT_4_4_4_4:
1463            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1464            case GL_UNSIGNED_SHORT_5_5_5_1:
1465            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1466            case GL_UNSIGNED_INT_8_8_8_8:
1467            case GL_UNSIGNED_INT_8_8_8_8_REV:
1468            case GL_UNSIGNED_INT_10_10_10_2:
1469            case GL_UNSIGNED_INT_2_10_10_10_REV:
1470               return GL_NO_ERROR;
1471            case GL_HALF_FLOAT:
1472               return ctx->Extensions.ARB_half_float_pixel
1473                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1474            default:
1475               return GL_INVALID_ENUM;
1476         }
1477
1478      case GL_YCBCR_MESA:
1479         if (!ctx->Extensions.MESA_ycbcr_texture)
1480            return GL_INVALID_ENUM;
1481         if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
1482             type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
1483            return GL_NO_ERROR;
1484         else
1485            return GL_INVALID_OPERATION;
1486
1487      case GL_DEPTH_STENCIL_EXT:
1488         if (ctx->Extensions.EXT_packed_depth_stencil &&
1489             type == GL_UNSIGNED_INT_24_8)
1490            return GL_NO_ERROR;
1491         else if (ctx->Extensions.ARB_depth_buffer_float &&
1492             type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)
1493            return GL_NO_ERROR;
1494         else
1495            return GL_INVALID_ENUM;
1496
1497      case GL_DUDV_ATI:
1498      case GL_DU8DV8_ATI:
1499         if (!ctx->Extensions.ATI_envmap_bumpmap)
1500            return GL_INVALID_ENUM;
1501         switch (type) {
1502            case GL_BYTE:
1503            case GL_UNSIGNED_BYTE:
1504            case GL_SHORT:
1505            case GL_UNSIGNED_SHORT:
1506            case GL_INT:
1507            case GL_UNSIGNED_INT:
1508            case GL_FLOAT:
1509               return GL_NO_ERROR;
1510            default:
1511               return GL_INVALID_ENUM;
1512         }
1513
1514      /* integer-valued formats */
1515      case GL_RED_INTEGER_EXT:
1516      case GL_GREEN_INTEGER_EXT:
1517      case GL_BLUE_INTEGER_EXT:
1518      case GL_ALPHA_INTEGER_EXT:
1519      case GL_RG_INTEGER:
1520         switch (type) {
1521            case GL_BYTE:
1522            case GL_UNSIGNED_BYTE:
1523            case GL_SHORT:
1524            case GL_UNSIGNED_SHORT:
1525            case GL_INT:
1526            case GL_UNSIGNED_INT:
1527               return (ctx->Version >= 30 ||
1528                       ctx->Extensions.EXT_texture_integer)
1529                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1530            default:
1531               return GL_INVALID_ENUM;
1532         }
1533
1534      case GL_RGB_INTEGER_EXT:
1535         switch (type) {
1536            case GL_BYTE:
1537            case GL_UNSIGNED_BYTE:
1538            case GL_SHORT:
1539            case GL_UNSIGNED_SHORT:
1540            case GL_INT:
1541            case GL_UNSIGNED_INT:
1542               return (ctx->Version >= 30 ||
1543                       ctx->Extensions.EXT_texture_integer)
1544                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1545            case GL_UNSIGNED_BYTE_3_3_2:
1546            case GL_UNSIGNED_BYTE_2_3_3_REV:
1547            case GL_UNSIGNED_SHORT_5_6_5:
1548            case GL_UNSIGNED_SHORT_5_6_5_REV:
1549               return ctx->Extensions.ARB_texture_rgb10_a2ui
1550                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1551            default:
1552               return GL_INVALID_ENUM;
1553         }
1554
1555      case GL_BGR_INTEGER_EXT:
1556         switch (type) {
1557            case GL_BYTE:
1558            case GL_UNSIGNED_BYTE:
1559            case GL_SHORT:
1560            case GL_UNSIGNED_SHORT:
1561            case GL_INT:
1562            case GL_UNSIGNED_INT:
1563            /* NOTE: no packed formats w/ BGR format */
1564               return (ctx->Version >= 30 ||
1565                       ctx->Extensions.EXT_texture_integer)
1566                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1567            default:
1568               return GL_INVALID_ENUM;
1569         }
1570
1571      case GL_RGBA_INTEGER_EXT:
1572      case GL_BGRA_INTEGER_EXT:
1573         switch (type) {
1574            case GL_BYTE:
1575            case GL_UNSIGNED_BYTE:
1576            case GL_SHORT:
1577            case GL_UNSIGNED_SHORT:
1578            case GL_INT:
1579            case GL_UNSIGNED_INT:
1580               return (ctx->Version >= 30 ||
1581                       ctx->Extensions.EXT_texture_integer)
1582                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1583            case GL_UNSIGNED_SHORT_4_4_4_4:
1584            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1585            case GL_UNSIGNED_SHORT_5_5_5_1:
1586            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1587            case GL_UNSIGNED_INT_8_8_8_8:
1588            case GL_UNSIGNED_INT_8_8_8_8_REV:
1589            case GL_UNSIGNED_INT_10_10_10_2:
1590            case GL_UNSIGNED_INT_2_10_10_10_REV:
1591               return ctx->Extensions.ARB_texture_rgb10_a2ui
1592                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1593            default:
1594               return GL_INVALID_ENUM;
1595         }
1596
1597      case GL_LUMINANCE_INTEGER_EXT:
1598      case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1599         switch (type) {
1600            case GL_BYTE:
1601            case GL_UNSIGNED_BYTE:
1602            case GL_SHORT:
1603            case GL_UNSIGNED_SHORT:
1604            case GL_INT:
1605            case GL_UNSIGNED_INT:
1606               return ctx->Extensions.EXT_texture_integer
1607                  ? GL_NO_ERROR : GL_INVALID_ENUM;
1608            default:
1609               return GL_INVALID_ENUM;
1610         }
1611
1612      default:
1613         return GL_INVALID_ENUM;
1614   }
1615   return GL_NO_ERROR;
1616}
1617
1618
1619/**
1620 * Do error checking of format/type combinations for OpenGL ES glReadPixels
1621 * and glTex[Sub]Image.
1622 * \return error code, or GL_NO_ERROR.
1623 */
1624GLenum
1625_mesa_es_error_check_format_and_type(GLenum format, GLenum type,
1626                                     unsigned dimensions)
1627{
1628   GLboolean type_valid = GL_TRUE;
1629
1630   switch (format) {
1631   case GL_ALPHA:
1632   case GL_LUMINANCE:
1633   case GL_LUMINANCE_ALPHA:
1634      type_valid = (type == GL_UNSIGNED_BYTE
1635                    || type == GL_FLOAT
1636                    || type == GL_HALF_FLOAT_OES);
1637      break;
1638
1639   case GL_RGB:
1640      type_valid = (type == GL_UNSIGNED_BYTE
1641                    || type == GL_UNSIGNED_SHORT_5_6_5
1642                    || type == GL_FLOAT
1643                    || type == GL_HALF_FLOAT_OES);
1644      break;
1645
1646   case GL_RGBA:
1647      type_valid = (type == GL_UNSIGNED_BYTE
1648                    || type == GL_UNSIGNED_SHORT_4_4_4_4
1649                    || type == GL_UNSIGNED_SHORT_5_5_5_1
1650                    || type == GL_FLOAT
1651                    || type == GL_HALF_FLOAT_OES
1652                    || type == GL_UNSIGNED_INT_2_10_10_10_REV);
1653      break;
1654
1655   case GL_DEPTH_COMPONENT:
1656      /* This format is filtered against invalid dimensionalities elsewhere.
1657       */
1658      type_valid = (type == GL_UNSIGNED_SHORT
1659                    || type == GL_UNSIGNED_INT);
1660      break;
1661
1662   case GL_DEPTH_STENCIL:
1663      /* This format is filtered against invalid dimensionalities elsewhere.
1664       */
1665      type_valid = (type == GL_UNSIGNED_INT_24_8);
1666      break;
1667
1668   case GL_BGRA_EXT:
1669      type_valid = (type == GL_UNSIGNED_BYTE);
1670
1671      /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but
1672       * the format does not appear to be allowed for 3D textures in OpenGL
1673       * ES.
1674       */
1675      if (dimensions != 2)
1676         return GL_INVALID_VALUE;
1677
1678      break;
1679
1680   default:
1681      return GL_INVALID_VALUE;
1682   }
1683
1684   return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
1685}
1686
1687
1688/**
1689 * Do error checking of format/type combinations for OpenGL ES 3
1690 * glTex[Sub]Image.
1691 * \return error code, or GL_NO_ERROR.
1692 */
1693GLenum
1694_mesa_es3_error_check_format_and_type(GLenum format, GLenum type,
1695                                      GLenum internalFormat)
1696{
1697   GLboolean type_valid = GL_TRUE;
1698
1699   switch (format) {
1700   case GL_RGBA:
1701      switch (type) {
1702      case GL_UNSIGNED_BYTE:
1703         switch (internalFormat) {
1704         case GL_RGBA:
1705         case GL_RGBA8:
1706         case GL_RGB5_A1:
1707         case GL_RGBA4:
1708         case GL_SRGB8_ALPHA8_EXT:
1709            break;
1710         default:
1711            return GL_INVALID_OPERATION;
1712         }
1713         break;
1714
1715      case GL_BYTE:
1716         if (internalFormat != GL_RGBA8_SNORM)
1717            return GL_INVALID_OPERATION;
1718         break;
1719
1720      case GL_UNSIGNED_SHORT_4_4_4_4:
1721         switch (internalFormat) {
1722         case GL_RGBA:
1723         case GL_RGBA4:
1724            break;
1725         default:
1726            return GL_INVALID_OPERATION;
1727         }
1728         break;
1729
1730      case GL_UNSIGNED_SHORT_5_5_5_1:
1731         switch (internalFormat) {
1732         case GL_RGBA:
1733         case GL_RGB5_A1:
1734            break;
1735         default:
1736            return GL_INVALID_OPERATION;
1737         }
1738         break;
1739
1740      case GL_UNSIGNED_INT_2_10_10_10_REV:
1741         switch (internalFormat) {
1742         case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */
1743         case GL_RGB10_A2:
1744         case GL_RGB5_A1:
1745            break;
1746         default:
1747            return GL_INVALID_OPERATION;
1748         }
1749         break;
1750
1751      case GL_HALF_FLOAT:
1752         if (internalFormat != GL_RGBA16F)
1753            return GL_INVALID_OPERATION;
1754         break;
1755
1756      case GL_FLOAT:
1757         switch (internalFormat) {
1758         case GL_RGBA16F:
1759         case GL_RGBA32F:
1760            break;
1761         default:
1762            return GL_INVALID_OPERATION;
1763         }
1764         break;
1765
1766      default:
1767         return GL_INVALID_OPERATION;
1768      }
1769      break;
1770
1771   case GL_RGBA_INTEGER:
1772      switch (type) {
1773      case GL_UNSIGNED_BYTE:
1774         if (internalFormat != GL_RGBA8UI)
1775            return GL_INVALID_OPERATION;
1776         break;
1777
1778      case GL_BYTE:
1779         if (internalFormat != GL_RGBA8I)
1780            return GL_INVALID_OPERATION;
1781         break;
1782
1783      case GL_UNSIGNED_SHORT:
1784         if (internalFormat != GL_RGBA16UI)
1785            return GL_INVALID_OPERATION;
1786         break;
1787
1788      case GL_SHORT:
1789         if (internalFormat != GL_RGBA16I)
1790            return GL_INVALID_OPERATION;
1791         break;
1792
1793      case GL_UNSIGNED_INT:
1794         if (internalFormat != GL_RGBA32UI)
1795            return GL_INVALID_OPERATION;
1796         break;
1797
1798      case GL_INT:
1799         if (internalFormat != GL_RGBA32I)
1800            return GL_INVALID_OPERATION;
1801         break;
1802
1803      case GL_UNSIGNED_INT_2_10_10_10_REV:
1804         if (internalFormat != GL_RGB10_A2UI)
1805            return GL_INVALID_OPERATION;
1806         break;
1807
1808      default:
1809         return GL_INVALID_OPERATION;
1810      }
1811      break;
1812
1813   case GL_RGB:
1814      switch (type) {
1815      case GL_UNSIGNED_BYTE:
1816         switch (internalFormat) {
1817         case GL_RGB:
1818         case GL_RGB8:
1819         case GL_RGB565:
1820         case GL_SRGB8:
1821            break;
1822         default:
1823            return GL_INVALID_OPERATION;
1824         }
1825         break;
1826
1827      case GL_BYTE:
1828         if (internalFormat != GL_RGB8_SNORM)
1829            return GL_INVALID_OPERATION;
1830         break;
1831
1832      case GL_UNSIGNED_SHORT_5_6_5:
1833         switch (internalFormat) {
1834         case GL_RGB:
1835         case GL_RGB565:
1836            break;
1837         default:
1838            return GL_INVALID_OPERATION;
1839         }
1840         break;
1841
1842      case GL_UNSIGNED_INT_10F_11F_11F_REV:
1843         if (internalFormat != GL_R11F_G11F_B10F)
1844            return GL_INVALID_OPERATION;
1845         break;
1846
1847      case GL_UNSIGNED_INT_5_9_9_9_REV:
1848         if (internalFormat != GL_RGB9_E5)
1849            return GL_INVALID_OPERATION;
1850         break;
1851
1852      case GL_HALF_FLOAT:
1853         switch (internalFormat) {
1854         case GL_RGB16F:
1855         case GL_R11F_G11F_B10F:
1856         case GL_RGB9_E5:
1857            break;
1858         default:
1859            return GL_INVALID_OPERATION;
1860         }
1861         break;
1862
1863      case GL_FLOAT:
1864         switch (internalFormat) {
1865         case GL_RGB16F:
1866         case GL_RGB32F:
1867         case GL_R11F_G11F_B10F:
1868         case GL_RGB9_E5:
1869            break;
1870         default:
1871            return GL_INVALID_OPERATION;
1872         }
1873         break;
1874
1875      case GL_UNSIGNED_INT_2_10_10_10_REV:
1876         switch (internalFormat) {
1877         case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */
1878            break;
1879         default:
1880            return GL_INVALID_OPERATION;
1881         }
1882         break;
1883
1884      default:
1885         return GL_INVALID_OPERATION;
1886      }
1887      break;
1888
1889   case GL_RGB_INTEGER:
1890      switch (type) {
1891      case GL_UNSIGNED_BYTE:
1892         if (internalFormat != GL_RGB8UI)
1893            return GL_INVALID_OPERATION;
1894         break;
1895
1896      case GL_BYTE:
1897         if (internalFormat != GL_RGB8I)
1898            return GL_INVALID_OPERATION;
1899         break;
1900
1901      case GL_UNSIGNED_SHORT:
1902         if (internalFormat != GL_RGB16UI)
1903            return GL_INVALID_OPERATION;
1904         break;
1905
1906      case GL_SHORT:
1907         if (internalFormat != GL_RGB16I)
1908            return GL_INVALID_OPERATION;
1909         break;
1910
1911      case GL_UNSIGNED_INT:
1912         if (internalFormat != GL_RGB32UI)
1913            return GL_INVALID_OPERATION;
1914         break;
1915
1916      case GL_INT:
1917         if (internalFormat != GL_RGB32I)
1918            return GL_INVALID_OPERATION;
1919         break;
1920
1921      default:
1922         return GL_INVALID_OPERATION;
1923      }
1924      break;
1925
1926   case GL_RG:
1927      switch (type) {
1928      case GL_UNSIGNED_BYTE:
1929         if (internalFormat != GL_RG8)
1930            return GL_INVALID_OPERATION;
1931         break;
1932
1933      case GL_BYTE:
1934         if (internalFormat != GL_RG8_SNORM)
1935            return GL_INVALID_OPERATION;
1936         break;
1937
1938      case GL_HALF_FLOAT:
1939         if (internalFormat != GL_RG16F)
1940            return GL_INVALID_OPERATION;
1941         break;
1942
1943      case GL_FLOAT:
1944         switch (internalFormat) {
1945         case GL_RG16F:
1946         case GL_RG32F:
1947            break;
1948         default:
1949            return GL_INVALID_OPERATION;
1950         }
1951         break;
1952
1953      default:
1954         return GL_INVALID_OPERATION;
1955      }
1956      break;
1957
1958   case GL_RG_INTEGER:
1959      switch (type) {
1960      case GL_UNSIGNED_BYTE:
1961         if (internalFormat != GL_RG8UI)
1962            return GL_INVALID_OPERATION;
1963         break;
1964
1965      case GL_BYTE:
1966         if (internalFormat != GL_RG8I)
1967            return GL_INVALID_OPERATION;
1968         break;
1969
1970      case GL_UNSIGNED_SHORT:
1971         if (internalFormat != GL_RG16UI)
1972            return GL_INVALID_OPERATION;
1973         break;
1974
1975      case GL_SHORT:
1976         if (internalFormat != GL_RG16I)
1977            return GL_INVALID_OPERATION;
1978         break;
1979
1980      case GL_UNSIGNED_INT:
1981         if (internalFormat != GL_RG32UI)
1982            return GL_INVALID_OPERATION;
1983         break;
1984
1985      case GL_INT:
1986         if (internalFormat != GL_RG32I)
1987            return GL_INVALID_OPERATION;
1988         break;
1989
1990      default:
1991         return GL_INVALID_OPERATION;
1992      }
1993      break;
1994
1995   case GL_RED:
1996      switch (type) {
1997      case GL_UNSIGNED_BYTE:
1998         if (internalFormat != GL_R8)
1999            return GL_INVALID_OPERATION;
2000         break;
2001
2002      case GL_BYTE:
2003         if (internalFormat != GL_R8_SNORM)
2004            return GL_INVALID_OPERATION;
2005         break;
2006
2007      case GL_HALF_FLOAT:
2008         if (internalFormat != GL_R16F)
2009            return GL_INVALID_OPERATION;
2010         break;
2011
2012      case GL_FLOAT:
2013         switch (internalFormat) {
2014         case GL_R16F:
2015         case GL_R32F:
2016            break;
2017         default:
2018            return GL_INVALID_OPERATION;
2019         }
2020         break;
2021
2022      default:
2023         return GL_INVALID_OPERATION;
2024      }
2025      break;
2026
2027   case GL_RED_INTEGER:
2028      switch (type) {
2029      case GL_UNSIGNED_BYTE:
2030         if (internalFormat != GL_R8UI)
2031            return GL_INVALID_OPERATION;
2032         break;
2033
2034      case GL_BYTE:
2035         if (internalFormat != GL_R8I)
2036            return GL_INVALID_OPERATION;
2037         break;
2038
2039      case GL_UNSIGNED_SHORT:
2040         if (internalFormat != GL_R16UI)
2041            return GL_INVALID_OPERATION;
2042         break;
2043
2044      case GL_SHORT:
2045         if (internalFormat != GL_R16I)
2046            return GL_INVALID_OPERATION;
2047         break;
2048
2049      case GL_UNSIGNED_INT:
2050         if (internalFormat != GL_R32UI)
2051            return GL_INVALID_OPERATION;
2052         break;
2053
2054      case GL_INT:
2055         if (internalFormat != GL_R32I)
2056            return GL_INVALID_OPERATION;
2057         break;
2058
2059      default:
2060         return GL_INVALID_OPERATION;
2061      }
2062      break;
2063
2064   case GL_DEPTH_COMPONENT:
2065      switch (type) {
2066      case GL_UNSIGNED_SHORT:
2067         if (internalFormat != GL_DEPTH_COMPONENT
2068             && internalFormat != GL_DEPTH_COMPONENT16)
2069            return GL_INVALID_OPERATION;
2070         break;
2071
2072      case GL_UNSIGNED_INT:
2073         switch (internalFormat) {
2074         case GL_DEPTH_COMPONENT:
2075         case GL_DEPTH_COMPONENT16:
2076         case GL_DEPTH_COMPONENT24:
2077            break;
2078         default:
2079            return GL_INVALID_OPERATION;
2080         }
2081         break;
2082
2083      case GL_FLOAT:
2084         if (internalFormat != GL_DEPTH_COMPONENT32F)
2085            return GL_INVALID_OPERATION;
2086         break;
2087
2088      default:
2089         return GL_INVALID_OPERATION;
2090      }
2091      break;
2092
2093   case GL_DEPTH_STENCIL:
2094      switch (type) {
2095      case GL_UNSIGNED_INT_24_8:
2096         if (internalFormat != GL_DEPTH_STENCIL
2097             && internalFormat != GL_DEPTH24_STENCIL8)
2098            return GL_INVALID_OPERATION;
2099         break;
2100
2101      case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
2102         if (internalFormat != GL_DEPTH32F_STENCIL8)
2103            return GL_INVALID_OPERATION;
2104         break;
2105
2106      default:
2107         return GL_INVALID_OPERATION;
2108      }
2109      break;
2110
2111   case GL_ALPHA:
2112   case GL_LUMINANCE:
2113   case GL_LUMINANCE_ALPHA:
2114      if (type != GL_UNSIGNED_BYTE || format != internalFormat)
2115         return GL_INVALID_OPERATION;
2116      break;
2117   }
2118
2119   return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION;
2120}
2121