libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 254 insertions, 241 deletions

diff --git a/xorg-server/exa/exa_priv.h b/xorg-server/exa/exa_priv.h
index 70de4bd6f..bde78c3a0 100644
--- a/xorg-server/exa/exa_priv.h
+++ b/xorg-server/exa/exa_priv.h
@@ -68,7 +68,7 @@ do {								\
 } while (0)
 
 char
-exaDrawableLocation(DrawablePtr pDrawable);
+ exaDrawableLocation(DrawablePtr pDrawable);
 #else
 #define EXA_FALLBACK(x)
 #endif
@@ -115,7 +115,7 @@ typedef struct {
     int glyphWidth;
     int glyphHeight;
 
-    int size; /* Size of cache; eventually this should be dynamically determined */
+    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
@@ -125,14 +125,14 @@ typedef struct {
      */
     int *hashEntries;
     int hashSize;
-    
+
     ExaCachedGlyphPtr glyphs;
-    int glyphCount; /* Current number of glyphs */
-    
-    PicturePtr 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 */
+    int glyphCount;             /* Current number of glyphs */
+
+    PicturePtr 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 EXA_NUM_GLYPH_CACHES 4
@@ -147,57 +147,58 @@ typedef struct _ExaMigrationRec {
     RegionPtr pReg;
 } ExaMigrationRec, *ExaMigrationPtr;
 
-typedef void (*EnableDisableFBAccessProcPtr)(int, Bool);
+typedef void (*EnableDisableFBAccessProcPtr) (int, Bool);
 typedef struct {
     ExaDriverPtr info;
-    ScreenBlockHandlerProcPtr	 SavedBlockHandler;
-    ScreenWakeupHandlerProcPtr	 SavedWakeupHandler;
-    CreateGCProcPtr 		 SavedCreateGC;
-    CloseScreenProcPtr 		 SavedCloseScreen;
-    GetImageProcPtr 		 SavedGetImage;
-    GetSpansProcPtr 		 SavedGetSpans;
-    CreatePixmapProcPtr 	 SavedCreatePixmap;
-    DestroyPixmapProcPtr 	 SavedDestroyPixmap;
-    CopyWindowProcPtr 		 SavedCopyWindow;
+    ScreenBlockHandlerProcPtr SavedBlockHandler;
+    ScreenWakeupHandlerProcPtr SavedWakeupHandler;
+    CreateGCProcPtr SavedCreateGC;
+    CloseScreenProcPtr SavedCloseScreen;
+    GetImageProcPtr SavedGetImage;
+    GetSpansProcPtr SavedGetSpans;
+    CreatePixmapProcPtr SavedCreatePixmap;
+    DestroyPixmapProcPtr SavedDestroyPixmap;
+    CopyWindowProcPtr SavedCopyWindow;
     ChangeWindowAttributesProcPtr SavedChangeWindowAttributes;
-    BitmapToRegionProcPtr        SavedBitmapToRegion;
+    BitmapToRegionProcPtr SavedBitmapToRegion;
     CreateScreenResourcesProcPtr SavedCreateScreenResources;
-    ModifyPixmapHeaderProcPtr    SavedModifyPixmapHeader;
-    SourceValidateProcPtr        SavedSourceValidate;
-    CompositeProcPtr             SavedComposite;
-    TrianglesProcPtr		 SavedTriangles;
-    GlyphsProcPtr                SavedGlyphs;
-    TrapezoidsProcPtr            SavedTrapezoids;
-    AddTrapsProcPtr		 SavedAddTraps;
-    void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+    ModifyPixmapHeaderProcPtr SavedModifyPixmapHeader;
+    SourceValidateProcPtr SavedSourceValidate;
+    CompositeProcPtr SavedComposite;
+    TrianglesProcPtr SavedTriangles;
+    GlyphsProcPtr SavedGlyphs;
+    TrapezoidsProcPtr SavedTrapezoids;
+    AddTrapsProcPtr SavedAddTraps;
+    void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps,
+                          Bool can_accel);
     Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);
     void (*do_move_in_pixmap) (PixmapPtr pPixmap);
     void (*do_move_out_pixmap) (PixmapPtr pPixmap);
-    void (*prepare_access_reg)(PixmapPtr 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;
-    PixmapPtr			 deferred_mixed_pixmap;
+    void (*prepare_access_reg) (PixmapPtr 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;
+    PixmapPtr deferred_mixed_pixmap;
 
     /* Reference counting for accessed pixmaps */
     struct {
-	PixmapPtr pixmap;
-	int count;
-	Bool retval;
+        PixmapPtr pixmap;
+        int count;
+        Bool retval;
     } access[EXA_NUM_PREPARE_INDICES];
 
     /* Holds information on fallbacks that cannot be relayed otherwise. */
     unsigned int fallback_flags;
     unsigned int fallback_counter;
 
-    ExaGlyphCacheRec             glyphCaches[EXA_NUM_GLYPH_CACHES];
+    ExaGlyphCacheRec glyphCaches[EXA_NUM_GLYPH_CACHES];
 
     /**
      * Regions affected by fallback composite source / mask operations.
@@ -222,10 +223,13 @@ typedef struct {
 #endif
 
 extern DevPrivateKeyRec exaScreenPrivateKeyRec;
+
 #define exaScreenPrivateKey (&exaScreenPrivateKeyRec)
 extern DevPrivateKeyRec exaPixmapPrivateKeyRec;
+
 #define exaPixmapPrivateKey (&exaPixmapPrivateKeyRec)
 extern DevPrivateKeyRec exaGCPrivateKeyRec;
+
 #define exaGCPrivateKey (&exaGCPrivateKeyRec)
 
 #define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)dixGetPrivate(&(s)->devPrivates, exaScreenPrivateKey))
@@ -291,15 +295,15 @@ extern DevPrivateKeyRec exaGCPrivateKeyRec;
 
 typedef struct {
     ExaOffscreenArea *area;
-    int		    score;	/**< score for the move-in vs move-out heuristic */
-    Bool	    use_gpu_copy;
+    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 *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 */
+    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
@@ -310,19 +314,19 @@ typedef struct {
      * 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;
+    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.
      */
-    DamagePtr	    pDamage;
+    DamagePtr 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;
+    RegionRec validSys, validFB;
     /**
      * Driver private storage per EXA pixmap
      */
@@ -351,374 +355,383 @@ typedef struct {
  * 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 (ScreenPtr pScreen);
+void exaDDXDriverInit(ScreenPtr pScreen);
 
 /* exa_unaccel.c */
 void
-exaPrepareAccessGC(GCPtr pGC);
+ exaPrepareAccessGC(GCPtr pGC);
 
 void
-exaFinishAccessGC(GCPtr pGC);
+ exaFinishAccessGC(GCPtr pGC);
 
 void
-ExaCheckFillSpans  (DrawablePtr pDrawable, GCPtr pGC, int nspans,
-		   DDXPointPtr ppt, int *pwidth, int fSorted);
+
+ExaCheckFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
+                  DDXPointPtr ppt, int *pwidth, int fSorted);
 
 void
-ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,
-		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
+
+ExaCheckSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
+                 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
 
 void
-ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
-		 int x, int y, int w, int h, int leftPad, int format,
-		 char *bits);
+
+ExaCheckPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
+                 int x, int y, int w, int h, int leftPad, int format,
+                 char *bits);
 
 void
-ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
-	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 
-	     Bool upsidedown, Pixel bitplane, void *closure);
+
+ExaCheckCopyNtoN(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                 BoxPtr pbox, int nbox, int dx, int dy, Bool reverse,
+                 Bool upsidedown, Pixel bitplane, void *closure);
 
 RegionPtr
-ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		 int srcx, int srcy, int w, int h, int dstx, int dsty);
+
+ExaCheckCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                 int srcx, int srcy, int w, int h, int dstx, int dsty);
 
 RegionPtr
-ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		  int srcx, int srcy, int w, int h, int dstx, int dsty,
-		  unsigned long bitPlane);
+
+ExaCheckCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                  int srcx, int srcy, int w, int h, int dstx, int dsty,
+                  unsigned long bitPlane);
 
 void
-ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
-		  DDXPointPtr pptInit);
+
+ExaCheckPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
+                  DDXPointPtr pptInit);
 
 void
-ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr ppt);
+
+ExaCheckPolylines(DrawablePtr pDrawable, GCPtr pGC,
+                  int mode, int npt, DDXPointPtr ppt);
 
 void
-ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
-		    int nsegInit, xSegment *pSegInit);
+
+ExaCheckPolySegment(DrawablePtr pDrawable, GCPtr pGC,
+                    int nsegInit, xSegment * pSegInit);
 
 void
-ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
-		int narcs, xArc *pArcs);
+ ExaCheckPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs);
 
 void
-ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
-		     int nrect, xRectangle *prect);
+
+ExaCheckPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
+                     int nrect, xRectangle *prect);
 
 void
-ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		      int x, int y, unsigned int nglyph,
-		      CharInfoPtr *ppci, pointer pglyphBase);
+
+ExaCheckImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+                      int x, int y, unsigned int nglyph,
+                      CharInfoPtr * ppci, pointer pglyphBase);
 
 void
-ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		     int x, int y, unsigned int nglyph,
-		     CharInfoPtr *ppci, pointer pglyphBase);
+
+ExaCheckPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+                     int x, int y, unsigned int nglyph,
+                     CharInfoPtr * ppci, pointer pglyphBase);
 
 void
-ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
-		   DrawablePtr pDrawable,
-		   int w, int h, int x, int y);
+
+ExaCheckPushPixels(GCPtr pGC, PixmapPtr pBitmap,
+                   DrawablePtr pDrawable, int w, int h, int x, int y);
 
 void
-ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
+ ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
 
 void
+
 ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
-		unsigned int format, unsigned long planeMask, char *d);
+                 unsigned int format, unsigned long planeMask, char *d);
 
 void
-ExaCheckGetSpans (DrawablePtr pDrawable,
-		 int wMax,
-		 DDXPointPtr ppt,
-		 int *pwidth,
-		 int nspans,
-		 char *pdstStart);
+
+ExaCheckGetSpans(DrawablePtr pDrawable,
+                 int wMax,
+                 DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart);
 
 void
-ExaCheckAddTraps (PicturePtr	pPicture,
-		  INT16		x_off,
-		  INT16		y_off,
-		  int		ntrap,
-		  xTrap		*traps);
+
+ExaCheckAddTraps(PicturePtr pPicture,
+                 INT16 x_off, INT16 y_off, int ntrap, xTrap * traps);
 
 /* exa_accel.c */
 
 static _X_INLINE Bool
 exaGCReadsDestination(DrawablePtr pDrawable, unsigned long planemask,
-		      unsigned int fillStyle, unsigned char alu,
-		      unsigned int clientClipType)
+                      unsigned int fillStyle, unsigned char alu,
+                      unsigned int clientClipType)
 {
     return ((alu != GXcopy && alu != GXclear && alu != GXset &&
-	     alu != GXcopyInverted) || fillStyle == FillStippled ||
-	    clientClipType != CT_NONE || !EXA_PM_IS_SOLID(pDrawable, planemask));
+             alu != GXcopyInverted) || fillStyle == FillStippled ||
+            clientClipType != CT_NONE ||
+            !EXA_PM_IS_SOLID(pDrawable, planemask));
 }
 
 void
-exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
+ exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
 
 Bool
-exaFillRegionTiled (DrawablePtr	pDrawable, RegionPtr pRegion, PixmapPtr pTile,
-		    DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
-		    unsigned int clientClipType);
+
+exaFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
+                   DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu,
+                   unsigned int clientClipType);
 
 void
-exaGetImage (DrawablePtr pDrawable, int x, int y, int w, int h,
-	     unsigned int format, unsigned long planeMask, char *d);
+
+exaGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
+            unsigned int format, unsigned long planeMask, char *d);
 
 RegionPtr
+
 exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
-	    int srcx, int srcy, int width, int height, int dstx, int dsty);
+            int srcx, int srcy, int width, int height, int dstx, int dsty);
 
 Bool
-exaHWCopyNtoN (DrawablePtr    pSrcDrawable,
-	     DrawablePtr    pDstDrawable,
-	     GCPtr	    pGC,
-	     BoxPtr	    pbox,
-	     int	    nbox,
-	     int	    dx,
-	     int	    dy,
-	     Bool	    reverse,
-	     Bool	    upsidedown);
-
-void
-exaCopyNtoN (DrawablePtr    pSrcDrawable,
-	     DrawablePtr    pDstDrawable,
-	     GCPtr	    pGC,
-	     BoxPtr	    pbox,
-	     int	    nbox,
-	     int	    dx,
-	     int	    dy,
-	     Bool	    reverse,
-	     Bool	    upsidedown,
-	     Pixel	    bitplane,
-	     void	    *closure);
+
+exaHWCopyNtoN(DrawablePtr pSrcDrawable,
+              DrawablePtr pDstDrawable,
+              GCPtr pGC,
+              BoxPtr pbox,
+              int nbox, int dx, int dy, Bool reverse, Bool upsidedown);
+
+void
+
+exaCopyNtoN(DrawablePtr pSrcDrawable,
+            DrawablePtr pDstDrawable,
+            GCPtr pGC,
+            BoxPtr pbox,
+            int nbox,
+            int dx,
+            int dy,
+            Bool reverse, Bool upsidedown, Pixel bitplane, void *closure);
 
 extern const GCOps exaOps;
 
 void
