*
* These functions are compiled into each DRI driver so libGL.so knows nothing
* about them.
- *
- * \note
- * When \c DRI_NEW_INTERFACE_ONLY is defined, code is built / not built so
- * that only the "new" libGL-to-driver interfaces are supported. This breaks
- * backwards compatability. However, this may be necessary when DRI drivers
- * are built to be used in non-XFree86 environments.
- *
- * \todo There are still some places in the code that need to be wrapped with
- * \c DRI_NEW_INTERFACE_ONLY.
*/
-#ifdef GLX_DIRECT_RENDERING
-
-#include <inttypes.h>
#include <assert.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/mman.h>
-#include <X11/Xlibint.h>
-#include <Xext.h>
-#include <extutil.h>
#include <stdio.h>
-#include "dri_util.h"
-#include "xf86dri.h"
-#include "sarea.h"
-#include "glcontextmodes.h"
-/*#define DRI_NEW_INTERFACE_ONLY*/
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *)-1)
+#endif
+
+#include "imports.h"
+#define None 0
+
+#include "dri_util.h"
+#include "drm_sarea.h"
#ifndef GLX_OML_sync_control
-typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRInativeDisplay *dpy, __DRIid drawable, int32_t *numerator, int32_t *denominator);
#endif
-/**
- * This is used in a couple of places that call \c driCreateNewDrawable.
+/* This pointer *must* be set by the driver's __driCreateNewScreen funciton!
*/
-static const int empty_attribute_list[1] = { None };
+const __DRIinterfaceMethods * dri_interface = NULL;
/**
- * Function used to determine if a drawable (window) still exists. Ideally
- * this function comes from libGL. With older versions of libGL from XFree86
- * we can fall-back to an internal version.
- *
- * \sa __driWindowExists __glXWindowExists
+ * This is used in a couple of places that call \c driCreateNewDrawable.
*/
-static PFNGLXWINDOWEXISTSPROC window_exists;
-
-typedef Bool (*PFNGLXCREATECONTEXTWITHCONFIGPROC)( Display*, int, int, void *,
- drmContextPtr );
+static const int empty_attribute_list[1] = { None };
-static PFNGLXCREATECONTEXTWITHCONFIGPROC create_context_with_config;
/**
* Cached copy of the internal API version used by libGL and the client-side
static int api_ver = 0;
/* forward declarations */
-static int driQueryFrameTracking( Display * dpy, void * priv,
- int64_t * sbc, int64_t * missedFrames, float * lastMissedUsage,
- float * usage );
-
-static void *driCreateNewDrawable(Display *dpy, const __GLcontextModes *modes,
- GLXDrawable draw, __DRIdrawable *pdraw, int renderType, const int *attrs);
-
-static void driDestroyDrawable(Display *dpy, void *drawablePrivate);
-
+static int driQueryFrameTracking( __DRInativeDisplay *dpy, void *priv,
+ int64_t *sbc, int64_t *missedFrames,
+ float *lastMissedUsage, float *usage );
+static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
+ const __GLcontextModes *modes,
+ __DRIid draw, __DRIdrawable *pdraw,
+ int renderType, const int *attrs);
-
-#ifdef not_defined
-static Bool driFeatureOn(const char *name)
-{
- char *env = getenv(name);
-
- if (!env) return GL_FALSE;
- if (!strcasecmp(env, "enable")) return GL_TRUE;
- if (!strcasecmp(env, "1")) return GL_TRUE;
- if (!strcasecmp(env, "on")) return GL_TRUE;
- if (!strcasecmp(env, "true")) return GL_TRUE;
- if (!strcasecmp(env, "t")) return GL_TRUE;
- if (!strcasecmp(env, "yes")) return GL_TRUE;
- if (!strcasecmp(env, "y")) return GL_TRUE;
-
- return GL_FALSE;
-}
-#endif /* not_defined */
+static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate);
/**
}
-/*****************************************************************/
-/** \name Visual utility functions */
-/*****************************************************************/
-/*@{*/
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Find a \c __GLcontextModes structure matching the given visual ID.
- *
- * \param dpy Display to search for a matching configuration.
- * \param scrn Screen number on \c dpy to be searched.
- * \param vid Desired \c VisualID to find.
- *
- * \returns A pointer to a \c __GLcontextModes structure that matches \c vid,
- * if found, or \c NULL if no match is found.
- */
-static const __GLcontextModes *
-findConfigMode(Display *dpy, int scrn, VisualID vid,
- const __DRIscreen * pDRIScreen)
-{
- if ( (pDRIScreen != NULL) && (pDRIScreen->private != NULL) ) {
- const __DRIscreenPrivate * const psp =
- (const __DRIscreenPrivate *) pDRIScreen->private;
-
- return _gl_context_modes_find_visual( psp->modes, vid );
- }
-
- return NULL;
-}
-
-
-/**
- * This function is a hack to work-around old versions of libGL.so that
- * do not export \c XF86DRICreateContextWithConfig. I would modify the
- * code to just use this function, but the stand-alone driver (i.e., DRI
- * drivers that are built to work without XFree86) shouldn't have to know
- * about X structures like a \c Visual.
- */
-static Bool
-fake_XF86DRICreateContextWithConfig( Display* dpy, int screen, int configID,
- XID* context, drmContextPtr hHWContext )
-{
- Visual vis;
-
- vis.visualid = configID;
- return XF86DRICreateContext( dpy, screen, & vis, context, hHWContext );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-/*@}*/
-
-
/*****************************************************************/
/** \name Drawable list management */
/*****************************************************************/
/*@{*/
-static Bool __driAddDrawable(void *drawHash, __DRIdrawable *pdraw)
+static GLboolean __driAddDrawable(void *drawHash, __DRIdrawable *pdraw)
{
__DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
return GL_TRUE;
}
-static __DRIdrawable *__driFindDrawable(void *drawHash, GLXDrawable draw)
+static __DRIdrawable *__driFindDrawable(void *drawHash, __DRIid draw)
{
int retcode;
__DRIdrawable *pdraw;
- retcode = drmHashLookup(drawHash, draw, (void **)&pdraw);
+ retcode = drmHashLookup(drawHash, draw, (void *)&pdraw);
if (retcode)
return NULL;
return pdraw;
}
-static void __driRemoveDrawable(void *drawHash, __DRIdrawable *pdraw)
-{
- int retcode;
- __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
-
- retcode = drmHashLookup(drawHash, pdp->draw, (void **)&pdraw);
- if (!retcode) { /* Found */
- drmHashDelete(drawHash, pdp->draw);
- }
-}
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-static Bool __driWindowExistsFlag;
-
-static int __driWindowExistsErrorHandler(Display *dpy, XErrorEvent *xerr)
-{
- if (xerr->error_code == BadWindow) {
- __driWindowExistsFlag = GL_FALSE;
- }
- return 0;
-}
-
-/**
- * Determine if a window associated with a \c GLXDrawable exists on the
- * X-server.
- *
- * \param dpy Display associated with the drawable to be queried.
- * \param draw \c GLXDrawable to test.
- *
- * \returns \c GL_TRUE if a window exists that is associated with \c draw,
- * otherwise \c GL_FALSE is returned.
- *
- * \warning This function is not currently thread-safe.
- *
- * \deprecated
- * \c __glXWindowExists (from libGL) is prefered over this function. Starting
- * with the next major release of XFree86, this function will be removed.
- * Even now this function is no longer directly called. Instead it is called
- * via a function pointer if and only if \c __glXWindowExists does not exist.
- *
- * \sa __glXWindowExists glXGetProcAddress window_exists
- */
-static Bool __driWindowExists(Display *dpy, GLXDrawable draw)
-{
- XWindowAttributes xwa;
- int (*oldXErrorHandler)(Display *, XErrorEvent *);
-
- XSync(dpy, GL_FALSE);
- __driWindowExistsFlag = GL_TRUE;
- oldXErrorHandler = XSetErrorHandler(__driWindowExistsErrorHandler);
- XGetWindowAttributes(dpy, draw, &xwa); /* dummy request */
- XSetErrorHandler(oldXErrorHandler);
- return __driWindowExistsFlag;
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
/**
* Find drawables in the local hash that have been destroyed on the
*/
static void __driGarbageCollectDrawables(void *drawHash)
{
- GLXDrawable draw;
+ __DRIid draw;
+ __DRInativeDisplay *dpy;
__DRIdrawable *pdraw;
- Display *dpy;
- if (drmHashFirst(drawHash, &draw, (void **)&pdraw)) {
+ if (drmHashFirst(drawHash, &draw, (void *)&pdraw) == 1) {
do {
__DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
dpy = pdp->driScreenPriv->display;
- if (! (*window_exists)(dpy, draw)) {
- /* Destroy the local drawable data in the hash table, if the
- drawable no longer exists in the Xserver */
- __driRemoveDrawable(drawHash, pdraw);
+ if (! (*dri_interface->windowExists)(dpy, draw)) {
+ /* Destroy the local drawable data, if the drawable no
+ longer exists in the Xserver */
(*pdraw->destroyDrawable)(dpy, pdraw->private);
- Xfree(pdraw);
+ _mesa_free(pdraw);
}
- } while (drmHashNext(drawHash, &draw, (void **)&pdraw));
+ } while (drmHashNext(drawHash, &draw, (void *)&pdraw) == 1);
}
}
* While casting the opaque private pointers associated with the parameters
* into their respective real types it also assures they are not \c NULL.
*/
-static Bool driUnbindContext3(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
+static GLboolean driUnbindContext(__DRInativeDisplay *dpy, int scrn,
+ __DRIid draw, __DRIid read,
__DRIcontext *ctx)
{
__DRIscreen *pDRIScreen;
/*
** Assume error checking is done properly in glXMakeCurrent before
- ** calling driUnbindContext3.
+ ** calling driUnbindContext.
*/
if (ctx == NULL || draw == None || read == None) {
return GL_FALSE;
}
- pDRIScreen = __glXFindDRIScreen(dpy, scrn);
+ pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return GL_FALSE;
* be needed in those places when support for pbuffers and / or pixmaps
* is added. Is it safe to assume that the drawable is a window?
*/
-static Bool DoBindContext(Display *dpy,
- GLXDrawable draw, GLXDrawable read,
+static GLboolean DoBindContext(__DRInativeDisplay *dpy,
+ __DRIid draw, __DRIid read,
__DRIcontext *ctx, const __GLcontextModes * modes,
__DRIscreenPrivate *psp)
{
__DRIcontextPrivate * const pcp = ctx->private;
- /* Find the _DRIdrawable which corresponds to the writing GLXDrawable */
+ /* Find the _DRIdrawable which corresponds to the writing drawable. */
pdraw = __driFindDrawable(psp->drawHash, draw);
if (!pdraw) {
/* Allocate a new drawable */
- pdraw = (__DRIdrawable *)Xmalloc(sizeof(__DRIdrawable));
+ pdraw = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
if (!pdraw) {
/* ERROR!!! */
return GL_FALSE;
empty_attribute_list);
if (!pdraw->private) {
/* ERROR!!! */
- Xfree(pdraw);
+ _mesa_free(pdraw);
return GL_FALSE;
}
}
pdp = (__DRIdrawablePrivate *) pdraw->private;
- /* Find the _DRIdrawable which corresponds to the reading GLXDrawable */
+ /* Find the _DRIdrawable which corresponds to the reading drawable. */
if (read == draw) {
/* read buffer == draw buffer */
prp = pdp;
pread = __driFindDrawable(psp->drawHash, read);
if (!pread) {
/* Allocate a new drawable */
- pread = (__DRIdrawable *)Xmalloc(sizeof(__DRIdrawable));
+ pread = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
if (!pread) {
/* ERROR!!! */
return GL_FALSE;
empty_attribute_list);
if (!pread->private) {
/* ERROR!!! */
- Xfree(pread);
+ _mesa_free(pread);
return GL_FALSE;
}
}
/* Bind the drawable to the context */
pcp->driDrawablePriv = pdp;
+ pcp->driReadablePriv = prp;
pdp->driContextPriv = pcp;
pdp->refcount++;
if ( pdp != prp ) {
DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
}
+ if ((pdp != prp) && (!prp->pStamp || *prp->pStamp != prp->lastStamp)) {
+ DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+ __driUtilUpdateDrawableInfo(prp);
+ DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+ }
+
/* Call device-specific MakeCurrent */
(*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
* for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
* function.
*/
-static Bool driBindContext3(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
+static GLboolean driBindContext(__DRInativeDisplay *dpy, int scrn,
+ __DRIid draw, __DRIid read,
__DRIcontext * ctx)
{
__DRIscreen *pDRIScreen;
return GL_FALSE;
}
- pDRIScreen = __glXFindDRIScreen(dpy, scrn);
+ pDRIScreen = (*dri_interface->getScreen)(dpy, scrn);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return GL_FALSE;
return DoBindContext( dpy, draw, read, ctx, ctx->mode,
(__DRIscreenPrivate *)pDRIScreen->private );
}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * This function takes both a read buffer and a draw buffer. This is needed
- * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
- * function.
- */
-static Bool driBindContext2(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc)
-{
- __DRIscreen *pDRIScreen;
- const __GLcontextModes *modes;
-
- /*
- ** Assume error checking is done properly in glXMakeCurrent before
- ** calling driBindContext.
- */
-
- if (gc == NULL || draw == None || read == None) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- pDRIScreen = __glXFindDRIScreen(dpy, scrn);
- modes = (driCompareGLXAPIVersion( 20040317 ) >= 0)
- ? gc->driContext.mode
- : findConfigMode( dpy, scrn, gc->vid, pDRIScreen );
-
- if ( modes == NULL ) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- /* findConfigMode will return NULL if the DRI screen or screen private
- * are NULL.
- */
- assert( (pDRIScreen != NULL) && (pDRIScreen->private != NULL) );
-
- return DoBindContext( dpy, draw, read, & gc->driContext, modes,
- (__DRIscreenPrivate *)pDRIScreen->private );
-}
-
-static Bool driUnbindContext2(Display *dpy, int scrn,
- GLXDrawable draw, GLXDrawable read,
- GLXContext gc)
-{
- return driUnbindContext3(dpy, scrn, draw, read, & gc->driContext);
-}
-
-/*
- * Simply call bind with the same GLXDrawable for the read and draw buffers.
- */
-static Bool driBindContext(Display *dpy, int scrn,
- GLXDrawable draw, GLXContext gc)
-{
- return driBindContext2(dpy, scrn, draw, draw, gc);
-}
-
-
-/*
- * Simply call bind with the same GLXDrawable for the read and draw buffers.
- */
-static Bool driUnbindContext(Display *dpy, int scrn,
- GLXDrawable draw, GLXContext gc,
- int will_rebind)
-{
- (void) will_rebind;
- return driUnbindContext2( dpy, scrn, draw, draw, gc );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/*@}*/
* \param pdp pointer to the private drawable information to update.
*
* This function basically updates the __DRIdrawablePrivate struct's
- * cliprect information by calling \c __DRIDrawablePrivate::getInfo. This is
- * usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
+ * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
+ * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
* compares the __DRIdrwablePrivate pStamp and lastStamp values. If
* the values are different that means we have to update the clipping
* info.
__DRIscreenPrivate *psp;
__DRIcontextPrivate *pcp = pdp->driContextPriv;
- if (!pcp || (pdp != pcp->driDrawablePriv)) {
- /* ERROR!!! */
- return;
+ if (!pcp
+ || ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {
+ /* ERROR!!!
+ * ...but we must ignore it. There can be many contexts bound to a
+ * drawable.
+ */
}
psp = pdp->driScreenPriv;
if (!psp) {
/* ERROR!!! */
+ _mesa_problem(NULL, "Warning! Possible infinite loop due to bug "
+ "in file %s, line %d\n",
+ __FILE__, __LINE__);
return;
}
if (pdp->pClipRects) {
- Xfree(pdp->pClipRects);
+ _mesa_free(pdp->pClipRects);
+ pdp->pClipRects = NULL;
}
if (pdp->pBackClipRects) {
- Xfree(pdp->pBackClipRects);
+ _mesa_free(pdp->pBackClipRects);
+ pdp->pBackClipRects = NULL;
}
DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
if (!__driFindDrawable(psp->drawHash, pdp->draw) ||
- ! (*pdp->getInfo)(pdp->display, pdp->screen, pdp->draw,
+ ! (*dri_interface->getDrawableInfo)(pdp->display, pdp->screen, pdp->draw,
&pdp->index, &pdp->lastStamp,
&pdp->x, &pdp->y, &pdp->w, &pdp->h,
&pdp->numClipRects, &pdp->pClipRects,
*
* Is called directly from glXSwapBuffers().
*/
-static void driSwapBuffers( Display *dpy, void *drawablePrivate )
+static void driSwapBuffers( __DRInativeDisplay *dpy, void *drawablePrivate )
{
__DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
+ drm_clip_rect_t rect;
+
dPriv->swapBuffers(dPriv);
- (void) dpy;
+
+ /* Check that we actually have the new damage report method */
+ if (api_ver < 20070105 || dri_interface->reportDamage == NULL)
+ return;
+
+ /* Assume it's affecting the whole drawable for now */
+ rect.x1 = 0;
+ rect.y1 = 0;
+ rect.x2 = rect.x1 + dPriv->w;
+ rect.y2 = rect.y1 + dPriv->h;
+
+ /* Report the damage. Currently, all our drivers draw directly to the
+ * front buffer, so we report the damage there rather than to the backing
+ * store (if any).
+ */
+ (*dri_interface->reportDamage)(dpy, dPriv->screen, dPriv->draw,
+ dPriv->x, dPriv->y,
+ &rect, 1, GL_TRUE);
}
/**
/**
* Called directly from a number of higher-level GLX functions.
*/
-static int driGetSBC( Display *dpy, void *drawablePrivate, int64_t *sbc )
+static int driGetSBC( __DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc )
{
__DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
__DRIswapInfo sInfo;
return status;
}
-static int driWaitForSBC( Display * dpy, void *drawablePriv,
+static int driWaitForSBC( __DRInativeDisplay * dpy, void *drawablePriv,
int64_t target_sbc,
int64_t * msc, int64_t * sbc )
{
msc, sbc );
}
-static int driWaitForMSC( Display * dpy, void *drawablePriv,
+static int driWaitForMSC( __DRInativeDisplay * dpy, void *drawablePriv,
int64_t target_msc,
int64_t divisor, int64_t remainder,
int64_t * msc, int64_t * sbc )
return status;
}
-static int64_t driSwapBuffersMSC( Display * dpy, void *drawablePriv,
+static int64_t driSwapBuffersMSC( __DRInativeDisplay * dpy, void *drawablePriv,
int64_t target_msc,
int64_t divisor, int64_t remainder )
{
remainder );
}
+static void driCopySubBuffer( __DRInativeDisplay *dpy, void *drawablePrivate,
+ int x, int y, int w, int h)
+{
+ __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
+ dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
+ (void) dpy;
+}
/**
* This is called via __DRIscreenRec's createNewDrawable pointer.
*/
-static void *driCreateNewDrawable(Display *dpy,
+static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
const __GLcontextModes *modes,
- GLXDrawable draw,
+ __DRIid draw,
__DRIdrawable *pdraw,
int renderType,
const int *attrs)
{
- __DRIscreen * const pDRIScreen = __glXFindDRIScreen(dpy, modes->screen);
+ __DRIscreen * const pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
__DRIscreenPrivate *psp;
__DRIdrawablePrivate *pdp;
+ pdraw->private = NULL;
+
/* Since pbuffers are not yet supported, no drawable attributes are
* supported either.
*/
return NULL;
}
- pdp = (__DRIdrawablePrivate *)Xmalloc(sizeof(__DRIdrawablePrivate));
+ pdp = (__DRIdrawablePrivate *)_mesa_malloc(sizeof(__DRIdrawablePrivate));
if (!pdp) {
return NULL;
}
- if (!XF86DRICreateDrawable(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
- Xfree(pdp);
+ if (!(*dri_interface->createDrawable)(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
+ _mesa_free(pdp);
return NULL;
}
pdp->driScreenPriv = psp;
pdp->driContextPriv = &psp->dummyContextPriv;
- pdp->getInfo = (GetDrawableInfo *)
- glXGetProcAddress( (const GLubyte *) "__glXGetDrawableInfo" );
- if ( pdp->getInfo == NULL ) {
- pdp->getInfo = XF86DRIGetDrawableInfo;
- }
-
if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
renderType == GLX_PIXMAP_BIT)) {
- (void)XF86DRIDestroyDrawable(dpy, modes->screen, pdp->draw);
- Xfree(pdp);
+ (void)(*dri_interface->destroyDrawable)(dpy, modes->screen, pdp->draw);
+ _mesa_free(pdp);
return NULL;
}
pdraw->destroyDrawable = driDestroyDrawable;
pdraw->swapBuffers = driSwapBuffers; /* called by glXSwapBuffers() */
- if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
- pdraw->getSBC = driGetSBC;
- pdraw->waitForSBC = driWaitForSBC;
- pdraw->waitForMSC = driWaitForMSC;
- pdraw->swapBuffersMSC = driSwapBuffersMSC;
- pdraw->frameTracking = NULL;
- pdraw->queryFrameTracking = driQueryFrameTracking;
-
- /* This special default value is replaced with the configured
- * default value when the drawable is first bound to a direct
- * rendering context. */
- pdraw->swap_interval = (unsigned)-1;
- }
+ pdraw->getSBC = driGetSBC;
+ pdraw->waitForSBC = driWaitForSBC;
+ pdraw->waitForMSC = driWaitForMSC;
+ pdraw->swapBuffersMSC = driSwapBuffersMSC;
+ pdraw->frameTracking = NULL;
+ pdraw->queryFrameTracking = driQueryFrameTracking;
+
+ if (driCompareGLXAPIVersion (20060314) >= 0)
+ pdraw->copySubBuffer = driCopySubBuffer;
+
+ /* This special default value is replaced with the configured
+ * default value when the drawable is first bound to a direct
+ * rendering context.
+ */
+ pdraw->swap_interval = (unsigned)-1;
pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
if (!__driAddDrawable(psp->drawHash, pdraw)) {
/* ERROR!!! */
(*pdraw->destroyDrawable)(dpy, pdp);
- Xfree(pdp);
+ _mesa_free(pdp);
pdp = NULL;
pdraw->private = NULL;
}
return (void *) pdp;
}
-static __DRIdrawable *driGetDrawable(Display *dpy, GLXDrawable draw,
- void *screenPrivate)
+static __DRIdrawable *
+driGetDrawable(__DRInativeDisplay *dpy, __DRIid draw, void *screenPrivate)
{
__DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
return __driFindDrawable(psp->drawHash, draw);
}
-static void driDestroyDrawable(Display *dpy, void *drawablePrivate)
+static void
+driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate)
{
__DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *) drawablePrivate;
- __DRIscreenPrivate *psp = pdp->driScreenPriv;
- int scrn = psp->myNum;
+ __DRIscreenPrivate *psp;
+ int scrn;
if (pdp) {
+ psp = pdp->driScreenPriv;
+ scrn = psp->myNum;
(*psp->DriverAPI.DestroyBuffer)(pdp);
- if ((*window_exists)(dpy, pdp->draw))
- (void)XF86DRIDestroyDrawable(dpy, scrn, pdp->draw);
+ if ((*dri_interface->windowExists)(dpy, pdp->draw))
+ (void)(*dri_interface->destroyDrawable)(dpy, scrn, pdp->draw);
+ drmHashDelete(psp->drawHash, pdp->draw);
if (pdp->pClipRects) {
- Xfree(pdp->pClipRects);
+ _mesa_free(pdp->pClipRects);
pdp->pClipRects = NULL;
}
if (pdp->pBackClipRects) {
- Xfree(pdp->pBackClipRects);
+ _mesa_free(pdp->pBackClipRects);
pdp->pBackClipRects = NULL;
}
- Xfree(pdp);
+ _mesa_free(pdp);
}
}
* This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
* drmDestroyContext(), and finally frees \p contextPrivate.
*/
-static void driDestroyContext(Display *dpy, int scrn, void *contextPrivate)
+static void
+driDestroyContext(__DRInativeDisplay *dpy, int scrn, void *contextPrivate)
{
__DRIcontextPrivate *pcp = (__DRIcontextPrivate *) contextPrivate;
if (pcp) {
(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
__driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
- (void)XF86DRIDestroyContext(dpy, scrn, pcp->contextID);
- Xfree(pcp);
+ (void) (*dri_interface->destroyContext)(dpy, scrn, pcp->contextID);
+ _mesa_free(pcp);
}
}
*
*/
static void *
-driCreateNewContext(Display *dpy, const __GLcontextModes *modes,
+driCreateNewContext(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
int render_type, void *sharedPrivate, __DRIcontext *pctx)
{
__DRIscreen *pDRIScreen;
__DRIscreenPrivate *psp;
void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
- pDRIScreen = __glXFindDRIScreen(dpy, modes->screen);
+ pDRIScreen = (*dri_interface->getScreen)(dpy, modes->screen);
if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
/* ERROR!!! */
return NULL;
psp = (__DRIscreenPrivate *)pDRIScreen->private;
- pcp = (__DRIcontextPrivate *)Xmalloc(sizeof(__DRIcontextPrivate));
+ pcp = (__DRIcontextPrivate *)_mesa_malloc(sizeof(__DRIcontextPrivate));
if (!pcp) {
return NULL;
}
- if (! (*create_context_with_config)(dpy, modes->screen, modes->fbconfigID,
+ if (! (*dri_interface->createContext)(dpy, modes->screen, modes->fbconfigID,
&pcp->contextID, &pcp->hHWContext)) {
- Xfree(pcp);
+ _mesa_free(pcp);
return NULL;
}
}
pctx->destroyContext = driDestroyContext;
-#ifdef DRI_NEW_INTERFACE_ONLY
- pctx->bindContext = NULL;
- pctx->unbindContext = NULL;
- pctx->bindContext2 = NULL;
- pctx->unbindContext2 = NULL;
- pctx->bindContex3 = driBindContext3;
- pctx->unbindContext3 = driUnbindContext3;
-#else
pctx->bindContext = driBindContext;
pctx->unbindContext = driUnbindContext;
- if ( driCompareGLXAPIVersion( 20030606 ) >= 0 ) {
- pctx->bindContext2 = driBindContext2;
- pctx->unbindContext2 = driUnbindContext2;
- }
-
- if ( driCompareGLXAPIVersion( 20040415 ) >= 0 ) {
- pctx->bindContext3 = driBindContext3;
- pctx->unbindContext3 = driUnbindContext3;
- }
-#endif
if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
- (void)XF86DRIDestroyContext(dpy, modes->screen, pcp->contextID);
- Xfree(pcp);
+ (void) (*dri_interface->destroyContext)(dpy, modes->screen,
+ pcp->contextID);
+ _mesa_free(pcp);
return NULL;
}
return pcp;
}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Create the per-drawable private driver information.
- *
- * \param dpy the display handle.
- * \param vis the visual information.
- * \param sharedPrivate the shared context dependent methods or \c NULL if
- * non-existent.
- * \param pctx will receive the context dependent methods.
- *
- * \returns a opaque pointer to the per-context private information on success, or \c NULL
- * on failure.
- *
- * \deprecated
- * This function has been replaced by \c driCreateNewContext. In drivers
- * built to work with XFree86, this function will continue to exist to support
- * older versions of libGL. Starting with the next major relelase of XFree86,
- * this function will be removed.
- *
- * \internal
- * This function allocates and fills a __DRIcontextPrivateRec structure. It
- * gets the visual, converts it into a __GLcontextModesRec and passes it
- * to __DriverAPIRec::CreateContext to create the context.
- */
-static void *driCreateContext(Display *dpy, XVisualInfo *vis,
- void *sharedPrivate, __DRIcontext *pctx)
-{
- __DRIscreen *pDRIScreen;
- const __GLcontextModes *modes;
-
- pDRIScreen = __glXFindDRIScreen(dpy, vis->screen);
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- /* ERROR!!! */
- return NULL;
- }
-
-
- /* Setup a __GLcontextModes struct corresponding to vis->visualid
- * and create the rendering context.
- */
-
- modes = findConfigMode(dpy, vis->screen, vis->visualid, pDRIScreen);
- return (modes == NULL)
- ? NULL
- : driCreateNewContext( dpy, modes, GLX_RGBA_TYPE,
- sharedPrivate, pctx );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
/*@}*/
* This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
* drmClose(), and finally frees \p screenPrivate.
*/
-static void driDestroyScreen(Display *dpy, int scrn, void *screenPrivate)
+static void driDestroyScreen(__DRInativeDisplay *dpy, int scrn, void *screenPrivate)
{
__DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
(void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
(void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
- Xfree(psp->pDevPriv);
- (void)drmClose(psp->fd);
+ _mesa_free(psp->pDevPriv);
+ (void)drmCloseOnce(psp->fd);
if ( psp->modes != NULL ) {
- _gl_context_modes_destroy( psp->modes );
+ (*dri_interface->destroyContextModes)( psp->modes );
}
- Xfree(psp);
+
+ assert(psp->drawHash);
+ drmHashDestroy(psp->drawHash);
+
+ _mesa_free(psp);
}
}
* \param internal_api_version Version of the internal interface between the
* driver and libGL.
* \param driverAPI Driver API functions used by other routines in dri_util.c.
+ *
+ * \note
+ * There is no need to check the minimum API version in this function. Since
+ * the \c __driCreateNewScreen function is versioned, it is impossible for a
+ * loader that is too old to even load this driver.
*/
__DRIscreenPrivate *
-__driUtilCreateNewScreen(Display *dpy, int scrn, __DRIscreen *psc,
+__driUtilCreateNewScreen(__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
__GLcontextModes * modes,
const __DRIversion * ddx_version,
const __DRIversion * dri_version,
const __DRIversion * drm_version,
const __DRIframebuffer * frame_buffer,
- drmAddress pSAREA,
+ drm_sarea_t *pSAREA,
int fd,
int internal_api_version,
const struct __DriverAPIRec *driverAPI)
__DRIscreenPrivate *psp;
-#ifdef DRI_NEW_INTERFACE_ONLY
- if ( internal_api_version < 20040415 ) {
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20040415 or later is required.\n", internal_api_version );
- return NULL;
- }
-#else
- if ( internal_api_version == 20031201 ) {
- fprintf( stderr, "libGL error: libGL version 20031201 has critical "
- "binary compatilibity bugs.\nlibGL error: You must upgrade "
- "to use direct-rendering!\n" );
- return NULL;
- }
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-
- window_exists = (PFNGLXWINDOWEXISTSPROC)
- glXGetProcAddress( (const GLubyte *) "__glXWindowExists" );
-
- if ( window_exists == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20021128 or later is required.\n", internal_api_version );
- return NULL;
-#else
- window_exists = (PFNGLXWINDOWEXISTSPROC) __driWindowExists;
-#endif /* DRI_NEW_INTERFACE_ONLY */
- }
-
- create_context_with_config = (PFNGLXCREATECONTEXTWITHCONFIGPROC)
- glXGetProcAddress( (const GLubyte *) "__glXCreateContextWithConfig" );
- if ( create_context_with_config == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20031201 or later is required.\n", internal_api_version );
- return NULL;
-#else
- create_context_with_config = (PFNGLXCREATECONTEXTWITHCONFIGPROC)
- fake_XF86DRICreateContextWithConfig;
-#endif /* DRI_NEW_INTERFACE_ONLY */
- }
-
api_ver = internal_api_version;
- psp = (__DRIscreenPrivate *)Xmalloc(sizeof(__DRIscreenPrivate));
+ psp = (__DRIscreenPrivate *)_mesa_malloc(sizeof(__DRIscreenPrivate));
if (!psp) {
return NULL;
}
/* Create the hash table */
psp->drawHash = drmHashCreate();
if ( psp->drawHash == NULL ) {
- Xfree( psp );
+ _mesa_free( psp );
return NULL;
}
psp->fbHeight = frame_buffer->height;
psp->devPrivSize = frame_buffer->dev_priv_size;
psp->pDevPriv = frame_buffer->dev_priv;
+ psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
psp->fd = fd;
psp->dummyContextPriv.driScreenPriv = NULL;
psc->destroyScreen = driDestroyScreen;
-#ifndef DRI_NEW_INTERFACE_ONLY
- psc->createContext = driCreateContext;
-#else
- psc->createConteext = NULL;
-#endif
psc->createNewDrawable = driCreateNewDrawable;
psc->getDrawable = driGetDrawable;
-#ifdef DRI_NEW_INTERFACE_ONLY
psc->getMSC = driGetMSC;
psc->createNewContext = driCreateNewContext;
-#else
- if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
- psc->getMSC = driGetMSC;
- if ( driCompareGLXAPIVersion( 20030824 ) >= 0 ) {
- psc->createNewContext = driCreateNewContext;
- }
- }
-#endif
+ if (internal_api_version >= 20070121)
+ psc->setTexOffset = psp->DriverAPI.setTexOffset;
if ( (psp->DriverAPI.InitDriver != NULL)
&& !(*psp->DriverAPI.InitDriver)(psp) ) {
- Xfree( psp );
- return NULL;
- }
-
-
- return psp;
-}
-
-
-#ifndef DRI_NEW_INTERFACE_ONLY
-/**
- * Utility function used to create a new driver-private screen structure.
- *
- * \param dpy Display pointer.
- * \param scrn Index of the screen.
- * \param psc DRI screen data (not driver private)
- * \param numConfigs Number of visual configs pointed to by \c configs.
- * \param configs Array of GLXvisualConfigs exported by the 2D driver.
- * \param driverAPI Driver API functions used by other routines in dri_util.c.
- *
- * \deprecated
- * This function has been replaced by \c __driUtilCreateNewScreen. In drivers
- * built to work with XFree86, this function will continue to exist to support
- * older versions of libGL. Starting with the next major relelase of XFree86,
- * this function will be removed.
- */
-__DRIscreenPrivate *
-__driUtilCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *configs,
- const struct __DriverAPIRec *driverAPI)
-{
- int directCapable;
- __DRIscreenPrivate *psp = NULL;
- drmHandle hSAREA;
- drmAddress pSAREA;
- char *BusID;
- __GLcontextModes *modes;
- __GLcontextModes *temp;
- int i;
- __DRIversion ddx_version;
- __DRIversion dri_version;
- __DRIversion drm_version;
- __DRIframebuffer framebuffer;
- int fd = -1;
- int status;
- const char * err_msg;
- const char * err_extra;
-
-
- if (!XF86DRIQueryDirectRenderingCapable(dpy, scrn, &directCapable)
- || !directCapable) {
- return NULL;
- }
-
-
- /* Create the linked list of context modes, and populate it with the
- * GLX visual information passed in by libGL.
- */
-
- modes = _gl_context_modes_create( numConfigs, sizeof(__GLcontextModes) );
- if ( modes == NULL ) {
+ _mesa_free( psp );
return NULL;
}
- temp = modes;
- for ( i = 0 ; i < numConfigs ; i++ ) {
- assert( temp != NULL );
- _gl_copy_visual_to_context_mode( temp, & configs[i] );
- temp->screen = scrn;
-
- temp = temp->next;
- }
-
- err_msg = "XF86DRIOpenConnection";
- err_extra = NULL;
-
- if (XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
- fd = drmOpen(NULL,BusID);
- Xfree(BusID); /* No longer needed */
-
- err_msg = "open DRM";
- err_extra = strerror( -fd );
-
- if (fd >= 0) {
- drmMagic magic;
-
- err_msg = "drmGetMagic";
- err_extra = NULL;
-
- if (!drmGetMagic(fd, &magic)) {
- drmVersionPtr version = drmGetVersion(fd);
- if (version) {
- drm_version.major = version->version_major;
- drm_version.minor = version->version_minor;
- drm_version.patch = version->version_patchlevel;
- drmFreeVersion(version);
- }
- else {
- drm_version.major = -1;
- drm_version.minor = -1;
- drm_version.patch = -1;
- }
-
- err_msg = "XF86DRIAuthConnection";
- if (XF86DRIAuthConnection(dpy, scrn, magic)) {
- char *driverName;
-
- /*
- * Get device name (like "tdfx") and the ddx version numbers.
- * We'll check the version in each DRI driver's "createScreen"
- * function.
- */
- err_msg = "XF86DRIGetClientDriverName";
- if (XF86DRIGetClientDriverName(dpy, scrn,
- &ddx_version.major,
- &ddx_version.minor,
- &ddx_version.patch,
- &driverName)) {
-
- /* No longer needed. */
- Xfree( driverName );
-
- /*
- * Get the DRI X extension version.
- */
- err_msg = "XF86DRIQueryVersion";
- if (XF86DRIQueryVersion(dpy,
- &dri_version.major,
- &dri_version.minor,
- &dri_version.patch)) {
- drmHandle hFB;
- int junk;
-
- /*
- * Get device-specific info. pDevPriv will point to a struct
- * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h)
- * that has information about the screen size, depth, pitch,
- * ancilliary buffers, DRM mmap handles, etc.
- */
- err_msg = "XF86DRIGetDeviceInfo";
- if (XF86DRIGetDeviceInfo(dpy, scrn,
- &hFB,
- &junk,
- &framebuffer.size,
- &framebuffer.stride,
- &framebuffer.dev_priv_size,
- &framebuffer.dev_priv)) {
- framebuffer.width = DisplayWidth(dpy, scrn);
- framebuffer.height = DisplayHeight(dpy, scrn);
-
- /*
- * Map the framebuffer region.
- */
- status = drmMap(fd, hFB, framebuffer.size,
- (drmAddressPtr)&framebuffer.base);
-
- err_msg = "drmMap of framebuffer";
- err_extra = strerror( -status );
-
- if ( status == 0 ) {
- /*
- * Map the SAREA region. Further mmap regions may be setup in
- * each DRI driver's "createScreen" function.
- */
- status = drmMap(fd, hSAREA, SAREA_MAX,
- &pSAREA);
-
- err_msg = "drmMap of sarea";
- err_extra = strerror( -status );
-
- if ( status == 0 ) {
- PFNGLXGETINTERNALVERSIONPROC get_ver;
-
- get_ver = (PFNGLXGETINTERNALVERSIONPROC)
- glXGetProcAddress( (const GLubyte *) "__glXGetInternalVersion" );
-
- err_msg = "InitDriver";
- err_extra = NULL;
- psp = __driUtilCreateNewScreen( dpy, scrn, psc, modes,
- & ddx_version,
- & dri_version,
- & drm_version,
- & framebuffer,
- pSAREA,
- fd,
- (get_ver != NULL) ? (*get_ver)() : 1,
- driverAPI );
- }
- }
- }
- }
- }
- }
- }
- }
- }
-
- if ( psp == NULL ) {
- if ( pSAREA != MAP_FAILED ) {
- (void)drmUnmap(pSAREA, SAREA_MAX);
- }
-
- if ( framebuffer.base != MAP_FAILED ) {
- (void)drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
- }
-
- if ( framebuffer.dev_priv != NULL ) {
- Xfree(framebuffer.dev_priv);
- }
-
- if ( fd >= 0 ) {
- (void)drmClose(fd);
- }
-
- if ( modes != NULL ) {
- _gl_context_modes_destroy( modes );
- }
-
- (void)XF86DRICloseConnection(dpy, scrn);
-
- if ( err_extra != NULL ) {
- fprintf(stderr, "libGL error: %s failed (%s)\n", err_msg,
- err_extra);
- }
- else {
- fprintf(stderr, "libGL error: %s failed\n", err_msg );
- }
-
- fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
- }
return psp;
}
-#endif /* DRI_NEW_INTERFACE_ONLY */
/**
*
* \sa __glXGetInternalVersion().
*/
-int driCompareGLXAPIVersion( GLuint required_version )
+int driCompareGLXAPIVersion( GLint required_version )
{
if ( api_ver > required_version ) {
return 1;
static int
-driQueryFrameTracking( Display * dpy, void * priv,
+driQueryFrameTracking( __DRInativeDisplay * dpy, void * priv,
int64_t * sbc, int64_t * missedFrames,
float * lastMissedUsage, float * usage )
{
- static PFNGLXGETUSTPROC get_ust;
__DRIswapInfo sInfo;
int status;
int64_t ust;
__DRIdrawablePrivate * dpriv = (__DRIdrawablePrivate *) priv;
- if ( get_ust == NULL ) {
- get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
- }
status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
if ( status == 0 ) {
*missedFrames = sInfo.swap_missed_count;
*lastMissedUsage = sInfo.swap_missed_usage;
- (*get_ust)( & ust );
+ (*dri_interface->getUST)( & ust );
*usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
}
driCalculateSwapUsage( __DRIdrawablePrivate *dPriv, int64_t last_swap_ust,
int64_t current_ust )
{
- static PFNGLXGETMSCRATEOMLPROC get_msc_rate = NULL;
int32_t n;
int32_t d;
int interval;
float usage = 1.0;
- if ( get_msc_rate == NULL ) {
- get_msc_rate = (PFNGLXGETMSCRATEOMLPROC)
- glXGetProcAddress( (const GLubyte *) "glXGetMscRateOML" );
- }
-
- if ( (get_msc_rate != NULL)
- && get_msc_rate( dPriv->display, dPriv->draw, &n, &d ) ) {
+ if ( (*dri_interface->getMSCRate)( dPriv->display, dPriv->draw, &n, &d ) ) {
interval = (dPriv->pdraw->swap_interval != 0)
? dPriv->pdraw->swap_interval : 1;
}
/*@}*/
-
-#endif /* GLX_DIRECT_RENDERING */
projects / mesa.git / blobdiff