[wxWidgets.git] / src / common / gifdecod.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        gifdecod.cpp
// Purpose:     wxGIFDecoder, GIF reader for wxImage and wxAnimation
// Author:      Guillermo Rodriguez Garcia <guille@iies.es>
// Version:     3.04
// RCS-ID:      $Id$
// Copyright:   (c) Guillermo Rodriguez Garcia
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "gifdecod.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#  pragma hdrstop
#endif

#ifndef WX_PRECOMP
#  include "wx/defs.h"
#endif

#if wxUSE_STREAMS && wxUSE_GIF

#include <stdlib.h>
#include <string.h>
#include "wx/gifdecod.h"


//---------------------------------------------------------------------------
// wxGIFDecoder constructor and destructor
//---------------------------------------------------------------------------

wxGIFDecoder::wxGIFDecoder(wxInputStream *s, bool anim)
{
    m_f    = s;
    m_anim = anim;

    m_background = -1;
    m_screenw = 0;
    m_screenh = 0;

    m_pimage  = NULL;
    m_pfirst  = NULL;
    m_plast   = NULL;
    m_image   = 0;
    m_nimages = 0;
}

wxGIFDecoder::~wxGIFDecoder()
{
    Destroy();
}

void wxGIFDecoder::Destroy()
{
    GIFImage *pimg, *paux;

    pimg = m_pfirst;

    while (pimg != NULL)
    {
        paux = pimg->next;
        free(pimg->p);
        free(pimg->pal);
        delete pimg;
        pimg = paux;
    }

    m_pimage  = NULL;
    m_pfirst  = NULL;
    m_plast   = NULL;
    m_image   = 0;
    m_nimages = 0;
}


//---------------------------------------------------------------------------
// Convert this image to a wxImage object
//---------------------------------------------------------------------------

// This function was designed by Vaclav Slavik

bool wxGIFDecoder::ConvertToImage(wxImage *image) const
{
    unsigned char *src, *dst, *pal;
    unsigned long i;
    int      transparent;

    /* just in case... */
    image->Destroy();

    /* create the image */
    image->Create(GetWidth(), GetHeight());

    if (!image->Ok())
        return FALSE;

    pal = GetPalette();
    src = GetData();
    dst = image->GetData();
    transparent = GetTransparentColour();

    /* set transparent colour mask */
    if (transparent != -1)
    {
        for (i = 0; i < 256; i++)
        {
            if ((pal[3 * i + 0] == 255) &&
                (pal[3 * i + 1] == 0) &&
                (pal[3 * i + 2] == 255))
            {
                pal[3 * i + 2] = 254;
            }
        }

        pal[3 * transparent + 0] = 255,
        pal[3 * transparent + 1] = 0,
        pal[3 * transparent + 2] = 255;

        image->SetMaskColour(255, 0, 255);
    }
    else
        image->SetMask(FALSE);

    // Set the palette
    // Palette creation not yet implemented on wxGTK
#ifndef __WXGTK__
    if (pal)
    {
        unsigned char* r = new unsigned char[256];
        unsigned char* g = new unsigned char[256];
        unsigned char* b = new unsigned char[256];
        for (i = 0; i < 256; i++)
        {
            r[i] = pal[3*i + 0];
            g[i] = pal[3*i + 1];
            b[i] = pal[3*i + 2];
        }
        image->SetPalette(wxPalette(256, r, g, b));
        delete[] r; delete[] g; delete[] b;
    }
#endif

    /* copy image data */
    for (i = 0; i < (GetWidth() * GetHeight()); i++, src++)
    {
        *(dst++) = pal[3 * (*src) + 0];
        *(dst++) = pal[3 * (*src) + 1];
        *(dst++) = pal[3 * (*src) + 2];
    }

    return TRUE;
}


//---------------------------------------------------------------------------
// Data accessors
//---------------------------------------------------------------------------

// Get data for current frame

int wxGIFDecoder::GetFrameIndex() const         { return m_image; }
unsigned char* wxGIFDecoder::GetData() const    { return (m_pimage->p); }
unsigned char* wxGIFDecoder::GetPalette() const { return (m_pimage->pal); }
unsigned int wxGIFDecoder::GetWidth() const     { return (m_pimage->w); }
unsigned int wxGIFDecoder::GetHeight() const    { return (m_pimage->h); }
unsigned int wxGIFDecoder::GetTop() const       { return (m_pimage->top); }
unsigned int wxGIFDecoder::GetLeft() const      { return (m_pimage->left); }
int wxGIFDecoder::GetTransparentColour() const  { return (m_pimage->transparent); }
int wxGIFDecoder::GetDisposalMethod() const     { return (m_pimage->disposal); }
long wxGIFDecoder::GetDelay() const             { return (m_pimage->delay); }

// Get global data

unsigned int wxGIFDecoder::GetLogicalScreenWidth() const    { return m_screenw; }
unsigned int wxGIFDecoder::GetLogicalScreenHeight() const   { return m_screenh; }
int wxGIFDecoder::GetBackgroundColour() const   { return m_background; }
int wxGIFDecoder::GetNumberOfFrames() const     { return m_nimages; }
bool wxGIFDecoder::IsAnimation() const          { return (m_nimages > 1); }


//---------------------------------------------------------------------------
// Functions to move through the animation
//---------------------------------------------------------------------------

