xref: /xsrc/external/mit/xf86-video-geode/dist/src/lx_exa.c

/*
 * Copyright (c) 2007-2008 Advanced Micro Devices, Inc.
 *
 * 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 THE
 * AUTHORS OR COPYRIGHT HOLDERS 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.
 *
 * Neither the name of the Advanced Micro Devices, Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 */

/* TODO:
   Support a8 as a source or destination?
   convert !a8 or !a4 masks?
   support multiple pass operations?
*/

/* To support PictOptAdd with a mask */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "xf86.h"
#include "exa.h"

#include "geode.h"
#include "cim_defs.h"
#include "cim_regs.h"

#include "geode_blend.h"

#define F(x)    IntToxFixed(x)
#define I(x)    xFixedToInt(x)

static const struct exa_format_t
{
    int exa;
    int bpp;
    int fmt;
    int alphabits;
} lx_exa_formats[] = {
    {
    PICT_a8r8g8b8, 32, CIMGP_SOURCE_FMT_8_8_8_8, 8}, {
    PICT_x8r8g8b8, 32, CIMGP_SOURCE_FMT_8_8_8_8, 0}, {
    PICT_x8b8g8r8, 32, CIMGP_SOURCE_FMT_32BPP_BGR, 0}, {
    PICT_a4r4g4b4, 16, CIMGP_SOURCE_FMT_4_4_4_4, 4}, {
    PICT_a1r5g5b5, 16, CIMGP_SOURCE_FMT_1_5_5_5, 1}, {
    PICT_r5g6b5, 16, CIMGP_SOURCE_FMT_0_5_6_5, 0}, {
    PICT_b5g6r5, 16, CIMGP_SOURCE_FMT_16BPP_BGR, 0}, {
    PICT_x1r5g5b5, 16, CIMGP_SOURCE_FMT_1_5_5_5, 0}, {
    PICT_x1b5g5r5, 16, CIMGP_SOURCE_FMT_15BPP_BGR, 0}, {
    PICT_r3g3b2, 8, CIMGP_SOURCE_FMT_3_3_2, 0}, {
    PICT_a8, 32, CIMGP_SOURCE_FMT_8_8_8_8, 8}
};

/* This is a chunk of memory we use for scratch space */

#define COMP_TYPE_MASK 0
#define COMP_TYPE_ONEPASS 1
#define COMP_TYPE_TWOPASS 3
#define COMP_TYPE_ROTATE  5

static struct
{
    int type;

    unsigned int srcOffset;
    unsigned int srcPitch;
    unsigned int srcBpp;
    unsigned int srcWidth, srcHeight;
    PixmapPtr srcPixmap;

    unsigned int srcColor;
    int op;
    int repeat;
    int maskrepeat;
    unsigned int fourBpp;
    unsigned int bufferOffset;
    struct exa_format_t *srcFormat;
    struct exa_format_t *dstFormat;

    int rotate;
    PictTransform *transform;

} exaScratch;

static const int SDfn[16] = {
    0x00, 0x88, 0x44, 0xCC, 0x22, 0xAA, 0x66, 0xEE,
    0x11, 0x99, 0x55, 0xDD, 0x33, 0xBB, 0x77, 0xFF
};

static const int SDfn_PM[16] = {
    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA
};

/* These functions check to see if we can safely prefetch the memory
 * for the blt, or if we have to wait the previous blt to complete.
 * One function is for the fill, and the other is for the copy because
 * they have different requirements based on ROP
 */

static int lx0 = -1, ly0 = -1, lx1 = -1, ly1 = -1;

static int
lx_fill_flags(int x0, int y0, int w, int h, int rop)
{
    int x1 = x0 + w, y1 = y0 + h;
    int n = ((rop ^ (rop >> 1)) & 0x55) == 0 ||	/* no dst */
	x0 >= lx1 || y0 >= ly1 ||      /* rght/below */
	x1 <= lx0 || y1 <= ly0 ?       /* left/above */
	0 : CIMGP_BLTFLAGS_HAZARD;

    lx0 = x0;
    ly0 = y0;
    lx1 = x1;
    ly1 = y1;

    return n;
}

static int
lx_copy_flags(int x0, int y0, int x1, int y1, int w, int h, int rop)
{
    int x2 = x1 + w, y2 = y1 + h;

    /* dst not hazzard and src not hazzard */
    int n = (((rop ^ (rop >> 1)) & 0x55) == 0 ||
	x1 >= lx1 || y1 >= ly1 ||
	x2 <= lx0 || y2 <= ly0) &&
	(((rop ^ (rop >> 2)) & 0x33) == 0 ||
	x0 >= lx1 || y0 >= ly1 ||
	x0 + w <= lx0 || y0 + h <= ly0) ? 0 : CIMGP_BLTFLAGS_HAZARD;

    lx0 = x1;
    ly0 = y1;
    lx1 = x2;
    ly1 = y2;

    return n;
}

/* These are borrowed from the exa engine - they should be made global
   and available to drivers, but until then....
*/

/* exaGetPixelFromRGBA (exa_render.c) */

static Bool
_GetPixelFromRGBA(CARD32 * pixel,
    CARD16 red, CARD16 green, CARD16 blue, CARD16 alpha, CARD32 format)
{
    int rbits, bbits, gbits, abits;
    int rshift, bshift, gshift, ashift;

    *pixel = 0;

    if (!PICT_FORMAT_COLOR(format))
	return FALSE;

    rbits = PICT_FORMAT_R(format);
    gbits = PICT_FORMAT_G(format);
    bbits = PICT_FORMAT_B(format);
    abits = PICT_FORMAT_A(format);

    if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) {
	bshift = 0;
	gshift = bbits;
	rshift = gshift + gbits;
	ashift = rshift + rbits;
    } else {			       /* PICT_TYPE_ABGR */
	rshift = 0;
	gshift = rbits;
	bshift = gshift + gbits;
	ashift = bshift + bbits;
    }

    *pixel |= (blue >> (16 - bbits)) << bshift;
    *pixel |= (red >> (16 - rbits)) << rshift;
    *pixel |= (green >> (16 - gbits)) << gshift;
    *pixel |= (alpha >> (16 - abits)) << ashift;

    return TRUE;
}

/* exaGetRGBAFromPixel (exa_render.c) */

