opc.temp.h

#ifndef OPC_H
#include "opc.h"
#endif

#ifndef PIXEL
#error 'PIXEL' must be defined.  It specifies the pixel format (i.e. uint8, uint16, uint32).
#endif

#ifndef OPC_DIRTY

/*#define OPC_DIRTY(rect) */
#endif

#ifndef OPC_PTR

#define OPC_PTR( opc, x,y )                 ((OPC_NAMING(Pixel)*)((opc)->origin + ((y)*(opc)->pitch)) + (x))
#endif

#ifndef OPC_COPY

#define OPC_COPY_PIXEL(dst,src)             {(dst)=(src);}
#endif

#ifndef OPC_HLINE

#define HLINE_GENERIC(dst,color,width) \
{ \
    register OPC_NAMING(Pixel)* hlpdst = (OPC_NAMING(Pixel)*)(dst); \
    register OPC_NAMING(Pixel) hcpixel = (OPC_NAMING(Pixel))(color); \
    ppDuff( 16, (int)(width), *hlpdst++ = hcpixel );\
}
#define OPC_HLINE(dst,color,width)  ppConcat( HLINE_FOR_ , PIXEL )(dst,color,width)
#define HLINE_FOR_int8      memset
#define HLINE_FOR_uint8     memset
#define HLINE_FOR_int16     HLINE_GENERIC
#define HLINE_FOR_uint16    HLINE_GENERIC
#define HLINE_FOR_int32     HLINE_GENERIC
#define HLINE_FOR_uint32    HLINE_GENERIC
#define HLINE_FOR_int64     HLINE_GENERIC
#define HLINE_FOR_uint64    HLINE_GENERIC
#define HLINE_FOR_float32   HLINE_GENERIC
#define HLINE_FOR_float64   HLINE_GENERIC
#endif

#ifndef OPC_HCOPY

#define HCOPY_GENERIC(dst,src,width) \
{ \
    register OPC_NAMING(Pixel)* hcpdst = (OPC_NAMING(Pixel)*)(dst); \
    register const OPC_NAMING(Pixel)* hcpsrc = (const OPC_NAMING(Pixel)*)(src); \
    ppDuff( 16, (int)(width), *hcpdst++ = *hcpsrc++ );\
}
#define OPC_HCOPY(dst,src,width)    ppConcat( HCOPY_FOR_ , PIXEL )(dst,src,width)
#define HCOPY_FOR_int8      memcpy
#define HCOPY_FOR_uint8     memcpy
#define HCOPY_FOR_int16(dst,src,width)  memcpy(dst,src,(width)<<1)
#define HCOPY_FOR_uint16(dst,src,width) memcpy(dst,src,(width)<<1)
#define HCOPY_FOR_int32     HCOPY_GENERIC
#define HCOPY_FOR_uint32    HCOPY_GENERIC
#define HCOPY_FOR_int64     HCOPY_GENERIC
#define HCOPY_FOR_uint64    HCOPY_GENERIC
#define HCOPY_FOR_float32   HCOPY_GENERIC
#define HCOPY_FOR_float64   HCOPY_GENERIC
#endif

/* Default masking color */
static OPC_NAMING(Pixel) OPC_NAMING(maskcolor) = 0;

size_t OPC_NAMING(Needs)( int wide, int high )
{
    return (((wide*sizeof(OPC_NAMING(Pixel))) + sizeof(int) - 1) / sizeof(int) * sizeof(int)) * high;
}

void OPC_NAMING(Init)( OPC* opc, int xOff, int yOff, const Rect* clip, void* buffer )
{
    opc->clip = *clip;
    opc->pitch = ((RectWide(*clip)*sizeof(OPC_NAMING(Pixel))) + sizeof(int)-1) / sizeof(int) * sizeof(int);
    opc->origin = ((uint8*)buffer + (opc->pitch*yOff)) + (sizeof(PIXEL)*xOff);
}

void OPC_NAMING(Clip)( OPC* opc, const OPC* src, const Rect* clip )
{
    *opc = *src;
    if( clip )
        RectIntRect(opc->clip,*clip);
}


void OPC_NAMING(Window)( OPC* opc, const OPC* src, const Rect* clip, int orgX, int orgY )
{
    *opc = *src;
    RectIntRect(opc->clip,*clip);
    opc->origin = (uint8*)OPC_PTR( opc, orgX, orgY );
    RectMoveBy( opc->clip, -orgX, -orgY );
}

