gifwrite.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>

#define MAXBITS         12

#define MAXCODE         4095

#define TABLESIZE       5003

#define HASHSHIFT       4

#define UNUSED          -1


typedef struct
{
    long Hash;              
    unsigned short Code;    
} tableentry;

typedef struct
{
    FILE *File;                 
    unsigned int BitsPerCode;   
    unsigned int BitAccum;      
    int NumBits;                
    int BlockSize;              
    unsigned char Block[255];   
} bitstream;

static void WriteWordLE(FILE *File, unsigned short Value);
static void WriteImageData(FILE *File, tableentry *Table,
    unsigned char *Data, int FrameLeft, int FrameTop,
    int FrameWidth, int FrameHeight, int ImageWidth);
static void CropFrame(int *FrameLeft, int *FrameTop,
    int *FrameWidth, int *FrameHeight, unsigned char *Data,
    int ImageWidth, int ImageHeight, int TransparentColor);


int GifWrite(unsigned char **Image,
    int ImageWidth, int ImageHeight, int NumFrames,
    const unsigned char *Palette, int NumColors, int TransparentColor,
    const int *Delays, const char *OutputFile)
{
    FILE *File = NULL;
    tableentry *Table = NULL;
    const int NumPixels = ImageWidth*ImageHeight;
    int i, Frame, TableSizePow;
    int FrameLeft, FrameTop, FrameWidth, FrameHeight, Success = 0;
    
    /* Input checking */
    if(!Image || !Palette || !OutputFile || ImageWidth <= 0
        || ImageHeight <= 0 || NumFrames <= 0 || NumColors <= 2
        || TransparentColor < 0 || TransparentColor >= NumColors)
        return 0;
    
    for(Frame = 0; Frame < NumFrames; Frame++)
    {
        if(!Image[Frame])
            return 0;
        
        for(i = 0; i < NumPixels; i++)
            if(Image[Frame][i] >= NumColors)
            {
                fprintf(stderr, "Pixel values exceed palette.\n");
                return 0;
            }
    }
    
    if(!(Table = (tableentry *)malloc(sizeof(tableentry)*TABLESIZE)))
        return 0;
    
    if(!(File = fopen(OutputFile, "wb")))
    {
        fprintf(stderr, "Unable to open \"%s\" for writing.\n", OutputFile);
        goto Catch;
    }
    
    for(TableSizePow = 1; TableSizePow < NumColors && TableSizePow < 8;)
        TableSizePow++;
    
    /* GIF Header */
    fwrite("GIF89a", 1, 6, File);
    WriteWordLE(File, (unsigned short)ImageWidth);
    WriteWordLE(File, (unsigned short)ImageHeight);
    putc(0xF0 | (TableSizePow - 1), File);
    WriteWordLE(File, 0x0000);
    fwrite(Palette, 1, 3*NumColors, File);

    /* Pad unused palette entries with 0 */
    for(i = 3*((1 << TableSizePow) - NumColors); i > 0; i--)
        putc(0x00, File);
    
    /* Netscape animation extension */
    if(NumFrames > 1)
        fwrite("\x21\xFF\x0BNETSCAPE2.0\x03\x01\xFF\xFF", 1, 19, File);
        
    for(Frame = 0; Frame < NumFrames; Frame++)
    {
        CropFrame(&FrameLeft, &FrameTop, &FrameWidth, &FrameHeight,
            Image[Frame], ImageWidth, ImageHeight, TransparentColor);
        
        /* Write Graphic control extension and frame descriptor */
        WriteWordLE(File, 0xF921);          /* Graphic control label     */
        WriteWordLE(File, 0x0504);          /* Size and packed fields    */
        WriteWordLE(File, (Delays) ? Delays[Frame] : 10);
        putc(TransparentColor, File);
        WriteWordLE(File, 0x2C00);          /* Begin frame descriptor    */
        WriteWordLE(File, (unsigned short)FrameLeft);
        WriteWordLE(File, (unsigned short)FrameTop);
        WriteWordLE(File, (unsigned short)FrameWidth);
        WriteWordLE(File, (unsigned short)FrameHeight);
        putc(0x00, File);                   /* No local color table      */
        
        /* Write the current frame */
        WriteImageData(File, Table, Image[Frame], FrameLeft, FrameTop,
            FrameWidth, FrameHeight, ImageWidth);
    }
    
    putc(0x3B, File);                       /* File terminator           */
    
    if(ferror(File))
    {
        fprintf(stderr, "Error while writing to \"%s\".\n", OutputFile);
        goto Catch;
    }
    
    Success = 1;
Catch:
    if(File)
        fclose(File);
    if(Table)
        free(Table);
    return Success;
}


static void WriteWordLE(FILE *File, unsigned short Value)
{
    putc(Value & 0xFF, File);
    putc((Value & 0xFF00) >> 8, File);
}


static void FlushBlock(bitstream *Stream)
{
    putc(Stream->BlockSize, Stream->File);  /* Write the size of the block */
    fwrite(Stream->Block, 1, Stream->BlockSize, Stream->File);
    Stream->BlockSize = 0;
}


static void FlushBits(bitstream *Stream, int MaxRemaining)
{
    for(; Stream->NumBits > MaxRemaining;
        Stream->BitAccum >>= 8, Stream->NumBits -= 8)
    {
        Stream->Block[Stream->BlockSize] =
            (unsigned char)(Stream->BitAccum & 0xFF);
        
        if((++Stream->BlockSize) == 255)
            FlushBlock(Stream);
    }
}


static void WriteBits(bitstream *Stream, unsigned short Code)
{
    Stream->BitAccum |= (Stream->NumBits == 0) ?
        Code : (Code << Stream->NumBits);
    Stream->NumBits += Stream->BitsPerCode;
    FlushBits(Stream, 7);
}


