gifutil.cpp

Go to the documentation of this file.

// $Header: /Camelot/winoil/gifutil.cpp 19    25/03/99 16:16 Markn $

// Contains useful routines for compressing a bitmap out to a GIF format file and
// routines to load that file back in.

/*
*/

#include "camtypes.h"
#include "ensure.h"
#include "fixmem.h"
#include "errors.h"
#include "progress.h"       // For hourglass stuff
//#include "resource.h"     // IDS_OUTOFMEMORY
//#include "accures.h"      // IDW_CANCELLEDBMPIMPORT
#include "gifutil.h"
//#include "outptgif.h"
//#include "andy.h"
//#include "dibconv.h"
//#include "string.h"           // memcpy
#include "camfiltr.h"       // BaseCamelotFilter

#define new CAM_DEBUG_NEW


CC_IMPLEMENT_MEMDUMP(Palette, CC_CLASS_MEMDUMP)
Palette::~Palette()
{
    if (m_pColours)
        delete [] m_pColours;
    m_pColours = NULL;          // ensure state correct
    m_nSize = 0;
}



Palette::Palette(const Palette& otherPalette)
{
    if (&otherPalette == this) return;

    if (otherPalette.m_nSize > m_nSize)
        delete [] m_pColours;
        m_pColours = new RGBQUAD[otherPalette.m_nSize];
        if (m_pColours == NULL)
        {
            m_bInitOK = FALSE;
            return;
        }
    m_nSize = otherPalette.m_nSize;
    memcpy(m_pColours, otherPalette.m_pColours, m_nSize);
    m_bInitOK = TRUE;
}

#define BitSet(byte, bit)      (((byte) & (bit)) == (bit))

// define the statics that we require
BOOL    GIFUtil::Interlace      = FALSE;    // Use interlace or not
int     GIFUtil::Transparent    = -1;       // colour or -1 = no transparency
UINT32  GIFUtil::m_Delay        = 0;        // Data member, to recieve a bitmaps Animation delay value
BOOL    GIFUtil::ZeroDataBlock  = FALSE;    // flag to say whether we have a zero length block or not 
int     GIFUtil::m_nCurrentBitmap = 0;
GIFDisposalMethod GIFUtil::m_Restore = GDM_LEAVE;   // Data member, to recieve a bitmaps' Animation  Restore value.

LPRGBQUAD   GIFUtil::lpGlobalPalette = NULL;        // pointer to temporary palette store
int         GIFUtil::GlobalPaletteSize = 0;         // size of the global palette found  
FilePos     GIFUtil::m_NextImageStartPosition = 0;  // Position in file of next image 
BOOL        GIFUtil::m_bImageRead = FALSE;          // Did we get something?

WORD        GIFUtil::m_GlobalWidth  = 0;            // The overall width from the GIF header
WORD        GIFUtil::m_GlobalHeight = 0;            // The overall height from the GIF header

/********************************************************************************************

>   GIFUtil::GIFUtil()

    Author:     Neville Humphrys
    Created:    29/6/95
    Purpose:    Default constructor for the class. 
    SeeAlso:    

********************************************************************************************/

//GIFUtil::GIFUtil()
//{
//}

/********************************************************************************************
>   GIFUtil::GIFUtil()

    Author:     Neville Humphrys
    Created:    29/6/95
    Purpose:    Default destructor for the class.
    SeeAlso:    

********************************************************************************************/

//GIFUtil::~GIFUtil()
//{
//}

/********************************************************************************************

>   static BOOL GIFUtil::ReadFromFile( CCLexFile *File, LPBITMAPINFO *Info, LPBYTE *Bits,
                                       int *TransColour, int& nBitmapToRead, 
                                       String_64 *ProgressString, BaseCamelotFilter *pFilter = NULL  )

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     File            A opened CCLexFile that can be read from. It should be positioned at the
                                start. Caller is responsible for closing it. The file needs to be in
                                Binary mode.
                nBitmapToRead   The number of the bitmap in the GIF that you wish to read.
                                If 1 then the GIF will be read from the beginning obtaining the
                                header information.
                                For any number other than 1 it should be noted that bitmaps can only
                                be read in an incremental sequence and that the first one must have
                                been read prior to any call with a non-1 value.
                ProgressString  allows the user to specify whether they require a progress hourglass or 
                                not. If NULL then none is shown, otherwise an progress bar is shown
                                using the text supplied. Defaults to NULL i.e. no progress bar.
                pFilter         is an alternative way of handling the progress bar, assume the
                                progress bar has been start and just call the IncProgressBarCount in 
                                BaseCamelotFilter to do the progress bar update.
                                Defaults to NULL i.e. no progress bar.
    Outputs:    Info points to a new LPBITMAPINFO struct and Bits points to the bytes.
                These can be freed up with FreeDIB.
                TransColour is either -1 == none or equal to the transparency colour found
                nBitmapToRead   Returns the number of the next bitmap that can be read from the GIF
                                or -1 if no further bitmaps exist.
    Returns:    TRUE if worked, FALSE if failed (error will be set accordingly but not reported)
    Purpose:    Reads a .gif file into memory decompressing it as it goes.
                ***Errors on 16-bit builds***
                A progress hourglass can be shown if required.
    Errors:     Calls SetError on FALSE returns.
    Scope:      Static, Public
    SeeAlso:    DIBUtil::ReadFromFile; AccusoftFilters::ReadFromFile;

********************************************************************************************/
BOOL GIFUtil::ReadFromFile( CCLexFile *File, LPBITMAPINFO *Info, LPBYTE *Bits,
                            int *TransColour, String_64 *ProgressString,
                            BaseCamelotFilter *pFilter )
{
    int nBitmap = 1;

    return (ReadFromFile( File, Info, Bits, TransColour, nBitmap, ProgressString, pFilter));
}

