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