1 /*
2  * Copyright © 2012 Intel Corporation
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  */
23 
24 #include "mtypes.h"
25 #include "context.h"
26 #include "glformats.h"
27 #include "macros.h"
28 #include "enums.h"
29 #include "fbobject.h"
30 #include "formatquery.h"
31 #include "teximage.h"
32 #include "texparam.h"
33 #include "texobj.h"
34 #include "get.h"
35 #include "genmipmap.h"
36 #include "shaderimage.h"
37 #include "texcompress.h"
38 #include "textureview.h"
39 #include "api_exec_decl.h"
40 
41 #include "state_tracker/st_format.h"
42 
43 static bool
_is_renderable(struct gl_context * ctx,GLenum internalformat)44 _is_renderable(struct gl_context *ctx, GLenum internalformat)
45 {
46    /*  Section 4.4.4 on page 212 of the  GLES 3.0.4 spec says:
47     *
48     *     "An internal format is color-renderable if it is one of the
49     *     formats from table 3.13 noted as color-renderable or if it
50     *     is unsized format RGBA or RGB."
51     *
52     * Therefore, we must accept GL_RGB and GL_RGBA here.
53     */
54    if (internalformat != GL_RGB && internalformat != GL_RGBA &&
55        _mesa_base_fbo_format(ctx, internalformat) == 0)
56       return false;
57 
58    return true;
59 }
60 
61 /* Handles the cases where either ARB_internalformat_query or
62  * ARB_internalformat_query2 have to return an error.
63  */
64 static bool
_legal_parameters(struct gl_context * ctx,GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)65 _legal_parameters(struct gl_context *ctx, GLenum target, GLenum internalformat,
66                   GLenum pname, GLsizei bufSize, GLint *params)
67 
68 {
69    bool query2 = _mesa_has_ARB_internalformat_query2(ctx);
70 
71    /* The ARB_internalformat_query2 spec says:
72     *
73     *    "The INVALID_ENUM error is generated if the <target> parameter to
74     *    GetInternalformati*v is not one of the targets listed in Table 6.xx.
75     */
76    switch(target){
77    case GL_TEXTURE_1D:
78    case GL_TEXTURE_1D_ARRAY:
79    case GL_TEXTURE_2D:
80    case GL_TEXTURE_2D_ARRAY:
81    case GL_TEXTURE_3D:
82    case GL_TEXTURE_CUBE_MAP:
83    case GL_TEXTURE_CUBE_MAP_ARRAY:
84    case GL_TEXTURE_RECTANGLE:
85    case GL_TEXTURE_BUFFER:
86       if (!query2) {
87          /* The ARB_internalformat_query spec says:
88           *
89           *     "If the <target> parameter to GetInternalformativ is not one of
90           *      TEXTURE_2D_MULTISAMPLE, TEXTURE_2D_MULTISAMPLE_ARRAY
91           *      or RENDERBUFFER then an INVALID_ENUM error is generated.
92           */
93          _mesa_error(ctx, GL_INVALID_ENUM,
94                      "glGetInternalformativ(target=%s)",
95                      _mesa_enum_to_string(target));
96 
97          return false;
98       }
99       break;
100 
101    case GL_RENDERBUFFER:
102       break;
103 
104    case GL_TEXTURE_2D_MULTISAMPLE:
105    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
106       /* The non-existence of ARB_texture_multisample is treated in
107        * ARB_internalformat_query implementation like an error.
108        */
109       if (!query2 &&
110           !(_mesa_has_ARB_texture_multisample(ctx) || _mesa_is_gles31(ctx))) {
111          _mesa_error(ctx, GL_INVALID_ENUM,
112                      "glGetInternalformativ(target=%s)",
113                      _mesa_enum_to_string(target));
114 
115          return false;
116       }
117       break;
118 
119    default:
120       _mesa_error(ctx, GL_INVALID_ENUM,
121                   "glGetInternalformativ(target=%s)",
122                   _mesa_enum_to_string(target));
123       return false;
124    }
125 
126 
127    /* The ARB_internalformat_query2 spec says:
128     *
129     *     "The INVALID_ENUM error is generated if the <pname> parameter is
130     *     not one of the listed possibilities.
131     */
132    switch(pname){
133    case GL_SAMPLES:
134    case GL_NUM_SAMPLE_COUNTS:
135       break;
136 
137    case GL_TEXTURE_REDUCTION_MODE_ARB:
138       if (!_mesa_has_ARB_texture_filter_minmax(ctx)) {
139          _mesa_error(ctx, GL_INVALID_ENUM,
140                      "glGetInternalformativ(pname=%s)",
141                      _mesa_enum_to_string(pname));
142          return false;
143       }
144       break;
145 
146    case GL_NUM_VIRTUAL_PAGE_SIZES_ARB:
147    case GL_VIRTUAL_PAGE_SIZE_X_ARB:
148    case GL_VIRTUAL_PAGE_SIZE_Y_ARB:
149    case GL_VIRTUAL_PAGE_SIZE_Z_ARB:
150       if (!_mesa_has_ARB_sparse_texture(ctx)) {
151          _mesa_error(ctx, GL_INVALID_ENUM,
152                      "glGetInternalformativ(pname=%s)",
153                      _mesa_enum_to_string(pname));
154          return false;
155       }
156       break;
157 
158    case GL_SRGB_DECODE_ARB:
159       /* The ARB_internalformat_query2 spec says:
160        *
161        *     "If ARB_texture_sRGB_decode or EXT_texture_sRGB_decode or
162        *     equivalent functionality is not supported, queries for the
163        *     SRGB_DECODE_ARB <pname> set the INVALID_ENUM error.
164        */
165       if (!_mesa_has_EXT_texture_sRGB_decode(ctx)) {
166          _mesa_error(ctx, GL_INVALID_ENUM,
167                      "glGetInternalformativ(pname=%s)",
168                      _mesa_enum_to_string(pname));
169          return false;
170       }
171       FALLTHROUGH;
172    case GL_INTERNALFORMAT_SUPPORTED:
173    case GL_INTERNALFORMAT_PREFERRED:
174    case GL_INTERNALFORMAT_RED_SIZE:
175    case GL_INTERNALFORMAT_GREEN_SIZE:
176    case GL_INTERNALFORMAT_BLUE_SIZE:
177    case GL_INTERNALFORMAT_ALPHA_SIZE:
178    case GL_INTERNALFORMAT_DEPTH_SIZE:
179    case GL_INTERNALFORMAT_STENCIL_SIZE:
180    case GL_INTERNALFORMAT_SHARED_SIZE:
181    case GL_INTERNALFORMAT_RED_TYPE:
182    case GL_INTERNALFORMAT_GREEN_TYPE:
183    case GL_INTERNALFORMAT_BLUE_TYPE:
184    case GL_INTERNALFORMAT_ALPHA_TYPE:
185    case GL_INTERNALFORMAT_DEPTH_TYPE:
186    case GL_INTERNALFORMAT_STENCIL_TYPE:
187    case GL_MAX_WIDTH:
188    case GL_MAX_HEIGHT:
189    case GL_MAX_DEPTH:
190    case GL_MAX_LAYERS:
191    case GL_MAX_COMBINED_DIMENSIONS:
192    case GL_COLOR_COMPONENTS:
193    case GL_DEPTH_COMPONENTS:
194    case GL_STENCIL_COMPONENTS:
195    case GL_COLOR_RENDERABLE:
196    case GL_DEPTH_RENDERABLE:
197    case GL_STENCIL_RENDERABLE:
198    case GL_FRAMEBUFFER_RENDERABLE:
199    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
200    case GL_FRAMEBUFFER_BLEND:
201    case GL_READ_PIXELS:
202    case GL_READ_PIXELS_FORMAT:
203    case GL_READ_PIXELS_TYPE:
204    case GL_TEXTURE_IMAGE_FORMAT:
205    case GL_TEXTURE_IMAGE_TYPE:
206    case GL_GET_TEXTURE_IMAGE_FORMAT:
207    case GL_GET_TEXTURE_IMAGE_TYPE:
208    case GL_MIPMAP:
209    case GL_MANUAL_GENERATE_MIPMAP:
210    case GL_AUTO_GENERATE_MIPMAP:
211    case GL_COLOR_ENCODING:
212    case GL_SRGB_READ:
213    case GL_SRGB_WRITE:
214    case GL_FILTER:
215    case GL_VERTEX_TEXTURE:
216    case GL_TESS_CONTROL_TEXTURE:
217    case GL_TESS_EVALUATION_TEXTURE:
218    case GL_GEOMETRY_TEXTURE:
219    case GL_FRAGMENT_TEXTURE:
220    case GL_COMPUTE_TEXTURE:
221    case GL_TEXTURE_SHADOW:
222    case GL_TEXTURE_GATHER:
223    case GL_TEXTURE_GATHER_SHADOW:
224    case GL_SHADER_IMAGE_LOAD:
225    case GL_SHADER_IMAGE_STORE:
226    case GL_SHADER_IMAGE_ATOMIC:
227    case GL_IMAGE_TEXEL_SIZE:
228    case GL_IMAGE_COMPATIBILITY_CLASS:
229    case GL_IMAGE_PIXEL_FORMAT:
230    case GL_IMAGE_PIXEL_TYPE:
231    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
232    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
233    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
234    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
235    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
236    case GL_TEXTURE_COMPRESSED:
237    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
238    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
239    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE:
240    case GL_CLEAR_BUFFER:
241    case GL_TEXTURE_VIEW:
242    case GL_VIEW_COMPATIBILITY_CLASS:
243    case GL_NUM_TILING_TYPES_EXT:
244    case GL_TILING_TYPES_EXT:
245       /* The ARB_internalformat_query spec says:
246        *
247        *     "If the <pname> parameter to GetInternalformativ is not SAMPLES
248        *     or NUM_SAMPLE_COUNTS, then an INVALID_ENUM error is generated."
249        */
250       if (!query2) {
251          _mesa_error(ctx, GL_INVALID_ENUM,
252                      "glGetInternalformativ(pname=%s)",
253                      _mesa_enum_to_string(pname));
254 
255          return false;
256       }
257       break;
258 
259    default:
260       _mesa_error(ctx, GL_INVALID_ENUM,
261                   "glGetInternalformativ(pname=%s)",
262                   _mesa_enum_to_string(pname));
263       return false;
264    }
265 
266    /* The ARB_internalformat_query spec says:
267     *
268     *     "If the <bufSize> parameter to GetInternalformativ is negative, then
269     *     an INVALID_VALUE error is generated."
270     *
271     * Nothing is said in ARB_internalformat_query2 but we assume the same.
272     */
273    if (bufSize < 0) {
274       _mesa_error(ctx, GL_INVALID_VALUE,
275                   "glGetInternalformativ(target=%s)",
276                   _mesa_enum_to_string(target));
277       return false;
278    }
279 
280    /* The ARB_internalformat_query spec says:
281     *
282     *     "If the <internalformat> parameter to GetInternalformativ is not
283     *     color-, depth- or stencil-renderable, then an INVALID_ENUM error is
284     *     generated."
285     */
286    if (!query2 && !_is_renderable(ctx, internalformat)) {
287       _mesa_error(ctx, GL_INVALID_ENUM,
288                   "glGetInternalformativ(internalformat=%s)",
289                   _mesa_enum_to_string(internalformat));
290       return false;
291    }
292 
293    return true;
294 }
295 
296 /* Sets the appropriate "unsupported" response as defined by the
297  * ARB_internalformat_query2 spec for each each <pname>.
298  */
299 static void
_set_default_response(GLenum pname,GLint buffer[16])300 _set_default_response(GLenum pname, GLint buffer[16])
301 {
302    /* The ARB_internalformat_query2 defines which is the reponse best
303     * representing "not supported" or "not applicable" for each <pname>.
304     *
305     *     " In general:
306     *          - size- or count-based queries will return zero,
307     *          - support-, format- or type-based queries will return NONE,
308     *          - boolean-based queries will return FALSE, and
309     *          - list-based queries return no entries."
310     */
311    switch(pname) {
312    case GL_SAMPLES:
313    case GL_TILING_TYPES_EXT:
314       break;
315 
316    case GL_MAX_COMBINED_DIMENSIONS:
317       /* This value can be a 64-bit value. As the default is the 32-bit query,
318        * we pack 2 32-bit integers. So we need to clean both */
319       buffer[0] = 0;
320       buffer[1] = 0;
321       break;
322 
323    case GL_NUM_SAMPLE_COUNTS:
324    case GL_INTERNALFORMAT_RED_SIZE:
325    case GL_INTERNALFORMAT_GREEN_SIZE:
326    case GL_INTERNALFORMAT_BLUE_SIZE:
327    case GL_INTERNALFORMAT_ALPHA_SIZE:
328    case GL_INTERNALFORMAT_DEPTH_SIZE:
329    case GL_INTERNALFORMAT_STENCIL_SIZE:
330    case GL_INTERNALFORMAT_SHARED_SIZE:
331    case GL_MAX_WIDTH:
332    case GL_MAX_HEIGHT:
333    case GL_MAX_DEPTH:
334    case GL_MAX_LAYERS:
335    case GL_IMAGE_TEXEL_SIZE:
336    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
337    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
338    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE:
339    case GL_NUM_TILING_TYPES_EXT:
340    case GL_NUM_VIRTUAL_PAGE_SIZES_ARB:
341    case GL_VIRTUAL_PAGE_SIZE_X_ARB:
342    case GL_VIRTUAL_PAGE_SIZE_Y_ARB:
343    case GL_VIRTUAL_PAGE_SIZE_Z_ARB:
344       buffer[0] = 0;
345       break;
346 
347    case GL_INTERNALFORMAT_PREFERRED:
348    case GL_INTERNALFORMAT_RED_TYPE:
349    case GL_INTERNALFORMAT_GREEN_TYPE:
350    case GL_INTERNALFORMAT_BLUE_TYPE:
351    case GL_INTERNALFORMAT_ALPHA_TYPE:
352    case GL_INTERNALFORMAT_DEPTH_TYPE:
353    case GL_INTERNALFORMAT_STENCIL_TYPE:
354    case GL_FRAMEBUFFER_RENDERABLE:
355    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
356    case GL_FRAMEBUFFER_BLEND:
357    case GL_READ_PIXELS:
358    case GL_READ_PIXELS_FORMAT:
359    case GL_READ_PIXELS_TYPE:
360    case GL_TEXTURE_IMAGE_FORMAT:
361    case GL_TEXTURE_IMAGE_TYPE:
362    case GL_GET_TEXTURE_IMAGE_FORMAT:
363    case GL_GET_TEXTURE_IMAGE_TYPE:
364    case GL_MANUAL_GENERATE_MIPMAP:
365    case GL_AUTO_GENERATE_MIPMAP:
366    case GL_COLOR_ENCODING:
367    case GL_SRGB_READ:
368    case GL_SRGB_WRITE:
369    case GL_SRGB_DECODE_ARB:
370    case GL_FILTER:
371    case GL_VERTEX_TEXTURE:
372    case GL_TESS_CONTROL_TEXTURE:
373    case GL_TESS_EVALUATION_TEXTURE:
374    case GL_GEOMETRY_TEXTURE:
375    case GL_FRAGMENT_TEXTURE:
376    case GL_COMPUTE_TEXTURE:
377    case GL_TEXTURE_SHADOW:
378    case GL_TEXTURE_GATHER:
379    case GL_TEXTURE_GATHER_SHADOW:
380    case GL_SHADER_IMAGE_LOAD:
381    case GL_SHADER_IMAGE_STORE:
382    case GL_SHADER_IMAGE_ATOMIC:
383    case GL_IMAGE_COMPATIBILITY_CLASS:
384    case GL_IMAGE_PIXEL_FORMAT:
385    case GL_IMAGE_PIXEL_TYPE:
386    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
387    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
388    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
389    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
390    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
391    case GL_CLEAR_BUFFER:
392    case GL_TEXTURE_VIEW:
393    case GL_VIEW_COMPATIBILITY_CLASS:
394       buffer[0] = GL_NONE;
395       break;
396 
397    case GL_INTERNALFORMAT_SUPPORTED:
398    case GL_COLOR_COMPONENTS:
399    case GL_DEPTH_COMPONENTS:
400    case GL_STENCIL_COMPONENTS:
401    case GL_COLOR_RENDERABLE:
402    case GL_DEPTH_RENDERABLE:
403    case GL_STENCIL_RENDERABLE:
404    case GL_MIPMAP:
405    case GL_TEXTURE_COMPRESSED:
406    case GL_TEXTURE_REDUCTION_MODE_ARB:
407       buffer[0] = GL_FALSE;
408       break;
409 
410    default:
411       unreachable("invalid 'pname'");
412    }
413 }
414 
415 static bool
_is_target_supported(struct gl_context * ctx,GLenum target)416 _is_target_supported(struct gl_context *ctx, GLenum target)
417 {
418    /* The ARB_internalformat_query2 spec says:
419     *
420     *     "if a particular type of <target> is not supported by the
421     *     implementation the "unsupported" answer should be given.
422     *     This is not an error."
423     *
424     * Note that legality of targets has already been verified.
425     */
426    switch(target){
427    case GL_TEXTURE_1D:
428    case GL_TEXTURE_2D:
429    case GL_TEXTURE_3D:
430       break;
431 
432    case GL_TEXTURE_1D_ARRAY:
433       if (!_mesa_has_EXT_texture_array(ctx))
434          return false;
435       break;
436 
437    case GL_TEXTURE_2D_ARRAY:
438       if (!_mesa_has_EXT_texture_array(ctx))
439          return false;
440       break;
441 
442    case GL_TEXTURE_CUBE_MAP:
443       if (!_mesa_is_desktop_gl(ctx))
444          return false;
445       break;
446 
447    case GL_TEXTURE_CUBE_MAP_ARRAY:
448       if (!_mesa_has_ARB_texture_cube_map_array(ctx))
449          return false;
450       break;
451 
452    case GL_TEXTURE_RECTANGLE:
453       if (!_mesa_has_ARB_texture_rectangle(ctx))
454           return false;
455       break;
456 
457    case GL_TEXTURE_BUFFER:
458       if (!_mesa_has_ARB_texture_buffer_object(ctx))
459          return false;
460       break;
461 
462    case GL_RENDERBUFFER:
463       if (!(_mesa_has_ARB_framebuffer_object(ctx) ||
464             _mesa_is_gles3(ctx)))
465          return false;
466       break;
467 
468    case GL_TEXTURE_2D_MULTISAMPLE:
469    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
470       if (!(_mesa_has_ARB_texture_multisample(ctx) ||
471             _mesa_is_gles31(ctx)))
472          return false;
473       break;
474 
475    default:
476       unreachable("invalid target");
477    }
478 
479    return true;
480 }
481 
482 static bool
_is_resource_supported(struct gl_context * ctx,GLenum target,GLenum internalformat,GLenum pname)483 _is_resource_supported(struct gl_context *ctx, GLenum target,
484                        GLenum internalformat, GLenum pname)
485 {
486    /* From the ARB_internalformat_query2 spec:
487     *
488     * In the following descriptions, the term /resource/ is used to generically
489     * refer to an object of the appropriate type that has been created with
490     * <internalformat> and <target>.  If the particular <target> and
491     * <internalformat> combination do not make sense, ... the "unsupported"
492     * answer should be given. This is not an error.
493     */
494 
495    /* In the ARB_internalformat_query2 spec wording, some <pnames> do not care
496     * about the /resource/ being supported or not, we return 'true' for those.
497     */
498    switch (pname) {
499    case GL_INTERNALFORMAT_SUPPORTED:
500    case GL_INTERNALFORMAT_PREFERRED:
501    case GL_COLOR_COMPONENTS:
502    case GL_DEPTH_COMPONENTS:
503    case GL_STENCIL_COMPONENTS:
504    case GL_COLOR_RENDERABLE:
505    case GL_DEPTH_RENDERABLE:
506    case GL_STENCIL_RENDERABLE:
507       return true;
508    default:
509       break;
510    }
511 
512    switch(target){
513    case GL_TEXTURE_1D:
514    case GL_TEXTURE_1D_ARRAY:
515    case GL_TEXTURE_2D:
516    case GL_TEXTURE_2D_ARRAY:
517    case GL_TEXTURE_3D:
518    case GL_TEXTURE_CUBE_MAP:
519    case GL_TEXTURE_CUBE_MAP_ARRAY:
520    case GL_TEXTURE_RECTANGLE:
521       /* Based on what Mesa does for glTexImage1D/2D/3D and
522        * glCompressedTexImage1D/2D/3D functions.
523        */
524       if (_mesa_base_tex_format(ctx, internalformat) < 0)
525          return false;
526 
527       /* additional checks for depth textures */
528       if (!_mesa_legal_texture_base_format_for_target(ctx, target, internalformat))
529          return false;
530 
531       /* additional checks for compressed textures */
532       if (_mesa_is_compressed_format(ctx, internalformat) &&
533           !_mesa_target_can_be_compressed(ctx, target, internalformat, NULL))
534          return false;
535 
536       break;
537    case GL_TEXTURE_2D_MULTISAMPLE:
538    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
539       /* Based on what Mesa does for glTexImage2D/3DMultisample,
540        * glTexStorage2D/3DMultisample and
541        * glTextureStorage2D/3DMultisample functions.
542        */
543       if (!_mesa_is_renderable_texture_format(ctx, internalformat))
544          return false;
545 
546       break;
547    case GL_TEXTURE_BUFFER:
548       /* Based on what Mesa does for the glTexBuffer function. */
549       if (_mesa_validate_texbuffer_format(ctx, internalformat) ==
550           MESA_FORMAT_NONE)
551          return false;
552 
553       break;
554    case GL_RENDERBUFFER:
555       /* Based on what Mesa does for glRenderbufferStorage(Multisample) and
556        * glNamedRenderbufferStorage functions.
557        */
558       if (!_mesa_base_fbo_format(ctx, internalformat))
559          return false;
560 
561       break;
562    default:
563       unreachable("bad target");
564    }
565 
566    return true;
567 }
568 
569 static bool
_is_internalformat_supported(struct gl_context * ctx,GLenum target,GLenum internalformat)570 _is_internalformat_supported(struct gl_context *ctx, GLenum target,
571                              GLenum internalformat)
572 {
573    /* From the ARB_internalformat_query2 specification:
574     *
575     *     "- INTERNALFORMAT_SUPPORTED: If <internalformat> is an internal format
576     *     that is supported by the implementation in at least some subset of
577     *     possible operations, TRUE is written to <params>.  If <internalformat>
578     *     if not a valid token for any internal format usage, FALSE is returned.
579     *
580     *     <internalformats> that must be supported (in GL 4.2 or later) include
581     *      the following:
582     *         - "sized internal formats" from Table 3.12, 3.13, and 3.15,
583     *         - any specific "compressed internal format" from Table 3.14,
584     *         - any "image unit format" from Table 3.21.
585     *         - any generic "compressed internal format" from Table 3.14, if the
586     *         implementation accepts it for any texture specification commands, and
587     *         - unsized or base internal format, if the implementation accepts
588     *         it for texture or image specification.
589     *
590     * But also:
591     * "If the particualar <target> and <internalformat> combination do not make
592     * sense, or if a particular type of <target> is not supported by the
593     * implementation the "unsupported" answer should be given. This is not an
594     * error.
595     */
596    GLint buffer[1];
597 
598    if (target == GL_RENDERBUFFER) {
599       if (_mesa_base_fbo_format(ctx, internalformat) == 0) {
600          return false;
601       }
602    } else if (target == GL_TEXTURE_BUFFER) {
603       if (_mesa_validate_texbuffer_format(ctx, internalformat) ==
604           MESA_FORMAT_NONE) {
605          return false;
606       }
607    } else {
608       if (_mesa_base_tex_format(ctx, internalformat) < 0) {
609          return false;
610       }
611    }
612 
613    /* Let the driver have the final word */
614    st_QueryInternalFormat(ctx, target, internalformat,
615                           GL_INTERNALFORMAT_SUPPORTED, buffer);
616 
617    return (buffer[0] == GL_TRUE);
618 }
619 
620 static bool
_legal_target_for_framebuffer_texture_layer(struct gl_context * ctx,GLenum target)621 _legal_target_for_framebuffer_texture_layer(struct gl_context *ctx,
622                                             GLenum target)
623 {
624    switch (target) {
625    case GL_TEXTURE_3D:
626    case GL_TEXTURE_1D_ARRAY:
627    case GL_TEXTURE_2D_ARRAY:
628    case GL_TEXTURE_CUBE_MAP_ARRAY:
629    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
630    case GL_TEXTURE_CUBE_MAP:
631       return true;
632    default:
633       return false;
634    }
635 }
636 
637 static GLenum
_mesa_generic_type_for_internal_format(GLenum internalFormat)638 _mesa_generic_type_for_internal_format(GLenum internalFormat)
639 {
640    if (_mesa_is_enum_format_unsigned_int(internalFormat))
641       return GL_UNSIGNED_BYTE;
642    else if (_mesa_is_enum_format_signed_int(internalFormat))
643       return GL_BYTE;
644    else
645       return GL_FLOAT;
646 }
647 
648 /* default implementation of QueryInternalFormat driverfunc, for
649  * drivers not implementing ARB_internalformat_query2.
650  */
651 void
_mesa_query_internal_format_default(struct gl_context * ctx,GLenum target,GLenum internalFormat,GLenum pname,GLint * params)652 _mesa_query_internal_format_default(struct gl_context *ctx, GLenum target,
653                                     GLenum internalFormat, GLenum pname,
654                                     GLint *params)
655 {
656    (void) target;
657 
658    switch (pname) {
659    case GL_SAMPLES:
660    case GL_NUM_SAMPLE_COUNTS:
661       params[0] = 1;
662       break;
663 
664    case GL_INTERNALFORMAT_SUPPORTED:
665       params[0] = GL_TRUE;
666       break;
667 
668    case GL_INTERNALFORMAT_PREFERRED:
669       params[0] = internalFormat;
670       break;
671 
672    case GL_READ_PIXELS_FORMAT: {
673       GLenum base_format = _mesa_base_tex_format(ctx, internalFormat);
674       switch (base_format) {
675       case GL_STENCIL_INDEX:
676       case GL_DEPTH_COMPONENT:
677       case GL_DEPTH_STENCIL:
678       case GL_RED:
679       case GL_RGB:
680       case GL_BGR:
681       case GL_RGBA:
682       case GL_BGRA:
683          params[0] = base_format;
684          break;
685       default:
686          params[0] = GL_NONE;
687          break;
688       }
689       break;
690    }
691 
692    case GL_READ_PIXELS_TYPE:
693    case GL_TEXTURE_IMAGE_TYPE:
694    case GL_GET_TEXTURE_IMAGE_TYPE: {
695       GLenum base_format = _mesa_base_tex_format(ctx, internalFormat);
696       if (base_format > 0)
697          params[0] = _mesa_generic_type_for_internal_format(internalFormat);
698       else
699          params[0] = GL_NONE;
700       break;
701    }
702 
703    case GL_TEXTURE_IMAGE_FORMAT:
704    case GL_GET_TEXTURE_IMAGE_FORMAT: {
705       GLenum format = GL_NONE;
706       GLenum base_format = _mesa_base_tex_format(ctx, internalFormat);
707       if (base_format > 0) {
708          if (_mesa_is_enum_format_integer(internalFormat))
709            format = _mesa_base_format_to_integer_format(base_format);
710          else
711            format = base_format;
712       }
713 
714       params[0] = format;
715       break;
716    }
717 
718    case GL_MANUAL_GENERATE_MIPMAP:
719    case GL_AUTO_GENERATE_MIPMAP:
720    case GL_SRGB_READ:
721    case GL_SRGB_WRITE:
722    case GL_SRGB_DECODE_ARB:
723    case GL_VERTEX_TEXTURE:
724    case GL_TESS_CONTROL_TEXTURE:
725    case GL_TESS_EVALUATION_TEXTURE:
726    case GL_GEOMETRY_TEXTURE:
727    case GL_FRAGMENT_TEXTURE:
728    case GL_COMPUTE_TEXTURE:
729    case GL_SHADER_IMAGE_LOAD:
730    case GL_SHADER_IMAGE_STORE:
731    case GL_SHADER_IMAGE_ATOMIC:
732    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
733    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
734    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
735    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
736    case GL_CLEAR_BUFFER:
737    case GL_TEXTURE_VIEW:
738    case GL_TEXTURE_SHADOW:
739    case GL_TEXTURE_GATHER:
740    case GL_TEXTURE_GATHER_SHADOW:
741    case GL_FRAMEBUFFER_RENDERABLE:
742    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
743    case GL_FRAMEBUFFER_BLEND:
744    case GL_FILTER:
745       /*
746        * TODO seems a tad optimistic just saying yes to everything here.
747        * Even for combinations which make no sense...
748        * And things like TESS_CONTROL_TEXTURE should definitely default to
749        * NONE if the driver doesn't even support tessellation...
750        */
751       params[0] = GL_FULL_SUPPORT;
752       break;
753    case GL_NUM_TILING_TYPES_EXT:
754       params[0] = 2;
755       break;
756    case GL_TILING_TYPES_EXT:
757       params[0] = GL_OPTIMAL_TILING_EXT;
758       params[1] = GL_LINEAR_TILING_EXT;
759       break;
760 
761    default:
762       _set_default_response(pname, params);
763       break;
764    }
765 }
766 
767 /*
768  * For MAX_WIDTH/MAX_HEIGHT/MAX_DEPTH it returns the equivalent GetInteger
769  * pname for a Getinternalformat pname/target combination. target/pname
770  * combinations that would return 0 due dimension number or unsupported status
771  * should be already filtered out
772  *
773  * Note that this means that the returned value would be independent of the
774  * internalformat. This possibility is already mentioned at the Issue 7 of the
775  * arb_internalformat_query2 spec.
776  */
777 static GLenum
_equivalent_size_pname(GLenum target,GLenum pname)778 _equivalent_size_pname(GLenum target,
779                        GLenum pname)
780 {
781    switch (target) {
782    case GL_TEXTURE_1D:
783    case GL_TEXTURE_2D:
784    case GL_TEXTURE_2D_MULTISAMPLE:
785       return GL_MAX_TEXTURE_SIZE;
786    case GL_TEXTURE_3D:
787       return GL_MAX_3D_TEXTURE_SIZE;
788    case GL_TEXTURE_CUBE_MAP:
789       return GL_MAX_CUBE_MAP_TEXTURE_SIZE;
790    case GL_TEXTURE_RECTANGLE:
791       return GL_MAX_RECTANGLE_TEXTURE_SIZE;
792    case GL_RENDERBUFFER:
793       return GL_MAX_RENDERBUFFER_SIZE;
794    case GL_TEXTURE_1D_ARRAY:
795       if (pname == GL_MAX_HEIGHT)
796          return GL_MAX_ARRAY_TEXTURE_LAYERS;
797       else
798          return GL_MAX_TEXTURE_SIZE;
799    case GL_TEXTURE_2D_ARRAY:
800    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
801       if (pname == GL_MAX_DEPTH)
802          return GL_MAX_ARRAY_TEXTURE_LAYERS;
803       else
804          return GL_MAX_TEXTURE_SIZE;
805    case GL_TEXTURE_CUBE_MAP_ARRAY:
806       if (pname == GL_MAX_DEPTH)
807          return GL_MAX_ARRAY_TEXTURE_LAYERS;
808       else
809          return GL_MAX_CUBE_MAP_TEXTURE_SIZE;
810    case GL_TEXTURE_BUFFER:
811       return GL_MAX_TEXTURE_BUFFER_SIZE;
812    default:
813       return 0;
814    }
815 }
816 
817 /*
818  * Returns the dimensions associated to a target. GL_TEXTURE_BUFFER and
819  * GL_RENDERBUFFER have associated a dimension, but they are not textures
820  * per-se, so we can't just call _mesa_get_texture_dimension directly.
821  */
822 static GLint
_get_target_dimensions(GLenum target)823 _get_target_dimensions(GLenum target)
824 {
825    switch(target) {
826    case GL_TEXTURE_BUFFER:
827       return 1;
828    case GL_RENDERBUFFER:
829       return 2;
830    default:
831       return _mesa_get_texture_dimensions(target);
832    }
833 }
834 
835 /*
836  * Returns the minimum amount of dimensions associated to a pname. So for
837  * example, if querying GL_MAX_HEIGHT, it is assumed that your target would
838  * have as minimum 2 dimensions.
839  *
840  * Useful to handle sentences like this from query2 spec:
841  *
842  * "MAX_HEIGHT:
843  *  <skip>
844  *  If the resource does not have at least two dimensions
845  *  <skip>."
846  */
847 static GLint
_get_min_dimensions(GLenum pname)848 _get_min_dimensions(GLenum pname)
849 {
850    switch(pname) {
851    case GL_MAX_WIDTH:
852       return 1;
853    case GL_MAX_HEIGHT:
854       return 2;
855    case GL_MAX_DEPTH:
856       return 3;
857    default:
858       return 0;
859    }
860 }
861 
862 /*
863  * Similar to teximage.c:check_multisample_target, but independent of the
864  * dimensions.
865  */
866 bool
_mesa_is_multisample_target(GLenum target)867 _mesa_is_multisample_target(GLenum target)
868 {
869    switch(target) {
870    case GL_TEXTURE_2D_MULTISAMPLE:
871    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
872       return true;
873    default:
874       return false;
875    }
876 
877 }
878 
879 void GLAPIENTRY
_mesa_GetInternalformativ(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint * params)880 _mesa_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
881                           GLsizei bufSize, GLint *params)
882 {
883    GLint buffer[16];
884    GET_CURRENT_CONTEXT(ctx);
885 
886    ASSERT_OUTSIDE_BEGIN_END(ctx);
887 
888    /* ARB_internalformat_query is also mandatory for ARB_internalformat_query2 */
889    if (!(_mesa_has_ARB_internalformat_query(ctx) ||
890          _mesa_is_gles3(ctx))) {
891       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInternalformativ");
892       return;
893    }
894 
895    if (!_legal_parameters(ctx, target, internalformat, pname, bufSize, params))
896       return;
897 
898    /* initialize the contents of the temporary buffer */
899    memcpy(buffer, params, MIN2(bufSize, 16) * sizeof(GLint));
900 
901    /* Use the 'unsupported' response defined by the spec for every pname
902     * as the default answer.
903     */
904    _set_default_response(pname, buffer);
905 
906    if (!_is_target_supported(ctx, target) ||
907        !_is_internalformat_supported(ctx, target, internalformat) ||
908        !_is_resource_supported(ctx, target, internalformat, pname))
909       goto end;
910 
911    switch (pname) {
912    case GL_SAMPLES:
913       FALLTHROUGH;
914    case GL_NUM_SAMPLE_COUNTS:
915       /* The ARB_internalformat_query2 sets the response as 'unsupported' for
916        * SAMPLES and NUM_SAMPLE_COUNTS:
917        *
918        *     "If <internalformat> is not color-renderable, depth-renderable, or
919        *     stencil-renderable (as defined in section 4.4.4), or if <target>
920        *     does not support multiple samples (ie other than
921        *     TEXTURE_2D_MULTISAMPLE,  TEXTURE_2D_MULTISAMPLE_ARRAY,
922        *     or RENDERBUFFER)."
923        */
924       if ((target != GL_RENDERBUFFER &&
925            target != GL_TEXTURE_2D_MULTISAMPLE &&
926            target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY) ||
927           !_is_renderable(ctx, internalformat))
928          goto end;
929 
930       /* The GL ES 3.0 specification, section 6.1.15 page 236 says:
931        *
932        *     "Since multisampling is not supported for signed and unsigned
933        *     integer internal formats, the value of NUM_SAMPLE_COUNTS will be
934        *     zero for such formats.
935        *
936        * Since OpenGL ES 3.1 adds support for multisampled integer formats, we
937        * have to check the version for 30 exactly.
938        */
939       if (pname == GL_NUM_SAMPLE_COUNTS && ctx->API == API_OPENGLES2 &&
940           ctx->Version == 30 && _mesa_is_enum_format_integer(internalformat)) {
941          goto end;
942       }
943 
944       st_QueryInternalFormat(ctx, target, internalformat, pname,
945                              buffer);
946       break;
947 
948    case GL_INTERNALFORMAT_SUPPORTED:
949       /* Having a supported <internalformat> is implemented as a prerequisite
950        * for all the <pnames>. Thus,  if we reach this point, the internalformat is
951        * supported.
952        */
953       buffer[0] = GL_TRUE;
954       break;
955 
956    case GL_INTERNALFORMAT_PREFERRED:
957       /* The ARB_internalformat_query2 spec says:
958        *
959        *     "- INTERNALFORMAT_PREFERRED: The implementation-preferred internal
960        *     format for representing resources of the specified <internalformat> is
961        *     returned in <params>.
962        *
963        * Therefore, we let the driver answer. Note that if we reach this
964        * point, it means that the internalformat is supported, so the driver
965        * is called just to try to get a preferred format. If not supported,
966        * GL_NONE was already returned and the driver is not called.
967        */
968       st_QueryInternalFormat(ctx, target, internalformat, pname,
969                              buffer);
970       break;
971 
972    case GL_INTERNALFORMAT_RED_SIZE:
973    case GL_INTERNALFORMAT_GREEN_SIZE:
974    case GL_INTERNALFORMAT_BLUE_SIZE:
975    case GL_INTERNALFORMAT_ALPHA_SIZE:
976    case GL_INTERNALFORMAT_DEPTH_SIZE:
977    case GL_INTERNALFORMAT_STENCIL_SIZE:
978    case GL_INTERNALFORMAT_SHARED_SIZE:
979    case GL_INTERNALFORMAT_RED_TYPE:
980    case GL_INTERNALFORMAT_GREEN_TYPE:
981    case GL_INTERNALFORMAT_BLUE_TYPE:
982    case GL_INTERNALFORMAT_ALPHA_TYPE:
983    case GL_INTERNALFORMAT_DEPTH_TYPE:
984    case GL_INTERNALFORMAT_STENCIL_TYPE: {
985       GLint baseformat;
986       mesa_format texformat;
987 
988       if (target != GL_RENDERBUFFER) {
989          baseformat = _mesa_base_tex_format(ctx, internalformat);
990       } else {
991          baseformat = _mesa_base_fbo_format(ctx, internalformat);
992       }
993 
994       /* Let the driver choose the texture format.
995        *
996        * Disclaimer: I am considering that drivers use for renderbuffers the
997        * same format-choice logic as for textures.
998        */
999       texformat = st_ChooseTextureFormat(ctx, target, internalformat,
1000                                          GL_NONE /*format */, GL_NONE /* type */);
1001 
1002       if (texformat == MESA_FORMAT_NONE || baseformat <= 0)
1003          goto end;
1004 
1005       /* Implementation based on what Mesa does for glGetTexLevelParameteriv
1006        * and glGetRenderbufferParameteriv functions.
1007        */
1008       if (pname == GL_INTERNALFORMAT_SHARED_SIZE) {
1009          if (texformat == MESA_FORMAT_R9G9B9E5_FLOAT) {
1010             buffer[0] = 5;
1011          }
1012          goto end;
1013       }
1014 
1015       if (!_mesa_base_format_has_channel(baseformat, pname))
1016          goto end;
1017 
1018       switch (pname) {
1019       case GL_INTERNALFORMAT_DEPTH_SIZE:
1020          if (!_mesa_is_desktop_gl(ctx) &&
1021              target != GL_RENDERBUFFER &&
1022              target != GL_TEXTURE_BUFFER)
1023             goto end;
1024          FALLTHROUGH;
1025       case GL_INTERNALFORMAT_RED_SIZE:
1026       case GL_INTERNALFORMAT_GREEN_SIZE:
1027       case GL_INTERNALFORMAT_BLUE_SIZE:
1028       case GL_INTERNALFORMAT_ALPHA_SIZE:
1029       case GL_INTERNALFORMAT_STENCIL_SIZE:
1030          buffer[0] = _mesa_get_format_bits(texformat, pname);
1031          break;
1032 
1033       case GL_INTERNALFORMAT_DEPTH_TYPE:
1034          if (!_mesa_has_ARB_texture_float(ctx))
1035             goto end;
1036          FALLTHROUGH;
1037       case GL_INTERNALFORMAT_RED_TYPE:
1038       case GL_INTERNALFORMAT_GREEN_TYPE:
1039       case GL_INTERNALFORMAT_BLUE_TYPE:
1040       case GL_INTERNALFORMAT_ALPHA_TYPE:
1041       case GL_INTERNALFORMAT_STENCIL_TYPE:
1042          buffer[0]  = _mesa_get_format_datatype(texformat);
1043          break;
1044 
1045       default:
1046          break;
1047 
1048       }
1049       break;
1050    }
1051 
1052       /* For WIDTH/HEIGHT/DEPTH/LAYERS there is no reason to think that the
1053        * returned values should be different to the values returned by
1054        * GetInteger with MAX_TEXTURE_SIZE, MAX_3D_TEXTURE_SIZE, etc.*/
1055    case GL_MAX_WIDTH:
1056    case GL_MAX_HEIGHT:
1057    case GL_MAX_DEPTH: {
1058       GLenum get_pname;
1059       GLint dimensions;
1060       GLint min_dimensions;
1061 
1062       /* From query2:MAX_HEIGHT spec (as example):
1063        *
1064        * "If the resource does not have at least two dimensions, or if the
1065        * resource is unsupported, zero is returned."
1066        */
1067       dimensions = _get_target_dimensions(target);
1068       min_dimensions = _get_min_dimensions(pname);
1069       if (dimensions < min_dimensions)
1070          goto end;
1071 
1072       get_pname = _equivalent_size_pname(target, pname);
1073       if (get_pname == 0)
1074          goto end;
1075 
1076       _mesa_GetIntegerv(get_pname, buffer);
1077       break;
1078    }
1079 
1080    case GL_MAX_LAYERS:
1081       if (!_mesa_has_EXT_texture_array(ctx))
1082          goto end;
1083 
1084       if (!_mesa_is_array_texture(target))
1085          goto end;
1086 
1087       _mesa_GetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, buffer);
1088       break;
1089 
1090    case GL_MAX_COMBINED_DIMENSIONS:{
1091       GLint64 combined_value = 1;
1092       GLenum max_dimensions_pnames[] = {
1093          GL_MAX_WIDTH,
1094          GL_MAX_HEIGHT,
1095          GL_MAX_DEPTH,
1096          GL_SAMPLES
1097       };
1098       unsigned i;
1099       GLint current_value;
1100 
1101       /* Combining the dimensions. Note that for array targets, this would
1102        * automatically include the value of MAX_LAYERS, as that value is
1103        * returned as MAX_HEIGHT or MAX_DEPTH */
1104       for (i = 0; i < 4; i++) {
1105          if (max_dimensions_pnames[i] == GL_SAMPLES &&
1106              !_mesa_is_multisample_target(target))
1107             continue;
1108 
1109          _mesa_GetInternalformativ(target, internalformat,
1110                                    max_dimensions_pnames[i],
1111                                    1, &current_value);
1112 
1113          if (current_value != 0)
1114             combined_value *= current_value;
1115       }
1116 
1117       if (_mesa_is_cube_map_texture(target))
1118          combined_value *= 6;
1119 
1120       /* We pack the 64-bit value on two 32-bit values. Calling the 32-bit
1121        * query, this would work as far as the value can be hold on a 32-bit
1122        * signed integer. For the 64-bit query, the wrapper around the 32-bit
1123        * query will unpack the value */
1124       memcpy(buffer, &combined_value, sizeof(GLint64));
1125       break;
1126    }
1127 
1128    case GL_COLOR_COMPONENTS:
1129       /* The ARB_internalformat_query2 spec says:
1130        *
1131        *     "- COLOR_COMPONENTS: If the internal format contains any color
1132        *     components (R, G, B, or A), TRUE is returned in <params>.
1133        *     If the internal format is unsupported or contains no color
1134        *     components, FALSE is returned."
1135        */
1136       if (_mesa_is_color_format(internalformat))
1137          buffer[0] = GL_TRUE;
1138       break;
1139 
1140    case GL_DEPTH_COMPONENTS:
1141       /* The ARB_internalformat_query2 spec says:
1142        *
1143        *     "- DEPTH_COMPONENTS: If the internal format contains a depth
1144        *     component (D), TRUE is returned in <params>. If the internal format
1145        *     is unsupported or contains no depth component, FALSE is returned."
1146        */
1147       if (_mesa_is_depth_format(internalformat) ||
1148           _mesa_is_depthstencil_format(internalformat))
1149          buffer[0] = GL_TRUE;
1150       break;
1151 
1152    case GL_STENCIL_COMPONENTS:
1153       /* The ARB_internalformat_query2 spec says:
1154        *
1155        *     "- STENCIL_COMPONENTS: If the internal format contains a stencil
1156        *     component (S), TRUE is returned in <params>. If the internal format
1157        *     is unsupported or contains no stencil component, FALSE is returned.
1158        */
1159       if (_mesa_is_stencil_format(internalformat) ||
1160           _mesa_is_depthstencil_format(internalformat))
1161          buffer[0] = GL_TRUE;
1162       break;
1163 
1164    case GL_COLOR_RENDERABLE:
1165    case GL_DEPTH_RENDERABLE:
1166    case GL_STENCIL_RENDERABLE:
1167       if (!_is_renderable(ctx, internalformat))
1168          goto end;
1169 
1170       if (pname == GL_COLOR_RENDERABLE) {
1171          if (!_mesa_is_color_format(internalformat))
1172             goto end;
1173       } else {
1174          GLenum baseFormat = _mesa_base_fbo_format(ctx, internalformat);
1175          if (baseFormat != GL_DEPTH_STENCIL &&
1176              ((pname == GL_DEPTH_RENDERABLE && baseFormat != GL_DEPTH_COMPONENT) ||
1177               (pname == GL_STENCIL_RENDERABLE && baseFormat != GL_STENCIL_INDEX)))
1178             goto end;
1179       }
1180 
1181       buffer[0] = GL_TRUE;
1182       break;
1183 
1184    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
1185       if (!_mesa_has_EXT_texture_array(ctx) ||
1186           _legal_target_for_framebuffer_texture_layer(ctx, target))
1187          goto end;
1188       FALLTHROUGH;
1189    case GL_FRAMEBUFFER_RENDERABLE:
1190    case GL_FRAMEBUFFER_BLEND:
1191       if (!_mesa_has_ARB_framebuffer_object(ctx))
1192          goto end;
1193 
1194       if (target == GL_TEXTURE_BUFFER ||
1195           !_is_renderable(ctx, internalformat))
1196          goto end;
1197 
1198       st_QueryInternalFormat(ctx, target, internalformat, pname,
1199                              buffer);
1200       break;
1201 
1202    case GL_READ_PIXELS:
1203    case GL_READ_PIXELS_FORMAT:
1204    case GL_READ_PIXELS_TYPE:
1205       st_QueryInternalFormat(ctx, target, internalformat, pname,
1206                              buffer);
1207       break;
1208 
1209    case GL_TEXTURE_IMAGE_FORMAT:
1210    case GL_GET_TEXTURE_IMAGE_FORMAT:
1211    case GL_TEXTURE_IMAGE_TYPE:
1212    case GL_GET_TEXTURE_IMAGE_TYPE:
1213       st_QueryInternalFormat(ctx, target, internalformat, pname,
1214                              buffer);
1215       break;
1216 
1217    case GL_MIPMAP:
1218    case GL_MANUAL_GENERATE_MIPMAP:
1219    case GL_AUTO_GENERATE_MIPMAP:
1220       if (!_mesa_is_valid_generate_texture_mipmap_target(ctx, target) ||
1221           !_mesa_is_valid_generate_texture_mipmap_internalformat(ctx,
1222                                                               internalformat)) {
1223          goto end;
1224       }
1225 
1226       if (pname == GL_MIPMAP) {
1227          buffer[0] = GL_TRUE;
1228          goto end;
1229       }
1230       else if (pname == GL_MANUAL_GENERATE_MIPMAP) {
1231          if (!_mesa_has_ARB_framebuffer_object(ctx))
1232             goto end;
1233       }
1234       else {
1235          /* From ARB_internalformat_query2:
1236           *    "Dependencies on OpenGL 3.2 (Core Profile)
1237           *     In core profiles for OpenGL 3.2 and later versions, queries
1238           *     for the AUTO_GENERATE_MIPMAP <pname> return the appropriate
1239           *     unsupported response."
1240           */
1241          if (_mesa_is_desktop_gl(ctx) && ctx->Version >= 32)
1242             goto end;
1243       }
1244 
1245       st_QueryInternalFormat(ctx, target, internalformat, pname,
1246                              buffer);
1247       break;
1248 
1249    case GL_COLOR_ENCODING:
1250       if (!_mesa_is_color_format(internalformat))
1251          goto end;
1252 
1253       if (_mesa_is_srgb_format(internalformat))
1254          buffer[0] = GL_SRGB;
1255       else
1256          buffer[0] = GL_LINEAR;
1257       break;
1258 
1259    case GL_SRGB_READ:
1260       if (!_mesa_has_EXT_texture_sRGB(ctx) ||
1261           !_mesa_is_srgb_format(internalformat)) {
1262          goto end;
1263       }
1264 
1265       st_QueryInternalFormat(ctx, target, internalformat, pname,
1266                              buffer);
1267       break;
1268 
1269    case GL_SRGB_WRITE:
1270       if (!ctx->Extensions.EXT_sRGB ||
1271           !_mesa_is_color_format(internalformat)) {
1272          goto end;
1273       }
1274 
1275       st_QueryInternalFormat(ctx, target, internalformat, pname,
1276                              buffer);
1277       break;
1278 
1279    case GL_SRGB_DECODE_ARB:
1280       /* Presence of EXT_texture_sRGB_decode was already verified */
1281       if (!_mesa_has_EXT_texture_sRGB(ctx) ||
1282           target == GL_RENDERBUFFER ||
1283           !_mesa_is_srgb_format(internalformat)) {
1284          goto end;
1285       }
1286 
1287       st_QueryInternalFormat(ctx, target, internalformat, pname,
1288                              buffer);
1289       break;
1290 
1291    case GL_FILTER:
1292       /* If it doesn't allow to set sampler parameters then it would not allow
1293        * to set a filter different to GL_NEAREST. In practice, this method
1294        * only filters out MULTISAMPLE/MULTISAMPLE_ARRAY */
1295       if (!_mesa_target_allows_setting_sampler_parameters(target))
1296          goto end;
1297 
1298       if (_mesa_is_enum_format_integer(internalformat))
1299          goto end;
1300 
1301       if (target == GL_TEXTURE_BUFFER)
1302          goto end;
1303 
1304       /* At this point we know that multi-texel filtering is supported. We
1305        * need to call the driver to know if it is CAVEAT_SUPPORT or
1306        * FULL_SUPPORT.
1307        */
1308       st_QueryInternalFormat(ctx, target, internalformat, pname,
1309                              buffer);
1310       break;
1311 
1312    case GL_VERTEX_TEXTURE:
1313    case GL_TESS_CONTROL_TEXTURE:
1314    case GL_TESS_EVALUATION_TEXTURE:
1315    case GL_GEOMETRY_TEXTURE:
1316    case GL_FRAGMENT_TEXTURE:
1317    case GL_COMPUTE_TEXTURE:
1318       if (target == GL_RENDERBUFFER)
1319          goto end;
1320 
1321       if ((pname == GL_TESS_CONTROL_TEXTURE ||
1322            pname == GL_TESS_EVALUATION_TEXTURE) &&
1323           !_mesa_has_tessellation(ctx))
1324          goto end;
1325 
1326       if (pname == GL_GEOMETRY_TEXTURE && !_mesa_has_geometry_shaders(ctx))
1327          goto end;
1328 
1329       if (pname == GL_COMPUTE_TEXTURE && !_mesa_has_compute_shaders(ctx))
1330          goto end;
1331 
1332       st_QueryInternalFormat(ctx, target, internalformat, pname,
1333                              buffer);
1334       break;
1335 
1336    case GL_TEXTURE_GATHER:
1337    case GL_TEXTURE_GATHER_SHADOW:
1338       if (!_mesa_has_ARB_texture_gather(ctx))
1339          goto end;
1340 
1341       FALLTHROUGH;
1342    case GL_TEXTURE_SHADOW:
1343       /* Only depth or depth-stencil image formats make sense in shadow
1344          samplers */
1345       if (pname != GL_TEXTURE_GATHER &&
1346           !_mesa_is_depth_format(internalformat) &&
1347           !_mesa_is_depthstencil_format(internalformat))
1348          goto end;
1349 
1350       /* Validate the target for shadow and gather operations */
1351       switch (target) {
1352       case GL_TEXTURE_2D:
1353       case GL_TEXTURE_2D_ARRAY:
1354       case GL_TEXTURE_CUBE_MAP:
1355       case GL_TEXTURE_CUBE_MAP_ARRAY:
1356       case GL_TEXTURE_RECTANGLE:
1357          break;
1358 
1359       case GL_TEXTURE_1D:
1360       case GL_TEXTURE_1D_ARRAY:
1361          /* 1D and 1DArray textures are not admitted in gather operations */
1362          if (pname != GL_TEXTURE_SHADOW)
1363             goto end;
1364          break;
1365 
1366       default:
1367          goto end;
1368       }
1369 
1370       st_QueryInternalFormat(ctx, target, internalformat, pname,
1371                              buffer);
1372       break;
1373 
1374    case GL_SHADER_IMAGE_LOAD:
1375    case GL_SHADER_IMAGE_STORE:
1376       if (!_mesa_has_ARB_shader_image_load_store(ctx))
1377          goto end;
1378 
1379       /* We call to _mesa_is_shader_image_format_supported
1380        * using "internalformat" as parameter, because the
1381        * the ARB_internalformat_query2 spec says:
1382        * "In this case the <internalformat> is the value of the <format>
1383        * parameter that is passed to BindImageTexture."
1384        */
1385       if (target == GL_RENDERBUFFER ||
1386           !_mesa_is_shader_image_format_supported(ctx, internalformat))
1387          goto end;
1388 
1389       st_QueryInternalFormat(ctx, target, internalformat, pname,
1390                              buffer);
1391       break;
1392 
1393    case GL_SHADER_IMAGE_ATOMIC:
1394       if (!_mesa_has_ARB_shader_image_load_store(ctx))
1395          goto end;
1396 
1397       st_QueryInternalFormat(ctx, target, internalformat, pname,
1398                              buffer);
1399       break;
1400 
1401    case GL_IMAGE_TEXEL_SIZE: {
1402       mesa_format image_format;
1403 
1404       if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
1405           target == GL_RENDERBUFFER)
1406          goto end;
1407 
1408       image_format = _mesa_get_shader_image_format(internalformat);
1409       if (image_format == MESA_FORMAT_NONE)
1410          goto end;
1411 
1412       /* We return bits */
1413       buffer[0] = (_mesa_get_format_bytes(image_format) * 8);
1414       break;
1415    }
1416 
1417    case GL_IMAGE_COMPATIBILITY_CLASS:
1418       if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
1419           target == GL_RENDERBUFFER)
1420          goto end;
1421 
1422       buffer[0] = _mesa_get_image_format_class(internalformat);
1423       break;
1424 
1425    case GL_IMAGE_PIXEL_FORMAT: {
1426       GLint base_format;
1427 
1428       if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
1429           target == GL_RENDERBUFFER ||
1430           !_mesa_is_shader_image_format_supported(ctx, internalformat))
1431          goto end;
1432 
1433       base_format = _mesa_base_tex_format(ctx, internalformat);
1434       if (base_format == -1)
1435          goto end;
1436 
1437       if (_mesa_is_enum_format_integer(internalformat))
1438          buffer[0] = _mesa_base_format_to_integer_format(base_format);
1439       else
1440          buffer[0] = base_format;
1441       break;
1442    }
1443 
1444    case GL_IMAGE_PIXEL_TYPE: {
1445       mesa_format image_format;
1446       GLenum datatype;
1447       GLuint comps;
1448 
1449       if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
1450           target == GL_RENDERBUFFER)
1451          goto end;
1452 
1453       image_format = _mesa_get_shader_image_format(internalformat);
1454       if (image_format == MESA_FORMAT_NONE)
1455          goto end;
1456 
1457       _mesa_uncompressed_format_to_type_and_comps(image_format, &datatype,
1458                                                   &comps);
1459       if (!datatype)
1460          goto end;
1461 
1462       buffer[0] = datatype;
1463       break;
1464    }
1465 
1466    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE: {
1467       if (!_mesa_has_ARB_shader_image_load_store(ctx))
1468          goto end;
1469 
1470       /* As pointed by the spec quote below, this pname query should return
1471        * the same value that GetTexParameter. So if the target is not valid
1472        * for GetTexParameter we return the unsupported value. The check below
1473        * is the same target check used by GetTexParameter.
1474        */
1475       int targetIndex = _mesa_tex_target_to_index(ctx, target);
1476       if (targetIndex < 0 || targetIndex == TEXTURE_BUFFER_INDEX)
1477          goto end;
1478 
1479       /* From spec: "Equivalent to calling GetTexParameter with <value> set
1480        * to IMAGE_FORMAT_COMPATIBILITY_TYPE."
1481        *
1482        * GetTexParameter just returns
1483        * tex_obj->ImageFormatCompatibilityType. We create a fake tex_obj
1484        * just with the purpose of getting the value.
1485        */
1486       struct gl_texture_object *tex_obj = _mesa_new_texture_object(ctx, 0, target);
1487       buffer[0] = tex_obj->Attrib.ImageFormatCompatibilityType;
1488       _mesa_delete_texture_object(ctx, tex_obj);
1489 
1490       break;
1491    }
1492 
1493    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
1494    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
1495    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
1496    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
1497       if (target == GL_RENDERBUFFER)
1498          goto end;
1499 
1500       if (!_mesa_is_depthstencil_format(internalformat)) {
1501          if (((pname == GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST ||
1502                pname == GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE) &&
1503               !_mesa_is_depth_format(internalformat)) ||
1504              ((pname == GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST ||
1505                pname == GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE) &&
1506               !_mesa_is_stencil_format(internalformat)))
1507             goto end;
1508       }
1509 
1510       st_QueryInternalFormat(ctx, target, internalformat, pname,
1511                              buffer);
1512       break;
1513 
1514    case GL_TEXTURE_COMPRESSED:
1515       buffer[0] = _mesa_is_compressed_format(ctx, internalformat);
1516       break;
1517 
1518    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
1519    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
1520    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE: {
1521       mesa_format mesaformat;
1522       GLint block_size;
1523 
1524       mesaformat = _mesa_glenum_to_compressed_format(internalformat);
1525       if (mesaformat == MESA_FORMAT_NONE)
1526          goto end;
1527 
1528       block_size = _mesa_get_format_bytes(mesaformat);
1529       assert(block_size > 0);
1530 
1531       if (pname == GL_TEXTURE_COMPRESSED_BLOCK_SIZE) {
1532          buffer[0] = block_size;
1533       } else {
1534          GLuint bwidth, bheight;
1535 
1536          /* Returns the width and height in pixels. We return bytes */
1537          _mesa_get_format_block_size(mesaformat, &bwidth, &bheight);
1538          assert(bwidth > 0 && bheight > 0);
1539 
1540          if (pname == GL_TEXTURE_COMPRESSED_BLOCK_WIDTH)
1541             buffer[0] = block_size / bheight;
1542          else
1543             buffer[0] = block_size / bwidth;
1544       }
1545       break;
1546    }
1547 
1548    case GL_CLEAR_BUFFER:
1549       if (target != GL_TEXTURE_BUFFER)
1550          goto end;
1551 
1552       st_QueryInternalFormat(ctx, target, internalformat, pname,
1553                                       buffer);
1554       break;
1555 
1556    case GL_TEXTURE_VIEW:
1557    case GL_VIEW_COMPATIBILITY_CLASS:
1558       if (!_mesa_has_ARB_texture_view(ctx) ||
1559           target == GL_TEXTURE_BUFFER ||
1560           target == GL_RENDERBUFFER)
1561          goto end;
1562 
1563       if (pname == GL_TEXTURE_VIEW) {
1564          st_QueryInternalFormat(ctx, target, internalformat, pname,
1565                                 buffer);
1566       } else {
1567          GLenum view_class = _mesa_texture_view_lookup_view_class(ctx,
1568                                                                   internalformat);
1569          if (view_class == GL_FALSE)
1570             goto end;
1571 
1572          buffer[0] = view_class;
1573       }
1574       break;
1575 
1576    case GL_NUM_TILING_TYPES_EXT:
1577    case GL_TILING_TYPES_EXT:
1578       st_QueryInternalFormat(ctx, target, internalformat, pname,
1579                              buffer);
1580       break;
1581 
1582    case GL_TEXTURE_REDUCTION_MODE_ARB:
1583       if (ctx->Extensions.EXT_texture_filter_minmax)
1584          buffer[0] = (GLint)1;
1585       else if (ctx->Extensions.ARB_texture_filter_minmax)
1586          st_QueryInternalFormat(ctx, target, internalformat, pname,
1587                                 buffer);
1588       else
1589          buffer[0] = (GLint)0;
1590       break;
1591 
1592    case GL_NUM_VIRTUAL_PAGE_SIZES_ARB:
1593    case GL_VIRTUAL_PAGE_SIZE_X_ARB:
1594    case GL_VIRTUAL_PAGE_SIZE_Y_ARB:
1595    case GL_VIRTUAL_PAGE_SIZE_Z_ARB:
1596       st_QueryInternalFormat(ctx, target, internalformat, pname, buffer);
1597       break;
1598 
1599    default:
1600       unreachable("bad param");
1601    }
1602 
1603  end:
1604    if (bufSize != 0 && params == NULL) {
1605       /* Emit a warning to aid application debugging, but go ahead and do the
1606        * memcpy (and probably crash) anyway.
1607        */
1608       _mesa_warning(ctx,
1609                     "glGetInternalformativ(bufSize = %d, but params = NULL)",
1610                     bufSize);
1611    }
1612 
1613    /* Copy the data from the temporary buffer to the buffer supplied by the
1614     * application.  Clamp the size of the copy to the size supplied by the
1615     * application.
1616     */
1617    memcpy(params, buffer, MIN2(bufSize, 16) * sizeof(GLint));
1618 
1619    return;
1620 }
1621 
1622 void GLAPIENTRY
_mesa_GetInternalformati64v(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint64 * params)1623 _mesa_GetInternalformati64v(GLenum target, GLenum internalformat,
1624                             GLenum pname, GLsizei bufSize, GLint64 *params)
1625 {
1626    GLint params32[16];
1627    unsigned i;
1628    GLsizei realSize = MIN2(bufSize, 16);
1629    GLsizei callSize;
1630 
1631    GET_CURRENT_CONTEXT(ctx);
1632 
1633    ASSERT_OUTSIDE_BEGIN_END(ctx);
1634 
1635    if (!_mesa_has_ARB_internalformat_query2(ctx)) {
1636       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInternalformati64v");
1637       return;
1638    }
1639 
1640    /* For SAMPLES there are cases where params needs to remain unmodified. As
1641     * no pname can return a negative value, we fill params32 with negative
1642     * values as reference values, that can be used to know what copy-back to
1643     * params */
1644    for (i = 0; i < realSize; i++)
1645       params32[i] = -1;
1646 
1647    /* For GL_MAX_COMBINED_DIMENSIONS we need to get back 2 32-bit integers,
1648     * and at the same time we only need 2. So for that pname, we call the
1649     * 32-bit query with bufSize 2, except on the case of bufSize 0, that is
1650     * basically like asking to not get the value, but that is a caller
1651     * problem. */
1652    if (pname == GL_MAX_COMBINED_DIMENSIONS && bufSize > 0)
1653       callSize = 2;
1654    else
1655       callSize = bufSize;
1656 
1657    _mesa_GetInternalformativ(target, internalformat, pname, callSize, params32);
1658 
1659    if (pname == GL_MAX_COMBINED_DIMENSIONS) {
1660       memcpy(params, params32, sizeof(GLint64));
1661    } else {
1662       for (i = 0; i < realSize; i++) {
1663          /* We only copy back the values that changed */
1664          if (params32[i] < 0)
1665             break;
1666          params[i] = (GLint64) params32[i];
1667       }
1668    }
1669 }
1670