static Bool
_GetRGBAFromPixel(CARD32 pixel,
    CARD16 * red,
    CARD16 * green, CARD16 * blue, CARD16 * alpha, CARD32 format)
{
    int rbits, bbits, gbits, abits;
    int rshift, bshift, gshift, ashift;

    if (!PICT_FORMAT_COLOR(format))
	return FALSE;

    rbits = PICT_FORMAT_R(format);
    gbits = PICT_FORMAT_G(format);
    bbits = PICT_FORMAT_B(format);
    abits = PICT_FORMAT_A(format);

    if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) {
	bshift = 0;
	gshift = bbits;
	rshift = gshift + gbits;
	ashift = rshift + rbits;
    } else {			       /* PICT_TYPE_ABGR */
	rshift = 0;
	gshift = rbits;
	bshift = gshift + gbits;
	ashift = bshift + bbits;
    }

    *red = ((pixel >> rshift) & ((1 << rbits) - 1)) << (16 - rbits);
    while (rbits < 16) {
	*red |= *red >> rbits;
	rbits <<= 1;
    }

    *green = ((pixel >> gshift) & ((1 << gbits) - 1)) << (16 - gbits);
    while (gbits < 16) {
	*green |= *green >> gbits;
	gbits <<= 1;
    }

    *blue = ((pixel >> bshift) & ((1 << bbits) - 1)) << (16 - bbits);
    while (bbits < 16) {
	*blue |= *blue >> bbits;
	bbits <<= 1;
    }

    if (abits) {
	*alpha = ((pixel >> ashift) & ((1 << abits) - 1)) << (16 - abits);
	while (abits < 16) {
	    *alpha |= *alpha >> abits;
	    abits <<= 1;
	}
    } else
	*alpha = 0xffff;

    return TRUE;
}

static unsigned int
lx_get_source_color(PixmapPtr pSrc, int srcFormat, int dstFormat)
{
    CARD32 in, out;
    CARD16 red = 0, green = 0, blue = 0, alpha = 0;

    /* Stall to avoid a race with the upload function */
    /* for 1.4 and newer, the problem will be resolved within
     * exaGetPixmapFirstPixel, so this should be adjusted so
     * the stall isn't run needlessly
     */

    gp_wait_until_idle();
    in = exaGetPixmapFirstPixel(pSrc);

    _GetRGBAFromPixel(in, &red, &blue, &green, &alpha, srcFormat);
    _GetPixelFromRGBA(&out, red, blue, green, alpha, dstFormat);

    return out;
}

static Bool
lx_prepare_solid(PixmapPtr pxMap, int alu, Pixel planemask, Pixel fg)
{
    int pitch = exaGetPixmapPitch(pxMap);
    int op = (planemask == ~0U) ? SDfn[alu] : SDfn_PM[alu];

    gp_declare_blt(0);
    gp_set_bpp(pxMap->drawable.bitsPerPixel);

    gp_set_raster_operation(op);

    if (planemask != ~0U)
	gp_set_solid_pattern(planemask);

    exaScratch.op = op;

    gp_set_solid_source(fg);

    gp_set_strides(pitch, pitch);
    gp_write_parameters();
    return TRUE;
}

static void
lx_do_solid(PixmapPtr pxMap, int x1, int y1, int x2, int y2)
{
    int bpp = (pxMap->drawable.bitsPerPixel + 7) / 8;
    int pitch = exaGetPixmapPitch(pxMap);
    unsigned int offset =
	exaGetPixmapOffset(pxMap) + (pitch * y1) + (bpp * x1);

    gp_declare_blt(lx_fill_flags(x1, y1, x2 - x1, y2 - y1, exaScratch.op));
    gp_pattern_fill(offset, x2 - x1, y2 - y1);
}

static Bool
lx_prepare_copy(PixmapPtr pxSrc, PixmapPtr pxDst, int dx, int dy,
    int alu, Pixel planemask)
{
    int dpitch = exaGetPixmapPitch(pxDst);
    int op = (planemask == ~0U) ? SDfn[alu] : SDfn_PM[alu];

    gp_declare_blt(0);
    gp_set_bpp(pxDst->drawable.bitsPerPixel);

    gp_set_raster_operation(op);

    if (planemask != ~0U)
	gp_set_solid_pattern(planemask);

    exaScratch.srcOffset = exaGetPixmapOffset(pxSrc);
    exaScratch.srcPitch = exaGetPixmapPitch(pxSrc);
    exaScratch.srcBpp = (pxSrc->drawable.bitsPerPixel + 7) / 8;

    exaScratch.op = op;

    gp_set_strides(dpitch, exaScratch.srcPitch);
    gp_write_parameters();
    return TRUE;
}

static void
lx_do_copy(PixmapPtr pxDst, int srcX, int srcY,
    int dstX, int dstY, int w, int h)
{
    int dstBpp = (pxDst->drawable.bitsPerPixel + 7) / 8;
    int dstPitch = exaGetPixmapPitch(pxDst);
    unsigned int srcOffset, dstOffset;
    int flags = 0;

    gp_declare_blt(lx_copy_flags(srcX, srcY, dstX, dstY, w, h,
	    exaScratch.op));

    srcOffset = exaScratch.srcOffset + (exaScratch.srcPitch * srcY) +
	(exaScratch.srcBpp) * srcX;

    dstOffset = exaGetPixmapOffset(pxDst) +
	(dstPitch * dstY) + (dstBpp * dstX);

    if (dstX > srcX)
	flags |= CIMGP_NEGXDIR;

    if (dstY > srcY)
	flags |= CIMGP_NEGYDIR;

    gp_screen_to_screen_blt(dstOffset, srcOffset, w, h, flags);
}

/* Composite operations

These are the simplest - one pass operations - if there is no format or
mask, the we can make these happen pretty fast

                       Operation  Type  Channel   Alpha
PictOpClear            0          2     0         3
PictOpSrc              0          3     0         3
PictOpDst              0          3     1         3
PictOpOver             2          0     0         3
PictOpOverReverse      2          0     1         3
PictOpIn               0          1     0         3
PictOpInReverse        0          1     1         3
PictOpOut              1          0     0         3
PictOpOutReverse       1          0     1         3
PictOpAdd              2          2     0         3

The following require multiple passes
PictOpAtop
PictOpXor
*/

struct blend_ops_t
{
    int operation;
    int type;
    int channel;
} lx_alpha_ops[] = {
    /* PictOpClear */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONSTANT_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    },
	/* PictOpSrc */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_ALPHA_EQUALS_ONE, CIMGP_CHANNEL_A_SOURCE}, {
    },
	/* PictOpDst */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_ALPHA_EQUALS_ONE, CIMGP_CHANNEL_A_DEST}, {
    },
	/* PictOpOver */
    {
    CIMGP_A_PLUS_BETA_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpOverReverse */
    {
    CIMGP_A_PLUS_BETA_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_DEST}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpIn */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_CHANNEL_B_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpInReverse */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_CHANNEL_B_ALPHA, CIMGP_CHANNEL_A_DEST}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpOut */
    {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_DEST}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpOutReverse */
    {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    CIMGP_ALPHA_TIMES_A, CIMGP_CONVERTED_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* SrcAtop */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_CHANNEL_B_ALPHA, CIMGP_CHANNEL_A_DEST}, {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* SrcAtopReverse */
    {
    CIMGP_ALPHA_TIMES_A, CIMGP_CHANNEL_B_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_DEST},
	/* Xor */
    {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    CIMGP_BETA_TIMES_B, CIMGP_CHANNEL_A_ALPHA, CIMGP_CHANNEL_A_SOURCE},
	/* PictOpAdd */
    {
    CIMGP_A_PLUS_BETA_B, CIMGP_CONSTANT_ALPHA, CIMGP_CHANNEL_A_SOURCE}, {
    }
};

