opctool.temp.h File Reference

Tool related OPC function generator Generates things purely useful for tooling up code to make OPC/OPCShape data. More...

#include "opctool.h"

Include dependency graph for opctool.temp.h:

Go to the source code of this file.

Functions
void OPC_NAMING()	ShrinkBound (OPC *dst, const OPC *src, OPC_NAMING(Pixel) transparent)
	Find the non-transparent edges of a shape Copies src to dst, then moves clipping bounds of dst down until they all hit something non-transparent.
size_t OPC_NAMING()	Shape_Calc (const OPC *src, OPC_NAMING(Pixel) transparent, bool bMask)
	Calculate how big a buffer would be required to define a new shape This will usually calculate a little bigger, because it doesn't bother working out how to eliminate excess skips.
OPCShape *OPC_NAMING()	Shape_Create (const OPC *src, OPC_NAMING(Pixel) transparent, void *buffer, bool bMask)
	Define a new transparent shape Not super optimized, more a tool library or initialization function Origin is set to clipping box's origin, so make an OPC_Window, then find the edges, then pass that in.
size_t OPC_NAMING()	Shape_Pack_Needs (OPCShape *shape)
	Do something like LZ+RLE on non-transparent parts of a shape.
size_t OPC_NAMING()	Shape_Pack (OPCShape *shape, void *buffer)
	Do something like LZ on non-transparent, non-RUN parts of a shape.
void OPC_NAMING()	ExportH (const OPC *opc, FILE *fp, const char *szname)
	Export a header definition for OPC data.
void OPC_NAMING()	ExportC (const OPC *opc, FILE *fp, const char *modifier, const char *szname, const char *szComment,...)
	Export the OPC structure portion of OPC data.
void OPC_NAMING()	ExportCData (const OPC *opc, FILE *fp, const char *szname)
	Export the OPCShape pixel image data.
void OPC_NAMING()	Shape_ExportH (const OPCShape *shape, FILE *fp, const char *szname, bool bMask)
	Export a header definition for OPCShape data.
void OPC_NAMING()	Shape_ExportC (const OPCShape *shape, FILE *fp, const char *modifier, const char *szname, bool bMask, const char *szComment,...)
	Export the OPCShape structure portion of OPC data.
void OPC_NAMING()	Shape_ExportCData (const OPCShape *shape, FILE *fp, const char *szname, bool bMask)
	Export the OPCShape pixel image data.

---

Detailed Description

Tool related OPC function generator Generates things purely useful for tooling up code to make OPC/OPCShape data.

Author:

David Mace

Definition in file opctool.temp.h.

---

Function Documentation

void OPC_NAMING() ExportC	(	const OPC *	opc,
		FILE *	fp,
		const char *	modifier,
		const char *	szname,
		const char *	szComment,
			...
	)

Export the OPC structure portion of OPC data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	modifier	Definition modifier (such as 'static' or __declspec(dllexport)), or just ""
	szname	What to call this particular export
	szComment	An optional comment for the export, or NULL if you don't want it Writes OPC with forward references to static data

Definition at line 538 of file opctool.temp.h.

{
    if( szComment )
    {
        va_list args;
        va_start( args, szComment );     /* Initialize variable arguments. */
        fputs( "\n/*\n * ", fp );
        vfprintf( fp, szComment, args );
        fputs( "\n */\n", fp );
    }
    fprintf( fp, "static const OPC_NAMING(Pixel) data_%s[];\n", szname );
    if( modifier && *modifier )
        fprintf( fp, "%s ", modifier );
    fprintf( fp, "const OPC %s = /* Stamp */\n{\n", szname );
    fprintf( fp, "\t(uint8*)data_%s,\t/* origin */\n", szname );
    fprintf( fp, "\t%d,\t/* pitch */\n", abs(opc->pitch) );
    fprintf( fp, "\t{%d,%d,%d,%d}\t/* clip */\n", opc->clip.left, opc->clip.top, opc->clip.right, opc->clip.bottom );
    fputs( "};\n", fp );
}

