path: root/drv/exa/exa_priv.h

/*
 *
 * Copyright (C) 2000 Keith Packard, member of The XFree86 Project, Inc.
 *               2005 Zack Rusin, Trolltech
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

#ifndef EXAPRIV_H
#define EXAPRIV_H

#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

#include "drvexa.h"

#include <X11/X.h>
#include <X11/Xproto.h>
#ifdef MITSHM
#include "shmint.h"
#endif
#include "drv_scrnintstr.h"
#include "drv_pixmapstr.h"

#include "servermd.h"
#include "mibstore.h"
#include "colormapst.h"
#include "drv_gcstruct.h"
#include "input.h"
#include "mipointer.h"
#include "drv_mi.h"
#include "dix.h"
#include "fb.h"
#include "fboverlay.h"
#include "fbpict.h"
#include "glyphstr.h"
#include "drv_damage.h"
#include "drv_damagestr.h"

#define DEBUG_TRACE_FALL	0
#define DEBUG_MIGRATE		0
#define DEBUG_PIXMAP		0
#define DEBUG_OFFSCREEN		0
#define DEBUG_GLYPH_CACHE	0

#if DEBUG_TRACE_FALL
#define DRV_EXA_FALLBACK(x)     					\
do {								\
	ErrorF("EXA fallback at %s: ", __FUNCTION__);		\
	ErrorF x;						\
} while (0)

char
exaDrawableLocation(DrvPixmapPtr pPixmap);
#else
#define DRV_EXA_FALLBACK(x)
#endif

#if DEBUG_PIXMAP
#define DBG_PIXMAP(a) ErrorF a
#else
#define DBG_PIXMAP(a)
#endif

#ifndef EXA_MAX_FB
#define EXA_MAX_FB   FB_OVERLAY_MAX
#endif

#ifdef DEBUG
#define DRV_EXA_FatalErrorDebug(x) FatalError x
#define DRV_EXA_FatalErrorDebugWithRet(x, ret) FatalError x
#else
#define DRV_EXA_FatalErrorDebug(x) ErrorF x
#define DRV_EXA_FatalErrorDebugWithRet(x, ret) \
do { \
    ErrorF x; \
    return ret; \
} while (0)
#endif

/**
 * This is the list of migration heuristics supported by EXA.  See
 * exaDoMigration() for what their implementations do.
 */
enum ExaMigrationHeuristic {
    ExaMigrationGreedy,
    ExaMigrationAlways,
    ExaMigrationSmart
};

typedef struct {
    unsigned char sha1[20];
} ExaCachedGlyphRec, *ExaCachedGlyphPtr;

typedef struct {
    /* The identity of the cache, statically configured at initialization */
    unsigned int format;
    int glyphWidth;
    int glyphHeight;

    int size; /* Size of cache; eventually this should be dynamically determined */

    /* Hash table mapping from glyph sha1 to position in the glyph; we use
     * open addressing with a hash table size determined based on size and large
     * enough so that we always have a good amount of free space, so we can
     * use linear probing. (Linear probing is preferrable to double hashing
     * here because it allows us to easily remove entries.)
     */
    int *hashEntries;
    int hashSize;
    
    ExaCachedGlyphPtr glyphs;
    int glyphCount; /* Current number of glyphs */
    
    DrvPicturePtr picture;   /* Where the glyphs of the cache are stored */
    int yOffset;          /* y location within the picture where the cache starts */
    int columns;          /* Number of columns the glyphs are layed out in */
    int evictionPosition; /* Next random position to evict a glyph */
} ExaGlyphCacheRec, *ExaGlyphCachePtr;

#define DRV_EXA_NUM_GLYPH_CACHES 4

typedef struct _ExaMigrationRec {
    Bool as_dst;
    Bool as_src;
    DrvPixmapPtr pPix;
    RegionPtr pReg;
} ExaMigrationRec, *ExaMigrationPtr;

