*
* 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 <stdio.h>
-#ifndef DRI_NEW_INTERFACE_ONLY
-# include <X11/Xlibint.h>
-# include <Xext.h>
-# include <extutil.h>
-# include "xf86dri.h"
-# define _mesa_malloc(b) Xmalloc(b)
-# define _mesa_free(m) Xfree(m)
-#else
-# include "imports.h"
-# define None 0
-#endif /* 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"
-#include "glcontextmodes.h"
+#include "utils.h"
-#ifndef PFNGLXGETMSCRATEOMLPROC
-typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRInativeDisplay *dpy, __DRIid drawable, int32_t *numerator, int32_t *denominator);
+#ifndef GLX_OML_sync_control
+typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);
#endif
/**
- * Weak thread-safety dispatch pointer. Older versions of libGL will not have
- * this symbol, so a "weak" version is included here so that the driver will
- * dynamically link properly. The value is set to \c NULL. This forces the
- * driver to fall back to the old dispatch interface.
+ * This is just a token extension used to signal that the driver
+ * supports setting a read drawable.
*/
-struct _glapi_table *_glapi_DispatchTSD __attribute__((weak)) = NULL;
-
-/**
- * This is used in a couple of places that call \c driCreateNewDrawable.
- */
-static const int empty_attribute_list[1] = { None };
-
-/**
- * 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
- */
-static PFNGLXWINDOWEXISTSPROC window_exists;
-
-typedef GLboolean (*PFNGLXCREATECONTEXTWITHCONFIGPROC)( __DRInativeDisplay*, int, int, void *,
- drm_context_t * );
-
-static PFNGLXCREATECONTEXTWITHCONFIGPROC create_context_with_config;
-
-/**
- * Cached copy of the internal API version used by libGL and the client-side
- * DRI driver.
- */
-static int api_ver = 0;
-
-/* forward declarations */
-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);
-
-static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate);
-
-
-
-
-#ifdef not_defined
-static GLboolean 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 */
-
+const __DRIextension driReadDrawableExtension = {
+ __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION
+};
/**
* Print message to \c stderr if the \c LIBGL_DEBUG environment variable
}
}
-/*
- * fd.o bug #1713: Some rare libGL's have __glXFindDRIScreen defined but do not
- * export it via glXGetProcAddress. These are not supported anymore, so print
- * an error message to that effect. - ajax 2004-10-26
- */
-typedef __DRIscreen *(*PFNGLXFINDDRISCREEN)(__DRInativeDisplay *, int);
-
-static __DRIscreen *glx_find_dri_screen(__DRInativeDisplay *d, int i)
+GLint
+driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )
{
- PFNGLXFINDDRISCREEN findscreen =
- (PFNGLXFINDDRISCREEN)glXGetProcAddress("__glXFindDRIScreen");
+ if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;
+ if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;
+ if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;
+ if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;
- if (!findscreen)
- {
- __driUtilMessage("glXGetProcAddress(\"__glXFindDRIScreen\") failed!");
- __driUtilMessage("Your libGL is too old, please upgrade.");
- return NULL;
- }
- else return findscreen(d, i);
-}
-
-/*****************************************************************/
-/** \name Visual utility functions */
-/*****************************************************************/
-/*@{*/
+ if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;
-#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(__DRInativeDisplay *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 GLboolean
-fake_XF86DRICreateContextWithConfig( __DRInativeDisplay* dpy, int screen, int configID,
- XID* context, drm_context_t * hHWContext )
-{
- Visual vis;
-
- vis.visualid = configID;
- return XF86DRICreateContext( dpy, screen, & vis, context, hHWContext );
-}
-#endif /* DRI_NEW_INTERFACE_ONLY */
-
-/*@}*/
-
-
-/*****************************************************************/
-/** \name Drawable list management */
-/*****************************************************************/
-/*@{*/
-
-static GLboolean __driAddDrawable(void *drawHash, __DRIdrawable *pdraw)
-{
- __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *)pdraw->private;
-
- if (drmHashInsert(drawHash, pdp->draw, pdraw))
- return GL_FALSE;
-
- return GL_TRUE;
-}
-
-static __DRIdrawable *__driFindDrawable(void *drawHash, __DRIid draw)
-{
- int retcode;
- __DRIdrawable *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 GLboolean __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 GLboolean __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
- * server.
- *
- * \param drawHash Hash-table containing all know drawables.
- */
-static void __driGarbageCollectDrawables(void *drawHash)
-{
- __DRIid draw;
- __DRIdrawable *pdraw;
- __DRInativeDisplay *dpy;
-
- if (drmHashFirst(drawHash, &draw, (void **)&pdraw)) {
- 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);
- (*pdraw->destroyDrawable)(dpy, pdraw->private);
- _mesa_free(pdraw);
- }
- } while (drmHashNext(drawHash, &draw, (void **)&pdraw));
- }
+ return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);
}
-/*@}*/
-
-
/*****************************************************************/
/** \name Context (un)binding functions */
/*****************************************************************/
/**
* Unbind context.
*
- * \param dpy the display handle.
- * \param scrn the screen number.
- * \param draw drawable.
- * \param read Current reading drawable.
+ * \param scrn the screen.
* \param gc context.
*
* \return \c GL_TRUE on success, or \c GL_FALSE on failure.
* While casting the opaque private pointers associated with the parameters
* into their respective real types it also assures they are not \c NULL.
*/
-static GLboolean driUnbindContext3(__DRInativeDisplay *dpy, int scrn,
- __DRIid draw, __DRIid read,
- __DRIcontext *ctx)
+static int driUnbindContext(__DRIcontext *pcp)
{
- __DRIscreen *pDRIScreen;
- __DRIdrawable *pdraw;
- __DRIdrawable *pread;
- __DRIcontextPrivate *pcp;
- __DRIscreenPrivate *psp;
- __DRIdrawablePrivate *pdp;
- __DRIdrawablePrivate *prp;
+ __DRIscreen *psp;
+ __DRIdrawable *pdp;
+ __DRIdrawable *prp;
/*
** Assume error checking is done properly in glXMakeCurrent before
- ** calling driUnbindContext3.
+ ** calling driUnbindContext.
*/
- if (ctx == NULL || draw == None || read == None) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- pDRIScreen = glx_find_dri_screen(dpy, scrn);
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- psp = (__DRIscreenPrivate *)pDRIScreen->private;
- pcp = (__DRIcontextPrivate *)ctx->private;
-
- pdraw = __driFindDrawable(psp->drawHash, draw);
- if (!pdraw) {
- /* ERROR!!! */
- return GL_FALSE;
- }
- pdp = (__DRIdrawablePrivate *)pdraw->private;
-
- pread = __driFindDrawable(psp->drawHash, read);
- if (!pread) {
- /* ERROR!!! */
- return GL_FALSE;
- }
- prp = (__DRIdrawablePrivate *)pread->private;
+ if (pcp == NULL)
+ return GL_FALSE;
+ psp = pcp->driScreenPriv;
+ pdp = pcp->driDrawablePriv;
+ prp = pcp->driReadablePriv;
/* Let driver unbind drawable from context */
(*psp->DriverAPI.UnbindContext)(pcp);
-
if (pdp->refcount == 0) {
/* ERROR!!! */
return GL_FALSE;
return GL_TRUE;
}
-
/**
* 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.
- *
- * \bug This function calls \c driCreateNewDrawable in two places with the
- * \c renderType hard-coded to \c GLX_WINDOW_BIT. Some checking might
- * 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 GLboolean DoBindContext(__DRInativeDisplay *dpy,
- __DRIid draw, __DRIid read,
- __DRIcontext *ctx, const __GLcontextModes * modes,
- __DRIscreenPrivate *psp)
+static int driBindContext(__DRIcontext *pcp,
+ __DRIdrawable *pdp,
+ __DRIdrawable *prp)
{
- __DRIdrawable *pdraw;
- __DRIdrawablePrivate *pdp;
- __DRIdrawable *pread;
- __DRIdrawablePrivate *prp;
- __DRIcontextPrivate * const pcp = ctx->private;
-
-
- /* Find the _DRIdrawable which corresponds to the writing drawable. */
- pdraw = __driFindDrawable(psp->drawHash, draw);
- if (!pdraw) {
- /* Allocate a new drawable */
- pdraw = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
- if (!pdraw) {
- /* ERROR!!! */
- return GL_FALSE;
- }
+ __DRIscreenPrivate *psp = pcp->driScreenPriv;
- /* Create a new drawable */
- driCreateNewDrawable(dpy, modes, draw, pdraw, GLX_WINDOW_BIT,
- empty_attribute_list);
- if (!pdraw->private) {
- /* ERROR!!! */
- _mesa_free(pdraw);
- return GL_FALSE;
- }
-
- }
- pdp = (__DRIdrawablePrivate *) pdraw->private;
+ /*
+ ** Assume error checking is done properly in glXMakeCurrent before
+ ** calling driBindContext.
+ */
- /* Find the _DRIdrawable which corresponds to the reading drawable. */
- if (read == draw) {
- /* read buffer == draw buffer */
- prp = pdp;
- }
- else {
- pread = __driFindDrawable(psp->drawHash, read);
- if (!pread) {
- /* Allocate a new drawable */
- pread = (__DRIdrawable *)_mesa_malloc(sizeof(__DRIdrawable));
- if (!pread) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- /* Create a new drawable */
- driCreateNewDrawable(dpy, modes, read, pread, GLX_WINDOW_BIT,
- empty_attribute_list);
- if (!pread->private) {
- /* ERROR!!! */
- _mesa_free(pread);
- return GL_FALSE;
- }
- }
- prp = (__DRIdrawablePrivate *) pread->private;
- }
+ if (pcp == NULL || pdp == None || prp == None)
+ return GL_FALSE;
/* Bind the drawable to the context */
pcp->driDrawablePriv = pdp;
+ pcp->driReadablePriv = prp;
pdp->driContextPriv = pcp;
pdp->refcount++;
if ( pdp != prp ) {
** Now that we have a context associated with this drawable, we can
** initialize the drawable information if has not been done before.
*/
- if (!pdp->pStamp || *pdp->pStamp != pdp->lastStamp) {
- DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
- __driUtilUpdateDrawableInfo(pdp);
- DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+ if (!psp->dri2.enabled) {
+ if (!pdp->pStamp || *pdp->pStamp != pdp->lastStamp) {
+ DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+ __driUtilUpdateDrawableInfo(pdp);
+ 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 */
return GL_TRUE;
}
-
-/**
- * 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 GLboolean driBindContext3(__DRInativeDisplay *dpy, int scrn,
- __DRIid draw, __DRIid read,
- __DRIcontext * ctx)
-{
- __DRIscreen *pDRIScreen;
-
- /*
- ** Assume error checking is done properly in glXMakeCurrent before
- ** calling driBindContext.
- */
-
- if (ctx == NULL || draw == None || read == None) {
- /* ERROR!!! */
- return GL_FALSE;
- }
-
- pDRIScreen = glx_find_dri_screen(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 GLboolean 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 = glx_find_dri_screen(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 GLboolean 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 GLboolean 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 GLboolean 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.
void
__driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp)
{
- __DRIscreenPrivate *psp;
+ __DRIscreenPrivate *psp = pdp->driScreenPriv;
__DRIcontextPrivate *pcp = pdp->driContextPriv;
- if (!pcp || (pdp != pcp->driDrawablePriv)) {
- /* ERROR!!! */
- return;
- }
-
- psp = pdp->driScreenPriv;
- if (!psp) {
- /* 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.
+ */
}
if (pdp->pClipRects) {
_mesa_free(pdp->pClipRects);
+ pdp->pClipRects = NULL;
}
if (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,
+ if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,
&pdp->index, &pdp->lastStamp,
&pdp->x, &pdp->y, &pdp->w, &pdp->h,
&pdp->numClipRects, &pdp->pClipRects,
&pdp->backX,
&pdp->backY,
&pdp->numBackClipRects,
- &pdp->pBackClipRects )) {
+ &pdp->pBackClipRects,
+ pdp->loaderPrivate)) {
/* Error -- eg the window may have been destroyed. Keep going
* with no cliprects.
*/
pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
-
}
/*@}*/
/*****************************************************************/
/*@{*/
+static void driReportDamage(__DRIdrawable *pdp,
+ struct drm_clip_rect *pClipRects, int numClipRects)
+{
+ __DRIscreen *psp = pdp->driScreenPriv;
+
+ /* Check that we actually have the new damage report method */
+ if (psp->damage) {
+ /* Report the damage. Currently, all our drivers draw
+ * directly to the front buffer, so we report the damage there
+ * rather than to the backing storein (if any).
+ */
+ (*psp->damage->reportDamage)(pdp,
+ pdp->x, pdp->y,
+ pClipRects, numClipRects,
+ GL_TRUE, pdp->loaderPrivate);
+ }
+}
+
+
/**
* Swap buffers.
*
- * \param dpy the display handle.
* \param drawablePrivate opaque pointer to the per-drawable private info.
*
* \internal
*
* Is called directly from glXSwapBuffers().
*/
-static void driSwapBuffers( __DRInativeDisplay *dpy, void *drawablePrivate )
+static void driSwapBuffers(__DRIdrawable *dPriv)
{
- __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
- dPriv->swapBuffers(dPriv);
- (void) dpy;
-}
+ __DRIscreen *psp = dPriv->driScreenPriv;
-/**
- * Called directly from a number of higher-level GLX functions.
- */
-static int driGetMSC( void *screenPrivate, int64_t *msc )
-{
- __DRIscreenPrivate *sPriv = (__DRIscreenPrivate *) screenPrivate;
-
- return sPriv->DriverAPI.GetMSC( sPriv, msc );
-}
+ if (!dPriv->numClipRects)
+ return;
-/**
- * Called directly from a number of higher-level GLX functions.
- */
-static int driGetSBC( __DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc )
-{
- __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePrivate;
- __DRIswapInfo sInfo;
- int status;
+ psp->DriverAPI.SwapBuffers(dPriv);
-
- status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
- *sbc = sInfo.swap_count;
-
- return status;
+ driReportDamage(dPriv, dPriv->pClipRects, dPriv->numClipRects);
}
-static int driWaitForSBC( __DRInativeDisplay * dpy, void *drawablePriv,
- int64_t target_sbc,
- int64_t * msc, int64_t * sbc )
+static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,
+ int64_t *msc )
{
- __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
-
- return dPriv->driScreenPriv->DriverAPI.WaitForSBC( dPriv, target_sbc,
- msc, sbc );
+ return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);
}
-static int driWaitForMSC( __DRInativeDisplay * dpy, void *drawablePriv,
- int64_t target_msc,
- int64_t divisor, int64_t remainder,
- int64_t * msc, int64_t * sbc )
+
+static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,
+ int64_t divisor, int64_t remainder,
+ int64_t * msc, int64_t * sbc)
{
- __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
__DRIswapInfo sInfo;
int status;
-
status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
divisor, remainder,
msc );
return status;
}
-static int64_t driSwapBuffersMSC( __DRInativeDisplay * dpy, void *drawablePriv,
- int64_t target_msc,
- int64_t divisor, int64_t remainder )
+
+const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {
+ { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },
+ driWaitForMSC,
+ driDrawableGetMSC,
+};
+
+
+static void driCopySubBuffer(__DRIdrawable *dPriv,
+ int x, int y, int w, int h)
+{
+ drm_clip_rect_t rect;
+
+ rect.x1 = x;
+ rect.y1 = dPriv->h - y - h;
+ rect.x2 = x + w;
+ rect.y2 = rect.y1 + h;
+ driReportDamage(dPriv, &rect, 1);
+
+ dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
+}
+
+const __DRIcopySubBufferExtension driCopySubBufferExtension = {
+ { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },
+ driCopySubBuffer
+};
+
+static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)
{
- __DRIdrawablePrivate *dPriv = (__DRIdrawablePrivate *) drawablePriv;
+ dPriv->swap_interval = interval;
+}
- return dPriv->driScreenPriv->DriverAPI.SwapBuffersMSC( dPriv, target_msc,
- divisor,
- remainder );
+static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)
+{
+ return dPriv->swap_interval;
}
+const __DRIswapControlExtension driSwapControlExtension = {
+ { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },
+ driSetSwapInterval,
+ driGetSwapInterval
+};
+
/**
* This is called via __DRIscreenRec's createNewDrawable pointer.
*/
-static void *driCreateNewDrawable(__DRInativeDisplay *dpy,
- const __GLcontextModes *modes,
- __DRIid draw,
- __DRIdrawable *pdraw,
- int renderType,
- const int *attrs)
+static __DRIdrawable *
+driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,
+ drm_drawable_t hwDrawable, int renderType,
+ const int *attrs, void *data)
{
- __DRIscreen * const pDRIScreen = glx_find_dri_screen(dpy, modes->screen);
- __DRIscreenPrivate *psp;
- __DRIdrawablePrivate *pdp;
-
-
- pdraw->private = NULL;
+ __DRIdrawable *pdp;
/* Since pbuffers are not yet supported, no drawable attributes are
* supported either.
*/
(void) attrs;
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- return NULL;
- }
-
- pdp = (__DRIdrawablePrivate *)_mesa_malloc(sizeof(__DRIdrawablePrivate));
+ pdp = _mesa_malloc(sizeof *pdp);
if (!pdp) {
return NULL;
}
- if (!XF86DRICreateDrawable(dpy, modes->screen, draw, &pdp->hHWDrawable)) {
- _mesa_free(pdp);
- return NULL;
- }
-
- pdp->draw = draw;
- pdp->pdraw = pdraw;
+ pdp->loaderPrivate = data;
+ pdp->hHWDrawable = hwDrawable;
pdp->refcount = 0;
pdp->pStamp = NULL;
pdp->lastStamp = 0;
pdp->numBackClipRects = 0;
pdp->pClipRects = NULL;
pdp->pBackClipRects = NULL;
- pdp->display = dpy;
- pdp->screen = modes->screen;
+ pdp->vblSeq = 0;
+ pdp->vblFlags = 0;
- psp = (__DRIscreenPrivate *)pDRIScreen->private;
pdp->driScreenPriv = psp;
pdp->driContextPriv = &psp->dummyContextPriv;
- pdp->getInfo = (PFNGLXGETDRAWABLEINFOPROC)
- glXGetProcAddress( (const GLubyte *) "__glXGetDrawableInfo" );
- if ( pdp->getInfo == NULL ) {
-#ifdef DRI_NEW_INTERFACE_ONLY
- (void)XF86DRIDestroyDrawable(dpy, modes->screen, pdp->draw);
- _mesa_free(pdp);
- return NULL;
-#else
- pdp->getInfo = XF86DRIGetDrawableInfo;
-#endif /* DRI_NEW_INTERFACE_ONLY */
- }
-
- if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, modes,
+ if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes,
renderType == GLX_PIXMAP_BIT)) {
- (void)XF86DRIDestroyDrawable(dpy, modes->screen, pdp->draw);
_mesa_free(pdp);
return NULL;
}
- pdraw->private = pdp;
- 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;
- }
-
- pdp->swapBuffers = psp->DriverAPI.SwapBuffers;
+ pdp->msc_base = 0;
- /* Add pdraw to drawable list */
- if (!__driAddDrawable(psp->drawHash, pdraw)) {
- /* ERROR!!! */
- (*pdraw->destroyDrawable)(dpy, pdp);
- _mesa_free(pdp);
- pdp = NULL;
- pdraw->private = NULL;
- }
+ /* This special default value is replaced with the configured
+ * default value when the drawable is first bound to a direct
+ * rendering context.
+ */
+ pdp->swap_interval = (unsigned)-1;
- return (void *) pdp;
+ return pdp;
}
-static __DRIdrawable *driGetDrawable(__DRInativeDisplay *dpy, __DRIid draw,
- void *screenPrivate)
+
+static __DRIdrawable *
+dri2CreateNewDrawable(__DRIscreen *screen,
+ const __DRIconfig *config,
+ void *loaderPrivate)
{
- __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
+ __DRIdrawable *pdraw;
- /*
- ** Make sure this routine returns NULL if the drawable is not bound
- ** to a direct rendering context!
- */
- return __driFindDrawable(psp->drawHash, draw);
+ pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);
+ if (!pdraw)
+ return NULL;
+
+ pdraw->pClipRects = _mesa_malloc(sizeof *pdraw->pBackClipRects);
+ pdraw->pBackClipRects = _mesa_malloc(sizeof *pdraw->pBackClipRects);
+
+ return pdraw;
}
-static void driDestroyDrawable(__DRInativeDisplay *dpy, void *drawablePrivate)
+
+static void
+driDestroyDrawable(__DRIdrawable *pdp)
{
- __DRIdrawablePrivate *pdp = (__DRIdrawablePrivate *) drawablePrivate;
- __DRIscreenPrivate *psp = pdp->driScreenPriv;
- int scrn = psp->myNum;
+ __DRIscreenPrivate *psp;
if (pdp) {
+ psp = pdp->driScreenPriv;
(*psp->DriverAPI.DestroyBuffer)(pdp);
- if ((*window_exists)(dpy, pdp->draw))
- (void)XF86DRIDestroyDrawable(dpy, scrn, pdp->draw);
if (pdp->pClipRects) {
_mesa_free(pdp->pClipRects);
pdp->pClipRects = NULL;
/**
* Destroy the per-context private information.
*
- * \param dpy the display handle.
- * \param scrn the screen number.
- * \param contextPrivate opaque pointer to the per-drawable private info.
- *
* \internal
* This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
* drmDestroyContext(), and finally frees \p contextPrivate.
*/
-static void driDestroyContext(__DRInativeDisplay *dpy, int scrn, void *contextPrivate)
+static void
+driDestroyContext(__DRIcontext *pcp)
{
- __DRIcontextPrivate *pcp = (__DRIcontextPrivate *) contextPrivate;
-
if (pcp) {
(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
- __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
- (void)XF86DRIDestroyContext(dpy, scrn, pcp->contextID);
_mesa_free(pcp);
}
}
/**
* Create the per-drawable private driver information.
*
- * \param dpy The display handle.
- * \param modes Mode used to create the new context.
* \param render_type Type of rendering target. \c GLX_RGBA is the only
* type likely to ever be supported for direct-rendering.
- * \param sharedPrivate The shared context dependent methods or \c NULL if
- * non-existent.
- * \param pctx DRI context to receive the context dependent methods.
+ * \param shared Context with which to share textures, etc. or NULL
*
* \returns An opaque pointer to the per-context private information on
* success, or \c NULL on failure.
* context.
*
*/
-static void *
-driCreateNewContext(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
- int render_type, void *sharedPrivate, __DRIcontext *pctx)
+static __DRIcontext *
+driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,
+ int render_type, __DRIcontext *shared,
+ drm_context_t hwContext, void *data)
{
- __DRIscreen *pDRIScreen;
- __DRIcontextPrivate *pcp;
- __DRIcontextPrivate *pshare = (__DRIcontextPrivate *) sharedPrivate;
- __DRIscreenPrivate *psp;
- void * const shareCtx = (pshare != NULL) ? pshare->driverPrivate : NULL;
-
- pDRIScreen = glx_find_dri_screen(dpy, modes->screen);
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- /* ERROR!!! */
- return NULL;
- }
-
- psp = (__DRIscreenPrivate *)pDRIScreen->private;
+ __DRIcontext *pcp;
+ void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
- pcp = (__DRIcontextPrivate *)_mesa_malloc(sizeof(__DRIcontextPrivate));
- if (!pcp) {
+ pcp = _mesa_malloc(sizeof *pcp);
+ if (!pcp)
return NULL;
- }
- if (! (*create_context_with_config)(dpy, modes->screen, modes->fbconfigID,
- &pcp->contextID, &pcp->hHWContext)) {
- _mesa_free(pcp);
- return NULL;
- }
-
- pcp->display = dpy;
pcp->driScreenPriv = psp;
pcp->driDrawablePriv = NULL;
* context.
*/
- if (!psp->dummyContextPriv.driScreenPriv) {
- psp->dummyContextPriv.contextID = 0;
+ if (!psp->dri2.enabled && !psp->dummyContextPriv.driScreenPriv) {
psp->dummyContextPriv.hHWContext = psp->pSAREA->dummy_context;
psp->dummyContextPriv.driScreenPriv = psp;
psp->dummyContextPriv.driDrawablePriv = NULL;
/* No other fields should be used! */
}
- pctx->destroyContext = driDestroyContext;
-#ifdef DRI_NEW_INTERFACE_ONLY
- pctx->bindContext = NULL;
- pctx->unbindContext = NULL;
- pctx->bindContext2 = NULL;
- pctx->unbindContext2 = NULL;
- pctx->bindContext3 = 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
+ pcp->hHWContext = hwContext;
- if ( !(*psp->DriverAPI.CreateContext)(modes, pcp, shareCtx) ) {
- (void)XF86DRIDestroyContext(dpy, modes->screen, pcp->contextID);
+ if ( !(*psp->DriverAPI.CreateContext)(&config->modes, pcp, shareCtx) ) {
_mesa_free(pcp);
return NULL;
}
- __driGarbageCollectDrawables(pcp->driScreenPriv->drawHash);
-
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)
+static __DRIcontext *
+dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,
+ __DRIcontext *shared, void *data)
{
- __DRIscreen *pDRIScreen;
- const __GLcontextModes *modes;
-
- pDRIScreen = glx_find_dri_screen(dpy, vis->screen);
- if ( (pDRIScreen == NULL) || (pDRIScreen->private == NULL) ) {
- /* ERROR!!! */
- return NULL;
- }
-
+ return driCreateNewContext(screen, config, 0, shared, 0, data);
+}
- /* 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 );
+static int
+driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)
+{
+ return GL_FALSE;
}
-#endif /* DRI_NEW_INTERFACE_ONLY */
/*@}*/
/**
* Destroy the per-screen private information.
*
- * \param dpy the display handle.
- * \param scrn the screen number.
- * \param screenPrivate opaque pointer to the per-screen private information.
- *
* \internal
* This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
* drmClose(), and finally frees \p screenPrivate.
*/
-static void driDestroyScreen(__DRInativeDisplay *dpy, int scrn, void *screenPrivate)
+static void driDestroyScreen(__DRIscreen *psp)
{
- __DRIscreenPrivate *psp = (__DRIscreenPrivate *) screenPrivate;
-
if (psp) {
/* No interaction with the X-server is possible at this point. This
* routine is called after XCloseDisplay, so there is no protocol
if (psp->DriverAPI.DestroyScreen)
(*psp->DriverAPI.DestroyScreen)(psp);
- (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
- (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
- _mesa_free(psp->pDevPriv);
- (void)drmClose(psp->fd);
- if ( psp->modes != NULL ) {
- _gl_context_modes_destroy( psp->modes );
+ if (!psp->dri2.enabled) {
+ (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+ (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+ (void)drmCloseOnce(psp->fd);
}
+
_mesa_free(psp);
}
}
+static void
+setupLoaderExtensions(__DRIscreen *psp,
+ const __DRIextension **extensions)
+{
+ int i;
+
+ for (i = 0; extensions[i]; i++) {
+ if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)
+ psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];
+ if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)
+ psp->damage = (__DRIdamageExtension *) extensions[i];
+ if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)
+ psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];
+ if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)
+ psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];
+ }
+}
/**
- * Utility function used to create a new driver-private screen structure.
+ * This is the bootstrap function for the driver. libGL supplies all of the
+ * requisite information about the system, and the driver initializes itself.
+ * This routine also fills in the linked list pointed to by \c driver_modes
+ * with the \c __GLcontextModes that the driver can support for windows or
+ * pbuffers.
+ *
+ * For legacy DRI.
*
- * \param dpy Display pointer
* \param scrn Index of the screen
- * \param psc DRI screen data (not driver private)
- * \param modes Linked list of known display modes. This list is, at a
- * minimum, a list of modes based on the current display mode.
- * These roughly match the set of available X11 visuals, but it
- * need not be limited to X11! The calling libGL should create
- * a list that will inform the driver of the current display
- * mode (i.e., color buffer depth, depth buffer depth, etc.).
* \param ddx_version Version of the 2D DDX. This may not be meaningful for
* all drivers.
* \param dri_version Version of the "server-side" DRI.
* framebuffer.
* \param pSAREA Pointer the the SAREA.
* \param fd Device handle for the DRM.
- * \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.
+ * \param extensions ??
+ * \param driver_modes Returns modes suppoted by the driver
+ * \param loaderPrivate ??
+ *
+ * \note There is no need to check the minimum API version in this
+ * function. Since the name of this function is versioned, it is
+ * impossible for a loader that is too old to even load this driver.
*/
-__DRIscreenPrivate *
-__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,
- 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 < 20040602 ) {
- fprintf( stderr, "libGL error: libGL.so version (%08u) is too old. "
- "20040602 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" );
+static __DRIscreen *
+driCreateNewScreen(int scrn,
+ const __DRIversion *ddx_version,
+ const __DRIversion *dri_version,
+ const __DRIversion *drm_version,
+ const __DRIframebuffer *frame_buffer,
+ drmAddress pSAREA, int fd,
+ const __DRIextension **extensions,
+ const __DRIconfig ***driver_modes,
+ void *loaderPrivate)
+{
+ static const __DRIextension *emptyExtensionList[] = { NULL };
+ __DRIscreen *psp;
+
+ psp = _mesa_malloc(sizeof *psp);
+ if (!psp)
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 *)_mesa_malloc(sizeof(__DRIscreenPrivate));
- if (!psp) {
- return NULL;
- }
-
- /* Create the hash table */
- psp->drawHash = drmHashCreate();
- if ( psp->drawHash == NULL ) {
- _mesa_free( psp );
- return NULL;
- }
-
- psp->display = dpy;
- psp->myNum = scrn;
- psp->psc = psc;
- psp->modes = modes;
+ setupLoaderExtensions(psp, extensions);
/*
** NOT_DONE: This is used by the X server to detect when the client
*/
psp->drawLockID = 1;
- psp->drmMajor = drm_version->major;
- psp->drmMinor = drm_version->minor;
- psp->drmPatch = drm_version->patch;
- psp->ddxMajor = ddx_version->major;
- psp->ddxMinor = ddx_version->minor;
- psp->ddxPatch = ddx_version->patch;
- psp->driMajor = dri_version->major;
- psp->driMinor = dri_version->minor;
- psp->driPatch = dri_version->patch;
-
- /* install driver's callback functions */
- memcpy( &psp->DriverAPI, driverAPI, sizeof(struct __DriverAPIRec) );
+ psp->drm_version = *drm_version;
+ psp->ddx_version = *ddx_version;
+ psp->dri_version = *dri_version;
psp->pSAREA = pSAREA;
+ psp->lock = (drmLock *) &psp->pSAREA->lock;
psp->pFB = frame_buffer->base;
psp->fbSize = frame_buffer->size;
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->extensions = emptyExtensionList;
psp->fd = fd;
+ psp->myNum = scrn;
+ psp->dri2.enabled = GL_FALSE;
/*
** Do not init dummy context here; actual initialization will be
*/
psp->dummyContextPriv.driScreenPriv = NULL;
- psc->destroyScreen = driDestroyScreen;
-#ifndef DRI_NEW_INTERFACE_ONLY
- psc->createContext = driCreateContext;
-#else
- psc->createContext = 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
+ psp->DriverAPI = driDriverAPI;
- if ( (psp->DriverAPI.InitDriver != NULL)
- && !(*psp->DriverAPI.InitDriver)(psp) ) {
- _mesa_free( psp );
+ *driver_modes = driDriverAPI.InitScreen(psp);
+ if (*driver_modes == NULL) {
+ _mesa_free(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.
+ * DRI2
*/
-__DRIscreenPrivate *
-__driUtilCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
- int numConfigs, __GLXvisualConfig *configs,
- const struct __DriverAPIRec *driverAPI)
+static __DRIscreen *
+dri2CreateNewScreen(int scrn, int fd,
+ const __DRIextension **extensions,
+ const __DRIconfig ***driver_configs, void *data)
{
- int directCapable;
- __DRIscreenPrivate *psp = NULL;
- drm_handle_t 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;
- }
-
+ static const __DRIextension *emptyExtensionList[] = { NULL };
+ __DRIscreen *psp;
+ drmVersionPtr version;
- /* Create the linked list of context modes, and populate it with the
- * GLX visual information passed in by libGL.
- */
+ if (driDriverAPI.InitScreen2 == NULL)
+ return NULL;
- modes = _gl_context_modes_create( numConfigs, sizeof(__GLcontextModes) );
- if ( modes == NULL ) {
+ psp = _mesa_malloc(sizeof(*psp));
+ if (!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;
+ setupLoaderExtensions(psp, extensions);
- temp = temp->next;
+ version = drmGetVersion(fd);
+ if (version) {
+ psp->drm_version.major = version->version_major;
+ psp->drm_version.minor = version->version_minor;
+ psp->drm_version.patch = version->version_patchlevel;
+ drmFreeVersion(version);
}
- err_msg = "XF86DRIOpenConnection";
- err_extra = NULL;
-
- if (XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
- fd = drmOpen(NULL,BusID);
- _mesa_free(BusID); /* No longer needed */
-
- err_msg = "open DRM";
- err_extra = strerror( -fd );
-
- if (fd >= 0) {
- drm_magic_t 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. */
- _mesa_free( driverName );
-
- /*
- * Get the DRI X extension version.
- */
- err_msg = "XF86DRIQueryVersion";
- if (XF86DRIQueryVersion(dpy,
- &dri_version.major,
- &dri_version.minor,
- &dri_version.patch)) {
- drm_handle_t 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 ) {
- _mesa_free(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 );
- }
+ psp->extensions = emptyExtensionList;
+ psp->fd = fd;
+ psp->myNum = scrn;
+ psp->dri2.enabled = GL_TRUE;
- fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
+ psp->DriverAPI = driDriverAPI;
+ *driver_configs = driDriverAPI.InitScreen2(psp);
+ if (*driver_configs == NULL) {
+ _mesa_free(psp);
+ return NULL;
}
+ psp->DriverAPI = driDriverAPI;
+
return psp;
}
-#endif /* DRI_NEW_INTERFACE_ONLY */
+static const __DRIextension **driGetExtensions(__DRIscreen *psp)
+{
+ return psp->extensions;
+}
+
+/** Core interface */
+const __DRIcoreExtension driCoreExtension = {
+ { __DRI_CORE, __DRI_CORE_VERSION },
+ NULL,
+ driDestroyScreen,
+ driGetExtensions,
+ driGetConfigAttrib,
+ driIndexConfigAttrib,
+ NULL,
+ driDestroyDrawable,
+ driSwapBuffers,
+ NULL,
+ driCopyContext,
+ driDestroyContext,
+ driBindContext,
+ driUnbindContext
+};
+
+/** Legacy DRI interface */
+const __DRIlegacyExtension driLegacyExtension = {
+ { __DRI_LEGACY, __DRI_LEGACY_VERSION },
+ driCreateNewScreen,
+ driCreateNewDrawable,
+ driCreateNewContext,
+};
+
+/** Legacy DRI interface */
+const __DRIdri2Extension driDRI2Extension = {
+ { __DRI_DRI2, __DRI_DRI2_VERSION },
+ dri2CreateNewScreen,
+ dri2CreateNewDrawable,
+ dri2CreateNewContext,
+};
+
+/* This is the table of extensions that the loader will dlsym() for. */
+PUBLIC const __DRIextension *__driDriverExtensions[] = {
+ &driCoreExtension.base,
+ &driLegacyExtension.base,
+ &driDRI2Extension.base,
+ NULL
+};
-/**
- * Compare the current GLX API version with a driver supplied required version.
- *
- * The minimum required version is compared with the API version exported by
- * the \c __glXGetInternalVersion function (in libGL.so).
- *
- * \param required_version Minimum required internal GLX API version.
- * \return A tri-value return, as from strcmp is returned. A value less
- * than, equal to, or greater than zero will be returned if the
- * internal GLX API version is less than, equal to, or greater
- * than \c required_version.
- *
- * \sa __glXGetInternalVersion().
- */
-int driCompareGLXAPIVersion( GLuint required_version )
+static int
+driFrameTracking(__DRIdrawable *drawable, GLboolean enable)
{
- if ( api_ver > required_version ) {
- return 1;
- }
- else if ( api_ver == required_version ) {
- return 0;
- }
-
- return -1;
+ return GLX_BAD_CONTEXT;
}
-
static int
-driQueryFrameTracking( __DRInativeDisplay * dpy, void * priv,
- int64_t * sbc, int64_t * missedFrames,
- float * lastMissedUsage, float * usage )
+driQueryFrameTracking(__DRIdrawable *dpriv,
+ 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" );
- }
+ __DRIscreenPrivate *psp = dpriv->driScreenPriv;
status = dpriv->driScreenPriv->DriverAPI.GetSwapInfo( dpriv, & sInfo );
if ( status == 0 ) {
*missedFrames = sInfo.swap_missed_count;
*lastMissedUsage = sInfo.swap_missed_usage;
- (*get_ust)( & ust );
+ (*psp->systemTime->getUST)( & ust );
*usage = driCalculateSwapUsage( dpriv, sInfo.swap_ust, ust );
}
return status;
}
+const __DRIframeTrackingExtension driFrameTrackingExtension = {
+ { __DRI_FRAME_TRACKING, __DRI_FRAME_TRACKING_VERSION },
+ driFrameTracking,
+ driQueryFrameTracking
+};
/**
* Calculate amount of swap interval used between GLX buffer swaps.
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;
+ __DRIscreenPrivate *psp = dPriv->driScreenPriv;
-
- 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 ) ) {
- interval = (dPriv->pdraw->swap_interval != 0)
- ? dPriv->pdraw->swap_interval : 1;
+ if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {
+ interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;
/* We want to calculate
}
/*@}*/
-
-#endif /* GLX_DIRECT_RENDERING */