OPC_NAMING(Pixel)* OPC_NAMING(Ptr)( const OPC* dst, int x, int y )
{
    return OPC_PTR(dst,x,y);
}

void OPC_NAMING(Plot)( const OPC* dst, int x, int y, OPC_NAMING(Pixel) color )
{ 
    if( RectPtInRect(dst->clip,x,y) )
        OPC_COPY_PIXEL(*OPC_PTR( dst, x,y ),color);
}

OPC_NAMING(Pixel) OPC_NAMING(Peek)( const OPC* dst, int x, int y )
{ 
    if( RectPtInRect(dst->clip,x,y) ) 
        return *OPC_PTR( dst, x,y );
    return 0;
}

void OPC_NAMING(HLine)( const OPC* dst, int x, int y, int wide, OPC_NAMING(Pixel) color )
{
    if( y < dst->clip.top || y >= dst->clip.bottom )
        return;
    if( x < dst->clip.left )
    {
        wide -= dst->clip.left - x;
        x = dst->clip.left;
    }
    if( x + wide > dst->clip.right )
    {
        wide = dst->clip.right - x;
    }
    if( wide > 0 )
    {
        OPC_HLINE(OPC_PTR( dst, x, y ),color,wide);
    }
}

void OPC_NAMING(VLine)( const OPC* dst, int x, int y, int high, OPC_NAMING(Pixel) color )
{
    if( x < dst->clip.left || x >= dst->clip.right )
        return;
    if( y < dst->clip.top )
    {
        high -= dst->clip.top - y;
        y = dst->clip.top;
    }
    if( y + high > dst->clip.bottom )
    {
        high = dst->clip.bottom - y;
    }
    if( high > 0 )
    {
        OPC_NAMING(Pixel)* pdst = OPC_PTR( dst, x, y );
        int remain = high;
        int offset = dst->pitch;
        while( remain-- )
        {
            OPC_COPY_PIXEL(*pdst,color);
            pdst = (OPC_NAMING(Pixel)*)((uint8*)pdst + offset);
        }
    }
}

void OPC_NAMING(HCopy)( const OPC* dst, int x, int y, int wide, const OPC_NAMING(Pixel)* src )
{
    if( y < dst->clip.top || y >= dst->clip.bottom )
        return;
    if( x < dst->clip.left )
    {
        int offset = dst->clip.left - x;
        wide -= offset;
        src += offset;
        x = dst->clip.left;
    }
    if( x + wide > dst->clip.right )
    {
        wide = dst->clip.right - x;
    }
    if( wide > 0 )
    {
        OPC_HCOPY(OPC_PTR( dst, x, y ),src,wide);
    }
}

#if 0
/*
 * Non-compressed runs
 */
size_t  NONE_Reserve( size_t len );
size_t  NONE_Pack( const PIXEL* pdstBase, PIXEL* pdst, PIXEL* psrc, size_t len );
void    NONE_Unpack( const PIXEL* psrcBase, PIXEL* psrc, PIXEL* pdst, size_t len );
void    NONE_UnpackClip( const PIXEL* psrcBase, PIXEL* psrc, PIXEL* pdst, size_t len, size_t offset, size_t clipLen );

/*
 * History compressed runs
 * Does a half-hearted LZ77+RLE based packing only on runs equal to this one
 * While it doesn't squeeze the last byte out, it is speedy.
 * 0: Dump starting after this 
 * >0: Should equal run, followed by color to fill with
 * <0: Do this run as copy of previous run
 */
size_t  LZRLE_Reserve( size_t len );
size_t  LZRLE_Pack( const PIXEL* pdstBase, PIXEL* pdst, PIXEL* psrc, size_t len );
void    LZRLE_Unpack( const PIXEL* psrcBase, PIXEL* psrc, PIXEL* pdst, size_t len );
void    LZRLE_UnpackClip( const PIXEL* psrcBase, PIXEL* psrc, PIXEL* pdst, size_t len, size_t offset, size_t clipLen );

#endif