/**********************************************************************************************

static  BOOL GIFUtil::ReadFromFile( CCLexFile *File, LPBITMAPINFO *Info, LPBYTE *Bits,
                                    int *TransColour, int& nBitmapToRead, String_64 *ProgressString = NULL,
                                    BaseCamelotFilter *pFilter = NULL, UINT32* Delay=NULL,
                                    GIFDisposalMethod *Restore=NULL,
                                    UINT32 * pLeftOffset = NULL, UINT32 * pTopOffset = NULL,
                                    BOOL * pLocalPalette = NULL)
Author:         -
Created:        -
Inputs/Outputs  Refer to the above Function Header for a full explanation. 

*************************************************************************************************/

BOOL GIFUtil::ReadFromFile( CCLexFile *File, LPBITMAPINFO *Info, LPBYTE *Bits,
                            int *TransColour, int& nBitmapToRead, String_64 *ProgressString,
                            BaseCamelotFilter *pFilter, UINT32* Delay, GIFDisposalMethod *Restore,
                            UINT32 * pLeftOffset, UINT32 * pTopOffset,
                            BOOL * pLocalPalette)
{
    if ((nBitmapToRead > 1 && nBitmapToRead == m_nCurrentBitmap) || nBitmapToRead < 1)
    {
        ERROR3("GIFUtil::ReadFromFile() - can't read that bitmap");
        return FALSE;
    }

    *Info           = NULL;     // in case of early exit
    *Bits           = NULL;
    Transparent     = -1;
    *TransColour    = -1;       // in case of early exit set to none
    int Background  = 0;        // background colour number !!! not used !!!
    Interlace       = FALSE;    // set interlace to false by default

    // Must set the exception throwing flag to True and force reporting of errors to False.
    // This means that the caller must report an error if the function returns False.
    // Any calls to CCLexFile::GotError will now throw a file exception and should fall into
    // the catch handler at the end of the function.
    BOOL OldThrowingState = File->SetThrowExceptions( TRUE );
    BOOL OldReportingState = File->SetReportErrors( FALSE );

    // If the caller has specified a string then assume they require a progress bar
    // Start it up.
    if (ProgressString != NULL)
        BeginSlowJob(100, FALSE, ProgressString);

    try
    {
        // If we want the first bitmap we'll assume we're at the start of the file & read the header
        if (nBitmapToRead == 1)
        {
            // place to store the global palette, if present, for later use
            lpGlobalPalette         = NULL; // pointer to temporary palette store
            GlobalPaletteSize           = 0;    // size of the global palette found  

            GIFINFOHEADER Header;
            // This is really sizeof(GIFINFOHEADER) but this returns 14 instead of 13
            // as it rounds to the nearest word boundary
            const size_t HeaderSize = sizeof(char)* 6 + sizeof(WORD) * 2 + sizeof(BYTE) * 3;

            File->read( &Header, HeaderSize );
            if (File->bad())
                File->GotError( _R(IDE_FORMATNOTSUPPORTED) );

            // Just double check that the signature is correct, if not then fail immediately
            if (
                (strncmp(Header.giName, "GIF89a", 6) != 0) &&
                (strncmp(Header.giName, "GIF87a", 6) != 0)
            )
                File->GotError( _R(IDE_BADFORMAT) );

            // Note the overall size of the GIF from the header, may be the animation size
            m_GlobalWidth       = Header.giWidth;
            m_GlobalHeight      = Header.giHeight;
            // flags word consists of:-
            // - bit 7 colour table flag                = set if global colour table follows
            // - bits 6-4 colour resolution             = bpps - 1
            // - bit 3 sort flag                        = set global colour table sorted
            // - bits 3-0 size of global colour table   = size is 2^(value+1)
            int ColorResolution = (((Header.giFlags >> 4) & 0x07) + 1);
            GlobalPaletteSize   = 2 << (Header.giFlags & 0x07);
            Background          = Header.giBackground;
//          int AspectRatio     = Header.giAspect;

TRACEUSER("Neville",_T("Gif Global Width = %d Height = %d\n"), m_GlobalWidth, m_GlobalHeight);
TRACEUSER("Neville",_T("Gif ColorResolution = %d\n"), ColorResolution);

            // Check if we have a global colour map present or not, if so then read it in.
            if (BitSet(Header.giFlags, GLOBALCOLOURMAP))
            {
TRACEUSER("Neville",_T("Gif read global colour table size = %d\n"), GlobalPaletteSize);
                // Read in the global colour map into a palette structure for possible later use
                const size_t TotalPal = sizeof(RGBQUAD) * GlobalPaletteSize;
                lpGlobalPalette = (LPRGBQUAD)CCMalloc( TotalPal );
                if (lpGlobalPalette==NULL)
                    return FALSE;

                ReadColourMap(File, GlobalPaletteSize, lpGlobalPalette);
            }
            m_nCurrentBitmap = 0;
            m_NextImageStartPosition = 0;
        }

        // We now need to go through and process the data in this file which
        // should now consist off GIF blocks until we hit the end of file or
        // we have processed the lot.
        BOOL FileProcessed = FALSE;

        m_bImageRead = FALSE;
        unsigned char c;
        // Set up bad values so that the DIB alloc claim will fail if there
        // has been no GIFIMAGEBLOCK found
//      int Width           = 0;    // Width of bitmap  
//      int Height          = 0;    // Height of bitmap 
//      int BitsPerPixel    = 0;    //ColorResolution;  // Colour depth required

        if (m_NextImageStartPosition != 0)
        {
            File->seekIn(m_NextImageStartPosition, ios::beg);
            m_NextImageStartPosition = 0;
        }

        while (!File->eof() && !File->bad() && !FileProcessed)
        {
            // Get the next character in the stream and see what it indicates
            // comes next in the file
            // Use Get as this will read the EOF character (255) and exit via the
            // File->eof() test rather than Read which will throw an exception. 
            //File->read( &c, 1 );
            File->get( (char&)c );
            
            switch (c)
            {
                case ';':
                {
                    // GIF terminator
                    // Cannot assume that the terminator immediately follows the image data
                    // Might have some extensions following the image data.                      
                    FileProcessed = TRUE;
                    nBitmapToRead = -1;
                    break;
                }

                case '!': //EXTENSIONBLOCK:
                {
                    // Extension
                    ProcessExtension(File);
                    break;
                }
                
                case ',':
                {
                    // start of image character
                    if (m_bImageRead)   // another bitmap - save it for the next call to ReadFromFile()
                    {
                        if (m_NextImageStartPosition == 0)
                        {
                            // No transparency info for the next one so start here
                            m_NextImageStartPosition = File->tellIn() - 1;
                        }
                        ++nBitmapToRead;
                        FileProcessed = TRUE;
                        break;
                    }

                    UINT32 LeftOffset = 0;
                    UINT32 TopOffset = 0;
                    BOOL LocalPalette = FALSE;

                    // Should be followed by a GIFIMAGE BLOCK
                    ProcessImageBlock(File, Info, Bits, &LeftOffset, &TopOffset, &LocalPalette);
                    ++m_nCurrentBitmap;

                    if (nBitmapToRead == m_nCurrentBitmap)
                    {
                        m_bImageRead = TRUE;
                    }

                    // return the values back to the caller if it desired them
                    if (pLeftOffset)
                        *pLeftOffset = LeftOffset;
                    if (pTopOffset)
                        *pTopOffset = TopOffset;
                    if (pLocalPalette)
                        *pLocalPalette = LocalPalette;
                    break;
                }

                default:
                    // We have found something other than what we are expecting
                    // so fail with an error
                    //File->GotError( IDE_BADFORMAT );
                    // Cannot do this as some files have random bits
                    // e.g. galileo.gif has a random zero before the ;
                    //      colsec.gif has a rampant > at the end instead of ;
                    if (m_bImageRead)
                    {
                        // We've already got something so ignore anything else in case it goes
                        // completely wrong.
                        FileProcessed = TRUE;
                        nBitmapToRead = -1;
                    }
                    TRACE( _T("Unrecognized Character %x at %d\n"), (int)c, File->tellIn());

                    break;
            }
        }

        // If we reach here and the bitmap allocations are still null then no valid image
        // was found and so we should error now.
        // Might have just been a GIF file with extension tags in and no images!
        if (*Info == NULL || *Bits == NULL)
            File->GotError( _R(IDE_BADFORMAT) );

        // We read the desired bitmap but the EOF came along before we could try anything else
        // Signal this is the last bitmap
        if (m_bImageRead && File->eof())
        {
            TRACE( _T("GIF: Premature end of file") );
            nBitmapToRead = -1;
        }

        // Return the transparency/delay/restore found to the caller.
        *TransColour = Transparent;
        if (Delay)
        {
            *Delay = m_Delay;
        }
        if (Restore)
        {
            *Restore = m_Restore;
        }

        // Free up the bit of memory for a palette we grabbed, if present & no more images to read
        if (lpGlobalPalette && nBitmapToRead == -1)
        {
            CCFree(lpGlobalPalette);
            lpGlobalPalette = NULL;
        }

        // If started, then stop then progress bar
        if (ProgressString != NULL)
            EndSlowJob();

        // Must set the exception throwing and reporting flags back to their entry states
        File->SetThrowExceptions( OldThrowingState );
        File->SetReportErrors( OldReportingState );

        // er, we seem to have finished OK so say so
        return TRUE;
    }
    catch( CFileException e )
    {
        // catch our form of a file exception
        TRACE( _T("GIFUtil::ReadFromFile CC catch handler\n") );

        FreeDIB( *Info, *Bits );                            // free any alloced memory
        *Info = NULL;                                       // and NULL the pointers
        *Bits = NULL;
        
        // Free up the bit of memory for a palette we grabbed, if present
        if (lpGlobalPalette)
        {
            CCFree(lpGlobalPalette);
            lpGlobalPalette = NULL;
        }

        // If started, then stop then progress bar
        if (ProgressString != NULL)
            EndSlowJob();

        // Must set the exception throwing and reporting flags back to their entry states
        File->SetThrowExceptions( OldThrowingState );
        File->SetReportErrors( OldReportingState );

        return FALSE;
    }

    ERROR2( FALSE, "Escaped exception clause somehow" );
}


