src/mesa/main/extensions.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /**
  28  * \file
  29  * \brief Extension handling
  30  */
  31
  32
  33 #include "glheader.h"
  34 #include "imports.h"
  35 #include "context.h"
  36 #include "extensions.h"
  37 #include "macros.h"
  38 #include "mtypes.h"
  39
  40 struct gl_extensions _mesa_extension_override_enables;
  41 struct gl_extensions _mesa_extension_override_disables;
  42 static char *extra_extensions = NULL;
  43 static char *cant_disable_extensions = NULL;
  44
  45 enum {
  46    DISABLE = 0,
  47    GLL = 1 << API_OPENGL_COMPAT,       /* GL Legacy / Compatibility */
  48    GLC = 1 << API_OPENGL_CORE,  /* GL Core */
  49    GL  = (1 << API_OPENGL_COMPAT) | (1 << API_OPENGL_CORE),
  50    ES1 = 1 << API_OPENGLES,
  51    ES2 = 1 << API_OPENGLES2,
  52 };
  53
  54 /**
  55  * \brief An element of the \c extension_table.
  56  */
  57 struct extension {
  58    /** Name of extension, such as "GL_ARB_depth_clamp". */
  59    const char *name;
  60
  61    /** Offset (in bytes) of the corresponding member in struct gl_extensions. */
  62    size_t offset;
  63
  64    /** Set of API's in which the extension exists, as a bitset. */
  65    uint8_t api_set;
  66
  67    /** Minimum version the extension requires for the given API
  68     * (see gl_api defined in mtypes.h). The value is equal to:
  69     * 10 * major_version + minor_version
  70     */
  71    uint8_t version[API_OPENGL_LAST + 1];
  72
  73    /** Year the extension was proposed or approved.  Used to sort the
  74     * extension string chronologically. */
  75    uint16_t year;
  76 };
  77
  78
  79 /**
  80  * Given a member \c x of struct gl_extensions, return offset of
  81  * \c x in bytes.
  82  */
  83 #define o(x) offsetof(struct gl_extensions, x)
  84
  85
  86 /**
  87  * \brief Table of supported OpenGL extensions for all API's.
  88  */
  89 static const struct extension extension_table[] = {
  90 #define EXT(name_str, driver_cap, api_flags, gll_ver, glc_ver, gles_ver, gles2_ver, yyyy) \
  91         { .name = "GL_" #name_str, .offset = o(driver_cap), .api_set = api_flags, \
  92           .version = { \
  93             [API_OPENGL_COMPAT] = gll_ver, \
  94             [API_OPENGL_CORE]   = glc_ver, \
  95             [API_OPENGLES]      = gles_ver, \
  96             [API_OPENGLES2]     = gles2_ver, \
  97            }, \
  98            .year = yyyy \
  99         },
 100 #include "extensions_table.h"
 101 #undef EXT
 102 };
 103
 104
 105 /**
 106  * Given an extension name, lookup up the corresponding member of struct
 107  * gl_extensions and return that member's offset (in bytes).  If the name is
 108  * not found in the \c extension_table, return 0.
 109  *
 110  * \param name Name of extension.
 111  * \return Offset of member in struct gl_extensions.
 112  */
 113 static size_t
 114 name_to_offset(const char* name)
 115 {
 116    unsigned i;
 117
 118    if (name == 0)
 119       return 0;
 120
 121    for (i = 0; i < ARRAY_SIZE(extension_table); ++i) {
 122       if (strcmp(name, extension_table[i].name) == 0)
 123          return extension_table[i].offset;
 124    }
 125
 126    return 0;
 127 }
 128
 129 /**
 130  * Overrides extensions in \c ctx based on the values in
 131  * _mesa_extension_override_enables and _mesa_extension_override_disables.
 132  */
 133 static void
 134 override_extensions_in_context(struct gl_context *ctx)
 135 {
 136    unsigned i;
 137    const GLboolean *enables =
 138       (GLboolean*) &_mesa_extension_override_enables;
 139    const GLboolean *disables =
 140       (GLboolean*) &_mesa_extension_override_disables;
 141    GLboolean *ctx_ext = (GLboolean*)&ctx->Extensions;
 142
 143    for (i = 0; i < ARRAY_SIZE(extension_table); ++i) {
 144       size_t offset = extension_table[i].offset;
 145
 146       assert(!enables[offset] || !disables[offset]);
 147       if (enables[offset]) {
 148          ctx_ext[offset] = 1;
 149       } else if (disables[offset]) {
 150          ctx_ext[offset] = 0;
 151       }
 152    }
 153 }
 154
 155
 156 /**
 157  * Enable all extensions suitable for a software-only renderer.
 158  * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
 159  */
 160 void
 161 _mesa_enable_sw_extensions(struct gl_context *ctx)
 162 {
 163    ctx->Extensions.ARB_depth_clamp = GL_TRUE;
 164    ctx->Extensions.ARB_depth_texture = GL_TRUE;
 165    ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 166    ctx->Extensions.ARB_draw_instanced = GL_TRUE;
 167    ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
 168    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
 169    ctx->Extensions.ARB_fragment_program = GL_TRUE;
 170    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
 171    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 172    ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
 173    ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
 174    ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
 175    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
 176    ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
 177    ctx->Extensions.ARB_point_sprite = GL_TRUE;
 178    ctx->Extensions.ARB_shadow = GL_TRUE;
 179    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
 180    ctx->Extensions.ARB_texture_compression_bptc = GL_TRUE;
 181    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
 182    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
 183    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
 184    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
 185 #ifdef TEXTURE_FLOAT_ENABLED
 186    ctx->Extensions.ARB_texture_float = GL_TRUE;
 187 #endif
 188    ctx->Extensions.ARB_texture_mirror_clamp_to_edge = GL_TRUE;
 189    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
 190    ctx->Extensions.ARB_texture_rg = GL_TRUE;
 191    ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
 192    ctx->Extensions.ARB_vertex_program = GL_TRUE;
 193    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 194    ctx->Extensions.ARB_sync = GL_TRUE;
 195    ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
 196    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
 197    ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
 198    ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
 199    ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
 200    ctx->Extensions.ATI_separate_stencil = GL_TRUE;
 201    ctx->Extensions.EXT_blend_color = GL_TRUE;
 202    ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
 203    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
 204    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
 205    ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
 206    ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
 207    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
 208    ctx->Extensions.EXT_point_parameters = GL_TRUE;
 209    ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
 210    ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
 211    ctx->Extensions.EXT_texture_array = GL_TRUE;
 212    ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
 213    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
 214    ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
 215    ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
 216    ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
 217    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 218    ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
 219    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
 220    /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
 221    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
 222    ctx->Extensions.MESA_pack_invert = GL_TRUE;
 223    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
 224    ctx->Extensions.NV_conditional_render = GL_TRUE;
 225    ctx->Extensions.NV_point_sprite = GL_TRUE;
 226    ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
 227    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
 228    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
 229    ctx->Extensions.OES_standard_derivatives = GL_TRUE;
 230    ctx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
 231    if (ctx->Mesa_DXTn) {
 232       ctx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
 233       ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
 234    }
 235 }
 236
 237 /**
 238  * Either enable or disable the named extension.
 239  * \return offset of extensions withint `ext' or 0 if extension is not known
 240  */
 241 static size_t
 242 set_extension(struct gl_extensions *ext, const char *name, GLboolean state)
 243 {
 244    size_t offset;
 245
 246    offset = name_to_offset(name);
 247    if (offset != 0 && (offset != o(dummy_true) || state != GL_FALSE)) {
 248       ((GLboolean *) ext)[offset] = state;
 249    }
 250
 251    return offset;
 252 }
 253
 254 /**
 255  * \brief Apply the \c MESA_EXTENSION_OVERRIDE environment variable.
 256  *
 257  * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
 258  * enable or disable. The list is processed thus:
 259  *    - Enable recognized extension names that are prefixed with '+'.
 260  *    - Disable recognized extension names that are prefixed with '-'.
 261  *    - Enable recognized extension names that are not prefixed.
 262  *    - Collect unrecognized extension names in a new string.
 263  *
 264  * \c MESA_EXTENSION_OVERRIDE was previously parsed during
 265  * _mesa_one_time_init_extension_overrides. We just use the results of that
 266  * parsing in this function.
 267  *
 268  * \return Space-separated list of unrecognized extension names (which must
 269  *    be freed). Does not return \c NULL.
 270  */
 271 static char *
 272 get_extension_override( struct gl_context *ctx )
 273 {
 274    override_extensions_in_context(ctx);
 275
 276    if (cant_disable_extensions != NULL) {
 277       _mesa_problem(ctx,
 278                     "Trying to disable permanently enabled extensions: %s",
 279                     cant_disable_extensions);
 280    }
 281
 282    if (extra_extensions == NULL) {
 283       return calloc(1, sizeof(char));
 284    } else {
 285       _mesa_problem(ctx, "Trying to enable unknown extensions: %s",
 286                     extra_extensions);
 287       return strdup(extra_extensions);
 288    }
 289 }
 290
 291
 292 /**
 293  * \brief Free extra_extensions and cant_disable_extensions strings
 294  *
 295  * These strings are allocated early during the first context creation by
 296  * _mesa_one_time_init_extension_overrides.
 297  */
 298 static void
 299 free_unknown_extensions_strings(void)
 300 {
 301    free(extra_extensions);
 302    free(cant_disable_extensions);
 303 }
 304
 305
 306 /**
 307  * \brief Initialize extension override tables.
 308  *
 309  * This should be called one time early during first context initialization.
 310  */
 311 void
 312 _mesa_one_time_init_extension_overrides(void)
 313 {
 314    const char *env_const = getenv("MESA_EXTENSION_OVERRIDE");
 315    char *env;
 316    char *ext;
 317    int len;
 318    size_t offset;
 319
 320    atexit(free_unknown_extensions_strings);
 321
 322    memset(&_mesa_extension_override_enables, 0, sizeof(struct gl_extensions));
 323    memset(&_mesa_extension_override_disables, 0, sizeof(struct gl_extensions));
 324
 325    if (env_const == NULL) {
 326       return;
 327    }
 328
 329    /* extra_exts: List of unrecognized extensions. */
 330    extra_extensions = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
 331    cant_disable_extensions = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
 332
 333    /* Copy env_const because strtok() is destructive. */
 334    env = strdup(env_const);
 335
 336    if (env == NULL || extra_extensions == NULL ||
 337            cant_disable_extensions == NULL) {
 338        free(env);
 339        free(extra_extensions);
 340        free(cant_disable_extensions);
 341        return;
 342    }
 343
 344    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
 345       int enable;
 346       bool recognized;
 347       switch (ext[0]) {
 348       case '+':
 349          enable = 1;
 350          ++ext;
 351          break;
 352       case '-':
 353          enable = 0;
 354          ++ext;
 355          break;
 356       default:
 357          enable = 1;
 358          break;
 359       }
 360
 361       offset = set_extension(&_mesa_extension_override_enables, ext, enable);
 362       if (offset != 0 && (offset != o(dummy_true) || enable != GL_FALSE)) {
 363          ((GLboolean *) &_mesa_extension_override_disables)[offset] = !enable;
 364          recognized = true;
 365       } else {
 366          recognized = false;
 367       }
 368
 369       if (!recognized) {
 370          if (enable) {
 371             strcat(extra_extensions, ext);
 372             strcat(extra_extensions, " ");
 373          } else if (offset == o(dummy_true)) {
 374             strcat(cant_disable_extensions, ext);
 375             strcat(cant_disable_extensions, " ");
 376          }
 377       }
 378    }
 379
 380    free(env);
 381
 382    /* Remove trailing space, and free if unused. */
 383    len = strlen(extra_extensions);
 384    if (len == 0) {
 385       free(extra_extensions);
 386       extra_extensions = NULL;
 387    } else if (extra_extensions[len - 1] == ' ') {
 388       extra_extensions[len - 1] = '\0';
 389    }
 390    len = strlen(cant_disable_extensions);
 391    if (len == 0) {
 392       free(cant_disable_extensions);
 393       cant_disable_extensions = NULL;
 394    } else if (cant_disable_extensions[len - 1] == ' ') {
 395       cant_disable_extensions[len - 1] = '\0';
 396    }
 397 }
 398
 399
 400 /**
 401  * \brief Initialize extension tables and enable default extensions.
 402  *
 403  * This should be called during context initialization.
 404  * Note: Sets gl_extensions.dummy_true to true.
 405  */
 406 void
 407 _mesa_init_extensions(struct gl_extensions *extensions)
 408 {
 409    GLboolean *base = (GLboolean *) extensions;
 410    GLboolean *sentinel = base + o(extension_sentinel);
 411    GLboolean *i;
 412
 413    /* First, turn all extensions off. */
 414    for (i = base; i != sentinel; ++i)
 415       *i = GL_FALSE;
 416
 417    /* Then, selectively turn default extensions on. */
 418    extensions->dummy_true = GL_TRUE;
 419    extensions->EXT_texture3D = GL_TRUE;
 420 }
 421
 422
 423 typedef unsigned short extension_index;
 424
 425
 426 /**
 427  * Given an extension enum, return whether or not the extension is supported
 428  * dependent on the following factors:
 429  * There's driver support and the OpenGL/ES version is at least that
 430  * specified in the extension_table.
 431  */
 432 static inline bool
 433 _mesa_extension_supported(const struct gl_context *ctx, extension_index i)
 434 {
 435    const bool *base = (bool *) &ctx->Extensions;
 436    const struct extension *ext = extension_table + i;
 437    const uint8_t api_bit = 1 << ctx->API;
 438
 439    return (ext->api_set & api_bit) &&
 440           (ctx->Version >= ext->version[ctx->API]) &&
 441           base[ext->offset];
 442 }
 443
 444 /**
 445  * Compare two entries of the extensions table.  Sorts first by year,
 446  * then by name.
 447  *
 448  * Arguments are indices into extension_table.
 449  */
 450 static int
 451 extension_compare(const void *p1, const void *p2)
 452 {
 453    extension_index i1 = * (const extension_index *) p1;
 454    extension_index i2 = * (const extension_index *) p2;
 455    const struct extension *e1 = &extension_table[i1];
 456    const struct extension *e2 = &extension_table[i2];
 457    int res;
 458
 459    res = (int)e1->year - (int)e2->year;
 460
 461    if (res == 0) {
 462       res = strcmp(e1->name, e2->name);
 463    }
 464
 465    return res;
 466 }
 467
 468
 469 /**
 470  * Construct the GL_EXTENSIONS string.  Called the first time that
 471  * glGetString(GL_EXTENSIONS) is called.
 472  */
 473 GLubyte*
 474 _mesa_make_extension_string(struct gl_context *ctx)
 475 {
 476    /* The extension string. */
 477    char *exts = 0;
 478    /* Length of extension string. */
 479    size_t length = 0;
 480    /* Number of extensions */
 481    unsigned count;
 482    /* Indices of the extensions sorted by year */
 483    extension_index *extension_indices;
 484    /* String of extra extensions. */
 485    char *extra_extensions = get_extension_override(ctx);
 486    unsigned k;
 487    unsigned j;
 488    unsigned maxYear = ~0;
 489
 490    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
 491    {
 492       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
 493       if (env) {
 494          maxYear = atoi(env);
 495          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
 496                      maxYear);
 497       }
 498    }
 499
 500    /* Compute length of the extension string. */
 501    count = 0;
 502    for (k = 0; k < ARRAY_SIZE(extension_table); ++k) {
 503       const struct extension *i = extension_table + k;
 504
 505       if (i->year <= maxYear &&
 506           _mesa_extension_supported(ctx, k)) {
 507          length += strlen(i->name) + 1; /* +1 for space */
 508          ++count;
 509       }
 510    }
 511    if (extra_extensions != NULL)
 512       length += 1 + strlen(extra_extensions); /* +1 for space */
 513
 514    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
 515    if (exts == NULL) {
 516       free(extra_extensions);
 517       return NULL;
 518    }
 519
 520    extension_indices = malloc(count * sizeof(extension_index));
 521    if (extension_indices == NULL) {
 522       free(exts);
 523       free(extra_extensions);
 524       return NULL;
 525    }
 526
 527    /* Sort extensions in chronological order because certain old applications
 528     * (e.g., Quake3 demo) store the extension list in a static size buffer so
 529     * chronologically order ensure that the extensions that such applications
 530     * expect will fit into that buffer.
 531     */
 532    j = 0;
 533    for (k = 0; k < ARRAY_SIZE(extension_table); ++k) {
 534       if (extension_table[k].year <= maxYear &&
 535          _mesa_extension_supported(ctx, k)) {
 536          extension_indices[j++] = k;
 537       }
 538    }
 539    assert(j == count);
 540    qsort(extension_indices, count,
 541          sizeof *extension_indices, extension_compare);
 542
 543    /* Build the extension string.*/
 544    for (j = 0; j < count; ++j) {
 545       const struct extension *i = &extension_table[extension_indices[j]];
 546       assert(_mesa_extension_supported(ctx, extension_indices[j]));
 547       strcat(exts, i->name);
 548       strcat(exts, " ");
 549    }
 550    free(extension_indices);
 551    if (extra_extensions != 0) {
 552       strcat(exts, extra_extensions);
 553       free(extra_extensions);
 554    }
 555
 556    return (GLubyte *) exts;
 557 }
 558
 559 /**
 560  * Return number of enabled extensions.
 561  */
 562 GLuint
 563 _mesa_get_extension_count(struct gl_context *ctx)
 564 {
 565    unsigned k;
 566
 567    /* only count once */
 568    if (ctx->Extensions.Count != 0)
 569       return ctx->Extensions.Count;
 570
 571    for (k = 0; k < ARRAY_SIZE(extension_table); ++k) {
 572       if (_mesa_extension_supported(ctx, k))
 573          ctx->Extensions.Count++;
 574    }
 575    return ctx->Extensions.Count;
 576 }
 577
 578 /**
 579  * Return name of i-th enabled extension
 580  */
 581 const GLubyte *
 582 _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
 583 {
 584    size_t n = 0;
 585    unsigned i;
 586
 587    for (i = 0; i < ARRAY_SIZE(extension_table); ++i) {
 588       if (_mesa_extension_supported(ctx, i)) {
 589          if (n == index)
 590             return (const GLubyte*) extension_table[i].name;
 591          else
 592             ++n;
 593       }
 594    }
 595
 596    return NULL;
 597 }