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
  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 *unrecognized_extensions = NULL;
  43
  44
  45 /**
  46  * Given a member \c x of struct gl_extensions, return offset of
  47  * \c x in bytes.
  48  */
  49 #define o(x) offsetof(struct gl_extensions, x)
  50
  51 static int
  52 extension_name_compare(const void *name, const void *elem)
  53 {
  54    const struct mesa_extension *entry = elem;
  55    return strcmp(name, entry->name);
  56 }
  57
  58 /**
  59  * Given an extension name, lookup up the corresponding member of struct
  60  * gl_extensions and return that member's index.  If the name is
  61  * not found in the \c _mesa_extension_table, return -1.
  62  *
  63  * \param name Name of extension.
  64  * \return Index of member in struct gl_extensions.
  65  */
  66 static int
  67 name_to_index(const char* name)
  68 {
  69    const struct mesa_extension *entry;
  70
  71    if (!name)
  72       return -1;
  73
  74    entry = bsearch(name,
  75                    _mesa_extension_table, MESA_EXTENSION_COUNT,
  76                    sizeof(_mesa_extension_table[0]),
  77                    extension_name_compare);
  78
  79    if (entry)
  80       return entry - _mesa_extension_table;
  81
  82    return -1;
  83 }
  84
  85 /**
  86  * Overrides extensions in \c ctx based on the values in
  87  * _mesa_extension_override_enables and _mesa_extension_override_disables.
  88  */
  89 void
  90 _mesa_override_extensions(struct gl_context *ctx)
  91 {
  92    unsigned i;
  93    const GLboolean *enables =
  94       (GLboolean*) &_mesa_extension_override_enables;
  95    const GLboolean *disables =
  96       (GLboolean*) &_mesa_extension_override_disables;
  97    GLboolean *ctx_ext = (GLboolean*)&ctx->Extensions;
  98
  99    for (i = 0; i < MESA_EXTENSION_COUNT; ++i) {
 100       size_t offset = _mesa_extension_table[i].offset;
 101
 102       assert(!enables[offset] || !disables[offset]);
 103       if (enables[offset]) {
 104          ctx_ext[offset] = 1;
 105       } else if (disables[offset]) {
 106          ctx_ext[offset] = 0;
 107       }
 108    }
 109 }
 110
 111
 112 /**
 113  * Enable all extensions suitable for a software-only renderer.
 114  * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
 115  */
 116 void
 117 _mesa_enable_sw_extensions(struct gl_context *ctx)
 118 {
 119    ctx->Extensions.ARB_depth_clamp = GL_TRUE;
 120    ctx->Extensions.ARB_depth_texture = GL_TRUE;
 121    ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 122    ctx->Extensions.ARB_draw_instanced = GL_TRUE;
 123    ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
 124    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
 125    ctx->Extensions.ARB_fragment_program = GL_TRUE;
 126    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
 127    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 128    ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
 129    ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
 130    ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
 131    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
 132    ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
 133    ctx->Extensions.ARB_point_sprite = GL_TRUE;
 134    ctx->Extensions.ARB_shadow = GL_TRUE;
 135    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
 136    ctx->Extensions.ARB_texture_compression_bptc = GL_TRUE;
 137    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
 138    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
 139    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
 140    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
 141    ctx->Extensions.ARB_texture_filter_anisotropic = GL_TRUE;
 142    ctx->Extensions.ARB_texture_float = GL_TRUE;
 143    ctx->Extensions.ARB_texture_mirror_clamp_to_edge = GL_TRUE;
 144    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
 145    ctx->Extensions.ARB_texture_rg = GL_TRUE;
 146    ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
 147    ctx->Extensions.ARB_vertex_program = GL_TRUE;
 148    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 149    ctx->Extensions.ARB_sync = GL_TRUE;
 150    ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
 151    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
 152    ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
 153    ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
 154    ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
 155    ctx->Extensions.EXT_blend_color = GL_TRUE;
 156    ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
 157    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
 158    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
 159    ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
 160    ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
 161    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
 162    ctx->Extensions.EXT_point_parameters = GL_TRUE;
 163    ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
 164    ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
 165    ctx->Extensions.EXT_texture_array = GL_TRUE;
 166    ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
 167    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
 168    ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
 169    ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
 170    ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
 171    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 172    ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
 173    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
 174    /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
 175    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
 176    ctx->Extensions.MESA_pack_invert = GL_TRUE;
 177    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
 178    ctx->Extensions.NV_conditional_render = GL_TRUE;
 179    ctx->Extensions.NV_point_sprite = GL_TRUE;
 180    ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
 181    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
 182    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
 183    ctx->Extensions.OES_standard_derivatives = GL_TRUE;
 184    ctx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
 185    ctx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
 186    ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
 187 }
 188
 189 /**
 190  * Either enable or disable the named extension.
 191  * \return offset of extensions withint `ext' or 0 if extension is not known
 192  */
 193 static size_t
 194 set_extension(struct gl_extensions *ext, int i, GLboolean state)
 195 {
 196    size_t offset;
 197
 198    offset = i < 0 ? 0 : _mesa_extension_table[i].offset;
 199    if (offset != 0 && (offset != o(dummy_true) || state != GL_FALSE)) {
 200       ((GLboolean *) ext)[offset] = state;
 201    }
 202
 203    return offset;
 204 }
 205
 206
 207 /**
 208  * \brief Free string pointed by unrecognized_extensions
 209  *
 210  * This string is allocated early during the first context creation by
 211  * _mesa_one_time_init_extension_overrides.
 212  */
 213 static void
 214 free_unknown_extensions_strings(void)
 215 {
 216    free(unrecognized_extensions);
 217 }
 218
 219
 220 /**
 221  * \brief Initialize extension override tables based on \c MESA_EXTENSION_OVERRIDE
 222  *
 223  * This should be called one time early during first context initialization.
 224
 225  * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
 226  * enable or disable. The list is processed thus:
 227  *    - Enable recognized extension names that are prefixed with '+'.
 228  *    - Disable recognized extension names that are prefixed with '-'.
 229  *    - Enable recognized extension names that are not prefixed.
 230  *    - Collect unrecognized extension names in a new string.
 231  */
 232 void
 233 _mesa_one_time_init_extension_overrides(struct gl_context *ctx)
 234 {
 235    const char *env_const = getenv("MESA_EXTENSION_OVERRIDE");
 236    char *env;
 237    char *ext;
 238    size_t offset;
 239    unsigned unknown_ext = 0;
 240
 241    memset(&_mesa_extension_override_enables, 0, sizeof(struct gl_extensions));
 242    memset(&_mesa_extension_override_disables, 0, sizeof(struct gl_extensions));
 243
 244    if (env_const == NULL) {
 245       return;
 246    }
 247
 248    /* Copy env_const because strtok() is destructive. */
 249    env = strdup(env_const);
 250
 251    if (env == NULL)
 252       return;
 253
 254    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
 255       int enable;
 256       int i;
 257       bool recognized;
 258       switch (ext[0]) {
 259       case '+':
 260          enable = 1;
 261          ++ext;
 262          break;
 263       case '-':
 264          enable = 0;
 265          ++ext;
 266          break;
 267       default:
 268          enable = 1;
 269          break;
 270       }
 271
 272       i = name_to_index(ext);
 273       offset = set_extension(&_mesa_extension_override_enables, i, enable);
 274       offset = set_extension(&_mesa_extension_override_disables, i, !enable);
 275       if (offset != 0)
 276          recognized = true;
 277       else
 278          recognized = false;
 279
 280       if (!recognized && enable) {
 281          if (unknown_ext >= MAX_UNRECOGNIZED_EXTENSIONS) {
 282             static bool warned;
 283
 284             if (!warned) {
 285                warned = true;
 286                _mesa_problem(ctx, "Trying to enable too many unknown extension. "
 287                                   "Only the first %d will be honoured",
 288                                   MAX_UNRECOGNIZED_EXTENSIONS);
 289             }
 290          } else {
 291             ctx->Extensions.unrecognized_extensions[unknown_ext] = ext;
 292             unknown_ext++;
 293
 294             _mesa_problem(ctx, "Trying to enable unknown extension: %s", ext);
 295          }
 296       }
 297    }
 298
 299    if (!unknown_ext) {
 300       free(env);
 301    } else {
 302       unrecognized_extensions = env;
 303       atexit(free_unknown_extensions_strings);
 304    }
 305 }
 306
 307
 308 /**
 309  * \brief Initialize extension tables and enable default extensions.
 310  *
 311  * This should be called during context initialization.
 312  * Note: Sets gl_extensions.dummy_true to true.
 313  */
 314 void
 315 _mesa_init_extensions(struct gl_extensions *extensions)
 316 {
 317    GLboolean *base = (GLboolean *) extensions;
 318    GLboolean *sentinel = base + o(extension_sentinel);
 319    GLboolean *i;
 320
 321    /* First, turn all extensions off. */
 322    for (i = base; i != sentinel; ++i)
 323       *i = GL_FALSE;
 324
 325    /* Then, selectively turn default extensions on. */
 326    extensions->dummy_true = GL_TRUE;
 327 }
 328
 329
 330 typedef unsigned short extension_index;
 331
 332
 333 /**
 334  * Given an extension enum, return whether or not the extension is supported
 335  * dependent on the following factors:
 336  * There's driver support and the OpenGL/ES version is at least that
 337  * specified in the _mesa_extension_table.
 338  */
 339 static inline bool
 340 _mesa_extension_supported(const struct gl_context *ctx, extension_index i)
 341 {
 342    const bool *base = (bool *) &ctx->Extensions;
 343    const struct mesa_extension *ext = _mesa_extension_table + i;
 344
 345    return (ctx->Version >= ext->version[ctx->API]) && base[ext->offset];
 346 }
 347
 348 /**
 349  * Compare two entries of the extensions table.  Sorts first by year,
 350  * then by name.
 351  *
 352  * Arguments are indices into _mesa_extension_table.
 353  */
 354 static int
 355 extension_compare(const void *p1, const void *p2)
 356 {
 357    extension_index i1 = * (const extension_index *) p1;
 358    extension_index i2 = * (const extension_index *) p2;
 359    const struct mesa_extension *e1 = &_mesa_extension_table[i1];
 360    const struct mesa_extension *e2 = &_mesa_extension_table[i2];
 361    int res;
 362
 363    res = (int)e1->year - (int)e2->year;
 364
 365    if (res == 0) {
 366       res = strcmp(e1->name, e2->name);
 367    }
 368
 369    return res;
 370 }
 371
 372
 373 /**
 374  * Construct the GL_EXTENSIONS string.  Called the first time that
 375  * glGetString(GL_EXTENSIONS) is called.
 376  */
 377 GLubyte*
 378 _mesa_make_extension_string(struct gl_context *ctx)
 379 {
 380    /* The extension string. */
 381    char *exts = 0;
 382    /* Length of extension string. */
 383    size_t length = 0;
 384    /* Number of extensions */
 385    unsigned count;
 386    /* Indices of the extensions sorted by year */
 387    extension_index extension_indices[MESA_EXTENSION_COUNT];
 388    unsigned k;
 389    unsigned j;
 390    unsigned maxYear = ~0;
 391
 392    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
 393    {
 394       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
 395       if (env) {
 396          maxYear = atoi(env);
 397          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
 398                      maxYear);
 399       }
 400    }
 401
 402    /* Compute length of the extension string. */
 403    count = 0;
 404    for (k = 0; k < MESA_EXTENSION_COUNT; ++k) {
 405       const struct mesa_extension *i = _mesa_extension_table + k;
 406
 407       if (i->year <= maxYear &&
 408           _mesa_extension_supported(ctx, k)) {
 409          length += strlen(i->name) + 1; /* +1 for space */
 410          ++count;
 411       }
 412    }
 413    for (k = 0; k < MAX_UNRECOGNIZED_EXTENSIONS; k++)
 414       if (ctx->Extensions.unrecognized_extensions[k])
 415          length += 1 + strlen(ctx->Extensions.unrecognized_extensions[k]); /* +1 for space */
 416
 417    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
 418    if (exts == NULL) {
 419       return NULL;
 420    }
 421
 422    /* Sort extensions in chronological order because idTech 2/3 games
 423     * (e.g., Quake3 demo) store the extension list in a fixed size buffer.
 424     * Some cases truncate, while others overflow the buffer. Resulting in
 425     * misrendering and crashes, respectively.
 426     * Address the former here, while the latter will be addressed by setting
 427     * the MESA_EXTENSION_MAX_YEAR environment variable.
 428     */
 429    j = 0;
 430    for (k = 0; k < MESA_EXTENSION_COUNT; ++k) {
 431       if (_mesa_extension_table[k].year <= maxYear &&
 432          _mesa_extension_supported(ctx, k)) {
 433          extension_indices[j++] = k;
 434       }
 435    }
 436    assert(j == count);
 437    qsort(extension_indices, count,
 438          sizeof *extension_indices, extension_compare);
 439
 440    /* Build the extension string.*/
 441    for (j = 0; j < count; ++j) {
 442       const struct mesa_extension *i = &_mesa_extension_table[extension_indices[j]];
 443       assert(_mesa_extension_supported(ctx, extension_indices[j]));
 444       strcat(exts, i->name);
 445       strcat(exts, " ");
 446    }
 447    for (j = 0; j < MAX_UNRECOGNIZED_EXTENSIONS; j++) {
 448       if (ctx->Extensions.unrecognized_extensions[j]) {
 449          strcat(exts, ctx->Extensions.unrecognized_extensions[j]);
 450          strcat(exts, " ");
 451       }
 452    }
 453
 454    return (GLubyte *) exts;
 455 }
 456
 457 /**
 458  * Return number of enabled extensions.
 459  */
 460 GLuint
 461 _mesa_get_extension_count(struct gl_context *ctx)
 462 {
 463    unsigned k;
 464
 465    /* only count once */
 466    if (ctx->Extensions.Count != 0)
 467       return ctx->Extensions.Count;
 468
 469    for (k = 0; k < MESA_EXTENSION_COUNT; ++k) {
 470       if (_mesa_extension_supported(ctx, k))
 471          ctx->Extensions.Count++;
 472    }
 473
 474    for (k = 0; k < MAX_UNRECOGNIZED_EXTENSIONS; ++k) {
 475       if (ctx->Extensions.unrecognized_extensions[k])
 476          ctx->Extensions.Count++;
 477    }
 478    return ctx->Extensions.Count;
 479 }
 480
 481 /**
 482  * Return name of i-th enabled extension
 483  */
 484 const GLubyte *
 485 _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
 486 {
 487    size_t n = 0;
 488    unsigned i;
 489
 490    for (i = 0; i < MESA_EXTENSION_COUNT; ++i) {
 491       if (_mesa_extension_supported(ctx, i)) {
 492          if (n == index)
 493             return (const GLubyte*) _mesa_extension_table[i].name;
 494          else
 495             ++n;
 496       }
 497    }
 498
 499    for (i = 0; i < MAX_UNRECOGNIZED_EXTENSIONS; ++i) {
 500       if (ctx->Extensions.unrecognized_extensions[i]) {
 501          if (n == index)
 502             return (const GLubyte*) ctx->Extensions.unrecognized_extensions[i];
 503          else
 504             ++n;
 505       }
 506    }
 507    return NULL;
 508 }