/********************************************************************************************

>   static BOOL GIFUtil::ProcessExtension(CCLexFile *fd)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
    Outputs:    -
    Returns:    True if worked ok, False otherwise.
    Purpose:    
    SeeAlso:    

********************************************************************************************/

BOOL GIFUtil::ProcessExtension(CCLexFile *fd)
{
    static char buf[256];

    // Get the type of this extension and then process it
    unsigned char ExtensionType;
    fd->read( &ExtensionType, 1 );

    switch (ExtensionType)
    {
        case TRANSPARENTBLOCK:
        {
            // The next image in the file might need to start here to get transparency
            // information. So remember the position
            m_NextImageStartPosition = fd->tellIn() - 2;

            // Graphic Control Extension
            // We have read in the identfier and the type of extension block so we
            // really need to read the data from that point onwards
            GIFTRANSBLOCK TransBlock;

            // This is really sizeof(GIFTRANSBLOCK) but this returns 14 instead of 13
            // as it rounds to the nearest word boundary
            const size_t TransBlockSize = sizeof(WORD) * 1 + sizeof(BYTE) * 6;
            fd->read( &(TransBlock.gtbBlockSize), TransBlockSize - 2);
            
            // Contains lots of random rubbish we are not interested in.            
            // Just skip to the crux of the matter and read in the transparency colour,
            // if the transparency flag is set.

            if (!m_bImageRead)
            {
                BOOL fTrans = TransBlock.gtbFlags & 0x1;  
                if (fTrans != 0)
                    Transparent = TransBlock.gtbTransparency;
                else
                {
                    Transparent = -1; // no transparency    
                }

                TRACEUSER("Neville", _T("ProcessExtension - transparent fTrans = %d Transparent = %d\n"), fTrans, Transparent );

                // Animation Restore\Delay values.
                m_Delay = TransBlock.gtbDelay;
                m_Restore = GIFDisposalMethod((TransBlock.gtbFlags >> 2) & 0x03);
            }

            return TRUE;
        }

        case PLAINTEXTBLOCK:
        {
            // We need to bin any transparency information we have since
            // "The scope of this [Graphic Control (TRANSPARENTBLOCK)] Extension is the 
            // graphic rendering block that follows it"

            if (m_bImageRead)
            {
                // We've read the image but don't need to start with any TRANSPARENT block
                // that might have been read after the image, so make sure we don't
                m_NextImageStartPosition = 0;
            }
            else
            {
                // We haven't read any image yet so just make sure no transparency
                Transparent = -1;
            }
            // ...and drop through
        }
        
        default:
            break;
    }

    // Must set this as otherwise, if this is after we have loaded an image then we have
    // the possibility that the zero block has been encountered and GetDataBlock will
    // always return 0, so force it not to. 
    ZeroDataBlock = FALSE;

    // If not recognised then read the rest of that extension
    while (GetDataBlock(fd, (unsigned char*) buf) != 0)
        ;

    return FALSE;
}