#define ARRAY_SIZE(a) (sizeof((a)) / (sizeof(*(a))))

static const struct exa_format_t *
lx_get_format(PicturePtr p)
{
    int i;
    unsigned int format = p->format;

    for (i = 0; i < ARRAY_SIZE(lx_exa_formats); i++)
	if (lx_exa_formats[i].exa == format)
	    return (&lx_exa_formats[i]);

    return NULL;
}

static Bool
lx_process_transform(PicturePtr pSrc)
{
    PictTransformPtr t = pSrc->transform;
    xFixed c0 = t->matrix[0][0];
    xFixed s0 = t->matrix[0][1];
    xFixed s1 = t->matrix[1][0];
    xFixed c1 = t->matrix[1][1];

    /* If the transform doesn't have any rotation
     * or scaling components, then just grab the
     * translate coordinates */

    if (t->matrix[0][0] == 0 &&
	t->matrix[0][1] == 0 &&
	t->matrix[1][0] == 0 && t->matrix[1][1] == 0) {
	exaScratch.transform = pSrc->transform;
	return TRUE;
    }

    /* Otherwise, see if this is a simple
     * rotate transform - if it isn't, then
     * we have to punt back to software */

    if (t->matrix[2][2] != F(1))
	return FALSE;

    /* The rotate matrix looks like this:
     * [ cos X   -sin x
     * sin X   cos X ]
     *
     * Where X is the angle.  We do a simple
     * check first - if [0,0] != [1,1], then
     * scaling was specified too, and we can
     * bail, and if [0,1] != -[1,1] then this
     * isn't scaling that we can handle.
     */

    if ((c0 != c1) || (s0 != -s1))
	return FALSE;

    /* Now, figure out what angle we want - we
     * can only accelerate right angle rotations,
     * so this turns into an easy set of if statements */

    if (c0 == F(1) && s1 == F(0))
	exaScratch.rotate = RR_Rotate_0;
    else if (c0 == F(0) && s1 == F(1))
	exaScratch.rotate = RR_Rotate_90;
    else if (c0 == F(-1) && s1 == F(0))
	exaScratch.rotate = RR_Rotate_180;
    else if (c0 == F(0) && s1 == F(-1))
	exaScratch.rotate = RR_Rotate_270;
    else
	return FALSE;

    exaScratch.transform = pSrc->transform;

    return TRUE;
}

static Bool
lx_check_composite(int op, PicturePtr pSrc, PicturePtr pMsk, PicturePtr pDst)
{
    GeodeRec *pGeode = GEODEPTR_FROM_PICTURE(pDst);
    const struct exa_format_t *srcFmt, *dstFmt;

    /* Check that the operation is supported */

    if (op > PictOpAdd)
	return FALSE;

    /* FIXME: Meet this conditions from the debug for PictOpAdd.
     * Any Other possibilities? Add a judge for the future supplement */
    if (op == PictOpAdd && pSrc->format == PICT_a8r8g8b8 &&
	pDst->format == PICT_a8 && !pMsk)
	return TRUE;

    if (op == PictOpAdd && pSrc->format == PICT_x8r8g8b8 &&
	pDst->format == PICT_a8 && !pMsk)
	return TRUE;

    if (op == PictOpAdd && pSrc->format == PICT_r5g6b5 &&
	pDst->format == PICT_a8 && !pMsk)
	return TRUE;

    /* We need the off-screen buffer to do the multipass work */

    if (usesPasses(op)) {
	if (pGeode->exaBfrOffset == 0 || !pMsk)
	    return FALSE;
    }

    if (pMsk && op == PictOpAdd)
	return FALSE;

    /* Check that the filter matches what we support */

    switch (pSrc->filter) {
    case PictFilterNearest:
    case PictFilterFast:
    case PictFilterGood:
    case PictFilterBest:
	break;

    default:
	/* WE don't support bilinear or convolution filters */
	return FALSE;
    }

    /* We don't support any mask transforms */
    if (pMsk && pMsk->transform)
	return FALSE;

    /* XXX - don't know if we can do any hwaccel on solid fills or gradient types */
    if (pSrc->pSourcePict || (pMsk && pMsk->pSourcePict))
	return FALSE;

    /* Keep an eye out for source rotation transforms - those we can
     * do something about */

    exaScratch.rotate = RR_Rotate_0;
    exaScratch.transform = NULL;

    if (pSrc->transform && !lx_process_transform(pSrc))
	return FALSE;

    /* XXX - I don't understand PICT_a8 enough - so I'm punting */

    if ((op != PictOpAdd) && (pSrc->format == PICT_a8 ||
	pDst->format == PICT_a8))
	return FALSE;

    if (pMsk && op != PictOpClear) {
	struct blend_ops_t *opPtr = &lx_alpha_ops[op * 2];
	int direction = (opPtr->channel == CIMGP_CHANNEL_A_SOURCE) ? 0 : 1;

	/* Direction 0 indicates src->dst, 1 indiates dst->src */
	if (((direction == 0) && (pSrc->pDrawable->bitsPerPixel < 16)) ||
	    ((direction == 1) && (pDst->pDrawable->bitsPerPixel < 16))) {
	    ErrorF("Can't do mask blending with less then 16bpp\n");
	    return FALSE;
	}
	/* We can only do masks with a 8bpp or a 4bpp mask */
	if (pMsk->format != PICT_a8 && pMsk->format != PICT_a4)
	    return FALSE;
	/* The pSrc should be 1x1 pixel if the pMsk is not zero */
	if (pSrc->pDrawable->width != 1 || pSrc->pDrawable->height != 1)
	    return FALSE;
	/* FIXME: In lx_prepare_composite, there are no variables to record the
	 * one pixel source's width and height when the mask is not zero.
	 * That will lead to bigger region to render instead of one pixel in lx
	 * _do_composite, so we should fallback currently to avoid this */
	if (!pSrc->repeat)
	    return FALSE;
    }

    /* Get the formats for the source and destination */

    if ((srcFmt = lx_get_format(pSrc)) == NULL) {
	ErrorF("EXA: Invalid source format %x\n", pSrc->format);
	return FALSE;
    }

    if ((dstFmt = lx_get_format(pDst)) == NULL) {
	ErrorF("EXA:  Invalid destination format %x\n", pDst->format);
	return FALSE;
    }

    /* Make sure operations that need alpha bits have them */
    /* If a mask is enabled, the alpha will come from there */

    if (!pMsk && (!srcFmt->alphabits && usesSrcAlpha(op)))
	return FALSE;

    if (!pMsk && (!dstFmt->alphabits && usesDstAlpha(op)))
	return FALSE;

    /* FIXME:  See a way around this! */

    if (srcFmt->alphabits == 0 && dstFmt->alphabits != 0)
	return FALSE;

    /* If this is a rotate operation, then make sure the src and dst
     * formats are the same */

    if (exaScratch.rotate != RR_Rotate_0 && srcFmt != dstFmt) {
	ErrorF("EXA: Can't rotate and convert formats at the same time\n");
	return FALSE;
    }
    return TRUE;
}