bool wxGIFDecoder::GoFirstFrame()
{
    if (!IsAnimation())
        return FALSE;

    m_image = 1;
    m_pimage = m_pfirst;
    return TRUE;
}

bool wxGIFDecoder::GoLastFrame()
{
    if (!IsAnimation())
        return FALSE;

    m_image = m_nimages;
    m_pimage = m_plast;
    return TRUE;
}

bool wxGIFDecoder::GoNextFrame(bool cyclic)
{
    if (!IsAnimation())
        return FALSE;

    if ((m_image < m_nimages) || (cyclic))
    {
        m_pimage = m_pimage->next;
        m_image++;

        if (!m_pimage)
        {
            m_image = 1;
            m_pimage = m_pfirst;
        }

        return TRUE;
    }
    else
        return FALSE;
}

bool wxGIFDecoder::GoPrevFrame(bool cyclic)
{
    if (!IsAnimation())
        return FALSE;

    if ((m_image > 1) || (cyclic))
    {
        m_pimage = m_pimage->prev;
        m_image--;

        if (!m_pimage)
        {
            m_image = m_nimages;
            m_pimage = m_plast;
        }

        return TRUE;
    }
    else
        return FALSE;
}

bool wxGIFDecoder::GoFrame(int which)
{
    int i;

    if (!IsAnimation())
        return FALSE;

    if ((which >= 1) && (which <= m_nimages))
    {
        m_pimage = m_pfirst;

        for (i = 1; i < which; i++)
            m_pimage = m_pimage->next;

        return TRUE;
    }
    else
        return FALSE;
}


//---------------------------------------------------------------------------
// GIF reading and decoding
//---------------------------------------------------------------------------

// getcode:
//  Reads the next code from the file stream, with size 'bits'
//
int wxGIFDecoder::getcode(int bits, int ab_fin)
{
    unsigned int mask;          /* bit mask */
    unsigned int code;          /* code (result) */


    /* get remaining bits from last byte read */
    mask = (1 << bits) - 1;
    code = (m_lastbyte >> (8 - m_restbits)) & mask;

    /* keep reading new bytes while needed */
    while (bits > m_restbits)
    {
        /* if no bytes left in this block, read the next block */
        if (m_restbyte == 0)
        {
            m_restbyte = (unsigned char)m_f->GetC();

            /* Some encoders are a bit broken: instead of issuing
             * an end-of-image symbol (ab_fin) they come up with
             * a zero-length subblock!! We catch this here so
             * that the decoder sees an ab_fin code.
             */
            if (m_restbyte == 0)
            {
                code = ab_fin;
                break;
            }

            /* prefetch data */
            m_f->Read((void *) m_buffer, m_restbyte);
            m_bufp = m_buffer;
        }

        /* read next byte and isolate the bits we need */
        m_lastbyte = (unsigned char) (*m_bufp++);
        mask       = (1 << (bits - m_restbits)) - 1;
        code       = code + ((m_lastbyte & mask) << m_restbits);
        m_restbyte--;

        /* adjust total number of bits extracted from the buffer */
        m_restbits = m_restbits + 8;
    }

    /* find number of bits remaining for next code */
    m_restbits = (m_restbits - bits);

    return code;
}


// dgif:
//  GIF decoding function. The initial code size (aka root size)
//  is 'bits'. Supports interlaced images (interl == 1).
//
int wxGIFDecoder::dgif(GIFImage *img, int interl, int bits)
{
#ifdef __WXMAC__
    int *ab_prefix = new int[4096];        /* alphabet (prefixes) */
    int *ab_tail = new int[4096];          /* alphabet (tails) */
    int *stack = new int[4096];            /* decompression stack */
#else
    int ab_prefix[4096];        /* alphabet (prefixes) */
    int ab_tail[4096];          /* alphabet (tails) */
    int stack[4096];            /* decompression stack */
#endif
    int ab_clr;                 /* clear code */
    int ab_fin;                 /* end of info code */
    int ab_bits;                /* actual symbol width, in bits */
    int ab_free;                /* first free position in alphabet */
    int ab_max;                 /* last possible character in alphabet */
    int pass;                   /* pass number in interlaced images */
    int pos;                    /* index into decompresion stack */
    unsigned int x, y;          /* position in image buffer */

    int code, readcode, lastcode, abcabca;

    /* these won't change */
    ab_clr = (1 << bits);
    ab_fin = (1 << bits) + 1;

    /* these will change through the decompression proccess */
    ab_bits  = bits + 1;
    ab_free  = (1 << bits) + 2;
    ab_max   = (1 << ab_bits) - 1;
    lastcode = -1;
    abcabca  = -1;
    pass     = 1;
    pos = x = y = 0;

    /* reset decoder vars */
    m_restbits = 0;
    m_restbyte = 0;
    m_lastbyte = 0;

    do
    {
        /* get next code */
        readcode = code = getcode(ab_bits, ab_fin);

        /* end of image? */
        if (code == ab_fin) break;

        /* reset alphabet? */
        if (code == ab_clr)
        {
            /* reset main variables */
            ab_bits  = bits + 1;
            ab_free  = (1 << bits) + 2;
            ab_max   = (1 << ab_bits) - 1;
            lastcode = -1;
            abcabca  = -1;

            /* skip to next code */
            continue;
        }

        /* unknown code: special case (like in ABCABCA) */
        if (code >= ab_free)
        {
            code = lastcode;            /* take last string */
            stack[pos++] = abcabca;     /* add first character */
        }

        /* build the string for this code in the stack */
        while (code > ab_clr)
        {
            stack[pos++] = ab_tail[code];
            code         = ab_prefix[code];
        }
        stack[pos] = code;              /* push last code into the stack */
        abcabca    = code;              /* save for special case */

        /* make new entry in alphabet (only if NOT just cleared) */
        if (lastcode != -1)
        {
            ab_prefix[ab_free] = lastcode;
            ab_tail[ab_free]   = code;
            ab_free++;

            if ((ab_free > ab_max) && (ab_bits < 12))
            {
                ab_bits++;
                ab_max = (1 << ab_bits) - 1;
            }
        }

        /* dump stack data to the buffer */
        while (pos >= 0)
        {
            (img->p)[x + (y * (img->w))] = (char)stack[pos--];

            if (++x >= (img->w))
            {
                x = 0;

                if (interl)
                {
                    /* support for interlaced images */
                    switch (pass)
                    {
                        case 1: y += 8; break;
                        case 2: y += 8; break;
                        case 3: y += 4; break;
                        case 4: y += 2; break;
                    }
                    if (y >= (img->h))
                    {
                        switch (++pass)
                        {
                            case 2: y = 4; break;
                            case 3: y = 2; break;
                            case 4: y = 1; break;
                        }
                    }
                }
                else
                {
                    /* non-interlaced */
                    y++;
                }
            }
        }

        pos = 0;
        lastcode = readcode;
    }
    while (code != ab_fin);

#ifdef __WXMAC__
    delete [] ab_prefix ;       
    delete [] ab_tail ;       
    delete [] stack ;       
#endif
    return 0;
}


