Skip to content
Browse files

Merge pull request #9 from shtylman/master

update for newer versions of node >= 0.8
  • Loading branch information...
2 parents bf80483 + 7457571 commit d3d8a4b9467b4185fec328a8886226930291af1a @pkrumins committed
View
31 binding.gyp
@@ -0,0 +1,31 @@
+{
+ 'targets': [
+ {
+ 'target_name': 'gif',
+ 'sources': [
+ 'src/animated_gif.cpp',
+ 'src/async_animated_gif.cpp',
+ 'src/buffer_compat.cpp',
+ 'src/common.cpp',
+ 'src/dynamic_gif_stack.cpp',
+ 'src/gif.cpp',
+ 'src/gif_encoder.cpp',
+ 'src/module.cpp',
+ 'src/palette.cpp',
+ 'src/quantize.cpp',
+ 'src/utils.cpp'
+ ],
+ 'dependencies': [
+ '<(module_root_dir)/deps/giflib/giflib.gyp:giflib'
+ ],
+ 'cflags_cc!': [ '-fno-exceptions' ],
+ 'conditions': [
+ ['OS=="mac"', {
+ 'xcode_settings': {
+ 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
+ }
+ }]
+ ]
+ }
+ ]
+}
View
1,166 deps/giflib/dgif_lib.c
@@ -0,0 +1,1166 @@
+/******************************************************************************
+
+dgif_lib.c - GIF decoding
+
+The functions here and in egif_lib.c are partitioned carefully so that
+if you only require one of read and write capability, only one of these
+two modules will be linked. Preserve this property!
+
+*****************************************************************************/
+
+#include <stdlib.h>
+#include <limits.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include <io.h>
+#endif /* _WIN32 */
+
+#include "gif_lib.h"
+#include "gif_lib_private.h"
+
+/* compose unsigned little endian value */
+#define UNSIGNED_LITTLE_ENDIAN(lo, hi) ((lo) | ((hi) << 8))
+
+/* avoid extra function call in case we use fread (TVT) */
+#define READ(_gif,_buf,_len) \
+ (((GifFilePrivateType*)_gif->Private)->Read ? \
+ ((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len) : \
+ fread(_buf,1,_len,((GifFilePrivateType*)_gif->Private)->File))
+
+static int DGifGetWord(GifFileType *GifFile, GifWord *Word);
+static int DGifSetupDecompress(GifFileType *GifFile);
+static int DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line,
+ int LineLen);
+static int DGifGetPrefixChar(GifPrefixType *Prefix, int Code, int ClearCode);
+static int DGifDecompressInput(GifFileType *GifFile, int *Code);
+static int DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf,
+ GifByteType *NextByte);
+
+/******************************************************************************
+ Open a new GIF file for read, given by its name.
+ Returns dynamically allocated GifFileType pointer which serves as the GIF
+ info record.
+******************************************************************************/
+GifFileType *
+DGifOpenFileName(const char *FileName, int *Error)
+{
+ int FileHandle;
+ GifFileType *GifFile;
+
+ if ((FileHandle = open(FileName, O_RDONLY)) == -1) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_OPEN_FAILED;
+ return NULL;
+ }
+
+ GifFile = DGifOpenFileHandle(FileHandle, Error);
+ // cppcheck-suppress resourceLeak
+ return GifFile;
+}
+
+/******************************************************************************
+ Update a new GIF file, given its file handle.
+ Returns dynamically allocated GifFileType pointer which serves as the GIF
+ info record.
+******************************************************************************/
+GifFileType *
+DGifOpenFileHandle(int FileHandle, int *Error)
+{
+ char Buf[GIF_STAMP_LEN + 1];
+ GifFileType *GifFile;
+ GifFilePrivateType *Private;
+ FILE *f;
+
+ GifFile = (GifFileType *)malloc(sizeof(GifFileType));
+ if (GifFile == NULL) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ (void)close(FileHandle);
+ return NULL;
+ }
+
+ /*@i1@*/memset(GifFile, '\0', sizeof(GifFileType));
+
+ /* Belt and suspenders, in case the null pointer isn't zero */
+ GifFile->SavedImages = NULL;
+ GifFile->SColorMap = NULL;
+
+ Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
+ if (Private == NULL) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ (void)close(FileHandle);
+ free((char *)GifFile);
+ return NULL;
+ }
+#ifdef _WIN32
+ _setmode(FileHandle, O_BINARY); /* Make sure it is in binary mode. */
+#endif /* _WIN32 */
+
+ f = fdopen(FileHandle, "rb"); /* Make it into a stream: */
+
+ /*@-mustfreeonly@*/
+ GifFile->Private = (void *)Private;
+ Private->FileHandle = FileHandle;
+ Private->File = f;
+ Private->FileState = FILE_STATE_READ;
+ Private->Read = NULL; /* don't use alternate input method (TVT) */
+ GifFile->UserData = NULL; /* TVT */
+ /*@=mustfreeonly@*/
+
+ /* Let's see if this is a GIF file: */
+ if (READ(GifFile, (unsigned char *)Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_READ_FAILED;
+ (void)fclose(f);
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ /* Check for GIF prefix at start of file */
+ Buf[GIF_STAMP_LEN] = 0;
+ if (strncmp(GIF_STAMP, Buf, GIF_VERSION_POS) != 0) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_GIF_FILE;
+ (void)fclose(f);
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ if (DGifGetScreenDesc(GifFile) == GIF_ERROR) {
+ (void)fclose(f);
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ GifFile->Error = 0;
+
+ /* What version of GIF? */
+ Private->gif89 = (Buf[GIF_VERSION_POS] == '9');
+
+ return GifFile;
+}
+
+/******************************************************************************
+ GifFileType constructor with user supplied input function (TVT)
+******************************************************************************/
+GifFileType *
+DGifOpen(void *userData, InputFunc readFunc, int *Error)
+{
+ char Buf[GIF_STAMP_LEN + 1];
+ GifFileType *GifFile;
+ GifFilePrivateType *Private;
+
+ GifFile = (GifFileType *)malloc(sizeof(GifFileType));
+ if (GifFile == NULL) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+
+ memset(GifFile, '\0', sizeof(GifFileType));
+
+ /* Belt and suspenders, in case the null pointer isn't zero */
+ GifFile->SavedImages = NULL;
+ GifFile->SColorMap = NULL;
+
+ Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
+ if (!Private) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ GifFile->Private = (void *)Private;
+ Private->FileHandle = 0;
+ Private->File = NULL;
+ Private->FileState = FILE_STATE_READ;
+
+ Private->Read = readFunc; /* TVT */
+ GifFile->UserData = userData; /* TVT */
+
+ /* Lets see if this is a GIF file: */
+ if (READ(GifFile, (unsigned char *)Buf, GIF_STAMP_LEN) != GIF_STAMP_LEN) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_READ_FAILED;
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ /* Check for GIF prefix at start of file */
+ Buf[GIF_STAMP_LEN] = '\0';
+ if (strncmp(GIF_STAMP, Buf, GIF_VERSION_POS) != 0) {
+ if (Error != NULL)
+ *Error = D_GIF_ERR_NOT_GIF_FILE;
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ if (DGifGetScreenDesc(GifFile) == GIF_ERROR) {
+ free((char *)Private);
+ free((char *)GifFile);
+ return NULL;
+ }
+
+ GifFile->Error = 0;
+
+ /* What version of GIF? */
+ Private->gif89 = (Buf[GIF_VERSION_POS] == '9');
+
+ return GifFile;
+}
+
+/******************************************************************************
+ This routine should be called before any other DGif calls. Note that
+ this routine is called automatically from DGif file open routines.
+******************************************************************************/
+int
+DGifGetScreenDesc(GifFileType *GifFile)
+{
+ int BitsPerPixel;
+ bool SortFlag;
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ /* Put the screen descriptor into the file: */
+ if (DGifGetWord(GifFile, &GifFile->SWidth) == GIF_ERROR ||
+ DGifGetWord(GifFile, &GifFile->SHeight) == GIF_ERROR)
+ return GIF_ERROR;
+
+ if (READ(GifFile, Buf, 3) != 3) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ GifFreeMapObject(GifFile->SColorMap);
+ GifFile->SColorMap = NULL;
+ return GIF_ERROR;
+ }
+ GifFile->SColorResolution = (((Buf[0] & 0x70) + 1) >> 4) + 1;
+ SortFlag = (Buf[0] & 0x08) != 0;
+ BitsPerPixel = (Buf[0] & 0x07) + 1;
+ GifFile->SBackGroundColor = Buf[1];
+ GifFile->AspectByte = Buf[2];
+ if (Buf[0] & 0x80) { /* Do we have global color map? */
+ int i;
+
+ GifFile->SColorMap = GifMakeMapObject(1 << BitsPerPixel, NULL);
+ if (GifFile->SColorMap == NULL) {
+ GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+
+ /* Get the global color map: */
+ GifFile->SColorMap->SortFlag = SortFlag;
+ for (i = 0; i < GifFile->SColorMap->ColorCount; i++) {
+ if (READ(GifFile, Buf, 3) != 3) {
+ GifFreeMapObject(GifFile->SColorMap);
+ GifFile->SColorMap = NULL;
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ GifFile->SColorMap->Colors[i].Red = Buf[0];
+ GifFile->SColorMap->Colors[i].Green = Buf[1];
+ GifFile->SColorMap->Colors[i].Blue = Buf[2];
+ }
+ } else {
+ GifFile->SColorMap = NULL;
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine should be called before any attempt to read an image.
+******************************************************************************/
+int
+DGifGetRecordType(GifFileType *GifFile, GifRecordType* Type)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (READ(GifFile, &Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+
+ switch (Buf) {
+ case DESCRIPTOR_INTRODUCER:
+ *Type = IMAGE_DESC_RECORD_TYPE;
+ break;
+ case EXTENSION_INTRODUCER:
+ *Type = EXTENSION_RECORD_TYPE;
+ break;
+ case TERMINATOR_INTRODUCER:
+ *Type = TERMINATE_RECORD_TYPE;
+ break;
+ default:
+ *Type = UNDEFINED_RECORD_TYPE;
+ GifFile->Error = D_GIF_ERR_WRONG_RECORD;
+ return GIF_ERROR;
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine should be called before any attempt to read an image.
+ Note it is assumed the Image desc. header has been read.
+******************************************************************************/
+int
+DGifGetImageDesc(GifFileType *GifFile)
+{
+ unsigned int BitsPerPixel;
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+ SavedImage *sp;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (DGifGetWord(GifFile, &GifFile->Image.Left) == GIF_ERROR ||
+ DGifGetWord(GifFile, &GifFile->Image.Top) == GIF_ERROR ||
+ DGifGetWord(GifFile, &GifFile->Image.Width) == GIF_ERROR ||
+ DGifGetWord(GifFile, &GifFile->Image.Height) == GIF_ERROR)
+ return GIF_ERROR;
+ if (READ(GifFile, Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ GifFreeMapObject(GifFile->Image.ColorMap);
+ GifFile->Image.ColorMap = NULL;
+ return GIF_ERROR;
+ }
+ BitsPerPixel = (Buf[0] & 0x07) + 1;
+ GifFile->Image.Interlace = (Buf[0] & 0x40) ? true : false;
+
+ /* Setup the colormap */
+ if (GifFile->Image.ColorMap) {
+ GifFreeMapObject(GifFile->Image.ColorMap);
+ GifFile->Image.ColorMap = NULL;
+ }
+ /* Does this image have local color map? */
+ if (Buf[0] & 0x80) {
+ unsigned int i;
+
+ GifFile->Image.ColorMap = GifMakeMapObject(1 << BitsPerPixel, NULL);
+ if (GifFile->Image.ColorMap == NULL) {
+ GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+
+ /* Get the image local color map: */
+ for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++) {
+ if (READ(GifFile, Buf, 3) != 3) {
+ GifFreeMapObject(GifFile->Image.ColorMap);
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ GifFile->Image.ColorMap = NULL;
+ return GIF_ERROR;
+ }
+ GifFile->Image.ColorMap->Colors[i].Red = Buf[0];
+ GifFile->Image.ColorMap->Colors[i].Green = Buf[1];
+ GifFile->Image.ColorMap->Colors[i].Blue = Buf[2];
+ }
+ }
+
+ if (GifFile->SavedImages) {
+ if ((GifFile->SavedImages = (SavedImage *)realloc(GifFile->SavedImages,
+ sizeof(SavedImage) *
+ (GifFile->ImageCount + 1))) == NULL) {
+ GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+ } else {
+ if ((GifFile->SavedImages =
+ (SavedImage *) malloc(sizeof(SavedImage))) == NULL) {
+ GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+ }
+
+ sp = &GifFile->SavedImages[GifFile->ImageCount];
+ memcpy(&sp->ImageDesc, &GifFile->Image, sizeof(GifImageDesc));
+ if (GifFile->Image.ColorMap != NULL) {
+ sp->ImageDesc.ColorMap = GifMakeMapObject(
+ GifFile->Image.ColorMap->ColorCount,
+ GifFile->Image.ColorMap->Colors);
+ if (sp->ImageDesc.ColorMap == NULL) {
+ GifFile->Error = D_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+ }
+ sp->RasterBits = (unsigned char *)NULL;
+ sp->ExtensionBlockCount = 0;
+ sp->ExtensionBlocks = (ExtensionBlock *) NULL;
+
+ GifFile->ImageCount++;
+
+ Private->PixelCount = (long)GifFile->Image.Width *
+ (long)GifFile->Image.Height;
+
+ /* Reset decompress algorithm parameters. */
+ (void)DGifSetupDecompress(GifFile);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Get one full scanned line (Line) of length LineLen from GIF file.
+******************************************************************************/
+int
+DGifGetLine(GifFileType *GifFile, GifPixelType *Line, int LineLen)
+{
+ GifByteType *Dummy;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (!LineLen)
+ LineLen = GifFile->Image.Width;
+
+ if ((Private->PixelCount -= LineLen) > 0xffff0000UL) {
+ GifFile->Error = D_GIF_ERR_DATA_TOO_BIG;
+ return GIF_ERROR;
+ }
+
+ if (DGifDecompressLine(GifFile, Line, LineLen) == GIF_OK) {
+ if (Private->PixelCount == 0) {
+ /* We probably won't be called any more, so let's clean up
+ * everything before we return: need to flush out all the
+ * rest of image until an empty block (size 0)
+ * detected. We use GetCodeNext.
+ */
+ do
+ if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR)
+ return GIF_ERROR;
+ while (Dummy != NULL) ;
+ }
+ return GIF_OK;
+ } else
+ return GIF_ERROR;
+}
+
+/******************************************************************************
+ Put one pixel (Pixel) into GIF file.
+******************************************************************************/
+int
+DGifGetPixel(GifFileType *GifFile, GifPixelType Pixel)
+{
+ GifByteType *Dummy;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+ if (--Private->PixelCount > 0xffff0000UL)
+ {
+ GifFile->Error = D_GIF_ERR_DATA_TOO_BIG;
+ return GIF_ERROR;
+ }
+
+ if (DGifDecompressLine(GifFile, &Pixel, 1) == GIF_OK) {
+ if (Private->PixelCount == 0) {
+ /* We probably won't be called any more, so let's clean up
+ * everything before we return: need to flush out all the
+ * rest of image until an empty block (size 0)
+ * detected. We use GetCodeNext.
+ */
+ do
+ if (DGifGetCodeNext(GifFile, &Dummy) == GIF_ERROR)
+ return GIF_ERROR;
+ while (Dummy != NULL) ;
+ }
+ return GIF_OK;
+ } else
+ return GIF_ERROR;
+}
+
+/******************************************************************************
+ Get an extension block (see GIF manual) from GIF file. This routine only
+ returns the first data block, and DGifGetExtensionNext should be called
+ after this one until NULL extension is returned.
+ The Extension should NOT be freed by the user (not dynamically allocated).
+ Note it is assumed the Extension description header has been read.
+******************************************************************************/
+int
+DGifGetExtension(GifFileType *GifFile, int *ExtCode, GifByteType **Extension)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (READ(GifFile, &Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ *ExtCode = Buf;
+
+ return DGifGetExtensionNext(GifFile, Extension);
+}
+
+/******************************************************************************
+ Get a following extension block (see GIF manual) from GIF file. This
+ routine should be called until NULL Extension is returned.
+ The Extension should NOT be freed by the user (not dynamically allocated).
+******************************************************************************/
+int
+DGifGetExtensionNext(GifFileType *GifFile, GifByteType ** Extension)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (READ(GifFile, &Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ if (Buf > 0) {
+ *Extension = Private->Buf; /* Use private unused buffer. */
+ (*Extension)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */
+ /* coverity[tainted_data] */
+ if (READ(GifFile, &((*Extension)[1]), Buf) != Buf) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ } else
+ *Extension = NULL;
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Extract a Graphics Control Block from raw extension data
+******************************************************************************/
+
+int DGifExtensionToGCB(const size_t GifExtensionLength,
+ const GifByteType *GifExtension,
+ GraphicsControlBlock *GCB)
+{
+ if (GifExtensionLength != 4) {
+ return GIF_ERROR;
+ }
+
+ GCB->DisposalMode = (GifExtension[0] >> 2) & 0x07;
+ GCB->UserInputFlag = (GifExtension[0] & 0x02) != 0;
+ GCB->DelayTime = UNSIGNED_LITTLE_ENDIAN(GifExtension[1], GifExtension[2]);
+ if (GifExtension[0] & 0x01)
+ GCB->TransparentColor = (int)GifExtension[3];
+ else
+ GCB->TransparentColor = NO_TRANSPARENT_COLOR;
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Extract the Graphics Control Block for a saved image, if it exists.
+******************************************************************************/
+
+int DGifSavedExtensionToGCB(GifFileType *GifFile,
+ int ImageIndex, GraphicsControlBlock *GCB)
+{
+ int i;
+
+ if (ImageIndex < 0 || ImageIndex > GifFile->ImageCount - 1)
+ return GIF_ERROR;
+
+ GCB->DisposalMode = DISPOSAL_UNSPECIFIED;
+ GCB->UserInputFlag = false;
+ GCB->DelayTime = 0;
+ GCB->TransparentColor = NO_TRANSPARENT_COLOR;
+
+ for (i = 0; i < GifFile->SavedImages[ImageIndex].ExtensionBlockCount; i++) {
+ ExtensionBlock *ep = &GifFile->SavedImages[ImageIndex].ExtensionBlocks[i];
+ if (ep->Function == GRAPHICS_EXT_FUNC_CODE)
+ return DGifExtensionToGCB(ep->ByteCount, ep->Bytes, GCB);
+ }
+
+ return GIF_ERROR;
+}
+
+/******************************************************************************
+ This routine should be called last, to close the GIF file.
+******************************************************************************/
+int
+DGifCloseFile(GifFileType *GifFile)
+{
+ GifFilePrivateType *Private;
+
+ if (GifFile == NULL || GifFile->Private == NULL)
+ return GIF_ERROR;
+
+ if (GifFile->Image.ColorMap) {
+ GifFreeMapObject(GifFile->Image.ColorMap);
+ GifFile->Image.ColorMap = NULL;
+ }
+
+ if (GifFile->SColorMap) {
+ GifFreeMapObject(GifFile->SColorMap);
+ GifFile->SColorMap = NULL;
+ }
+
+ if (GifFile->SavedImages) {
+ GifFreeSavedImages(GifFile);
+ GifFile->SavedImages = NULL;
+ }
+
+ GifFreeExtensions(&GifFile->ExtensionBlockCount, &GifFile->ExtensionBlocks);
+
+ Private = (GifFilePrivateType *) GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (Private->File && (fclose(Private->File) != 0)) {
+ GifFile->Error = D_GIF_ERR_CLOSE_FAILED;
+ return GIF_ERROR;
+ }
+
+ free((char *)GifFile->Private);
+
+ /*
+ * Without the #ifndef, we get spurious warnings because Coverity mistakenly
+ * thinks the GIF structure is freed on an error return.
+ */
+#ifndef __COVERITY__
+ free(GifFile);
+#endif /* __COVERITY__ */
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Get 2 bytes (word) from the given file:
+******************************************************************************/
+static int
+DGifGetWord(GifFileType *GifFile, GifWord *Word)
+{
+ unsigned char c[2];
+
+ if (READ(GifFile, c, 2) != 2) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+
+ *Word = (GifWord)UNSIGNED_LITTLE_ENDIAN(c[0], c[1]);
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Get the image code in compressed form. This routine can be called if the
+ information needed to be piped out as is. Obviously this is much faster
+ than decoding and encoding again. This routine should be followed by calls
+ to DGifGetCodeNext, until NULL block is returned.
+ The block should NOT be freed by the user (not dynamically allocated).
+******************************************************************************/
+int
+DGifGetCode(GifFileType *GifFile, int *CodeSize, GifByteType **CodeBlock)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ *CodeSize = Private->BitsPerPixel;
+
+ return DGifGetCodeNext(GifFile, CodeBlock);
+}
+
+/******************************************************************************
+ Continue to get the image code in compressed form. This routine should be
+ called until NULL block is returned.
+ The block should NOT be freed by the user (not dynamically allocated).
+******************************************************************************/
+int
+DGifGetCodeNext(GifFileType *GifFile, GifByteType **CodeBlock)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ /* coverity[tainted_data_argument] */
+ if (READ(GifFile, &Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+
+ /* coverity[lower_bounds] */
+ if (Buf > 0) {
+ *CodeBlock = Private->Buf; /* Use private unused buffer. */
+ (*CodeBlock)[0] = Buf; /* Pascal strings notation (pos. 0 is len.). */
+ /* coverity[tainted_data] */
+ if (READ(GifFile, &((*CodeBlock)[1]), Buf) != Buf) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ } else {
+ *CodeBlock = NULL;
+ Private->Buf[0] = 0; /* Make sure the buffer is empty! */
+ Private->PixelCount = 0; /* And local info. indicate image read. */
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Setup the LZ decompression for this image:
+******************************************************************************/
+static int
+DGifSetupDecompress(GifFileType *GifFile)
+{
+ int i, BitsPerPixel;
+ GifByteType CodeSize;
+ GifPrefixType *Prefix;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ READ(GifFile, &CodeSize, 1); /* Read Code size from file. */
+ BitsPerPixel = CodeSize;
+
+ Private->Buf[0] = 0; /* Input Buffer empty. */
+ Private->BitsPerPixel = BitsPerPixel;
+ Private->ClearCode = (1 << BitsPerPixel);
+ Private->EOFCode = Private->ClearCode + 1;
+ Private->RunningCode = Private->EOFCode + 1;
+ Private->RunningBits = BitsPerPixel + 1; /* Number of bits per code. */
+ Private->MaxCode1 = 1 << Private->RunningBits; /* Max. code + 1. */
+ Private->StackPtr = 0; /* No pixels on the pixel stack. */
+ Private->LastCode = NO_SUCH_CODE;
+ Private->CrntShiftState = 0; /* No information in CrntShiftDWord. */
+ Private->CrntShiftDWord = 0;
+
+ Prefix = Private->Prefix;
+ for (i = 0; i <= LZ_MAX_CODE; i++)
+ Prefix[i] = NO_SUCH_CODE;
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ The LZ decompression routine:
+ This version decompress the given GIF file into Line of length LineLen.
+ This routine can be called few times (one per scan line, for example), in
+ order the complete the whole image.
+******************************************************************************/
+static int
+DGifDecompressLine(GifFileType *GifFile, GifPixelType *Line, int LineLen)
+{
+ int i = 0;
+ int j, CrntCode, EOFCode, ClearCode, CrntPrefix, LastCode, StackPtr;
+ GifByteType *Stack, *Suffix;
+ GifPrefixType *Prefix;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ StackPtr = Private->StackPtr;
+ Prefix = Private->Prefix;
+ Suffix = Private->Suffix;
+ Stack = Private->Stack;
+ EOFCode = Private->EOFCode;
+ ClearCode = Private->ClearCode;
+ LastCode = Private->LastCode;
+
+ if (StackPtr > LZ_MAX_CODE) {
+ return GIF_ERROR;
+ }
+
+ if (StackPtr != 0) {
+ /* Let pop the stack off before continueing to read the GIF file: */
+ while (StackPtr != 0 && i < LineLen)
+ Line[i++] = Stack[--StackPtr];
+ }
+
+ while (i < LineLen) { /* Decode LineLen items. */
+ if (DGifDecompressInput(GifFile, &CrntCode) == GIF_ERROR)
+ return GIF_ERROR;
+
+ if (CrntCode == EOFCode) {
+ /* Note however that usually we will not be here as we will stop
+ * decoding as soon as we got all the pixel, or EOF code will
+ * not be read at all, and DGifGetLine/Pixel clean everything. */
+ GifFile->Error = D_GIF_ERR_EOF_TOO_SOON;
+ return GIF_ERROR;
+ } else if (CrntCode == ClearCode) {
+ /* We need to start over again: */
+ for (j = 0; j <= LZ_MAX_CODE; j++)
+ Prefix[j] = NO_SUCH_CODE;
+ Private->RunningCode = Private->EOFCode + 1;
+ Private->RunningBits = Private->BitsPerPixel + 1;
+ Private->MaxCode1 = 1 << Private->RunningBits;
+ LastCode = Private->LastCode = NO_SUCH_CODE;
+ } else {
+ /* Its regular code - if in pixel range simply add it to output
+ * stream, otherwise trace to codes linked list until the prefix
+ * is in pixel range: */
+ if (CrntCode < ClearCode) {
+ /* This is simple - its pixel scalar, so add it to output: */
+ Line[i++] = CrntCode;
+ } else {
+ /* Its a code to needed to be traced: trace the linked list
+ * until the prefix is a pixel, while pushing the suffix
+ * pixels on our stack. If we done, pop the stack in reverse
+ * (thats what stack is good for!) order to output. */
+ if (Prefix[CrntCode] == NO_SUCH_CODE) {
+ /* Only allowed if CrntCode is exactly the running code:
+ * In that case CrntCode = XXXCode, CrntCode or the
+ * prefix code is last code and the suffix char is
+ * exactly the prefix of last code! */
+ if (CrntCode == Private->RunningCode - 2) {
+ CrntPrefix = LastCode;
+ Suffix[Private->RunningCode - 2] =
+ Stack[StackPtr++] = DGifGetPrefixChar(Prefix,
+ LastCode,
+ ClearCode);
+ } else {
+ GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
+ return GIF_ERROR;
+ }
+ } else
+ CrntPrefix = CrntCode;
+
+ /* Now (if image is O.K.) we should not get a NO_SUCH_CODE
+ * during the trace. As we might loop forever, in case of
+ * defective image, we use StackPtr as loop counter and stop
+ * before overflowing Stack[]. */
+ while (StackPtr < LZ_MAX_CODE &&
+ CrntPrefix > ClearCode && CrntPrefix <= LZ_MAX_CODE) {
+ Stack[StackPtr++] = Suffix[CrntPrefix];
+ CrntPrefix = Prefix[CrntPrefix];
+ }
+ if (StackPtr >= LZ_MAX_CODE || CrntPrefix > LZ_MAX_CODE) {
+ GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
+ return GIF_ERROR;
+ }
+ /* Push the last character on stack: */
+ Stack[StackPtr++] = CrntPrefix;
+
+ /* Now lets pop all the stack into output: */
+ while (StackPtr != 0 && i < LineLen)
+ Line[i++] = Stack[--StackPtr];
+ }
+ if (LastCode != NO_SUCH_CODE) {
+ Prefix[Private->RunningCode - 2] = LastCode;
+
+ if (CrntCode == Private->RunningCode - 2) {
+ /* Only allowed if CrntCode is exactly the running code:
+ * In that case CrntCode = XXXCode, CrntCode or the
+ * prefix code is last code and the suffix char is
+ * exactly the prefix of last code! */
+ Suffix[Private->RunningCode - 2] =
+ DGifGetPrefixChar(Prefix, LastCode, ClearCode);
+ } else {
+ Suffix[Private->RunningCode - 2] =
+ DGifGetPrefixChar(Prefix, CrntCode, ClearCode);
+ }
+ }
+ LastCode = CrntCode;
+ }
+ }
+
+ Private->LastCode = LastCode;
+ Private->StackPtr = StackPtr;
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Routine to trace the Prefixes linked list until we get a prefix which is
+ not code, but a pixel value (less than ClearCode). Returns that pixel value.
+ If image is defective, we might loop here forever, so we limit the loops to
+ the maximum possible if image O.k. - LZ_MAX_CODE times.
+******************************************************************************/
+static int
+DGifGetPrefixChar(GifPrefixType *Prefix, int Code, int ClearCode)
+{
+ int i = 0;
+
+ while (Code > ClearCode && i++ <= LZ_MAX_CODE) {
+ if (Code > LZ_MAX_CODE) {
+ return NO_SUCH_CODE;
+ }
+ Code = Prefix[Code];
+ }
+ return Code;
+}
+
+/******************************************************************************
+ Interface for accessing the LZ codes directly. Set Code to the real code
+ (12bits), or to -1 if EOF code is returned.
+******************************************************************************/
+int
+DGifGetLZCodes(GifFileType *GifFile, int *Code)
+{
+ GifByteType *CodeBlock;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_READABLE(Private)) {
+ /* This file was NOT open for reading: */
+ GifFile->Error = D_GIF_ERR_NOT_READABLE;
+ return GIF_ERROR;
+ }
+
+ if (DGifDecompressInput(GifFile, Code) == GIF_ERROR)
+ return GIF_ERROR;
+
+ if (*Code == Private->EOFCode) {
+ /* Skip rest of codes (hopefully only NULL terminating block): */
+ do {
+ if (DGifGetCodeNext(GifFile, &CodeBlock) == GIF_ERROR)
+ return GIF_ERROR;
+ } while (CodeBlock != NULL) ;
+
+ *Code = -1;
+ } else if (*Code == Private->ClearCode) {
+ /* We need to start over again: */
+ Private->RunningCode = Private->EOFCode + 1;
+ Private->RunningBits = Private->BitsPerPixel + 1;
+ Private->MaxCode1 = 1 << Private->RunningBits;
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ The LZ decompression input routine:
+ This routine is responsable for the decompression of the bit stream from
+ 8 bits (bytes) packets, into the real codes.
+ Returns GIF_OK if read successfully.
+******************************************************************************/
+static int
+DGifDecompressInput(GifFileType *GifFile, int *Code)
+{
+ static const unsigned short CodeMasks[] = {
+ 0x0000, 0x0001, 0x0003, 0x0007,
+ 0x000f, 0x001f, 0x003f, 0x007f,
+ 0x00ff, 0x01ff, 0x03ff, 0x07ff,
+ 0x0fff
+ };
+
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ GifByteType NextByte;
+
+ /* The image can't contain more than LZ_BITS per code. */
+ if (Private->RunningBits > LZ_BITS) {
+ GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
+ return GIF_ERROR;
+ }
+
+ while (Private->CrntShiftState < Private->RunningBits) {
+ /* Needs to get more bytes from input stream for next code: */
+ if (DGifBufferedInput(GifFile, Private->Buf, &NextByte) == GIF_ERROR) {
+ return GIF_ERROR;
+ }
+ Private->CrntShiftDWord |=
+ ((unsigned long)NextByte) << Private->CrntShiftState;
+ Private->CrntShiftState += 8;
+ }
+ *Code = Private->CrntShiftDWord & CodeMasks[Private->RunningBits];
+
+ Private->CrntShiftDWord >>= Private->RunningBits;
+ Private->CrntShiftState -= Private->RunningBits;
+
+ /* If code cannot fit into RunningBits bits, must raise its size. Note
+ * however that codes above 4095 are used for special signaling.
+ * If we're using LZ_BITS bits already and we're at the max code, just
+ * keep using the table as it is, don't increment Private->RunningCode.
+ */
+ if (Private->RunningCode < LZ_MAX_CODE + 2 &&
+ ++Private->RunningCode > Private->MaxCode1 &&
+ Private->RunningBits < LZ_BITS) {
+ Private->MaxCode1 <<= 1;
+ Private->RunningBits++;
+ }
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routines read one GIF data block at a time and buffers it internally
+ so that the decompression routine could access it.
+ The routine returns the next byte from its internal buffer (or read next
+ block in if buffer empty) and returns GIF_OK if succesful.
+******************************************************************************/
+static int
+DGifBufferedInput(GifFileType *GifFile, GifByteType *Buf, GifByteType *NextByte)
+{
+ if (Buf[0] == 0) {
+ /* Needs to read the next buffer - this one is empty: */
+ if (READ(GifFile, Buf, 1) != 1) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ /* There shouldn't be any empty data blocks here as the LZW spec
+ * says the LZW termination code should come first. Therefore we
+ * shouldn't be inside this routine at that point.
+ */
+ if (Buf[0] == 0) {
+ GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
+ return GIF_ERROR;
+ }
+ /* There shouldn't be any empty data blocks here as the LZW spec
+ * says the LZW termination code should come first. Therefore we
+ * shouldn't be inside this routine at that point.
+ */
+ if (Buf[0] == 0) {
+ GifFile->Error = D_GIF_ERR_IMAGE_DEFECT;
+ return GIF_ERROR;
+ }
+ if (READ(GifFile, &Buf[1], Buf[0]) != Buf[0]) {
+ GifFile->Error = D_GIF_ERR_READ_FAILED;
+ return GIF_ERROR;
+ }
+ *NextByte = Buf[1];
+ Buf[1] = 2; /* We use now the second place as last char read! */
+ Buf[0]--;
+ } else {
+ *NextByte = Buf[Buf[1]++];
+ Buf[0]--;
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine reads an entire GIF into core, hanging all its state info off
+ the GifFileType pointer. Call DGifOpenFileName() or DGifOpenFileHandle()
+ first to initialize I/O. Its inverse is EGifSpew().
+*******************************************************************************/
+int
+DGifSlurp(GifFileType *GifFile)
+{
+ size_t ImageSize;
+ GifRecordType RecordType;
+ SavedImage *sp;
+ GifByteType *ExtData;
+ int ExtFunction;
+
+ GifFile->ExtensionBlocks = NULL;
+ GifFile->ExtensionBlockCount = 0;
+
+ do {
+ if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ switch (RecordType) {
+ case IMAGE_DESC_RECORD_TYPE:
+ if (DGifGetImageDesc(GifFile) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ sp = &GifFile->SavedImages[GifFile->ImageCount - 1];
+ /* Allocate memory for the image */
+ if (sp->ImageDesc.Width < 0 && sp->ImageDesc.Height < 0 &&
+ sp->ImageDesc.Width > (INT_MAX / sp->ImageDesc.Height)) {
+ return GIF_ERROR;
+ }
+ ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height;
+
+ if (ImageSize > (SIZE_MAX / sizeof(GifPixelType))) {
+ return GIF_ERROR;
+ }
+ sp->RasterBits = (unsigned char *)malloc(ImageSize *
+ sizeof(GifPixelType));
+
+ if (sp->RasterBits == NULL) {
+ return GIF_ERROR;
+ }
+
+ if (sp->ImageDesc.Interlace) {
+ int i, j;
+ /*
+ * The way an interlaced image should be read -
+ * offsets and jumps...
+ */
+ int InterlacedOffset[] = { 0, 4, 2, 1 };
+ int InterlacedJumps[] = { 8, 8, 4, 2 };
+ /* Need to perform 4 passes on the image */
+ for (i = 0; i < 4; i++)
+ for (j = InterlacedOffset[i];
+ j < sp->ImageDesc.Height;
+ j += InterlacedJumps[i]) {
+ if (DGifGetLine(GifFile,
+ sp->RasterBits+j*sp->ImageDesc.Width,
+ sp->ImageDesc.Width) == GIF_ERROR)
+ return GIF_ERROR;
+ }
+ }
+ else {
+ if (DGifGetLine(GifFile,sp->RasterBits,ImageSize)==GIF_ERROR)
+ return (GIF_ERROR);
+ }
+
+ if (GifFile->ExtensionBlocks) {
+ sp->ExtensionBlocks = GifFile->ExtensionBlocks;
+ sp->ExtensionBlockCount = GifFile->ExtensionBlockCount;
+
+ GifFile->ExtensionBlocks = NULL;
+ GifFile->ExtensionBlockCount = 0;
+ }
+ break;
+
+ case EXTENSION_RECORD_TYPE:
+ if (DGifGetExtension(GifFile,&ExtFunction,&ExtData) == GIF_ERROR)
+ return (GIF_ERROR);
+ /* Create an extension block with our data */
+ if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,
+ &GifFile->ExtensionBlocks,
+ ExtFunction, ExtData[0], &ExtData[1])
+ == GIF_ERROR)
+ return (GIF_ERROR);
+ while (ExtData != NULL) {
+ if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR)
+ return (GIF_ERROR);
+ /* Continue the extension block */
+ if (ExtData != NULL)
+ if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,
+ &GifFile->ExtensionBlocks,
+ CONTINUE_EXT_FUNC_CODE,
+ ExtData[0], &ExtData[1]) == GIF_ERROR)
+ return (GIF_ERROR);
+ }
+ break;
+
+ case TERMINATE_RECORD_TYPE:
+ break;
+
+ default: /* Should be trapped by DGifGetRecordType */
+ break;
+ }
+ } while (RecordType != TERMINATE_RECORD_TYPE);
+
+ return (GIF_OK);
+}
+
+/* end */
View
1,127 deps/giflib/egif_lib.c
@@ -0,0 +1,1127 @@
+/******************************************************************************
+
+egif_lib.c - GIF encoding
+
+The functions here and in dgif_lib.c are partitioned carefully so that
+if you only require one of read and write capability, only one of these
+two modules will be linked. Preserve this property!
+
+*****************************************************************************/
+
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+#include <io.h>
+#include <sys\stat.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif /* _WIN32 */
+
+#include "gif_lib.h"
+#include "gif_lib_private.h"
+
+/* Masks given codes to BitsPerPixel, to make sure all codes are in range: */
+/*@+charint@*/
+static const GifPixelType CodeMask[] = {
+ 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff
+};
+/*@-charint@*/
+
+static int EGifPutWord(int Word, GifFileType * GifFile);
+static int EGifSetupCompress(GifFileType * GifFile);
+static int EGifCompressLine(GifFileType * GifFile, GifPixelType * Line,
+ int LineLen);
+static int EGifCompressOutput(GifFileType * GifFile, int Code);
+static int EGifBufferedOutput(GifFileType * GifFile, GifByteType * Buf,
+ int c);
+
+/* extract bytes from an unsigned word */
+#define LOBYTE(x) ((x) & 0xff)
+#define HIBYTE(x) (((x) >> 8) & 0xff)
+
+/******************************************************************************
+ Open a new GIF file for write, specified by name. If TestExistance then
+ if the file exists this routines fails (returns NULL).
+ Returns a dynamically allocated GifFileType pointer which serves as the GIF
+ info record. The Error member is cleared if successful.
+******************************************************************************/
+GifFileType *
+EGifOpenFileName(const char *FileName, const bool TestExistence, int *Error)
+{
+
+ int FileHandle;
+ GifFileType *GifFile;
+
+ if (TestExistence)
+ FileHandle = open(FileName, O_WRONLY | O_CREAT | O_EXCL,
+ S_IREAD | S_IWRITE);
+ else
+ FileHandle = open(FileName, O_WRONLY | O_CREAT | O_TRUNC,
+ S_IREAD | S_IWRITE);
+
+ if (FileHandle == -1) {
+ if (Error != NULL)
+ *Error = E_GIF_ERR_OPEN_FAILED;
+ return NULL;
+ }
+ GifFile = EGifOpenFileHandle(FileHandle, Error);
+ if (GifFile == (GifFileType *) NULL)
+ (void)close(FileHandle);
+ return GifFile;
+}
+
+/******************************************************************************
+ Update a new GIF file, given its file handle, which must be opened for
+ write in binary mode.
+ Returns dynamically allocated a GifFileType pointer which serves as the GIF
+ info record.
+ Only fails on a memory allocation error.
+******************************************************************************/
+GifFileType *
+EGifOpenFileHandle(const int FileHandle, int *Error)
+{
+ GifFileType *GifFile;
+ GifFilePrivateType *Private;
+ FILE *f;
+
+ GifFile = (GifFileType *) malloc(sizeof(GifFileType));
+ if (GifFile == NULL) {
+ return NULL;
+ }
+
+ memset(GifFile, '\0', sizeof(GifFileType));
+
+ Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
+ if (Private == NULL) {
+ free(GifFile);
+ if (Error != NULL)
+ *Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+ if ((Private->HashTable = _InitHashTable()) == NULL) {
+ free(GifFile);
+ free(Private);
+ if (Error != NULL)
+ *Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+
+#ifdef _WIN32
+ _setmode(FileHandle, O_BINARY); /* Make sure it is in binary mode. */
+#endif /* _WIN32 */
+
+ f = fdopen(FileHandle, "wb"); /* Make it into a stream: */
+
+ GifFile->Private = (void *)Private;
+ Private->FileHandle = FileHandle;
+ Private->File = f;
+ Private->FileState = FILE_STATE_WRITE;
+
+ Private->Write = (OutputFunc) 0; /* No user write routine (MRB) */
+ GifFile->UserData = (void *)NULL; /* No user write handle (MRB) */
+
+ GifFile->Error = 0;
+
+ return GifFile;
+}
+
+/******************************************************************************
+ Output constructor that takes user supplied output function.
+ Basically just a copy of EGifOpenFileHandle. (MRB)
+******************************************************************************/
+GifFileType *
+EGifOpen(void *userData, OutputFunc writeFunc, int *Error)
+{
+ GifFileType *GifFile;
+ GifFilePrivateType *Private;
+
+ GifFile = (GifFileType *)malloc(sizeof(GifFileType));
+ if (GifFile == NULL) {
+ if (Error != NULL)
+ *Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+
+ memset(GifFile, '\0', sizeof(GifFileType));
+
+ Private = (GifFilePrivateType *)malloc(sizeof(GifFilePrivateType));
+ if (Private == NULL) {
+ free(GifFile);
+ if (Error != NULL)
+ *Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+
+ Private->HashTable = _InitHashTable();
+ if (Private->HashTable == NULL) {
+ free (GifFile);
+ free (Private);
+ if (Error != NULL)
+ *Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return NULL;
+ }
+
+ GifFile->Private = (void *)Private;
+ Private->FileHandle = 0;
+ Private->File = (FILE *) 0;
+ Private->FileState = FILE_STATE_WRITE;
+
+ Private->Write = writeFunc; /* User write routine (MRB) */
+ GifFile->UserData = userData; /* User write handle (MRB) */
+
+ GifFile->Error = 0;
+
+ return GifFile;
+}
+
+/******************************************************************************
+ Routine to compute the GIF version that will be written on output.
+******************************************************************************/
+char *
+EGifGetGifVersion(GifFileType *GifFile)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+ int i, j;
+
+ /* Bulletproofing - always write GIF89 if we need to */
+ for (i = 0; i < GifFile->ImageCount; i++) {
+ for (j = 0; j < GifFile->SavedImages[i].ExtensionBlockCount; j++) {
+ int function =
+ GifFile->SavedImages[i].ExtensionBlocks[j].Function;
+
+ if (function == COMMENT_EXT_FUNC_CODE
+ || function == GRAPHICS_EXT_FUNC_CODE
+ || function == PLAINTEXT_EXT_FUNC_CODE
+ || function == APPLICATION_EXT_FUNC_CODE)
+ Private->gif89 = true;
+ }
+ }
+ for (i = 0; i < GifFile->ExtensionBlockCount; i++) {
+ int function = GifFile->ExtensionBlocks[i].Function;
+
+ if (function == COMMENT_EXT_FUNC_CODE
+ || function == GRAPHICS_EXT_FUNC_CODE
+ || function == PLAINTEXT_EXT_FUNC_CODE
+ || function == APPLICATION_EXT_FUNC_CODE)
+ Private->gif89 = true;
+ }
+
+ if (Private->gif89)
+ return GIF89_STAMP;
+ else
+ return GIF87_STAMP;
+}
+
+/******************************************************************************
+ All writes to the GIF should go through this.
+******************************************************************************/
+static int InternalWrite(GifFileType *GifFileOut,
+ const unsigned char *buf, size_t len)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType*)GifFileOut->Private;
+ if (Private->Write)
+ return Private->Write(GifFileOut,buf,len);
+ else
+ return fwrite(buf, 1, len, Private->File);
+}
+
+/******************************************************************************
+ This routine should be called before any other EGif calls, immediately
+ following the GIF file opening.
+******************************************************************************/
+int
+EGifPutScreenDesc(GifFileType *GifFile,
+ const int Width,
+ const int Height,
+ const int ColorRes,
+ const int BackGround,
+ const ColorMapObject *ColorMap)
+{
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+ char *write_version;
+
+ if (Private->FileState & FILE_STATE_SCREEN) {
+ /* If already has screen descriptor - something is wrong! */
+ GifFile->Error = E_GIF_ERR_HAS_SCRN_DSCR;
+ return GIF_ERROR;
+ }
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ write_version = EGifGetGifVersion(GifFile);
+
+ /* First write the version prefix into the file. */
+ if (InternalWrite(GifFile, (unsigned char *)write_version,
+ strlen(write_version)) != strlen(write_version)) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+
+ GifFile->SWidth = Width;
+ GifFile->SHeight = Height;
+ GifFile->SColorResolution = ColorRes;
+ GifFile->SBackGroundColor = BackGround;
+ if (ColorMap) {
+ GifFile->SColorMap = GifMakeMapObject(ColorMap->ColorCount,
+ ColorMap->Colors);
+ if (GifFile->SColorMap == NULL) {
+ GifFile->Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+ } else
+ GifFile->SColorMap = NULL;
+
+ /*
+ * Put the logical screen descriptor into the file:
+ */
+ /* Logical Screen Descriptor: Dimensions */
+ (void)EGifPutWord(Width, GifFile);
+ (void)EGifPutWord(Height, GifFile);
+
+ /* Logical Screen Descriptor: Packed Fields */
+ /* Note: We have actual size of the color table default to the largest
+ * possible size (7+1 == 8 bits) because the decoder can use it to decide
+ * how to display the files.
+ */
+ Buf[0] = (ColorMap ? 0x80 : 0x00) | /* Yes/no global colormap */
+ ((ColorRes - 1) << 4) | /* Bits allocated to each primary color */
+ (ColorMap ? ColorMap->BitsPerPixel - 1 : 0x07 ); /* Actual size of the
+ color table. */
+ if (ColorMap != NULL && ColorMap->SortFlag)
+ Buf[0] |= 0x08;
+ Buf[1] = BackGround; /* Index into the ColorTable for background color */
+ Buf[2] = GifFile->AspectByte; /* Pixel Aspect Ratio */
+ InternalWrite(GifFile, Buf, 3);
+
+ /* If we have Global color map - dump it also: */
+ if (ColorMap != NULL) {
+ int i;
+ for (i = 0; i < ColorMap->ColorCount; i++) {
+ /* Put the ColorMap out also: */
+ Buf[0] = ColorMap->Colors[i].Red;
+ Buf[1] = ColorMap->Colors[i].Green;
+ Buf[2] = ColorMap->Colors[i].Blue;
+ if (InternalWrite(GifFile, Buf, 3) != 3) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ }
+ }
+
+ /* Mark this file as has screen descriptor, and no pixel written yet: */
+ Private->FileState |= FILE_STATE_SCREEN;
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine should be called before any attempt to dump an image - any
+ call to any of the pixel dump routines.
+******************************************************************************/
+int
+EGifPutImageDesc(GifFileType *GifFile,
+ const int Left,
+ const int Top,
+ const int Width,
+ const int Height,
+ const bool Interlace,
+ const ColorMapObject *ColorMap)
+{
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (Private->FileState & FILE_STATE_IMAGE &&
+ Private->PixelCount > 0xffff0000UL) {
+ /* If already has active image descriptor - something is wrong! */
+ GifFile->Error = E_GIF_ERR_HAS_IMAG_DSCR;
+ return GIF_ERROR;
+ }
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+ GifFile->Image.Left = Left;
+ GifFile->Image.Top = Top;
+ GifFile->Image.Width = Width;
+ GifFile->Image.Height = Height;
+ GifFile->Image.Interlace = Interlace;
+ if (ColorMap) {
+ GifFile->Image.ColorMap = GifMakeMapObject(ColorMap->ColorCount,
+ ColorMap->Colors);
+ if (GifFile->Image.ColorMap == NULL) {
+ GifFile->Error = E_GIF_ERR_NOT_ENOUGH_MEM;
+ return GIF_ERROR;
+ }
+ } else {
+ GifFile->Image.ColorMap = NULL;
+ }
+
+ /* Put the image descriptor into the file: */
+ Buf[0] = DESCRIPTOR_INTRODUCER; /* Image separator character. */
+ InternalWrite(GifFile, Buf, 1);
+ (void)EGifPutWord(Left, GifFile);
+ (void)EGifPutWord(Top, GifFile);
+ (void)EGifPutWord(Width, GifFile);
+ (void)EGifPutWord(Height, GifFile);
+ Buf[0] = (ColorMap ? 0x80 : 0x00) |
+ (Interlace ? 0x40 : 0x00) |
+ (ColorMap ? ColorMap->BitsPerPixel - 1 : 0);
+ InternalWrite(GifFile, Buf, 1);
+
+ /* If we have Global color map - dump it also: */
+ if (ColorMap != NULL) {
+ int i;
+ for (i = 0; i < ColorMap->ColorCount; i++) {
+ /* Put the ColorMap out also: */
+ Buf[0] = ColorMap->Colors[i].Red;
+ Buf[1] = ColorMap->Colors[i].Green;
+ Buf[2] = ColorMap->Colors[i].Blue;
+ if (InternalWrite(GifFile, Buf, 3) != 3) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ }
+ }
+ if (GifFile->SColorMap == NULL && GifFile->Image.ColorMap == NULL) {
+ GifFile->Error = E_GIF_ERR_NO_COLOR_MAP;
+ return GIF_ERROR;
+ }
+
+ /* Mark this file as has screen descriptor: */
+ Private->FileState |= FILE_STATE_IMAGE;
+ Private->PixelCount = (long)Width *(long)Height;
+
+ /* Reset compress algorithm parameters. */
+ (void)EGifSetupCompress(GifFile);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Put one full scanned line (Line) of length LineLen into GIF file.
+******************************************************************************/
+int
+EGifPutLine(GifFileType * GifFile, GifPixelType *Line, int LineLen)
+{
+ int i;
+ GifPixelType Mask;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ if (!LineLen)
+ LineLen = GifFile->Image.Width;
+ if (Private->PixelCount < (unsigned)LineLen) {
+ GifFile->Error = E_GIF_ERR_DATA_TOO_BIG;
+ return GIF_ERROR;
+ }
+ Private->PixelCount -= LineLen;
+
+ /* Make sure the codes are not out of bit range, as we might generate
+ * wrong code (because of overflow when we combine them) in this case: */
+ Mask = CodeMask[Private->BitsPerPixel];
+ for (i = 0; i < LineLen; i++)
+ Line[i] &= Mask;
+
+ return EGifCompressLine(GifFile, Line, LineLen);
+}
+
+/******************************************************************************
+ Put one pixel (Pixel) into GIF file.
+******************************************************************************/
+int
+EGifPutPixel(GifFileType *GifFile, GifPixelType Pixel)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ if (Private->PixelCount == 0) {
+ GifFile->Error = E_GIF_ERR_DATA_TOO_BIG;
+ return GIF_ERROR;
+ }
+ --Private->PixelCount;
+
+ /* Make sure the code is not out of bit range, as we might generate
+ * wrong code (because of overflow when we combine them) in this case: */
+ Pixel &= CodeMask[Private->BitsPerPixel];
+
+ return EGifCompressLine(GifFile, &Pixel, 1);
+}
+
+/******************************************************************************
+ Put a comment into GIF file using the GIF89 comment extension block.
+******************************************************************************/
+int
+EGifPutComment(GifFileType *GifFile, const char *Comment)
+{
+ unsigned int length = strlen(Comment);
+ char *buf;
+
+ length = strlen(Comment);
+ if (length <= 255) {
+ return EGifPutExtension(GifFile, COMMENT_EXT_FUNC_CODE,
+ length, Comment);
+ } else {
+ buf = (char *)Comment;
+ if (EGifPutExtensionLeader(GifFile, COMMENT_EXT_FUNC_CODE)
+ == GIF_ERROR) {
+ return GIF_ERROR;
+ }
+
+ /* Break the comment into 255 byte sub blocks */
+ while (length > 255) {
+ if (EGifPutExtensionBlock(GifFile, 255, buf) == GIF_ERROR) {
+ return GIF_ERROR;
+ }
+ buf = buf + 255;
+ length -= 255;
+ }
+ /* Output any partial block and the clear code. */
+ if (length > 0) {
+ if (EGifPutExtensionBlock(GifFile, length, buf) == GIF_ERROR) {
+ return GIF_ERROR;
+ }
+ }
+ if (EGifPutExtensionTrailer(GifFile) == GIF_ERROR) {
+ return GIF_ERROR;
+ }
+ }
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Begin an extension block (see GIF manual). More
+ extensions can be dumped using EGifPutExtensionBlock until
+ EGifPutExtensionTrailer is invoked.
+******************************************************************************/
+int
+EGifPutExtensionLeader(GifFileType *GifFile, const int ExtCode)
+{
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ Buf[0] = EXTENSION_INTRODUCER;
+ Buf[1] = ExtCode;
+ InternalWrite(GifFile, Buf, 2);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Put extension block data (see GIF manual) into a GIF file.
+******************************************************************************/
+int
+EGifPutExtensionBlock(GifFileType *GifFile,
+ const int ExtLen,
+ const void *Extension)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ Buf = ExtLen;
+ InternalWrite(GifFile, &Buf, 1);
+ InternalWrite(GifFile, Extension, ExtLen);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Put a terminating block (see GIF manual) into a GIF file.
+******************************************************************************/
+int
+EGifPutExtensionTrailer(GifFileType *GifFile) {
+
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ /* Write the block terminator */
+ Buf = 0;
+ InternalWrite(GifFile, &Buf, 1);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Put an extension block (see GIF manual) into a GIF file.
+ Warning: This function is only useful for Extension blocks that have at
+ most one subblock. Extensions with more than one subblock need to use the
+ EGifPutExtension{Leader,Block,Trailer} functions instead.
+******************************************************************************/
+int
+EGifPutExtension(GifFileType *GifFile,
+ const int ExtCode,
+ const int ExtLen,
+ const void *Extension) {
+
+ GifByteType Buf[3];
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ if (ExtCode == 0)
+ InternalWrite(GifFile, (GifByteType *)&ExtLen, 1);
+ else {
+ Buf[0] = EXTENSION_INTRODUCER;
+ Buf[1] = ExtCode; /* Extension Label */
+ Buf[2] = ExtLen; /* Extension length */
+ InternalWrite(GifFile, Buf, 3);
+ }
+ InternalWrite(GifFile, Extension, ExtLen);
+ Buf[0] = 0;
+ InternalWrite(GifFile, Buf, 1);
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Render a Graphics Control Block as raw extension data
+******************************************************************************/
+
+size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
+ GifByteType *GifExtension)
+{
+ GifExtension[0] = 0;
+ GifExtension[0] |= (GCB->TransparentColor == NO_TRANSPARENT_COLOR) ? 0x00 : 0x01;
+ GifExtension[0] |= GCB->UserInputFlag ? 0x02 : 0x00;
+ GifExtension[0] |= ((GCB->DisposalMode & 0x07) << 2);
+ GifExtension[1] = LOBYTE(GCB->DelayTime);
+ GifExtension[2] = HIBYTE(GCB->DelayTime);
+ GifExtension[3] = (char)GCB->TransparentColor;
+ return 4;
+}
+
+/******************************************************************************
+ Replace the Graphics Control Block for a saved image, if it exists.
+******************************************************************************/
+
+int EGifGCBToSavedExtension(const GraphicsControlBlock *GCB,
+ GifFileType *GifFile, int ImageIndex)
+{
+ int i;
+ size_t Len;
+ GifByteType buf[sizeof(GraphicsControlBlock)]; /* a bit dodgy... */
+
+ if (ImageIndex < 0 || ImageIndex > GifFile->ImageCount - 1)
+ return GIF_ERROR;
+
+ for (i = 0; i < GifFile->SavedImages[ImageIndex].ExtensionBlockCount; i++) {
+ ExtensionBlock *ep = &GifFile->SavedImages[ImageIndex].ExtensionBlocks[i];
+ if (ep->Function == GRAPHICS_EXT_FUNC_CODE) {
+ EGifGCBToExtension(GCB, ep->Bytes);
+ return GIF_OK;
+ }
+ }
+
+ Len = EGifGCBToExtension(GCB, (GifByteType *)buf);
+ if (GifAddExtensionBlock(&GifFile->SavedImages[ImageIndex].ExtensionBlockCount,
+ &GifFile->SavedImages[ImageIndex].ExtensionBlocks,
+ GRAPHICS_EXT_FUNC_CODE,
+ Len,
+ (unsigned char *)buf) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ return (GIF_OK);
+}
+
+/******************************************************************************
+ Put the image code in compressed form. This routine can be called if the
+ information needed to be piped out as is. Obviously this is much faster
+ than decoding and encoding again. This routine should be followed by calls
+ to EGifPutCodeNext, until NULL block is given.
+ The block should NOT be freed by the user (not dynamically allocated).
+******************************************************************************/
+int
+EGifPutCode(GifFileType *GifFile, int CodeSize, const GifByteType *CodeBlock)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ /* No need to dump code size as Compression set up does any for us: */
+ /*
+ * Buf = CodeSize;
+ * if (InternalWrite(GifFile, &Buf, 1) != 1) {
+ * GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ * return GIF_ERROR;
+ * }
+ */
+
+ return EGifPutCodeNext(GifFile, CodeBlock);
+}
+
+/******************************************************************************
+ Continue to put the image code in compressed form. This routine should be
+ called with blocks of code as read via DGifGetCode/DGifGetCodeNext. If
+ given buffer pointer is NULL, empty block is written to mark end of code.
+******************************************************************************/
+int
+EGifPutCodeNext(GifFileType *GifFile, const GifByteType *CodeBlock)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *)GifFile->Private;
+
+ if (CodeBlock != NULL) {
+ if (InternalWrite(GifFile, CodeBlock, CodeBlock[0] + 1)
+ != (unsigned)(CodeBlock[0] + 1)) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ } else {
+ Buf = 0;
+ if (InternalWrite(GifFile, &Buf, 1) != 1) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ Private->PixelCount = 0; /* And local info. indicate image read. */
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine should be called last, to close the GIF file.
+******************************************************************************/
+int
+EGifCloseFile(GifFileType *GifFile)
+{
+ GifByteType Buf;
+ GifFilePrivateType *Private;
+ FILE *File;
+
+ if (GifFile == NULL)
+ return GIF_ERROR;
+
+ Private = (GifFilePrivateType *) GifFile->Private;
+ if (Private == NULL)
+ return GIF_ERROR;
+ if (!IS_WRITEABLE(Private)) {
+ /* This file was NOT open for writing: */
+ GifFile->Error = E_GIF_ERR_NOT_WRITEABLE;
+ return GIF_ERROR;
+ }
+
+ File = Private->File;
+
+ Buf = TERMINATOR_INTRODUCER;
+ InternalWrite(GifFile, &Buf, 1);
+
+ if (GifFile->Image.ColorMap) {
+ GifFreeMapObject(GifFile->Image.ColorMap);
+ GifFile->Image.ColorMap = NULL;
+ }
+ if (GifFile->SColorMap) {
+ GifFreeMapObject(GifFile->SColorMap);
+ GifFile->SColorMap = NULL;
+ }
+ if (Private) {
+ if (Private->HashTable) {
+ free((char *) Private->HashTable);
+ }
+ free((char *) Private);
+ }
+
+ if (File && fclose(File) != 0) {
+ GifFile->Error = E_GIF_ERR_CLOSE_FAILED;
+ return GIF_ERROR;
+ }
+
+ /*
+ * Without the #ifndef, we get spurious warnings because Coverity mistakenly
+ * thinks the GIF structure is freed on an error return.
+ */
+#ifndef __COVERITY__
+ free(GifFile);
+#endif /* __COVERITY__ */
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ Put 2 bytes (a word) into the given file in little-endian order:
+******************************************************************************/
+static int
+EGifPutWord(int Word, GifFileType *GifFile)
+{
+ unsigned char c[2];
+
+ c[0] = LOBYTE(Word);
+ c[1] = HIBYTE(Word);
+ if (InternalWrite(GifFile, c, 2) == 2)
+ return GIF_OK;
+ else
+ return GIF_ERROR;
+}
+
+/******************************************************************************
+ Setup the LZ compression for this image:
+******************************************************************************/
+static int
+EGifSetupCompress(GifFileType *GifFile)
+{
+ int BitsPerPixel;
+ GifByteType Buf;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ /* Test and see what color map to use, and from it # bits per pixel: */
+ if (GifFile->Image.ColorMap)
+ BitsPerPixel = GifFile->Image.ColorMap->BitsPerPixel;
+ else if (GifFile->SColorMap)
+ BitsPerPixel = GifFile->SColorMap->BitsPerPixel;
+ else {
+ GifFile->Error = E_GIF_ERR_NO_COLOR_MAP;
+ return GIF_ERROR;
+ }
+
+ Buf = BitsPerPixel = (BitsPerPixel < 2 ? 2 : BitsPerPixel);
+ InternalWrite(GifFile, &Buf, 1); /* Write the Code size to file. */
+
+ Private->Buf[0] = 0; /* Nothing was output yet. */
+ Private->BitsPerPixel = BitsPerPixel;
+ Private->ClearCode = (1 << BitsPerPixel);
+ Private->EOFCode = Private->ClearCode + 1;
+ Private->RunningCode = Private->EOFCode + 1;
+ Private->RunningBits = BitsPerPixel + 1; /* Number of bits per code. */
+ Private->MaxCode1 = 1 << Private->RunningBits; /* Max. code + 1. */
+ Private->CrntCode = FIRST_CODE; /* Signal that this is first one! */
+ Private->CrntShiftState = 0; /* No information in CrntShiftDWord. */
+ Private->CrntShiftDWord = 0;
+
+ /* Clear hash table and send Clear to make sure the decoder do the same. */
+ _ClearHashTable(Private->HashTable);
+
+ if (EGifCompressOutput(GifFile, Private->ClearCode) == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ return GIF_OK;
+}
+
+/******************************************************************************
+ The LZ compression routine:
+ This version compresses the given buffer Line of length LineLen.
+ This routine can be called a few times (one per scan line, for example), in
+ order to complete the whole image.
+******************************************************************************/
+static int
+EGifCompressLine(GifFileType *GifFile,
+ GifPixelType *Line,
+ const int LineLen)
+{
+ int i = 0, CrntCode, NewCode;
+ unsigned long NewKey;
+ GifPixelType Pixel;
+ GifHashTableType *HashTable;
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+
+ HashTable = Private->HashTable;
+
+ if (Private->CrntCode == FIRST_CODE) /* Its first time! */
+ CrntCode = Line[i++];
+ else
+ CrntCode = Private->CrntCode; /* Get last code in compression. */
+
+ while (i < LineLen) { /* Decode LineLen items. */
+ Pixel = Line[i++]; /* Get next pixel from stream. */
+ /* Form a new unique key to search hash table for the code combines
+ * CrntCode as Prefix string with Pixel as postfix char.
+ */
+ NewKey = (((uint32_t) CrntCode) << 8) + Pixel;
+ if ((NewCode = _ExistsHashTable(HashTable, NewKey)) >= 0) {
+ /* This Key is already there, or the string is old one, so
+ * simple take new code as our CrntCode:
+ */
+ CrntCode = NewCode;
+ } else {
+ /* Put it in hash table, output the prefix code, and make our
+ * CrntCode equal to Pixel.
+ */
+ if (EGifCompressOutput(GifFile, CrntCode) == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ CrntCode = Pixel;
+
+ /* If however the HashTable if full, we send a clear first and
+ * Clear the hash table.
+ */
+ if (Private->RunningCode >= LZ_MAX_CODE) {
+ /* Time to do some clearance: */
+ if (EGifCompressOutput(GifFile, Private->ClearCode)
+ == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ Private->RunningCode = Private->EOFCode + 1;
+ Private->RunningBits = Private->BitsPerPixel + 1;
+ Private->MaxCode1 = 1 << Private->RunningBits;
+ _ClearHashTable(HashTable);
+ } else {
+ /* Put this unique key with its relative Code in hash table: */
+ _InsertHashTable(HashTable, NewKey, Private->RunningCode++);
+ }
+ }
+
+ }
+
+ /* Preserve the current state of the compression algorithm: */
+ Private->CrntCode = CrntCode;
+
+ if (Private->PixelCount == 0) {
+ /* We are done - output last Code and flush output buffers: */
+ if (EGifCompressOutput(GifFile, CrntCode) == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ if (EGifCompressOutput(GifFile, Private->EOFCode) == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ if (EGifCompressOutput(GifFile, FLUSH_OUTPUT) == GIF_ERROR) {
+ GifFile->Error = E_GIF_ERR_DISK_IS_FULL;
+ return GIF_ERROR;
+ }
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ The LZ compression output routine:
+ This routine is responsible for the compression of the bit stream into
+ 8 bits (bytes) packets.
+ Returns GIF_OK if written successfully.
+******************************************************************************/
+static int
+EGifCompressOutput(GifFileType *GifFile,
+ const int Code)
+{
+ GifFilePrivateType *Private = (GifFilePrivateType *) GifFile->Private;
+ int retval = GIF_OK;
+
+ if (Code == FLUSH_OUTPUT) {
+ while (Private->CrntShiftState > 0) {
+ /* Get Rid of what is left in DWord, and flush it. */
+ if (EGifBufferedOutput(GifFile, Private->Buf,
+ Private->CrntShiftDWord & 0xff) == GIF_ERROR)
+ retval = GIF_ERROR;
+ Private->CrntShiftDWord >>= 8;
+ Private->CrntShiftState -= 8;
+ }
+ Private->CrntShiftState = 0; /* For next time. */
+ if (EGifBufferedOutput(GifFile, Private->Buf,
+ FLUSH_OUTPUT) == GIF_ERROR)
+ retval = GIF_ERROR;
+ } else {
+ Private->CrntShiftDWord |= ((long)Code) << Private->CrntShiftState;
+ Private->CrntShiftState += Private->RunningBits;
+ while (Private->CrntShiftState >= 8) {
+ /* Dump out full bytes: */
+ if (EGifBufferedOutput(GifFile, Private->Buf,
+ Private->CrntShiftDWord & 0xff) == GIF_ERROR)
+ retval = GIF_ERROR;
+ Private->CrntShiftDWord >>= 8;
+ Private->CrntShiftState -= 8;
+ }
+ }
+
+ /* If code cannt fit into RunningBits bits, must raise its size. Note */
+ /* however that codes above 4095 are used for special signaling. */
+ if (Private->RunningCode >= Private->MaxCode1 && Code <= 4095) {
+ Private->MaxCode1 = 1 << ++Private->RunningBits;
+ }
+
+ return retval;
+}
+
+/******************************************************************************
+ This routines buffers the given characters until 255 characters are ready
+ to be output. If Code is equal to -1 the buffer is flushed (EOF).
+ The buffer is Dumped with first byte as its size, as GIF format requires.
+ Returns GIF_OK if written successfully.
+******************************************************************************/
+static int
+EGifBufferedOutput(GifFileType *GifFile,
+ GifByteType *Buf,
+ int c)
+{
+ if (c == FLUSH_OUTPUT) {
+ /* Flush everything out. */
+ if (Buf[0] != 0
+ && InternalWrite(GifFile, Buf, Buf[0] + 1) != (unsigned)(Buf[0] + 1)) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ /* Mark end of compressed data, by an empty block (see GIF doc): */
+ Buf[0] = 0;
+ if (InternalWrite(GifFile, Buf, 1) != 1) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ } else {
+ if (Buf[0] == 255) {
+ /* Dump out this buffer - it is full: */
+ if (InternalWrite(GifFile, Buf, Buf[0] + 1) != (unsigned)(Buf[0] + 1)) {
+ GifFile->Error = E_GIF_ERR_WRITE_FAILED;
+ return GIF_ERROR;
+ }
+ Buf[0] = 0;
+ }
+ Buf[++Buf[0]] = c;
+ }
+
+ return GIF_OK;
+}
+
+/******************************************************************************
+ This routine writes to disk an in-core representation of a GIF previously
+ created by DGifSlurp().
+******************************************************************************/
+
+static int
+EGifWriteExtensions(GifFileType *GifFileOut,
+ ExtensionBlock *ExtensionBlocks,
+ int ExtensionBlockCount)
+{
+ if (ExtensionBlocks) {
+ ExtensionBlock *ep;
+ int j;
+
+ for (j = 0; j < ExtensionBlockCount; j++) {
+ ep = &ExtensionBlocks[j];
+ if (ep->Function != CONTINUE_EXT_FUNC_CODE)
+ if (EGifPutExtensionLeader(GifFileOut, ep->Function) == GIF_ERROR)
+ return (GIF_ERROR);
+ if (EGifPutExtensionBlock(GifFileOut, ep->ByteCount, ep->Bytes) == GIF_ERROR)
+ return (GIF_ERROR);
+ if (j == ExtensionBlockCount - 1 || (ep+1)->Function != CONTINUE_EXT_FUNC_CODE)
+ if (EGifPutExtensionTrailer(GifFileOut) == GIF_ERROR)
+ return (GIF_ERROR);
+ }
+ }
+
+ return (GIF_OK);
+}
+
+int
+EGifSpew(GifFileType *GifFileOut)
+{
+ int i, j;
+
+ if (EGifPutScreenDesc(GifFileOut,
+ GifFileOut->SWidth,
+ GifFileOut->SHeight,
+ GifFileOut->SColorResolution,
+ GifFileOut->SBackGroundColor,
+ GifFileOut->SColorMap) == GIF_ERROR) {
+ return (GIF_ERROR);
+ }
+
+ for (i = 0; i < GifFileOut->ImageCount; i++) {
+ SavedImage *sp = &GifFileOut->SavedImages[i];
+ int SavedHeight = sp->ImageDesc.Height;
+ int SavedWidth = sp->ImageDesc.Width;
+
+ /* this allows us to delete images by nuking their rasters */
+ if (sp->RasterBits == NULL)
+ continue;
+
+ if (EGifWriteExtensions(GifFileOut,
+ sp->ExtensionBlocks,
+ sp->ExtensionBlockCount) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ if (EGifPutImageDesc(GifFileOut,
+ sp->ImageDesc.Left,
+ sp->ImageDesc.Top,
+ SavedWidth,
+ SavedHeight,
+ sp->ImageDesc.Interlace,
+ sp->ImageDesc.ColorMap) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ if (sp->ImageDesc.Interlace) {
+ /*
+ * The way an interlaced image should be written -
+ * offsets and jumps...
+ */
+ int InterlacedOffset[] = { 0, 4, 2, 1 };
+ int InterlacedJumps[] = { 8, 8, 4, 2 };
+ int k;
+ /* Need to perform 4 passes on the images: */
+ for (k = 0; k < 4; k++)
+ for (j = InterlacedOffset[k];
+ j < SavedHeight;
+ j += InterlacedJumps[k]) {
+ if (EGifPutLine(GifFileOut,
+ sp->RasterBits + j * SavedWidth,
+ SavedWidth) == GIF_ERROR)
+ return (GIF_ERROR);
+ }
+ } else {
+ for (j = 0; j < SavedHeight; j++) {
+ if (EGifPutLine(GifFileOut,
+ sp->RasterBits + j * SavedWidth,
+ SavedWidth) == GIF_ERROR)
+ return (GIF_ERROR);
+ }
+ }
+ }
+
+ if (EGifWriteExtensions(GifFileOut,
+ GifFileOut->ExtensionBlocks,
+ GifFileOut->ExtensionBlockCount) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ if (EGifCloseFile(GifFileOut) == GIF_ERROR)
+ return (GIF_ERROR);
+
+ return (GIF_OK);
+}
+
+/* end */
View
97 deps/giflib/gif_err.c
@@ -0,0 +1,97 @@
+/*****************************************************************************
+
+gif_err.c - handle error reporting for the GIF library.
+
+****************************************************************************/
+
+#include <stdio.h>
+
+#include "gif_lib.h"
+#include "gif_lib_private.h"
+
+/*****************************************************************************
+ Return a string description of the last GIF error
+*****************************************************************************/
+char *
+GifErrorString(int ErrorCode)
+{
+ char *Err;
+
+ switch (ErrorCode) {
+ case E_GIF_ERR_OPEN_FAILED:
+ Err = "Failed to open given file";
+ break;
+ case E_GIF_ERR_WRITE_FAILED:
+ Err = "Failed to write to given file";
+ break;
+ case E_GIF_ERR_HAS_SCRN_DSCR:
+ Err = "Screen descriptor has already been set";
+ break;
+ case E_GIF_ERR_HAS_IMAG_DSCR:
+ Err = "Image descriptor is still active";
+ break;
+ case E_GIF_ERR_NO_COLOR_MAP:
+ Err = "Neither global nor local color map";
+ break;
+ case E_GIF_ERR_DATA_TOO_BIG:
+ Err = "Number of pixels bigger than width * height";
+ break;
+ case E_GIF_ERR_NOT_ENOUGH_MEM:
+ Err = "Failed to allocate required memory";
+ break;
+ case E_GIF_ERR_DISK_IS_FULL:
+ Err = "Write failed (disk full?)";
+ break;
+ case E_GIF_ERR_CLOSE_FAILED:
+ Err = "Failed to close given file";
+ break;
+ case E_GIF_ERR_NOT_WRITEABLE:
+ Err = "Given file was not opened for write";
+ break;
+ case D_GIF_ERR_OPEN_FAILED:
+ Err = "Failed to open given file";
+ break;
+ case D_GIF_ERR_READ_FAILED:
+ Err = "Failed to read from given file";
+ break;
+ case D_GIF_ERR_NOT_GIF_FILE:
+ Err = "Data is not in GIF format";
+ break;
+ case D_GIF_ERR_NO_SCRN_DSCR:
+ Err = "No screen descriptor detected";
+ break;
+ case D_GIF_ERR_NO_IMAG_DSCR:
+ Err = "No Image Descriptor detected";
+ break;
+ case D_GIF_ERR_NO_COLOR_MAP:
+ Err = "Neither global nor local color map";
+ break;
+ case D_GIF_ERR_WRONG_RECORD:
+ Err = "Wrong record type detected";
+ break;
+ case D_GIF_ERR_DATA_TOO_BIG:
+ Err = "Number of pixels bigger than width * height";
+ break;
+ case D_GIF_ERR_NOT_ENOUGH_MEM:
+ Err = "Failed to allocate required memory";
+ break;
+ case D_GIF_ERR_CLOSE_FAILED:
+ Err = "Failed to close given file";
+ break;
+ case D_GIF_ERR_NOT_READABLE:
+ Err = "Given file was not opened for read";
+ break;
+ case D_GIF_ERR_IMAGE_DEFECT:
+ Err = "Image is defective, decoding aborted";
+ break;
+ case D_GIF_ERR_EOF_TOO_SOON:
+ Err = "Image EOF detected before image complete";
+ break;
+ default:
+ Err = NULL;
+ break;
+ }
+ return Err;
+}
+
+/* end */
View
252 deps/giflib/gif_font.c
@@ -0,0 +1,252 @@
+/*****************************************************************************
+
+gif_font.c - utility font handling and simple drawing for the GIF library
+
+****************************************************************************/
+
+#include <string.h>
+
+#include "gif_lib.h"
+
+/*****************************************************************************
+ Ascii 8 by 8 regular font - only first 128 characters are supported.
+*****************************************************************************/
+
+/*
+ * Each array entry holds the bits for 8 horizontal scan lines, topmost
+ * first. The most significant bit of each constant is the leftmost bit of
+ * the scan line.
+ */
+/*@+charint@*/
+const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH] = {
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* Ascii 0 */
+ {0x3c, 0x42, 0xa5, 0x81, 0xbd, 0x42, 0x3c, 0x00}, /* Ascii 1 */
+ {0x3c, 0x7e, 0xdb, 0xff, 0xc3, 0x7e, 0x3c, 0x00}, /* Ascii 2 */
+ {0x00, 0xee, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 3 */
+ {0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 4 */
+ {0x00, 0x3c, 0x18, 0xff, 0xff, 0x08, 0x18, 0x00}, /* Ascii 5 */
+ {0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x10, 0x38, 0x00}, /* Ascii 6 */
+ {0x00, 0x00, 0x18, 0x3c, 0x18, 0x00, 0x00, 0x00}, /* Ascii 7 */
+ {0xff, 0xff, 0xe7, 0xc3, 0xe7, 0xff, 0xff, 0xff}, /* Ascii 8 */
+ {0x00, 0x3c, 0x42, 0x81, 0x81, 0x42, 0x3c, 0x00}, /* Ascii 9 */
+ {0xff, 0xc3, 0xbd, 0x7e, 0x7e, 0xbd, 0xc3, 0xff}, /* Ascii 10 */
+ {0x1f, 0x07, 0x0d, 0x7c, 0xc6, 0xc6, 0x7c, 0x00}, /* Ascii 11 */
+ {0x00, 0x7e, 0xc3, 0xc3, 0x7e, 0x18, 0x7e, 0x18}, /* Ascii 12 */
+ {0x04, 0x06, 0x07, 0x04, 0x04, 0xfc, 0xf8, 0x00}, /* Ascii 13 */
+ {0x0c, 0x0a, 0x0d, 0x0b, 0xf9, 0xf9, 0x1f, 0x1f}, /* Ascii 14 */
+ {0x00, 0x92, 0x7c, 0x44, 0xc6, 0x7c, 0x92, 0x00}, /* Ascii 15 */
+ {0x00, 0x00, 0x60, 0x78, 0x7e, 0x78, 0x60, 0x00}, /* Ascii 16 */
+ {0x00, 0x00, 0x06, 0x1e, 0x7e, 0x1e, 0x06, 0x00}, /* Ascii 17 */
+ {0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18}, /* Ascii 18 */
+ {0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00}, /* Ascii 19 */
+ {0xff, 0xb6, 0x76, 0x36, 0x36, 0x36, 0x36, 0x00}, /* Ascii 20 */
+ {0x7e, 0xc1, 0xdc, 0x22, 0x22, 0x1f, 0x83, 0x7e}, /* Ascii 21 */
+ {0x00, 0x00, 0x00, 0x7e, 0x7e, 0x00, 0x00, 0x00}, /* Ascii 22 */
+ {0x18, 0x7e, 0x18, 0x18, 0x7e, 0x18, 0x00, 0xff}, /* Ascii 23 */
+ {0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}, /* Ascii 24 */
+ {0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x00}, /* Ascii 25 */
+ {0x00, 0x04, 0x06, 0xff, 0x06, 0x04, 0x00, 0x00}, /* Ascii 26 */
+ {0x00, 0x20, 0x60, 0xff, 0x60, 0x20, 0x00, 0x00}, /* Ascii 27 */
+ {0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xff, 0x00}, /* Ascii 28 */
+ {0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00}, /* Ascii 29 */
+ {0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x00, 0x00}, /* Ascii 30 */
+ {0x00, 0x00, 0x00, 0xfe, 0x7c, 0x38, 0x10, 0x00}, /* Ascii 31 */
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* */
+ {0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x00}, /* ! */
+ {0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* " */
+ {0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00}, /* # */
+ {0x10, 0x7c, 0xd2, 0x7c, 0x86, 0x7c, 0x10, 0x00}, /* $ */
+ {0xf0, 0x96, 0xfc, 0x18, 0x3e, 0x72, 0xde, 0x00}, /* % */
+ {0x30, 0x48, 0x30, 0x78, 0xce, 0xcc, 0x78, 0x00}, /* & */
+ {0x0c, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ' */
+ {0x10, 0x60, 0xc0, 0xc0, 0xc0, 0x60, 0x10, 0x00}, /* ( */
+ {0x10, 0x0c, 0x06, 0x06, 0x06, 0x0c, 0x10, 0x00}, /* ) */
+ {0x00, 0x54, 0x38, 0xfe, 0x38, 0x54, 0x00, 0x00}, /* * */
+ {0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00}, /* + */
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x70}, /* , */
+ {0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00}, /* - */
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00}, /* . */
+ {0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00}, /* / */
+ {0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* 0 */
+ {0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* 1 */
+ {0x7c, 0xc6, 0x06, 0x0c, 0x30, 0x60, 0xfe, 0x00}, /* 2 */
+ {0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00}, /* 3 */
+ {0x0e, 0x1e, 0x36, 0x66, 0xfe, 0x06, 0x06, 0x00}, /* 4 */
+ {0xfe, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0xfc, 0x00}, /* 5 */
+ {0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00}, /* 6 */
+ {0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x60, 0x00}, /* 7 */
+ {0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00}, /* 8 */
+ {0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00}, /* 9 */
+ {0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00}, /* : */
+ {0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x20, 0x00}, /* }, */
+ {0x00, 0x1c, 0x30, 0x60, 0x30, 0x1c, 0x00, 0x00}, /* < */
+ {0x00, 0x00, 0x7e, 0x00, 0x7e, 0x00, 0x00, 0x00}, /* = */
+ {0x00, 0x70, 0x18, 0x0c, 0x18, 0x70, 0x00, 0x00}, /* > */
+ {0x7c, 0xc6, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00}, /* ? */
+ {0x7c, 0x82, 0x9a, 0xaa, 0xaa, 0x9e, 0x7c, 0x00}, /* @ */
+ {0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x00}, /* A */
+ {0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xfc, 0x00}, /* B */
+ {0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x00}, /* C */
+ {0xf8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00}, /* D */
+ {0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xfe, 0x00}, /* E */
+ {0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0x00}, /* F */
+ {0x7c, 0xc6, 0xc0, 0xce, 0xc6, 0xc6, 0x7e, 0x00}, /* G */
+ {0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00}, /* H */
+ {0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00}, /* I */
+ {0x1e, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00}, /* J */
+ {0xc6, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0xc6, 0x00}, /* K */
+ {0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00}, /* L */
+ {0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0x00}, /* M */
+ {0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00}, /* N */
+ {0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* O */
+ {0xfc, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0x00}, /* P */
+ {0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x06}, /* Q */
+ {0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0x00}, /* R */
+ {0x78, 0xcc, 0x60, 0x30, 0x18, 0xcc, 0x78, 0x00}, /* S */
+ {0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00}, /* T */
+ {0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* U */
+ {0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00}, /* V */
+ {0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00}, /* W */
+ {0xc6, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0xc6, 0x00}, /* X */
+ {0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00}, /* Y */
+ {0xfe, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00}, /* Z */
+ {0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00}, /* [ */
+ {0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x00}, /* \ */
+ {0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00}, /* ] */
+ {0x00, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00}, /* ^ */
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}, /* _ */
+ {0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, /* ` */
+ {0x00, 0x00, 0x7c, 0x06, 0x7e, 0xc6, 0x7e, 0x00}, /* a */
+ {0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0x00}, /* b */
+ {0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0x7e, 0x00}, /* c */
+ {0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x00}, /* d */
+ {0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7e, 0x00}, /* e */
+ {0x1e, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x30, 0x00}, /* f */
+ {0x00, 0x00, 0x7e, 0xc6, 0xce, 0x76, 0x06, 0x7c}, /* g */
+ {0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00}, /* */
+ {0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* i */
+ {0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0xf0}, /* j */
+ {0xc0, 0xc0, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0x00}, /* k */
+ {0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00}, /* l */
+ {0x00, 0x00, 0xcc, 0xfe, 0xd6, 0xc6, 0xc6, 0x00}, /* m */
+ {0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00}, /* n */
+ {0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00}, /* o */
+ {0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0xc0}, /* p */
+ {0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x06}, /* q */
+ {0x00, 0x00, 0x6e, 0x70, 0x60, 0x60, 0x60, 0x00}, /* r */
+ {0x00, 0x00, 0x7c, 0xc0, 0x7c, 0x06, 0xfc, 0x00}, /* s */
+ {0x30, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x1c, 0x00}, /* t */
+ {0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00}, /* u */
+ {0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00}, /* v */
+ {0x00, 0x00, 0xc6, 0xc6, 0xd6, 0xfe, 0x6c, 0x00}, /* w */
+ {0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00}, /* x */
+ {0x00, 0x00, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x7c}, /* y */
+ {0x00, 0x00, 0xfc, 0x18, 0x30, 0x60, 0xfc, 0x00}, /* z */
+ {0x0e, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0e, 0x00}, /* { */
+ {0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, /* | */
+ {0xe0, 0x30, 0x30, 0x1c, 0x30, 0x30, 0xe0, 0x00}, /* } */
+ {0x00, 0x00, 0x70, 0x9a, 0x0e, 0x00, 0x00, 0x00}, /* ~ */
+ {0x00, 0x00, 0x18, 0x3c, 0x66, 0xff, 0x00, 0x00} /* Ascii 127 */