static Bool
lx_prepare_composite(int op, PicturePtr pSrc, PicturePtr pMsk,
    PicturePtr pDst, PixmapPtr pxSrc, PixmapPtr pxMsk, PixmapPtr pxDst)
{
    GeodeRec *pGeode = GEODEPTR_FROM_PIXMAP(pxDst);
    const struct exa_format_t *srcFmt, *dstFmt;

    /* Get the formats for the source and destination */

    srcFmt = lx_get_format(pSrc);
    dstFmt = lx_get_format(pDst);

    /* Set up the scratch buffer with the information we need */

    exaScratch.srcFormat = (struct exa_format_t *)srcFmt;
    exaScratch.dstFormat = (struct exa_format_t *)dstFmt;
    exaScratch.op = op;
    exaScratch.repeat = pSrc->repeat;
    exaScratch.bufferOffset = pGeode->exaBfrOffset;

    if (pMsk && op != PictOpClear) {
	/* Get the source color */
	/* If the op is PictOpOver(or PictOpOutReverse, PictOpInReverse,
	 * PictOpIn, PictOpOut, PictOpOverReverse), we should get the
	 * ARGB32 source format */

	if ((op == PictOpOver || op == PictOpOutReverse || op ==
	    PictOpInReverse || op == PictOpIn || op == PictOpOut ||
	    op == PictOpOverReverse) && (srcFmt->alphabits != 0))
	    exaScratch.srcColor = exaGetPixmapFirstPixel(pxSrc);
	else if ((op == PictOpOver || op == PictOpOutReverse || op ==
	    PictOpInReverse || op == PictOpIn || op == PictOpOut ||
	    op == PictOpOverReverse) &&
	    (srcFmt->alphabits == 0))
	    exaScratch.srcColor = lx_get_source_color(pxSrc, pSrc->format,
		PICT_a8r8g8b8);
	else
	    exaScratch.srcColor = lx_get_source_color(pxSrc, pSrc->format,
		pDst->format);

	/* Save off the info we need (reuse the source values to save space) */

	exaScratch.type = COMP_TYPE_MASK;
	exaScratch.maskrepeat = pMsk->repeat;

	exaScratch.srcOffset = exaGetPixmapOffset(pxMsk);
	exaScratch.srcPitch = exaGetPixmapPitch(pxMsk);
	exaScratch.srcBpp = (pxMsk->drawable.bitsPerPixel + 7) / 8;

	exaScratch.srcWidth = pMsk->pDrawable->width;
	exaScratch.srcHeight = pMsk->pDrawable->height;

	/* Flag to indicate if this a 8BPP or a 4BPP mask */
	exaScratch.fourBpp = (pxMsk->drawable.bitsPerPixel == 4) ? 1 : 0;
    } else {
	if (usesPasses(op))
	    exaScratch.type = COMP_TYPE_TWOPASS;
	else if (exaScratch.rotate != RR_Rotate_0)
	    exaScratch.type = COMP_TYPE_ROTATE;
	else
	    exaScratch.type = COMP_TYPE_ONEPASS;

	exaScratch.srcOffset = exaGetPixmapOffset(pxSrc);
	exaScratch.srcPitch = exaGetPixmapPitch(pxSrc);
	exaScratch.srcBpp = (pxSrc->drawable.bitsPerPixel + 7) / 8;

	exaScratch.srcWidth = pSrc->pDrawable->width;
	exaScratch.srcHeight = pSrc->pDrawable->height;
    }

    return TRUE;
}

static int
lx_get_bpp_from_format(int format)
{

    switch (format) {
    case CIMGP_SOURCE_FMT_8_8_8_8:
    case CIMGP_SOURCE_FMT_32BPP_BGR:
	return 32;

    case CIMGP_SOURCE_FMT_4_4_4_4:
	return 12;

    case CIMGP_SOURCE_FMT_0_5_6_5:
    case CIMGP_SOURCE_FMT_16BPP_BGR:
	return 16;

    case CIMGP_SOURCE_FMT_1_5_5_5:
    case CIMGP_SOURCE_FMT_15BPP_BGR:
	return 15;

    case CIMGP_SOURCE_FMT_3_3_2:
	return 8;
    }

    return 0;
}

/* BGR needs to be set in the source for it to take - so adjust the source
 * to enable BGR if the two formats are different, and disable it if they
 * are the same
 */

static void
lx_set_source_format(int srcFormat, int dstFormat)
{
    if (!(srcFormat & 0x10) && (dstFormat & 0x10))
	gp_set_source_format(srcFormat | 0x10);
    else if ((srcFormat & 0x10) && (dstFormat & 0x10))
	gp_set_source_format(srcFormat & ~0x10);
    else
	gp_set_source_format(srcFormat);
}

/* If we are converting colors and we need the channel A alpha,
 * then use a special alpha type that preserves the alpha before
 * converting the format
 */

static inline int
get_op_type(struct exa_format_t *src, struct exa_format_t *dst, int type)
{
    return (type == CIMGP_CHANNEL_A_ALPHA &&
	src->alphabits != dst->alphabits) ? CIMGP_CONVERTED_ALPHA : type;
}

/* Note - this is the preferred onepass method.  The other will remain
 * ifdefed out until such time that we are sure its not needed
 */

#define GetPixmapOffset(px, x, y) ( exaGetPixmapOffset((px)) + \
  (exaGetPixmapPitch((px)) * (y)) + \
  ((((px)->drawable.bitsPerPixel + 7) / 8) * (x)) )

#define GetSrcOffset(_x, _y) (exaScratch.srcOffset + ((_y) * exaScratch.srcPitch) + \
			      ((_x) * exaScratch.srcBpp))

