EGIFLIB.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/*    file   EGIFLIB.C    */

#pragma warning( disable : 4244)

#include "render.h"
#undef OK
#include "giflib.h"
#include "gifhash.h"


#define COMMENT_EXT_FUNC_CODE  'C'
#define GIF_STAMP87     "GIF87a"   /* First chars in file - GIF stamp */
#define GIF_STAMP89     "GIF89a"   /* First chars in file - GIF stamp */
#define ZL_MAX_CODE 4095           /* Biggest code possible in 12 bits. */

#define FILE_STATE_WRITE  0x01/* 1 write, 0 read - DGIF_LIB compatible */
#define FILE_STATE_SCREEN 0x02
#define FILE_STATE_IMAGE  0x04

#define FLUSH_OUTPUT      4096 /* Impossible code, to signal flush */
#define FIRST_CODE        4097  /* Impossible code, to signal first */

#define IS_WRITEABLE(Private) (Private -> FileState & FILE_STATE_WRITE)

typedef struct GifFilePrivateType {
  long FileState,
  FileHandle,   /* Where old this data goes to! */
  BitsPerPixel, /* Bits per pixel (Codes uses at list this + 1) */
  ClearCode,    /* The CLEAR LZ code */
  EOFCode,      /* The EOF LZ code */
  RunningCode,  /* The next code algorithm can generate */
  RunningBits,  /* The number of bits required to represent RunningCode */
  MaxCode1,     /* 1 bigger than maximum possible code, in RunningBits bits */
  CrntCode,                     /* Current algorithm code */
  CrntShiftState;               /* Number of bits in CrntShiftDWord */
  unsigned long CrntShiftDWord, /* For bytes decomposition into codes */
           PixelCount;
  FILE *File;              /* File as stream */
  ByteType Buf[256];       /* Compressed output is buffered here */
  GifHashTableType *HashTable;
} GifFilePrivateType;

long _GifError;

/* Masks given codes to BitsPerPixel, to make sure all codes are in range: */
static PixelType CodeMask[] = {
    0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff
};

#ifdef _SUNSTYLE
static long EGifPutWord();
static long EGifSetupCompress();
static long EGifCompressLine();
static long EGifCompressOutput();
static long EGifBufferedOutput();
#else
static long EGifPutWord(long Word, FILE *File);
static long EGifSetupCompress(GifFileType *GifFile);
static long EGifCompressLine(GifFileType *GifFile, PixelType *Line, long LineLen);
static long EGifCompressOutput(GifFilePrivateType *Private, long Code);
static long EGifBufferedOutput(FILE *File, ByteType *Buf, long c);
#endif

