coffeecake 0.0.1

data/node_modules/jasmine-reporters/ext/phantomjs/src/gif/gif.pri

@@ -0,0 +1,20 @@
+VPATH += $$PWD
+INCLUDEPATH += $$PWD
+
+DEFINES += HAVE_CONFIG_H
+DEFINES += HAVE_STDINT_H
+DEFINES += HAVE_FCNTL_H
+DEFINES += HAVE_UNISTD_H
+DEFINES += HAVE_STDARG_H
+
+SOURCES += gif_err.c
+SOURCES += gifalloc.c
+SOURCES += egif_lib.c
+SOURCES += gif_hash.c
+SOURCES += quantize.c
+SOURCES += gifwriter.cpp
+
+HEADERS += gif_hash.h
+HEADERS += gif_lib_private.h
+HEADERS += gif_lib.h
+HEADERS += gifwriter.h

data/node_modules/jasmine-reporters/ext/phantomjs/src/gif/gif_err.c

@@ -0,0 +1,120 @@
+/*****************************************************************************
+ *   "Gif-Lib" - Yet another gif library.                     
+ *                                         
+ * Written by:  Gershon Elber            IBM PC Ver 0.1,    Jun. 1989    
+ *****************************************************************************
+ * Handle error reporting for the GIF library.                     
+ *****************************************************************************
+ * History:                                     
+ * 17 Jun 89 - Version 1.0 by Gershon Elber.                     
+ ****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include "gif_lib.h"
+
+int _GifError = 0;
+
+/*****************************************************************************
+ * Return the last GIF error (0 if none) and reset the error.             
+ ****************************************************************************/
+int
+GifLastError(void) {
+    int i = _GifError;
+
+    _GifError = 0;
+
+    return i;
+}
+#ifndef _GBA_NO_FILEIO
+
+/*****************************************************************************
+ * Print the last GIF error to stderr.                         
+ ****************************************************************************/
+void
+PrintGifError(void) {
+    char *Err;
+
+    switch (_GifError) {
+      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 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 = "#Pixels bigger than Width * Height";
+        break;
+      case E_GIF_ERR_NOT_ENOUGH_MEM:
+        Err = "Fail 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 = "Given file is NOT GIF file";
+        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 = "#Pixels bigger than Width * Height";
+        break;
+      case D_GIF_ERR_NOT_ENOUGH_MEM:
+        Err = "Fail 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;
+    }
+    if (Err != NULL)
+        fprintf(stderr, "\nGIF-LIB error: %s.\n", Err);
+    else
+        fprintf(stderr, "\nGIF-LIB undefined error %d.\n", _GifError);
+}
+#endif /* _GBA_NO_FILEIO */

data/node_modules/jasmine-reporters/ext/phantomjs/src/gif/gif_hash.c

