xserver git update 11/6/2010

1 files changed, 213 insertions, 213 deletions

diff --git a/xorg-server/hw/xfree86/xaa/xaaFillArc.c b/xorg-server/hw/xfree86/xaa/xaaFillArc.c
index d83922ce0..824d2af1d 100644
--- a/xorg-server/hw/xfree86/xaa/xaaFillArc.c
+++ b/xorg-server/hw/xfree86/xaa/xaaFillArc.c
@@ -1,213 +1,213 @@
-/*
- * Copyright 1996  The XFree86 Project
- *
- * 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, sublicense, 
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL 
- * HARM HANEMAAYER 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.
- * 
- * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).
- */
- 
-/*
- * Filled solid arcs, based on cfbfillarc.c.
- *
- * Fill arc using calls to low-level span fill. Because the math for
- * each span can be done concurrently with the drawing of the span
- * with a graphics coprocessor operation, this is faster than just
- * using miPolyFillArc, which first calculates all the spans and then
- * calls FillSpans.
- *
- * Clipped arcs are dispatched to FillSpans.
- */
-#ifdef HAVE_XORG_CONFIG_H
-#include <xorg-config.h>
-#endif
-
-#include <limits.h>
-
-#include "misc.h"
-#include "xf86.h"
-#include "xf86_OSproc.h"
-
-#include <X11/X.h>
-#include "scrnintstr.h"
-#include "pixmapstr.h"
-#include "xf86str.h"
-#include "xaa.h"
-#include "xaalocal.h"
-#include "mifillarc.h"
-#include "mi.h"
-
-/*
- * This is based on the integer-math versions from mi. Perhaps on a
- * Pentium, the floating-point (double)-math version is faster.
- */
-
-static void
-XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
-{
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    register int x, y, e;
-    int yk, xk, ym, xm, dx, dy, xorg, yorg;
-    int slw;
-    miFillArcRec info;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
-		pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    MIFILLARCSETUP();
-    if (pGC->miTranslate)
-    {
-	xorg += pDraw->x;
-	yorg += pDraw->y;
-    }
-    while (y > 0)
-    {
-	MIFILLARCSTEP(slw);
-	if (slw > 0) {
-	    (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn, xorg - x,
-		    yorg - y, slw, 1);
-            if (miFillArcLower(slw))
-		(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,
-			xorg - x, yorg + y + dy, slw, 1);
-	}
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-#define ADDSPAN(l,r) \
-    if (r >= l) \
-	(*infoRec->SubsequentSolidFillRect)( \
-	    infoRec->pScrn, l, ya, r - l + 1, 1);
-
-#define ADDSLICESPANS(flip) \
-    if (!flip) \
-    { \
-	ADDSPAN(xl, xr); \
-    } \
-    else \
-    { \
-	xc = xorg - x; \
-	ADDSPAN(xc, xr); \
-	xc += slw - 1; \
-	ADDSPAN(xl, xc); \
-    }
-
-static void
-XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)
-{ 
-    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
-    register int x, y, e;
-    miFillArcRec info;
-    miArcSliceRec slice;
-    int ya, xl, xr, xc;
-
-    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,
-        pGC->planemask);
-
-    miFillArcSetup(arc, &info);
-    miFillArcSliceSetup(arc, &slice, pGC);
-    MIFILLARCSETUP();
-    slw = arc->height;
-    if (slice.flip_top || slice.flip_bot)
-	slw += (arc->height >> 1) + 1;
-    if (pGC->miTranslate)
-    {
-	xorg += pDraw->x;
-	yorg += pDraw->y;
-	slice.edge1.x += pDraw->x;
-	slice.edge2.x += pDraw->x;
-    }
-    while (y > 0)
-    {
-	MIFILLARCSTEP(slw);
-	MIARCSLICESTEP(slice.edge1);
-	MIARCSLICESTEP(slice.edge2);
-	if (miFillSliceUpper(slice))
-	{
-	    ya = yorg - y;
-	    MIARCSLICEUPPER(xl, xr, slice, slw);
-	    
-	    ADDSLICESPANS(slice.flip_top);
-	}
-	if (miFillSliceLower(slice))
-	{
-	    ya = yorg + y + dy;
-	    MIARCSLICELOWER(xl, xr, slice, slw);
-	    ADDSLICESPANS(slice.flip_bot);
-	}
-    }
-
-    SET_SYNC_FLAG(infoRec);
-}
-
-
-void
-XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
-{
-    register xArc *arc;
-    register int i;
-    int x2, y2;
-    BoxRec box;
-    RegionPtr cclip;
-
-    cclip = pGC->pCompositeClip;
-
-    if(!REGION_NUM_RECTS(cclip))
-	return;
-
-    for (arc = parcs, i = narcs; --i >= 0; arc++)
-    {
-	if (miFillArcEmpty(arc))
-	    continue;
-	if (miCanFillArc(arc))
-	{
-	    box.x1 = arc->x + pDraw->x;
-	    box.y1 = arc->y + pDraw->y;
- 	    /*
- 	     * Because box.x2 and box.y2 get truncated to 16 bits, and the
- 	     * RECT_IN_REGION test treats the resulting number as a signed
- 	     * integer, the RECT_IN_REGION test alone can go the wrong way.
- 	     * This can result in a server crash because the rendering
- 	     * routines in this file deal directly with cpu addresses
- 	     * of pixels to be stored, and do not clip or otherwise check
- 	     * that all such addresses are within their respective pixmaps.
- 	     * So we only allow the RECT_IN_REGION test to be used for
- 	     * values that can be expressed correctly in a signed short.
- 	     */
- 	    x2 = box.x1 + (int)arc->width + 1;
- 	    box.x2 = x2;
- 	    y2 = box.y1 + (int)arc->height + 1;
- 	    box.y2 = y2;
- 	    if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
- 		    (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
-	    {
-		if ((arc->angle2 >= FULLCIRCLE) ||
-		    (arc->angle2 <= -FULLCIRCLE))
-		    XAAFillEllipseSolid(pDraw, pGC, arc);
-		else
-		    XAAFillArcSliceSolid(pDraw, pGC, arc);
-		continue;
-	    }
-	}
-	miPolyFillArc(pDraw, pGC, 1, arc);
-    }
-}
+/*

+ * Copyright 1996  The XFree86 Project

+ *

+ * 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, sublicense, 

+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL 

+ * HARM HANEMAAYER 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.

+ * 

+ * Written by Harm Hanemaayer (H.Hanemaayer@inter.nl.net).

+ */

+ 

+/*

+ * Filled solid arcs, based on cfbfillarc.c.

+ *

+ * Fill arc using calls to low-level span fill. Because the math for

+ * each span can be done concurrently with the drawing of the span

+ * with a graphics coprocessor operation, this is faster than just

+ * using miPolyFillArc, which first calculates all the spans and then

+ * calls FillSpans.

+ *

+ * Clipped arcs are dispatched to FillSpans.

+ */

+#ifdef HAVE_XORG_CONFIG_H

+#include <xorg-config.h>

+#endif

+

+#include <limits.h>

+

+#include "misc.h"

+#include "xf86.h"

+#include "xf86_OSproc.h"

+

+#include <X11/X.h>

+#include "scrnintstr.h"

+#include "pixmapstr.h"

+#include "xf86str.h"

+#include "xaa.h"

+#include "xaalocal.h"

+#include "mifillarc.h"

+#include "mi.h"

+

+/*

+ * This is based on the integer-math versions from mi. Perhaps on a

+ * Pentium, the floating-point (double)-math version is faster.

+ */

+

+static void

+XAAFillEllipseSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)