typedef void (*EnableDisableFBAccessProcPtr)(DrvScreenPtr, Bool);
typedef struct {
    DrvExaDriverPtr info;
    DrvScreenBlockHandlerProcPtr	 SavedBlockHandler;
    DrvScreenWakeupHandlerProcPtr	 SavedWakeupHandler;
    DrvCreateGCProcPtr 		 SavedCreateGC;
    drvCloseScreenProcPtr 		 SavedCloseScreen;
    drvGetImageProcPtr 		 SavedGetImage;
    DrvGetSpansProcPtr 		 SavedGetSpans;
    DrvCreatePixmapProcPtr 	 SavedCreatePixmap;
    DrvDestroyPixmapProcPtr 	 SavedDestroyPixmap;
    DrvCreateScreenResourcesProcPtr SavedCreateScreenResources;
    DrvModifyPixmapHeaderProcPtr    SavedModifyPixmapHeader;

    DrvSharePixmapBackingProcPtr        SavedSharePixmapBacking;
    DrvSetSharedPixmapBackingProcPtr    SavedSetSharedPixmapBacking;
    DrvStartPixmapTrackingProcPtr SavedStartPixmapTracking;
    
    SourceValidateProcPtr        SavedSourceValidate;
    DrvCompositeProcPtr             SavedComposite;
    DrvTrianglesProcPtr		 SavedTriangles;
    DrvGlyphsProcPtr                SavedGlyphs;
    DrvTrapezoidsProcPtr            SavedTrapezoids;
    DrvAddTrapsProcPtr		 SavedAddTraps;

    DrvBitmapToRegionProcPtr        SavedPixmapToRegion;

    PixmapWindowFixupProcPtr     SavedPixmapWindowFixup;
    GetCopyAreaFunctionProcPtr   SavedGetCopyAreaFunction;
    GetCopyPlaneFunctionProcPtr  SavedGetCopyPlaneFunction;

    void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
    Bool (*pixmap_has_gpu_copy) (DrvPixmapPtr pPixmap);
    void (*do_move_in_pixmap) (DrvPixmapPtr pPixmap);
    void (*do_move_out_pixmap) (DrvPixmapPtr pPixmap);
    void (*prepare_access_reg)(DrvPixmapPtr pPixmap, int index, RegionPtr pReg);

    Bool			 swappedOut;
    enum ExaMigrationHeuristic	 migration;
    Bool			 checkDirtyCorrectness;
    unsigned			 disableFbCount;
    Bool			 optimize_migration;
    unsigned			 offScreenCounter;
    unsigned			 numOffscreenAvailable;
    CARD32			 lastDefragment;
    CARD32			 nextDefragment;
    DrvPixmapPtr			 deferred_mixed_pixmap;

    /* Reference counting for accessed pixmaps */
    struct {
	DrvPixmapPtr pixmap;
	int count;
	Bool retval;
    } access[DRV_EXA_NUM_PREPARE_INDICES];

    /* Holds information on fallbacks that cannot be relayed otherwise. */
    unsigned int fallback_flags;
    unsigned int fallback_counter;

    ExaGlyphCacheRec             glyphCaches[DRV_EXA_NUM_GLYPH_CACHES];

    /**
     * Regions affected by fallback composite source / mask operations.
     */

    RegionRec srcReg;
    RegionRec maskReg;
    DrvPixmapPtr srcPix;

} ExaScreenPrivRec, *ExaScreenPrivPtr;

/*
 * This is the only completely portable way to
 * compute this info.
 */
#ifndef BitsPerPixel
#define BitsPerPixel(d) (\
    PixmapWidthPaddingInfo[d].notPower2 ? \
    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
    (PixmapWidthPaddingInfo[d].padRoundUp+1)))
#endif

extern DevPrivateKeyRec drvexaScreenPrivateKeyRec;
#define exaScreenPrivateKey (&drvexaScreenPrivateKeyRec)
extern DevPrivateKeyRec drvexaPixmapPrivateKeyRec;
#define exaPixmapPrivateKey (&drvexaPixmapPrivateKeyRec)
extern DevPrivateKeyRec drvexaGCPrivateKeyRec;
#define exaGCPrivateKey (&drvexaGCPrivateKeyRec)

#define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixGetPrivate(&(s)->devPrivates, exaScreenPrivateKey))
#define ExaScreenPriv(s)	ExaScreenPrivPtr    pExaScr = ExaGetScreenPriv(s)

#define ExaGetGCPriv(gc) ((ExaGCPrivPtr)dixGetPrivateAddr(&(gc)->devPrivates, exaGCPrivateKey))
#define ExaGCPriv(gc) ExaGCPrivPtr pExaGC = ExaGetGCPriv(gc)