@@ -0,0 +1,160 @@
+/*****************************************************************************
+*   "Gif-Lib" - Yet another gif library.				     *
+*									     *
+* Written by:  Gershon Elber			IBM PC Ver 0.1,	Jun. 1989    *
+******************************************************************************
+* Module to support the following operations:				     *
+*									     *
+* 1. InitHashTable - initialize hash table.				     *
+* 2. ClearHashTable - clear the hash table to an empty state.		     *
+* 2. InsertHashTable - insert one item into data structure.		     *
+* 3. ExistsHashTable - test if item exists in data structure.		     *
+*									     *
+* This module is used to hash the GIF codes during encoding.		     *
+******************************************************************************
+* History:								     *
+* 14 Jun 89 - Version 1.0 by Gershon Elber.				     *
+*****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* Find a thirty-two bit int type */
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef __MSDOS__
+#include <io.h>
+#include <alloc.h>
+#include <sys\stat.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif /* __MSDOS__ */
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif /* HAVE_FCNTL_H */
+#include <stdio.h>
+#include <string.h>
+#include "gif_lib.h"
+#include "gif_hash.h"
+#include "gif_lib_private.h"
+
+/* #define  DEBUG_HIT_RATE    Debug number of misses per hash Insert/Exists. */
+
+#ifdef	DEBUG_HIT_RATE
+static long NumberOfTests = 0,
+	    NumberOfMisses = 0;
+#endif	/* DEBUG_HIT_RATE */
+
+static int KeyItem(UINT32 Item);
+
+/******************************************************************************
+* Initialize HashTable - allocate the memory needed and clear it.	      *
+******************************************************************************/
+GifHashTableType *_InitHashTable(void)
+{
+    GifHashTableType *HashTable;
+
+    if ((HashTable = (GifHashTableType *) malloc(sizeof(GifHashTableType)))
+	== NULL)
+	return NULL;
+
+    _ClearHashTable(HashTable);
+
+    return HashTable;
+}
+
+/******************************************************************************
+* Routine to clear the HashTable to an empty state.			      *
+* This part is a little machine depended. Use the commented part otherwise.   *
+******************************************************************************/
+void _ClearHashTable(GifHashTableType *HashTable)
+{
+    memset(HashTable -> HTable, 0xFF, HT_SIZE * sizeof(UINT32));
+}
+
+/******************************************************************************
+* Routine to insert a new Item into the HashTable. The data is assumed to be  *
+* new one.								      *
+******************************************************************************/
+void _InsertHashTable(GifHashTableType *HashTable, UINT32 Key, int Code)
+{
+    int HKey = KeyItem(Key);
+    UINT32 *HTable = HashTable -> HTable;
+
+#ifdef DEBUG_HIT_RATE
+	NumberOfTests++;
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+
+    while (HT_GET_KEY(HTable[HKey]) != 0xFFFFFL) {
+#ifdef DEBUG_HIT_RATE
+	    NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+	HKey = (HKey + 1) & HT_KEY_MASK;
+    }
+    HTable[HKey] = HT_PUT_KEY(Key) | HT_PUT_CODE(Code);
+}
+
+/******************************************************************************
+* Routine to test if given Key exists in HashTable and if so returns its code *
+* Returns the Code if key was found, -1 if not.				      *
+******************************************************************************/
+int _ExistsHashTable(GifHashTableType *HashTable, UINT32 Key)
+{
+    int HKey = KeyItem(Key);
+    UINT32 *HTable = HashTable -> HTable, HTKey;
+
+#ifdef DEBUG_HIT_RATE
+	NumberOfTests++;
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+
+    while ((HTKey = HT_GET_KEY(HTable[HKey])) != 0xFFFFFL) {
+#ifdef DEBUG_HIT_RATE
+	    NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+	if (Key == HTKey) return HT_GET_CODE(HTable[HKey]);
+	HKey = (HKey + 1) & HT_KEY_MASK;
+    }
+
+    return -1;
+}
+
+/******************************************************************************
+* Routine to generate an HKey for the hashtable out of the given unique key.  *
+* The given Key is assumed to be 20 bits as follows: lower 8 bits are the     *
+* new postfix character, while the upper 12 bits are the prefix code.	      *
+* Because the average hit ratio is only 2 (2 hash references per entry),      *
+* evaluating more complex keys (such as twin prime keys) does not worth it!   *
+******************************************************************************/
+static int KeyItem(UINT32 Item)
+{
+    return ((Item >> 12) ^ Item) & HT_KEY_MASK;
+}
+
+#ifdef	DEBUG_HIT_RATE
+/******************************************************************************
+* Debugging routine to print the hit ratio - number of times the hash table   *
+* was tested per operation. This routine was used to test the KeyItem routine *
+******************************************************************************/
+void HashTablePrintHitRatio(void)
+{
+    printf("Hash Table Hit Ratio is %ld/%ld = %ld%%.\n",
+	NumberOfMisses, NumberOfTests,
+	NumberOfMisses * 100 / NumberOfTests);
+}
+#endif	/* DEBUG_HIT_RATE */

data/node_modules/jasmine-reporters/ext/phantomjs/src/gif/gif_hash.h