+{

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    register int x, y, e;

+    int yk, xk, ym, xm, dx, dy, xorg, yorg;

+    int slw;

+    miFillArcRec info;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,

+		pGC->planemask);

+

+    miFillArcSetup(arc, &info);

+    MIFILLARCSETUP();

+    if (pGC->miTranslate)

+    {

+	xorg += pDraw->x;

+	yorg += pDraw->y;

+    }

+    while (y > 0)

+    {

+	MIFILLARCSTEP(slw);

+	if (slw > 0) {

+	    (*infoRec->SubsequentSolidFillRect)(infoRec->pScrn, xorg - x,

+		    yorg - y, slw, 1);

+            if (miFillArcLower(slw))

+		(*infoRec->SubsequentSolidFillRect)(infoRec->pScrn,

+			xorg - x, yorg + y + dy, slw, 1);

+	}

+    }

+

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+#define ADDSPAN(l,r) \

+    if (r >= l) \

+	(*infoRec->SubsequentSolidFillRect)( \

+	    infoRec->pScrn, l, ya, r - l + 1, 1);

+

+#define ADDSLICESPANS(flip) \

+    if (!flip) \

+    { \

+	ADDSPAN(xl, xr); \

+    } \

+    else \

+    { \

+	xc = xorg - x; \

+	ADDSPAN(xc, xr); \

+	xc += slw - 1; \

+	ADDSPAN(xl, xc); \

+    }

