src/common/imaggif.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        imaggif.cpp
// Purpose:     wxGIFHandler
// Author:      Guillermo Rodriguez Garcia
//              wxWindows adaptation by Vaclav Slavik
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

/*
   We don't put pragma implement in this file because it is already present in
   src/common/image.cpp
*/

// 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

#include "wx/image.h"
#include "wx/wfstream.h"
#include "wx/module.h"
#include "wx/log.h"

IMPLEMENT_DYNAMIC_CLASS(wxGIFHandler,wxImageHandler)

#if wxUSE_STREAMS

/*

FOLLOWING CODE IS BY G.R.G. :
(except wxInputStream stuff)

*/

/************************************************************************
  READGIF.H - Reads a GIF file
 ------------------------------------------------------------------------
  Guillermo Rodriguez Garcia
  <guille@iies.es>

  Version: 2.1
*************************************************************************/


typedef struct
{
    int w;                  /* width */
    int h;                  /* height */
    int transparent;        /* transparent color (-1 = none) */
    unsigned char *p;       /* bitmap */
    unsigned char *pal;     /* palette */
} IMAGEN;


/************************************************************************
  READGIF.C - Reads a GIF file
 ------------------------------------------------------------------------
  Guillermo Rodriguez Garcia
  <guille@iies.es>

  Version: 2.1
*************************************************************************/


#include <stdlib.h>
#include <string.h>


/* error codes */
#define E_OK        0               /* everything was OK */
#define E_ARCHIVO   -1              /* error opening file */
#define E_FORMATO   -2              /* error in gif header */
#define E_MEMORIA   -3              /* error allocating memory */


/* This class binding is by VS, so all bugs in it are mine ;-) */

class gifDecoder
{
    private:
        /* globals */
        int            restbits;            /* remaining valid bits */
        unsigned int   restbyte;            /* remaining bytes in this block */
        unsigned int   lastbyte;            /* last byte read */

        wxInputStream  *f;                  /* input file */

	public:
		gifDecoder(wxInputStream *s) { f = s; }
		int getcode(int bits);
		int dgif(IMAGEN *img, int interl, int bits);
		int readgif(IMAGEN *img);
};


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


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

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

        /* read next byte and isolate the bits we need */
        lastbyte = (unsigned char)f->GetC();
        mask     = (1 << (bits - restbits)) - 1;
        code     = code + ((lastbyte & mask) << restbits);
        restbyte--;

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

    /* find number of bits reamining for next code */
    restbits = (restbits - bits);

    return code;
}


/* dgif:
 *  GIF decoding function. The initial code size (aka root size)
 *  is 'bits'. Supports interlaced images (interl == 1).
 */