/********************************************************************************************

>   static BOOL GIFUtil::ReadColourMap(CCLexFile *fd, int number, LPRGBQUAD lpPalette)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
    Outputs:    -
    Returns:    True if worked ok, False otherwise.
    Purpose:    
    SeeAlso:    

********************************************************************************************/

BOOL GIFUtil::ReadColourMap(CCLexFile *fd, int number, LPRGBQUAD lpPalette)
{
    GIFRGBTRIPLE rgb;
    for (int i = 0; i < number; ++i)
    {
        fd->read( &rgb, sizeof(GIFRGBTRIPLE) );
        lpPalette->rgbBlue = rgb.grgbtBlue;
        lpPalette->rgbGreen = rgb.grgbtGreen;
        lpPalette->rgbRed = rgb.grgbtRed;
        lpPalette->rgbReserved = 0;
        lpPalette++;
    }
    
    return TRUE;
}



/********************************************************************************************

>   static int GIFUtil::GetDataBlock(CCLexFile *fd, unsigned char *buf)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
    Outputs:    -
    Returns:    Number of bytes read
    Purpose:    To read in a block of data from the specifed file. Reads a 1 byte count
                and then reads that many bytes in, as long as the count is non-zero.
                Any non-image calls must set ZeroDataBlock to False before calling this as
                otherwise it may just return zero. 
    SeeAlso:    

********************************************************************************************/

int GIFUtil::GetDataBlock(CCLexFile *fd, unsigned char *buf)
{
    unsigned char count;

    // Added, as if we encounter the zero block then that is the end of this image
    // and we should never read any more info from that image. (added 14/8/95)
    if (ZeroDataBlock)
        return 0;
    
    fd->read( &count, 1 );

    // If there is a count then read that many bytes in
    // If zero then this is a terminator so return that
    if (count == 0)
    {
        ZeroDataBlock = TRUE;
        // Fall through to return 0
    }
    else
    {
        ZeroDataBlock = FALSE;
        fd->read( buf, count );
        // fall through to return the number of bytes found
    }

    return count;
}

