592 lines
17 KiB
C
592 lines
17 KiB
C
/* $XFree86: xc/lib/GL/dri/dri_util.h,v 1.1 2002/02/22 21:32:52 dawes Exp $ */
|
|
/**
|
|
* \file dri_util.h
|
|
* DRI utility functions definitions.
|
|
*
|
|
* This module acts as glue between GLX and the actual hardware driver. A DRI
|
|
* driver doesn't really \e have to use any of this - it's optional. But, some
|
|
* useful stuff is done here that otherwise would have to be duplicated in most
|
|
* drivers.
|
|
*
|
|
* Basically, these utility functions take care of some of the dirty details of
|
|
* screen initialization, context creation, context binding, DRM setup, etc.
|
|
*
|
|
* These functions are compiled into each DRI driver so libGL.so knows nothing
|
|
* about them.
|
|
*
|
|
* \sa dri_util.c.
|
|
*
|
|
* \author Kevin E. Martin <kevin@precisioninsight.com>
|
|
* \author Brian Paul <brian@precisioninsight.com>
|
|
*/
|
|
|
|
/*
|
|
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
#ifndef _DRI_UTIL_H_
|
|
#define _DRI_UTIL_H_
|
|
|
|
#include <GL/gl.h>
|
|
#include "drm.h"
|
|
#include "drm_sarea.h"
|
|
#include "xf86drm.h"
|
|
#include "GL/internal/glcore.h"
|
|
#include "GL/internal/dri_interface.h"
|
|
#include "GL/internal/dri_sarea.h"
|
|
|
|
#define GLX_BAD_CONTEXT 5
|
|
|
|
typedef struct __DRIdisplayPrivateRec __DRIdisplayPrivate;
|
|
typedef struct __DRIscreenPrivateRec __DRIscreenPrivate;
|
|
typedef struct __DRIcontextPrivateRec __DRIcontextPrivate;
|
|
typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
|
|
typedef struct __DRIswapInfoRec __DRIswapInfo;
|
|
typedef struct __DRIutilversionRec2 __DRIutilversion2;
|
|
|
|
|
|
/**
|
|
* Driver specific entry point. Implemented by the driver. Called
|
|
* from the top level createNewScreen entry point to initialize the
|
|
* __DRIscreenPrivate struct.
|
|
*/
|
|
extern __GLcontextModes *__driDriverInitScreen(__DRIscreenPrivate *psp);
|
|
|
|
/** Ditto for DRI2 capable drivers. */
|
|
extern __GLcontextModes *__dri2DriverInitScreen(__DRIscreenPrivate *psp);
|
|
|
|
/**
|
|
* Extensions.
|
|
*/
|
|
extern const __DRIextension driReadDrawableExtension;
|
|
extern const __DRIcopySubBufferExtension driCopySubBufferExtension;
|
|
extern const __DRIswapControlExtension driSwapControlExtension;
|
|
extern const __DRIframeTrackingExtension driFrameTrackingExtension;
|
|
extern const __DRImediaStreamCounterExtension driMediaStreamCounterExtension;
|
|
|
|
/**
|
|
* Used by DRI_VALIDATE_DRAWABLE_INFO
|
|
*/
|
|
#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv) \
|
|
do { \
|
|
if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) { \
|
|
__driUtilUpdateDrawableInfo(pDrawPriv); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/**
|
|
* Utility macro to validate the drawable information.
|
|
*
|
|
* See __DRIdrawablePrivate::pStamp and __DRIdrawablePrivate::lastStamp.
|
|
*/
|
|
#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp) \
|
|
do { \
|
|
while (*(pdp->pStamp) != pdp->lastStamp) { \
|
|
register unsigned int hwContext = psp->pSAREA->lock.lock & \
|
|
~(DRM_LOCK_HELD | DRM_LOCK_CONT); \
|
|
DRM_UNLOCK(psp->fd, &psp->pSAREA->lock, hwContext); \
|
|
\
|
|
DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID); \
|
|
DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp); \
|
|
DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID); \
|
|
\
|
|
DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock, hwContext); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/**
|
|
* Driver callback functions.
|
|
*
|
|
* Each DRI driver must have one of these structures with all the pointers set
|
|
* to appropriate functions within the driver.
|
|
*
|
|
* When glXCreateContext() is called, for example, it'll call a helper function
|
|
* dri_util.c which in turn will jump through the \a CreateContext pointer in
|
|
* this structure.
|
|
*/
|
|
struct __DriverAPIRec {
|
|
/**
|
|
* Screen destruction callback
|
|
*/
|
|
void (*DestroyScreen)(__DRIscreenPrivate *driScrnPriv);
|
|
|
|
/**
|
|
* Context creation callback
|
|
*/
|
|
GLboolean (*CreateContext)(const __GLcontextModes *glVis,
|
|
__DRIcontextPrivate *driContextPriv,
|
|
void *sharedContextPrivate);
|
|
|
|
/**
|
|
* Context destruction callback
|
|
*/
|
|
void (*DestroyContext)(__DRIcontextPrivate *driContextPriv);
|
|
|
|
/**
|
|
* Buffer (drawable) creation callback
|
|
*/
|
|
GLboolean (*CreateBuffer)(__DRIscreenPrivate *driScrnPriv,
|
|
__DRIdrawablePrivate *driDrawPriv,
|
|
const __GLcontextModes *glVis,
|
|
GLboolean pixmapBuffer);
|
|
|
|
/**
|
|
* Buffer (drawable) destruction callback
|
|
*/
|
|
void (*DestroyBuffer)(__DRIdrawablePrivate *driDrawPriv);
|
|
|
|
/**
|
|
* Buffer swapping callback
|
|
*/
|
|
void (*SwapBuffers)(__DRIdrawablePrivate *driDrawPriv);
|
|
|
|
/**
|
|
* Context activation callback
|
|
*/
|
|
GLboolean (*MakeCurrent)(__DRIcontextPrivate *driContextPriv,
|
|
__DRIdrawablePrivate *driDrawPriv,
|
|
__DRIdrawablePrivate *driReadPriv);
|
|
|
|
/**
|
|
* Context unbinding callback
|
|
*/
|
|
GLboolean (*UnbindContext)(__DRIcontextPrivate *driContextPriv);
|
|
|
|
/**
|
|
* Retrieves statistics about buffer swap operations. Required if
|
|
* GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.
|
|
*/
|
|
int (*GetSwapInfo)( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
|
|
|
|
|
|
/**
|
|
* Required if GLX_SGI_video_sync or GLX_OML_sync_control is
|
|
* supported.
|
|
*/
|
|
int (*GetMSC)( __DRIscreenPrivate * priv, int64_t * count );
|
|
|
|
/**
|
|
* These are required if GLX_OML_sync_control is supported.
|
|
*/
|
|
/*@{*/
|
|
int (*WaitForMSC)( __DRIdrawablePrivate *priv, int64_t target_msc,
|
|
int64_t divisor, int64_t remainder,
|
|
int64_t * msc );
|
|
int (*WaitForSBC)( __DRIdrawablePrivate *priv, int64_t target_sbc,
|
|
int64_t * msc, int64_t * sbc );
|
|
|
|
int64_t (*SwapBuffersMSC)( __DRIdrawablePrivate *priv, int64_t target_msc,
|
|
int64_t divisor, int64_t remainder );
|
|
/*@}*/
|
|
void (*CopySubBuffer)(__DRIdrawablePrivate *driDrawPriv,
|
|
int x, int y, int w, int h);
|
|
|
|
/**
|
|
* See corresponding field in \c __DRIscreenRec.
|
|
*/
|
|
void (*setTexOffset)(__DRIcontext *pDRICtx, GLint texname,
|
|
unsigned long long offset, GLint depth, GLuint pitch);
|
|
|
|
/**
|
|
* New version of GetMSC so we can pass drawable data to the low level
|
|
* DRM driver (e.g. pipe info).
|
|
*/
|
|
int (*GetDrawableMSC) ( __DRIscreenPrivate * priv,
|
|
__DRIdrawablePrivate *drawablePrivate,
|
|
int64_t *count);
|
|
|
|
/* DRI2 Entry points */
|
|
void (*UpdateBuffer)(__DRIdrawablePrivate *dPriv,
|
|
unsigned int *event);
|
|
};
|
|
|
|
|
|
struct __DRIswapInfoRec {
|
|
/**
|
|
* Number of swapBuffers operations that have been *completed*.
|
|
*/
|
|
u_int64_t swap_count;
|
|
|
|
/**
|
|
* Unadjusted system time of the last buffer swap. This is the time
|
|
* when the swap completed, not the time when swapBuffers was called.
|
|
*/
|
|
int64_t swap_ust;
|
|
|
|
/**
|
|
* Number of swap operations that occurred after the swap deadline. That
|
|
* is if a swap happens more than swap_interval frames after the previous
|
|
* swap, it has missed its deadline. If swap_interval is 0, then the
|
|
* swap deadline is 1 frame after the previous swap.
|
|
*/
|
|
u_int64_t swap_missed_count;
|
|
|
|
/**
|
|
* Amount of time used by the last swap that missed its deadline. This
|
|
* is calculated as (__glXGetUST() - swap_ust) / (swap_interval *
|
|
* time_for_single_vrefresh)). If the actual value of swap_interval is
|
|
* 0, then 1 is used instead. If swap_missed_count is non-zero, this
|
|
* should be greater-than 1.0.
|
|
*/
|
|
float swap_missed_usage;
|
|
};
|
|
|
|
|
|
/**
|
|
* Per-drawable private DRI driver information.
|
|
*/
|
|
struct __DRIdrawablePrivateRec {
|
|
/**
|
|
* Kernel drawable handle
|
|
*/
|
|
drm_drawable_t hHWDrawable;
|
|
|
|
/**
|
|
* Driver's private drawable information.
|
|
*
|
|
* This structure is opaque.
|
|
*/
|
|
void *driverPrivate;
|
|
|
|
/**
|
|
* X's drawable ID associated with this private drawable.
|
|
*/
|
|
__DRIdrawable *pdraw;
|
|
|
|
/**
|
|
* Reference count for number of context's currently bound to this
|
|
* drawable.
|
|
*
|
|
* Once it reaches zero, the drawable can be destroyed.
|
|
*
|
|
* \note This behavior will change with GLX 1.3.
|
|
*/
|
|
int refcount;
|
|
|
|
/**
|
|
* Index of this drawable information in the SAREA.
|
|
*/
|
|
unsigned int index;
|
|
|
|
/**
|
|
* Pointer to the "drawable has changed ID" stamp in the SAREA.
|
|
*/
|
|
unsigned int *pStamp;
|
|
|
|
/**
|
|
* Last value of the stamp.
|
|
*
|
|
* If this differs from the value stored at __DRIdrawablePrivate::pStamp,
|
|
* then the drawable information has been modified by the X server, and the
|
|
* drawable information (below) should be retrieved from the X server.
|
|
*/
|
|
unsigned int lastStamp;
|
|
|
|
/**
|
|
* \name Drawable
|
|
*
|
|
* Drawable information used in software fallbacks.
|
|
*/
|
|
/*@{*/
|
|
int x;
|
|
int y;
|
|
int w;
|
|
int h;
|
|
int numClipRects;
|
|
drm_clip_rect_t *pClipRects;
|
|
/*@}*/
|
|
|
|
/**
|
|
* \name Back and depthbuffer
|
|
*
|
|
* Information about the back and depthbuffer where different from above.
|
|
*/
|
|
/*@{*/
|
|
int backX;
|
|
int backY;
|
|
int backClipRectType;
|
|
int numBackClipRects;
|
|
drm_clip_rect_t *pBackClipRects;
|
|
/*@}*/
|
|
|
|
/**
|
|
* \name Vertical blank tracking information
|
|
* Used for waiting on vertical blank events.
|
|
*/
|
|
/*@{*/
|
|
unsigned int vblSeq;
|
|
unsigned int vblFlags;
|
|
/*@}*/
|
|
|
|
/**
|
|
* \name Monotonic MSC tracking
|
|
*
|
|
* Low level driver is responsible for updating msc_base and
|
|
* vblSeq values so that higher level code can calculate
|
|
* a new msc value or msc target for a WaitMSC call. The new value
|
|
* will be:
|
|
* msc = msc_base + get_vblank_count() - vblank_base;
|
|
*
|
|
* And for waiting on a value, core code will use:
|
|
* actual_target = target_msc - msc_base + vblank_base;
|
|
*/
|
|
/*@{*/
|
|
int64_t vblank_base;
|
|
int64_t msc_base;
|
|
/*@}*/
|
|
|
|
/**
|
|
* Pointer to context to which this drawable is currently bound.
|
|
*/
|
|
__DRIcontextPrivate *driContextPriv;
|
|
|
|
/**
|
|
* Pointer to screen on which this drawable was created.
|
|
*/
|
|
__DRIscreenPrivate *driScreenPriv;
|
|
|
|
/**
|
|
* Called via glXSwapBuffers().
|
|
*/
|
|
void (*swapBuffers)( __DRIdrawablePrivate *dPriv );
|
|
|
|
/**
|
|
* Controls swap interval as used by GLX_SGI_swap_control and
|
|
* GLX_MESA_swap_control.
|
|
*/
|
|
unsigned int swap_interval;
|
|
struct {
|
|
unsigned int tail;
|
|
} dri2;
|
|
};
|
|
|
|
/**
|
|
* Per-context private driver information.
|
|
*/
|
|
struct __DRIcontextPrivateRec {
|
|
/**
|
|
* Kernel context handle used to access the device lock.
|
|
*/
|
|
drm_context_t hHWContext;
|
|
|
|
/**
|
|
* Device driver's private context data. This structure is opaque.
|
|
*/
|
|
void *driverPrivate;
|
|
|
|
/**
|
|
* Pointer back to the \c __DRIcontext that contains this structure.
|
|
*/
|
|
__DRIcontext *pctx;
|
|
|
|
/**
|
|
* Pointer to drawable currently bound to this context for drawing.
|
|
*/
|
|
__DRIdrawablePrivate *driDrawablePriv;
|
|
|
|
/**
|
|
* Pointer to drawable currently bound to this context for reading.
|
|
*/
|
|
__DRIdrawablePrivate *driReadablePriv;
|
|
|
|
/**
|
|
* Pointer to screen on which this context was created.
|
|
*/
|
|
__DRIscreenPrivate *driScreenPriv;
|
|
};
|
|
|
|
/**
|
|
* Per-screen private driver information.
|
|
*/
|
|
struct __DRIscreenPrivateRec {
|
|
/**
|
|
* Current screen's number
|
|
*/
|
|
int myNum;
|
|
|
|
/**
|
|
* Callback functions into the hardware-specific DRI driver code.
|
|
*/
|
|
struct __DriverAPIRec DriverAPI;
|
|
|
|
/**
|
|
* DDX / 2D driver version information.
|
|
*/
|
|
__DRIversion ddx_version;
|
|
|
|
/**
|
|
* DRI X extension version information.
|
|
*/
|
|
__DRIversion dri_version;
|
|
|
|
/**
|
|
* DRM (kernel module) version information.
|
|
*/
|
|
__DRIversion drm_version;
|
|
|
|
/**
|
|
* ID used when the client sets the drawable lock.
|
|
*
|
|
* The X server uses this value to detect if the client has died while
|
|
* holding the drawable lock.
|
|
*/
|
|
int drawLockID;
|
|
|
|
/**
|
|
* File descriptor returned when the kernel device driver is opened.
|
|
*
|
|
* Used to:
|
|
* - authenticate client to kernel
|
|
* - map the frame buffer, SAREA, etc.
|
|
* - close the kernel device driver
|
|
*/
|
|
int fd;
|
|
|
|
/**
|
|
* SAREA pointer
|
|
*
|
|
* Used to access:
|
|
* - the device lock
|
|
* - the device-independent per-drawable and per-context(?) information
|
|
*/
|
|
drm_sarea_t *pSAREA;
|
|
|
|
/**
|
|
* \name Direct frame buffer access information
|
|
* Used for software fallbacks.
|
|
*/
|
|
/*@{*/
|
|
unsigned char *pFB;
|
|
int fbSize;
|
|
int fbOrigin;
|
|
int fbStride;
|
|
int fbWidth;
|
|
int fbHeight;
|
|
int fbBPP;
|
|
/*@}*/
|
|
|
|
/**
|
|
* \name Device-dependent private information (stored in the SAREA).
|
|
*
|
|
* This data is accessed by the client driver only.
|
|
*/
|
|
/*@{*/
|
|
void *pDevPriv;
|
|
int devPrivSize;
|
|
/*@}*/
|
|
|
|
/**
|
|
* Dummy context to which drawables are bound when not bound to any
|
|
* other context.
|
|
*
|
|
* A dummy hHWContext is created for this context, and is used by the GL
|
|
* core when a hardware lock is required but the drawable is not currently
|
|
* bound (e.g., potentially during a SwapBuffers request). The dummy
|
|
* context is created when the first "real" context is created on this
|
|
* screen.
|
|
*/
|
|
__DRIcontextPrivate dummyContextPriv;
|
|
|
|
/**
|
|
* Device-dependent private information (not stored in the SAREA).
|
|
*
|
|
* This pointer is never touched by the DRI layer.
|
|
*/
|
|
void *private;
|
|
|
|
/**
|
|
* Pointer back to the \c __DRIscreen that contains this structure.
|
|
*/
|
|
__DRIscreen *psc;
|
|
|
|
/**
|
|
* Extensions provided by this driver.
|
|
*/
|
|
const __DRIextension **extensions;
|
|
|
|
struct {
|
|
/* Flag to indicate that this is a DRI2 screen. Many of the above
|
|
* fields will not be valid or initializaed in that case. */
|
|
int enabled;
|
|
drmBO sareaBO;
|
|
void *sarea;
|
|
__DRIEventBuffer *buffer;
|
|
__DRILock *lock;
|
|
} dri2;
|
|
|
|
/* The lock actually in use, old sarea or DRI2 */
|
|
drmLock *lock;
|
|
};
|
|
|
|
|
|
/**
|
|
* Used to store a version which includes a major range instead of a single
|
|
* major version number.
|
|
*/
|
|
struct __DRIutilversionRec2 {
|
|
int major_min; /** min allowed Major version number. */
|
|
int major_max; /** max allowed Major version number. */
|
|
int minor; /**< Minor version number. */
|
|
int patch; /**< Patch-level. */
|
|
};
|
|
|
|
|
|
extern void
|
|
__driUtilMessage(const char *f, ...);
|
|
|
|
|
|
extern void
|
|
__driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp);
|
|
|
|
extern int
|
|
__driParseEvents(__DRIscreenPrivate *psp, __DRIdrawablePrivate *pdp);
|
|
|
|
extern __DRIscreenPrivate * __driUtilCreateNewScreen( int scr, __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 );
|
|
|
|
/* Test the version of the internal GLX API. Returns a value like strcmp. */
|
|
extern int
|
|
driCompareGLXAPIVersion( GLint required_version );
|
|
|
|
extern float
|
|
driCalculateSwapUsage( __DRIdrawablePrivate *dPriv,
|
|
int64_t last_swap_ust, int64_t current_ust );
|
|
|
|
/**
|
|
* Pointer to the \c __DRIinterfaceMethods passed to the driver by the loader.
|
|
*
|
|
* This pointer is set in the driver's \c __driCreateNewScreen function and
|
|
* is defined in dri_util.c.
|
|
*/
|
|
extern const __DRIinterfaceMethods * dri_interface;
|
|
|
|
#endif /* _DRI_UTIL_H_ */
|