void OPC_NAMING() ExportCData	(	const OPC *	opc,
		FILE *	fp,
		const char *	szname
	)

Export the OPCShape pixel image data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	szname	What to call this particular export Writes the static data, tries to write it same shape as opc, but gives up past a certain point.

Definition at line 572 of file opctool.temp.h.

References RectHigh, RectWide, throwassert, and wrap.

{
#ifndef GIVEUP_AFTER
#define GIVEUP_AFTER    15
#endif
    size_t curr;
    const OPC_NAMING(Pixel)* pData = (const OPC_NAMING(Pixel)*)opc->origin;
    size_t size = OPC_NAMING(Needs)( RectWide(opc->clip), RectHigh(opc->clip) );
    unsigned wrap = min( RectWide(opc->clip), GIVEUP_AFTER );
    fprintf( fp, "static const OPC_NAMING(Pixel) data_%s[%d] = \n{\n\t", szname, size );
#ifdef PIXEL_OUTPUT
    for( curr = 0; curr < size; ++curr )
    {
        PIXEL_OUTPUT( fp, *pData++ );
        if( (curr % wrap) == wrap - 1 )
            fputs( "\n\t", fp );
    }
#else
    switch(sizeof(OPC_NAMING(Pixel)))
    {
    case 1:
        for( curr = 0; curr < size; ++curr )
        {
            fprintf( fp, "%3d,", (unsigned)*pData++ );
            if( (curr % wrap) == wrap - 1 )
                fputs( "\n\t", fp );
        }
        break;
    case 2:
        for( curr = 0; curr < size; ++curr )
        {
            fprintf( fp, "0x%04x,", (unsigned)*pData++ );
            if( (curr % wrap) == wrap - 1 )
                fputs( "\n\t", fp );
        }
        break;
    case 4:
        for( curr = 0; curr < size; ++curr )
        {
            fprintf( fp, "0x%08x,", (unsigned)*pData++ );
            if( (curr % wrap) == wrap - 1 )
                fputs( "\n\t", fp );
        }
        break;
    case 8:
        for( curr = 0; curr < size; ++curr )
        {
            fprintf( fp, "0x%" LLX(char) ",", (uint64)*pData++ );
            if( (curr % wrap) == wrap - 1 )
                fputs( "\n\t", fp );
        }
        break;
    default:
        throwassert( "Invalid pixel size." );
        break;
    }
    fputs( "\n};\n", fp );
#endif
}

void OPC_NAMING() ExportH	(	const OPC *	opc,
		FILE *	fp,
		const char *	szname
	)

Export a header definition for OPC data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	szname	What to call this particular export

Definition at line 521 of file opctool.temp.h.

References RectHigh, and RectWide.

{
    fprintf( fp, "#define %s_BOUND(x,y)\t{(x),(y),(x)+%d,(y)+%d}\n", szname, RectWide(opc->clip), RectHigh(opc->clip) );
    fprintf( fp, "#define %s_WIDE\t%d\n", szname, RectWide(opc->clip) );
    fprintf( fp, "#define %s_HIGh\t%d\n", szname, RectHigh(opc->clip) );
    fprintf( fp, "extern const OPC %s; /* Stamp */\n", szname );
}

size_t OPC_NAMING() Shape_Calc	(	const OPC *	src,
		OPC_NAMING(Pixel)	transparent,
		bool	bMask
	)

Calculate how big a buffer would be required to define a new shape This will usually calculate a little bigger, because it doesn't bother working out how to eliminate excess skips.

Parameters:

	src	OPC containing shape to be defined
	transparent	Color to consider 'invisible'
	bMask	True if we're making a mask, rather than a textured shape

Definition at line 117 of file opctool.temp.h.

References Rect::bottom, Rect::left, Rect::right, and Rect::top.

