src/mesa/main/formatquery.c

   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
  34 static bool
  35 _is_renderable(struct gl_context *ctx, GLenum internalformat)
  36 {
  37    /*  Section 4.4.4 on page 212 of the  GLES 3.0.4 spec says:
  38     *
  39     *     "An internal format is color-renderable if it is one of the
  40     *     formats from table 3.13 noted as color-renderable or if it
  41     *     is unsized format RGBA or RGB."
  42     *
  43     * Therefore, we must accept GL_RGB and GL_RGBA here.
  44     */
  45    if (internalformat != GL_RGB && internalformat != GL_RGBA &&
  46        _mesa_base_fbo_format(ctx, internalformat) == 0)
  47       return false;
  48
  49    return true;
  50 }
  51
  52 /* Handles the cases where either ARB_internalformat_query or
  53  * ARB_internalformat_query2 have to return an error.
  54  */
  55 static bool
  56 _legal_parameters(struct gl_context *ctx, GLenum target, GLenum internalformat,
  57                   GLenum pname, GLsizei bufSize, GLint *params)
  58
  59 {
  60    bool query2 = _mesa_has_ARB_internalformat_query2(ctx);
  61
  62    /* The ARB_internalformat_query2 spec says:
  63     *
  64     *    "The INVALID_ENUM error is generated if the <target> parameter to
  65     *    GetInternalformati*v is not one of the targets listed in Table 6.xx.
  66     */
  67    switch(target){
  68    case GL_TEXTURE_1D:
  69    case GL_TEXTURE_1D_ARRAY:
  70    case GL_TEXTURE_2D:
  71    case GL_TEXTURE_2D_ARRAY:
  72    case GL_TEXTURE_3D:
  73    case GL_TEXTURE_CUBE_MAP:
  74    case GL_TEXTURE_CUBE_MAP_ARRAY:
  75    case GL_TEXTURE_RECTANGLE:
  76    case GL_TEXTURE_BUFFER:
  77       if (!query2) {
  78          /* The ARB_internalformat_query spec says:
  79           *
  80           *     "If the <target> parameter to GetInternalformativ is not one of
  81           *      TEXTURE_2D_MULTISAMPLE, TEXTURE_2D_MULTISAMPLE_ARRAY
  82           *      or RENDERBUFFER then an INVALID_ENUM error is generated.
  83           */
  84          _mesa_error(ctx, GL_INVALID_ENUM,
  85                      "glGetInternalformativ(target=%s)",
  86                      _mesa_enum_to_string(target));
  87
  88          return false;
  89       }
  90       break;
  91
  92    case GL_RENDERBUFFER:
  93       break;
  94
  95    case GL_TEXTURE_2D_MULTISAMPLE:
  96    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
  97       /* The non-existence of ARB_texture_multisample is treated in
  98        * ARB_internalformat_query implementation like an error.
  99        */
 100       if (!query2 &&
 101           !(_mesa_has_ARB_texture_multisample(ctx) || _mesa_is_gles31(ctx))) {
 102          _mesa_error(ctx, GL_INVALID_ENUM,
 103                      "glGetInternalformativ(target=%s)",
 104                      _mesa_enum_to_string(target));
 105
 106          return false;
 107       }
 108       break;
 109
 110    default:
 111       _mesa_error(ctx, GL_INVALID_ENUM,
 112                   "glGetInternalformativ(target=%s)",
 113                   _mesa_enum_to_string(target));
 114       return false;
 115    }
 116
 117
 118    /* The ARB_internalformat_query2 spec says:
 119     *
 120     *     "The INVALID_ENUM error is generated if the <pname> parameter is
 121     *     not one of the listed possibilities.
 122     */
 123    switch(pname){
 124    case GL_SAMPLES:
 125    case GL_NUM_SAMPLE_COUNTS:
 126       break;
 127
 128    case GL_SRGB_DECODE_ARB:
 129       /* The ARB_internalformat_query2 spec says:
 130        *
 131        *     "If ARB_texture_sRGB_decode or EXT_texture_sRGB_decode or
 132        *     equivalent functionality is not supported, queries for the
 133        *     SRGB_DECODE_ARB <pname> set the INVALID_ENUM error.
 134        */
 135       if (!_mesa_has_EXT_texture_sRGB_decode(ctx)) {
 136          _mesa_error(ctx, GL_INVALID_ENUM,
 137                      "glGetInternalformativ(pname=%s)",
 138                      _mesa_enum_to_string(pname));
 139          return false;
 140       }
 141       /* fallthrough */
 142    case GL_INTERNALFORMAT_SUPPORTED:
 143    case GL_INTERNALFORMAT_PREFERRED:
 144    case GL_INTERNALFORMAT_RED_SIZE:
 145    case GL_INTERNALFORMAT_GREEN_SIZE:
 146    case GL_INTERNALFORMAT_BLUE_SIZE:
 147    case GL_INTERNALFORMAT_ALPHA_SIZE:
 148    case GL_INTERNALFORMAT_DEPTH_SIZE:
 149    case GL_INTERNALFORMAT_STENCIL_SIZE:
 150    case GL_INTERNALFORMAT_SHARED_SIZE:
 151    case GL_INTERNALFORMAT_RED_TYPE:
 152    case GL_INTERNALFORMAT_GREEN_TYPE:
 153    case GL_INTERNALFORMAT_BLUE_TYPE:
 154    case GL_INTERNALFORMAT_ALPHA_TYPE:
 155    case GL_INTERNALFORMAT_DEPTH_TYPE:
 156    case GL_INTERNALFORMAT_STENCIL_TYPE:
 157    case GL_MAX_WIDTH:
 158    case GL_MAX_HEIGHT:
 159    case GL_MAX_DEPTH:
 160    case GL_MAX_LAYERS:
 161    case GL_MAX_COMBINED_DIMENSIONS:
 162    case GL_COLOR_COMPONENTS:
 163    case GL_DEPTH_COMPONENTS:
 164    case GL_STENCIL_COMPONENTS:
 165    case GL_COLOR_RENDERABLE:
 166    case GL_DEPTH_RENDERABLE:
 167    case GL_STENCIL_RENDERABLE:
 168    case GL_FRAMEBUFFER_RENDERABLE:
 169    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
 170    case GL_FRAMEBUFFER_BLEND:
 171    case GL_READ_PIXELS:
 172    case GL_READ_PIXELS_FORMAT:
 173    case GL_READ_PIXELS_TYPE:
 174    case GL_TEXTURE_IMAGE_FORMAT:
 175    case GL_TEXTURE_IMAGE_TYPE:
 176    case GL_GET_TEXTURE_IMAGE_FORMAT:
 177    case GL_GET_TEXTURE_IMAGE_TYPE:
 178    case GL_MIPMAP:
 179    case GL_MANUAL_GENERATE_MIPMAP:
 180    case GL_AUTO_GENERATE_MIPMAP:
 181    case GL_COLOR_ENCODING:
 182    case GL_SRGB_READ:
 183    case GL_SRGB_WRITE:
 184    case GL_FILTER:
 185    case GL_VERTEX_TEXTURE:
 186    case GL_TESS_CONTROL_TEXTURE:
 187    case GL_TESS_EVALUATION_TEXTURE:
 188    case GL_GEOMETRY_TEXTURE:
 189    case GL_FRAGMENT_TEXTURE:
 190    case GL_COMPUTE_TEXTURE:
 191    case GL_TEXTURE_SHADOW:
 192    case GL_TEXTURE_GATHER:
 193    case GL_TEXTURE_GATHER_SHADOW:
 194    case GL_SHADER_IMAGE_LOAD:
 195    case GL_SHADER_IMAGE_STORE:
 196    case GL_SHADER_IMAGE_ATOMIC:
 197    case GL_IMAGE_TEXEL_SIZE:
 198    case GL_IMAGE_COMPATIBILITY_CLASS:
 199    case GL_IMAGE_PIXEL_FORMAT:
 200    case GL_IMAGE_PIXEL_TYPE:
 201    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
 202    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
 203    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
 204    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
 205    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
 206    case GL_TEXTURE_COMPRESSED:
 207    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
 208    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
 209    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE:
 210    case GL_CLEAR_BUFFER:
 211    case GL_TEXTURE_VIEW:
 212    case GL_VIEW_COMPATIBILITY_CLASS:
 213       /* The ARB_internalformat_query spec says:
 214        *
 215        *     "If the <pname> parameter to GetInternalformativ is not SAMPLES
 216        *     or NUM_SAMPLE_COUNTS, then an INVALID_ENUM error is generated."
 217        */
 218       if (!query2) {
 219          _mesa_error(ctx, GL_INVALID_ENUM,
 220                      "glGetInternalformativ(pname=%s)",
 221                      _mesa_enum_to_string(pname));
 222
 223          return false;
 224       }
 225       break;
 226
 227    default:
 228       _mesa_error(ctx, GL_INVALID_ENUM,
 229                   "glGetInternalformativ(pname=%s)",
 230                   _mesa_enum_to_string(pname));
 231       return false;
 232    }
 233
 234    /* The ARB_internalformat_query spec says:
 235     *
 236     *     "If the <bufSize> parameter to GetInternalformativ is negative, then
 237     *     an INVALID_VALUE error is generated."
 238     *
 239     * Nothing is said in ARB_internalformat_query2 but we assume the same.
 240     */
 241    if (bufSize < 0) {
 242       _mesa_error(ctx, GL_INVALID_VALUE,
 243                   "glGetInternalformativ(target=%s)",
 244                   _mesa_enum_to_string(target));
 245       return false;
 246    }
 247
 248    /* The ARB_internalformat_query spec says:
 249     *
 250     *     "If the <internalformat> parameter to GetInternalformativ is not
 251     *     color-, depth- or stencil-renderable, then an INVALID_ENUM error is
 252     *     generated."
 253     */
 254    if (!query2 && !_is_renderable(ctx, internalformat)) {
 255       _mesa_error(ctx, GL_INVALID_ENUM,
 256                   "glGetInternalformativ(internalformat=%s)",
 257                   _mesa_enum_to_string(internalformat));
 258       return false;
 259    }
 260
 261    return true;
 262 }
 263
 264 /* Sets the appropriate "unsupported" response as defined by the
 265  * ARB_internalformat_query2 spec for each each <pname>.
 266  */
 267 static void
 268 _set_default_response(GLenum pname, GLint buffer[16])
 269 {
 270    /* The ARB_internalformat_query2 defines which is the reponse best
 271     * representing "not supported" or "not applicable" for each <pname>.
 272     *
 273     *     " In general:
 274     *          - size- or count-based queries will return zero,
 275     *          - support-, format- or type-based queries will return NONE,
 276     *          - boolean-based queries will return FALSE, and
 277     *          - list-based queries return no entries."
 278     */
 279    switch(pname) {
 280    case GL_SAMPLES:
 281       break;
 282
 283    case GL_MAX_COMBINED_DIMENSIONS:
 284    case GL_NUM_SAMPLE_COUNTS:
 285    case GL_INTERNALFORMAT_RED_SIZE:
 286    case GL_INTERNALFORMAT_GREEN_SIZE:
 287    case GL_INTERNALFORMAT_BLUE_SIZE:
 288    case GL_INTERNALFORMAT_ALPHA_SIZE:
 289    case GL_INTERNALFORMAT_DEPTH_SIZE:
 290    case GL_INTERNALFORMAT_STENCIL_SIZE:
 291    case GL_INTERNALFORMAT_SHARED_SIZE:
 292    case GL_MAX_WIDTH:
 293    case GL_MAX_HEIGHT:
 294    case GL_MAX_DEPTH:
 295    case GL_MAX_LAYERS:
 296    case GL_IMAGE_TEXEL_SIZE:
 297    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
 298    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
 299    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE:
 300       buffer[0] = 0;
 301       break;
 302
 303    case GL_INTERNALFORMAT_PREFERRED:
 304    case GL_INTERNALFORMAT_RED_TYPE:
 305    case GL_INTERNALFORMAT_GREEN_TYPE:
 306    case GL_INTERNALFORMAT_BLUE_TYPE:
 307    case GL_INTERNALFORMAT_ALPHA_TYPE:
 308    case GL_INTERNALFORMAT_DEPTH_TYPE:
 309    case GL_INTERNALFORMAT_STENCIL_TYPE:
 310    case GL_FRAMEBUFFER_RENDERABLE:
 311    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
 312    case GL_FRAMEBUFFER_BLEND:
 313    case GL_READ_PIXELS:
 314    case GL_READ_PIXELS_FORMAT:
 315    case GL_READ_PIXELS_TYPE:
 316    case GL_TEXTURE_IMAGE_FORMAT:
 317    case GL_TEXTURE_IMAGE_TYPE:
 318    case GL_GET_TEXTURE_IMAGE_FORMAT:
 319    case GL_GET_TEXTURE_IMAGE_TYPE:
 320    case GL_MANUAL_GENERATE_MIPMAP:
 321    case GL_AUTO_GENERATE_MIPMAP:
 322    case GL_COLOR_ENCODING:
 323    case GL_SRGB_READ:
 324    case GL_SRGB_WRITE:
 325    case GL_SRGB_DECODE_ARB:
 326    case GL_FILTER:
 327    case GL_VERTEX_TEXTURE:
 328    case GL_TESS_CONTROL_TEXTURE:
 329    case GL_TESS_EVALUATION_TEXTURE:
 330    case GL_GEOMETRY_TEXTURE:
 331    case GL_FRAGMENT_TEXTURE:
 332    case GL_COMPUTE_TEXTURE:
 333    case GL_TEXTURE_SHADOW:
 334    case GL_TEXTURE_GATHER:
 335    case GL_TEXTURE_GATHER_SHADOW:
 336    case GL_SHADER_IMAGE_LOAD:
 337    case GL_SHADER_IMAGE_STORE:
 338    case GL_SHADER_IMAGE_ATOMIC:
 339    case GL_IMAGE_COMPATIBILITY_CLASS:
 340    case GL_IMAGE_PIXEL_FORMAT:
 341    case GL_IMAGE_PIXEL_TYPE:
 342    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
 343    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
 344    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
 345    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
 346    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
 347    case GL_CLEAR_BUFFER:
 348    case GL_TEXTURE_VIEW:
 349    case GL_VIEW_COMPATIBILITY_CLASS:
 350       buffer[0] = GL_NONE;
 351       break;
 352
 353    case GL_INTERNALFORMAT_SUPPORTED:
 354    case GL_COLOR_COMPONENTS:
 355    case GL_DEPTH_COMPONENTS:
 356    case GL_STENCIL_COMPONENTS:
 357    case GL_COLOR_RENDERABLE:
 358    case GL_DEPTH_RENDERABLE:
 359    case GL_STENCIL_RENDERABLE:
 360    case GL_MIPMAP:
 361    case GL_TEXTURE_COMPRESSED:
 362       buffer[0] = GL_FALSE;
 363       break;
 364
 365    default:
 366       unreachable("invalid 'pname'");
 367    }
 368 }
 369
 370 static bool
 371 _is_target_supported(struct gl_context *ctx, GLenum target)
 372 {
 373    /* The ARB_internalformat_query2 spec says:
 374     *
 375     *     "if a particular type of <target> is not supported by the
 376     *     implementation the "unsupported" answer should be given.
 377     *     This is not an error."
 378     */
 379    switch(target){
 380    case GL_TEXTURE_2D:
 381    case GL_TEXTURE_3D:
 382       break;
 383
 384    case GL_TEXTURE_1D:
 385       if (!_mesa_is_desktop_gl(ctx))
 386          return false;
 387       break;
 388
 389    case GL_TEXTURE_1D_ARRAY:
 390       if (!_mesa_has_EXT_texture_array(ctx))
 391          return false;
 392       break;
 393
 394    case GL_TEXTURE_2D_ARRAY:
 395       if (!(_mesa_has_EXT_texture_array(ctx) || _mesa_is_gles3(ctx)))
 396          return false;
 397       break;
 398
 399    case GL_TEXTURE_CUBE_MAP:
 400       if (!_mesa_has_ARB_texture_cube_map(ctx))
 401          return false;
 402       break;
 403
 404    case GL_TEXTURE_CUBE_MAP_ARRAY:
 405       if (!_mesa_has_ARB_texture_cube_map_array(ctx))
 406          return false;
 407       break;
 408
 409    case GL_TEXTURE_RECTANGLE:
 410       if (!_mesa_has_NV_texture_rectangle(ctx))
 411           return false;
 412       break;
 413
 414    case GL_TEXTURE_BUFFER:
 415       if (!_mesa_has_ARB_texture_buffer_object(ctx))
 416          return false;
 417       break;
 418
 419    case GL_RENDERBUFFER:
 420       if (!(_mesa_has_ARB_framebuffer_object(ctx) ||
 421             _mesa_is_gles3(ctx)))
 422          return false;
 423       break;
 424
 425    case GL_TEXTURE_2D_MULTISAMPLE:
 426    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
 427       if (!(_mesa_has_ARB_texture_multisample(ctx) ||
 428             _mesa_is_gles31(ctx)))
 429          return false;
 430       break;
 431
 432    default:
 433       unreachable("invalid target");
 434    }
 435
 436    return true;
 437 }
 438
 439 static bool
 440 _is_resource_supported(struct gl_context *ctx, GLenum target,
 441                        GLenum internalformat, GLenum pname)
 442 {
 443    /* From the ARB_internalformat_query2 spec:
 444     *
 445     * In the following descriptions, the term /resource/ is used to generically
 446     * refer to an object of the appropriate type that has been created with
 447     * <internalformat> and <target>.  If the particular <target> and
 448     * <internalformat> combination do not make sense, ... the "unsupported"
 449     * answer should be given. This is not an error.
 450     */
 451
 452    /* In the ARB_internalformat_query2 spec wording, some <pnames> do not care
 453     * about the /resource/ being supported or not, we return 'true' for those.
 454     */
 455    switch (pname) {
 456    case GL_INTERNALFORMAT_SUPPORTED:
 457    case GL_INTERNALFORMAT_PREFERRED:
 458    case GL_COLOR_COMPONENTS:
 459    case GL_DEPTH_COMPONENTS:
 460    case GL_STENCIL_COMPONENTS:
 461    case GL_COLOR_RENDERABLE:
 462    case GL_DEPTH_RENDERABLE:
 463    case GL_STENCIL_RENDERABLE:
 464       return true;
 465    default:
 466       break;
 467    }
 468
 469    switch(target){
 470    case GL_TEXTURE_1D:
 471    case GL_TEXTURE_1D_ARRAY:
 472    case GL_TEXTURE_2D:
 473    case GL_TEXTURE_2D_ARRAY:
 474    case GL_TEXTURE_3D:
 475    case GL_TEXTURE_CUBE_MAP:
 476    case GL_TEXTURE_CUBE_MAP_ARRAY:
 477    case GL_TEXTURE_RECTANGLE:
 478       /* Based on what Mesa does for glTexImage1D/2D/3D and
 479        * glCompressedTexImage1D/2D/3D functions.
 480        */
 481       if (_mesa_base_tex_format(ctx, internalformat) < 0)
 482          return false;
 483
 484       /* additional checks for depth textures */
 485       if (!_mesa_legal_texture_base_format_for_target(ctx, target, internalformat))
 486          return false;
 487
 488       /* additional checks for compressed textures */
 489       if (_mesa_is_compressed_format(ctx, internalformat) &&
 490           (!_mesa_target_can_be_compressed(ctx, target, internalformat, NULL) ||
 491            _mesa_format_no_online_compression(ctx, internalformat)))
 492          return false;
 493
 494       break;
 495    case GL_TEXTURE_2D_MULTISAMPLE:
 496    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
 497       /* Based on what Mesa does for glTexImage2D/3DMultisample,
 498        * glTexStorage2D/3DMultisample and
 499        * glTextureStorage2D/3DMultisample functions.
 500        */
 501       if (!_mesa_is_renderable_texture_format(ctx, internalformat))
 502          return false;
 503
 504       break;
 505    case GL_TEXTURE_BUFFER:
 506       /* Based on what Mesa does for the glTexBuffer function. */
 507       if (_mesa_validate_texbuffer_format(ctx, internalformat) ==
 508           MESA_FORMAT_NONE)
 509          return false;
 510
 511       break;
 512    case GL_RENDERBUFFER:
 513       /* Based on what Mesa does for glRenderbufferStorage(Multisample) and
 514        * glNamedRenderbufferStorage functions.
 515        */
 516       if (!_mesa_base_fbo_format(ctx, internalformat))
 517          return false;
 518
 519       break;
 520    default:
 521       unreachable("bad target");
 522    }
 523
 524    return true;
 525 }
 526
 527 static bool
 528 _is_internalformat_supported(struct gl_context *ctx, GLenum target,
 529                              GLenum internalformat)
 530 {
 531    /* From the ARB_internalformat_query2 specification:
 532     *
 533     *     "- INTERNALFORMAT_SUPPORTED: If <internalformat> is an internal format
 534     *     that is supported by the implementation in at least some subset of
 535     *     possible operations, TRUE is written to <params>.  If <internalformat>
 536     *     if not a valid token for any internal format usage, FALSE is returned.
 537     *
 538     *     <internalformats> that must be supported (in GL 4.2 or later) include
 539     *      the following:
 540     *         - "sized internal formats" from Table 3.12, 3.13, and 3.15,
 541     *         - any specific "compressed internal format" from Table 3.14,
 542     *         - any "image unit format" from Table 3.21.
 543     *         - any generic "compressed internal format" from Table 3.14, if the
 544     *         implementation accepts it for any texture specification commands, and
 545     *         - unsized or base internal format, if the implementation accepts
 546     *         it for texture or image specification.
 547     */
 548    GLint buffer[1];
 549
 550    /* At this point a internalformat is valid if it is valid as a texture or
 551     * as a renderbuffer format. The checks are different because those methods
 552     * return different values when passing non supported internalformats */
 553    if (_mesa_base_tex_format(ctx, internalformat) < 0 &&
 554        _mesa_base_fbo_format(ctx, internalformat) == 0)
 555       return false;
 556
 557    /* Let the driver have the final word */
 558    ctx->Driver.QueryInternalFormat(ctx, target, internalformat,
 559                                    GL_INTERNALFORMAT_SUPPORTED, buffer);
 560
 561    return (buffer[0] == GL_TRUE);
 562 }
 563
 564 /* default implementation of QueryInternalFormat driverfunc, for
 565  * drivers not implementing ARB_internalformat_query2.
 566  */
 567 void
 568 _mesa_query_internal_format_default(struct gl_context *ctx, GLenum target,
 569                                     GLenum internalFormat, GLenum pname,
 570                                     GLint *params)
 571 {
 572    (void) ctx;
 573    (void) target;
 574    (void) internalFormat;
 575
 576    switch (pname) {
 577    case GL_SAMPLES:
 578    case GL_NUM_SAMPLE_COUNTS:
 579       params[0] = 1;
 580       break;
 581
 582    case GL_INTERNALFORMAT_SUPPORTED:
 583       params[0] = GL_TRUE;
 584       break;
 585
 586    case GL_INTERNALFORMAT_PREFERRED:
 587       params[0] = internalFormat;
 588       break;
 589
 590    default:
 591       _set_default_response(pname, params);
 592       break;
 593    }
 594 }
 595
 596 void GLAPIENTRY
 597 _mesa_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
 598                           GLsizei bufSize, GLint *params)
 599 {
 600    GLint buffer[16];
 601    GET_CURRENT_CONTEXT(ctx);
 602
 603    ASSERT_OUTSIDE_BEGIN_END(ctx);
 604
 605    /* ARB_internalformat_query is also mandatory for ARB_internalformat_query2 */
 606    if (!(_mesa_has_ARB_internalformat_query(ctx) ||
 607          _mesa_is_gles3(ctx))) {
 608       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInternalformativ");
 609       return;
 610    }
 611
 612    assert(ctx->Driver.QueryInternalFormat != NULL);
 613
 614    if (!_legal_parameters(ctx, target, internalformat, pname, bufSize, params))
 615       return;
 616
 617    /* initialize the contents of the temporary buffer */
 618    memcpy(buffer, params, MIN2(bufSize, 16) * sizeof(GLint));
 619
 620    /* Use the 'unsupported' response defined by the spec for every pname
 621     * as the default answer.
 622     */
 623    _set_default_response(pname, buffer);
 624
 625    if (!_is_target_supported(ctx, target) ||
 626        !_is_internalformat_supported(ctx, target, internalformat) ||
 627        !_is_resource_supported(ctx, target, internalformat, pname))
 628       goto end;
 629
 630    switch (pname) {
 631    case GL_SAMPLES:
 632       /* fall-through */
 633    case GL_NUM_SAMPLE_COUNTS:
 634       /* The ARB_internalformat_query2 sets the response as 'unsupported' for
 635        * SAMPLES and NUM_SAMPLE_COUNTS:
 636        *
 637        *     "If <internalformat> is not color-renderable, depth-renderable, or
 638        *     stencil-renderable (as defined in section 4.4.4), or if <target>
 639        *     does not support multiple samples (ie other than
 640        *     TEXTURE_2D_MULTISAMPLE,  TEXTURE_2D_MULTISAMPLE_ARRAY,
 641        *     or RENDERBUFFER)."
 642        */
 643       if ((target != GL_RENDERBUFFER &&
 644            target != GL_TEXTURE_2D_MULTISAMPLE &&
 645            target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY) ||
 646           !_is_renderable(ctx, internalformat))
 647          goto end;
 648
 649       /* The GL ES 3.0 specification, section 6.1.15 page 236 says:
 650        *
 651        *     "Since multisampling is not supported for signed and unsigned
 652        *     integer internal formats, the value of NUM_SAMPLE_COUNTS will be
 653        *     zero for such formats.
 654        */
 655       if (pname == GL_NUM_SAMPLE_COUNTS && ctx->API == API_OPENGLES2 &&
 656           ctx->Version == 30 && _mesa_is_enum_format_integer(internalformat)) {
 657          goto end;
 658       }
 659
 660       ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
 661                                       buffer);
 662       break;
 663
 664    case GL_INTERNALFORMAT_SUPPORTED:
 665       /* Having a supported <internalformat> is implemented as a prerequisite
 666        * for all the <pnames>. Thus,  if we reach this point, the internalformat is
 667        * supported.
 668        */
 669       buffer[0] = GL_TRUE;
 670       break;
 671
 672    case GL_INTERNALFORMAT_PREFERRED:
 673       /* The ARB_internalformat_query2 spec says:
 674        *
 675        *     "- INTERNALFORMAT_PREFERRED: The implementation-preferred internal
 676        *     format for representing resources of the specified <internalformat> is
 677        *     returned in <params>.
 678        *
 679        * Therefore, we let the driver answer.
 680        */
 681       ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
 682                                       buffer);
 683       break;
 684
 685    case GL_INTERNALFORMAT_RED_SIZE:
 686    case GL_INTERNALFORMAT_GREEN_SIZE:
 687    case GL_INTERNALFORMAT_BLUE_SIZE:
 688    case GL_INTERNALFORMAT_ALPHA_SIZE:
 689    case GL_INTERNALFORMAT_DEPTH_SIZE:
 690    case GL_INTERNALFORMAT_STENCIL_SIZE:
 691    case GL_INTERNALFORMAT_SHARED_SIZE:
 692    case GL_INTERNALFORMAT_RED_TYPE:
 693    case GL_INTERNALFORMAT_GREEN_TYPE:
 694    case GL_INTERNALFORMAT_BLUE_TYPE:
 695    case GL_INTERNALFORMAT_ALPHA_TYPE:
 696    case GL_INTERNALFORMAT_DEPTH_TYPE:
 697    case GL_INTERNALFORMAT_STENCIL_TYPE: {
 698       GLint baseformat;
 699       mesa_format texformat;
 700
 701       if (target != GL_RENDERBUFFER) {
 702          if (!_mesa_legal_get_tex_level_parameter_target(ctx, target, true))
 703             goto end;
 704
 705          baseformat = _mesa_base_tex_format(ctx, internalformat);
 706       } else {
 707          baseformat = _mesa_base_fbo_format(ctx, internalformat);
 708       }
 709
 710       /* Let the driver choose the texture format.
 711        *
 712        * Disclaimer: I am considering that drivers use for renderbuffers the
 713        * same format-choice logic as for textures.
 714        */
 715       texformat = ctx->Driver.ChooseTextureFormat(ctx, target, internalformat,
 716                                                   GL_NONE /*format */, GL_NONE /* type */);
 717
 718       if (texformat == MESA_FORMAT_NONE || baseformat <= 0)
 719          goto end;
 720
 721       /* Implementation based on what Mesa does for glGetTexLevelParameteriv
 722        * and glGetRenderbufferParameteriv functions.
 723        */
 724       if (pname == GL_INTERNALFORMAT_SHARED_SIZE) {
 725          if (_mesa_has_EXT_texture_shared_exponent(ctx) &&
 726              target != GL_TEXTURE_BUFFER &&
 727              target != GL_RENDERBUFFER &&
 728              texformat == MESA_FORMAT_R9G9B9E5_FLOAT) {
 729             buffer[0] = 5;
 730          }
 731          goto end;
 732       }
 733
 734       if (!_mesa_base_format_has_channel(baseformat, pname))
 735          goto end;
 736
 737       switch (pname) {
 738       case GL_INTERNALFORMAT_DEPTH_SIZE:
 739          if (!_mesa_has_ARB_depth_texture(ctx) &&
 740              target != GL_RENDERBUFFER &&
 741              target != GL_TEXTURE_BUFFER)
 742             goto end;
 743          /* fallthrough */
 744       case GL_INTERNALFORMAT_RED_SIZE:
 745       case GL_INTERNALFORMAT_GREEN_SIZE:
 746       case GL_INTERNALFORMAT_BLUE_SIZE:
 747       case GL_INTERNALFORMAT_ALPHA_SIZE:
 748       case GL_INTERNALFORMAT_STENCIL_SIZE:
 749          buffer[0] = _mesa_get_format_bits(texformat, pname);
 750          break;
 751
 752       case GL_INTERNALFORMAT_DEPTH_TYPE:
 753          if (!_mesa_has_ARB_texture_float(ctx))
 754             goto end;
 755          /* fallthrough */
 756       case GL_INTERNALFORMAT_RED_TYPE:
 757       case GL_INTERNALFORMAT_GREEN_TYPE:
 758       case GL_INTERNALFORMAT_BLUE_TYPE:
 759       case GL_INTERNALFORMAT_ALPHA_TYPE:
 760       case GL_INTERNALFORMAT_STENCIL_TYPE:
 761          buffer[0]  = _mesa_get_format_datatype(texformat);
 762          break;
 763
 764       default:
 765          break;
 766
 767       }
 768       break;
 769    }
 770
 771    case GL_MAX_WIDTH:
 772       /* @TODO */
 773       break;
 774
 775    case GL_MAX_HEIGHT:
 776       /* @TODO */
 777       break;
 778
 779    case GL_MAX_DEPTH:
 780       /* @TODO */
 781       break;
 782
 783    case GL_MAX_LAYERS:
 784       /* @TODO */
 785       break;
 786
 787    case GL_MAX_COMBINED_DIMENSIONS:
 788       /* @TODO */
 789       break;
 790
 791    case GL_COLOR_COMPONENTS:
 792       /* @TODO */
 793       break;
 794
 795    case GL_DEPTH_COMPONENTS:
 796       /* @TODO */
 797       break;
 798
 799    case GL_STENCIL_COMPONENTS:
 800       /* @TODO */
 801       break;
 802
 803    case GL_COLOR_RENDERABLE:
 804       /* @TODO */
 805       break;
 806
 807    case GL_DEPTH_RENDERABLE:
 808       /* @TODO */
 809       break;
 810
 811    case GL_STENCIL_RENDERABLE:
 812       /* @TODO */
 813       break;
 814
 815    case GL_FRAMEBUFFER_RENDERABLE:
 816       /* @TODO */
 817       break;
 818
 819    case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
 820       /* @TODO */
 821       break;
 822
 823    case GL_FRAMEBUFFER_BLEND:
 824       /* @TODO */
 825       break;
 826
 827    case GL_READ_PIXELS:
 828       /* @TODO */
 829       break;
 830
 831    case GL_READ_PIXELS_FORMAT:
 832       /* @TODO */
 833       break;
 834
 835    case GL_READ_PIXELS_TYPE:
 836       /* @TODO */
 837       break;
 838
 839    case GL_TEXTURE_IMAGE_FORMAT:
 840       /* @TODO */
 841       break;
 842
 843    case GL_TEXTURE_IMAGE_TYPE:
 844       /* @TODO */
 845       break;
 846
 847    case GL_GET_TEXTURE_IMAGE_FORMAT:
 848       /* @TODO */
 849       break;
 850
 851    case GL_GET_TEXTURE_IMAGE_TYPE:
 852       /* @TODO */
 853       break;
 854
 855    case GL_MIPMAP:
 856       /* @TODO */
 857       break;
 858
 859    case GL_MANUAL_GENERATE_MIPMAP:
 860       /* @TODO */
 861       break;
 862
 863    case GL_AUTO_GENERATE_MIPMAP:
 864       /* @TODO */
 865       break;
 866
 867    case GL_COLOR_ENCODING:
 868       /* @TODO */
 869       break;
 870
 871    case GL_SRGB_READ:
 872       /* @TODO */
 873       break;
 874
 875    case GL_SRGB_WRITE:
 876       /* @TODO */
 877       break;
 878
 879    case GL_SRGB_DECODE_ARB:
 880       /* @TODO */
 881       break;
 882
 883    case GL_FILTER:
 884       /* @TODO */
 885       break;
 886
 887    case GL_VERTEX_TEXTURE:
 888       /* @TODO */
 889       break;
 890
 891    case GL_TESS_CONTROL_TEXTURE:
 892       /* @TODO */
 893       break;
 894
 895    case GL_TESS_EVALUATION_TEXTURE:
 896       /* @TODO */
 897       break;
 898
 899    case GL_GEOMETRY_TEXTURE:
 900       /* @TODO */
 901       break;
 902
 903    case GL_FRAGMENT_TEXTURE:
 904       /* @TODO */
 905       break;
 906
 907    case GL_COMPUTE_TEXTURE:
 908       /* @TODO */
 909       break;
 910
 911    case GL_TEXTURE_SHADOW:
 912       /* @TODO */
 913       break;
 914
 915    case GL_TEXTURE_GATHER:
 916       /* @TODO */
 917       break;
 918
 919    case GL_TEXTURE_GATHER_SHADOW:
 920       /* @TODO */
 921       break;
 922
 923    case GL_SHADER_IMAGE_LOAD:
 924       /* @TODO */
 925       break;
 926
 927    case GL_SHADER_IMAGE_STORE:
 928       /* @TODO */
 929       break;
 930
 931    case GL_SHADER_IMAGE_ATOMIC:
 932       /* @TODO */
 933       break;
 934
 935    case GL_IMAGE_TEXEL_SIZE:
 936       /* @TODO */
 937       break;
 938
 939    case GL_IMAGE_COMPATIBILITY_CLASS:
 940       /* @TODO */
 941       break;
 942
 943    case GL_IMAGE_PIXEL_FORMAT:
 944       /* @TODO */
 945       break;
 946
 947    case GL_IMAGE_PIXEL_TYPE:
 948       /* @TODO */
 949       break;
 950
 951    case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
 952       /* @TODO */
 953       break;
 954
 955    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
 956       /* @TODO */
 957       break;
 958
 959    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
 960       /* @TODO */
 961       break;
 962
 963    case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
 964       /* @TODO */
 965       break;
 966
 967    case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
 968       /* @TODO */
 969       break;
 970
 971    case GL_TEXTURE_COMPRESSED:
 972       /* @TODO */
 973       break;
 974
 975    case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
 976       /* @TODO */
 977       break;
 978
 979    case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
 980       /* @TODO */
 981       break;
 982
 983    case GL_TEXTURE_COMPRESSED_BLOCK_SIZE:
 984       /* @TODO */
 985       break;
 986
 987    case GL_CLEAR_BUFFER:
 988       /* @TODO */
 989       break;
 990
 991    case GL_TEXTURE_VIEW:
 992       /* @TODO */
 993       break;
 994
 995    case GL_VIEW_COMPATIBILITY_CLASS:
 996       /* @TODO */
 997       break;
 998
 999    default:
1000       unreachable("bad param");
1001    }
1002
1003  end:
1004    if (bufSize != 0 && params == NULL) {
1005       /* Emit a warning to aid application debugging, but go ahead and do the
1006        * memcpy (and probably crash) anyway.
1007        */
1008       _mesa_warning(ctx,
1009                     "glGetInternalformativ(bufSize = %d, but params = NULL)",
1010                     bufSize);
1011    }
1012
1013    /* Copy the data from the temporary buffer to the buffer supplied by the
1014     * application.  Clamp the size of the copy to the size supplied by the
1015     * application.
1016     */
1017    memcpy(params, buffer, MIN2(bufSize, 16) * sizeof(GLint));
1018
1019    return;
1020 }
1021
1022 void GLAPIENTRY
1023 _mesa_GetInternalformati64v(GLenum target, GLenum internalformat,
1024                             GLenum pname, GLsizei bufSize, GLint64 *params)
1025 {
1026    GET_CURRENT_CONTEXT(ctx);
1027
1028    ASSERT_OUTSIDE_BEGIN_END(ctx);
1029
1030    if (!_mesa_has_ARB_internalformat_query2(ctx)) {
1031       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInternalformati64v");
1032       return;
1033    }
1034
1035    _mesa_debug(ctx, "glGetInternalformati64v() not implemented");
1036 }