static void
lx_composite_onepass_add_a8(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned long srcOffset, int width, int height, int opX, int opY,
    int srcX, int srcY)
{
    struct blend_ops_t *opPtr;
    int apply, type;
    int optempX, optempY;
    int i, j;
    unsigned long pixmapOffset, pixmapPitch, calBitsPixel;

    pixmapOffset = exaGetPixmapOffset(pxDst);
    pixmapPitch = exaGetPixmapPitch(pxDst);
    calBitsPixel = (pxDst->drawable.bitsPerPixel + 7) / 8;

    /* Keep this GP idle judge here. Otherwise the SW method has chance to
     * conflict with the HW rendering method */
    gp_wait_until_idle();

    if (opX % 4 == 0 && srcX % 4 == 0) {
	/* HW acceleration */
	opPtr = &lx_alpha_ops[exaScratch.op * 2];
	apply = CIMGP_APPLY_BLEND_TO_ALL;
	gp_declare_blt(0);
	gp_set_bpp(32);
	gp_set_strides(exaGetPixmapPitch(pxDst), exaScratch.srcPitch);
	gp_set_source_format(8);
	type = opPtr->type;
	gp_set_alpha_operation(opPtr->operation, type, opPtr->channel, apply, 0);
	gp_screen_to_screen_convert(dstOffset, srcOffset, width / 4, height, 0);
	/* Calculate the pixels in the tail of each line */
	for (j = srcY; j < srcY + height; j++)
	    for (i = srcX + (width / 4) * 4; i < srcX + width; i++) {
		srcOffset = GetSrcOffset(i, j);
		optempX = opX + i - srcX;
		optempY = opY + j - srcY;
		dstOffset = pixmapOffset + pixmapPitch * optempY +
		    calBitsPixel * optempX;
		*(cim_fb_ptr + dstOffset) = (*(cim_fb_ptr + srcOffset)
		    + *(cim_fb_ptr + dstOffset) <= 0xff) ?
		    *(cim_fb_ptr + srcOffset) + *(cim_fb_ptr + dstOffset) : 0xff;
	}
    } else {
	for (j = srcY; j < srcY + height; j++)
	    for (i = srcX; i < srcX + width; i++) {
		srcOffset = GetSrcOffset(i, j);
		optempX = opX + i - srcX;
		optempY = opY + j - srcY;
		dstOffset = pixmapOffset + pixmapPitch * optempY +
		    calBitsPixel * optempX;
		*(cim_fb_ptr + dstOffset) = (*(cim_fb_ptr + srcOffset) +
		    *(cim_fb_ptr + dstOffset) <= 0xff) ?
		    *(cim_fb_ptr + srcOffset) + *(cim_fb_ptr + dstOffset) : 0xff;
	}
    }
}

static void
lx_composite_onepass(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned long srcOffset, int width, int height)
{
    struct blend_ops_t *opPtr;
    int apply, type;

    opPtr = &lx_alpha_ops[exaScratch.op * 2];

    apply = (exaScratch.dstFormat->alphabits != 0 &&
	exaScratch.srcFormat->alphabits != 0) ?
	CIMGP_APPLY_BLEND_TO_ALL : CIMGP_APPLY_BLEND_TO_RGB;

    gp_declare_blt(0);
    gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));
    gp_set_strides(exaGetPixmapPitch(pxDst), exaScratch.srcPitch);

    lx_set_source_format(exaScratch.srcFormat->fmt,
	exaScratch.dstFormat->fmt);

    type =
	get_op_type(exaScratch.srcFormat, exaScratch.dstFormat, opPtr->type);

    gp_set_alpha_operation(opPtr->operation, type, opPtr->channel, apply, 0);

    gp_screen_to_screen_convert(dstOffset, srcOffset, width, height, 0);
}

static void
lx_composite_all_black(unsigned long srcOffset, int width, int height)
{
    struct blend_ops_t *opPtr;
    int apply, type;

    opPtr = &lx_alpha_ops[0];
    apply = (exaScratch.srcFormat->alphabits != 0) ?
	CIMGP_APPLY_BLEND_TO_ALL : CIMGP_APPLY_BLEND_TO_RGB;
    gp_declare_blt(0);
    gp_set_bpp(lx_get_bpp_from_format(exaScratch.srcFormat->fmt));
    gp_set_strides(exaScratch.srcPitch, exaScratch.srcPitch);
    lx_set_source_format(exaScratch.srcFormat->fmt,
	exaScratch.srcFormat->fmt);
    type =
	get_op_type(exaScratch.srcFormat, exaScratch.srcFormat, opPtr->type);
    gp_set_alpha_operation(opPtr->operation, type, opPtr->channel, apply, 0);
    gp_screen_to_screen_convert(srcOffset, srcOffset, width, height, 0);

}

static void
lx_composite_onepass_special(PixmapPtr pxDst, int width, int height, int opX,
    int opY, int srcX, int srcY)
{
    struct blend_ops_t *opPtr;
    int apply, type;
    int opWidth, opHeight;
    int optempX, optempY;
    unsigned int dstOffset, srcOffset = 0;

    optempX = opX;
    optempY = opY;

    /* Make sure srcX and srcY are in source region */
    srcX = ((srcX % (int)exaScratch.srcWidth) + (int)exaScratch.srcWidth)
	% (int)exaScratch.srcWidth;
    srcY = ((srcY % (int)exaScratch.srcHeight) + (int)exaScratch.srcHeight)
	% (int)exaScratch.srcHeight;

    opWidth = exaScratch.srcWidth - srcX;
    opHeight = exaScratch.srcHeight -  srcY;

    srcOffset = GetSrcOffset(srcX, srcY);

    if (width < opWidth)
	opWidth = width;
    if (height < opHeight)
	opHeight = height;

    while (1) {
	gp_wait_until_idle();
	dstOffset = GetPixmapOffset(pxDst, optempX, optempY);
	opPtr = &lx_alpha_ops[exaScratch.op * 2];
	apply = (exaScratch.dstFormat->alphabits != 0 &&
	    exaScratch.srcFormat->alphabits != 0) ?
	    CIMGP_APPLY_BLEND_TO_ALL : CIMGP_APPLY_BLEND_TO_RGB;
	gp_declare_blt(0);
	gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));
	gp_set_strides(exaGetPixmapPitch(pxDst), exaScratch.srcPitch);
	lx_set_source_format(exaScratch.srcFormat->fmt,
	    exaScratch.dstFormat->fmt);
	type = get_op_type(exaScratch.srcFormat, exaScratch.dstFormat,
	    opPtr->type);
	gp_set_alpha_operation(opPtr->operation, type, opPtr->channel,
	    apply, 0);
	gp_screen_to_screen_convert(dstOffset, srcOffset, opWidth, opHeight, 0);

	optempX += opWidth;
	if (optempX >= opX + width) {
	    optempX = opX;
	    optempY += opHeight;
	    if (optempY >= opY + height)
		break;
	}
	if (optempX == opX) {
	    srcOffset = GetSrcOffset(srcX, 0);
	    opWidth = ((opX + width) - optempX) > (exaScratch.srcWidth - srcX)
		? (exaScratch.srcWidth - srcX) : ((opX + width) - optempX);
	    opHeight = ((opY + height) - optempY) > exaScratch.srcHeight
		? exaScratch.srcHeight : ((opY + height) - optempY);
	} else if (optempY == opY) {
	    srcOffset = GetSrcOffset(0, srcY);
	    opWidth = ((opX + width) - optempX) > exaScratch.srcWidth
		? exaScratch.srcWidth : ((opX + width) - optempX);
	    opHeight = ((opY + height) - optempY) > (exaScratch.srcHeight -
		srcY) ? (exaScratch.srcHeight - srcY) : ((opY + height) - optempY);
	} else {
	    srcOffset = GetSrcOffset(0, 0);
	    opWidth = ((opX + width) - optempX) > exaScratch.srcWidth
		? exaScratch.srcWidth : ((opX + width) - optempX);
	    opHeight = ((opY + height) - optempY) > exaScratch.srcHeight
		? exaScratch.srcHeight : ((opY + height) - optempY);
	}
    }
}