void
exaValidateGC(DrvGCPtr pGC,
		unsigned long changes,
	      DrvPixmapPtr pPixmap);
/*
 * Some macros to deal with function wrapping.
 */
#define wrap(priv, real, mem, func) {\
    priv->Saved##mem = real->mem; \
    real->mem = func; \
}

#define unwrap(priv, real, mem) {\
    real->mem = priv->Saved##mem; \
}

#define swap(priv, real, mem) {\
    void *tmp = priv->Saved##mem; \
    priv->Saved##mem = real->mem; \
    real->mem = tmp; \
}

#define DRV_EXA_PRE_FALLBACK(_screen_) \
    ExaScreenPriv(_screen_); \
    pExaScr->fallback_counter++;

#define DRV_EXA_POST_FALLBACK(_screen_) \
    pExaScr->fallback_counter--;

#define DRV_EXA_PRE_FALLBACK_GC(_gc_) \
    ExaScreenPriv(_gc_->pDrvScreen); \
    ExaGCPriv(_gc_); \
    pExaScr->fallback_counter++; \
    swap(pExaGC, _gc_, ops);

#define DRV_EXA_POST_FALLBACK_GC(_gc_) \
    pExaScr->fallback_counter--; \
    swap(pExaGC, _gc_, ops);

/** Align an offset to an arbitrary alignment */
#define DRV_EXA_ALIGN(offset, align) (((offset) + (align) - 1) - \
	(((offset) + (align) - 1) % (align)))
/** Align an offset to a power-of-two alignment */
#define DRV_EXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))

#define DRV_EXA_PIXMAP_SCORE_MOVE_IN    10
#define DRV_EXA_PIXMAP_SCORE_MAX	    20
#define DRV_EXA_PIXMAP_SCORE_MOVE_OUT   -10
#define DRV_EXA_PIXMAP_SCORE_MIN	    -20
#define DRV_EXA_PIXMAP_SCORE_PINNED	    1000
#define DRV_EXA_PIXMAP_SCORE_INIT	    1001

#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)dixGetPrivateAddr(&(p)->devPrivates, exaPixmapPrivateKey))
#define ExaPixmapPriv(p)	ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p)

#define DRV_EXA_RANGE_PITCH (1 << 0)
#define DRV_EXA_RANGE_WIDTH (1 << 1)
#define DRV_EXA_RANGE_HEIGHT (1 << 2)

typedef struct {
    drvExaOffscreenArea *area;
    int		    score;	/**< score for the move-in vs move-out heuristic */
    Bool	    use_gpu_copy;

    CARD8	    *sys_ptr;	/**< pointer to pixmap data in system memory */
    int		    sys_pitch;	/**< pitch of pixmap in system memory */

    CARD8	    *fb_ptr;	/**< pointer to pixmap data in framebuffer memory */
    int		    fb_pitch;	/**< pitch of pixmap in framebuffer memory */
    unsigned int    fb_size;	/**< size of pixmap in framebuffer memory */

    /**
     * Holds information about whether this pixmap can be used for
     * acceleration (== 0) or not (> 0).
     *
     * Contains a OR'ed combination of the following values:
     * EXA_RANGE_PITCH - set if the pixmap's pitch is out of range
     * EXA_RANGE_WIDTH - set if the pixmap's width is out of range
     * EXA_RANGE_HEIGHT - set if the pixmap's height is out of range
     */
    unsigned int    accel_blocked;

    /**
     * The damage record contains the areas of the pixmap's current location
     * (framebuffer or system) that have been damaged compared to the other
     * location.
     */
    DrvDamagePtr	    pDamage;
    /**
     * The valid regions mark the valid bits (at least, as they're derived from
     * damage, which may be overreported) of a pixmap's system and FB copies.
     */
    RegionRec	    validSys, validFB;
    /**
     * Driver private storage per EXA pixmap
     */
    void *driverPriv;
} ExaPixmapPrivRec, *ExaPixmapPrivPtr;

typedef struct {
    /* GC values from the layer below. */
    DrvGCOps *Savedops;
} ExaGCPrivRec, *ExaGCPrivPtr;

typedef struct {
    DrvPicturePtr pDst;
    INT16 xSrc;
    INT16 ySrc;
    INT16 xMask;
    INT16 yMask;
    INT16 xDst;
    INT16 yDst;
    INT16 width;
    INT16 height;
} ExaCompositeRectRec, *ExaCompositeRectPtr;