int gifDecoder::dgif(IMAGEN *img, int interl, int bits)
{
    int ab_prefix[4096];        /* alphabet (prefixes) */
    int ab_tail[4096];          /* alphabet (tails) */
    int stack[4096];            /* decompression stack */

    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 */
    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 static globals */
    restbits = 0;
    restbyte = 0;
    lastbyte = 0;

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

        /* 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);

    return 0;
}


/* readgif:
 *  Reads a GIF image from the file with filename 'nombre' in the
 *  IMAGEN structure pointed by 'img'. Can read GIFs with any bit
 *  size (color depth), but the output image is always expanded
 *  to 8 bits per pixel. Also, the image palette always contains
 *  256 colors, although some of them may be unused. Returns E_OK
 *  (== 0) on success, or an error code if something fails. Error
 *  codes are E_ARCHIVO, E_FORMATO, E_MEMORIA (see above).
 */
int gifDecoder::readgif(IMAGEN *img)
{
    int             size, ncolors, bits, interl, i;
    unsigned char   pal[768];
    unsigned char   buf[16];


    /* read header and logical screen descriptor block (LSDB) */
    f->Read(buf, 13);

    /* check GIF signature */
    if (memcmp(buf, "GIF", 3) != 0) return E_FORMATO;

    /* load global color map if available */
    if ((buf[10] & 0x80) == 0x80)
    {
        ncolors = 2 << (buf[10] & 0x07);
        f->Read(pal, 3 * ncolors);
    }

    /* assume no transparent color */
    img->transparent = -1;

    /* skip most extensions */
    while (((unsigned char)f->GetC()) == 0x21)               /* separator */
    {
        if (((unsigned char)f->GetC()) == 0xF9)              /* graphic control ext. */
        {
            f->Read(buf, 6);
            if (buf[1] & 0x01)
                img->transparent = buf[4];
        }
        else
            while ((i = (unsigned char)f->GetC()) != 0)    /* byte count */
                f->SeekI(i, wxFromCurrent);
    }

    /* read image descriptor block (IDB) */
    f->Read(buf, 9);
    img->w = buf[4] + 256 * buf[5];
    img->h = buf[6] + 256 * buf[7];
    size   = img->w * img->h;
    interl = ((buf[8] & 0x40)? 1 : 0);

    /* load local color map if available */
    if ((buf[8] & 0x80) == 0x80)
    {
        ncolors = 2 << (buf[8] & 0x07);
        f->Read(pal, 3 * ncolors);
    }

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

    /* allocate memory for image and palette */
    if ((img->p   = (unsigned char*) malloc(size)) == NULL) return E_MEMORIA;
    if ((img->pal = (unsigned char*) malloc(768))  == NULL) return E_MEMORIA;

    /* shift palette to fit VGA 6-bit format */
    for (i = 0; i < 768; i++)
        (img->pal)[i] = (unsigned char)pal[i]; /* >> 2 not in wxWin */

    /* decode GIF */
    dgif(img, interl, bits);

    /* finish successfully :-) */
    return E_OK;
}


/*

FOLLOWING CODE IS BY V.S. :

*/

//-----------------------------------------------------------------------------
// wxGIFHandler
//-----------------------------------------------------------------------------

bool wxGIFHandler::LoadFile( wxImage *image, wxInputStream& stream )
{
    unsigned char *ptr, *src, *pal;
    IMAGEN igif;
    int i;
    gifDecoder *decod;

    image->Destroy();

    decod = new gifDecoder(&stream);

    if (decod->readgif(&igif) != E_OK) {
        wxLogDebug(_T("Error reading GIF"));
        delete decod;
        return FALSE;
    }
    delete decod;

    image->Create(igif.w, igif.h);
    if (!image->Ok()) {
        free(igif.pal);
        free(igif.p);
        return FALSE;
    }

    ptr = image->GetData();
    src = igif.p;
    pal = igif.pal;

    if (igif.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 * (igif.transparent) + 0] = 255,
        pal[3 * (igif.transparent) + 1] = 0,
        pal[3 * (igif.transparent) + 2] = 255;
        image->SetMaskColour(255, 0, 255);
    }
    else image->SetMask(FALSE);

    for (i = 0; i < igif.w * igif.h; i++, src++) {
        *(ptr++) = pal[3 * (*src) + 0];
        *(ptr++) = pal[3 * (*src) + 1];
        *(ptr++) = pal[3 * (*src) + 2];
    }

    free(igif.pal);
    free(igif.p);
    return TRUE;
}