// CanRead:
//  Returns TRUE if the file looks like a valid GIF, FALSE otherwise.
//
bool wxGIFDecoder::CanRead()
{
    unsigned char buf[3];

    m_f->Read(buf, 3);
    m_f->SeekI(-3, wxFromCurrent);

    return (memcmp(buf, "GIF", 3) == 0);
}


// ReadGIF:
//  Reads and decodes one or more GIF images, depending on whether
//  animated GIF support is enabled. Can read GIFs with any bit
//  size (color depth), but the output images are always expanded
//  to 8 bits per pixel. Also, the image palettes always contain
//  256 colors, although some of them may be unused. Returns wxGIF_OK
//  (== 0) on success, or an error code if something fails (see
//  header file for details)
//
int wxGIFDecoder::ReadGIF()
{
    int           ncolors, bits, interl, transparent, disposal, i;
    long          size;
    long          delay;
    unsigned char type = 0;
    unsigned char pal[768];
    unsigned char buf[16];
    GIFImage      **ppimg, *pimg, *pprev;

    /* check GIF signature */
    if (!CanRead())
        return wxGIF_INVFORMAT;

    /* check for animated GIF support (ver. >= 89a) */
    m_f->Read(buf, 6);

    if (memcmp(buf + 3, "89a", 3) < 0)
        m_anim = FALSE;

    /* read logical screen descriptor block (LSDB) */
    m_f->Read(buf, 7);
    m_screenw = buf[0] + 256 * buf[1];
    m_screenh = buf[2] + 256 * buf[3];

    /* load global color map if available */
    if ((buf[4] & 0x80) == 0x80)
    {
        m_background = buf[5];

        ncolors = 2 << (buf[4] & 0x07);
        m_f->Read(pal, 3 * ncolors);
    }

    /* transparent colour, disposal method and delay default to unused */
    transparent = -1;
    disposal = -1;
    delay = -1;

    /* read images */
    ppimg = &m_pfirst;
    pprev = NULL;
    pimg  = NULL;

    bool done = FALSE;

    while(!done)
    {
        type = (unsigned char)m_f->GetC();

        /* end of data? */
        if (type == 0x3B)
        {
            done = TRUE;
        }
        else
        /* extension block? */
        if (type == 0x21)
        {
            if (((unsigned char)m_f->GetC()) == 0xF9)
            /* graphics control extension, parse it */
            {
                m_f->Read(buf, 6);

                /* read delay and convert from 1/100 of a second to ms */
                delay = 10 * (buf[2] + 256 * buf[3]);

                /* read transparent colour index, if used */
                if (buf[1] & 0x01)
                    transparent = buf[4];

                /* read disposal method */
                disposal = (buf[1] & 0x1C) - 1;
            }
            else
            /* other extension, skip */
            {
                while ((i = (unsigned char)m_f->GetC()) != 0)
                {
                    m_f->SeekI(i, wxFromCurrent);
                }
            }
        }
        else
        /* image descriptor block? */
        if (type == 0x2C)
        {
            /* allocate memory for IMAGEN struct */
            pimg = (*ppimg) = new GIFImage();

            if (pimg == NULL)
            {
                Destroy();
                return wxGIF_MEMERR;
            }

            /* fill in the data */
            m_f->Read(buf, 9);
            pimg->left = buf[4] + 256 * buf[5];
            pimg->top = buf[4] + 256 * buf[5];
            pimg->w = buf[4] + 256 * buf[5];
            pimg->h = buf[6] + 256 * buf[7];
            interl = ((buf[8] & 0x40)? 1 : 0);
            size = pimg->w * pimg->h;

            pimg->transparent = transparent;
            pimg->disposal = disposal;
            pimg->delay = delay;
            pimg->next = NULL;
            pimg->prev = pprev;
            pprev = pimg;
            ppimg = &pimg->next;

            /* allocate memory for image and palette */
            pimg->p   = (unsigned char *) malloc((size_t)size);
            pimg->pal = (unsigned char *) malloc(768);

            if ((!pimg->p) || (!pimg->pal))
            {
                Destroy();
                return wxGIF_MEMERR;
            }

            /* load local color map if available, else use global map */
            if ((buf[8] & 0x80) == 0x80)
            {
                ncolors = 2 << (buf[8] & 0x07);
                m_f->Read(pimg->pal, 3 * ncolors);
            }
            else
                memcpy(pimg->pal, pal, 768);

            /* get initial code size from first byte in raster data */
            bits = (unsigned char)m_f->GetC();

            /* decode image */
            dgif(pimg, interl, bits);
            m_nimages++;

            /* if this is not an animated GIF, exit after first image */
            if (!m_anim)
                done = TRUE;
        }
    }

    /* setup image pointers */
    if (m_nimages != 0)
    {
        m_image = 1;
        m_plast = pimg;
        m_pimage = m_pfirst;
    }

    /* try to read to the end of the stream */
    while (type != 0x3B)
    {
        type = (unsigned char)m_f->GetC();

        if (type == 0x21)
        {
            /* extension type */
            (void) m_f->GetC();

            /* skip all data */
            while ((i = (unsigned char)m_f->GetC()) != 0)
            {
                m_f->SeekI(i, wxFromCurrent);
            }
        }
        else if (type == 0x2C)
        {
            /* image descriptor block */
            m_f->Read(buf, 9);

            /* local color map */
            if ((buf[8] & 0x80) == 0x80)
            {
                ncolors = 2 << (buf[8] & 0x07);
                m_f->SeekI(3 * ncolors, wxFromCurrent);
            }

            /* initial code size */
            (void) m_f->GetC();

            /* skip all data */
            while ((i = (unsigned char)m_f->GetC()) != 0)
            {
                m_f->SeekI(i, wxFromCurrent);
            }
        }
        else if ((type != 0x3B) && (type != 00)) /* testing */
        {
            /* images are OK, but couldn't read to the end of the stream */
            return wxGIF_TRUNCATED;
        }
    }

    return wxGIF_OK;
}