{
    size_t dataLen = 0;
    size_t codeLen = 0;
    int x, y;
    for( y = src->clip.top; y < src->clip.bottom; ++y )
    {
        for( x = src->clip.left; x < src->clip.right; )
        {
            {
                const OPC_NAMING(Pixel)* line = OPC_PTR( src, x,y );
                int skip = 0;
                for( ; x < src->clip.right && skip < MAX_SKIP && *line++ == transparent; x++ )
                    skip++;
                if( skip )
                {
                    codeLen++;
                }
            }
            {
                const OPC_NAMING(Pixel)* line = OPC_PTR( src, x,y );
                int run = 0;
                for( ; x < src->clip.right && run < MAX_DUMP && *line++ != transparent; x++ )
                    run++;
                if( run )
                {
                    codeLen++;
                    if( !bMask )
                        dataLen+=run;
                }
            }
        }
        codeLen++;
    }
    codeLen++;
    return sizeof(OPCShape) + (codeLen+sizeof(int)) + (dataLen * sizeof(OPC_NAMING(Pixel)));
}

OPCShape* OPC_NAMING() Shape_Create	(	const OPC *	src,
		OPC_NAMING(Pixel)	transparent,
		void *	buffer,
		bool	bMask
	)

Define a new transparent shape Not super optimized, more a tool library or initialization function Origin is set to clipping box's origin, so make an OPC_Window, then find the edges, then pass that in.

Parameters:

	src	OPC containing shape to be defined
	transparent	Color to consider 'invisible'
	buffer	A buffer of at least OPC_CalcShape(src,transparent) bytes to convert into
	bMask	True if we're making a mask, rather than a textured shape

Returns:

The new shape (pointer is equal to buffer)

OPC Data is basically an 8-bit skip compressed mask which references templated pixel data.

Codes (signed char code array): -1~-127 Skip -128: End line 0: End shape 1~MAX_DUMP: Copy MAX_DUMP~127: Fill If 'code' is not NULL, and first 'code' is 0, data is packed somehow

The pixel data can be either just dumped, or further compressed.

The compression to apply has a LOT to do with the target format and speed of target system. For instance, a PC will handle full-blown LZH compression, but many embedded CPUs will not. RLE might do very nicely on data with lots of solid runs, and a target with little or no horsepower to use on decompressing data. Data alignment also figures into the problem since data on 32 bit boundaries will consume 32 bits for a code, even if the code is 8-bits.

Definition at line 188 of file opctool.temp.h.

References Rect::bottom, OPC::clip, OPCShape::code, OPCShape::data, OPCShape::high, Rect::left, OPCShape::pack, OPC::pitch, RectHigh, RectWide, Rect::right, ShrinkBound(), Rect::top, OPCShape::wide, OPCShape::xOff, and OPCShape::yOff.