bool wxGIFHandler::SaveFile( wxImage * WXUNUSED(image),
                             wxOutputStream& WXUNUSED(stream) )
{
    wxLogDebug(_T("wxGIFHandler is read-only!!"));
    return FALSE;
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: imaggif.cpp
	3	// Purpose: wxGIFHandler
	4	// Author: Guillermo Rodriguez Garcia
	5	// wxWindows adaptation by Vaclav Slavik
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	/*
	10	We don't put pragma implement in this file because it is already present in
	11	src/common/image.cpp
	12	*/
	13
	14	// For compilers that support precompilation, includes "wx.h".
	15	#include <wx/wxprec.h>
	16
	17	#ifdef __BORLANDC__
	18	#pragma hdrstop
	19	#endif
	20
	21	#ifndef WX_PRECOMP
	22	#include "wx/defs.h"
	23	#endif
	24
	25	#include "wx/image.h"
	26	#include "wx/wfstream.h"
	27	#include "wx/module.h"
	28	#include "wx/log.h"
	29
	30	IMPLEMENT_DYNAMIC_CLASS(wxGIFHandler,wxImageHandler)
	31
	32	#if wxUSE_STREAMS
	33
	34	/*
	35
	36	FOLLOWING CODE IS BY G.R.G. :
	37	(except wxInputStream stuff)
	38
	39	*/
	40
	41	/************************************************************************
	42	READGIF.H - Reads a GIF file
	43	------------------------------------------------------------------------
	44	Guillermo Rodriguez Garcia
	45	<guille@iies.es>
	46
	47	Version: 2.1
	48	*************************************************************************/
	49
	50
	51	typedef struct
	52	{
	53	int w; /* width */
	54	int h; /* height */
	55	int transparent; /* transparent color (-1 = none) */
	56	unsigned char p; / bitmap */
	57	unsigned char pal; / palette */
	58	} IMAGEN;
	59
	60
	61
	62	/************************************************************************
	63	READGIF.C - Reads a GIF file
	64	------------------------------------------------------------------------
	65	Guillermo Rodriguez Garcia
	66	<guille@iies.es>
	67
	68	Version: 2.1
	69	*************************************************************************/
	70
	71
	72	#include <stdlib.h>
	73	#include <string.h>
	74
	75
	76	/* error codes */
	77	#define E_OK 0 /* everything was OK */
	78	#define E_ARCHIVO -1 /* error opening file */
	79	#define E_FORMATO -2 /* error in gif header */
	80	#define E_MEMORIA -3 /* error allocating memory */
	81
	82
	83	/* This class binding is by VS, so all bugs in it are mine ;-) */
	84
	85	class gifDecoder
	86	{
	87	private:
	88	/* globals */
	89	int restbits; /* remaining valid bits */
	90	unsigned int restbyte; /* remaining bytes in this block */
	91	unsigned int lastbyte; /* last byte read */
	92
	93	wxInputStream f; / input file */
	94
	95	public:
	96	gifDecoder(wxInputStream *s) { f = s; }
	97	int getcode(int bits);
	98	int dgif(IMAGEN *img, int interl, int bits);
	99	int readgif(IMAGEN *img);
	100	};
	101
	102
	103
	104	/* getcode:
	105	* Reads the next code from the file, with size 'bits'
	106	*/
	107	int gifDecoder::getcode(int bits)
	108	{
	109	unsigned int mask; /* bit mask */
	110	unsigned int code; /* code (result) */
	111
	112
	113	/* get remaining bits from last byte read */
	114	mask = (1 << bits) - 1;
	115	code = (lastbyte >> (8 - restbits)) & mask;
	116
	117	/* keep reading new bytes while needed */
	118	while (bits > restbits)
	119	{
	120	/* if no bytes left in this block, read the next block */
	121	if (restbyte == 0)
	122	restbyte = (unsigned char)f->GetC();
	123
	124	/* read next byte and isolate the bits we need */
	125	lastbyte = (unsigned char)f->GetC();
	126	mask = (1 << (bits - restbits)) - 1;
	127	code = code + ((lastbyte & mask) << restbits);
	128	restbyte--;
	129
	130	/* adjust total number of bits extracted from the buffer */
	131	restbits = restbits + 8;
	132	}
	133
	134	/* find number of bits reamining for next code */
	135	restbits = (restbits - bits);
	136
	137	return code;
	138	}
	139
	140
	141
	142	/* dgif:
	143	* GIF decoding function. The initial code size (aka root size)
	144	* is 'bits'. Supports interlaced images (interl == 1).
	145	*/
	146	int gifDecoder::dgif(IMAGEN *img, int interl, int bits)
	147	{
	148	int ab_prefix[4096]; /* alphabet (prefixes) */
	149	int ab_tail[4096]; /* alphabet (tails) */
	150	int stack[4096]; /* decompression stack */
	151
	152	int ab_clr; /* clear code */
	153	int ab_fin; /* end of info code */
	154	int ab_bits; /* actual symbol width, in bits */
	155	int ab_free; /* first free position in alphabet */
	156	int ab_max; /* last possible character in alphabet */
	157	int pass; /* pass number in interlaced images */
	158	int pos; /* index into decompresion stack */
	159	int x, y; /* position in image buffer */
	160
	161	int code, readcode, lastcode, abcabca;
	162
	163	/* these won't change */
	164	ab_clr = (1 << bits);
	165	ab_fin = (1 << bits) + 1;
	166
	167	/* these will change through the decompression proccess */
	168	ab_bits = bits + 1;
	169	ab_free = (1 << bits) + 2;
	170	ab_max = (1 << ab_bits) - 1;
	171	lastcode = -1;
	172	abcabca = -1;
	173	pass = 1;
	174	pos = x = y = 0;
	175
	176	/* reset static globals */
	177	restbits = 0;
	178	restbyte = 0;
	179	lastbyte = 0;
	180
	181	do
	182	{
	183	/* get next code */
	184	readcode = code = getcode(ab_bits);
	185
	186	/* end of image? */
	187	if (code == ab_fin) break;
	188
	189	/* reset alphabet? */
	190	if (code == ab_clr)
	191	{
	192	/* reset main variables */
	193	ab_bits = bits + 1;
	194	ab_free = (1 << bits) + 2;
	195	ab_max = (1 << ab_bits) - 1;
	196	lastcode = -1;
	197	abcabca = -1;
	198
	199	/* skip to next code */
	200	continue;
	201	}
	202
	203	/* unknown code: special case (like in ABCABCA) */
	204	if (code >= ab_free)
	205	{
	206	code = lastcode; /* take last string */
	207	stack[pos++] = abcabca; /* add first character */
	208	}
	209
	210	/* build the string for this code in the stack */
	211	while (code > ab_clr)
	212	{
	213	stack[pos++] = ab_tail[code];
	214	code = ab_prefix[code];
	215	}
	216	stack[pos] = code; /* push last code into the stack */
	217	abcabca = code; /* save for special case */
	218
	219	/* make new entry in alphabet (only if NOT just cleared) */
	220	if (lastcode != -1)
	221	{
	222	ab_prefix[ab_free] = lastcode;
	223	ab_tail[ab_free] = code;
	224	ab_free++;
	225
	226	if ((ab_free > ab_max) && (ab_bits < 12))
	227	{
	228	ab_bits++;
	229	ab_max = (1 << ab_bits) - 1;
	230	}
	231	}
	232
	233	/* dump stack data to the buffer */
	234	while (pos >= 0)
	235	{
	236	(img->p)[x + (y * (img->w))] = (char)stack[pos--];
	237
	238	if (++x >= (img->w))
	239	{
	240	x = 0;
	241
	242	if (interl)
	243	{
	244	/* support for interlaced images */
	245	switch (pass)
	246	{
	247	case 1: y += 8; break;
	248	case 2: y += 8; break;
	249	case 3: y += 4; break;
	250	case 4: y += 2; break;
	251	}
	252	if (y >= (img->h))
	253	{
	254	switch (++pass)
	255	{
	256	case 2: y = 4; break;
	257	case 3: y = 2; break;
	258	case 4: y = 1; break;
	259	}
	260	}
	261	}
	262	else
	263	{
	264	/* non-interlaced */
	265	y++;
	266	}
	267	}
	268	}
	269
	270	pos = 0;
	271	lastcode = readcode;
	272	}
	273	while (code != ab_fin);
	274
	275	return 0;
	276	}
	277
	278
	279
	280	/* readgif:
	281	* Reads a GIF image from the file with filename 'nombre' in the
	282	* IMAGEN structure pointed by 'img'. Can read GIFs with any bit
	283	* size (color depth), but the output image is always expanded
	284	* to 8 bits per pixel. Also, the image palette always contains
	285	* 256 colors, although some of them may be unused. Returns E_OK
	286	* (== 0) on success, or an error code if something fails. Error
	287	* codes are E_ARCHIVO, E_FORMATO, E_MEMORIA (see above).
	288	*/
	289	int gifDecoder::readgif(IMAGEN *img)
	290	{
	291	int size, ncolors, bits, interl, i;
	292	unsigned char pal[768];
	293	unsigned char buf[16];
	294
	295
	296	/* read header and logical screen descriptor block (LSDB) */
	297	f->Read(buf, 13);
	298
	299	/* check GIF signature */
	300	if (memcmp(buf, "GIF", 3) != 0) return E_FORMATO;
	301
	302	/* load global color map if available */
	303	if ((buf[10] & 0x80) == 0x80)
	304	{
	305	ncolors = 2 << (buf[10] & 0x07);
	306	f->Read(pal, 3 * ncolors);
	307	}
	308
	309	/* assume no transparent color */
	310	img->transparent = -1;
	311
	312	/* skip most extensions */
	313	while (((unsigned char)f->GetC()) == 0x21) /* separator */
	314	{
	315	if (((unsigned char)f->GetC()) == 0xF9) /* graphic control ext. */
	316	{
	317	f->Read(buf, 6);
	318	if (buf[1] & 0x01)
	319	img->transparent = buf[4];
	320	}
	321	else
	322	while ((i = (unsigned char)f->GetC()) != 0) /* byte count */
	323	f->SeekI(i, wxFromCurrent);
	324	}
	325
	326	/* read image descriptor block (IDB) */
	327	f->Read(buf, 9);
	328	img->w = buf[4] + 256 * buf[5];
	329	img->h = buf[6] + 256 * buf[7];
	330	size = img->w * img->h;
	331	interl = ((buf[8] & 0x40)? 1 : 0);
	332
	333	/* load local color map if available */
	334	if ((buf[8] & 0x80) == 0x80)
	335	{
	336	ncolors = 2 << (buf[8] & 0x07);
	337	f->Read(pal, 3 * ncolors);
	338	}
	339
	340	/* get initial code size from first byte in raster data */
	341	bits = (unsigned char)f->GetC();
	342
	343	/* allocate memory for image and palette */
	344	if ((img->p = (unsigned char*) malloc(size)) == NULL) return E_MEMORIA;
	345	if ((img->pal = (unsigned char*) malloc(768)) == NULL) return E_MEMORIA;
	346
	347	/* shift palette to fit VGA 6-bit format */
	348	for (i = 0; i < 768; i++)
	349	(img->pal)[i] = (unsigned char)pal[i]; /* >> 2 not in wxWin */
	350
	351	/* decode GIF */
	352	dgif(img, interl, bits);
	353
	354	/* finish successfully :-) */
	355	return E_OK;
	356	}
	357
	358
	359
	360	/*
	361
	362	FOLLOWING CODE IS BY V.S. :
	363
	364	*/
	365
	366	//-----------------------------------------------------------------------------
	367	// wxGIFHandler
	368	//-----------------------------------------------------------------------------
	369
	370	bool wxGIFHandler::LoadFile( wxImage *image, wxInputStream& stream )
	371	{
	372	unsigned char ptr, src, *pal;
	373	IMAGEN igif;
	374	int i;
	375	gifDecoder *decod;
	376
	377	image->Destroy();
	378
	379	decod = new gifDecoder(&stream);
	380
	381	if (decod->readgif(&igif) != E_OK) {
	382	wxLogDebug(_T("Error reading GIF"));
	383	delete decod;
	384	return FALSE;
	385	}
	386	delete decod;
	387
	388	image->Create(igif.w, igif.h);
	389	if (!image->Ok()) {
	390	free(igif.pal);
	391	free(igif.p);
	392	return FALSE;
	393	}
	394
	395	ptr = image->GetData();
	396	src = igif.p;
	397	pal = igif.pal;
	398
	399	if (igif.transparent != -1) {
	400	for (i = 0; i < 256; i++)
	401	if ((pal[3 * i + 0] == 255) && (pal[3 * i + 1] == 0) && (pal[3 * i + 2] == 255)) pal[3 * i + 2] = 254;
	402	pal[3 * (igif.transparent) + 0] = 255,
	403	pal[3 * (igif.transparent) + 1] = 0,
	404	pal[3 * (igif.transparent) + 2] = 255;
	405	image->SetMaskColour(255, 0, 255);
	406	}
	407	else image->SetMask(FALSE);
	408
	409	for (i = 0; i < igif.w * igif.h; i++, src++) {
	410	(ptr++) = pal[3 (*src) + 0];
	411	(ptr++) = pal[3 (*src) + 1];
	412	(ptr++) = pal[3 (*src) + 2];
	413	}
	414
	415	free(igif.pal);
	416	free(igif.p);
	417	return TRUE;
	418	}
	419
	420	bool wxGIFHandler::SaveFile( wxImage * WXUNUSED(image),
	421	wxOutputStream& WXUNUSED(stream) )
	422	{
	423	wxLogDebug(_T("wxGIFHandler is read-only!!"));
	424	return FALSE;
	425	}
	426
	427	#endif