/* This function handles the multipass blend functions */

static void
lx_composite_multipass(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned long srcOffset, int width, int height)
{
    struct blend_ops_t *opPtr;
    int sbpp = lx_get_bpp_from_format(exaScratch.srcFormat->fmt);
    int apply, type;

    /* Wait until the GP is idle - this will ensure that the scratch buffer
     * isn't occupied */

    gp_wait_until_idle();

    /* Copy the destination to the scratch buffer, and convert it to the
     * source format */

    gp_declare_blt(0);

    gp_set_bpp(sbpp);
    gp_set_source_format(exaScratch.dstFormat->fmt);
    gp_set_raster_operation(0xCC);
    gp_set_strides(exaScratch.srcPitch, exaGetPixmapPitch(pxDst));
    gp_screen_to_screen_convert(exaScratch.bufferOffset, dstOffset,
	width, height, 0);

    /* Do the first blend from the source to the scratch buffer */

    gp_declare_blt(CIMGP_BLTFLAGS_HAZARD);
    gp_set_bpp(sbpp);
    gp_set_source_format(exaScratch.srcFormat->fmt);
    gp_set_strides(exaScratch.srcPitch, exaScratch.srcPitch);

    opPtr = &lx_alpha_ops[exaScratch.op * 2];

    apply = (exaScratch.srcFormat->alphabits == 0) ?
	CIMGP_APPLY_BLEND_TO_RGB : CIMGP_APPLY_BLEND_TO_ALL;

    /* If we're destroying the source alpha bits, then make sure we
     * use the alpha before the color conversion
     */

    gp_screen_to_screen_blt(exaScratch.bufferOffset, srcOffset, width, height,
	0);

    /* Finally, do the second blend back to the destination */

    opPtr = &lx_alpha_ops[(exaScratch.op * 2) + 1];

    apply = (exaScratch.dstFormat->alphabits == 0) ?
	CIMGP_APPLY_BLEND_TO_RGB : CIMGP_APPLY_BLEND_TO_ALL;

    gp_declare_blt(CIMGP_BLTFLAGS_HAZARD);
    gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));

    lx_set_source_format(exaScratch.srcFormat->fmt,
	exaScratch.dstFormat->fmt);

    type =
	get_op_type(exaScratch.srcFormat, exaScratch.dstFormat, opPtr->type);

    gp_set_alpha_operation(opPtr->operation, type, opPtr->channel, apply, 0);

    gp_screen_to_screen_convert(dstOffset, exaScratch.bufferOffset,
	width, height, 0);
}

static void
lx_composite_rotate(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned int srcOffset, int width, int height)
{
    int degrees = 0;

    gp_declare_blt(0);
    gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));
    gp_set_strides(exaGetPixmapPitch(pxDst), exaScratch.srcPitch);

    lx_set_source_format(exaScratch.srcFormat->fmt,
	exaScratch.dstFormat->fmt);

    gp_set_raster_operation(0xCC);

    /* RandR rotation is counter-clockwise, our rotation
     * is clockwise, so adjust the numbers accordingly */

    switch (exaScratch.rotate) {
    case RR_Rotate_90:
	degrees = 270;
	break;
    case RR_Rotate_180:
	degrees = 180;
	break;
    case RR_Rotate_270:
	degrees = 90;
	break;
    }

    gp_rotate_blt(dstOffset, srcOffset, width, height, degrees);
}

static void
lx_do_composite_mask(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned int maskOffset, int width, int height)
{
    struct blend_ops_t *opPtr = &lx_alpha_ops[exaScratch.op * 2];

    gp_declare_blt(0);

    gp_set_source_format(exaScratch.srcFormat->fmt);
    gp_set_strides(exaGetPixmapPitch(pxDst), exaScratch.srcPitch);
    gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));
    gp_set_solid_source(exaScratch.srcColor);

    gp_blend_mask_blt(dstOffset, 0, width, height, maskOffset,
	exaScratch.srcPitch, opPtr->operation, exaScratch.fourBpp);
}

static void
lx_do_composite_mask_two_pass(PixmapPtr pxDst, unsigned long dstOffset,
    unsigned int maskOffset, int width, int height, int opX, int opY,
    xPointFixed srcPoint)
{
    int apply, type;
    struct blend_ops_t *opPtr;
    int opWidth, opHeight;
    int opoverX, opoverY;

    opoverX = opX;
    opoverY = opY;

    /* The rendering region should not be bigger than off-screen memory size
     * which equals to DEFAULT_EXA_SCRATCH_BFRSZ. If that happens, we split
     * the PictOpOver rendering region into several 256KB chunks. And because
     * of the Pitch(stride) parameter, so we use maximun width of mask picture.
     * that is to say it is a scanline rendering process */
    if (width * height * 4 > DEFAULT_EXA_SCRATCH_BFRSZ) {
	opWidth = width;
	opHeight = DEFAULT_EXA_SCRATCH_BFRSZ / (width * 4);
    } else {
	opWidth = width;
	opHeight = height;
    }

    while (1) {

	/* Wait until the GP is idle - this will ensure that the scratch buffer
	 * isn't occupied */

	gp_wait_until_idle();

	/* Copy the source to the scratch buffer, and do a src * mask raster
	 * operation */

	gp_declare_blt(0);
	opPtr = &lx_alpha_ops[(exaScratch.op * 2) + 1];
	gp_set_source_format(CIMGP_SOURCE_FMT_8_8_8_8);
	gp_set_strides(opWidth * 4, exaScratch.srcPitch);
	gp_set_bpp(lx_get_bpp_from_format(CIMGP_SOURCE_FMT_8_8_8_8));
	gp_set_solid_source(exaScratch.srcColor);
	gp_blend_mask_blt(exaScratch.bufferOffset, 0, opWidth, opHeight,
	    maskOffset, exaScratch.srcPitch, opPtr->operation,
	    exaScratch.fourBpp);

	/* Do a relative operation(refer rendercheck ops.c), and copy the
	 * operation result to destination */

	gp_declare_blt(CIMGP_BLTFLAGS_HAZARD);
	opPtr = &lx_alpha_ops[exaScratch.op * 2];
	apply = (exaScratch.dstFormat->alphabits == 0) ?
	    CIMGP_APPLY_BLEND_TO_RGB : CIMGP_APPLY_BLEND_TO_ALL;
	gp_set_source_format(CIMGP_SOURCE_FMT_8_8_8_8);
	gp_set_strides(exaGetPixmapPitch(pxDst), opWidth * 4);
	gp_set_bpp(lx_get_bpp_from_format(exaScratch.dstFormat->fmt));
	type = CIMGP_CONVERTED_ALPHA;
	gp_set_alpha_operation(opPtr->operation, type, opPtr->channel,
	    apply, 0);
	gp_screen_to_screen_convert(dstOffset, exaScratch.bufferOffset,
	    opWidth, opHeight, 0);

	if (width * height * 4 > DEFAULT_EXA_SCRATCH_BFRSZ) {
	    /* Finish the rendering */
	    if (opoverY + opHeight == opY + height)
		break;
	    /* Recalculate the Dest and Mask rendering start point */
	    srcPoint.y = srcPoint.y + F(opHeight);
	    opoverY = opoverY + opHeight;
	    if (opoverY + opHeight > opY + height)
		opHeight = opY + height - opoverY;
	    dstOffset = GetPixmapOffset(pxDst, opoverX, opoverY);
	    maskOffset = GetSrcOffset(I(srcPoint.x), I(srcPoint.y));
	} else
	    break;
    }
}

