opctool.temp.h

Go to the documentation of this file.

#ifndef OPCTOOL_H
#include "opctool.h"
#endif

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

/*
 * PIXEL_OUTPUT_SIZE
 * PIXEL_OUTPUT( fp, p )
 *
 * Define these macros to customize pixel output, to break up RGB like the palette
 * output does, or simply to make the numbers pretty-print the way YOU think they're
 * most pretty.
 *
 * PIXEL_OUTPUT takes a file pointer (i.e. for printf) and a pixel, and is 
 * expected to output an array member, and return length of output, like fprintf.
 */

void OPC_NAMING(ShrinkBound)( OPC* dst, const OPC* src, OPC_NAMING(Pixel) transparent )
{
    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--;
    }
}


size_t OPC_NAMING(Shape_Calc)( const OPC* src, OPC_NAMING(Pixel) transparent, bool bMask )
{
    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 )
{
    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;
}

size_t OPC_NAMING(Shape_Pack_Needs)( OPCShape* shape )
{
    /*
     * If we needed more space than DataSize, compression fails
     */
    return OPC_NAMING(Shape_DataSize)( shape );
}

size_t OPC_NAMING(Shape_Pack)( OPCShape* shape, void* buffer )
{
#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(ExportH)( const OPC* opc, FILE* fp, const char* szname )
{
    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 );
}

void OPC_NAMING(ExportC)( const OPC* opc, FILE* fp, const char* modifier, const char* szname, const char* szComment, ... )
{
    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 );
}

/*
 * TODO: 
 *  Export RGB data as macro that takes red,green,blue 0..255 levels: 
 *  RGB(ab,cd,ef) -> {0xab,0xcd,0xef}, or XLAT(0xab,0xcd,0xef)
 *  
 */

void OPC_NAMING(ExportCData)( const OPC* opc, FILE* fp, const char* szname )
{
#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(Shape_ExportH)( const OPCShape* shape, FILE* fp, const char* szname, bool bMask )
{
    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 );
}

void OPC_NAMING(Shape_ExportC)( const OPCShape* shape, FILE* fp, const char* modifier, const char* szname, bool bMask, const char* szComment, ... )
{
    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 )
{
    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 );
    }
}