/********************************************************************************************

>   static int GIFUtil::GetCode(CCLexFile *fd, int code_size, int flag)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
                code_size
                flag            
    Outputs:    -
    Returns:    The code found.
    Purpose:    Returns the next code in the stream.
    SeeAlso:    

********************************************************************************************/

int GIFUtil::GetCode(CCLexFile *fd, int code_size, int flag)
{
    static unsigned char    buf[280];
    static int  curbit;
    static int  lastbit;
    static int  done;
    static int  last_byte;
    int i;
    int j;
    int ret;
    unsigned char   count;

    if (flag)
    {
        curbit = 0;
        lastbit = 0;
        done = FALSE;
        return 0;
    }

    if ( (curbit+code_size) >= lastbit)
    {
        if (done)
        {
            if (curbit >= lastbit)
            {
                /* Oh well */
            }                        
            return -1;
        }
        buf[0] = buf[last_byte-2];
        buf[1] = buf[last_byte-1];

        if ((count = GetDataBlock(fd, &buf[2])) == 0)
            done = TRUE;

        last_byte = 2 + count;
        curbit = (curbit - lastbit) + 16;
        lastbit = (2+count)*8 ;
    }

    ret = 0;
    for (i = curbit, j = 0; j < code_size; ++i, ++j)
        ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;

    curbit += code_size;

    return ret;
}


/********************************************************************************************

>   static int GIFUtil::LWZReadByte(CCLexFile *fd, int flag, int input_code_size)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd              pointer to a CCLexFile to read the data from
                flag
                input_code_size 
    Outputs:    -
    Returns:    The next LZW byte in the stream. 
    Purpose:    To read the next LZW byte from the stream.
    SeeAlso:    

********************************************************************************************/

int GIFUtil::LWZReadByte(CCLexFile *fd, int flag, int input_code_size)
{
    static int  fresh = FALSE;
    int         code;
    int         incode;
    static int  code_size;
    static int  set_code_size;
    static int  max_code;
    static int  max_code_size;
    static int  firstcode;
    static int  oldcode;
    static int  clear_code;
    static int  end_code;
    static int  table[2][(1<< MAX_LWZ_BITS)];
    static int  stack[(1<<(MAX_LWZ_BITS))*2];
    static int  *sp;
    int i;

    if (flag)
    {
        set_code_size = input_code_size;
        code_size = set_code_size+1;
        clear_code = 1 << set_code_size ;
        end_code = clear_code + 1;
        max_code_size = 2*clear_code;
        max_code = clear_code+2;

        GetCode(fd, 0, TRUE);

        fresh = TRUE;

        for (i = 0; i < clear_code; ++i)
        {
            table[0][i] = 0;
            table[1][i] = i;
        }
        for (; i < (1<<MAX_LWZ_BITS); ++i)
            table[0][i] = table[1][0] = 0;

        sp = stack;

        return 0;
    }
    else if (fresh)
    {
        fresh = FALSE;
        do
        {
            firstcode = oldcode = GetCode(fd, code_size, FALSE);
        } while (firstcode == clear_code);

        return firstcode;
    }

    if (sp > stack)
        return *--sp;

    while ((code = GetCode(fd, code_size, FALSE)) >= 0)
    {
        if (code == clear_code)
        {
            for (i = 0; i < clear_code; ++i)
            {
                   table[0][i] = 0;
                   table[1][i] = i;
            }

            for (; i < (1<<MAX_LWZ_BITS); ++i)
                   table[0][i] = table[1][i] = 0;

            code_size = set_code_size+1;
            max_code_size = 2*clear_code;
            max_code = clear_code+2;
            sp = stack;
            firstcode = oldcode = GetCode(fd, code_size, FALSE);

            return firstcode;
        }
        else if (code == end_code)
        {
            int             count;
            unsigned char   buf[260];

            if (ZeroDataBlock)
                return -2;

            while ((count = GetDataBlock(fd, buf)) > 0)
                ;

            if (count != 0)
                return -2;
        }

        incode = code;

        if (code >= max_code)
        {
            *sp++ = firstcode;
            code = oldcode;
        }

        while (code >= clear_code)
        {
            *sp++ = table[1][code];
            if (code == table[0][code])
            {
                /* Oh well */
            }
            code = table[0][code];
        }

        *sp++ = firstcode = table[1][code];

        if ((code = max_code) <(1<<MAX_LWZ_BITS))
        {
            table[0][code] = oldcode;
            table[1][code] = firstcode;
            ++max_code;
            if ((max_code >= max_code_size) && (max_code_size < (1<<MAX_LWZ_BITS)))
            {
                max_code_size *= 2;
                ++code_size;
            }
        }

        oldcode = incode;

        if (sp > stack)
            return *--sp;
    }
    return code;
}

/********************************************************************************************

>   static BOOL GIFUtil::ReadImage(CCLexFile *fd, LPBYTE pBitsData, int width, int height,
                                   BOOL interlace, BaseCamelotFilter *pFilter = NULL )

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
                pBitsData   pointer to the place to put the bitmap data, should have been
                            claimed so that it is the correct size to contain it.
                width       width of the bitmap in pixels
                height      height of the bitmap in pixels
                bpp         colour depth of the bitmap in bits per pixel
                interlace   flag to say if this data is interlaced or not.
                pFilter     is an alternative way of handling the progress bar, assume the
                            progress bar has been start and just call the IncProgressBarCount in 
                            BaseCamelotFilter to do the progress bar update.
                            Defaults to NULL i.e. no progress bar.
    Purpose:    The read the bitmap data into the specified buffer. It decompresses the
                data from the specified file and then puts the pixel data into the buffer.
                Copes with interlaced GIFs.
                Assumes progress hourglass has been started with 100.
    SeeAlso:    GIFUtil::ReadFromFile;

********************************************************************************************/