static void
transformPoint(PictTransform * t, xPointFixed * point)
{
    PictVector v;

    v.vector[0] = point->x;
    v.vector[1] = point->y;
    v.vector[2] = xFixed1;

    if (t != NULL)
	PictureTransformPoint(t, &v);

    point->x = v.vector[0];
    point->y = v.vector[1];
}

static void
lx_do_composite(PixmapPtr pxDst, int srcX, int srcY, int maskX,
    int maskY, int dstX, int dstY, int width, int height)
{
    unsigned int dstOffset, srcOffset = 0;

    xPointFixed srcPoint;

    int opX = dstX;
    int opY = dstY;
    int opWidth = width;
    int opHeight = height;

    /* Transform the source coordinates */

    if (exaScratch.type == COMP_TYPE_MASK) {
	srcPoint.x = F(maskX);
	srcPoint.y = F(maskY);
    } else {
	srcPoint.x = F(srcX);
	srcPoint.y = F(srcY);
    }

    /* srcX, srcY point to the upper right side of the bounding box
     * in the unrotated coordinate space.  Depending on the orientation,
     * we have to translate the coordinates to point to the origin of
     * the rectangle in the source pixmap */

    switch (exaScratch.rotate) {
    case RR_Rotate_270:
	srcPoint.x += F(width);

	opWidth = height;
	opHeight = width;
	break;

    case RR_Rotate_180:
	srcPoint.x += F(width);
	srcPoint.y += F(height);

	srcX += width;
	srcY += height;
	break;

    case RR_Rotate_90:
	srcPoint.y += F(height);

	opWidth = height;
	opHeight = width;
	break;
    }

    transformPoint(exaScratch.transform, &srcPoint);

    /* Adjust the point to fit into the pixmap */

    if (I(srcPoint.x) < 0) {
	opWidth += I(srcPoint.x);
	srcPoint.x = F(0);
    }

    if (I(srcPoint.y) < 0) {
	opHeight += I(srcPoint.y);
	srcPoint.y = F(0);
    }

    /* Get the source point offset position */

    srcOffset = GetSrcOffset(I(srcPoint.x), I(srcPoint.y));

    /* When mask exists, exaScratch.srcWidth and exaScratch.srcHeight are
     * the source width and source height; Otherwise, they are mask width
     * and mask height */
    /* exaScratch.repeat is the source repeat attribute
     * exaScratch.maskrepeat is the mask repeat attribute */
    /* If type is COMP_TYPE_MASK, maskX and maskY are not zero, we should
     * subtract them to do the operation in the correct region */

    /* FIXME:  Please add the code to handle the condition when the maskX
     * and maskY coordinate are negative or greater than
     * exaScratch.srcWidth and exaScratch.srcHeight */

    if (exaScratch.type == COMP_TYPE_MASK) {
	if ((exaScratch.srcWidth - maskX) < opWidth)
	    opWidth = exaScratch.srcWidth - maskX;
	if ((exaScratch.srcHeight - maskY) < opHeight)
	    opHeight = exaScratch.srcHeight - maskY;
    } else {
	if (exaScratch.type == COMP_TYPE_ONEPASS) {
	    /* This is the condition srcX or/and srcY is/are out of source
	     * region */
	    if (((srcX >= 0 && srcY >= exaScratch.srcHeight)
		|| (srcX >= exaScratch.srcWidth  && srcY >= 0)) &&
		(exaScratch.op == PictOpOver || exaScratch.op == PictOpSrc)) {
		if (exaScratch.repeat == 1) {
		    opWidth = width;
		    opHeight = height;
		} else {
		    if (exaScratch.op == PictOpOver)
			return ;
		    else {
			exaScratch.op = PictOpClear;
			opWidth = width;
			opHeight = height;
		    }
		}
	    /* This is the condition srcX or/and srcY is/are in the source
	     * region */
	    } else if (srcX >= 0 && srcY >= 0 &&
		(exaScratch.op == PictOpOver || exaScratch.op == PictOpSrc)) {
		if (exaScratch.repeat == 1) {
		    opWidth = width;
		    opHeight = height;
		} else {
		    if ((exaScratch.srcWidth - srcX) < opWidth)
			opWidth = exaScratch.srcWidth - srcX;
		    if ((exaScratch.srcHeight - srcY) < opHeight)
			opHeight = exaScratch.srcHeight - srcY;
		}
	    /* This is the condition srcX or/and srcY is/are negative */
	    } else if ((srcX < 0 || srcY < 0) &&
		(exaScratch.op == PictOpOver || exaScratch.op == PictOpSrc)) {
		if (exaScratch.repeat == 1) {
		    opWidth = width;
		    opHeight = height;
		} else {
		/* Have not met this condition till now */
		    return ;
		}
	    } else {
		if (exaScratch.srcWidth < opWidth)
		    opWidth = exaScratch.srcWidth;
		if (exaScratch.srcHeight < opHeight)
		    opHeight = exaScratch.srcHeight;
	    }
	} else {
	    if (exaScratch.rotate == RR_Rotate_180) {
	    } else {
		if ((exaScratch.srcWidth - srcY) < opWidth)
		    opWidth = exaScratch.srcWidth - srcY;
		if ((exaScratch.srcHeight - srcX) < opHeight)
		    opHeight = exaScratch.srcHeight - srcX;
	    }
	}
    }

    while (1) {

	dstOffset = GetPixmapOffset(pxDst, opX, opY);

	switch (exaScratch.type) {

	case COMP_TYPE_MASK:{
	    if (exaScratch.op == PictOpOver || exaScratch.op ==
		PictOpOutReverse || exaScratch.op == PictOpInReverse ||
		exaScratch.op == PictOpIn || exaScratch.op == PictOpOut ||
		exaScratch.op == PictOpOverReverse)
		lx_do_composite_mask_two_pass(pxDst, dstOffset,
		    srcOffset, opWidth, opHeight, opX, opY, srcPoint);
	    else
		lx_do_composite_mask(pxDst, dstOffset, srcOffset,
		    opWidth, opHeight);
	    }
	    break;

	case COMP_TYPE_ONEPASS:
	    if ((exaScratch.op == PictOpOver || exaScratch.op == PictOpSrc)
		&& (exaScratch.repeat == 1)) {
		lx_composite_onepass_special(pxDst, opWidth, opHeight, opX, opY,
		    srcX, srcY);
		return ;
	    } else if ((exaScratch.op == PictOpAdd) && (exaScratch.srcFormat->exa
		== PICT_a8) && (exaScratch.dstFormat->exa == PICT_a8))
		lx_composite_onepass_add_a8(pxDst, dstOffset, srcOffset,
		    opWidth, opHeight, opX, opY, srcX, srcY);
	    else
		lx_composite_onepass(pxDst, dstOffset, srcOffset, opWidth,
		    opHeight);
	    break;

	case COMP_TYPE_TWOPASS:
	    lx_composite_multipass(pxDst, dstOffset, srcOffset, opWidth,
		opHeight);

	case COMP_TYPE_ROTATE:
	    lx_composite_rotate(pxDst, dstOffset, srcOffset, opWidth,
		opHeight);
	    break;
	}

	opX += opWidth;

	if (opX >= dstX + width) {
	    opX = dstX;
	    opY += opHeight;

	    if (opY >= dstY + height)
		break;
	}

	/* FIXME:  Please add the code to handle the condition when the maskX
	 * and maskY coordinate are negative or greater than
	 * exaScratch.srcWidth and exaScratch.srcHeight */

	if (exaScratch.type == COMP_TYPE_MASK) {
	    opWidth = ((dstX + width) - opX) > (exaScratch.srcWidth - maskX)
		? (exaScratch.srcWidth - maskX) : (dstX + width) - opX;
	    opHeight = ((dstY + height) - opY) > (exaScratch.srcHeight - maskY)
		? (exaScratch.srcHeight - maskY) : (dstY + height) - opY;
	    /* All black out of the mask */
	    if (!exaScratch.maskrepeat)
		exaScratch.srcColor = 0x0;
	} else {
	    if (exaScratch.type == COMP_TYPE_ONEPASS) {
		if (srcX >= 0 && srcY >= 0 && (exaScratch.op == PictOpOver ||
		    exaScratch.op == PictOpSrc || exaScratch.op ==
		    PictOpClear)) {
		    opWidth = ((dstX + width) - opX) > (exaScratch.srcWidth -
			srcX) ? (exaScratch.srcWidth - srcX) : (dstX + width)
			- opX;
		    opHeight = ((dstY + height) - opY) >
		    (exaScratch.srcHeight - srcY) ?
		    (exaScratch.srcHeight - srcY) : (dstY + height) - opY;
		} else {
		opWidth = ((dstX + width) - opX) > exaScratch.srcWidth ?
		    exaScratch.srcWidth : (dstX + width) - opX;
		opHeight = ((dstY + height) - opY) > exaScratch.srcHeight ?
		    exaScratch.srcHeight : (dstY + height) - opY;
		}
	    } else {
		opWidth = ((dstX + width) - opX) > (exaScratch.srcWidth - srcY)
		    ? (exaScratch.srcWidth - srcY) : (dstX + width) - opX;
		opHeight = ((dstY + height) - opY) > (exaScratch.srcHeight - srcX
		    ) ? (exaScratch.srcHeight - srcX) : (dstY + height) - opY;
	    }
	    /* All black out of the source */
	    if (!exaScratch.repeat && (exaScratch.type == COMP_TYPE_ONEPASS)) {
		    lx_composite_all_black(srcOffset, exaScratch.srcWidth,
			exaScratch.srcHeight);
	    }
	    if (!exaScratch.repeat && (exaScratch.type == COMP_TYPE_ROTATE))
		    break;
	}
    }
}

