AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d0560f59cedf7ca88efe25bfbee72ff0819bcd15
mesa/src/glx/dri_common.c

1034 lines
31 KiB
C
Raw Blame History

/*
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright © 2008 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Soft-
* ware"), to deal in the Software without restriction, including without
* limitation the rights to use, copy, modify, merge, publish, distribute,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, provided that the above copyright
* notice(s) and this permission notice appear in all copies of the Soft-
* ware and that both the above copyright notice(s) and this permission
* notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
* ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
* RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
* THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
* QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
* MANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder shall
* not be used in advertising or otherwise to promote the sale, use or
* other dealings in this Software without prior written authorization of
* the copyright holder.
*
* Authors:
* Kevin E. Martin <kevin@precisioninsight.com>
* Brian Paul <brian@precisioninsight.com>
* Kristian Høgsberg (krh@redhat.com)
*/
#if defined(GLX_DIRECT_RENDERING) && (!defined(GLX_USE_APPLEGL) || defined(GLX_USE_APPLE))
#include <unistd.h>
#include <dlfcn.h>
#include <stdarg.h>
#include "glxclient.h"
#include "dri_common.h"
#include "loader.h"
#include <X11/Xlib-xcb.h>
#include <xcb/xproto.h>
#include "dri_util.h"
#include "pipe-loader/pipe_loader.h"
#define __ATTRIB(attrib, field) \
{ attrib, offsetof(struct glx_config, field) }
static const struct
{
unsigned int attrib, offset;
} attribMap[] = {
__ATTRIB(__DRI_ATTRIB_BUFFER_SIZE, rgbBits),
__ATTRIB(__DRI_ATTRIB_LEVEL, level),
__ATTRIB(__DRI_ATTRIB_RED_SIZE, redBits),
__ATTRIB(__DRI_ATTRIB_GREEN_SIZE, greenBits),
__ATTRIB(__DRI_ATTRIB_BLUE_SIZE, blueBits),
__ATTRIB(__DRI_ATTRIB_ALPHA_SIZE, alphaBits),
__ATTRIB(__DRI_ATTRIB_DEPTH_SIZE, depthBits),
__ATTRIB(__DRI_ATTRIB_STENCIL_SIZE, stencilBits),
__ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE, accumRedBits),
__ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE, accumGreenBits),
__ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE, accumBlueBits),
__ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE, accumAlphaBits),
__ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS, sampleBuffers),
__ATTRIB(__DRI_ATTRIB_SAMPLES, samples),
__ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER, doubleBufferMode),
__ATTRIB(__DRI_ATTRIB_STEREO, stereoMode),
__ATTRIB(__DRI_ATTRIB_AUX_BUFFERS, numAuxBuffers),
__ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB, bindToTextureRgb),
__ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA, bindToTextureRgba),
__ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE, bindToMipmapTexture),
__ATTRIB(__DRI_ATTRIB_YINVERTED, yInverted),
__ATTRIB(__DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE, sRGBCapable)
};
static int
scalarEqual(struct glx_config *mode, unsigned int attrib, unsigned int value)
{
unsigned glxValue, i;
for (i = 0; i < ARRAY_SIZE(attribMap); i++)
if (attribMap[i].attrib == attrib) {
glxValue = *(unsigned int *) ((char *) mode + attribMap[i].offset);
return glxValue == GLX_DONT_CARE || glxValue == value;
}
return GL_TRUE; /* Is a non-existing attribute equal to value? */
}
static int
driConfigEqual(struct glx_config *config, const struct dri_config *driConfig)
{
unsigned int attrib, value, glxValue;
int i;
i = 0;
while (driIndexConfigAttrib(driConfig, i++, &attrib, &value)) {
switch (attrib) {
case __DRI_ATTRIB_RENDER_TYPE:
glxValue = 0;
if (value & __DRI_ATTRIB_RGBA_BIT) {
glxValue |= GLX_RGBA_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;
case __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS:
glxValue = 0;
if (value & __DRI_ATTRIB_TEXTURE_1D_BIT)
glxValue |= GLX_TEXTURE_1D_BIT_EXT;
if (value & __DRI_ATTRIB_TEXTURE_2D_BIT)
glxValue |= GLX_TEXTURE_2D_BIT_EXT;
if (value & __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT)
glxValue |= GLX_TEXTURE_RECTANGLE_BIT_EXT;
if (config->bindToTextureTargets != GLX_DONT_CARE &&
glxValue != config->bindToTextureTargets)
return GL_FALSE;
break;
/* Nerf some attributes we can safely ignore if the server claims to
* support them but the driver does not.
*/
case __DRI_ATTRIB_CONFIG_CAVEAT:
if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
glxValue = GLX_NON_CONFORMANT_CONFIG;
else if (value & __DRI_ATTRIB_SLOW_BIT)
glxValue = GLX_SLOW_CONFIG;
else
glxValue = GLX_NONE;
if (glxValue != config->visualRating) {
if (config->visualRating == GLX_NONE) {
static int warned;
if (!warned) {
DebugMessageF("Not downgrading visual rating\n");
warned = 1;
}
} else {
return GL_FALSE;
}
}
break;
case __DRI_ATTRIB_AUX_BUFFERS:
if (!scalarEqual(config, attrib, value)) {
static int warned;
if (!warned) {
DebugMessageF("Disabling server's aux buffer support\n");
warned = 1;
}
config->numAuxBuffers = 0;
}
break;
case __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE:
if (!scalarEqual(config, attrib, value)) {
static int warned;
if (!warned) {
DebugMessageF("Disabling server's tfp mipmap support\n");
warned = 1;
}
config->bindToMipmapTexture = 0;
}
break;
default:
if (!scalarEqual(config, attrib, value))
return GL_FALSE;
}
}
return GL_TRUE;
}
static struct glx_config *
createDriMode(struct glx_config *config, const struct dri_config **driConfigs)
{
__GLXDRIconfigPrivate *driConfig;
int i;
for (i = 0; driConfigs[i]; i++) {
if (driConfigEqual(config, driConfigs[i]))
break;
}
if (driConfigs[i] == NULL)
return NULL;
driConfig = malloc(sizeof *driConfig);
if (driConfig == NULL)
return NULL;
driConfig->base = *config;
driConfig->driConfig = driConfigs[i];
return &driConfig->base;
}
_X_HIDDEN struct glx_config *
driConvertConfigs(struct glx_config *configs, const struct dri_config **driConfigs)
{
struct glx_config head, *tail, *m;
tail = &head;
head.next = NULL;
for (m = configs; m; m = m->next) {
tail->next = createDriMode(m, driConfigs);
if (tail->next == NULL) {
/* no matching dri config for m */
continue;
}
tail = tail->next;
}
return head.next;
}
_X_HIDDEN void
driDestroyConfigs(const struct dri_config **configs)
{
int i;
for (i = 0; configs[i]; i++)
free((struct dri_config *) configs[i]);
free(configs);
}
static struct glx_config *
driInferDrawableConfig(struct glx_screen *psc, GLXDrawable draw)
{
unsigned int fbconfig = 0;
xcb_get_window_attributes_cookie_t cookie = { 0 };
xcb_get_window_attributes_reply_t *attr = NULL;
xcb_connection_t *conn = XGetXCBConnection(psc->dpy);
/* In practice here, either the XID is a bare Window or it was created
* by some other client. First let's see if the X server can tell us
* the answer. Xorg first added GLX_EXT_no_config_context in 1.20, where
* this usually works except for bare Windows that haven't been made
* current yet.
*/
if (__glXGetDrawableAttribute(psc->dpy, draw, GLX_FBCONFIG_ID, &fbconfig)) {
return glx_config_find_fbconfig(psc->configs, fbconfig);
}
/* Well this had better be a Window then. Figure out its visual and
* then find the corresponding GLX visual.
*/
cookie = xcb_get_window_attributes(conn, draw);
attr = xcb_get_window_attributes_reply(conn, cookie, NULL);
if (attr) {
uint32_t vid = attr->visual;
free(attr);
return glx_config_find_visual(psc->visuals, vid);
}
return NULL;
}
_X_HIDDEN __GLXDRIdrawable *
driFetchDrawable(struct glx_context *gc, GLXDrawable glxDrawable)
{
Display *dpy = gc->psc->dpy;
struct glx_display *const priv = __glXInitialize(dpy);
__GLXDRIdrawable *pdraw;
struct glx_screen *psc = gc->psc;
struct glx_config *config = gc->config;
unsigned int type;
if (priv == NULL)
return NULL;
if (glxDrawable == None)
return NULL;
if (priv->drawHash == NULL)
return NULL;
if (__glxHashLookup(priv->drawHash, glxDrawable, (void *) &pdraw) == 0) {
/* Resurrected, so remove from the alive-query-set if exist. */
_mesa_set_remove_key(priv->zombieGLXDrawable, pdraw);
pdraw->refcount ++;
return pdraw;
}
/* if this is a no-config context, infer the fbconfig from the drawable */
if (config == NULL)
config = driInferDrawableConfig(psc, glxDrawable);
if (config == NULL)
return NULL;
/* We can't find this GLX drawable above because it's either:
*
* 1. An X window ID instead of a GLX window ID. This could happend when
* glXMakeCurrent() is passed an X window directly instead of creating
* GLXWindow with glXCreateWindow() first.
*
* 2. A GLXPbuffer created on other display:
*
* From the GLX spec:
*
* Like other drawable types, GLXPbuffers are shared; any client which
* knows the associated XID can use a GLXPbuffer.
*
* So client other than the creator of this GLXPbuffer could use its
* XID to do something like glXMakeCurrent(). I can't find explicite
* statement in GLX spec that also allow GLXWindow and GLXPixmap.
*
* But even GLXWindow and GLXPixmap is allowed, currently client other
* than the GLX drawable creator has no way to find which X drawable
* (window or pixmap) this GLX drawable uses, except the GLXPbuffer
* case which use the same XID for both X pixmap and GLX drawable.
*/
/* Infer the GLX drawable type. */
if (__glXGetDrawableAttribute(dpy, glxDrawable, GLX_DRAWABLE_TYPE, &type)) {
/* Xserver may support query with raw X11 window. */
if (type == GLX_PIXMAP_BIT) {
ErrorMessageF("GLXPixmap drawable type is not supported\n");
return NULL;
}
} else {
/* Xserver may not implement GLX_DRAWABLE_TYPE query yet. */
type = GLX_PBUFFER_BIT | GLX_WINDOW_BIT;
}
pdraw = psc->driScreen.createDrawable(psc, glxDrawable, glxDrawable,
type, config);
if (pdraw == NULL) {
ErrorMessageF("failed to create drawable\n");
return NULL;
}
if (__glxHashInsert(priv->drawHash, glxDrawable, pdraw)) {
pdraw->destroyDrawable(pdraw);
return NULL;
}
pdraw->refcount = 1;
return pdraw;
}
static int
discardGLXBadDrawableHandler(Display *display, xError *err, XExtCodes *codes,
int *ret_code)
{
int code = codes->first_error + GLXBadDrawable;
/* Only discard error which is expected. */
if (err->majorCode == codes->major_opcode &&
err->minorCode == X_GLXGetDrawableAttributes &&
/* newer xserver use GLXBadDrawable, old one use BadDrawable */
(err->errorCode == code || err->errorCode == BadDrawable)) {
*ret_code = 1;
return 1;
}
return 0;
}
static void
checkServerGLXDrawableAlive(const struct glx_display *priv)
{
ErrorType old = XESetError(priv->dpy, priv->codes.extension,
discardGLXBadDrawableHandler);
set_foreach(priv->zombieGLXDrawable, entry) {
__GLXDRIdrawable *pdraw = (__GLXDRIdrawable *)entry->key;
GLXDrawable drawable = pdraw->drawable;
unsigned int dummy;
/* Fail to query, so the window has been closed. Release the GLXDrawable. */
if (!__glXGetDrawableAttribute(priv->dpy, drawable, GLX_WIDTH, &dummy)) {
pdraw->destroyDrawable(pdraw);
__glxHashDelete(priv->drawHash, drawable);
_mesa_set_remove(priv->zombieGLXDrawable, entry);
}
}
XESetError(priv->dpy, priv->codes.extension, old);
}
static void
releaseDrawable(const struct glx_display *priv, GLXDrawable drawable)
{
__GLXDRIdrawable *pdraw;
if (__glxHashLookup(priv->drawHash, drawable, (void *) &pdraw) == 0) {
/* Only native window and pbuffer have same GLX and X11 drawable ID. */
if (pdraw->drawable == pdraw->xDrawable) {
pdraw->refcount --;
/* If pbuffer's refcount reaches 0, it must be imported from other
* display. Because pbuffer created from this display will always
* hold the last refcount until destroy the GLXPbuffer object.
*/
if (pdraw->refcount == 0) {
if (pdraw->psc->keep_native_window_glx_drawable) {
checkServerGLXDrawableAlive(priv);
_mesa_set_add(priv->zombieGLXDrawable, pdraw);
} else {
pdraw->destroyDrawable(pdraw);
__glxHashDelete(priv->drawHash, drawable);
}
}
}
}
}
_X_HIDDEN void
driReleaseDrawables(struct glx_context *gc)
{
const struct glx_display *priv = gc->psc->display;
releaseDrawable(priv, gc->currentDrawable);
releaseDrawable(priv, gc->currentReadable);
gc->currentDrawable = None;
gc->currentReadable = None;
}
_X_HIDDEN int
dri_convert_glx_attribs(unsigned num_attribs, const uint32_t *attribs,
struct dri_ctx_attribs *dca)
{
unsigned i;
uint32_t profile = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
dca->major_ver = 1;
dca->minor_ver = 0;
dca->render_type = GLX_RGBA_TYPE;
dca->reset = __DRI_CTX_RESET_NO_NOTIFICATION;
dca->release = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
dca->flags = 0;
dca->api = __DRI_API_OPENGL;
dca->no_error = 0;
for (i = 0; i < num_attribs; i++) {
switch (attribs[i * 2]) {
case GLX_CONTEXT_MAJOR_VERSION_ARB:
dca->major_ver = attribs[i * 2 + 1];
break;
case GLX_CONTEXT_MINOR_VERSION_ARB:
dca->minor_ver = attribs[i * 2 + 1];
break;
case GLX_CONTEXT_FLAGS_ARB:
dca->flags = attribs[i * 2 + 1];
break;
case GLX_CONTEXT_OPENGL_NO_ERROR_ARB:
dca->no_error = attribs[i * 2 + 1];
break;
case GLX_CONTEXT_PROFILE_MASK_ARB:
profile = attribs[i * 2 + 1];
break;
case GLX_RENDER_TYPE:
dca->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:
dca->reset = __DRI_CTX_RESET_NO_NOTIFICATION;
break;
case GLX_LOSE_CONTEXT_ON_RESET_ARB:
dca->reset = __DRI_CTX_RESET_LOSE_CONTEXT;
break;
default:
return BadValue;
}
break;
case GLX_CONTEXT_RELEASE_BEHAVIOR_ARB:
switch (attribs[i * 2 + 1]) {
case GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB:
dca->release = __DRI_CTX_RELEASE_BEHAVIOR_NONE;
break;
case GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB:
dca->release = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
break;
default:
return BadValue;
}
break;
case GLX_SCREEN:
/* Implies GLX_EXT_no_config_context */
dca->render_type = GLX_DONT_CARE;
break;
default:
/* If an unknown attribute is received, fail.
*/
return BadValue;
}
}
switch (profile) {
case GLX_CONTEXT_CORE_PROFILE_BIT_ARB:
/* This is the default value, but 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."
*/
dca->api = (dca->major_ver > 3 || (dca->major_ver == 3 && dca->minor_ver >= 2))
? __DRI_API_OPENGL_CORE : __DRI_API_OPENGL;
break;
case GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
dca->api = __DRI_API_OPENGL;
break;
case GLX_CONTEXT_ES_PROFILE_BIT_EXT:
if (dca->major_ver >= 3)
dca->api = __DRI_API_GLES3;
else if (dca->major_ver == 2 && dca->minor_ver == 0)
dca->api = __DRI_API_GLES2;
else if (dca->major_ver == 1 && dca->minor_ver < 2)
dca->api = __DRI_API_GLES;
else {
return BadValue;
}
break;
default:
return GLXBadProfileARB;
}
/* Unknown flag value */
if (dca->flags & ~(__DRI_CTX_FLAG_DEBUG |
__DRI_CTX_FLAG_FORWARD_COMPATIBLE |
__DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS |
__DRI_CTX_FLAG_RESET_ISOLATION))
return BadValue;
/* 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 (dca->major_ver < 3 && (dca->flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0)
return BadMatch;
/* It also says:
*
* "OpenGL contexts supporting version 3.0 or later of the API do not
* support color index rendering, even if a color index <config> is
* available."
*/
if (dca->major_ver >= 3 && dca->render_type == GLX_COLOR_INDEX_TYPE)
return BadMatch;
/* The KHR_no_error specs say:
*
* Requires OpenGL ES 2.0 or OpenGL 2.0.
*/
if (dca->no_error && dca->major_ver < 2)
return BadMatch;
/* 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 (dca->no_error && ((dca->flags & __DRI_CTX_FLAG_DEBUG) ||
(dca->flags & __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS)))
return BadMatch;
return Success;
}
unsigned
dri_context_error_to_glx_error(unsigned error)
{
if (error == __DRI_CTX_ERROR_SUCCESS)
return Success;
if (error == __DRI_CTX_ERROR_NO_MEMORY)
return BadAlloc;
else if (error == __DRI_CTX_ERROR_BAD_API)
return BadMatch;
else if (error == __DRI_CTX_ERROR_BAD_VERSION)
return GLXBadFBConfig;
else if (error == __DRI_CTX_ERROR_BAD_FLAG)
return BadMatch;
else if (error == __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE)
return BadValue;
else if (error == __DRI_CTX_ERROR_UNKNOWN_FLAG)
return BadValue;
else
unreachable("Impossible DRI context error");
}
struct glx_context *
dri_common_create_context(struct glx_screen *base,
struct glx_config *config_base,
struct glx_context *shareList,
int renderType)
{
unsigned int error;
uint32_t attribs[2] = { GLX_RENDER_TYPE, renderType };
return base->vtable->create_context_attribs(base, config_base, shareList,
1, attribs, &error);
}
/*
* Given a display pointer and screen number, determine the name of
* the DRI driver for the screen (i.e., "i965", "radeon", "nouveau", etc).
* Return True for success, False for failure.
*/
static Bool
driGetDriverName(Display * dpy, int scrNum, char **driverName)
{
struct glx_screen *glx_screen = GetGLXScreenConfigs(dpy, scrNum);
if (!glx_screen || !glx_screen->vtable->get_driver_name)
return False;
*driverName = glx_screen->vtable->get_driver_name(glx_screen);
return True;
}
/*
* Exported function for querying the DRI driver for a given screen.
*
* The returned char pointer points to a static array that will be
* overwritten by subsequent calls.
*/
_GLX_PUBLIC const char *
glXGetScreenDriver(Display * dpy, int scrNum)
{
static char ret[32];
char *driverName;
if (driGetDriverName(dpy, scrNum, &driverName)) {
int len;
if (!driverName)
return NULL;
len = strlen(driverName);
if (len >= 31)
return NULL;
memcpy(ret, driverName, len + 1);
free(driverName);
return ret;
}
return NULL;
}
/* glXGetDriverConfig must return a pointer with a static lifetime. To avoid
* keeping drivers loaded and other leaks, we keep a cache of results here that
* is cleared by an atexit handler.
*/
struct driver_config_entry {
struct driver_config_entry *next;
char *driverName;
char *config;
};
static pthread_mutex_t driver_config_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct driver_config_entry *driver_config_cache = NULL;
/* Called as an atexit function. Otherwise, this would have to be called with
* driver_config_mutex locked.
*/
static void
clear_driver_config_cache()
{
while (driver_config_cache) {
struct driver_config_entry *e = driver_config_cache;
driver_config_cache = e->next;
free(e->driverName);
free(e->config);
free(e);
}
}
/*
* Exported function for obtaining a driver's option list (UTF-8 encoded XML).
*
* The returned char pointer points directly into the driver. Therefore
* it should be treated as a constant.
*
* If the driver was not found or does not support configuration NULL is
* returned.
*/
_GLX_PUBLIC const char *
glXGetDriverConfig(const char *driverName)
{
struct driver_config_entry *e;
pthread_mutex_lock(&driver_config_mutex);
for (e = driver_config_cache; e; e = e->next) {
if (strcmp(e->driverName, driverName) == 0)
goto out;
}
e = malloc(sizeof(*e));
if (!e)
goto out;
e->config = pipe_loader_get_driinfo_xml(driverName);
e->driverName = strdup(driverName);
if (!e->config || !e->driverName) {
free(e->config);
free(e->driverName);
free(e);
e = NULL;
goto out;
}
e->next = driver_config_cache;
driver_config_cache = e;
if (!e->next)
atexit(clear_driver_config_cache);
out:
pthread_mutex_unlock(&driver_config_mutex);
return e ? e->config : NULL;
}
static void
driSetBackgroundContext(void *loaderPrivate)
{
__glXSetCurrentContext(loaderPrivate);
}
static GLboolean
driIsThreadSafe(void *loaderPrivate)
{
struct glx_context *pcp = (struct glx_context *) loaderPrivate;
/* Check Xlib is running in thread safe mode
*
* 'lock_fns' is the XLockDisplay function pointer of the X11 display 'dpy'.
* It will be NULL if XInitThreads wasn't called.
*/
return pcp->psc->dpy->lock_fns != NULL;
}
const __DRIbackgroundCallableExtension driBackgroundCallable = {
.base = { __DRI_BACKGROUND_CALLABLE, 2 },
.setBackgroundContext = driSetBackgroundContext,
.isThreadSafe = driIsThreadSafe,
};
const __DRIuseInvalidateExtension dri2UseInvalidate = {
.base = { __DRI_USE_INVALIDATE, 1 }
};
Bool
dri_bind_context(struct glx_context *context, GLXDrawable draw, GLXDrawable read)
{
__GLXDRIdrawable *pdraw, *pread;
struct dri_drawable *dri_draw = NULL, *dri_read = NULL;
pdraw = driFetchDrawable(context, draw);
pread = driFetchDrawable(context, read);
driReleaseDrawables(context);
if (pdraw)
dri_draw = pdraw->dri_drawable;
else if (draw != None)
return GLXBadDrawable;
if (pread)
dri_read = pread->dri_drawable;
else if (read != None)
return GLXBadDrawable;
if (!driBindContext(context->driContext, dri_draw, dri_read))
return GLXBadContext;
if (context->psc->display->driver == GLX_DRIVER_DRI3 ||
context->psc->display->driver == GLX_DRIVER_ZINK_YES) {
if (dri_draw)
dri_invalidate_drawable(dri_draw);
if (dri_read && dri_read != dri_draw)
dri_invalidate_drawable(dri_read);
}
return Success;
}
void
dri_unbind_context(struct glx_context *context)
{
driUnbindContext(context->driContext);
}
void
dri_destroy_context(struct glx_context *context)
{
driReleaseDrawables(context);
free((char *) context->extensions);
driDestroyContext(context->driContext);
free(context);
}
struct glx_context *
dri_create_context_attribs(struct glx_screen *base,
struct glx_config *config_base,
struct glx_context *shareList,
unsigned num_attribs,
const uint32_t *attribs,
unsigned *error)
{
struct glx_context *pcp = NULL;
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
struct dri_context *shared = NULL;
struct dri_ctx_attribs dca;
uint32_t ctx_attribs[2 * 6];
unsigned num_ctx_attribs = 0;
*error = dri_convert_glx_attribs(num_attribs, attribs, &dca);
if (*error != __DRI_CTX_ERROR_SUCCESS)
goto error_exit;
/* Check the renderType value */
if (!validate_renderType_against_config(config_base, dca.render_type)) {
*error = BadValue;
goto error_exit;
}
if (shareList) {
/* We can't share with an indirect context */
if (!shareList->isDirect)
return NULL;
/* 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 (!!shareList->noError != !!dca.no_error) {
*error = BadMatch;
return NULL;
}
shared = shareList->driContext;
}
pcp = calloc(1, sizeof *pcp);
if (pcp == NULL) {
*error = BadAlloc;
goto error_exit;
}
if (!glx_context_init(pcp, base, config_base))
goto error_exit;
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
ctx_attribs[num_ctx_attribs++] = dca.major_ver;
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
ctx_attribs[num_ctx_attribs++] = dca.minor_ver;
/* Only send a value when the non-default value is requested. By doing
* this we don't have to check the driver's DRI3 version before sending the
* default value.
*/
if (dca.reset != __DRI_CTX_RESET_NO_NOTIFICATION) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
ctx_attribs[num_ctx_attribs++] = dca.reset;
}
if (dca.release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
ctx_attribs[num_ctx_attribs++] = dca.release;
}
if (dca.no_error) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_NO_ERROR;
ctx_attribs[num_ctx_attribs++] = dca.no_error;
pcp->noError = GL_TRUE;
}
if (dca.flags != 0) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
ctx_attribs[num_ctx_attribs++] = dca.flags;
}
/* The renderType is retrieved from attribs, or set to default
* of GLX_RGBA_TYPE.
*/
pcp->renderType = dca.render_type;
pcp->driContext =
driCreateContextAttribs(base->frontend_screen,
dca.api,
config ? config->driConfig : NULL,
shared,
num_ctx_attribs / 2,
ctx_attribs,
error,
pcp);
*error = dri_context_error_to_glx_error(*error);
if (pcp->driContext == NULL)
goto error_exit;
pcp->vtable = base->context_vtable;
return pcp;
error_exit:
free(pcp);
return NULL;
}
char *
dri_get_driver_name(struct glx_screen *glx_screen)
{
return strdup(glx_screen->driverName);
}
const struct glx_screen_vtable dri_screen_vtable = {
.create_context = dri_common_create_context,
.create_context_attribs = dri_create_context_attribs,
.query_renderer_integer = glx_dri_query_renderer_integer,
.query_renderer_string = glx_dri_query_renderer_string,
.get_driver_name = dri_get_driver_name,
};
void
dri_bind_tex_image(__GLXDRIdrawable *base, int buffer, const int *attrib_list)
{
struct glx_context *gc = __glXGetCurrentContext();
if (!base)
return;
if (base->psc->display->driver == GLX_DRIVER_DRI3) {
dri_invalidate_drawable(base->dri_drawable);
XSync(gc->currentDpy, false);
}
dri_set_tex_buffer2(gc->driContext,
base->textureTarget,
base->textureFormat,
base->dri_drawable);
}
bool
dri_screen_init(struct glx_screen *psc, struct glx_display *priv, int screen, int fd, const __DRIextension **loader_extensions, bool driver_name_is_inferred)
{
const struct dri_config **driver_configs;
struct glx_config *configs = NULL, *visuals = NULL;
if (!glx_screen_init(psc, screen, priv))
return false;
enum dri_screen_type type;
switch (psc->display->driver) {
case GLX_DRIVER_DRI3:
case GLX_DRIVER_DRI2:
type = DRI_SCREEN_DRI3;
break;
case GLX_DRIVER_ZINK_YES:
type = DRI_SCREEN_KOPPER;
break;
case GLX_DRIVER_SW:
type = DRI_SCREEN_SWRAST;
break;
default:
unreachable("unknown glx driver type");
}
psc->frontend_screen = driCreateNewScreen3(screen, fd,
loader_extensions,
type,
&driver_configs, driver_name_is_inferred,
psc->display->has_multibuffer, psc);
if (psc->frontend_screen == NULL) {
goto handle_error;
}
configs = driConvertConfigs(psc->configs, driver_configs);
visuals = driConvertConfigs(psc->visuals, driver_configs);
if (!configs || !visuals) {
ErrorMessageF("No matching fbConfigs or visuals found\n");
goto handle_error;
}
glx_config_destroy_list(psc->configs);
psc->configs = configs;
glx_config_destroy_list(psc->visuals);
psc->visuals = visuals;
psc->driver_configs = driver_configs;
psc->vtable = &dri_screen_vtable;
psc->driScreen.bindTexImage = dri_bind_tex_image;
return true;
handle_error:
if (configs)
glx_config_destroy_list(configs);
if (visuals)
glx_config_destroy_list(visuals);
return false;
}
#endif /* GLX_DIRECT_RENDERING */
Reference in New Issue View Git Blame Copy Permalink