///////////////////////////////////////////////////////////////////////////// // Name: imaggif.cpp // Purpose: wxGIFHandler // Author: Guillermo Rodriguez Garcia // wxWindows adaptation by Vaclav Slavik // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifdef __GNUG__ #pragma implementation "imaggif.h" #endif // For compilers that support precompilation, includes "wx.h". #include #ifdef __BORLANDC__ #pragma hdrstop #endif #include #include #include #include #include /* FOLLOWING CODE IS BY G.R.G. : (except wxInputStream stuff) */ /************************************************************************ READGIF.H - Leer un archivo GIF de 8 bits ------------------------------------------------------------------------ Tratamiento Digital de la Imagen ------------------------------------------------------------------------ Guillermo Rodriguez Garcia 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 - Lee un archivo GIF de 256 colores ------------------------------------------------------------------------ Tratamiento Digital de la Imagen ------------------------------------------------------------------------ Guillermo Rodriguez Garcia Version: 2.1 *************************************************************************/ #include #include /* 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); private: unsigned char mygetc(); // This is NEEDED! GetC is char (signed) why we need unsigned value // from here }; unsigned char gifDecoder::mygetc() { unsigned char c; f -> Read(&c, 1); return c; } /* getcode: * Reads the next code from the file, with size 'bits' * v2.0 - changed to support 'bits' values < 8 */ 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 until needed */ while (bits > restbits) { /* if no bytes left in this block, read the next block */ if (restbyte == 0) restbyte = mygetc(); /* read next byte and isolate the bits we need */ lastbyte = mygetc(); 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 (mygetc() == 0x21) /* separator */ { wxLogDebug("ugh"); if (mygetc() == 0xF9) /* graphic control ext. */ { wxLogDebug("..."); f->Read(buf, 6); wxLogDebug("buf[1] is %i (%i)", buf[1], buf[1] & 0x01); if (buf[1] & 0x01) { wxLogDebug("setting transparen %i", buf[4]); img->transparent = buf[4]; } } else while ((i = mygetc()) != 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 = mygetc(); /* 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 needed under wxWin */; /* decode GIF */ dgif(img, interl, bits); /* finish successfully :-) */ return E_OK; } /* FOLLOWING CODE IS BY V.S. : */ //----------------------------------------------------------------------------- // wxGIFHandler //----------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxGIFHandler,wxImageHandler) 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("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; } image->SetMask(FALSE); ptr = image->GetData(); src = igif.p; pal = igif.pal; 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]; } if (igif.transparent != -1) { wxLogDebug("oko"); image->SetMaskColour(pal[3 * (igif.transparent) + 0], pal[3 * (igif.transparent) + 0], pal[3 * (igif.transparent) + 0]); image->SetMask(TRUE); } wxLogDebug("(unsigned int)%i", (unsigned int)-1); free(igif.pal); free(igif.p); return TRUE; } bool wxGIFHandler::SaveFile( wxImage *image, wxOutputStream& stream ) { wxLogDebug("wxGIFHandler is read-only!!"); return FALSE; }