{
    OPC bound;
    OPCShape* shape = (OPCShape*)buffer;
    int8* pCode = (int8*)(shape+1);
    int x, y;
    OPC_NAMING(ShrinkBound)( &bound, src, transparent );
#ifdef OPC_POINTERS
    shape->code = pCode;
    shape->data = NULL;
    shape->pack = NULL;
#else
    shape->code = pCode-(int8*)shape;
    shape->data = 0;
    shape->pack = 0;
#endif
    shape->wide = (uint16)RectWide(bound.clip);
    shape->high = (uint16)RectHigh(bound.clip);
    shape->xOff = (int16)bound.clip.left;
    shape->yOff = (int16)bound.clip.top;
    for( y = bound.clip.top; y < bound.clip.bottom; ++y )
    {
        for( x = bound.clip.left; x < bound.clip.right; )
        {
            {
                /* Skip transparent */
                const OPC_NAMING(Pixel)* line = OPC_PTR( src, x,y );
                int skip = 0;
                for( x = x; x < bound.clip.right && skip < MAX_SKIP && *line == transparent; x++, skip++, line++ )
                    ;
                if( skip )
                {
                    *pCode++ = SKIP_CODE(skip);
                    continue;
                }
            }
            {
                /* Now do RLE on non-transparent pixels */
                const OPC_NAMING(Pixel)* line = OPC_PTR( src, x,y );
                int dump = 0;
                for( x = x; x < bound.clip.right && dump < MAX_DUMP && *line != transparent; x++, dump++, line++ ) /* Small optimization for 8/16 bit data on large, solid shapes */
                if( !bMask ) /* If we're building a mask, we don't need to break lines down */
                {
                    /* Look for runs of color in dump */
                    PIXEL prun = *line;
                    const PIXEL* scanLine = line+1;
                    int run = 1;
                    int tmpx;
                    for( tmpx = x+1; tmpx < bound.clip.right && run < MAX_RUN && *scanLine == prun && *scanLine != transparent; tmpx++, run++, scanLine++ )
                        ;
                    if( run >= MIN_RUN ) /* We want more than mere crumbs of run */
                    {
                        /* Output dump code */
                        if( dump )
                        {
                            *pCode++ = DUMP_CODE(dump);
                            dump = 0;
                        }
                        /* Output run length */
                        *pCode++ = RUN_CODE(run);
                        x = tmpx;
                        break;
                    }
                }
                if( dump )
                {
                    *pCode++ = DUMP_CODE(dump);
                }
            }
        }
        /* Consume any trailing skips (a wide shape might contain two or more skips on the trailing edge of the line) */
        if( *(pCode-1) < 0 && *(pCode-1) != -128 && pCode > (int8*)(shape+1) )
            *--pCode = -128;
        *pCode++ = -128;
    }
    /* Terminate, removing all trailing skips */
    while( *(pCode-1) < 0 && pCode > (int8*)(shape+1) )
        --pCode;
    *pCode++ = 0;
    /* Clear extra bytes & align 'pointer' */
    while( (size_t)pCode & 3 )
        *pCode++ = 0;
    if( bMask )
    {
        shape->data = 0;
    }
    else
    {
    /* Get pixel data onto integer boundary */
#ifdef OPC_POINTERS
        shape->data = pCode;
#else
        shape->data = pCode-(int8*)shape;
#endif
        {
            /*
             * Now that we know how big the code is, we can copy the data onto the 
             * end of it. Use the rle code we generated to determine what to copy
             */
#ifdef OPC_POINTERS
            const int8* pCode = shape->code;
            OPC_NAMING(Pixel)* pData = (OPC_NAMING(Pixel)*)shape->data;
#else
            const int8* pCode = (int8*)shape + shape->code;
            OPC_NAMING(Pixel)* pData = (OPC_NAMING(Pixel)*)((uint8*)shape + shape->data);
#endif
            const OPC_NAMING(Pixel)* pSrc = OPC_PTR( src, bound.clip.left,bound.clip.top );
            const OPC_NAMING(Pixel)* pSpan = pSrc;
            size_t wrote = 0;
            for( ; ; )
            {
                int curr = *pCode++;
                if( IS_SKIP(curr) )
                {
                    if( IS_EOL(curr) )
                        pSpan = pSrc = (OPC_NAMING(Pixel)*)((uint8*)pSrc + bound.pitch);
                    else
                        pSpan += SKIP_LEN(curr);
                }
                else if( IS_RUNDUMP(curr) )
                {
                    if( IS_RUN(curr) )
                    {
                        OPC_HCOPY(pData,pSpan,1);
                        pSpan += RUN_LEN(curr);
                        pData += 1;
                        wrote += sizeof(OPC_NAMING(Pixel));
                    }
                    else /* if( IS_DUMP(curr) ) */
                    {
                        OPC_HCOPY(pData,pSpan,curr);
                        pSpan += DUMP_LEN(curr);
                        pData += DUMP_LEN(curr);
                        wrote += DUMP_LEN(curr) * sizeof(OPC_NAMING(Pixel));
                    }
                }
                else
                {
                    break;
                }
            }
            if( !wrote )
                shape->data = 0;
        }
        /* Now we know how big the whole thing is. */
        /*shape->size = (uint8*)pData - (uint8*)shape;*/
    }
    return shape;
}

Here is the call graph for this function:

void OPC_NAMING() Shape_ExportC	(	const OPCShape *	shape,
		FILE *	fp,
		const char *	modifier,
		const char *	szname,
		bool	bMask,
		const char *	szComment,
			...
	)

Export the OPCShape structure portion of OPC data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	modifier	Definition modifier (such as 'static' or __declspec(dllexport)), or just ""
	szname	What to call this particular export
	bMask	If true, PIXEL data is exclued; just the OPCShape and runs
	szComment	An optional comment for the export, or NULL if you don't want it Writes OPCShape structure with forward references to static data

Definition at line 657 of file opctool.temp.h.

{
    if( szComment )
    {
        va_list args;
        va_start( args, szComment );     /* Initialize variable arguments. */
        fputs( "\n/*\n * ", fp );
        vfprintf( fp, szComment, args );
        fputs( "\n */\n", fp );
    }
    fprintf( fp, "static const int8 code_%s[%u];\n", szname, OPC_NAMING(Shape_CodeSize)( shape ) );
    if( !bMask && shape->data )
        fprintf( fp, "static const OPC_NAMING(Pixel) data_%s[%u];\n", szname, OPC_NAMING(Shape_DataSize)( shape ) );
    if( !bMask && shape->pack )
        fprintf( fp, "static const opc_pack_type pack_%s[%u];\n", szname, OPC_NAMING(Shape_PackLutSize)( shape ) );
    if( modifier && *modifier )
        fprintf( fp, "%s ", modifier );
    fprintf( fp, "const OPCShape %s =\n", szname );
    fputs( "{\n", fp );
    fprintf( fp, "\t%3d,\t/* xOff */\n", shape->xOff );
    fprintf( fp, "\t%3d,\t/* yOff */\n", shape->yOff );
    fprintf( fp, "\t%3u,\t/* wide */\n", shape->wide );
    fprintf( fp, "\t%3u,\t/* high */\n", shape->high );
    fprintf( fp, "\tcode_%s,\t/* code */\n", szname );
    if( bMask || !shape->data )
        fprintf( fp, "\tNULL,\t/* no data */\n" );
    else
        fprintf( fp, "\tdata_%s,\t/* data */\n", szname );
    if( bMask || !shape->pack )
        fprintf( fp, "\tNULL,\t/* no pack */\n" );
    else
        fprintf( fp, "\tpack_%s,\t/* packed */\n", szname );
    fputs( "};\n", fp );
}

void OPC_NAMING() Shape_ExportCData	(	const OPCShape *	shape,
		FILE *	fp,
		const char *	szname,
		bool	bMask
	)

Export the OPCShape pixel image data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	szname	What to call this particular export Writes the static data, tries to write it same shape as opc
	bMask	If true, PIXEL data is exclued; just the OPCShape and runs

Definition at line 700 of file opctool.temp.h.

References throwassert.