/**
 * exaDDXDriverInit must be implemented by the DDX using EXA, and is the place
 * to set EXA options or hook in screen functions to handle using EXA as the AA.
  */
void exaDDXDriverInit (DrvScreenPtr pScreen);

/* exa_unaccel.c */
void
drvexaPrepareAccessGC(DrvGCPtr pGC);

void
drvexaFinishAccessGC(DrvGCPtr pGC);

void
drvExaCheckFillSpans  (DrvPixmapPtr pPixmap, DrvGCPtr pGC, int nspans,
		   DDXPointPtr ppt, int *pwidth, int fSorted);

void
drvExaCheckSetSpans (DrvPixmapPtr pPixmap, DrvGCPtr pGC, char *psrc,
		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);

void
drvExaCheckPutImage (DrvPixmapPtr pPixmap, DrvGCPtr pGC, int depth,
		 int x, int y, int w, int h, int leftPad, int format,
		 char *bits);

void
drvExaCheckCopyNtoN (DrvPixmapPtr pSrc, DrvPixmapPtr pDst,  DrvGCPtr pGC,
	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 
	     Bool upsidedown, Pixel bitplane, void *closure);

RegionPtr
drvExaCheckCopyArea (DrvPixmapPtr pSrc, DrvPixmapPtr pDst, DrvGCPtr pGC,
		 int srcx, int srcy, int w, int h, int dstx, int dsty);

RegionPtr
drvExaCheckCopyPlane (DrvPixmapPtr pSrc, DrvPixmapPtr pDst, DrvGCPtr pGC,
		  int srcx, int srcy, int w, int h, int dstx, int dsty,
		  unsigned long bitPlane);

void
drvExaCheckPolyPoint (DrvPixmapPtr pPixmap, DrvGCPtr pGC, int mode, int npt,
		  DDXPointPtr pptInit);

void
drvExaCheckPolylines (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		  int mode, int npt, DDXPointPtr ppt);

void
drvExaCheckPolySegment (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		    int nsegInit, xSegment *pSegInit);

void
drvExaCheckPolyArc (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		int narcs, xArc *pArcs);

void
drvExaCheckPolyFillRect (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		     int nrect, xRectangle *prect);

void
drvExaCheckImageGlyphBlt (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		      int x, int y, unsigned int nglyph,
		      CharInfoPtr *ppci, pointer pglyphBase);

void
drvExaCheckPolyGlyphBlt (DrvPixmapPtr pPixmap, DrvGCPtr pGC,
		     int x, int y, unsigned int nglyph,
		     CharInfoPtr *ppci, pointer pglyphBase);

void
drvExaCheckPushPixels (DrvGCPtr pGC, DrvPixmapPtr pBitmap,
		   DrvPixmapPtr pPixmap,
		   int w, int h, int x, int y);

void
drvExaCheckGetImage(DrvPixmapPtr pPixmap, int x, int y, int w, int h,
		 unsigned int format, unsigned long planeMask, int dst_stride, char *d);

void
drvExaCheckGetSpans (DrvPixmapPtr pPixmap,
		 int wMax,
		 DDXPointPtr ppt,
		 int *pwidth,
		 int nspans,
		 char *pdstStart);

void
drvExaCheckAddTraps (DrvPicturePtr	pPicture,
		  INT16		x_off,
		  INT16		y_off,
		  int		ntrap,
		  xTrap		*traps);

/* exa_accel.c */

static _X_INLINE Bool
exaGCReadsDestination(DrvPixmapPtr pPixmap, unsigned long planemask,
		      unsigned int fillStyle, unsigned char alu,
		      unsigned int clientClipType)
{
    return ((alu != GXcopy && alu != GXclear && alu != GXset &&
	     alu != GXcopyInverted) || fillStyle == FillStippled ||
	    clientClipType != CT_NONE || !DRV_EXA_PM_IS_SOLID(pPixmap, planemask));
}

Bool
drvexaFillRegionTiled (DrvPixmapPtr	pPixmap, RegionPtr pRegion, DrvPixmapPtr pTile,
		    DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
		    unsigned int clientClipType);

void
drvexaGetImage (DrvPixmapPtr pPixmap, int x, int y, int w, int h,
	     unsigned int format, unsigned long planeMask, int dst_stride, char *d);