@@ -0,0 +1,59 @@
+/******************************************************************************
+* Declarations, global to other of the GIF-HASH.C module.		      *
+*									      *
+*					Written by Gershon Elber,  Jun 1989   *
+*******************************************************************************
+* History:								      *
+* 14 Jun 89 - Version 1.0 by Gershon Elber.				      *
+******************************************************************************/
+
+#ifndef _GIF_HASH_H_
+#define _GIF_HASH_H_
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* Find a thirty-two bit int type */
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_BASETSD_H
+#include <basetsd.h>
+#endif
+
+#define HT_SIZE			8192	   /* 12bits = 4096 or twice as big! */
+#define HT_KEY_MASK		0x1FFF			      /* 13bits keys */
+#define HT_KEY_NUM_BITS		13			      /* 13bits keys */
+#define HT_MAX_KEY		8191	/* 13bits - 1, maximal code possible */
+#define HT_MAX_CODE		4095	/* Biggest code possible in 12 bits. */
+
+/* The 32 bits of the long are divided into two parts for the key & code:   */
+/* 1. The code is 12 bits as our compression algorithm is limited to 12bits */
+/* 2. The key is 12 bits Prefix code + 8 bit new char or 20 bits.	    */
+/* The key is the upper 20 bits.  The code is the lower 12. */
+#define HT_GET_KEY(l)	(l >> 12)
+#define HT_GET_CODE(l)	(l & 0x0FFF)
+#define HT_PUT_KEY(l)	(l << 12)
+#define HT_PUT_CODE(l)	(l & 0x0FFF)
+
+typedef struct GifHashTableType {
+    UINT32 HTable[HT_SIZE];
+} GifHashTableType;
+
+GifHashTableType *_InitHashTable(void);
+void _ClearHashTable(GifHashTableType *HashTable);
+void _InsertHashTable(GifHashTableType *HashTable, UINT32 Key, int Code);
+int _ExistsHashTable(GifHashTableType *HashTable, UINT32 Key);
+
+#endif /* _GIF_HASH_H_ */

data/node_modules/jasmine-reporters/ext/phantomjs/src/gif/gif_lib.h

