/*

 * Copyright © 2004 Keith Packard

 *

 * 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.

 *

 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

 * EVENT SHALL KEITH PACKARD 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.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include "pixman-private.h"

#include "pixman-accessor.h"

/*

 * Step across a small sample grid gap

 */

#define RENDER_EDGE_STEP_SMALL(edge)					\

    {									\

	edge->x += edge->stepx_small;					\

	edge->e += edge->dx_small;					\

	if (edge->e > 0)						\

	{								\

	    edge->e -= edge->dy;					\

	    edge->x += edge->signdx;					\

	}								\

    }

/*

 * Step across a large sample grid gap

 */

#define RENDER_EDGE_STEP_BIG(edge)					\

    {									\

	edge->x += edge->stepx_big;					\

	edge->e += edge->dx_big;					\

	if (edge->e > 0)						\

	{								\

	    edge->e -= edge->dy;					\

	    edge->x += edge->signdx;					\

	}								\

    }

#ifdef PIXMAN_FB_ACCESSORS

#define PIXMAN_RASTERIZE_EDGES pixman_rasterize_edges_accessors

#else

#define PIXMAN_RASTERIZE_EDGES pixman_rasterize_edges_no_accessors

#endif

/*

 * 4 bit alpha

 */

#define N_BITS  4

#define RASTERIZE_EDGES rasterize_edges_4

#ifndef WORDS_BIGENDIAN

#define SHIFT_4(o)      ((o) << 2)

#else

#define SHIFT_4(o)      ((1 - (o)) << 2)

#endif

#define GET_4(x, o)      (((x) >> SHIFT_4 (o)) & 0xf)

#define PUT_4(x, o, v)							\

    (((x) & ~(0xf << SHIFT_4 (o))) | (((v) & 0xf) << SHIFT_4 (o)))

#define DEFINE_ALPHA(line, x)						\

    uint8_t   *__ap = (uint8_t *) line + ((x) >> 1);			\

    int __ao = (x) & 1

#define STEP_ALPHA      ((__ap += __ao), (__ao ^= 1))

#define ADD_ALPHA(a)							\

    {									\

        uint8_t __o = READ (image, __ap);				\

        uint8_t __a = (a) + GET_4 (__o, __ao);				\

        WRITE (image, __ap, PUT_4 (__o, __ao, __a | (0 - ((__a) >> 4)))); \

    }

#include "pixman-edge-imp.h"

#undef ADD_ALPHA

#undef STEP_ALPHA

#undef DEFINE_ALPHA

#undef RASTERIZE_EDGES

#undef N_BITS

/*

 * 1 bit alpha

 */

#define N_BITS 1

#define RASTERIZE_EDGES rasterize_edges_1

#include "pixman-edge-imp.h"

#undef RASTERIZE_EDGES

#undef N_BITS

/*

 * 8 bit alpha

 */

static force_inline uint8_t

clip255 (int x)

{

    if (x > 255)

	return 255;

    return x;

}

#define ADD_SATURATE_8(buf, val, length)				\

    do									\

    {									\

        int i__ = (length);						\

        uint8_t *buf__ = (buf);						\

        int val__ = (val);						\

									\

        while (i__--)							\

        {								\

            WRITE (image, (buf__), clip255 (READ (image, (buf__)) + (val__))); \

            (buf__)++;							\

	}								\

    } while (0)

/*

 * We want to detect the case where we add the same value to a long

 * span of pixels.  The triangles on the end are filled in while we

 * count how many sub-pixel scanlines contribute to the middle section.

 *

 *                 +--------------------------+

 *  fill_height =|   \                      /

 *                     +------------------+

 *                      |================|

 *                   fill_start       fill_end

 */

static void

rasterize_edges_8 (pixman_image_t *image,

                   pixman_edge_t * l,

                   pixman_edge_t * r,

                   pixman_fixed_t  t,

                   pixman_fixed_t  b)