static void
lx_wait_marker(ScreenPtr PScreen, int marker)
{
    gp_wait_until_idle();
}

static void
lx_done(PixmapPtr ptr)
{
}

#if 0
static void
lx_upload_to_screen(PixmapPtr pxDst, int x, int y, int w, int h,
    char *src, int src_pitch)
{
    GeodeRec *pGeode = GEODEPTR_FROM_PIXMAP(pxDst);
    int dst_pitch = exaGetPixmapPitch(pxDst);
    int cpp = (pxDst->drawable.bitsPerPixel + 7) / 8;

    char *dst;
    int offset = exaGetPixmapOffset(pxDst);

    dst = (char *)(pGeode->FBBase + offset + (y * dst_pitch) + (x * cpp));
    int i;

    for (i = 0; i < h; i++) {
	memcpy(dst, src, w * cpp);
	dst += dst_pitch;
	src += src_pitch;
    }
}
#endif

#if EXA_VERSION_MINOR >= 2

static Bool
lx_exa_pixmap_is_offscreen(PixmapPtr pPixmap)
{
    ScrnInfoPtr pScrni = xf86Screens[pPixmap->drawable.pScreen->myNum];
    GeodeRec *pGeode = GEODEPTR(pScrni);
    void *start = (void *)(pGeode->FBBase);
    void *end =
	(void *)(pGeode->FBBase + pGeode->offscreenStart +
	pGeode->offscreenSize);

    if ((void *)pPixmap->devPrivate.ptr >= start &&
	(void *)pPixmap->devPrivate.ptr < end)
	return TRUE;

    return FALSE;
}

#endif

Bool
LXExaInit(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrni = xf86Screens[pScreen->myNum];
    GeodeRec *pGeode = GEODEPTR(pScrni);
    ExaDriverPtr pExa = pGeode->pExa;

    pExa->exa_major = EXA_VERSION_MAJOR;
    pExa->exa_minor = EXA_VERSION_MINOR;

    pExa->WaitMarker = lx_wait_marker;

    pExa->PrepareSolid = lx_prepare_solid;
    pExa->Solid = lx_do_solid;
    pExa->DoneSolid = lx_done;

    pExa->PrepareCopy = lx_prepare_copy;
    pExa->Copy = lx_do_copy;
    pExa->DoneCopy = lx_done;

    /* Composite */
    pExa->CheckComposite = lx_check_composite;
    pExa->PrepareComposite = lx_prepare_composite;
    pExa->Composite = lx_do_composite;
    pExa->DoneComposite = lx_done;
    //pExa->UploadToScreen =  lx_upload_to_screen;

#if EXA_VERSION_MINOR >= 2
    pExa->PixmapIsOffscreen = lx_exa_pixmap_is_offscreen;
#endif

    //pExa->flags = EXA_OFFSCREEN_PIXMAPS;

    return exaDriverInit(pScreen, pGeode->pExa);
}