{
    size_t cCode = OPC_NAMING(Shape_CodeSize)( shape );
    size_t curr;
#ifdef OPC_POINTERS
    const int8* pCode = shape->code;
#else
    const int8* pCode = (int8*)shape + shape->code;
#endif
    /* Lay out codes intelligibly */
    fprintf( fp, "static const int8 code_%s[%u] = \n{\n\t", szname, cCode );
    for( curr = 0; curr < cCode; ++curr )
    {
        int code = *pCode++;
        if( code == -128 )
        {
            fputs( "-128,\n\t", fp );
        }
        else
        {
            fprintf( fp, "%d, ", code );
        }
    }
    fputs( "\n};\n", fp );
    if( !bMask && shape->pack )
    {
        size_t cData = OPC_NAMING(Shape_PackLutSize)( shape );
        size_t cols = 0;
#ifdef OPC_POINTERS
        const uint8* plut = (const opc_pack_type*)shape->pack;
#else
        const uint8* plut = (const opc_pack_type*)shape + shape->pack;
#endif
        /* Align data so a few more 32 bit DMA's can happen on 8/16 bit art */
        fprintf( fp, "static const OPC_NAMING(Pixel) pack_%s[%u] __attribute__((aligned)) = \n{\n\t", szname, cData );
        while( cData-- )
        {
            fprintf( fp, "%d,", (unsigned)*plut++ );
            ++cols;
            if( 0 == (cols & 0xf) )
            {
                fputs( "\n\t", fp );
                cols = 0;
            }
        }
        fputs( "\n};\n", fp );
    }
    if( !bMask && shape->data )
    {
        /* Draw shapes recognizably */
        size_t cData = OPC_NAMING(Shape_DataSize)( shape );
        size_t cols = 0;
#ifdef OPC_POINTERS
        const uint8* pData = (const uint8*)shape->data;
#else
        const uint8* pData = (const uint8*)shape + shape->data;
#endif
        /* Align data so a few more 32 bit DMA's can happen on 8/16 bit art */
        fprintf( fp, "static const OPC_NAMING(Pixel) data_%s[%u] __attribute__((aligned)) = \n{\n\t", szname, cData );
        while( cData-- )
        {
#ifdef PIXEL_OUTPUT
            PIXEL_OUTPUT( fp, *pData++ );
#else
            switch(sizeof(OPC_NAMING(Pixel)))
            {
            case 1:
                fprintf( fp, "0x%02x,", (unsigned)*pData++ );
                break;
            case 2:
                fprintf( fp, "0x%04x,", (unsigned)*pData++ );
                break;
            case 4:
                fprintf( fp, "0x%08x,", (unsigned)*pData++ );
                break;
            case 8:
                fprintf( fp, "0x%" LLX(char) ",", (uint64)*pData++ );
                break;
            default:
                throwassert( "Invalid pixel size." );
                break;
            }
#endif
            ++cols;
            if( 0 == (cols & 0xf) )
            {
                fputs( "\n\t", fp );
                cols = 0;
            }
            else if( 0 == (cols & 7) )
            {
                fputs( " ", fp );
            }
        }
        fputs( "\n};\n", fp );
    }
}

void OPC_NAMING() Shape_ExportH	(	const OPCShape *	shape,
		FILE *	fp,
		const char *	szname,
		bool	bMask
	)

Export a header definition for OPCShape data.

Parameters:

	opc	Solid buffer we're weiting
	fp	FILE* open to write to a header file
	szname	What to call this particular export
	bMask	If true, PIXEL data is exclued; just the OPCShape and runs

Definition at line 639 of file opctool.temp.h.

{
    fprintf( fp, "#define %s_BOUND(x,y)\t{ (x)+%d, (y)+%d, (x)+%d+%d, (y)+%d+%d }\n", szname, shape->xOff, shape->yOff, shape->xOff, shape->xOff+shape->wide, shape->yOff, shape->yOff + shape->high );
    fprintf( fp, "#define %s_WIDE\t%d\n", szname, shape->wide );
    fprintf( fp, "#define %s_HIGH\t%d\n", szname, shape->high );
    fprintf( fp, "extern const OPCShape %s;\n", szname );
}

size_t OPC_NAMING() Shape_Pack	(	OPCShape *	shape,
		void *	buffer
	)

Do something like LZ on non-transparent, non-RUN parts of a shape.

Parameters:

	shape	Shape to attempt compression on
	buffer	Scratch buffer, needs at least 'OPC_NAMING(Shape_Pack_Needs)(shape)' bytes

Returns:

Size of data; may be same as original (no savings), should be less in many cases

A compressed shape is identified by having the first skip code '0', which is normally the shape terminator. If it is '0', then we look for a compression header at the start of data, and parse from there.

All in all, this doesn't try very hard to find runs. It only searches for matches the same size as the RLE dumps that are passed in. Otherwise, clipping could get really ugly and time-consuming. The idea here is to have some compression, but not make it really cost us anything substantial in runtime cycles, possibly saving some runtime cycles on cache hits. It's also important to me to keep the RLE compression seperate from this packing, so 'better' and more time- consuming packing can be added for faster target platforms without melting down the whole skip compressed format.

TODO: I need to rethink this kludged format a bit; the source code output is endian-dependant; tool and code must match for source to work. It's that uint16 LUT.