BOOL GIFUtil::ReadImage(CCLexFile *fd, LPBYTE pBitsData, int width, int height, int bpp,
                        BOOL interlace, BaseCamelotFilter *pFilter)
{
    ERROR2IF(pBitsData == NULL, FALSE, "GIFUtil::ReadImage given null pointer to bits data");
    ERROR2IF(bpp != 8 && bpp != 4 && bpp != 1, FALSE, "GIFUtil::ReadImage - bpp invalid");

    unsigned char c;      
    int v = 0;
    int xpos = 0;
    int ypos = 0;
    int pass = 0;
    int yposcount = 0;

    ZeroDataBlock = FALSE;
    
    // Work out how often we need to update the progress bar
    int UpdateEvery = 1;
    INT32 UpdateValue = 1;
    if (pFilter == NULL)
        UpdateEvery = height/100 + 1;
    else
    {
        // Ask the filter what the record size for this bitmap is and hence
        // what the allocation we have for progress bar updates are.
        // We will then have to update our progress bar by
        //  current scanline/total number of scanlines * allocation
        // so that we get update by a proportion of the value.
        // We can assume no interlacing as in native/web files this is turned off.
        INT32 RecordSize = pFilter->GetCurrentRecordSize();
        if (RecordSize == 0)
            RecordSize = 1;
        UpdateValue = RecordSize/height;
        UpdateEvery = 0;    // So it updates every time round the loop
    }
        
    int LastProgressUpdate = 0;
    
    // Work out the word/byte rounded line width rather than the pixel width
    INT32 WidthOfLine = DIBUtil::ScanlineSize( width, bpp );

    // Initialize the Compression routines
    fd->read( &c, 1 );
    ERROR3IF(c > GIFBITS,"Bad code size in GIFUtil ReadImage");
    
    if (LWZReadByte(fd, TRUE, c) < 0)
    {
        return FALSE;
    }

    while ((v = LWZReadByte(fd, FALSE, c)) >= 0 )
    {
        //GIFSetPixel(pBitsData, xpos, ypos, v);
        // Check that the specified pixel is within the bounds specified and that we
        // have a buffer to write to

//      if ( !(((ypos < 0) || (ypos >= height)) || ((xpos < 0) || (xpos >= width))) && pBitsData )
//      {
            // Our DIBs are the wrong way up so we must output the data from the last 
            // line of the image and go up to the start
            // -1 as height = 1 .. Height whereas y goes from 0 .. Height - 1
            // Use the word/byte rounded line width rather than the pixel width
            if (bpp == 8)
            {
                // If 8 bpp then just use the whole byte straight
                LPBYTE pData = pBitsData + xpos + ((height - 1 - ypos)  * WidthOfLine);
                *(pData) = v;
            }
            else if (bpp == 4)
            {
                // 4bpp so we must put the data into either the high or low nibble.
                // This will be dependent on whether we are on an odd or even pixel.
                // So test the LSBit of the curx, if set we will be odd.
                // Only move onto next byte every other pixel hence curx/2.
                LPBYTE pData = pBitsData + xpos/2 + ((height - 1 - ypos)  * WidthOfLine);
                // Get whole present byte 
                if (xpos & 1)
                    *(pData) = ((*(pData)) & 0xF0) | (v & 0x0F);    // add into low nibble 
                else
                    *(pData) = ((*(pData)) & 0x0F) | ((v << 4) & 0xF0); // add into top nibble
            }
            else if (bpp == 1)
            {
                // 1bpp so we must put the data into either the high or low nibble.
                // This will be dependent on whether we are on an odd or even pixel.
                // So test the LSBit of the curx, if set we will be odd.
                // Only move onto next byte every other pixel hence curx/2.
                LPBYTE pOutputBitmap = pBitsData + (xpos / 8) + ((height - 1 - ypos)  * WidthOfLine);
                // Get whole present byte
                UINT32 BitPosition = 7 - (xpos % 8);
                BYTE SetBit = v << BitPosition;
                BYTE Mask = ~(1 << BitPosition);

                *pOutputBitmap = ((*pOutputBitmap) & Mask) | SetBit;
            }
            else
            {
                ERROR3IF(TRUE, "GIFUtil::ReadImage() - Invalid bpp");
                // bad bpp but should not get here so do nothing
            }
            
//      }
        
        ++xpos;
        
        BOOL JobState = TRUE;
        // if we have reached the end of the current line then work out the next
        // line that we must do, if interlacing is on 
        if (xpos >= width)
        {
            xpos = 0;
            
            // Do different filing methods depending on whether interlaced on non-interlaced.
            if (interlace)
            {
                // We are interlaced so learn not to count properly!
                switch (pass)
                {
                    case 0:
                    case 1:
                        ypos += 8; break;
                    case 2:
                        ypos += 4; break;
                    case 3:
                        ypos += 2; break;
                }

                while (ypos >= height && pass <= 3)
                {
                    ++pass;
                    switch (pass)
                    {
                        case 1:
                            ypos = 4;
                            break;
                        case 2:
                            ypos = 2;
                            break;
                        case 3:
                            ypos = 1;
                            break;
                        default:
                            goto finish;
                    }
                }
            }
            else
            {
                // Non-interlaced case
                ++ypos;
            }

            yposcount++;
            
            if (yposcount > (LastProgressUpdate + UpdateEvery))
            {
                // Note the update point so that we know the next one  
                LastProgressUpdate = yposcount;

                // Now update the progress display, started with 100
                if (pFilter == NULL)
                    JobState = ContinueSlowJob( (long)(100 * yposcount/height) );
                else
                    JobState = pFilter->IncProgressBarCount(UpdateValue);

                // If JobState is False then the user has probably pressed escape and we should
                // immediately stop what we are doing. 
                if (!JobState)
                {
                    fd->GotError( _R(IDW_CANCELLEDBMPIMPORT) ); // Expects error set on cancel
                    return FALSE;
                }
            }
        }

        if (ypos >= height)
            break;
    }

finish:
    if (LWZReadByte(fd, FALSE, c) >= 0)
    {
        /* Ignore extra */
    }

    // Everything seemed to go ok 
    return TRUE;
}