void OPC_NAMING(Blit)( const OPC* dst, const Rect* rdst, const OPC* src, int sx, int sy )
{
    /* Initially clip target rectangle */
    Rect dstblit = *rdst;
    RectIntRect(dstblit,dst->clip);
    if( !RectEmpty(dstblit) )
    {
        /* Make ourself a source rectangle from clipped target */
        Rect orgsrcblit = RectAutoXYWH( sx, sy, RectWide(dstblit), RectHigh(dstblit) );
        Rect srcblit = orgsrcblit;
        /* Offset source rectangle edges given clipped target */
        srcblit.left += dstblit.left - rdst->left;
        srcblit.top += dstblit.top - rdst->top;
        srcblit.right += dstblit.right - rdst->right;
        srcblit.bottom += dstblit.bottom - rdst->bottom;
        /* Now clip source rectangle and offset target as appropriate */
        RectIntRect(srcblit,src->clip);
        dstblit.left += srcblit.left - orgsrcblit.left;
        dstblit.top += srcblit.top - orgsrcblit.top;
        if( !RectEmpty(srcblit) )
        {
            /* Now do the deed for clipped source, which is the smallest rect */
            int wide = RectWide(srcblit);
            int high = RectHigh(srcblit);
            int offsrc = src->pitch;
            int offdst = dst->pitch;
            const OPC_NAMING(Pixel)* pSrc = OPC_PTR( src, srcblit.left, srcblit.top );
            OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, dstblit.left, dstblit.top );
            while( high-- )
            {
                OPC_HCOPY(pDst,pSrc,wide);
                pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + offdst);
                pSrc = (const OPC_NAMING(Pixel)*)((const uint8*)pSrc + offsrc);
            }
#ifdef OPC_DIRTY
            /* Mark dirty region */
            OPC_DIRTY(dstblit);
#endif
        }
    }
}

void OPC_NAMING(Stamp)( const OPC* dst, int dx, int dy, const OPC* src )
{
    Rect rdst = src->clip;
    RectMove(rdst,dx,dy);
    OPC_NAMING(Blit)( dst, &rdst, src, 0,0 );
}

void OPC_NAMING(Fill)( const OPC* dst, const Rect* rdst, OPC_NAMING(Pixel) color )
{
    /* Initially clip target rectangle */
    Rect dstblit = *rdst;
    RectIntRect(dstblit,dst->clip);
    if( !RectEmpty(dstblit) )
    {
        /* Now do the deed for clipped source, which is the smallest rect */
        int wide = RectWide(dstblit);
        int high = RectHigh(dstblit);
        int offdst = dst->pitch;
        OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, dstblit.left, dstblit.top );
        while( high-- )
        {
            OPC_HLINE(pDst,color,wide);
            pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + offdst);
        }
        /* Mark dirty region */
#ifdef OPC_DIRTY
        OPC_DIRTY(dstblit);
#endif
    }
}

