#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
+#include <xcb/xproto.h>
+#include <xcb/shm.h>
#include <X11/Xlib.h>
+#include <X11/Xlib-xcb.h>
#include "glxclient.h"
#include <dlfcn.h>
#include "dri_common.h"
+#include "drisw_priv.h"
+#include <X11/extensions/shmproto.h>
+#include <assert.h>
-struct drisw_display
-{
- __GLXDRIdisplay base;
-};
-
-struct drisw_context
-{
- struct glx_context base;
- __DRIcontext *driContext;
-
-};
+static int xshm_error = 0;
+static int xshm_opcode = -1;
-struct drisw_screen
+/**
+ * Catches potential Xlib errors.
+ */
+static int
+handle_xerror(Display *dpy, XErrorEvent *event)
{
- struct glx_screen base;
-
- __DRIscreen *driScreen;
- __GLXDRIscreen vtable;
- const __DRIcoreExtension *core;
- const __DRIswrastExtension *swrast;
- const __DRItexBufferExtension *texBuffer;
+ (void) dpy;
- const __DRIconfig **driver_configs;
+ assert(xshm_opcode != -1);
+ if (event->request_code != xshm_opcode)
+ return 0;
- void *driver;
-};
+ xshm_error = event->error_code;
+ return 0;
+}
-struct drisw_drawable
+static Bool
+XCreateDrawable(struct drisw_drawable * pdp, int shmid, Display * dpy)
{
- __GLXDRIdrawable base;
-
- GC gc;
- GC swapgc;
+ if (pdp->ximage) {
+ XDestroyImage(pdp->ximage);
+ pdp->ximage = NULL;
+ if ((pdp->shminfo.shmid > 0) && (shmid != pdp->shminfo.shmid))
+ XShmDetach(dpy, &pdp->shminfo);
+ }
- __DRIdrawable *driDrawable;
- XVisualInfo *visinfo;
- XImage *ximage;
-};
+ if (!xshm_error && shmid >= 0) {
+ pdp->shminfo.shmid = shmid;
+ pdp->ximage = XShmCreateImage(dpy,
+ NULL,
+ pdp->xDepth,
+ ZPixmap, /* format */
+ NULL, /* data */
+ &pdp->shminfo, /* shminfo */
+ 0, 0); /* width, height */
+ if (pdp->ximage != NULL) {
+ int (*old_handler)(Display *, XErrorEvent *);
+
+ /* dispatch pending errors */
+ XSync(dpy, False);
+
+ old_handler = XSetErrorHandler(handle_xerror);
+ /* This may trigger the X protocol error we're ready to catch: */
+ XShmAttach(dpy, &pdp->shminfo);
+ XSync(dpy, False);
+
+ if (xshm_error) {
+ /* we are on a remote display, this error is normal, don't print it */
+ XDestroyImage(pdp->ximage);
+ pdp->ximage = NULL;
+ }
+
+ (void) XSetErrorHandler(old_handler);
+ }
+ }
-static Bool
-XCreateDrawable(struct drisw_drawable * pdp,
- Display * dpy, XID drawable, int visualid)
-{
- XGCValues gcvalues;
- long visMask;
- XVisualInfo visTemp;
- int num_visuals;
-
- /* create GC's */
- pdp->gc = XCreateGC(dpy, drawable, 0, NULL);
- pdp->swapgc = XCreateGC(dpy, drawable, 0, NULL);
-
- gcvalues.function = GXcopy;
- gcvalues.graphics_exposures = False;
- XChangeGC(dpy, pdp->gc, GCFunction, &gcvalues);
- XChangeGC(dpy, pdp->swapgc, GCFunction, &gcvalues);
- XChangeGC(dpy, pdp->swapgc, GCGraphicsExposures, &gcvalues);
-
- /* visual */
- visTemp.screen = DefaultScreen(dpy);
- visTemp.visualid = visualid;
- visMask = (VisualScreenMask | VisualIDMask);
- pdp->visinfo = XGetVisualInfo(dpy, visMask, &visTemp, &num_visuals);
-
- /* create XImage */
- pdp->ximage = XCreateImage(dpy,
- pdp->visinfo->visual,
- pdp->visinfo->depth,
- ZPixmap, 0, /* format, offset */
- NULL, /* data */
- 0, 0, /* width, height */
- 32, /* bitmap_pad */
- 0); /* bytes_per_line */
+ if (pdp->ximage == NULL) {
+ pdp->shminfo.shmid = -1;
+ pdp->ximage = XCreateImage(dpy,
+ NULL,
+ pdp->xDepth,
+ ZPixmap, 0, /* format, offset */
+ NULL, /* data */
+ 0, 0, /* width, height */
+ 32, /* bitmap_pad */
+ 0); /* bytes_per_line */
+ }
/**
* swrast does not handle 24-bit depth with 24 bpp, so let X do the
static void
XDestroyDrawable(struct drisw_drawable * pdp, Display * dpy, XID drawable)
{
- XDestroyImage(pdp->ximage);
- XFree(pdp->visinfo);
+ if (pdp->ximage)
+ XDestroyImage(pdp->ximage);
+
+ if (pdp->shminfo.shmid > 0)
+ XShmDetach(dpy, &pdp->shminfo);
XFreeGC(dpy, pdp->gc);
- XFreeGC(dpy, pdp->swapgc);
}
/**
}
static void
-swrastPutImage(__DRIdrawable * draw, int op,
- int x, int y, int w, int h,
- char *data, void *loaderPrivate)
+swrastXPutImage(__DRIdrawable * draw, int op,
+ int srcx, int srcy, int x, int y,
+ int w, int h, int stride,
+ int shmid, char *data, void *loaderPrivate)
{
struct drisw_drawable *pdp = loaderPrivate;
__GLXDRIdrawable *pdraw = &(pdp->base);
Display *dpy = pdraw->psc->dpy;
Drawable drawable;
XImage *ximage;
- GC gc;
+ GC gc = pdp->gc;
- switch (op) {
- case __DRI_SWRAST_IMAGE_OP_DRAW:
- gc = pdp->gc;
- break;
- case __DRI_SWRAST_IMAGE_OP_SWAP:
- gc = pdp->swapgc;
- break;
- default:
- return;
+ if (!pdp->ximage || shmid != pdp->shminfo.shmid) {
+ if (!XCreateDrawable(pdp, shmid, dpy))
+ return;
}
drawable = pdraw->xDrawable;
-
ximage = pdp->ximage;
+ ximage->bytes_per_line = stride ? stride : bytes_per_line(w * ximage->bits_per_pixel, 32);
+ ximage->data = data;
+
+ ximage->width = ximage->bytes_per_line / ((ximage->bits_per_pixel + 7)/ 8);
+ ximage->height = h;
+
+ if (pdp->shminfo.shmid >= 0) {
+ XShmPutImage(dpy, drawable, gc, ximage, srcx, srcy, x, y, w, h, False);
+ XSync(dpy, False);
+ } else {
+ XPutImage(dpy, drawable, gc, ximage, srcx, srcy, x, y, w, h);
+ }
+ ximage->data = NULL;
+}
+
+static void
+swrastPutImageShm(__DRIdrawable * draw, int op,
+ int x, int y, int w, int h, int stride,
+ int shmid, char *shmaddr, unsigned offset,
+ void *loaderPrivate)
+{
+ struct drisw_drawable *pdp = loaderPrivate;
+
+ pdp->shminfo.shmaddr = shmaddr;
+ swrastXPutImage(draw, op, 0, 0, x, y, w, h, stride, shmid,
+ shmaddr + offset, loaderPrivate);
+}
+
+static void
+swrastPutImageShm2(__DRIdrawable * draw, int op,
+ int x, int y,
+ int w, int h, int stride,
+ int shmid, char *shmaddr, unsigned offset,
+ void *loaderPrivate)
+{
+ struct drisw_drawable *pdp = loaderPrivate;
+
+ pdp->shminfo.shmaddr = shmaddr;
+ swrastXPutImage(draw, op, x, 0, x, y, w, h, stride, shmid,
+ shmaddr + offset, loaderPrivate);
+}
+
+static void
+swrastPutImage2(__DRIdrawable * draw, int op,
+ int x, int y, int w, int h, int stride,
+ char *data, void *loaderPrivate)
+{
+ swrastXPutImage(draw, op, 0, 0, x, y, w, h, stride, -1,
+ data, loaderPrivate);
+}
+
+static void
+swrastPutImage(__DRIdrawable * draw, int op,
+ int x, int y, int w, int h,
+ char *data, void *loaderPrivate)
+{
+ swrastXPutImage(draw, op, 0, 0, x, y, w, h, 0, -1,
+ data, loaderPrivate);
+}
+
+static void
+swrastGetImage2(__DRIdrawable * read,
+ int x, int y, int w, int h, int stride,
+ char *data, void *loaderPrivate)
+{
+ struct drisw_drawable *prp = loaderPrivate;
+ __GLXDRIdrawable *pread = &(prp->base);
+ Display *dpy = pread->psc->dpy;
+ Drawable readable;
+ XImage *ximage;
+
+ if (!prp->ximage || prp->shminfo.shmid >= 0) {
+ if (!XCreateDrawable(prp, -1, dpy))
+ return;
+ }
+
+ readable = pread->xDrawable;
+
+ ximage = prp->ximage;
ximage->data = data;
ximage->width = w;
ximage->height = h;
- ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32);
+ ximage->bytes_per_line = stride ? stride : bytes_per_line(w * ximage->bits_per_pixel, 32);
- XPutImage(dpy, drawable, gc, ximage, 0, 0, x, y, w, h);
+ XGetSubImage(dpy, readable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0);
ximage->data = NULL;
}
swrastGetImage(__DRIdrawable * read,
int x, int y, int w, int h,
char *data, void *loaderPrivate)
+{
+ swrastGetImage2(read, x, y, w, h, 0, data, loaderPrivate);
+}
+
+static GLboolean
+swrastGetImageShm2(__DRIdrawable * read,
+ int x, int y, int w, int h,
+ int shmid, void *loaderPrivate)
{
struct drisw_drawable *prp = loaderPrivate;
__GLXDRIdrawable *pread = &(prp->base);
Drawable readable;
XImage *ximage;
+ if (!prp->ximage || shmid != prp->shminfo.shmid) {
+ if (!XCreateDrawable(prp, shmid, dpy))
+ return GL_FALSE;
+ }
+
+ if (prp->shminfo.shmid == -1)
+ return GL_FALSE;
readable = pread->xDrawable;
ximage = prp->ximage;
- ximage->data = data;
+ ximage->data = prp->shminfo.shmaddr; /* no offset */
ximage->width = w;
ximage->height = h;
ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32);
- XGetSubImage(dpy, readable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0);
+ XShmGetImage(dpy, readable, ximage, x, y, ~0L);
+ return GL_TRUE;
+}
- ximage->data = NULL;
+static void
+swrastGetImageShm(__DRIdrawable * read,
+ int x, int y, int w, int h,
+ int shmid, void *loaderPrivate)
+{
+ swrastGetImageShm2(read, x, y, w, h, shmid, loaderPrivate);
}
+static const __DRIswrastLoaderExtension swrastLoaderExtension_shm = {
+ .base = {__DRI_SWRAST_LOADER, 6 },
+
+ .getDrawableInfo = swrastGetDrawableInfo,
+ .putImage = swrastPutImage,
+ .getImage = swrastGetImage,
+ .putImage2 = swrastPutImage2,
+ .getImage2 = swrastGetImage2,
+ .putImageShm = swrastPutImageShm,
+ .getImageShm = swrastGetImageShm,
+ .putImageShm2 = swrastPutImageShm2,
+ .getImageShm2 = swrastGetImageShm2,
+};
+
+static const __DRIextension *loader_extensions_shm[] = {
+ &swrastLoaderExtension_shm.base,
+ NULL
+};
+
static const __DRIswrastLoaderExtension swrastLoaderExtension = {
- {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION},
- swrastGetDrawableInfo,
- swrastPutImage,
- swrastGetImage
+ .base = {__DRI_SWRAST_LOADER, 3 },
+
+ .getDrawableInfo = swrastGetDrawableInfo,
+ .putImage = swrastPutImage,
+ .getImage = swrastGetImage,
+ .putImage2 = swrastPutImage2,
+ .getImage2 = swrastGetImage2,
};
-static const __DRIextension *loader_extensions[] = {
- &systemTimeExtension.base,
+static const __DRIextension *loader_extensions_noshm[] = {
&swrastLoaderExtension.base,
NULL
};
driReleaseDrawables(&pcp->base);
- if (context->extensions)
- XFree((char *) context->extensions);
+ free((char *) context->extensions);
(*psc->core->destroyContext) (pcp->driContext);
- Xfree(pcp);
+ free(pcp);
}
static int
driReleaseDrawables(&pcp->base);
- if (pdraw == NULL || pread == NULL)
- return GLXBadDrawable;
-
if ((*psc->core->bindContext) (pcp->driContext,
- pdraw->driDrawable, pread->driDrawable))
+ pdraw ? pdraw->driDrawable : NULL,
+ pread ? pread->driDrawable : NULL))
return Success;
return GLXBadContext;
static void
drisw_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
{
-#if __DRI_TEX_BUFFER_VERSION >= 3
struct glx_context *gc = __glXGetCurrentContext();
- struct dri2_context *pcp = (struct dri2_context *) gc;
+ struct drisw_context *pcp = (struct drisw_context *) gc;
__GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
struct glx_display *dpyPriv = __glXInitialize(dpy);
- struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
- struct dri2_screen *psc;
+ struct drisw_drawable *pdraw = (struct drisw_drawable *) base;
+ struct drisw_screen *psc;
- if (pdraw != NULL) {
- psc = (struct dri2_screen *) base->psc;
+ if (dpyPriv != NULL && pdraw != NULL) {
+ psc = (struct drisw_screen *) base->psc;
if (!psc->texBuffer)
return;
pdraw->driDrawable);
}
}
-#endif
}
static const struct glx_context_vtable drisw_context_vtable = {
- drisw_destroy_context,
- drisw_bind_context,
- drisw_unbind_context,
- NULL,
- NULL,
- DRI_glXUseXFont,
- drisw_bind_tex_image,
- drisw_release_tex_image,
- NULL, /* get_proc_address */
+ .destroy = drisw_destroy_context,
+ .bind = drisw_bind_context,
+ .unbind = drisw_unbind_context,
+ .wait_gl = NULL,
+ .wait_x = NULL,
+ .use_x_font = DRI_glXUseXFont,
+ .bind_tex_image = drisw_bind_tex_image,
+ .release_tex_image = drisw_release_tex_image,
+ .get_proc_address = NULL,
};
static struct glx_context *
if (!psc->base.driScreen)
return NULL;
+ /* Check the renderType value */
+ if (!validate_renderType_against_config(config_base, renderType))
+ return NULL;
+
if (shareList) {
/* If the shareList context is not a DRISW context, we cannot possibly
* create a DRISW context that shares it.
shared = pcp_shared->driContext;
}
- pcp = Xmalloc(sizeof *pcp);
+ pcp = calloc(1, sizeof *pcp);
if (pcp == NULL)
return NULL;
- memset(pcp, 0, sizeof *pcp);
if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
- Xfree(pcp);
+ free(pcp);
return NULL;
}
+ pcp->base.renderType = renderType;
+
pcp->driContext =
(*psc->core->createNewContext) (psc->driScreen,
config->driConfig, shared, pcp);
if (pcp->driContext == NULL) {
- Xfree(pcp);
+ free(pcp);
return NULL;
}
struct drisw_screen *psc = (struct drisw_screen *) base;
__DRIcontext *shared = NULL;
- uint32_t minor_ver = 1;
- uint32_t major_ver = 0;
- uint32_t flags = 0;
+ uint32_t minor_ver;
+ uint32_t major_ver;
+ uint32_t renderType;
+ uint32_t flags;
unsigned api;
- uint32_t ctx_attribs[2 * 4];
+ int reset;
+ int release;
+ uint32_t ctx_attribs[2 * 5];
unsigned num_ctx_attribs = 0;
if (!psc->base.driScreen)
/* Remap the GLX tokens to DRI2 tokens.
*/
if (!dri2_convert_glx_attribs(num_attribs, attribs,
- &major_ver, &minor_ver, &flags, &api,
- error))
+ &major_ver, &minor_ver, &renderType, &flags,
+ &api, &reset, &release, error))
+ return NULL;
+
+ if (!dri2_check_no_error(flags, shareList, major_ver, error))
+ return NULL;
+
+ /* Check the renderType value */
+ if (!validate_renderType_against_config(config_base, renderType)) {
+ return NULL;
+ }
+
+ if (reset != __DRI_CTX_RESET_NO_NOTIFICATION)
+ return NULL;
+
+ if (release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH &&
+ release != __DRI_CTX_RELEASE_BEHAVIOR_NONE)
return NULL;
if (shareList) {
shared = pcp_shared->driContext;
}
- pcp = Xmalloc(sizeof *pcp);
+ pcp = calloc(1, sizeof *pcp);
if (pcp == NULL)
return NULL;
- memset(pcp, 0, sizeof *pcp);
- if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
- Xfree(pcp);
+ if (!glx_context_init(&pcp->base, &psc->base, config_base)) {
+ free(pcp);
return NULL;
}
ctx_attribs[num_ctx_attribs++] = major_ver;
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
ctx_attribs[num_ctx_attribs++] = minor_ver;
+ if (release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) {
+ ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
+ ctx_attribs[num_ctx_attribs++] = release;
+ }
if (flags != 0) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
* GLX_CONTEXT_*_BIT values.
*/
ctx_attribs[num_ctx_attribs++] = flags;
+
+ if (flags & __DRI_CTX_FLAG_NO_ERROR)
+ pcp->base.noError = GL_TRUE;
}
+ pcp->base.renderType = renderType;
+
pcp->driContext =
(*psc->swrast->createContextAttribs) (psc->driScreen,
api,
- config->driConfig,
+ config ? config->driConfig : 0,
shared,
num_ctx_attribs / 2,
ctx_attribs,
error,
pcp);
if (pcp->driContext == NULL) {
- Xfree(pcp);
+ free(pcp);
return NULL;
}
(*psc->core->destroyDrawable) (pdp->driDrawable);
XDestroyDrawable(pdp, pdraw->psc->dpy, pdraw->drawable);
- Xfree(pdp);
+ free(pdp);
}
static __GLXDRIdrawable *
struct drisw_drawable *pdp;
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
struct drisw_screen *psc = (struct drisw_screen *) base;
-
const __DRIswrastExtension *swrast = psc->swrast;
+ Display *dpy = psc->base.dpy;
- pdp = Xmalloc(sizeof(*pdp));
+ pdp = calloc(1, sizeof(*pdp));
if (!pdp)
return NULL;
- memset(pdp, 0, sizeof *pdp);
pdp->base.xDrawable = xDrawable;
pdp->base.drawable = drawable;
pdp->base.psc = &psc->base;
+ pdp->config = modes;
+ pdp->gc = XCreateGC(dpy, xDrawable, 0, NULL);
+ pdp->xDepth = 0;
+
+ /* Use the visual depth, if this fbconfig corresponds to a visual */
+ if (pdp->config->visualID != 0) {
+ int matches = 0;
+ XVisualInfo *visinfo, template;
+
+ template.visualid = pdp->config->visualID;
+ template.screen = pdp->config->screen;
+ visinfo = XGetVisualInfo(dpy, VisualIDMask | VisualScreenMask,
+ &template, &matches);
+
+ if (visinfo && matches) {
+ pdp->xDepth = visinfo->depth;
+ XFree(visinfo);
+ }
+ }
+
+ /* Otherwise, or if XGetVisualInfo failed, ask the server */
+ if (pdp->xDepth == 0) {
+ Window root;
+ int x, y;
+ unsigned uw, uh, bw, depth;
- XCreateDrawable(pdp, psc->base.dpy, xDrawable, modes->visualID);
+ XGetGeometry(dpy, xDrawable, &root, &x, &y, &uw, &uh, &bw, &depth);
+ pdp->xDepth = depth;
+ }
/* Create a new drawable */
pdp->driDrawable =
if (!pdp->driDrawable) {
XDestroyDrawable(pdp, psc->base.dpy, xDrawable);
- Xfree(pdp);
+ free(pdp);
return NULL;
}
static int64_t
driswSwapBuffers(__GLXDRIdrawable * pdraw,
- int64_t target_msc, int64_t divisor, int64_t remainder)
+ int64_t target_msc, int64_t divisor, int64_t remainder,
+ Bool flush)
{
struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw;
struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc;
(void) divisor;
(void) remainder;
+ if (flush) {
+ glFlush();
+ }
+
(*psc->core->swapBuffers) (pdp->driDrawable);
return 0;
}
+static void
+driswCopySubBuffer(__GLXDRIdrawable * pdraw,
+ int x, int y, int width, int height, Bool flush)
+{
+ struct drisw_drawable *pdp = (struct drisw_drawable *) pdraw;
+ struct drisw_screen *psc = (struct drisw_screen *) pdp->base.psc;
+
+ if (flush) {
+ glFlush();
+ }
+
+ (*psc->copySubBuffer->copySubBuffer) (pdp->driDrawable,
+ x, y, width, height);
+}
+
static void
driswDestroyScreen(struct glx_screen *base)
{
psc->driScreen = NULL;
if (psc->driver)
dlclose(psc->driver);
+ free(psc);
}
-static void *
-driOpenSwrast(void)
-{
- void *driver = NULL;
-
- if (driver == NULL)
- driver = driOpenDriver("swrast");
-
- return driver;
-}
+#define SWRAST_DRIVER_NAME "swrast"
static const struct glx_screen_vtable drisw_screen_vtable = {
- drisw_create_context,
- drisw_create_context_attribs
+ .create_context = drisw_create_context,
+ .create_context_attribs = drisw_create_context_attribs,
+ .query_renderer_integer = drisw_query_renderer_integer,
+ .query_renderer_string = drisw_query_renderer_string,
};
static void
if (psc->swrast->base.version >= 3) {
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context");
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile");
+
+ /* DRISW version >= 2 implies support for OpenGL ES.
+ */
+ __glXEnableDirectExtension(&psc->base,
+ "GLX_EXT_create_context_es_profile");
+ __glXEnableDirectExtension(&psc->base,
+ "GLX_EXT_create_context_es2_profile");
}
+ if (psc->copySubBuffer)
+ __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
+
/* FIXME: Figure out what other extensions can be ported here from dri2. */
for (i = 0; extensions[i]; i++) {
if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
__glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
}
+ /* DRISW version 3 is also required because GLX_MESA_query_renderer
+ * requires GLX_ARB_create_context_profile.
+ */
+ if (psc->swrast->base.version >= 3
+ && strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
+ psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
+ __glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer");
+ }
+
+ if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0)
+ __glXEnableDirectExtension(&psc->base,
+ "GLX_ARB_create_context_robustness");
+
+ if (strcmp(extensions[i]->name, __DRI2_FLUSH_CONTROL) == 0) {
+ __glXEnableDirectExtension(&psc->base,
+ "GLX_ARB_context_flush_control");
+ }
}
}
+static int
+check_xshm(Display *dpy)
+{
+ xcb_connection_t *c = XGetXCBConnection(dpy);
+ xcb_void_cookie_t cookie;
+ xcb_generic_error_t *error;
+ int ret = True;
+ int ignore;
+
+ if (!XQueryExtension(dpy, "MIT-SHM", &xshm_opcode, &ignore, &ignore))
+ return False;
+
+ cookie = xcb_shm_detach_checked(c, 0);
+ if ((error = xcb_request_check(c, cookie))) {
+ /* BadRequest means we're a remote client. If we were local we'd
+ * expect BadValue since 'info' has an invalid segment name.
+ */
+ if (error->error_code == BadRequest)
+ ret = False;
+ free(error);
+ }
+
+ return ret;
+}
+
static struct glx_screen *
driswCreateScreen(int screen, struct glx_display *priv)
{
struct drisw_screen *psc;
struct glx_config *configs = NULL, *visuals = NULL;
int i;
+ const __DRIextension **loader_extensions_local;
- psc = Xcalloc(1, sizeof *psc);
+ psc = calloc(1, sizeof *psc);
if (psc == NULL)
return NULL;
- memset(psc, 0, sizeof *psc);
if (!glx_screen_init(&psc->base, screen, priv)) {
- Xfree(psc);
+ free(psc);
return NULL;
}
- psc->driver = driOpenSwrast();
- if (psc->driver == NULL)
+ extensions = driOpenDriver(SWRAST_DRIVER_NAME, &psc->driver);
+ if (extensions == NULL)
goto handle_error;
- extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
- if (extensions == NULL) {
- ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
- goto handle_error;
- }
+ if (!check_xshm(psc->base.dpy))
+ loader_extensions_local = loader_extensions_noshm;
+ else
+ loader_extensions_local = loader_extensions_shm;
for (i = 0; extensions[i]; i++) {
if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
psc->core = (__DRIcoreExtension *) extensions[i];
if (strcmp(extensions[i]->name, __DRI_SWRAST) == 0)
psc->swrast = (__DRIswrastExtension *) extensions[i];
+ if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0)
+ psc->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
}
if (psc->core == NULL || psc->swrast == NULL) {
goto handle_error;
}
- psc->driScreen =
- psc->swrast->createNewScreen(screen, loader_extensions,
- &driver_configs, psc);
+ if (psc->swrast->base.version >= 4) {
+ psc->driScreen =
+ psc->swrast->createNewScreen2(screen, loader_extensions_local,
+ extensions,
+ &driver_configs, psc);
+ } else {
+ psc->driScreen =
+ psc->swrast->createNewScreen(screen, loader_extensions_local,
+ &driver_configs, psc);
+ }
if (psc->driScreen == NULL) {
ErrorMessageF("failed to create dri screen\n");
goto handle_error;
configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
- if (!configs || !visuals)
+ if (!configs || !visuals) {
+ ErrorMessageF("No matching fbConfigs or visuals found\n");
goto handle_error;
+ }
glx_config_destroy_list(psc->base.configs);
psc->base.configs = configs;
psp->createDrawable = driswCreateDrawable;
psp->swapBuffers = driswSwapBuffers;
+ if (psc->copySubBuffer)
+ psp->copySubBuffer = driswCopySubBuffer;
+
return &psc->base;
handle_error:
if (psc->driver)
dlclose(psc->driver);
glx_screen_cleanup(&psc->base);
- Xfree(psc);
+ free(psc);
- ErrorMessageF("reverting to indirect rendering\n");
+ CriticalErrorMessageF("failed to load driver: %s\n", SWRAST_DRIVER_NAME);
return NULL;
}
static void
driswDestroyDisplay(__GLXDRIdisplay * dpy)
{
- Xfree(dpy);
+ free(dpy);
}
/*
{
struct drisw_display *pdpyp;
- pdpyp = Xmalloc(sizeof *pdpyp);
+ pdpyp = malloc(sizeof *pdpyp);
if (pdpyp == NULL)
return NULL;
projects / mesa.git / blobdiff