RegionPtr
drvexaCopyArea(DrvPixmapPtr pSrcDrawable, DrvPixmapPtr pDstDrawable, DrvGCPtr pGC,
	    int srcx, int srcy, int width, int height, int dstx, int dsty);

Bool
drvexaHWCopyNtoN (DrvPixmapPtr    pSrcDrawable,
	     DrvPixmapPtr    pDstDrawable,
	     DrvGCPtr	    pGC,
	     BoxPtr	    pbox,
	     int	    nbox,
	     int	    dx,
	     int	    dy,
	     Bool	    reverse,
	     Bool	    upsidedown);

void
drvexaCopyNtoN (DrvPixmapPtr    pSrcDrawable,
	     DrvPixmapPtr    pDstDrawable,
	     DrvGCPtr	    pGC,
	     BoxPtr	    pbox,
	     int	    nbox,
	     int	    dx,
	     int	    dy,
	     Bool	    reverse,
	     Bool	    upsidedown,
	     Pixel	    bitplane,
	     void	    *closure);

void
drvExaCopyPlaneNtoN (DrvPixmapPtr	pSrcDrawable,
		  DrvPixmapPtr	pDstDrawable,
		  DrvGCPtr	pGC,
		  BoxPtr	pbox,
		  int		nbox,
		  int		dx,
		  int		dy,
		  Bool	reverse,
		  Bool	upsidedown,
		  Pixel	bitplane,
		  void	*closure);
extern const DrvGCOps exaOps;

void
drvExaCheckComposite (CARD8      op,
		  DrvPicturePtr pSrc,
		  DrvPicturePtr pMask,
		  DrvPicturePtr pDst,
		  INT16      xSrc,
		  INT16      ySrc,
		  INT16      xMask,
		  INT16      yMask,
		  INT16      xDst,
		  INT16      yDst,
		  CARD16     width,
		  CARD16     height);

void
drvExaCheckGlyphs (CARD8	      op,
		DrvPicturePtr    pSrc,
		DrvPicturePtr    pDst,
		PictFormatPtr maskFormat,
		INT16	      xSrc,
		INT16	      ySrc,
		int	      nlist,
		GlyphListPtr  list,
		GlyphPtr      *glyphs,
		int gp_index);

/* exa_offscreen.c */
void
drvExaOffscreenSwapOut (DrvScreenPtr pScreen);

void
drvExaOffscreenSwapIn (DrvScreenPtr pScreen);

drvExaOffscreenArea*
drvExaOffscreenDefragment (DrvScreenPtr pScreen);

Bool
drvexaOffscreenInit(DrvScreenPtr pScreen);

void
drvExaOffscreenFini (DrvScreenPtr pScreen);

/* exa.c */
Bool
ExaDoPrepareAccess(DrvPixmapPtr pPixmap, int index);

void
exaPrepareAccess(DrvPixmapPtr pPixmap, int index);

void
exaFinishAccess(DrvPixmapPtr pPixmap, int index);

void
exaDestroyPixmap(DrvPixmapPtr pPixmap);

void
exaPixmapDirty(DrvPixmapPtr pPix, int x1, int y1, int x2, int y2);

Bool
exaPixmapHasGpuCopy(DrvPixmapPtr p);

DrvPixmapPtr
drvexaGetOffscreenPixmap (DrvPixmapPtr pPixmap, int *dummy, int *dummy2);

DrvPixmapPtr
exaGetDrawablePixmap(DrvPixmapPtr pPixmap);

void
drvexaGetDrawableDeltas (DrvPixmapPtr pDrawable, DrvPixmapPtr pPixmap,
			 int *xp, int *yp);
void
exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
              int w, int h, int bpp);

void
exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
                 int w, int h, int bpp);