#ifdef _SUNSTYLE
GifFileType *EGifOpenFileName(FileName,TestExistance)
char *FileName; long TestExistance;{
#else
GifFileType *EGifOpenFileName(char *FileName, long TestExistance, long version){
#endif
    long FileHandle;
    FileHandle=1;
    return EGifOpenFileHandle(FileName,version);
}

#ifdef _SUNSTYLE
GifFileType *EGifOpenFileHandle(filename, version) char *filename; long version;{
#else
GifFileType *EGifOpenFileHandle(char *filename, long version){
#endif
    char *vers;
    long FileHandle;
    GifFileType *GifFile;
    GifFilePrivateType *Private;
    FILE *f;
    FileHandle=0;
    if((f = fopen((char *)strlwr(filename), "wb")) == NULL)return NULL;
    if ((GifFile = (GifFileType *) X__Malloc(sizeof(GifFileType))) == NULL) {
       _GifError = E_GIF_ERR_NotEnoughMem;
       return ERROR;
    }
    GifFile -> SWidth = GifFile -> SHeight =
    GifFile -> SColorResolution = GifFile -> SBitsPerPixel =
    GifFile -> SBackGroundColor =
    GifFile -> ILeft = GifFile -> ITop = GifFile -> IWidth = GifFile -> IHeight =
    GifFile -> IInterlace =
    GifFile -> IBitsPerPixel = 0;
    GifFile -> SColorMap = GifFile -> IColorMap = NULL;
    if(version)vers=GIF_STAMP89;
    else       vers=GIF_STAMP87;
    if(fwrite(vers,1,strlen(vers),f) != strlen(vers)) {
      _GifError = E_GIF_ERR_WriteFailed;
      X__Free((char *) GifFile);
      return NULL;
    }
    if ((Private = (GifFilePrivateType *) X__Malloc(sizeof(GifFilePrivateType)))
       == NULL) {
       _GifError = E_GIF_ERR_NotEnoughMem;
       return NULL;
    }
    GifFile -> Private = (VoidPtr)Private;
    Private -> FileHandle = FileHandle;
    Private -> File = f;
    Private -> FileState = FILE_STATE_WRITE;
    if ((Private -> HashTable = _InitHashTable()) == NULL) {
      _GifError = E_GIF_ERR_NotEnoughMem;
      return NULL;
    }
    _GifError = 0;
    return GifFile;
}

#ifdef _SUNSTYLE
long EGifPutScreenDesc(GifFile,Width,Height,ColorRes,BackGround,BitsPerPixel,
       ColorMap) GifFileType *GifFile; long Width;
       long Height; long ColorRes; long BackGround; long BitsPerPixel;
       GifColorType *ColorMap; {
#else
long EGifPutScreenDesc(GifFileType *GifFile,
 long Width, long Height, long ColorRes, long BackGround,
 long BitsPerPixel, GifColorType *ColorMap){
#endif
    long i, Size;
    ByteType Buf[3];
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;

    if (Private -> FileState & FILE_STATE_SCREEN) {
       /* If already has screen descriptor - something is wrong! */
       _GifError = E_GIF_ERR_HasScrnDscr;
       return ERROR;
    }
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }

    GifFile -> SWidth = Width;
    GifFile -> SHeight = Height;
    GifFile -> SColorResolution = ColorRes;
    GifFile -> SBitsPerPixel = BitsPerPixel;
    GifFile -> SBackGroundColor = BackGround;
    if (ColorMap) {
      Size = sizeof(GifColorType) * (1 << BitsPerPixel);
      if((GifFile -> SColorMap = (GifColorType *) X__Malloc(Size)) == NULL){
        return ERROR;
      }
      memcpy(GifFile -> SColorMap, ColorMap, Size);
    }
    /* Put the screen descriptor into the file: */
    EGifPutWord(Width, Private -> File);
    EGifPutWord(Height, Private -> File);
    Buf[0] = (ColorMap ? 0x80 : 0x00) |
             ((ColorRes - 1) << 4) |
             (BitsPerPixel - 1);
    Buf[1] = BackGround;
    Buf[2] = 0;
#ifndef DEBUG_NO_PREFIX
    fwrite(Buf, 1, 3, Private -> File);
#endif /* DEBUG_NO_PREFIX */
    /* If we have Global color map - dump it also: */
#ifndef DEBUG_NO_PREFIX
    if (ColorMap != NULL)for (i=0; i<(1 << BitsPerPixel); i++) {
       /* Put the ColorMap out also: */
      Buf[0] = ColorMap[i].Red;
      Buf[1] = ColorMap[i].Green;
      Buf[2] = ColorMap[i].Blue;
      if (fwrite(Buf, 1, 3, Private -> File) != 3) {
        _GifError = E_GIF_ERR_WriteFailed;
        return ERROR;
      }
    }
#endif /* DEBUG_NO_PREFIX */

    /* Mark this file as has screen descriptor, and no pixel written yet: */
    Private -> FileState |= FILE_STATE_SCREEN;
    return OK;
}

#ifdef _SUNSTYLE
long EGifPutImageDesc(GifFile,Left,Top,Width,Height,Interlace,BitsPerPixel,
                      ColorMap)
GifFileType *GifFile; long Left; long Top; long Width; long Height;
long Interlace; long BitsPerPixel; GifColorType *ColorMap; {
#else
long EGifPutImageDesc(GifFileType *GifFile,
     long Left, long Top, long Width, long Height, long Interlace,
     long BitsPerPixel, GifColorType *ColorMap){
#endif
    long i, Size;
    ByteType Buf[3];
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;

    if (Private -> FileState & FILE_STATE_IMAGE &&
        Private -> PixelCount > 0) {
      /* If already has active image descriptor - something is wrong! */
      _GifError = E_GIF_ERR_HasImagDscr;
      return ERROR;
    }
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    GifFile -> ILeft = Left;
    GifFile -> ITop = Top;
    GifFile -> IWidth = Width;
    GifFile -> IHeight = Height;
    GifFile -> IBitsPerPixel = BitsPerPixel;
    GifFile -> IInterlace = Interlace;
    if (ColorMap) {
      Size = sizeof(GifColorType) * (1 << BitsPerPixel);
      if (GifFile -> IColorMap){
        X__Free((char *) GifFile -> IColorMap);
      }
      if((GifFile -> IColorMap = (GifColorType *) X__Malloc(Size)) == NULL){
        return ERROR;
      }
      memcpy(GifFile -> IColorMap, ColorMap, Size);
    }
    /* Put the image descriptor into the file: */
    Buf[0] = ',';               /* Image seperator character */
#ifndef DEBUG_NO_PREFIX
    fwrite(Buf, 1, 1, Private -> File);
#endif /* DEBUG_NO_PREFIX */
    EGifPutWord(Left, Private -> File);
    EGifPutWord(Top, Private -> File);
    EGifPutWord(Width, Private -> File);
    EGifPutWord(Height, Private -> File);
    Buf[0] = (ColorMap ? 0x80 : 0x00) |
             (Interlace ? 0x40 : 0x00) |
             (BitsPerPixel - 1);
#ifndef DEBUG_NO_PREFIX
    fwrite(Buf, 1, 1, Private -> File);
#endif /* DEBUG_NO_PREFIX */
    /* If we have Global color map - dump it also: */
#ifndef DEBUG_NO_PREFIX
    if (ColorMap != NULL)for (i=0; i<(1 << BitsPerPixel); i++) {
      /* Put the ColorMap out also: */
      Buf[0] = ColorMap[i].Red;
      Buf[1] = ColorMap[i].Green;
      Buf[2] = ColorMap[i].Blue;
      if (fwrite(Buf, 1, 3, Private -> File) != 3) {
        _GifError = E_GIF_ERR_WriteFailed;
        return ERROR;
      }
    }
#endif /* DEBUG_NO_PREFIX */
    if (GifFile -> SColorMap == NULL && GifFile -> IColorMap == NULL){
      _GifError = E_GIF_ERR_NoColorMap;
      return ERROR;
    }
    /* Mark this file as has screen descriptor: */
    Private -> FileState |= FILE_STATE_IMAGE;
    Private -> PixelCount = (long) Width * (long) Height;
    EGifSetupCompress(GifFile);       /* Reset compress algorithm parameters */
    return OK;
}

long EGifPutControlDesc(GifFileType *GifFile,
    long transp, ByteType transpid, long delay, long dummy){
    ByteType Buf[3];
    GifFilePrivateType *Private = (GifFilePrivateType *)GifFile -> Private;
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    Buf[0] = 0x21;               /* Extension introducer */
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = 0xF9;               /* Control label */
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = 4;
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = (transp ? 0x01 : 0x00) |
             (dummy  ? 0x02 : 0x00);
    fwrite(Buf, 1, 1, Private -> File);
    EGifPutWord(delay, Private -> File);
    Buf[0]=(ByteType)transpid;
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0]=0;
    fwrite(Buf, 1, 1, Private -> File); /* Block Terminator */
    return OK;
}

long EGifPutBrowserControlDesc(GifFileType *GifFile,long repeat){
    ByteType Buf[16];
    GifFilePrivateType *Private = (GifFilePrivateType *)GifFile -> Private;
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    Buf[0] = 0x21;               /* Extension introducer */
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = 0xFF;               /* Control label */
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = 11;
    fwrite(Buf, 1, 1, Private -> File);
    strcpy((char *)Buf,"NETSCAPE2.0");
    fwrite(Buf, 1, 11, Private -> File);
    Buf[0] = 0x03;
    fwrite(Buf, 1, 1, Private -> File);
    Buf[0] = 0x01;
    fwrite(Buf, 1, 1, Private -> File);
    EGifPutWord(repeat, Private -> File);
    Buf[0]=0;
    fwrite(Buf, 1, 1, Private -> File); /* Block Terminator */
    return OK;
}

#ifdef _SUNSTYLE
long EGifPutLine(GifFile,Line,LineLen) GifFileType *GifFile;
PixelType *Line; long LineLen; {
#else
long EGifPutLine(GifFileType *GifFile, PixelType *Line, long LineLen){
#endif
    long i;
    PixelType Mask;
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    if (!LineLen) LineLen = GifFile -> IWidth;
    /* (long) added by RSF to satisfy the WATCOM compiler */
    if ((long)(Private -> PixelCount -= LineLen) < 0) {
       _GifError = E_GIF_ERR_DataTooBig;
       return ERROR;
    }
    /* 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);
}

#ifdef _SUNSTYLE
long EGifPutCode(GifFile,CodeSize,CodeBlock) GifFileType *GifFile;
     long CodeSize; ByteType *CodeBlock; {
#else
long EGifPutCode(GifFileType *GifFile, long CodeSize, ByteType *CodeBlock){
#endif
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    /* No need to dump code size as Compression set up does any for us: */
    /*
    Buf = CodeSize;
    if (fwrite(&Buf, 1, 1, Private -> File) != 1) {
      _GifError = E_GIF_ERR_WriteFailed;
      return ERROR;
    }
    */
    return EGifPutCodeNext(GifFile, CodeBlock);
}

#ifdef _SUNSTYLE
long EGifPutCodeNext(GifFile,CodeBlock) GifFileType *GifFile;
ByteType *CodeBlock; {
#else
long EGifPutCodeNext(GifFileType *GifFile, ByteType *CodeBlock){
#endif
    ByteType Buf;
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;
    if (CodeBlock != NULL) {
      if (fwrite(CodeBlock, 1, CodeBlock[0] + 1, Private -> File)
          != CodeBlock[0] + 1) {
        _GifError = E_GIF_ERR_WriteFailed;
        return ERROR;
      }
    }
    else {
      Buf = 0;
      if (fwrite(&Buf, 1, 1, Private -> File) != 1) {
        _GifError = E_GIF_ERR_WriteFailed;
        return ERROR;
      }
      Private -> PixelCount = 0;    /* And local info. indicate image read */
    }
    return OK;
}

#ifdef _SUNSTYLE
long EGifCloseFile(GifFile) GifFileType *GifFile; {
#else
long EGifCloseFile(GifFileType *GifFile){
#endif
    ByteType Buf;
    GifFilePrivateType *Private;
    FILE *File;

    if (GifFile == NULL) return ERROR;

    Private = (GifFilePrivateType *) GifFile -> Private;
    if (!IS_WRITEABLE(Private)) {
      /* This file was NOT open for writing: */
      _GifError = E_GIF_ERR_NotWriteable;
      return ERROR;
    }
    File = Private -> File;
    Buf = ';';
    fwrite(&Buf, 1, 1, Private -> File);
    if (GifFile -> IColorMap){
     X__Free((char *) GifFile -> IColorMap);
    }
    if (GifFile -> SColorMap){
      X__Free((char *) GifFile -> SColorMap);
    }
    if (Private) {
      if (Private -> HashTable){
        X__Free((char *) Private -> HashTable);
      }
      X__Free((char *) Private);
    }
    X__Free(GifFile);
    if (fclose(File) != 0) {
       _GifError = E_GIF_ERR_CloseFailed;
       return ERROR;
    }
    return OK;
}

#ifdef _SUNSTYLE
static long EGifPutWord(Word,File) long Word; FILE *File; {
#else
static long EGifPutWord(long Word, FILE *File){
#endif
    char c[2];
    c[0] = Word & 0xff;
    c[1] = (Word >> 8) & 0xff;
#ifndef DEBUG_NO_PREFIX
    if (fwrite(c, 1, 2, File) == 2)return OK;
    else return ERROR;
#else
    return OK;
#endif /* DEBUG_NO_PREFIX */
}

#ifdef _SUNSTYLE
static long EGifSetupCompress(GifFile) GifFileType *GifFile; {
#else
static long EGifSetupCompress(GifFileType *GifFile){
#endif
    long BitsPerPixel;
    ByteType Buf;
    GifFilePrivateType *Private = (GifFilePrivateType *) GifFile -> Private;

    /* Test and see what color map to use, and from it # bits per pixel: */
    if (GifFile -> IColorMap)
         BitsPerPixel = GifFile -> IBitsPerPixel;
    else
    if (GifFile -> SColorMap)
         BitsPerPixel = GifFile -> SBitsPerPixel;
    else {
        _GifError = E_GIF_ERR_NoColorMap;
        return ERROR;
    }

    Buf = BitsPerPixel = (BitsPerPixel < 2 ? 2 : BitsPerPixel);
    fwrite(&Buf, 1, 1, Private -> File);      /* 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(Private, Private -> ClearCode) == ERROR) {
        _GifError = E_GIF_ERR_DiskIsFull;
        return ERROR;
    }
    return OK;
}

/******************************************************************************
*   The LZ compression routine:                                               *
*   This version compress the given buffer Line of length LineLen.            *
*   This routine can be called few times (one per scan line, for example), in *
* order the complete the whole image.                                         *
******************************************************************************/
#ifdef _SUNSTYLE
static long EGifCompressLine(GifFile,Line,LineLen) GifFileType *GifFile;
PixelType *Line; long LineLen; {
#else
static long EGifCompressLine(GifFileType *GifFile, PixelType *Line,
                             long LineLen){
#endif
    long i = 0, CrntCode, NewCode;
    unsigned long NewKey;
    PixelType 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 = (((unsigned long) 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(Private, CrntCode)
                == ERROR) {
                _GifError = E_GIF_ERR_DiskIsFull;
                return ERROR;
            }
            CrntCode = Pixel;

            /* If however the HashTable if full, we send a clear first and   */
            /* Clear the hash table.                                         */
            if (Private -> RunningCode >= ZL_MAX_CODE) {
                /* Time to do some clearance: */
                if (EGifCompressOutput(Private, Private -> ClearCode)
                    == ERROR) {
                    _GifError = E_GIF_ERR_DiskIsFull;
                    return 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(Private, CrntCode)
            == ERROR) {
            _GifError = E_GIF_ERR_DiskIsFull;
            return ERROR;
        }
        if (EGifCompressOutput(Private, Private -> EOFCode)
            == ERROR) {
            _GifError = E_GIF_ERR_DiskIsFull;
            return ERROR;
        }
        if (EGifCompressOutput(Private, FLUSH_OUTPUT) == ERROR) {
            _GifError = E_GIF_ERR_DiskIsFull;
            return ERROR;
        }
    }

    return OK;
}

/******************************************************************************
*   The LZ compression output routine:                                        *
*   This routine is responsable for the compression of the bit stream into    *
* 8 bits (bytes) packets.                                                     *
*   Returns OK if written succesfully.                                        *
******************************************************************************/
#ifdef _SUNSTYLE
static long EGifCompressOutput(Private,Code) GifFilePrivateType *Private;
       long Code; {
#else
static long EGifCompressOutput(GifFilePrivateType *Private, long Code){
#endif
    long retval = OK;

    if (Code == FLUSH_OUTPUT) {
        while (Private -> CrntShiftState > 0) {
            /* Get Rid of what is left in DWord, and flush it */
            if (EGifBufferedOutput(Private -> File, Private -> Buf,
                (int)Private -> CrntShiftDWord & 0xff) == ERROR) retval = ERROR;
            Private -> CrntShiftDWord >>= 8;
            Private -> CrntShiftState -= 8;
        }
        Private -> CrntShiftState = 0;                      /* For next time */
        if (EGifBufferedOutput(Private -> File, Private -> Buf,
            FLUSH_OUTPUT) == ERROR) retval = ERROR;
    }
    else {
        Private -> CrntShiftDWord |= ((long) Code) << Private -> CrntShiftState;
        Private -> CrntShiftState += Private -> RunningBits;
        while (Private -> CrntShiftState >= 8) {
            /* Dump out full bytes: */
            if (EGifBufferedOutput(Private -> File, Private -> Buf,
                (int)Private -> CrntShiftDWord & 0xff) == ERROR) retval = 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 OK if written succesfully.                                        *
******************************************************************************/
#ifdef _SUNSTYLE
static long EGifBufferedOutput(File,Buf,c) FILE *File;
ByteType *Buf; long c; {
#else
static long EGifBufferedOutput(FILE *File, ByteType *Buf, long c){
#endif
    if (c == FLUSH_OUTPUT) {
        /* Flush everything out */
        if (Buf[0] != 0 && fwrite(Buf, 1, Buf[0]+1, File) != Buf[0] + 1)
        {
            _GifError = E_GIF_ERR_WriteFailed;
            return ERROR;
        }
        /* Mark end of compressed data, by an empty block (see GIF doc): */
        Buf[0] = 0;
        if (fwrite(Buf, 1, 1, File) != 1)
        {
            _GifError = E_GIF_ERR_WriteFailed;
            return ERROR;
        }
    }
    else {
        if (Buf[0] == 255) {
            /* Dump out this buffer - it is full: */
            if (fwrite(Buf, 1, Buf[0] + 1, File) != Buf[0] + 1)
            {
                _GifError = E_GIF_ERR_WriteFailed;
                return ERROR;
            }
            Buf[0] = 0;
        }
        Buf[++Buf[0]] = c;
    }

    return OK;
}