/********************************************************************************************

>   static void GIFUtil::GIFSetPixel(LPBYTE pBitsData, int x, int y, int colour)

    Author:     Neville Humphrys
    Created:    29/6/95
    Inputs:     
    Outputs:    
    Returns:    
    Purpose:    
    SeeAlso:    

********************************************************************************************/

//void GIFUtil::GIFSetPixel(LPBYTE pBitsData, int x, int y, int colour)
//{
//  // Check that the specified pixel is within the bounds specified and that we
//  // have a buffer to write to
//  if ( !(((y < 0) || (y >= Height)) || ((x < 0) || (x >= Width))) && pBitsData )
//  {
//      // Our DIBs are the wrong way up so we must output the data from the last 
//      // line of the image and go up to the start
//      // -1 as height = 1 .. Height whereas y goes from 0 .. Height - 1
//      // Use the word/byte rounded line width rather than the pixel width
//      LPBYTE pData = pBitsData + x + ((Height - 1 - y)  * WidthOfLine);
//      *(pData) = colour;
//  }
//}

/********************************************************************************************

>   static BOOL ReadColourMap(CCLexFile *fd, Palette& NewPalette)

    Author:     Colin
    Created:    29/6/95
    Inputs:     fd          pointer to a CCLexFile to read the data from
    Outputs:    -
    Returns:    True if worked ok, False otherwise.
    Purpose:    
    SeeAlso:    

********************************************************************************************/
BOOL Palette::SetSize(const UINT32 nNewSize)
{
    if (nNewSize == m_nSize) return TRUE;
    if (m_pColours != NULL)
    {
        delete [] m_pColours;
    }
    if (nNewSize == 0)
    {
        m_pColours = NULL;
        return TRUE;
    }
    m_pColours = new RGBQUAD[nNewSize];
//  m_StartIterator;
//  m_EndIterator;
    return (m_pColours == NULL) ? FALSE : TRUE;
}


static BOOL ReadColourMap(CCLexFile *fd, Palette& NewPalette)
{
    GIFRGBTRIPLE rgb;
    PaletteIterator PalColour;
    for (PalColour = NewPalette.Start(); PalColour < NewPalette.End(); ++PalColour)
    {
        fd->read(&rgb, sizeof(GIFRGBTRIPLE));

        PalColour.SetBlue(rgb.grgbtBlue);
        PalColour.SetGreen(rgb.grgbtGreen);
        PalColour.SetRed(rgb.grgbtRed);
        PalColour.SetTransparent(0);
    }
    
    return TRUE;
}

/********************************************************************************************

>   BOOL GIFUtil::ProcessHeader()

    Author:     Colin
    Created:    11/06/96
    Inputs:     
    Outputs:    
    Returns:    
    Purpose:    
    SeeAlso:    

********************************************************************************************/
BOOL GIFUtil::ProcessHeader()
{
    ERROR3("GIFUtil::ProcessHeader : not implemented");
    if (TRUE) return FALSE;

    CCLexFile* File;
    GIFINFOHEADER Header;
    // This is really sizeof(GIFINFOHEADER) but this returns 14 instead of 13
    // as it rounds to the nearest word boundary
    const size_t HeaderSize = sizeof(char)* 6 + sizeof(WORD) * 2 + sizeof(BYTE) * 3;
//  const size_t HeaderSize = (sizeof(GIFINFOHEADER)* sizeof(WORD)) / sizeof(WORD);

    File->read( &Header, HeaderSize );
    if (File->bad())
        File->GotError( _R(IDE_FORMATNOTSUPPORTED) );

    // Just double check that the signature is correct, if not then fail immediately
    if (
        ( strncmp( Header.giName, "GIF89a", 6 ) != 0 ) &&
        ( strncmp( Header.giName, "GIF87a", 6 ) != 0 )
        )
        File->GotError( _R(IDE_BADFORMAT) );

    // Note the overall size of the GIF from the header, may be the animation size
    m_GlobalWidth       = Header.giWidth;
    m_GlobalHeight      = Header.giHeight;
//  int ColorResolution = (((Header.giFlags >> 4) & 0x07) + 1);
//  int AspectRatio     = Header.giAspect;

    UINT32 nGlobalPaletteSize   = 2 << (Header.giFlags & 0x07);
//  m_nBackground = Header.giBackground;

    // Check if we have a global colour map present or not, if so then read it in.
    if (BitSet(Header.giFlags, GLOBALCOLOURMAP))
    {
        // Read in the global colour map into a palette structure for possible later use
        if (m_GlobalPalette.SetSize(nGlobalPaletteSize) == FALSE)
        {
            ERROR3("GIFUtil::ProcessHeader() - can't renew palette");
            return FALSE;
        }
		::ReadColourMap(File, m_GlobalPalette);
    }
    m_nCurrentBitmap = 0;
}


