xserver-multidpi/hw/xgl/xglcomp.c

/*
 * Copyright © 2004 David Reveman
 * 
 * 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
 * David Reveman not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior permission.
 * David Reveman makes no representations about the suitability of this
 * software for any purpose. It is provided "as is" without express or
 * implied warranty.
 *
 * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
 * NO EVENT SHALL DAVID REVEMAN 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.
 *
 * Author: David Reveman <davidr@novell.com>
 */

#include "xgl.h"

#ifdef RENDER

static glitz_operator_t xglOperators[] = {
    GLITZ_OPERATOR_CLEAR,
    GLITZ_OPERATOR_SRC,
    GLITZ_OPERATOR_DST,
    GLITZ_OPERATOR_OVER,
    GLITZ_OPERATOR_OVER_REVERSE,
    GLITZ_OPERATOR_IN,
    GLITZ_OPERATOR_IN_REVERSE,
    GLITZ_OPERATOR_OUT,
    GLITZ_OPERATOR_OUT_REVERSE,
    GLITZ_OPERATOR_ATOP,
    GLITZ_OPERATOR_ATOP_REVERSE,
    GLITZ_OPERATOR_XOR,
    GLITZ_OPERATOR_ADD
};

#define NUM_XGL_OPERATORS			       \
    (sizeof (xglOperators) / sizeof (xglOperators[0]))

#define XGL_OPERATOR(op) (xglOperators[op])

Bool
xglComp (CARD8		 op,
	 PicturePtr	 pSrc,
	 PicturePtr	 pMask,
	 PicturePtr	 pDst,
	 INT16		 xSrc,
	 INT16		 ySrc,
	 INT16		 xMask,
	 INT16		 yMask,
	 INT16		 xDst,
	 INT16		 yDst,
	 CARD16		 width,
	 CARD16		 height,
	 xglGeometryPtr  pGeometry,
	 glitz_surface_t *mask)
{
    ScreenPtr	    pScreen = pDst->pDrawable->pScreen;
    xglPixmapPtr    pSrcPriv;
    glitz_surface_t *src, *dst;
    int		    dstXoff, dstYoff;
    RegionRec	    region;
    BoxPtr	    pBox;
    int		    nBox;
    
    if (pDst->alphaMap)
	return FALSE;

    if (op >= NUM_XGL_OPERATORS)
	return FALSE;

    if (pSrc->pDrawable->type != DRAWABLE_PIXMAP)
	return FALSE;

    if (pSrc->pDrawable->bitsPerPixel == 1)
	return FALSE;

    if (pMask)
    {
	if (pMask->pDrawable->type != DRAWABLE_PIXMAP)
	    return FALSE;

	if (pSrc->pDrawable == pMask->pDrawable && pSrc != pMask)
	    return FALSE;
    }

    if (!miComputeCompositeRegion (&region, pSrc, pMask, pDst,
				   xSrc, ySrc, xMask, yMask,
				   xDst, yDst, width, height))
	return TRUE;

    pBox = REGION_RECTS (&region);
    nBox = REGION_NUM_RECTS (&region);

    if (!xglPrepareTarget (pDst->pDrawable))
    {
	REGION_UNINIT (pScreen, &region);
	return FALSE;
    }

    XGL_GET_DRAWABLE (pDst->pDrawable, dst, dstXoff, dstYoff);
    
    if (!xglSyncSurface (pSrc->pDrawable))
    {
	REGION_UNINIT (pScreen, &region);
	return FALSE;
    }
    
    pSrcPriv = XGL_GET_PIXMAP_PRIV ((PixmapPtr) pSrc->pDrawable);
    if (XGL_PICTURE_CHANGES (pSrcPriv->pictureMask))
	xglUpdatePicture (pSrc);

    src = pSrcPriv->surface;

    if (pMask)
    {
	xglPixmapPtr pMaskPriv;

	/* bitmap as mask */
	if (pMask->pDrawable->bitsPerPixel == 1)
	{
	    if (pGeometry)
	    {
		REGION_UNINIT (pScreen, &region);
		return FALSE;
	    }

	    pGeometry =
		xglPixmapToGeometry ((PixmapPtr) pMask->pDrawable,
				     xDst - xMask,
				     yDst - yMask);
	    if (!pGeometry)
	    {
		REGION_UNINIT (pScreen, &region);
		return FALSE;
	    }
	}
	else
	{
	    if (!xglSyncSurface (pMask->pDrawable))
	    {
		REGION_UNINIT (pScreen, &region);
		return FALSE;
	    }

	    pMaskPriv = XGL_GET_PIXMAP_PRIV ((PixmapPtr) pMask->pDrawable);
	    if (XGL_PICTURE_CHANGES (pMaskPriv->pictureMask))
		xglUpdatePicture (pMask);
		
	    mask = pMaskPriv->surface;
	}
    }

    if (!pGeometry)
    {
	if (!pSrc->transform && pSrc->filter != PictFilterConvolution)
	{
	    if (pSrc->repeat)
	    {
		/* tile */
		if (!pSrcPriv->acceleratedTile)
		{
		    pGeometry =
			xglTiledBoxGeometry ((PixmapPtr) pSrc->pDrawable,
					     xSrc - xDst, ySrc - yDst,
					     pBox, nBox);
		    if (!pGeometry)
		    {
			REGION_UNINIT (pScreen, &region);
			return FALSE;
		    }
		    
		    pBox = REGION_EXTENTS (pScreen, &region);
		    nBox = 1;
		}
	    }
	    else
	    {
		/* copy */
		if (op == PictOpSrc && !mask)
		{
		    if (xglCopy (pSrc->pDrawable,
				 pDst->pDrawable,
				 xSrc - xDst,
				 ySrc - yDst,
				 pBox,
				 nBox))
		    {
			REGION_UNINIT (pScreen, &region);
			return TRUE;
		    }
		}
	    }
	}

	if (nBox > 1)
	{
	    pGeometry = xglGetScratchVertexGeometry (pScreen, 4 * nBox);
	    
	    GEOMETRY_ADD_BOX (pScreen, pGeometry, pBox, nBox);
	    
	    pBox = REGION_EXTENTS (pScreen, &region);
	}

	xSrc += pBox->x1 - xDst;
	ySrc += pBox->y1 - yDst;

	if (pMask)
	{
	    xMask += pBox->x1 - xDst;
	    yMask += pBox->y1 - yDst;
	}
	
	xDst = pBox->x1;
	yDst = pBox->y1;
	
	width  = pBox->x2 - pBox->x1;
	height = pBox->y2 - pBox->y1;
    }
    else
    {
	glitz_surface_set_clip_region (dst,
				       dstXoff, dstYoff,
				       (glitz_box_t *) pBox, nBox);
    }

    if (pGeometry)
    {
	GEOMETRY_TRANSLATE (pGeometry, dstXoff, dstYoff);

	if (!GEOMETRY_ENABLE (pGeometry, dst))
	{
	    REGION_UNINIT (pScreen, &region);	
	    return FALSE;
	}
    } else
	GEOMETRY_DISABLE (dst);

    glitz_composite (XGL_OPERATOR (op),
		     src, mask, dst,
		     xSrc, ySrc,
		     xMask, yMask,
		     xDst + dstXoff, yDst + dstYoff,
		     width, height);

    glitz_surface_set_clip_region (dst, 0, 0, NULL, 0);

    REGION_UNINIT (pScreen, &region);
    
    if (glitz_surface_get_status (dst))
	return FALSE;
    
    return TRUE;
}

#endif