void OPC_NAMING(Shape)( const OPC* dst, const OPCShape* shape, int x, int y )
{
    if( !shape )
        return;
    if( shape->data )
    {
#ifdef OPC_POINTERS
        const int8* pCode = shape->code;
        const OPC_NAMING(Pixel)* pData = (const OPC_NAMING(Pixel)*)shape->data;
        const opc_pack_type* plut = (const uint8*)shape->pack;
#else
        const int8* pCode = (int8*)shape + shape->code;
        const OPC_NAMING(Pixel)* pData = (const OPC_NAMING(Pixel)*)((uint8*)shape + shape->data);
        const opc_pack_type* plut = shape->pack ? (const uint8*)shape + shape->pack : NULL;
#endif
        Rect bound;
        OPC_NAMING(Shape_Bound)( &bound, shape, x, y );

        /* See if we can eliminate it */
        if( RectInRect(dst->clip,bound) )
        {
            /* See if we can eliminate clipping */
            if( RectContainsRect(dst->clip,bound) )
            {
                /* Unclipped version */
                OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, bound.left,bound.top );
                OPC_NAMING(Pixel)* pSpan = pDst;
#ifdef OPC_DIRTY
                OPC_DIRTY(bound);
#endif
                for( ; ; )
                {
                    int curr = *pCode++;
                    if( curr <= 0 )
                    {
                        if( curr == -128 )
                            pSpan = pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + dst->pitch);
                        else if( 0 == curr )
                            break;
                        else
                            pSpan -= curr;
                    }
                    else
                    {
                        if( IS_RUN(curr) )
                        {
                            OPC_HLINE(pSpan,*pData,curr);
                            pData++;
                            pSpan += curr;
                        }
                        else
                        {
                            if( plut )
                            {
                                OPC_HCOPY(pSpan,pData-*plut,curr);
                                if( curr > *plut )
                                    pData = (pData - *plut) + curr;
                                plut++;
                                pSpan += curr;
                            }
                            else
                            {
                                OPC_HCOPY(pSpan,pData,curr);
                                pData += curr;
                                pSpan += curr;
                            }
                        }
                    }
                }
            }
            else
            {
                /* Clipped version */
                OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, bound.left, bound.top );
                OPC_NAMING(Pixel)* pSpan = pDst;
                int xCurr = bound.left;
                int yCurr = bound.top;
                RectIntRect(bound,dst->clip);
#ifdef OPC_DIRTY
                /* Mark dirty region */
                OPC_DIRTY(bound);
#endif
                while( yCurr < bound.bottom )
                {
                    int curr = *pCode++;
                    if( curr <= 0 )
                    {
                        if( IS_EOL(curr) )
                        {
                            pSpan = pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + dst->pitch);
                            yCurr++;
                            xCurr = x+shape->xOff;
                        }
                        else if( IS_EOS(curr) )
                            break;
                        else
                        {
                            xCurr += SKIP_LEN(curr);
                            pSpan += SKIP_LEN(curr);
                        }
                    }
                    else 
                    {
                        if( yCurr >= bound.top )
                        {
                            int wide = RUN_LEN(curr);
                            const OPC_NAMING(Pixel)* ppData = pData;
                            OPC_NAMING(Pixel)* ppSpan = pSpan;
                            if( plut )
                                ppData -= *plut;
                            if( xCurr + wide > bound.right )
                                wide = bound.right - xCurr;
                            if( xCurr < bound.left )
                            {
                                int offset = bound.left - xCurr;
                                wide -= offset;
                                ppData += offset;
                                ppSpan += offset;
                            }
                            if( wide > 0 )
                            {
                                if( IS_RUN(curr) )
                                {
                                    OPC_HLINE(ppSpan,*pData,wide);
                                }
                                else
                                {
                                    OPC_HCOPY(ppSpan,ppData,wide);
                                }
                            }
                        }
                        if( IS_RUN(curr) )
                        {
                            pData++;
                        }
                        else if( plut )
                        {
                            if( curr > *plut )
                                pData = (pData - *plut) + curr;
                            plut++;
                        }
                        else
                        {
                            pData += curr;
                        }
                        xCurr += curr;
                        pSpan += curr;
                    }
                }
            }
        }
    }
    else
    {
        OPC_NAMING(Shape_Mask)( dst, shape, x, y, OPC_NAMING(maskcolor) );
    }
}

void OPC_NAMING(Shape_Mask)( const OPC* dst, const OPCShape* shape, int x, int y, OPC_NAMING(Pixel) color )
{
    if( shape )
    {
#ifdef OPC_POINTERS
        const int8* pCode = shape->code;
#else
        const int8* pCode = (int8*)shape + shape->code;
#endif
        /* If we're drawing a mask from compressed shape, skip that byte */
        Rect bound;
        OPC_NAMING(Shape_Bound)( &bound, shape, x, y );
        /* See if we can eliminate it */
        if( RectInRect(dst->clip,bound) )
        {
            /* See if we can eliminate clipping */
            if( RectContainsRect(dst->clip,bound) )
            {
                /* Unclipped version */
                OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, bound.left, bound.top );
                OPC_NAMING(Pixel)* pSpan = pDst;
#ifdef OPC_DIRTY
                OPC_DIRTY(bound);
#endif
                for( ; ; )
                {
                    int curr = *pCode++;
                    if( curr <= 0 )
                    {
                        if( curr == -128 )
                            pSpan = pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + dst->pitch);
                        else if( 0 == curr )
                            break;
                        else
                            pSpan -= curr;
                    }
                    else
                    {
                        OPC_HLINE(pSpan,color,curr);
                        pSpan += curr;
                    }
                }
            }
            else
            {
                /* Clipped version */
                OPC_NAMING(Pixel)* pDst = OPC_PTR( dst, bound.left, bound.top );
                OPC_NAMING(Pixel)* pSpan = pDst;
                int xCurr = bound.left;
                int yCurr = bound.top;
                RectIntRect(bound,dst->clip);
#ifdef OPC_DIRTY
                /* Mark dirty region */
                OPC_DIRTY(bound);
#endif
                while( yCurr < bound.bottom )
                {
                    int curr = *pCode++;
                    if( curr <= 0 )
                    {
                        if( curr == -128 )
                        {
                            yCurr++;
                            xCurr = x;
                            pSpan = pDst = (OPC_NAMING(Pixel)*)((uint8*)pDst + dst->pitch);
                        }
                        else if( 0 == curr )
                            break;
                        else
                        {
                            xCurr -= curr;
                            pSpan -= curr;
                        }
                    }
                    else 
                    {
                        if( yCurr >= bound.top )
                        {
                            int wide = curr;
                            OPC_NAMING(Pixel)* ppSpan = pSpan;
                            if( xCurr + wide > bound.right )
                                wide = bound.right - xCurr;
                            if( xCurr < bound.left )
                            {
                                int offset = bound.left - xCurr;
                                wide -= offset;
                                ppSpan += offset;
                            }
                            if( wide > 0 )
                                OPC_HLINE(ppSpan,color,wide);
                        }
                        xCurr += curr;
                        pSpan += curr;
                    }
                }
            }
        }
    }
}