#endif // wxUSE_STREAMS && wxUSE_GIF
Commit	Line	Data
464122b6 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gifdecod.cpp
	3	// Purpose: wxGIFDecoder, GIF reader for wxImage and wxAnimation
	4	// Author: Guillermo Rodriguez Garcia <guille@iies.es>
9d0e21da GRG	5	// Version: 3.04
9d0e21da GRG	6	// RCS-ID: $Id$
464122b6 JS	7	// Copyright: (c) Guillermo Rodriguez Garcia
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifdef __GNUG__
	12	#pragma implementation "gifdecod.h"
	13	#endif
	14
	15	// For compilers that support precompilation, includes "wx.h".
	16	#include "wx/wxprec.h"
	17
	18	#ifdef __BORLANDC__
	19	# pragma hdrstop
	20	#endif
	21
	22	#ifndef WX_PRECOMP
7be110e3	23	# include "wx/defs.h"
464122b6 JS	24	#endif
464122b6 JS	25
7be110e3	26	#if wxUSE_STREAMS && wxUSE_GIF
464122b6 JS	27
	28	#include <stdlib.h>
	29	#include <string.h>
464122b6	30	#include "wx/gifdecod.h"
2ce0a6e2	31
464122b6 JS	32
	33	//---------------------------------------------------------------------------
	34	// wxGIFDecoder constructor and destructor
	35	//---------------------------------------------------------------------------
	36
	37	wxGIFDecoder::wxGIFDecoder(wxInputStream *s, bool anim)
	38	{
9742d3cc	39	m_f = s;
464122b6 JS	40	m_anim = anim;
	41
	42	m_background = -1;
	43	m_screenw = 0;
	44	m_screenh = 0;
	45
	46	m_pimage = NULL;
	47	m_pfirst = NULL;
	48	m_plast = NULL;
	49	m_image = 0;
	50	m_nimages = 0;
	51	}
	52
	53	wxGIFDecoder::~wxGIFDecoder()
	54	{
	55	Destroy();
	56	}
	57
	58	void wxGIFDecoder::Destroy()
	59	{
e4b8154a	60	GIFImage pimg, paux;
464122b6 JS	61
	62	pimg = m_pfirst;
	63
	64	while (pimg != NULL)
	65	{
	66	paux = pimg->next;
	67	free(pimg->p);
	68	free(pimg->pal);
e4b8154a	69	delete pimg;
464122b6 JS	70	pimg = paux;
464122b6 JS	71	}
9742d3cc GRG	72
	73	m_pimage = NULL;
	74	m_pfirst = NULL;
	75	m_plast = NULL;
	76	m_image = 0;
	77	m_nimages = 0;
464122b6 JS	78	}
	79
	80
	81	//---------------------------------------------------------------------------
	82	// Convert this image to a wxImage object
	83	//---------------------------------------------------------------------------
	84
	85	// This function was designed by Vaclav Slavik
	86
	87	bool wxGIFDecoder::ConvertToImage(wxImage *image) const
	88	{
	89	unsigned char src, dst, *pal;
	90	unsigned long i;
	91	int transparent;
	92
3c87527e GRG	93	/* just in case... */
	94	image->Destroy();
	95
464122b6 JS	96	/* create the image */
	97	image->Create(GetWidth(), GetHeight());
	98
	99	if (!image->Ok())
	100	return FALSE;
	101
	102	pal = GetPalette();
	103	src = GetData();
	104	dst = image->GetData();
	105	transparent = GetTransparentColour();
	106
	107	/* set transparent colour mask */
	108	if (transparent != -1)
	109	{
	110	for (i = 0; i < 256; i++)
	111	{
	112	if ((pal[3 * i + 0] == 255) &&
	113	(pal[3 * i + 1] == 0) &&
	114	(pal[3 * i + 2] == 255))
	115	{
	116	pal[3 * i + 2] = 254;
	117	}
	118	}
	119
	120	pal[3 * transparent + 0] = 255,
	121	pal[3 * transparent + 1] = 0,
	122	pal[3 * transparent + 2] = 255;
	123
	124	image->SetMaskColour(255, 0, 255);
	125	}
	126	else
	127	image->SetMask(FALSE);
	128
3f4fc796	129	// Set the palette
b3eb36df JS	130	// Palette creation not yet implemented on wxGTK
b3eb36df JS	131	#ifndef __WXGTK__
3f4fc796 JS	132	if (pal)
	133	{
	134	unsigned char* r = new unsigned char[256];
	135	unsigned char* g = new unsigned char[256];
	136	unsigned char* b = new unsigned char[256];
	137	for (i = 0; i < 256; i++)
	138	{
	139	r[i] = pal[3*i + 0];
	140	g[i] = pal[3*i + 1];
	141	b[i] = pal[3*i + 2];
	142	}
	143	image->SetPalette(wxPalette(256, r, g, b));
	144	delete[] r; delete[] g; delete[] b;
	145	}
b3eb36df	146	#endif
3f4fc796	147
464122b6 JS	148	/* copy image data */
	149	for (i = 0; i < (GetWidth() * GetHeight()); i++, src++)
	150	{
	151	(dst++) = pal[3 (*src) + 0];
	152	(dst++) = pal[3 (*src) + 1];
	153	(dst++) = pal[3 (*src) + 2];
	154	}
	155
	156	return TRUE;
	157	}
	158