@@ -0,0 +1,336 @@
+/******************************************************************************
+ * In order to make life a little bit easier when using the GIF file format,   
+ * this library was written, and which does all the dirty work...              
+ *                                                                             
+ *                                        Written by Gershon Elber,  Jun. 1989 
+ *                                        Hacks by Eric S. Raymond,  Sep. 1992 
+ ******************************************************************************
+ * History:                                                                    
+ * 14 Jun 89 - Version 1.0 by Gershon Elber.                                   
+ *  3 Sep 90 - Version 1.1 by Gershon Elber (Support for Gif89, Unique names)  
+ * 15 Sep 90 - Version 2.0 by Eric S. Raymond (Changes to suoport GIF slurp)   
+ * 26 Jun 96 - Version 3.0 by Eric S. Raymond (Full GIF89 support)
+ * 17 Dec 98 - Version 4.0 by Toshio Kuratomi (Fix extension writing code)     
+ *****************************************************************************/
+
+#ifndef _GIF_LIB_H_
+#define _GIF_LIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GIF_LIB_VERSION " Version 4.1, "
+
+#define GIF_ERROR   0
+#define GIF_OK      1
+
+#ifndef TRUE
+#define TRUE        1
+#endif /* TRUE */
+#ifndef FALSE
+#define FALSE       0
+#endif /* FALSE */
+
+#ifndef NULL
+#define NULL        0
+#endif /* NULL */
+
+#define GIF_STAMP "GIFVER"          /* First chars in file - GIF stamp.  */
+#define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1
+#define GIF_VERSION_POS 3           /* Version first character in stamp. */
+#define GIF87_STAMP "GIF87a"        /* First chars in file - GIF stamp.  */
+#define GIF89_STAMP "GIF89a"        /* First chars in file - GIF stamp.  */
+
+#define GIF_FILE_BUFFER_SIZE 16384  /* Files uses bigger buffers than usual. */
+
+typedef int GifBooleanType;
+typedef unsigned char GifPixelType;
+typedef unsigned char *GifRowType;
+typedef unsigned char GifByteType;
+#ifdef _GBA_OPTMEM
+    typedef unsigned short GifPrefixType;
+    typedef short GifWord;
+#else
+    typedef unsigned int GifPrefixType;
+    typedef int GifWord;
+#endif
+
+#define GIF_MESSAGE(Msg) fprintf(stderr, "\n%s: %s\n", PROGRAM_NAME, Msg)
+#define GIF_EXIT(Msg)    { GIF_MESSAGE(Msg); exit(-3); }
+
+#ifdef SYSV
+#define VoidPtr char *
+#else
+#define VoidPtr void *
+#endif /* SYSV */
+
+typedef struct GifColorType {
+    GifByteType Red, Green, Blue;
+} GifColorType;
+
+typedef struct ColorMapObject {
+    int ColorCount;
+    int BitsPerPixel;
+    GifColorType *Colors;    /* on malloc(3) heap */
+} ColorMapObject;
+
+typedef struct GifImageDesc {
+    GifWord Left, Top, Width, Height,   /* Current image dimensions. */
+      Interlace;                    /* Sequential/Interlaced lines. */
+    ColorMapObject *ColorMap;       /* The local color map */
+} GifImageDesc;
+
+typedef struct GifFileType {
+    GifWord SWidth, SHeight,        /* Screen dimensions. */
+      SColorResolution,         /* How many colors can we generate? */
+      SBackGroundColor;         /* I hope you understand this one... */
+    ColorMapObject *SColorMap;  /* NULL if not exists. */
+    int ImageCount;             /* Number of current image */
+    GifImageDesc Image;         /* Block describing current image */
+    struct SavedImage *SavedImages; /* Use this to accumulate file state */
+    VoidPtr UserData;           /* hook to attach user data (TVT) */
+    VoidPtr Private;            /* Don't mess with this! */
+} GifFileType;
+
+typedef enum {
+    UNDEFINED_RECORD_TYPE,
+    SCREEN_DESC_RECORD_TYPE,
+    IMAGE_DESC_RECORD_TYPE, /* Begin with ',' */
+    EXTENSION_RECORD_TYPE,  /* Begin with '!' */
+    TERMINATE_RECORD_TYPE   /* Begin with ';' */
+} GifRecordType;
+
+/* DumpScreen2Gif routine constants identify type of window/screen to dump.
+ * Note all values below 1000 are reserved for the IBMPC different display
+ * devices (it has many!) and are compatible with the numbering TC2.0
+ * (Turbo C 2.0 compiler for IBM PC) gives to these devices.
+ */
+typedef enum {
+    GIF_DUMP_SGI_WINDOW = 1000,
+    GIF_DUMP_X_WINDOW = 1001
+} GifScreenDumpType;
+
+/* func type to read gif data from arbitrary sources (TVT) */
+typedef int (*InputFunc) (GifFileType *, GifByteType *, int);
+
+/* func type to write gif data ro arbitrary targets.
+ * Returns count of bytes written. (MRB)
+ */
+typedef int (*OutputFunc) (GifFileType *, const GifByteType *, int);
+
+/******************************************************************************
+ *  GIF89 extension function codes                                             
+******************************************************************************/
+
+#define COMMENT_EXT_FUNC_CODE     0xfe    /* comment */
+#define GRAPHICS_EXT_FUNC_CODE    0xf9    /* graphics control */
+#define PLAINTEXT_EXT_FUNC_CODE   0x01    /* plaintext */
+#define APPLICATION_EXT_FUNC_CODE 0xff    /* application block */
+
+/******************************************************************************
+ * O.K., here are the routines one can access in order to encode GIF file:     
+ * (GIF_LIB file EGIF_LIB.C).                              
+******************************************************************************/
+
+GifFileType *EGifOpenFileName(const char *GifFileName,
+                              int GifTestExistance);
+GifFileType *EGifOpenFileHandle(int GifFileHandle);
+GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc);
+
+int EGifSpew(GifFileType * GifFile);
+void EGifSetGifVersion(const char *Version);
+int EGifPutScreenDesc(GifFileType * GifFile,
+                      int GifWidth, int GifHeight, int GifColorRes,
+                      int GifBackGround,
+                      const ColorMapObject * GifColorMap);
+int EGifPutImageDesc(GifFileType * GifFile, int GifLeft, int GifTop,
+                     int Width, int GifHeight, int GifInterlace,
+                     const ColorMapObject * GifColorMap);
+int EGifPutLine(GifFileType * GifFile, GifPixelType * GifLine,
+                int GifLineLen);
+int EGifPutPixel(GifFileType * GifFile, GifPixelType GifPixel);
+int EGifPutComment(GifFileType * GifFile, const char *GifComment);
+int EGifPutExtensionFirst(GifFileType * GifFile, int GifExtCode,
+                          int GifExtLen, const VoidPtr GifExtension);
+int EGifPutExtensionNext(GifFileType * GifFile, int GifExtCode,
+                         int GifExtLen, const VoidPtr GifExtension);
+int EGifPutExtensionLast(GifFileType * GifFile, int GifExtCode,
+                         int GifExtLen, const VoidPtr GifExtension);
+int EGifPutExtension(GifFileType * GifFile, int GifExtCode, int GifExtLen,
+                     const VoidPtr GifExtension);
+int EGifPutCode(GifFileType * GifFile, int GifCodeSize,
+                const GifByteType * GifCodeBlock);
+int EGifPutCodeNext(GifFileType * GifFile,
+                    const GifByteType * GifCodeBlock);
+int EGifCloseFile(GifFileType * GifFile);
+
+#define E_GIF_ERR_OPEN_FAILED    1    /* And EGif possible errors. */
+#define E_GIF_ERR_WRITE_FAILED   2
+#define E_GIF_ERR_HAS_SCRN_DSCR  3
+#define E_GIF_ERR_HAS_IMAG_DSCR  4
+#define E_GIF_ERR_NO_COLOR_MAP   5
+#define E_GIF_ERR_DATA_TOO_BIG   6
+#define E_GIF_ERR_NOT_ENOUGH_MEM 7
+#define E_GIF_ERR_DISK_IS_FULL   8
+#define E_GIF_ERR_CLOSE_FAILED   9
+#define E_GIF_ERR_NOT_WRITEABLE  10
+
+/******************************************************************************
+ * O.K., here are the routines one can access in order to decode GIF file:     
+ * (GIF_LIB file DGIF_LIB.C).                              
+ *****************************************************************************/
+#ifndef _GBA_NO_FILEIO
+GifFileType *DGifOpenFileName(const char *GifFileName);
+GifFileType *DGifOpenFileHandle(int GifFileHandle);
+int DGifSlurp(GifFileType * GifFile);
+#endif /* _GBA_NO_FILEIO */
+GifFileType *DGifOpen(void *userPtr, InputFunc readFunc);    /* new one
+                                                             * (TVT) */
+int DGifGetScreenDesc(GifFileType * GifFile);
+int DGifGetRecordType(GifFileType * GifFile, GifRecordType * GifType);
+int DGifGetImageDesc(GifFileType * GifFile);
+int DGifGetLine(GifFileType * GifFile, GifPixelType * GifLine, int GifLineLen);
+int DGifGetPixel(GifFileType * GifFile, GifPixelType GifPixel);
+int DGifGetComment(GifFileType * GifFile, char *GifComment);
+int DGifGetExtension(GifFileType * GifFile, int *GifExtCode,
+                     GifByteType ** GifExtension);
+int DGifGetExtensionNext(GifFileType * GifFile, GifByteType ** GifExtension);
+int DGifGetCode(GifFileType * GifFile, int *GifCodeSize,
+                GifByteType ** GifCodeBlock);
+int DGifGetCodeNext(GifFileType * GifFile, GifByteType ** GifCodeBlock);
+int DGifGetLZCodes(GifFileType * GifFile, int *GifCode);
+int DGifCloseFile(GifFileType * GifFile);
+
+#define D_GIF_ERR_OPEN_FAILED    101    /* And DGif possible errors. */
+#define D_GIF_ERR_READ_FAILED    102
+#define D_GIF_ERR_NOT_GIF_FILE   103
+#define D_GIF_ERR_NO_SCRN_DSCR   104
+#define D_GIF_ERR_NO_IMAG_DSCR   105
+#define D_GIF_ERR_NO_COLOR_MAP   106
+#define D_GIF_ERR_WRONG_RECORD   107
+#define D_GIF_ERR_DATA_TOO_BIG   108
+#define D_GIF_ERR_NOT_ENOUGH_MEM 109
+#define D_GIF_ERR_CLOSE_FAILED   110
+#define D_GIF_ERR_NOT_READABLE   111
+#define D_GIF_ERR_IMAGE_DEFECT   112
+#define D_GIF_ERR_EOF_TOO_SOON   113
+
+/******************************************************************************
+ * O.K., here are the routines from GIF_LIB file QUANTIZE.C.              
+******************************************************************************/
+int QuantizeBuffer(unsigned int Width, unsigned int Height,
+                   int *ColorMapSize, GifByteType * RedInput,
+                   GifByteType * GreenInput, GifByteType * BlueInput,
+                   GifByteType * OutputBuffer,
+                   GifColorType * OutputColorMap);
+
+/******************************************************************************
+ * O.K., here are the routines from GIF_LIB file QPRINTF.C.              
+******************************************************************************/
+extern int GifQuietPrint;
+
+#ifdef HAVE_STDARG_H
+    extern void GifQprintf(char *Format, ...);
+#elif defined (HAVE_VARARGS_H)
+    extern void GifQprintf();
+#endif /* HAVE_STDARG_H */
+
+/******************************************************************************
+ * O.K., here are the routines from GIF_LIB file GIF_ERR.C.              
+******************************************************************************/
+#ifndef _GBA_NO_FILEIO
+extern void PrintGifError(void);
+#endif /* _GBA_NO_FILEIO */
+extern int GifLastError(void);
+
+/******************************************************************************
+ * O.K., here are the routines from GIF_LIB file DEV2GIF.C.              
+******************************************************************************/
+extern int DumpScreen2Gif(const char *FileName,
+                          int ReqGraphDriver,
+                          long ReqGraphMode1,
+                          long ReqGraphMode2,
+                          long ReqGraphMode3);
+
+/*****************************************************************************
+ *
+ * Everything below this point is new after version 1.2, supporting `slurp
+ * mode' for doing I/O in two big belts with all the image-bashing in core.
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ * Color Map handling from ALLOCGIF.C                          
+ *****************************************************************************/
+
+extern ColorMapObject *MakeMapObject(int ColorCount,
+                                     const GifColorType * ColorMap);
+extern void FreeMapObject(ColorMapObject * Object);
+extern ColorMapObject *UnionColorMap(const ColorMapObject * ColorIn1,
+                                     const ColorMapObject * ColorIn2,
+                                     GifPixelType ColorTransIn2[]);
+extern int BitSize(int n);
+
+/******************************************************************************
+ * Support for the in-core structures allocation (slurp mode).              
+ *****************************************************************************/
+
+/* This is the in-core version of an extension record */
+typedef struct {
+    int ByteCount;
+    char *Bytes;    /* on malloc(3) heap */
+    int Function;   /* Holds the type of the Extension block. */
+} ExtensionBlock;
+
+/* This holds an image header, its unpacked raster bits, and extensions */
+typedef struct SavedImage {
+    GifImageDesc ImageDesc;
+    unsigned char *RasterBits;  /* on malloc(3) heap */
+    int Function;   /* DEPRECATED: Use ExtensionBlocks[x].Function instead */
+    int ExtensionBlockCount;
+    ExtensionBlock *ExtensionBlocks;    /* on malloc(3) heap */
+} SavedImage;
+
+extern void ApplyTranslation(SavedImage * Image, GifPixelType Translation[]);
+extern void MakeExtension(SavedImage * New, int Function);
+extern int AddExtensionBlock(SavedImage * New, int Len,
+                             unsigned char ExtData[]);
+extern void FreeExtension(SavedImage * Image);
+extern SavedImage *MakeSavedImage(GifFileType * GifFile,
+                                  const SavedImage * CopyFrom);
+extern void FreeSavedImages(GifFileType * GifFile);
+
+/******************************************************************************
+ * The library's internal utility font                          
+ *****************************************************************************/
+
+#define GIF_FONT_WIDTH  8
+#define GIF_FONT_HEIGHT 8
+extern unsigned char AsciiTable[][GIF_FONT_WIDTH];
+
+#ifdef _WIN32
+    extern void DrawGifText(SavedImage * Image,
+#else
+    extern void DrawText(SavedImage * Image,
+#endif
+                     const int x, const int y,
+                     const char *legend, const int color);
+
+extern void DrawBox(SavedImage * Image,
+                    const int x, const int y,
+                    const int w, const int d, const int color);
+
+void DrawRectangle(SavedImage * Image,
+                   const int x, const int y,
+                   const int w, const int d, const int color);
+
+extern void DrawBoxedText(SavedImage * Image,
+                          const int x, const int y,
+                          const char *legend,
+                          const int border, const int bg, const int fg);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* _GIF_LIB_H */