xenocara/xserver/hw/xfree86/xaa/xaaFillArc.c

/*
 * 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);
    }
}