2ce0a6e2	159
464122b6 JS	160	//---------------------------------------------------------------------------
	161	// Data accessors
	162	//---------------------------------------------------------------------------
	163
	164	// Get data for current frame
	165
	166	int wxGIFDecoder::GetFrameIndex() const { return m_image; }
	167	unsigned char* wxGIFDecoder::GetData() const { return (m_pimage->p); }
	168	unsigned char* wxGIFDecoder::GetPalette() const { return (m_pimage->pal); }
	169	unsigned int wxGIFDecoder::GetWidth() const { return (m_pimage->w); }
	170	unsigned int wxGIFDecoder::GetHeight() const { return (m_pimage->h); }
	171	unsigned int wxGIFDecoder::GetTop() const { return (m_pimage->top); }
	172	unsigned int wxGIFDecoder::GetLeft() const { return (m_pimage->left); }
	173	int wxGIFDecoder::GetTransparentColour() const { return (m_pimage->transparent); }
	174	int wxGIFDecoder::GetDisposalMethod() const { return (m_pimage->disposal); }
	175	long wxGIFDecoder::GetDelay() const { return (m_pimage->delay); }
	176
	177	// Get global data
	178
	179	unsigned int wxGIFDecoder::GetLogicalScreenWidth() const { return m_screenw; }
	180	unsigned int wxGIFDecoder::GetLogicalScreenHeight() const { return m_screenh; }
	181	int wxGIFDecoder::GetBackgroundColour() const { return m_background; }
	182	int wxGIFDecoder::GetNumberOfFrames() const { return m_nimages; }
	183	bool wxGIFDecoder::IsAnimation() const { return (m_nimages > 1); }
	184
	185
	186	//---------------------------------------------------------------------------
	187	// Functions to move through the animation
	188	//---------------------------------------------------------------------------
	189
	190	bool wxGIFDecoder::GoFirstFrame()
	191	{
	192	if (!IsAnimation())
	193	return FALSE;
	194
	195	m_image = 1;
	196	m_pimage = m_pfirst;
	197	return TRUE;
	198	}
	199
	200	bool wxGIFDecoder::GoLastFrame()
	201	{
	202	if (!IsAnimation())
	203	return FALSE;
	204
	205	m_image = m_nimages;
	206	m_pimage = m_plast;
	207	return TRUE;
	208	}
	209
	210	bool wxGIFDecoder::GoNextFrame(bool cyclic)
	211	{
	212	if (!IsAnimation())
	213	return FALSE;
	214
	215	if ((m_image < m_nimages) \|\| (cyclic))
	216	{
	217	m_pimage = m_pimage->next;
	218	m_image++;
	219
	220	if (!m_pimage)
	221	{
	222	m_image = 1;
	223	m_pimage = m_pfirst;
224	}
225
226	return TRUE;
227	}
228	else
229	return FALSE;
2ce0a6e2	230	}
464122b6 JS	231
	232	bool wxGIFDecoder::GoPrevFrame(bool cyclic)
	233	{
	234	if (!IsAnimation())
	235	return FALSE;
	236
	237	if ((m_image > 1) \|\| (cyclic))
	238	{
	239	m_pimage = m_pimage->prev;
	240	m_image--;
	241
	242	if (!m_pimage)
	243	{
	244	m_image = m_nimages;
	245	m_pimage = m_plast;
	246	}
	247
	248	return TRUE;
	249	}
	250	else
	251	return FALSE;
	252	}
	253
	254	bool wxGIFDecoder::GoFrame(int which)
	255	{
	256	int i;
	257
	258	if (!IsAnimation())
	259	return FALSE;
	260
	261	if ((which >= 1) && (which <= m_nimages))
	262	{
	263	m_pimage = m_pfirst;
	264
	265	for (i = 1; i < which; i++)
	266	m_pimage = m_pimage->next;
	267
	268	return TRUE;
	269	}
	270	else
	271	return FALSE;
	272	}
	273
	274
	275	//---------------------------------------------------------------------------
	276	// GIF reading and decoding
	277	//---------------------------------------------------------------------------
	278
	279	// getcode:
	280	// Reads the next code from the file stream, with size 'bits'
	281	//
	282	int wxGIFDecoder::getcode(int bits, int ab_fin)
	283	{
	284	unsigned int mask; /* bit mask */
	285	unsigned int code; /* code (result) */
	286
	287
	288	/* get remaining bits from last byte read */
	289	mask = (1 << bits) - 1;
	290	code = (m_lastbyte >> (8 - m_restbits)) & mask;
	291
	292	/* keep reading new bytes while needed */
	293	while (bits > m_restbits)
	294	{
295	/* if no bytes left in this block, read the next block */
296	if (m_restbyte == 0)
297	{
298	m_restbyte = (unsigned char)m_f->GetC();
299
300	/* Some encoders are a bit broken: instead of issuing
301	* an end-of-image symbol (ab_fin) they come up with
302	* a zero-length subblock!! We catch this here so
303	* that the decoder sees an ab_fin code.
304	*/
305	if (m_restbyte == 0)
306	{
307	code = ab_fin;
308	break;
309	}
8708a10f GRG	310
	311	/* prefetch data */
	312	m_f->Read((void *) m_buffer, m_restbyte);
	313	m_bufp = m_buffer;
464122b6 JS	314	}
	315
	316	/* read next byte and isolate the bits we need */
8708a10f	317	m_lastbyte = (unsigned char) (*m_bufp++);
464122b6 JS	318	mask = (1 << (bits - m_restbits)) - 1;
	319	code = code + ((m_lastbyte & mask) << m_restbits);
	320	m_restbyte--;
	321
	322	/* adjust total number of bits extracted from the buffer */
	323	m_restbits = m_restbits + 8;
	324	}
2ce0a6e2	325
464122b6 JS	326	/* find number of bits remaining for next code */
	327	m_restbits = (m_restbits - bits);
	328
	329	return code;
	330	}
	331
	332
	333	// dgif:
	334	// GIF decoding function. The initial code size (aka root size)
	335	// is 'bits'. Supports interlaced images (interl == 1).
	336	//