{

    pixman_fixed_t y = t;

    uint32_t  *line;

    int fill_start = -1, fill_end = -1;

    int fill_size = 0;

    uint32_t *buf = (image)->bits.bits;

    int stride = (image)->bits.rowstride;

    int width = (image)->bits.width;

    line = buf + pixman_fixed_to_int (y) * stride;

    for (;;)

    {

        uint8_t *ap = (uint8_t *) line;

        pixman_fixed_t lx, rx;

        int lxi, rxi;

        /* clip X */

        lx = l->x;

        if (lx < 0)

	    lx = 0;

        rx = r->x;

        if (pixman_fixed_to_int (rx) >= width)

	{

	    /* Use the last pixel of the scanline, covered 100%.

	     * We can't use the first pixel following the scanline,

	     * because accessing it could result in a buffer overrun.

	     */

	    rx = pixman_int_to_fixed (width) - 1;

	}

        /* Skip empty (or backwards) sections */

        if (rx > lx)

        {

            int lxs, rxs;

            /* Find pixel bounds for span. */

            lxi = pixman_fixed_to_int (lx);

            rxi = pixman_fixed_to_int (rx);

            /* Sample coverage for edge pixels */

            lxs = RENDER_SAMPLES_X (lx, 8);

            rxs = RENDER_SAMPLES_X (rx, 8);

            /* Add coverage across row */

            if (lxi == rxi)

            {

                WRITE (image, ap + lxi,

		       clip255 (READ (image, ap + lxi) + rxs - lxs));

	    }

            else

            {

                WRITE (image, ap + lxi,

		       clip255 (READ (image, ap + lxi) + N_X_FRAC (8) - lxs));

                /* Move forward so that lxi/rxi is the pixel span */

                lxi++;

                /* Don't bother trying to optimize the fill unless

		 * the span is longer than 4 pixels. */

                if (rxi - lxi > 4)

                {

                    if (fill_start < 0)

                    {

                        fill_start = lxi;

                        fill_end = rxi;

                        fill_size++;

		    }

                    else

                    {

                        if (lxi >= fill_end || rxi < fill_start)

                        {

                            /* We're beyond what we saved, just fill it */

                            ADD_SATURATE_8 (ap + fill_start,

                                            fill_size * N_X_FRAC (8),

                                            fill_end - fill_start);

                            fill_start = lxi;

                            fill_end = rxi;

                            fill_size = 1;

			}

                        else

                        {

                            /* Update fill_start */

                            if (lxi > fill_start)

                            {

                                ADD_SATURATE_8 (ap + fill_start,

                                                fill_size * N_X_FRAC (8),

                                                lxi - fill_start);

                                fill_start = lxi;

			    }

                            else if (lxi < fill_start)

                            {

                                ADD_SATURATE_8 (ap + lxi, N_X_FRAC (8),

                                                fill_start - lxi);

			    }

                            /* Update fill_end */

                            if (rxi < fill_end)

                            {

                                ADD_SATURATE_8 (ap + rxi,

                                                fill_size * N_X_FRAC (8),

                                                fill_end - rxi);

                                fill_end = rxi;

			    }

                            else if (fill_end < rxi)

                            {

                                ADD_SATURATE_8 (ap + fill_end,

                                                N_X_FRAC (8),

                                                rxi - fill_end);

			    }

                            fill_size++;

			}

		    }

		}

                else

                {

                    ADD_SATURATE_8 (ap + lxi, N_X_FRAC (8), rxi - lxi);

		}

                WRITE (image, ap + rxi, clip255 (READ (image, ap + rxi) + rxs));

	    }

	}

        if (y == b)

        {

            /* We're done, make sure we clean up any remaining fill. */

            if (fill_start != fill_end)

            {

                if (fill_size == N_Y_FRAC (8))

                {

                    MEMSET_WRAPPED (image, ap + fill_start,

				    0xff, fill_end - fill_start);

		}

                else

                {

                    ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC (8),

                                    fill_end - fill_start);

		}

	    }

            break;

	}

        if (pixman_fixed_frac (y) != Y_FRAC_LAST (8))

        {

            RENDER_EDGE_STEP_SMALL (l);

            RENDER_EDGE_STEP_SMALL (r);

            y += STEP_Y_SMALL (8);

	}

        else

        {

            RENDER_EDGE_STEP_BIG (l);

            RENDER_EDGE_STEP_BIG (r);

            y += STEP_Y_BIG (8);

            if (fill_start != fill_end)

            {

                if (fill_size == N_Y_FRAC (8))

                {

                    MEMSET_WRAPPED (image, ap + fill_start,

				    0xff, fill_end - fill_start);

		}

                else

                {

                    ADD_SATURATE_8 (ap + fill_start, fill_size * N_X_FRAC (8),

                                    fill_end - fill_start);

		}

                fill_start = fill_end = -1;

                fill_size = 0;

	    }

            line += stride;

	}

    }

}

#ifndef PIXMAN_FB_ACCESSORS

static

#endif

void

PIXMAN_RASTERIZE_EDGES (pixman_image_t *image,

                        pixman_edge_t * l,

                        pixman_edge_t * r,

                        pixman_fixed_t  t,

                        pixman_fixed_t  b)

{

    switch (PIXMAN_FORMAT_BPP (image->bits.format))

    {

    case 1:

	rasterize_edges_1 (image, l, r, t, b);

	break;

    case 4:

	rasterize_edges_4 (image, l, r, t, b);

	break;

    case 8:

	rasterize_edges_8 (image, l, r, t, b);

	break;

    default:

        break;

    }

}

#ifndef PIXMAN_FB_ACCESSORS

PIXMAN_EXPORT void

pixman_rasterize_edges (pixman_image_t *image,

                        pixman_edge_t * l,

                        pixman_edge_t * r,

                        pixman_fixed_t  t,

                        pixman_fixed_t  b)

{

    return_if_fail (image->type == BITS);

    return_if_fail (PIXMAN_FORMAT_TYPE (image->bits.format) == PIXMAN_TYPE_A);

    if (image->bits.read_func || image->bits.write_func)

	pixman_rasterize_edges_accessors (image, l, r, t, b);

    else

	pixman_rasterize_edges_no_accessors (image, l, r, t, b);

}

#endif