void OPC_NAMING(Shape_Bound)( Rect* posn, const OPCShape* shape, int x, int y )
{
    if( shape )
    {
        posn->left = x + shape->xOff;
        posn->top = y + shape->yOff;
        posn->right = posn->left + shape->wide;
        posn->bottom = posn->top + shape->high;
    }
    else
    {
        RectClear(*posn);
    }
}

size_t OPC_NAMING(Shape_TotalSize)( const OPCShape* shape )
{
    if( shape )
        return sizeof(OPCShape) + ((OPC_NAMING(Shape_CodeSize)( shape )+3)&~3) + OPC_NAMING(Shape_PackLutSize)( shape ) + OPC_NAMING(Shape_DataSize)( shape );
    return 0;
}

size_t OPC_NAMING(Shape_CodeSize)( const OPCShape* shape )
{
    if( shape )
    {
#ifdef OPC_POINTERS
        const int8* pCode = shape->code;
#else
        const int8* pCode = (int8*)shape + shape->code;
#endif
        return 1 + strlen( (char*)pCode );
    }
    return 0;
}

size_t OPC_NAMING(Shape_PackLutSize)( const OPCShape* shape )
{
    if( shape && shape->data )
    {
#ifdef OPC_POINTERS
        const int8* pCode = shape->code;
        const opc_pack_type* plut = (const uint8*)shape->pack;
#else
        const int8* pCode = (int8*)shape + shape->code;
        const opc_pack_type* plut = (const uint8*)shape + shape->pack;
#endif
        if( plut )
        {
            size_t dumps = 0;
            while( *pCode )
            {
                if( IS_RUNDUMP(*pCode) )
                {
                    if( IS_DUMP(*pCode) )
                    {
                        dumps++;
                    }
                }
                pCode++;
            }
            return ((sizeof(opc_pack_type) * dumps) + 3) & ~3;
        }
    }
    return 0;
}

size_t OPC_NAMING(Shape_DataSize)( const OPCShape* shape )
{
    if( shape && shape->data )
    {
#ifdef OPC_POINTERS
        const int8* pCode = shape->code;
        const opc_pack_type* plut = (const uint8*)shape->pack;
#else
        const int8* pCode = (int8*)shape + shape->code;
        const opc_pack_type* plut = shape->pack ? (const uint8*)shape + shape->pack : NULL;
#endif
        if( plut )
        {
            size_t pixels = 0;
            size_t luts = 0;
            while( *pCode )
            {
                if( IS_RUNDUMP(*pCode) )
                {
                    if( IS_RUN(*pCode) )
                    {
                        pixels++;
                    }
                    else
                    {
                        if( *pCode > *plut )
                        {
                            pixels += *pCode - *plut;
                        }
                        plut++;
                        luts++;
                    }
                }
                pCode++;
            }
            return pixels * sizeof(PIXEL);
        }
        else
        {
            size_t pixels = 0;
            while( *pCode )
            {
                if( IS_RUNDUMP(*pCode) )
                {
                    if( IS_RUN(*pCode) )
                    {
                        pixels++;
                    }
                    else
                    {
                        pixels += *pCode;
                    }
                }
                pCode++;
            }
            return pixels * sizeof(PIXEL);
        }
    }
    return 0;
}

OPC_NAMING(Pixel) OPC_NAMING(Shape_MaskColor)( OPC_NAMING(Pixel) color )
{
    OPC_NAMING(Pixel) ret = OPC_NAMING(maskcolor);
    OPC_NAMING(maskcolor) = color;
    return ret;
}