static void WriteImageData(FILE *File, tableentry *Table,
    unsigned char *Data, int FrameLeft, int FrameTop,
    int FrameWidth, int FrameHeight, int ImageWidth)
{
    bitstream Stream;
    long Hash;
    unsigned short ClearCode, FreeCode, Prefix, NextRaise;
    unsigned int AppendChar, InitBitsPerCode = 9;
    int x, y, i, Step;
    
    Stream.File = File;
    Stream.BitsPerCode = InitBitsPerCode;
    Stream.BitAccum = Stream.NumBits = Stream.BlockSize = 0;
    ClearCode = (unsigned short)(1 << (InitBitsPerCode - 1));
    NextRaise = (unsigned short)(1 << InitBitsPerCode);
    FreeCode = ClearCode + 2;
    
    for(i = 0; i < TABLESIZE; i++)
        Table[i].Hash = UNUSED;
    
    putc(InitBitsPerCode - 1, File);
    
    /* Get the first character (top left corner of the frame) */
    Prefix = Data[FrameLeft + ImageWidth*FrameTop];
    
    /* Loop over the pixels of the frame in row-major order.  The following is
       equivalent to the nested loop
          for(y = 0; y < FrameHeight; y++)
             for(x = 0; x < FrameWidth; x++)
       but starting from x=1, y=0 instead of x=0, y=0.*/
    for(x = 1, y = 0; y < FrameHeight; (++x >= FrameWidth) ? (x = 0, y++) : 0)
    {
        /* Get the next character */
        AppendChar = Data[(x + FrameLeft) + ImageWidth*(y + FrameTop)];
        
        /* Search for Prefix+AppendChar in the Table */
        Hash = (long)Prefix + (AppendChar << MAXBITS);
        i = (AppendChar << HASHSHIFT) ^ Prefix;
        Step = (i == 0) ? 1 : (TABLESIZE - i);
        
        while(Table[i].Hash != Hash && Table[i].Hash != UNUSED)
            if((i -= Step) < 0)
                i += TABLESIZE;
        
        if(Table[i].Hash != UNUSED)
        {
            /* Set Prefix <- Prefix+AppendChar */
            Prefix = Table[i].Code;
            continue;
        }
        
        /* If we get here, Prefix+AppendChar is not in the Table. */
        WriteBits(&Stream, Prefix);
        
        if(FreeCode < MAXCODE)
        {
            /* Increase BitsPerCode if necessary */
            if(FreeCode == NextRaise)
            {
                Stream.BitsPerCode++;
                NextRaise *= 2;
            }

            /* Add Prefix+AppendChar to the Table. */
            Table[i].Hash = Hash;
            Table[i].Code = FreeCode++;
        }
        else
        {   /* There are no free codes left, clear the Table. */
            WriteBits(&Stream, ClearCode);
            Stream.BitsPerCode = InitBitsPerCode;
            NextRaise = (unsigned short)(1 << InitBitsPerCode);
            FreeCode = ClearCode + 2;
            
            for(i = 0; i < TABLESIZE; i++)
                Table[i].Hash = UNUSED;
        }
        
        Prefix = AppendChar;
    }

    /* Flush buffers and write ending codes */
    WriteBits(&Stream, Prefix);
    WriteBits(&Stream, ClearCode + 1);
    FlushBits(&Stream, 0);
    
    if(Stream.BlockSize > 0)
        FlushBlock(&Stream);
    
    putc(0, File);
}


static void CropFrame(int *FrameLeft, int *FrameTop,
    int *FrameWidth, int *FrameHeight, unsigned char *Data,
    int ImageWidth, int ImageHeight, int TransparentColor)
{
    int x, y, Left = ImageWidth, Right = 0, Top = ImageHeight, Bottom = 0;
    
    for(y = 0; y < ImageHeight; y++, Data += ImageWidth)
        for(x = 0; x < ImageWidth; x++)
            if(Data[x] != TransparentColor)
            {
                if(x < Left)
                    Left = x;
                if(x > Right)
                    Right = x;
                if(y < Top)
                    Top = y;
                if(y > Bottom)
                    Bottom = y;
            }
    
    if(Left == ImageWidth)
    {
        *FrameLeft = *FrameTop = 0;
        *FrameWidth = *FrameHeight = 1;
    }
    else
    {
        *FrameLeft = Left;
        *FrameTop = Top;
        *FrameWidth = Right - Left + 1;
        *FrameHeight = Bottom - Top + 1;
    }
}


void FrameDifference(unsigned char **Image,
    int ImageWidth, int ImageHeight, int NumFrames, int TransparentColor)
{
    const int NumPixels = ImageWidth*ImageHeight;
    int i, Frame, PrevFrame;
    
    /* Input checking */
    if(!Image || ImageWidth <= 0 || ImageHeight <= 0 || NumFrames <= 0)
        return;
    
    for(Frame = 0; Frame < NumFrames; Frame++)
        if(!Image[Frame])
            return;
    
    for(Frame = NumFrames - 1; Frame > 0; Frame--)
        for(i = 0; i < NumPixels; i++)
        {
            if(Image[Frame][i] == TransparentColor)
                continue;
            
            /* Find most recent frame where ith pixel is nontransparent */
            for(PrevFrame = Frame - 1; PrevFrame >= 0; PrevFrame--)
                if(Image[PrevFrame][i] != TransparentColor)
                    break;

            /* Set pixel to transparent if previous pixel is the same color */
            if(PrevFrame >= 0 && Image[PrevFrame][i] == Image[Frame][i])
                Image[Frame][i] = TransparentColor;
        }
}