-ExaCheckComposite (CARD8      op,
-		  PicturePtr pSrc,
-		  PicturePtr pMask,
-		  PicturePtr pDst,
-		  INT16      xSrc,
-		  INT16      ySrc,
-		  INT16      xMask,
-		  INT16      yMask,
-		  INT16      xDst,
-		  INT16      yDst,
-		  CARD16     width,
-		  CARD16     height);
-
-void
-ExaCheckGlyphs (CARD8	      op,
-		PicturePtr    pSrc,
-		PicturePtr    pDst,
-		PictFormatPtr maskFormat,
-		INT16	      xSrc,
-		INT16	      ySrc,
-		int	      nlist,
-		GlyphListPtr  list,
-		GlyphPtr      *glyphs);
+
+ExaCheckComposite(CARD8 op,
+                  PicturePtr pSrc,
+                  PicturePtr pMask,
+                  PicturePtr pDst,
+                  INT16 xSrc,
+                  INT16 ySrc,
+                  INT16 xMask,
+                  INT16 yMask,
+                  INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
+
+void
+
+ExaCheckGlyphs(CARD8 op,
+               PicturePtr pSrc,
+               PicturePtr pDst,
+               PictFormatPtr maskFormat,
+               INT16 xSrc,
+               INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
 
 /* exa_offscreen.c */
 void
-ExaOffscreenSwapOut (ScreenPtr pScreen);
+ ExaOffscreenSwapOut(ScreenPtr pScreen);
 
 void
-ExaOffscreenSwapIn (ScreenPtr pScreen);
+ ExaOffscreenSwapIn(ScreenPtr pScreen);
 
-ExaOffscreenArea*
-ExaOffscreenDefragment (ScreenPtr pScreen);
+ExaOffscreenArea *ExaOffscreenDefragment(ScreenPtr pScreen);
 
 Bool
-exaOffscreenInit(ScreenPtr pScreen);
+ exaOffscreenInit(ScreenPtr pScreen);
 
 void
-ExaOffscreenFini (ScreenPtr pScreen);
+ ExaOffscreenFini(ScreenPtr pScreen);
 
 /* exa.c */
 Bool
-ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
+ ExaDoPrepareAccess(PixmapPtr pPixmap, int index);
 
 void
-exaPrepareAccess(DrawablePtr pDrawable, int index);
+ exaPrepareAccess(DrawablePtr pDrawable, int index);
 
 void
-exaFinishAccess(DrawablePtr pDrawable, int index);
+ exaFinishAccess(DrawablePtr pDrawable, int index);
 
 void
-exaDestroyPixmap(PixmapPtr pPixmap);
+ exaDestroyPixmap(PixmapPtr pPixmap);
 
 void
-exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
+ exaPixmapDirty(PixmapPtr pPix, int x1, int y1, int x2, int y2);
 
 void
-exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,
-		      int *xp, int *yp);
+
+exaGetDrawableDeltas(DrawablePtr pDrawable, PixmapPtr pPixmap,
+                     int *xp, int *yp);
 
 Bool
-exaPixmapHasGpuCopy(PixmapPtr p);
+ exaPixmapHasGpuCopy(PixmapPtr p);
 
 PixmapPtr
-exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp);
+ exaGetOffscreenPixmap(DrawablePtr pDrawable, int *xp, int *yp);
 
 PixmapPtr
-exaGetDrawablePixmap(DrawablePtr pDrawable);
+ exaGetDrawablePixmap(DrawablePtr pDrawable);
 
 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);
+ exaDoMigration(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
 
 Bool
-exaPixmapIsPinned (PixmapPtr pPix);
+ exaPixmapIsPinned(PixmapPtr pPix);
 
 extern const GCFuncs exaGCFuncs;
 
 /* exa_classic.c */
 PixmapPtr
+
 exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint);
+                        unsigned usage_hint);
 
 Bool
-exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int depth,
-		      int bitsPerPixel, int devKind, pointer pPixData);
+
+exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height,
+                              int depth, int bitsPerPixel, int devKind,
+                              pointer pPixData);
 
 Bool
-exaDestroyPixmap_classic (PixmapPtr pPixmap);
+ exaDestroyPixmap_classic(PixmapPtr pPixmap);
 
 Bool
-exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
+ exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
 
 /* exa_driver.c */
 PixmapPtr
+
 exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint);
+                       unsigned usage_hint);
 
 Bool
-exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth,
-		      int bitsPerPixel, int devKind, pointer pPixData);
+
+exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height,
+                             int depth, int bitsPerPixel, int devKind,
+                             pointer pPixData);
 
 Bool
-exaDestroyPixmap_driver (PixmapPtr pPixmap);
+ exaDestroyPixmap_driver(PixmapPtr pPixmap);
 
 Bool
-exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
+ exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
 
 /* exa_mixed.c */
 PixmapPtr
+
 exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
-		unsigned usage_hint);
+                      unsigned usage_hint);
 
 Bool
+
 exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
-		      int bitsPerPixel, int devKind, pointer pPixData);
+                            int bitsPerPixel, int devKind, pointer pPixData);
 
 Bool
-exaDestroyPixmap_mixed(PixmapPtr pPixmap);
+ exaDestroyPixmap_mixed(PixmapPtr pPixmap);
 
 Bool
-exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
+ exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
 
 /* exa_migration_mixed.c */
 void
-exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
+ exaCreateDriverPixmap_mixed(PixmapPtr pPixmap);
 
 void
-exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
 
 void
-exaMoveInPixmap_mixed(PixmapPtr pPixmap);
+ exaMoveInPixmap_mixed(PixmapPtr pPixmap);
 
 void
-exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
+ exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure);
 
 void
-exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
+ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg);
 
 /* exa_render.c */
 Bool
-exaOpReadsDestination (CARD8 op);
+ exaOpReadsDestination(CARD8 op);
 
 void
-exaComposite(CARD8	op,
-	     PicturePtr pSrc,
-	     PicturePtr pMask,
-	     PicturePtr pDst,
-	     INT16	xSrc,
-	     INT16	ySrc,
-	     INT16	xMask,
-	     INT16	yMask,
-	     INT16	xDst,
-	     INT16	yDst,
-	     CARD16	width,
-	     CARD16	height);
+
+exaComposite(CARD8 op,
+             PicturePtr pSrc,
+             PicturePtr pMask,
+             PicturePtr pDst,
+             INT16 xSrc,
+             INT16 ySrc,
+             INT16 xMask,
+             INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
 
 void
-exaCompositeRects(CARD8	              op,
-		  PicturePtr	      Src,
-		  PicturePtr	      pMask,
-		  PicturePtr	      pDst,
-		  int                 nrect,
-		  ExaCompositeRectPtr rects);
+
+exaCompositeRects(CARD8 op,
+                  PicturePtr Src,
+                  PicturePtr pMask,
+                  PicturePtr pDst, int nrect, ExaCompositeRectPtr rects);
 
 void
-exaTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
-               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
-               int ntrap, xTrapezoid *traps);
+
+exaTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+              PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+              int ntrap, xTrapezoid * traps);
 
 void
-exaTriangles (CARD8 op, PicturePtr pSrc, PicturePtr pDst,
-	      PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
-	      int ntri, xTriangle *tris);
+
+exaTriangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+             PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+             int ntri, xTriangle * tris);
 
 /* exa_glyph.c */
 void
-exaGlyphsInit(ScreenPtr pScreen);
+ exaGlyphsInit(ScreenPtr pScreen);
 
 void
-exaGlyphsFini (ScreenPtr pScreen);
+ exaGlyphsFini(ScreenPtr pScreen);
 
 void
-exaGlyphs (CARD8	op,
-	  PicturePtr	pSrc,
-	  PicturePtr	pDst,
-	  PictFormatPtr	maskFormat,
-	  INT16		xSrc,
-	  INT16		ySrc,
-	  int		nlist,
-	  GlyphListPtr	list,
-	  GlyphPtr	*glyphs);
+
+exaGlyphs(CARD8 op,
+          PicturePtr pSrc,
+          PicturePtr pDst,
+          PictFormatPtr maskFormat,
+          INT16 xSrc,
+          INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
 
 /* exa_migration_classic.c */
 void
-exaCopyDirtyToSys (ExaMigrationPtr migrate);
+ exaCopyDirtyToSys(ExaMigrationPtr migrate);
 
 void
-exaCopyDirtyToFb (ExaMigrationPtr migrate);
+ exaCopyDirtyToFb(ExaMigrationPtr migrate);
 
 void
-exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
+ exaDoMigration_classic(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
 
 void
-exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area);
+ exaPixmapSave(ScreenPtr pScreen, ExaOffscreenArea * area);
 
 void
-exaMoveOutPixmap_classic (PixmapPtr pPixmap);
+ exaMoveOutPixmap_classic(PixmapPtr pPixmap);
 
 void
-exaMoveInPixmap_classic (PixmapPtr pPixmap);
+ exaMoveInPixmap_classic(PixmapPtr pPixmap);
 
 void
-exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
+ exaPrepareAccessReg_classic(PixmapPtr pPixmap, int index, RegionPtr pReg);
 
-#endif /* EXAPRIV_H */
+#endif                          /* EXAPRIV_H */