/********************************************************************************************

>   BOOL GIFUtil::ProcessImageBlock(CCLexFile* File, LPBITMAPINFO *Info, LPBYTE *Bits,
                                    UINT32 * pLeftOffset = NULL, UINT32 * pTopOffset = NULL,
                                    BOOL * pLocalPalette = NULL)

    Author:     Colin
    Created:    11/06/96
    Inputs:     
    Outputs:    
    Returns:    
    Purpose:    
    SeeAlso:    

********************************************************************************************/
BOOL GIFUtil::ProcessImageBlock(CCLexFile* File, LPBITMAPINFO *Info, LPBYTE *Bits,
                                UINT32 * pLeftOffset, UINT32 * pTopOffset, BOOL * pLocalPalette)
{
    GIFIMAGEBLOCK ImageBlock;
    // This is really sizeof(GIFIMAGEBLOCK) but this returns 10 instead of 9 as it rounds to the nearest word boundary
    const size_t ImageHeaderSize = sizeof(WORD) * 4 + sizeof(BYTE) * 1;
    File->read( &ImageBlock, ImageHeaderSize );

    // Check whether we there is a local colour map or not
    // If there is use that otherwise use the global one read in earlier        
    BOOL UseLocalColourMap = BitSet(ImageBlock.gibFlags, LOCALCOLOURMAP);
    int LocalColourMapSize = 1 << ((ImageBlock.gibFlags & 0x07) + 1);
                    
    int Width   = ImageBlock.gibWidth;  //LM_to_uint(buf[4],buf[5]);
    int Height  = ImageBlock.gibDepth;  //LM_to_uint(buf[6],buf[7]);
    
    // If the user asked for them and they are within the animation's boundaries
    // Then return the offsets to the user
    if (pLeftOffset && ImageBlock.gibLeft < m_GlobalWidth)
        *pLeftOffset = ImageBlock.gibLeft;
    if (pTopOffset && ImageBlock.gibTop < m_GlobalHeight)
        *pTopOffset = ImageBlock.gibTop;
    if (pLocalPalette)
        *pLocalPalette = UseLocalColourMap;
    
    Interlace       = BitSet(ImageBlock.gibFlags, INTERLACE);

    int ColoursInPalette = UseLocalColourMap ? LocalColourMapSize : GlobalPaletteSize;
    int BitsPerPixel;
    if (ColoursInPalette > 16)
        BitsPerPixel = 8;
    else if (ColoursInPalette > 2)
        BitsPerPixel = 4;
    else
        BitsPerPixel = 1;

TRACEUSER("Neville", _T("Colours in palette = %d bpp = %d\n"), ColoursInPalette, BitsPerPixel );

    // Allocate the space that we require for this bitmap
    // Sanity checks on the file that we have been asked to load.
    if ((BitsPerPixel != 8) && (BitsPerPixel != 4) && (BitsPerPixel != 1) && (Width != 0) && (Height != 0))
        File->GotError( _R(IDE_FORMATNOTSUPPORTED) );

    // we know what sort of bitmap we are - lets allocate a new LPBITMAPINFO and some bytes
    *Info = AllocDIB( Width, Height, BitsPerPixel, Bits, NULL );

    if (*Info == NULL || *Bits == NULL)
        File->GotError( _R(IDS_OUT_OF_MEMORY) );

    // if the clrUsed field is zero, put a sensible value in it

    BOOL ok = FALSE;
    if (UseLocalColourMap)
    {
        // There is a local colour table specified so read this directly into
        // the palette of the DIB
        if (LocalColourMapSize > (1 << BitsPerPixel))
                File->GotError( _R(IDE_BADFORMAT) );

        ReadColourMap(File, LocalColourMapSize, (*Info)->bmiColors);
    }
    else
    {
        // No local palette so copy the global palette into the palette of the DIB, if 
        if (lpGlobalPalette && ((*Info)->bmiColors))
        {
            const size_t TotalPal = sizeof(RGBQUAD) * GlobalPaletteSize;
            memcpy((*Info)->bmiColors, lpGlobalPalette, TotalPal);
        }
    }

    // Note how many colours are in the palette
    (*Info)->bmiHeader.biClrUsed = ColoursInPalette;

    ok = ReadImage(File, *Bits, Width, Height, BitsPerPixel, Interlace);
    // Now read all that lovely data in
    if (!ok)
        File->GotError( _R(IDE_BADFORMAT) );

    return TRUE;
}

---