Definition at line 373 of file opctool.temp.h.

References assert.

{
#ifdef OPC_POINTERS
    int8* pCode = shape->code;
    OPC_NAMING(Pixel)* pData = (OPC_NAMING(Pixel)*)shape->data;
#else
    int8* pCode = (int8*)shape + shape->code;
    OPC_NAMING(Pixel)* pData = (OPC_NAMING(Pixel)*)((uint8*)shape + shape->data);
#endif
    if( pData && !shape->pack )
    {
        /*
         * Go through the shape run-by-run, and see if any runs can be 
         * made from earlier data, or if runs are just a solid fill-color.
         *
         * Unsigned 16 bit window
         * >0: Lookup pixels from earlier spans (length from 'pCode')
         * 0: Start from current position
         *
         * Special case: a run may be added to from '-code' that is 
         * shorter than 'span', if the additional bytes are added after 
         * it.  For instance, a previous span ended '...21234', and the 
         * current one is '23456...,' the '234' can be used for the 
         * current span, only adding '56...' on the end.  This will help 
         * with some pattern fills that might not have compressed at all.
         *
         */
        opc_pack_type* pIndexBegin = (opc_pack_type*)(buffer);
        opc_pack_type* pIndexEnd = pIndexBegin;
        opc_pack_type* pIndexes = pIndexBegin;
        const int8* pCodeEnd, *pCodeBegin;
        int indexCount = 0;
        OPC_NAMING(Pixel)* pixBegin, *pixCurr;
        OPC_NAMING(Pixel)* pixEnd = (uint8*)buffer + OPC_NAMING(Shape_DataSize)( shape );
        {
            pCodeBegin = pCodeEnd = pCode;
            while( *pCodeEnd )
            {
                int code = *pCodeEnd++;
                if( IS_DUMP(code) )
                    indexCount++;
            }
            pIndexEnd = pIndexBegin + indexCount;
            while( (size_t)pIndexEnd & 3 )
            {
                pIndexEnd++;
            }
            pixBegin = pixCurr = (OPC_NAMING(Pixel)*)pIndexEnd;
        }
        while( pixCurr < pixEnd )
        {
            int code = *pCode++;
            if( IS_RUN(code) )
            {
                /*
                 * Runs of color are transferred without an index lookup
                 */
                /* Don't smash RAM */
                if( pixCurr + 1 > pixEnd )
                    break;
                *pixCurr++ = *pData++;
            }
            else if( IS_DUMP(code) )
            {
                assert( pCode <= pCodeEnd );
                assert( pIndexes < (opc_pack_type*)pixBegin );
                /* See if some of new run can be re-used from previous run */
                {
                    int best = 0;
                    int bestLen = 0;
                    int index = 0;
                    const OPC_NAMING(Pixel)* scan = pixCurr;
                    while( scan-- > pixBegin && ++index < opc_pack_max )
                    {
                        size_t scanLen = min(pixCurr-scan,code);
                        if( !memcmp(scan,pData,sizeof(OPC_NAMING(Pixel))*scanLen) )
                        {
                            best = index;
                            bestLen = scanLen;
                            /* If we found a match equal to full code size, mission accomplished */
                            if( bestLen == code )
                                break;
                        }
                    }
                    if( bestLen > 0 )
                    {
                        *pIndexes++ = best;
                        if( bestLen < code )
                        {
                            /* Don't smash RAM */
                            if( pixCurr + (code-bestLen) > pixEnd )
                                break;
                            memcpy( pixCurr, pData+best, sizeof(OPC_NAMING(Pixel))*(code-bestLen) );
                            pixCurr += (code-bestLen);
                        }
                        pData += code;
                        continue;
                    }
                }
                /* Just dump new run on end and hope future runs are better */
                {
                    /* Don't smash RAM */
                    if( pixCurr + code > pixEnd )
                        break;
                    *pIndexes++ = 0;
                    memcpy( pixCurr, pData, sizeof(OPC_NAMING(Pixel))*code );
                    pixCurr += code;
                    pData += code;
                }
            }
            else if( code == 0 )
            {
                /* 
                 * We hit the end and didn't run out? SUCCESS!
                 * Update OPCShape, copy new data, etc.
                 */
                size_t packsize = (size_t)pixCurr - (size_t)buffer;

                /* Clear extra bytes & align pointer */
                while( (size_t)pCode & 3 )
                    *pCode++ = 0;
                memcpy( pCode, buffer, packsize );
                
#ifdef OPC_POINTERS
                shape->pack = pCode;
                shape->data = pCode + (pIndexEnd-pIndexBegin);
#else
                shape->pack = (size_t)pCode - (size_t)shape;
                shape->data = shape->pack + (pIndexEnd-pIndexBegin);
#endif

                return OPC_NAMING(Shape_TotalSize)( shape );
            }
            /* else if( code < 0 ), we ignore it. */
        }
    }
    /*
     * Just return input shape's size
     */
    return OPC_NAMING(Shape_TotalSize)( shape );
}