e4b8154a	337	int wxGIFDecoder::dgif(GIFImage *img, int interl, int bits)
464122b6	338	{
7d610b90 SC	339	#ifdef __WXMAC__
	340	int ab_prefix = new int[4096]; / alphabet (prefixes) */
	341	int ab_tail = new int[4096]; / alphabet (tails) */
	342	int stack = new int[4096]; / decompression stack */
	343	#else
464122b6 JS	344	int ab_prefix[4096]; /* alphabet (prefixes) */
	345	int ab_tail[4096]; /* alphabet (tails) */
	346	int stack[4096]; /* decompression stack */
7d610b90	347	#endif
464122b6 JS	348	int ab_clr; /* clear code */
	349	int ab_fin; /* end of info code */
	350	int ab_bits; /* actual symbol width, in bits */
	351	int ab_free; /* first free position in alphabet */
	352	int ab_max; /* last possible character in alphabet */
	353	int pass; /* pass number in interlaced images */
	354	int pos; /* index into decompresion stack */
	355	unsigned int x, y; /* position in image buffer */
	356
	357	int code, readcode, lastcode, abcabca;
	358
	359	/* these won't change */
	360	ab_clr = (1 << bits);
	361	ab_fin = (1 << bits) + 1;
	362
	363	/* these will change through the decompression proccess */
	364	ab_bits = bits + 1;
	365	ab_free = (1 << bits) + 2;
	366	ab_max = (1 << ab_bits) - 1;
	367	lastcode = -1;
	368	abcabca = -1;
	369	pass = 1;
	370	pos = x = y = 0;
	371
8708a10f	372	/* reset decoder vars */
464122b6 JS	373	m_restbits = 0;
	374	m_restbyte = 0;
	375	m_lastbyte = 0;
	376
	377	do
	378	{
	379	/* get next code */
	380	readcode = code = getcode(ab_bits, ab_fin);
	381
	382	/* end of image? */
	383	if (code == ab_fin) break;
	384
	385	/* reset alphabet? */
	386	if (code == ab_clr)
	387	{
	388	/* reset main variables */
	389	ab_bits = bits + 1;
	390	ab_free = (1 << bits) + 2;
	391	ab_max = (1 << ab_bits) - 1;
	392	lastcode = -1;
	393	abcabca = -1;
	394
	395	/* skip to next code */
	396	continue;
	397	}
	398
	399	/* unknown code: special case (like in ABCABCA) */
	400	if (code >= ab_free)
	401	{
	402	code = lastcode; /* take last string */
	403	stack[pos++] = abcabca; /* add first character */
	404	}
	405
	406	/* build the string for this code in the stack */
	407	while (code > ab_clr)
	408	{
	409	stack[pos++] = ab_tail[code];
	410	code = ab_prefix[code];
	411	}
	412	stack[pos] = code; /* push last code into the stack */
	413	abcabca = code; /* save for special case */
	414
	415	/* make new entry in alphabet (only if NOT just cleared) */
	416	if (lastcode != -1)
	417	{
	418	ab_prefix[ab_free] = lastcode;
	419	ab_tail[ab_free] = code;
	420	ab_free++;
	421
	422	if ((ab_free > ab_max) && (ab_bits < 12))
	423	{
	424	ab_bits++;
	425	ab_max = (1 << ab_bits) - 1;
	426	}
	427	}
	428
	429	/* dump stack data to the buffer */
	430	while (pos >= 0)
	431	{
	432	(img->p)[x + (y * (img->w))] = (char)stack[pos--];
	433
	434	if (++x >= (img->w))
	435	{
	436	x = 0;
437
438	if (interl)
439	{
440	/* support for interlaced images */
441	switch (pass)
442	{
443	case 1: y += 8; break;
444	case 2: y += 8; break;
445	case 3: y += 4; break;
446	case 4: y += 2; break;
447	}
448	if (y >= (img->h))
449	{
450	switch (++pass)
451	{
452	case 2: y = 4; break;
453	case 3: y = 2; break;
454	case 4: y = 1; break;
455	}
456	}
457	}
458	else
459	{
460	/* non-interlaced */
461	y++;
462	}
463	}
464	}
465
466	pos = 0;
467	lastcode = readcode;
468	}
469	while (code != ab_fin);
470
7d610b90 SC	471	#ifdef __WXMAC__
	472	delete [] ab_prefix ;
	473	delete [] ab_tail ;
	474	delete [] stack ;
	475	#endif
464122b6 JS	476	return 0;
	477	}
	478
	479
