#ifdef GLX_USE_APPLEGL
#include "apple/apple_glx_context.h"
#include "apple/apple_glx.h"
+#include "util/debug.h"
#else
#include <sys/time.h>
-#ifdef XF86VIDMODE
+#ifndef GLX_USE_WINDOWSGL
#include <X11/extensions/xf86vmode.h>
-#endif
+#endif /* GLX_USE_WINDOWSGL */
#endif
#endif
validate_renderType_against_config(const struct glx_config *config,
int renderType)
{
- switch (renderType) {
- case GLX_RGBA_TYPE:
- return (config->renderType & GLX_RGBA_BIT) != 0;
- case GLX_COLOR_INDEX_TYPE:
- return (config->renderType & GLX_COLOR_INDEX_BIT) != 0;
- case GLX_RGBA_FLOAT_TYPE_ARB:
- return (config->renderType & GLX_RGBA_FLOAT_BIT_ARB) != 0;
- case GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT:
- return (config->renderType & GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT) != 0;
- default:
- break;
- }
- return 0;
+ /* GLX_EXT_no_config_context supports any render type */
+ if (!config)
+ return True;
+
+ switch (renderType) {
+ case GLX_RGBA_TYPE:
+ return (config->renderType & GLX_RGBA_BIT) != 0;
+ case GLX_COLOR_INDEX_TYPE:
+ return (config->renderType & GLX_COLOR_INDEX_BIT) != 0;
+ case GLX_RGBA_FLOAT_TYPE_ARB:
+ return (config->renderType & GLX_RGBA_FLOAT_BIT_ARB) != 0;
+ case GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT:
+ return (config->renderType & GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT) != 0;
+ default:
+ break;
+ }
+ return 0;
}
_X_HIDDEN Bool
return True;
}
+/**
+ * Determine if a context uses direct rendering.
+ *
+ * \param dpy Display where the context was created.
+ * \param contextID ID of the context to be tested.
+ * \param error Out parameter, set to True on error if not NULL
+ *
+ * \returns \c True if the context is direct rendering or not.
+ */
+static Bool
+__glXIsDirect(Display * dpy, GLXContextID contextID, Bool *error)
+{
+ CARD8 opcode;
+ xcb_connection_t *c;
+ xcb_generic_error_t *err;
+ xcb_glx_is_direct_reply_t *reply;
+ Bool is_direct;
+
+ opcode = __glXSetupForCommand(dpy);
+ if (!opcode) {
+ return False;
+ }
+
+ c = XGetXCBConnection(dpy);
+ reply = xcb_glx_is_direct_reply(c, xcb_glx_is_direct(c, contextID), &err);
+ is_direct = (reply != NULL && reply->is_direct) ? True : False;
+
+ if (err != NULL) {
+ if (error)
+ *error = True;
+ __glXSendErrorForXcb(dpy, err);
+ free(err);
+ }
+
+ free(reply);
+
+ return is_direct;
+}
/**
* Create a new context.
gc->share_xid = shareList ? shareList->xid : None;
gc->imported = GL_FALSE;
+ /* Unlike most X resource creation requests, we're about to return a handle
+ * with client-side state, not just an XID. To simplify error handling
+ * elsewhere in libGL, force a round-trip here to ensure the CreateContext
+ * request above succeeded.
+ */
+ {
+ Bool error = False;
+ int isDirect = __glXIsDirect(dpy, gc->xid, &error);
+
+ if (error != False || isDirect != gc->isDirect) {
+ gc->vtable->destroy(gc);
+ gc = NULL;
+ }
+ }
+
return (GLXContext) gc;
}
config = glx_config_find_visual(psc->visuals, vis->visualid);
if (config == NULL) {
- xError error;
-
- error.errorCode = BadValue;
- error.resourceID = vis->visualid;
- error.sequenceNumber = dpy->request;
- error.type = X_Error;
- error.majorCode = __glXSetupForCommand(dpy);
- error.minorCode = X_GLXCreateContext;
- _XError(dpy, &error);
+ __glXSendError(dpy, BadValue, vis->visualid, X_GLXCreateContext, True);
return None;
}
{
struct glx_context *gc = __glXGetCurrentContext();
- if (gc && gc->vtable->wait_gl)
+ if (gc->vtable->wait_gl)
gc->vtable->wait_gl(gc);
}
{
struct glx_context *gc = __glXGetCurrentContext();
- if (gc && gc->vtable->wait_x)
+ if (gc->vtable->wait_x)
gc->vtable->wait_x(gc);
}
{
struct glx_context *gc = __glXGetCurrentContext();
- if (gc && gc->vtable->use_x_font)
+ if (gc->vtable->use_x_font)
gc->vtable->use_x_font(gc, font, first, count, listBase);
}
}
-/**
- * Determine if a context uses direct rendering.
- *
- * \param dpy Display where the context was created.
- * \param contextID ID of the context to be tested.
- *
- * \returns \c True if the context is direct rendering or not.
- */
-static Bool
-__glXIsDirect(Display * dpy, GLXContextID contextID)
-{
- CARD8 opcode;
- xcb_connection_t *c;
- xcb_generic_error_t *err;
- xcb_glx_is_direct_reply_t *reply;
- Bool is_direct;
-
- opcode = __glXSetupForCommand(dpy);
- if (!opcode) {
- return False;
- }
-
- c = XGetXCBConnection(dpy);
- reply = xcb_glx_is_direct_reply(c, xcb_glx_is_direct(c, contextID), &err);
- is_direct = (reply != NULL && reply->is_direct) ? True : False;
-
- if (err != NULL) {
- __glXSendErrorForXcb(dpy, err);
- free(err);
- }
-
- free(reply);
-
- return is_direct;
-}
-
/**
* \todo
* Shouldn't this function \b always return \c False when
#ifdef GLX_USE_APPLEGL /* TODO: indirect on darwin */
return False;
#else
- return __glXIsDirect(dpy, gc->xid);
+ return __glXIsDirect(dpy, gc->xid, NULL);
#endif
}
{
#ifdef GLX_USE_APPLEGL
struct glx_context * gc = __glXGetCurrentContext();
- if(gc && apple_glx_is_current_drawable(dpy, gc->driContext, drawable)) {
+ if(gc != &dummyContext && apple_glx_is_current_drawable(dpy, gc->driContext, drawable)) {
apple_glx_swap_buffers(gc->driContext);
} else {
__glXSendError(dpy, GLXBadCurrentWindow, 0, X_GLXSwapBuffers, false);
__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable);
if (pdraw != NULL) {
- Bool flush = gc && drawable == gc->currentDrawable;
+ Bool flush = gc != &dummyContext && drawable == gc->currentDrawable;
(*pdraw->psc->driScreen->swapBuffers)(pdraw, 0, 0, 0, flush);
return;
** The calling thread may or may not have a current context. If it
** does, send the context tag so the server can do a flush.
*/
- if ((gc != NULL) && (dpy == gc->currentDpy) &&
+ if ((gc != &dummyContext) && (dpy == gc->currentDpy) &&
((drawable == gc->currentDrawable)
|| (drawable == gc->currentReadable))) {
tag = gc->currentContextTag;
config->fbconfigID = (GLXFBConfigID) (GLX_DONT_CARE);
config->swapMethod = GLX_DONT_CARE;
+ config->sRGBCapable = GLX_DONT_CARE;
}
#define MATCH_DONT_CARE( param ) \
MATCH_MASK(drawableType);
MATCH_MASK(renderType);
+ MATCH_DONT_CARE(sRGBCapable);
/* There is a bug in a few of the XFree86 DDX drivers. They contain
* visuals with a "transparent type" of 0 when they really mean GLX_NONE.
/**
* Selects and sorts a subset of the supplied configs based on the attributes.
- * This function forms to basis of \c glXChooseVisual, \c glXChooseFBConfig,
- * and \c glXChooseFBConfigSGIX.
+ * This function forms to basis of \c glXChooseFBConfig and
+ * \c glXChooseFBConfigSGIX.
*
* \param configs Array of pointers to possible configs. The elements of
* this array that do not meet the criteria will be set to
* the various visual / FBConfig selection rules.
* \param num_configs Number of elements in the \c configs array.
* \param attribList Attributes used select from \c configs. This array is
- * terminated by a \c None tag. The array can either take
- * the form expected by \c glXChooseVisual (where boolean
- * tags do not have a value) or by \c glXChooseFBConfig
- * (where every tag has a value).
- * \param fbconfig_style_tags Selects whether \c attribList is in
- * \c glXChooseVisual style or
- * \c glXChooseFBConfig style.
+ * terminated by a \c None tag. The array is of the form
+ * expected by \c glXChooseFBConfig (where every tag has a
+ * value).
* \returns The number of valid elements left in \c configs.
*
- * \sa glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
+ * \sa glXChooseFBConfig, glXChooseFBConfigSGIX
*/
static int
-choose_visual(struct glx_config ** configs, int num_configs,
- const int *attribList, GLboolean fbconfig_style_tags)
+choose_fbconfig(struct glx_config ** configs, int num_configs,
+ const int *attribList)
{
struct glx_config test_config;
int base;
* list.
*/
- init_fbconfig_for_chooser(&test_config, fbconfig_style_tags);
+ init_fbconfig_for_chooser(&test_config, GL_TRUE);
__glXInitializeVisualConfigFromTags(&test_config, 512,
(const INT32 *) attribList,
- GL_TRUE, fbconfig_style_tags);
+ GL_TRUE, GL_TRUE);
base = 0;
for (i = 0; i < num_configs; i++) {
}
#ifdef GLX_USE_APPLEGL
- if(visualList && getenv("LIBGL_DUMP_VISUALID")) {
+ if(visualList && env_var_as_boolean("LIBGL_DUMP_VISUALID", false)) {
printf("visualid 0x%lx\n", visualList[0].visualid);
}
#endif
glXGetCurrentDisplay(void)
{
struct glx_context *gc = __glXGetCurrentContext();
- if (NULL == gc)
+ if (gc == &dummyContext)
return NULL;
return gc->currentDpy;
}
xGLXQueryContextReply reply;
CARD8 opcode;
struct glx_context *ctx;
-
- /* This GLX implementation knows about 5 different properties, so
- * allow the server to send us one of each.
- */
- int propList[5 * 2], *pProp, nPropListBytes;
- int numProps;
- int i, renderType;
- XID share;
- struct glx_config *mode;
+ int i, renderType = GLX_RGBA_TYPE; /* By default, assume RGBA context */
+ XID share = None;
+ struct glx_config *mode = NULL;
uint32_t fbconfigID = 0;
uint32_t visualID = 0;
uint32_t screen = 0;
return NULL;
}
- if (__glXIsDirect(dpy, contextID))
+ if (__glXIsDirect(dpy, contextID, NULL))
return NULL;
opcode = __glXSetupForCommand(dpy);
req->context = contextID;
}
- _XReply(dpy, (xReply *) & reply, 0, False);
-
- if (reply.n <= __GLX_MAX_CONTEXT_PROPS)
- nPropListBytes = reply.n * 2 * sizeof propList[0];
- else
- nPropListBytes = 0;
- _XRead(dpy, (char *) propList, nPropListBytes);
+ if (_XReply(dpy, (xReply *) & reply, 0, False) &&
+ reply.n < (INT32_MAX / 2)) {
+
+ for (i = 0; i < reply.n; i++) {
+ int prop[2];
+
+ _XRead(dpy, (char *)prop, sizeof(prop));
+ switch (prop[0]) {
+ case GLX_SCREEN:
+ screen = prop[1];
+ got_screen = True;
+ break;
+ case GLX_SHARE_CONTEXT_EXT:
+ share = prop[1];
+ break;
+ case GLX_VISUAL_ID_EXT:
+ visualID = prop[1];
+ break;
+ case GLX_FBCONFIG_ID:
+ fbconfigID = prop[1];
+ break;
+ case GLX_RENDER_TYPE:
+ renderType = prop[1];
+ break;
+ }
+ }
+ }
UnlockDisplay(dpy);
SyncHandle();
- numProps = nPropListBytes / (2 * sizeof(propList[0]));
- share = None;
- mode = NULL;
- renderType = GLX_RGBA_TYPE; /* By default, assume RGBA context */
- pProp = propList;
-
- for (i = 0, pProp = propList; i < numProps; i++, pProp += 2)
- switch (pProp[0]) {
- case GLX_SCREEN:
- screen = pProp[1];
- got_screen = True;
- break;
- case GLX_SHARE_CONTEXT_EXT:
- share = pProp[1];
- break;
- case GLX_VISUAL_ID_EXT:
- visualID = pProp[1];
- break;
- case GLX_FBCONFIG_ID:
- fbconfigID = pProp[1];
- break;
- case GLX_RENDER_TYPE:
- renderType = pProp[1];
- break;
- }
-
if (!got_screen)
return NULL;
glXGetFBConfigs(dpy, screen, &list_size);
if ((config_list != NULL) && (list_size > 0) && (attribList != NULL)) {
- list_size = choose_visual(config_list, list_size, attribList, GL_TRUE);
+ list_size = choose_fbconfig(config_list, list_size, attribList);
if (list_size == 0) {
free(config_list);
config_list = NULL;
int renderType, GLXContext shareList, Bool allowDirect)
{
struct glx_config *config = (struct glx_config *) fbconfig;
+ struct glx_config **config_list;
+ int list_size;
+ unsigned i;
+
+ if (!config) {
+ __glXSendError(dpy, GLXBadFBConfig, 0, X_GLXCreateNewContext, false);
+ return NULL;
+ }
+
+ config_list = (struct glx_config **)
+ glXGetFBConfigs(dpy, config->screen, &list_size);
+
+ for (i = 0; i < list_size; i++) {
+ if (config_list[i] == config)
+ break;
+ }
+ free(config_list);
+
+ if (i == list_size) {
+ __glXSendError(dpy, GLXBadFBConfig, 0, X_GLXCreateNewContext, false);
+ return NULL;
+ }
return CreateContext(dpy, config->fbconfigID, config, shareList,
allowDirect, X_GLXCreateNewContext, renderType,
CARD32 *interval_ptr;
CARD8 opcode;
- if (gc == NULL) {
+ if (gc == &dummyContext) {
return GLX_BAD_CONTEXT;
}
psc->driScreen->setSwapInterval) {
__GLXDRIdrawable *pdraw =
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
- psc->driScreen->setSwapInterval(pdraw, interval);
+ /* Simply ignore the command if the GLX drawable has been destroyed but
+ * the context is still bound.
+ */
+ if (pdraw)
+ psc->driScreen->setSwapInterval(pdraw, interval);
return 0;
}
#endif
#ifdef GLX_DIRECT_RENDERING
struct glx_context *gc = __glXGetCurrentContext();
- if (gc != NULL && gc->isDirect) {
+ if (gc != &dummyContext && gc->isDirect) {
struct glx_screen *psc;
psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
if (psc && psc->driScreen && psc->driScreen->setSwapInterval) {
__GLXDRIdrawable *pdraw =
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
- return psc->driScreen->setSwapInterval(pdraw, interval);
+
+ /* Simply ignore the command if the GLX drawable has been destroyed but
+ * the context is still bound.
+ */
+ if (!pdraw)
+ return 0;
+
+ return psc->driScreen->setSwapInterval(pdraw, interval);
}
}
#endif
#ifdef GLX_DIRECT_RENDERING
struct glx_context *gc = __glXGetCurrentContext();
- if (gc != NULL && gc->isDirect) {
+ if (gc != &dummyContext && gc->isDirect) {
struct glx_screen *psc;
psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
if (psc && psc->driScreen && psc->driScreen->getSwapInterval) {
__GLXDRIdrawable *pdraw =
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
- return psc->driScreen->getSwapInterval(pdraw);
+ if (pdraw)
+ return psc->driScreen->getSwapInterval(pdraw);
}
}
#endif
__GLXDRIdrawable *pdraw;
#endif
- if (!gc)
+ if (gc == &dummyContext)
return GLX_BAD_CONTEXT;
#ifdef GLX_DIRECT_RENDERING
if (divisor <= 0 || remainder < 0)
return GLX_BAD_VALUE;
- if (!gc)
+ if (gc == &dummyContext)
return GLX_BAD_CONTEXT;
#ifdef GLX_DIRECT_RENDERING
}
#ifndef GLX_USE_APPLEGL
-/*
-** GLX_SGIX_swap_group
-*/
-static void
-__glXJoinSwapGroupSGIX(Display * dpy, GLXDrawable drawable,
- GLXDrawable member)
-{
- (void) dpy;
- (void) drawable;
- (void) member;
-}
-
-
-/*
-** GLX_SGIX_swap_barrier
-*/
-static void
-__glXBindSwapBarrierSGIX(Display * dpy, GLXDrawable drawable, int barrier)
-{
- (void) dpy;
- (void) drawable;
- (void) barrier;
-}
-
-static Bool
-__glXQueryMaxSwapBarriersSGIX(Display * dpy, int screen, int *max)
-{
- (void) dpy;
- (void) screen;
- (void) max;
- return False;
-}
-
-
/*
** GLX_OML_sync_control
*/
__glxGetMscRate(struct glx_screen *psc,
int32_t * numerator, int32_t * denominator)
{
-#ifdef XF86VIDMODE
+#if !defined(GLX_USE_WINDOWSGL)
XF86VidModeModeLine mode_line;
int dot_clock;
int i;
return True;
}
- else
#endif
return False;
__glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
int32_t * numerator, int32_t * denominator)
{
-#if defined( GLX_DIRECT_RENDERING ) && defined( XF86VIDMODE )
+#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) && !defined(GLX_USE_WINDOWSGL)
__GLXDRIdrawable *draw = GetGLXDRIDrawable(dpy, drawable);
if (draw == NULL)
struct glx_screen *psc = pdraw ? pdraw->psc : NULL;
#endif
- if (!gc) /* no GLX for this */
+ if (gc == &dummyContext) /* no GLX for this */
return -1;
#ifdef GLX_DIRECT_RENDERING
** does, send the context tag so the server can do a flush.
*/
gc = __glXGetCurrentContext();
- if ((gc != NULL) && (dpy == gc->currentDpy) &&
+ if ((gc != &dummyContext) && (dpy == gc->currentDpy) &&
((drawable == gc->currentDrawable) ||
(drawable == gc->currentReadable))) {
tag = gc->currentContextTag;
{
struct glx_context *gc = __glXGetCurrentContext();
- if (gc == NULL || gc->vtable->bind_tex_image == NULL)
+ if (gc->vtable->bind_tex_image == NULL)
return;
gc->vtable->bind_tex_image(dpy, drawable, buffer, attrib_list);
{
struct glx_context *gc = __glXGetCurrentContext();
- if (gc == NULL || gc->vtable->release_tex_image == NULL)
+ if (gc->vtable->release_tex_image == NULL)
return;
gc->vtable->release_tex_image(dpy, drawable, buffer);
GLX_FUNCTION(glXSelectEventSGIX),
GLX_FUNCTION(glXGetSelectedEventSGIX),
- /*** GLX_SGIX_swap_group ***/
- GLX_FUNCTION2(glXJoinSwapGroupSGIX, __glXJoinSwapGroupSGIX),
-
- /*** GLX_SGIX_swap_barrier ***/
- GLX_FUNCTION2(glXBindSwapBarrierSGIX, __glXBindSwapBarrierSGIX),
- GLX_FUNCTION2(glXQueryMaxSwapBarriersSGIX, __glXQueryMaxSwapBarriersSGIX),
-
/*** GLX_MESA_copy_sub_buffer ***/
GLX_FUNCTION2(glXCopySubBufferMESA, __glXCopySubBufferMESA),
f = (gl_function) get_glx_proc_address((const char *) procName);
if ((f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
&& (procName[2] != 'X')) {
-#ifdef GLX_SHARED_GLAPI
+#ifdef GLX_INDIRECT_RENDERING
f = (gl_function) __indirect_get_proc_address((const char *) procName);
#endif
if (!f)
*
* \sa glXGetProcAddressARB
*/
-_GLX_PUBLIC void (*glXGetProcAddress(const GLubyte * procName)) (void)
-#if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
-# if defined(USE_MGL_NAMESPACE)
- __attribute__ ((alias("mglXGetProcAddressARB")));
-# else
- __attribute__ ((alias("glXGetProcAddressARB")));
-# endif
-#else
-{
- return glXGetProcAddressARB(procName);
-}
-#endif /* __GNUC__ */
-
+_GLX_PUBLIC
+GLX_ALIAS(__GLXextFuncPtr, glXGetProcAddress,
+ (const GLubyte * procName),
+ (procName), glXGetProcAddressARB)
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
/**
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
-int
+PUBLIC int
MesaGLInteropGLXQueryDeviceInfo(Display *dpy, GLXContext context,
- mesa_glinterop_device_info *out)
+ struct mesa_glinterop_device_info *out)
{
struct glx_context *gc = (struct glx_context*)context;
int ret;
return ret;
}
-int
+PUBLIC int
MesaGLInteropGLXExportObject(Display *dpy, GLXContext context,
- mesa_glinterop_export_in *in,
- mesa_glinterop_export_out *out)
+ struct mesa_glinterop_export_in *in,
+ struct mesa_glinterop_export_out *out)
{
struct glx_context *gc = (struct glx_context*)context;
int ret;