void
exaDoMigration (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

Bool
exaPixmapIsPinned (DrvPixmapPtr pPix);

extern const GCFuncs exaGCFuncs;

/* exa_classic.c */
DrvPixmapPtr
drvexaCreatePixmap_classic(DrvScreenPtr pScreen, int w, int h, int depth,
			   unsigned usage_hint, PixmapPtr parent);

Bool
drvexaModifyPixmapHeader_classic(DrvPixmapPtr pPixmap, int width, int height, int depth,
		      int bitsPerPixel, int devKind, pointer pPixData);

Bool
drvexaDestroyPixmap_classic (DrvPixmapPtr pPixmap);

Bool
drvexaPixmapHasGpuCopy_classic(DrvPixmapPtr pPixmap);

/* exa_driver.c */
DrvPixmapPtr
drvexaCreatePixmap_driver(DrvScreenPtr pScreen, int w, int h, int depth,
		       unsigned usage_hint, PixmapPtr parent);

Bool
drvexaModifyPixmapHeader_driver(DrvPixmapPtr pPixmap, int width, int height, int depth,
		      int bitsPerPixel, int devKind, pointer pPixData);

Bool
drvexaDestroyPixmap_driver (DrvPixmapPtr pPixmap);

Bool
drvexaPixmapHasGpuCopy_driver(DrvPixmapPtr pPixmap);

/* exa_mixed.c */
DrvPixmapPtr
drvexaCreatePixmap_mixed(DrvScreenPtr pScreen, int w, int h, int depth,
		      unsigned usage_hint, PixmapPtr parent);

Bool
drvexaModifyPixmapHeader_mixed(DrvPixmapPtr pPixmap, int width, int height, int depth,
		      int bitsPerPixel, int devKind, pointer pPixData);

Bool
drvexaDestroyPixmap_mixed(DrvPixmapPtr pPixmap);

Bool
drvexaPixmapHasGpuCopy_mixed(DrvPixmapPtr pPixmap);

Bool
exaSharePixmapBacking_mixed(DrvPixmapPtr pPixmap, int *handle_p);

Bool
exaSetSharedPixmapBacking_mixed(DrvPixmapPtr pPixmap, int handle);

/* exa_migration_mixed.c */
void
drvexaCreateDriverPixmap_mixed(DrvPixmapPtr pPixmap);

void
drvexaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

void
drvexaMoveInPixmap_mixed(DrvPixmapPtr pPixmap);

void
drvexaDamageReport_mixed(DrvDamagePtr pDamage, RegionPtr pRegion, void *closure);

void
drvexaPrepareAccessReg_mixed(DrvPixmapPtr pPixmap, int index, RegionPtr pReg);

/* exa_render.c */
Bool
drvexaOpReadsDestination (CARD8 op);

void
drvexaComposite(CARD8	op,
	     DrvPicturePtr pSrc,
	     DrvPicturePtr pMask,
	     DrvPicturePtr pDst,
	     INT16	xSrc,
	     INT16	ySrc,
	     INT16	xMask,
	     INT16	yMask,
	     INT16	xDst,
	     INT16	yDst,
	     CARD16	width,
	     CARD16	height);

void
drvexaCompositeRects(CARD8	              op,
		  DrvPicturePtr	      Src,
		  DrvPicturePtr	      pMask,
		  DrvPicturePtr	      pDst,
		  int                 nrect,
		  ExaCompositeRectPtr rects);

void
drvexaTrapezoids (CARD8 op, DrvPicturePtr pSrc, DrvPicturePtr pDst,
               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
               int ntrap, xTrapezoid *traps);

void
drvexaTriangles (CARD8 op, DrvPicturePtr pSrc, DrvPicturePtr pDst,
	      PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
	      int ntri, xTriangle *tris);

/* exa_glyph.c */
void
drvexaGlyphsInit(DrvScreenPtr pScreen);

void
drvexaGlyphsFini (DrvScreenPtr pScreen);

void
drvexaGlyphs (CARD8	op,
	  DrvPicturePtr	pSrc,
	  DrvPicturePtr	pDst,
	  PictFormatPtr	maskFormat,
	  INT16		xSrc,
	  INT16		ySrc,
	  int		nlist,
	  GlyphListPtr	list,
	  GlyphPtr	*glyphs, int gp_index);

/* exa_migration_classic.c */
void
drvexaCopyDirtyToSys (ExaMigrationPtr migrate);

void
drvexaCopyDirtyToFb (ExaMigrationPtr migrate);

void
drvexaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);

void
drvexaPixmapSave (DrvScreenPtr pScreen, drvExaOffscreenArea *area);

void
drvexaMoveOutPixmap_classic (DrvPixmapPtr pPixmap);

void
drvexaMoveInPixmap_classic (DrvPixmapPtr pPixmap);

void
drvexaPrepareAccessReg_classic(DrvPixmapPtr pPixmap, int index, RegionPtr pReg);

#endif /* EXAPRIV_H */