#include <stdarg.h>
#include "glxclient.h"
#include "dri_common.h"
+#include "loader.h"
#ifndef RTLD_NOW
#define RTLD_NOW 0
#endif
_X_HIDDEN void
-InfoMessageF(const char *f, ...)
+dri_message(int level, const char *f, ...)
{
va_list args;
- const char *env;
-
- if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
- fprintf(stderr, "libGL: ");
- va_start(args, f);
- vfprintf(stderr, f, args);
- va_end(args);
+ int threshold = _LOADER_WARNING;
+ const char *libgl_debug;
+
+ libgl_debug = getenv("LIBGL_DEBUG");
+ if (libgl_debug) {
+ if (strstr(libgl_debug, "quiet"))
+ threshold = _LOADER_FATAL;
+ else if (strstr(libgl_debug, "verbose"))
+ threshold = _LOADER_DEBUG;
}
-}
-
-/**
- * Print error to stderr, unless LIBGL_DEBUG=="quiet".
- */
-_X_HIDDEN void
-ErrorMessageF(const char *f, ...)
-{
- va_list args;
- const char *env;
- if ((env = getenv("LIBGL_DEBUG")) && !strstr(env, "quiet")) {
- fprintf(stderr, "libGL error: ");
+ /* Note that the _LOADER_* levels are lower numbers for more severe. */
+ if (level <= threshold) {
+ fprintf(stderr, "libGL%s: ", level <= _LOADER_WARNING ? " error" : "");
va_start(args, f);
vfprintf(stderr, f, args);
va_end(args);
}
}
-#ifndef DEFAULT_DRIVER_DIR
-/* this is normally defined in Mesa/configs/default with DRI_DRIVER_SEARCH_PATH */
-#define DEFAULT_DRIVER_DIR "/usr/local/lib/dri"
+#ifndef GL_LIB_NAME
+#define GL_LIB_NAME "libGL.so.1"
#endif
/**
* directories specified by the \c LIBGL_DRIVERS_PATH environment variable in
* order to find the driver.
*
- * \param driverName - a name like "tdfx", "i810", "mga", etc.
+ * \param driverName - a name like "i965", "radeon", "nouveau", etc.
+ * \param out_driver_handle - Address to return the resulting dlopen() handle.
*
* \returns
- * A handle from \c dlopen, or \c NULL if driver file not found.
+ * The __DRIextension entrypoint table for the driver, or \c NULL if driver
+ * file not found.
*/
-_X_HIDDEN void *
-driOpenDriver(const char *driverName)
+_X_HIDDEN const __DRIextension **
+driOpenDriver(const char *driverName, void **out_driver_handle)
{
- void *glhandle, *handle;
- const char *libPaths, *p, *next;
- char realDriverName[200];
- int len;
+ void *glhandle;
/* Attempt to make sure libGL symbols will be visible to the driver */
- glhandle = dlopen("libGL.so.1", RTLD_NOW | RTLD_GLOBAL);
-
- libPaths = NULL;
- if (geteuid() == getuid()) {
- /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
- libPaths = getenv("LIBGL_DRIVERS_PATH");
- if (!libPaths)
- libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
- }
- if (libPaths == NULL)
- libPaths = DEFAULT_DRIVER_DIR;
-
- handle = NULL;
- for (p = libPaths; *p; p = next) {
- next = strchr(p, ':');
- if (next == NULL) {
- len = strlen(p);
- next = p + len;
- }
- else {
- len = next - p;
- next++;
- }
+ glhandle = dlopen(GL_LIB_NAME, RTLD_NOW | RTLD_GLOBAL);
-#ifdef GLX_USE_TLS
- snprintf(realDriverName, sizeof realDriverName,
- "%.*s/tls/%s_dri.so", len, p, driverName);
- InfoMessageF("OpenDriver: trying %s\n", realDriverName);
- handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
-#endif
+ static const char *search_path_vars[] = {
+ "LIBGL_DRIVERS_PATH",
+ "LIBGL_DRIVERS_DIR", /* deprecated */
+ NULL
+ };
- if (handle == NULL) {
- snprintf(realDriverName, sizeof realDriverName,
- "%.*s/%s_dri.so", len, p, driverName);
- InfoMessageF("OpenDriver: trying %s\n", realDriverName);
- handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
- }
-
- if (handle != NULL)
- break;
- else
- ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
- }
-
- if (!handle)
- ErrorMessageF("unable to load driver: %s_dri.so\n", driverName);
+ const __DRIextension **extensions =
+ loader_open_driver(driverName, out_driver_handle, search_path_vars);
if (glhandle)
dlclose(glhandle);
- return handle;
+ return extensions;
}
static GLboolean
{
__GLXDRIdrawable *glxDraw = loaderPrivate;
- return __glxGetMscRate(glxDraw, numerator, denominator);
+ return __glxGetMscRate(glxDraw->psc, numerator, denominator);
}
_X_HIDDEN const __DRIsystemTimeExtension systemTimeExtension = {
- {__DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION},
- __glXGetUST,
- __driGetMSCRate
+ .base = {__DRI_SYSTEM_TIME, 1 },
+
+ .getUST = __glXGetUST,
+ .getMSCRate = __driGetMSCRate
};
#define __ATTRIB(attrib, field) \
__ATTRIB(__DRI_ATTRIB_GREEN_MASK, greenMask),
__ATTRIB(__DRI_ATTRIB_BLUE_MASK, blueMask),
__ATTRIB(__DRI_ATTRIB_ALPHA_MASK, alphaMask),
+ __ATTRIB(__DRI_ATTRIB_RED_SHIFT, redShift),
+ __ATTRIB(__DRI_ATTRIB_GREEN_SHIFT, greenShift),
+ __ATTRIB(__DRI_ATTRIB_BLUE_SHIFT, blueShift),
+ __ATTRIB(__DRI_ATTRIB_ALPHA_SHIFT, alphaShift),
#endif
__ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH, maxPbufferWidth),
__ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT, maxPbufferHeight),
__ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS, maxPbufferPixels),
__ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH, optimalPbufferWidth),
__ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT, optimalPbufferHeight),
-#if 0
__ATTRIB(__DRI_ATTRIB_SWAP_METHOD, swapMethod),
-#endif
-__ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB, bindToTextureRgb),
+ __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB, bindToTextureRgb),
__ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA, bindToTextureRgba),
__ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,
bindToMipmapTexture),
static int
scalarEqual(struct glx_config *mode, unsigned int attrib, unsigned int value)
{
- unsigned int glxValue;
- int i;
+ unsigned glxValue, i;
for (i = 0; i < ARRAY_SIZE(attribMap); i++)
if (attribMap[i].attrib == attrib) {
if (value & __DRI_ATTRIB_RGBA_BIT) {
glxValue |= GLX_RGBA_BIT;
}
- else if (value & __DRI_ATTRIB_COLOR_INDEX_BIT) {
+ if (value & __DRI_ATTRIB_COLOR_INDEX_BIT) {
glxValue |= GLX_COLOR_INDEX_BIT;
}
+ if (value & __DRI_ATTRIB_FLOAT_BIT) {
+ glxValue |= GLX_RGBA_FLOAT_BIT_ARB;
+ }
+ if (value & __DRI_ATTRIB_UNSIGNED_FLOAT_BIT) {
+ glxValue |= GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT;
+ }
if (glxValue != config->renderType)
return GL_FALSE;
break;
return GL_FALSE;
break;
+ case __DRI_ATTRIB_SWAP_METHOD:
+ if (value == __DRI_ATTRIB_SWAP_EXCHANGE)
+ glxValue = GLX_SWAP_EXCHANGE_OML;
+ else if (value == __DRI_ATTRIB_SWAP_COPY)
+ glxValue = GLX_SWAP_COPY_OML;
+ else
+ glxValue = GLX_SWAP_UNDEFINED_OML;
+
+ if (!scalarEqual(config, attrib, glxValue))
+ return GL_FALSE;
+
+ break;
+
default:
if (!scalarEqual(config, attrib, value))
return GL_FALSE;
if (driConfigs[i] == NULL)
return NULL;
- driConfig = Xmalloc(sizeof *driConfig);
+ driConfig = malloc(sizeof *driConfig);
if (driConfig == NULL)
return NULL;
tail = tail->next;
}
- glx_config_destroy_list(configs);
-
return head.next;
}
free(configs);
}
+static struct glx_config *
+driInferDrawableConfig(struct glx_screen *psc, GLXDrawable draw)
+{
+ unsigned int fbconfig = 0;
+
+ if (__glXGetDrawableAttribute(psc->dpy, draw, GLX_FBCONFIG_ID, &fbconfig)) {
+ return glx_config_find_fbconfig(psc->configs, fbconfig);
+ }
+
+ return NULL;
+}
+
_X_HIDDEN __GLXDRIdrawable *
driFetchDrawable(struct glx_context *gc, GLXDrawable glxDrawable)
{
struct glx_display *const priv = __glXInitialize(gc->psc->dpy);
__GLXDRIdrawable *pdraw;
struct glx_screen *psc;
+ struct glx_config *config = gc->config;
if (priv == NULL)
return NULL;
+ if (glxDrawable == None)
+ return NULL;
+
psc = priv->screens[gc->screen];
if (priv->drawHash == NULL)
return NULL;
return pdraw;
}
- pdraw = psc->driScreen->createDrawable(psc, glxDrawable,
- glxDrawable, gc->config);
+ if (config == NULL)
+ config = driInferDrawableConfig(gc->psc, glxDrawable);
+ if (config == NULL)
+ return NULL;
+
+ pdraw = psc->driScreen->createDrawable(psc, glxDrawable, glxDrawable,
+ config);
+
+ if (pdraw == NULL) {
+ ErrorMessageF("failed to create drawable\n");
+ return NULL;
+ }
+
if (__glxHashInsert(priv->drawHash, glxDrawable, pdraw)) {
(*pdraw->destroyDrawable) (pdraw);
return NULL;
if (pdraw->drawable == pdraw->xDrawable) {
pdraw->refcount --;
if (pdraw->refcount == 0) {
- (*pdraw->destroyDrawable)(pdraw);
+ pdraw->destroyDrawable(pdraw);
__glxHashDelete(priv->drawHash, gc->currentDrawable);
}
}
if (pdraw->drawable == pdraw->xDrawable) {
pdraw->refcount --;
if (pdraw->refcount == 0) {
- (*pdraw->destroyDrawable)(pdraw);
+ pdraw->destroyDrawable(pdraw);
__glxHashDelete(priv->drawHash, gc->currentReadable);
}
}
}
+_X_HIDDEN bool
+dri2_convert_glx_attribs(unsigned num_attribs, const uint32_t *attribs,
+ unsigned *major_ver, unsigned *minor_ver,
+ uint32_t *render_type, uint32_t *flags, unsigned *api,
+ int *reset, int *release, unsigned *error)
+{
+ unsigned i;
+ bool got_profile = false;
+ int no_error = 0;
+ uint32_t profile;
+
+ *major_ver = 1;
+ *minor_ver = 0;
+ *render_type = GLX_RGBA_TYPE;
+ *reset = __DRI_CTX_RESET_NO_NOTIFICATION;
+ *release = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
+ *flags = 0;
+ *api = __DRI_API_OPENGL;
+
+ if (num_attribs == 0) {
+ return true;
+ }
+
+ /* This is actually an internal error, but what the heck.
+ */
+ if (attribs == NULL) {
+ *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
+ return false;
+ }
+
+ for (i = 0; i < num_attribs; i++) {
+ switch (attribs[i * 2]) {
+ case GLX_CONTEXT_MAJOR_VERSION_ARB:
+ *major_ver = attribs[i * 2 + 1];
+ break;
+ case GLX_CONTEXT_MINOR_VERSION_ARB:
+ *minor_ver = attribs[i * 2 + 1];
+ break;
+ case GLX_CONTEXT_FLAGS_ARB:
+ *flags = attribs[i * 2 + 1];
+ break;
+ case GLX_CONTEXT_OPENGL_NO_ERROR_ARB:
+ no_error = attribs[i * 2 + 1];
+ break;
+ case GLX_CONTEXT_PROFILE_MASK_ARB:
+ profile = attribs[i * 2 + 1];
+ got_profile = true;
+ break;
+ case GLX_RENDER_TYPE:
+ *render_type = attribs[i * 2 + 1];
+ break;
+ case GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB:
+ switch (attribs[i * 2 + 1]) {
+ case GLX_NO_RESET_NOTIFICATION_ARB:
+ *reset = __DRI_CTX_RESET_NO_NOTIFICATION;
+ break;
+ case GLX_LOSE_CONTEXT_ON_RESET_ARB:
+ *reset = __DRI_CTX_RESET_LOSE_CONTEXT;
+ break;
+ default:
+ *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
+ return false;
+ }
+ break;
+ case GLX_CONTEXT_RELEASE_BEHAVIOR_ARB:
+ switch (attribs[i * 2 + 1]) {
+ case GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB:
+ *release = __DRI_CTX_RELEASE_BEHAVIOR_NONE;
+ break;
+ case GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB:
+ *release = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
+ break;
+ default:
+ *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
+ return false;
+ }
+ break;
+ default:
+ /* If an unknown attribute is received, fail.
+ */
+ *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
+ return false;
+ }
+ }
+
+ if (no_error) {
+ *flags |= __DRI_CTX_FLAG_NO_ERROR;
+ }
+
+ if (!got_profile) {
+ if (*major_ver > 3 || (*major_ver == 3 && *minor_ver >= 2))
+ *api = __DRI_API_OPENGL_CORE;
+ } else {
+ switch (profile) {
+ case GLX_CONTEXT_CORE_PROFILE_BIT_ARB:
+ /* There are no profiles before OpenGL 3.2. The
+ * GLX_ARB_create_context_profile spec says:
+ *
+ * "If the requested OpenGL version is less than 3.2,
+ * GLX_CONTEXT_PROFILE_MASK_ARB is ignored and the functionality
+ * of the context is determined solely by the requested version."
+ */
+ *api = (*major_ver > 3 || (*major_ver == 3 && *minor_ver >= 2))
+ ? __DRI_API_OPENGL_CORE : __DRI_API_OPENGL;
+ break;
+ case GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
+ *api = __DRI_API_OPENGL;
+ break;
+ case GLX_CONTEXT_ES_PROFILE_BIT_EXT:
+ if (*major_ver >= 3)
+ *api = __DRI_API_GLES3;
+ else if (*major_ver == 2 && *minor_ver == 0)
+ *api = __DRI_API_GLES2;
+ else if (*major_ver == 1 && *minor_ver < 2)
+ *api = __DRI_API_GLES;
+ else {
+ *error = __DRI_CTX_ERROR_BAD_API;
+ return false;
+ }
+ break;
+ default:
+ *error = __DRI_CTX_ERROR_BAD_API;
+ return false;
+ }
+ }
+
+ /* Unknown flag value.
+ */
+ if (*flags & ~(__DRI_CTX_FLAG_DEBUG | __DRI_CTX_FLAG_FORWARD_COMPATIBLE
+ | __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS
+ | __DRI_CTX_FLAG_NO_ERROR)) {
+ *error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
+ return false;
+ }
+
+ /* There are no forward-compatible contexts before OpenGL 3.0. The
+ * GLX_ARB_create_context spec says:
+ *
+ * "Forward-compatible contexts are defined only for OpenGL versions
+ * 3.0 and later."
+ */
+ if (*major_ver < 3 && (*flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0) {
+ *error = __DRI_CTX_ERROR_BAD_FLAG;
+ return false;
+ }
+
+ if (*major_ver >= 3 && *render_type == GLX_COLOR_INDEX_TYPE) {
+ *error = __DRI_CTX_ERROR_BAD_FLAG;
+ return false;
+ }
+
+ *error = __DRI_CTX_ERROR_SUCCESS;
+ return true;
+}
+
+_X_HIDDEN bool
+dri2_check_no_error(uint32_t flags, struct glx_context *share_context,
+ int major, unsigned *error)
+{
+ Bool noError = flags & __DRI_CTX_FLAG_NO_ERROR;
+
+ /* The KHR_no_error specs say:
+ *
+ * Requires OpenGL ES 2.0 or OpenGL 2.0.
+ */
+ if (noError && major < 2) {
+ *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
+ return false;
+ }
+
+ /* The GLX_ARB_create_context_no_error specs say:
+ *
+ * BadMatch is generated if the value of GLX_CONTEXT_OPENGL_NO_ERROR_ARB
+ * used to create <share_context> does not match the value of
+ * GLX_CONTEXT_OPENGL_NO_ERROR_ARB for the context being created.
+ */
+ if (share_context && !!share_context->noError != !!noError) {
+ *error = __DRI_CTX_ERROR_BAD_FLAG;
+ return false;
+ }
+
+ /* The GLX_ARB_create_context_no_error specs say:
+ *
+ * BadMatch is generated if the GLX_CONTEXT_OPENGL_NO_ERROR_ARB is TRUE at
+ * the same time as a debug or robustness context is specified.
+ *
+ */
+ if (noError && ((flags & __DRI_CTX_FLAG_DEBUG) ||
+ (flags & __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS))) {
+ *error = __DRI_CTX_ERROR_BAD_FLAG;
+ return false;
+ }
+
+ return true;
+}
+
#endif /* GLX_DIRECT_RENDERING */
projects / mesa.git / blobdiff