void OPC_NAMING() ShrinkBound	(	OPC *	dst,
		const OPC *	src,
		OPC_NAMING(Pixel)	transparent
	)

Find the non-transparent edges of a shape Copies src to dst, then moves clipping bounds of dst down until they all hit something non-transparent.

Parameters:

	dst	OPC we're constructing from src.
	src	OPC we're making a shrunken version of
	transparent	Pixel value to treat as transparent

Definition at line 35 of file opctool.temp.h.

References Rect::bottom, and Rect::right.

Referenced by Shape_Create().

{
    if( dst != src )
        *dst = *src;
    /* Move down top edge until it hits something */
    while( dst->clip.top < dst->clip.bottom )
    {
        OPC_NAMING(Pixel) pixel = transparent;
        const OPC_NAMING(Pixel)* curr = OPC_PTR( dst, dst->clip.left,dst->clip.top );
        int x;
        for( x = dst->clip.left; x < dst->clip.right; ++x )
        {
            pixel = *curr++;
            if( pixel != transparent )
                break;
        }
        if( pixel != transparent )
            break;
        dst->clip.top++;
    }
    /* Move up bottom edge until it hits something */
    while( dst->clip.top < dst->clip.bottom )
    {
        OPC_NAMING(Pixel) pixel = transparent;
        const OPC_NAMING(Pixel)* curr = OPC_PTR( dst, dst->clip.left,dst->clip.bottom-1 );
        int x;
        for( x = dst->clip.left; x < dst->clip.right; ++x )
        {
            pixel = *curr++;
            if( pixel != transparent )
                break;
        }
        if( pixel != transparent )
            break;
        dst->clip.bottom--;
    }
    /* Move left edge right until it hits something */
    while( dst->clip.left < dst->clip.right )
    {
        OPC_NAMING(Pixel) pixel = transparent;
        const OPC_NAMING(Pixel)* curr = OPC_PTR( dst, dst->clip.left,dst->clip.top );
        int pitch = dst->pitch;
        int y;
        for( y = dst->clip.top; y < dst->clip.bottom; ++y )
        {
            pixel = *curr;
            curr = (OPC_NAMING(Pixel)*)((uint8*)curr + pitch);
            if( pixel != transparent )
                break;
        }
        if( pixel != transparent )
            break;
        dst->clip.left++;
    }
    /* Move right edge left until it hits something */
    while( dst->clip.left < dst->clip.right )
    {
        OPC_NAMING(Pixel) pixel = transparent;
        const OPC_NAMING(Pixel)* curr = OPC_PTR( dst, dst->clip.right-1,dst->clip.top );
        int pitch = dst->pitch;
        int y;
        for( y = dst->clip.top; y < dst->clip.bottom; ++y )
        {
            pixel = *curr;
            curr = (OPC_NAMING(Pixel)*)((uint8*)curr + pitch);
            if( pixel != transparent )
                break;
        }
        if( pixel != transparent )
            break;
        dst->clip.right--;
    }
}