3c87527e GRG	480	// CanRead:
	481	// Returns TRUE if the file looks like a valid GIF, FALSE otherwise.
	482	//
	483	bool wxGIFDecoder::CanRead()
	484	{
	485	unsigned char buf[3];
	486
3c87527e	487	m_f->Read(buf, 3);
700ec454	488	m_f->SeekI(-3, wxFromCurrent);
3c87527e GRG	489
	490	return (memcmp(buf, "GIF", 3) == 0);
	491	}
	492
	493
464122b6 JS	494	// ReadGIF:
	495	// Reads and decodes one or more GIF images, depending on whether
	496	// animated GIF support is enabled. Can read GIFs with any bit
	497	// size (color depth), but the output images are always expanded
	498	// to 8 bits per pixel. Also, the image palettes always contain
8141573c	499	// 256 colors, although some of them may be unused. Returns wxGIF_OK
e4b8154a GRG	500	// (== 0) on success, or an error code if something fails (see
e4b8154a GRG	501	// header file for details)
464122b6 JS	502	//
	503	int wxGIFDecoder::ReadGIF()
	504	{
	505	int ncolors, bits, interl, transparent, disposal, i;
	506	long size;
	507	long delay;
3ca6a5f0	508	unsigned char type = 0;
464122b6 JS	509	unsigned char pal[768];
464122b6 JS	510	unsigned char buf[16];
e4b8154a	511	GIFImage *ppimg, pimg, *pprev;
464122b6	512
3c87527e GRG	513	/* check GIF signature */
3c87527e GRG	514	if (!CanRead())
e4b8154a	515	return wxGIF_INVFORMAT;
464122b6	516
8141573c	517	/* check for animated GIF support (ver. >= 89a) */
464122b6 JS	518	m_f->Read(buf, 6);
464122b6 JS	519
464122b6 JS	520	if (memcmp(buf + 3, "89a", 3) < 0)
	521	m_anim = FALSE;
	522
	523	/* read logical screen descriptor block (LSDB) */
	524	m_f->Read(buf, 7);
	525	m_screenw = buf[0] + 256 * buf[1];
	526	m_screenh = buf[2] + 256 * buf[3];
	527
	528	/* load global color map if available */
	529	if ((buf[4] & 0x80) == 0x80)
	530	{
	531	m_background = buf[5];
	532
	533	ncolors = 2 << (buf[4] & 0x07);
	534	m_f->Read(pal, 3 * ncolors);
	535	}
	536
	537	/* transparent colour, disposal method and delay default to unused */
	538	transparent = -1;
	539	disposal = -1;
	540	delay = -1;
	541
	542	/* read images */
	543	ppimg = &m_pfirst;
	544	pprev = NULL;
	545	pimg = NULL;
	546
8141573c GRG	547	bool done = FALSE;
	548
	549	while(!done)
464122b6 JS	550	{
	551	type = (unsigned char)m_f->GetC();
	552
	553	/* end of data? */
	554	if (type == 0x3B)
8141573c GRG	555	{
	556	done = TRUE;
	557	}
	558	else
464122b6 JS	559	/* extension block? */
	560	if (type == 0x21)
	561	{
	562	if (((unsigned char)m_f->GetC()) == 0xF9)
	563	/* graphics control extension, parse it */
	564	{
	565	m_f->Read(buf, 6);
	566
	567	/* read delay and convert from 1/100 of a second to ms */
	568	delay = 10 * (buf[2] + 256 * buf[3]);
	569
	570	/* read transparent colour index, if used */
	571	if (buf[1] & 0x01)
	572	transparent = buf[4];
	573
	574	/* read disposal method */
	575	disposal = (buf[1] & 0x1C) - 1;
	576	}
	577	else
	578	/* other extension, skip */
2ce0a6e2	579	{
464122b6 JS	580	while ((i = (unsigned char)m_f->GetC()) != 0)
464122b6 JS	581	{
464122b6 JS	582	m_f->SeekI(i, wxFromCurrent);
	583	}
	584	}
	585	}
8141573c	586	else
464122b6 JS	587	/* image descriptor block? */
	588	if (type == 0x2C)
	589	{
	590	/* allocate memory for IMAGEN struct */
e4b8154a	591	pimg = (*ppimg) = new GIFImage();
464122b6 JS	592
	593	if (pimg == NULL)
	594	{
	595	Destroy();
e4b8154a	596	return wxGIF_MEMERR;
464122b6 JS	597	}
	598
	599	/* fill in the data */
	600	m_f->Read(buf, 9);
	601	pimg->left = buf[4] + 256 * buf[5];
	602	pimg->top = buf[4] + 256 * buf[5];
	603	pimg->w = buf[4] + 256 * buf[5];
	604	pimg->h = buf[6] + 256 * buf[7];
	605	interl = ((buf[8] & 0x40)? 1 : 0);
	606	size = pimg->w * pimg->h;
	607
	608	pimg->transparent = transparent;
	609	pimg->disposal = disposal;
	610	pimg->delay = delay;
	611	pimg->next = NULL;
	612	pimg->prev = pprev;
	613	pprev = pimg;
	614	ppimg = &pimg->next;
	615
	616	/* allocate memory for image and palette */
13111b2a	617	pimg->p = (unsigned char *) malloc((size_t)size);
464122b6 JS	618	pimg->pal = (unsigned char *) malloc(768);
	619
	620	if ((!pimg->p) \|\| (!pimg->pal))
	621	{
	622	Destroy();
e4b8154a	623	return wxGIF_MEMERR;
464122b6 JS	624	}
	625
	626	/* load local color map if available, else use global map */
	627	if ((buf[8] & 0x80) == 0x80)
	628	{
	629	ncolors = 2 << (buf[8] & 0x07);
	630	m_f->Read(pimg->pal, 3 * ncolors);
	631	}
	632	else
	633	memcpy(pimg->pal, pal, 768);
	634
	635	/* get initial code size from first byte in raster data */
	636	bits = (unsigned char)m_f->GetC();
	637
	638	/* decode image */
	639	dgif(pimg, interl, bits);
464122b6	640	m_nimages++;
464122b6	641
8141573c GRG	642	/* if this is not an animated GIF, exit after first image */
	643	if (!m_anim)
	644	done = TRUE;
	645	}
464122b6 JS	646	}
464122b6 JS	647
8141573c	648	/* setup image pointers */
464122b6 JS	649	if (m_nimages != 0)
	650	{
	651	m_image = 1;
	652	m_plast = pimg;
	653	m_pimage = m_pfirst;
	654	}
	655
8141573c GRG	656	/* try to read to the end of the stream */
	657	while (type != 0x3B)
	658	{
	659	type = (unsigned char)m_f->GetC();
	660
	661	if (type == 0x21)
	662	{
	663	/* extension type */
	664	(void) m_f->GetC();
	665
	666	/* skip all data */
	667	while ((i = (unsigned char)m_f->GetC()) != 0)
	668	{
	669	m_f->SeekI(i, wxFromCurrent);
	670	}
	671	}
	672	else if (type == 0x2C)
	673	{
	674	/* image descriptor block */
	675	m_f->Read(buf, 9);
	676
	677	/* local color map */
	678	if ((buf[8] & 0x80) == 0x80)
	679	{
	680	ncolors = 2 << (buf[8] & 0x07);
9742d3cc	681	m_f->SeekI(3 * ncolors, wxFromCurrent);
8141573c GRG	682	}
	683
	684	/* initial code size */
	685	(void) m_f->GetC();
	686
	687	/* skip all data */
	688	while ((i = (unsigned char)m_f->GetC()) != 0)
	689	{
	690	m_f->SeekI(i, wxFromCurrent);
	691	}
	692	}
9742d3cc	693	else if ((type != 0x3B) && (type != 00)) /* testing */
8141573c GRG	694	{
	695	/* images are OK, but couldn't read to the end of the stream */
	696	return wxGIF_TRUNCATED;
	697	}
	698	}
	699
e4b8154a	700	return wxGIF_OK;
464122b6 JS	701	}
464122b6 JS	702
7be110e3	703	#endif // wxUSE_STREAMS && wxUSE_GIF