+

+static void

+XAAFillArcSliceSolid(DrawablePtr pDraw, GCPtr pGC, xArc *arc)

+{ 

+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);

+    int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;

+    register int x, y, e;

+    miFillArcRec info;

+    miArcSliceRec slice;

+    int ya, xl, xr, xc;

+

+    (*infoRec->SetupForSolidFill)(infoRec->pScrn, pGC->fgPixel, pGC->alu,

+        pGC->planemask);

+

+    miFillArcSetup(arc, &info);

+    miFillArcSliceSetup(arc, &slice, pGC);

+    MIFILLARCSETUP();

+    slw = arc->height;

+    if (slice.flip_top || slice.flip_bot)

+	slw += (arc->height >> 1) + 1;

+    if (pGC->miTranslate)

+    {

+	xorg += pDraw->x;

+	yorg += pDraw->y;

+	slice.edge1.x += pDraw->x;

+	slice.edge2.x += pDraw->x;

+    }

+    while (y > 0)

+    {

+	MIFILLARCSTEP(slw);

+	MIARCSLICESTEP(slice.edge1);

+	MIARCSLICESTEP(slice.edge2);

+	if (miFillSliceUpper(slice))

+	{

+	    ya = yorg - y;

+	    MIARCSLICEUPPER(xl, xr, slice, slw);

+	    

+	    ADDSLICESPANS(slice.flip_top);

+	}

+	if (miFillSliceLower(slice))

+	{

+	    ya = yorg + y + dy;

+	    MIARCSLICELOWER(xl, xr, slice, slw);

+	    ADDSLICESPANS(slice.flip_bot);

+	}

+    }

+

+    SET_SYNC_FLAG(infoRec);

+}

+

+

+void

+XAAPolyFillArcSolid(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)

+{

+    register xArc *arc;

+    register int i;

+    int x2, y2;

+    BoxRec box;

+    RegionPtr cclip;

+

+    cclip = pGC->pCompositeClip;

+

+    if(!RegionNumRects(cclip))

+	return;

+

+    for (arc = parcs, i = narcs; --i >= 0; arc++)

+    {

+	if (miFillArcEmpty(arc))

+	    continue;

+	if (miCanFillArc(arc))

+	{

+	    box.x1 = arc->x + pDraw->x;

+	    box.y1 = arc->y + pDraw->y;

+ 	    /*

+ 	     * Because box.x2 and box.y2 get truncated to 16 bits, and the

+ 	     * RECT_IN_REGION test treats the resulting number as a signed

+ 	     * integer, the RECT_IN_REGION test alone can go the wrong way.

+ 	     * This can result in a server crash because the rendering

+ 	     * routines in this file deal directly with cpu addresses

+ 	     * of pixels to be stored, and do not clip or otherwise check

+ 	     * that all such addresses are within their respective pixmaps.

+ 	     * So we only allow the RECT_IN_REGION test to be used for

+ 	     * values that can be expressed correctly in a signed short.

+ 	     */

+ 	    x2 = box.x1 + (int)arc->width + 1;

+ 	    box.x2 = x2;

+ 	    y2 = box.y1 + (int)arc->height + 1;

+ 	    box.y2 = y2;

+ 	    if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&

+		    (RegionContainsRect(cclip, &box) == rgnIN) )

+	    {

+		if ((arc->angle2 >= FULLCIRCLE) ||

+		    (arc->angle2 <= -FULLCIRCLE))

+		    XAAFillEllipseSolid(pDraw, pGC, arc);

+		else

+		    XAAFillArcSliceSolid(pDraw, pGC, arc);

+		continue;

+	    }

+	}

+	miPolyFillArc(pDraw, pGC, 1, arc);

+    }

+}