summaryrefslogtreecommitdiff
path: root/Build/source/libs/gd/libgd-src/src/gd_gif_out.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/gd/libgd-src/src/gd_gif_out.c')
-rw-r--r--Build/source/libs/gd/libgd-src/src/gd_gif_out.c1588
1 files changed, 1588 insertions, 0 deletions
diff --git a/Build/source/libs/gd/libgd-src/src/gd_gif_out.c b/Build/source/libs/gd/libgd-src/src/gd_gif_out.c
new file mode 100644
index 00000000000..51ceb753855
--- /dev/null
+++ b/Build/source/libs/gd/libgd-src/src/gd_gif_out.c
@@ -0,0 +1,1588 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+/* Code drawn from ppmtogif.c, from the pbmplus package
+**
+** Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>. A
+** Lempel-Zim compression based on "compress".
+**
+** Modified by Marcel Wijkstra <wijkstra@fwi.uva.nl>
+**
+** Copyright (C) 1989 by Jef Poskanzer.
+**
+** Permission to use, copy, modify, and distribute this software and its
+** documentation for any purpose and without fee is hereby granted, provided
+** that the above copyright notice appear in all copies and that both that
+** copyright notice and this permission notice appear in supporting
+** documentation. This software is provided "as is" without express or
+** implied warranty.
+**
+** The Graphics Interchange Format(c) is the Copyright property of
+** CompuServe Incorporated. GIF(sm) is a Service Mark property of
+** CompuServe Incorporated.
+*/
+
+/* a code_int must be able to hold 2**GIFBITS values of type int, and also -1 */
+typedef int code_int;
+
+#ifdef SIGNED_COMPARE_SLOW
+typedef unsigned long int count_int;
+typedef unsigned short int count_short;
+#else /* SIGNED_COMPARE_SLOW */
+typedef long int count_int;
+#endif /* SIGNED_COMPARE_SLOW */
+
+/* 2.0.28: threadsafe */
+
+#define maxbits GIFBITS
+
+/* should NEVER generate this code */
+#define maxmaxcode ((code_int)1 << GIFBITS)
+
+#define HSIZE 5003 /* 80% occupancy */
+#define hsize HSIZE /* Apparently invariant, left over from compress */
+
+typedef struct {
+ int Width, Height;
+ int curx, cury;
+ long CountDown;
+ int Pass;
+ int Interlace;
+ int n_bits;
+ code_int maxcode;
+ count_int htab [HSIZE];
+ unsigned short codetab [HSIZE];
+ /* first unused entry */
+ code_int free_ent;
+ /* block compression parameters -- after all codes are used up,
+ * and compression rate changes, start over. */
+ int clear_flg;
+ int offset;
+ long int in_count;
+ /* # of codes output (for debugging) */
+ long int out_count;
+ int g_init_bits;
+ gdIOCtx * g_outfile;
+ int ClearCode;
+ int EOFCode;
+ unsigned long cur_accum;
+ int cur_bits;
+ int a_count;
+ char accum[ 256 ];
+} GifCtx;
+
+static int gifPutWord(int w, gdIOCtx *out);
+static int colorstobpp(int colors);
+static void BumpPixel(GifCtx *ctx);
+static int GIFNextPixel(gdImagePtr im, GifCtx *ctx);
+static void GIFEncode(gdIOCtxPtr fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
+static void GIFAnimEncode(gdIOCtxPtr fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im);
+static void compress(int init_bits, gdIOCtx *outfile, gdImagePtr im, GifCtx *ctx);
+static void output(code_int code, GifCtx *ctx);
+static void cl_block(GifCtx *ctx);
+static void cl_hash(register count_int chsize, GifCtx *ctx);
+static void char_init(GifCtx *ctx);
+static void char_out(int c, GifCtx *ctx);
+static void flush_char(GifCtx *ctx);
+
+
+
+
+/*
+ Function: gdImageGifPtr
+
+ Identical to <gdImageGif> except that it returns a pointer to a
+ memory area with the GIF data. This memory must be freed by the
+ caller when it is no longer needed.
+
+ The caller *must* invoke <gdFree>, not _free()_. This is because
+ it is not guaranteed that libgd will use the same implementation
+ of malloc, free, etc. as your proggram.
+
+ The 'size' parameter receives the total size of the block of
+ memory.
+
+ Parameters:
+
+ im - The image to write
+ size - Output: the size of the resulting image.
+
+ Returns:
+
+ A pointer to the GIF data or NULL if an error occurred.
+
+*/
+BGD_DECLARE(void *) gdImageGifPtr(gdImagePtr im, int *size)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+ if (out == NULL) return NULL;
+ gdImageGifCtx(im, out);
+ rv = gdDPExtractData(out, size);
+ out->gd_free(out);
+ return rv;
+}
+
+/*
+ Function: gdImageGif
+
+ <gdImageGif> outputs the specified image to the specified file in
+ GIF format. The file must be open for binary writing. (Under MSDOS
+ and all versions of Windows, it is important to use "wb" as
+ opposed to simply "w" as the mode when opening the file; under
+ Unix there is no penalty for doing so). <gdImageGif> does not close
+ the file; your code must do so.
+
+ GIF does not support true color; GIF images can contain a maximum
+ of 256 colors. If the image to be written is a truecolor image,
+ such as those created with gdImageCreateTrueColor or loaded from a
+ JPEG or a truecolor PNG image file, a palette-based temporary
+ image will automatically be created internally using the
+ <gdImageCreatePaletteFromTrueColor> function. The original image
+ pixels are not modified. This conversion produces high quality
+ palettes but does require some CPU time. If you are regularly
+ converting truecolor to palette in this way, you should consider
+ creating your image as a palette-based image in the first place.
+
+ Variants:
+
+ <gdImageGifCtx> outputs the image via a <gdIOCtx> struct.
+
+ <gdImageGifPtr> stores the image in a large array of bytes.
+
+ Parameters:
+
+ im - The image to write
+ outFile - The FILE pointer to write the image to.
+
+ Returns:
+
+ Nothing
+
+ Example:
+
+ > gdImagePtr im;
+ > int black, white;
+ > FILE *out;
+ > // Create the image
+ > im = gdImageCreate(100, 100);
+ > // Allocate background
+ > white = gdImageColorAllocate(im, 255, 255, 255);
+ > // Allocate drawing color
+ > black = gdImageColorAllocate(im, 0, 0, 0);
+ > // Draw rectangle
+ > gdImageRectangle(im, 0, 0, 99, 99, black);
+ > // Open output file in binary mode
+ > out = fopen("rect.gif", "wb");
+ > // Write GIF
+ > gdImageGif(im, out);
+ > // Close file
+ > fclose(out);
+ > // Destroy image
+ > gdImageDestroy(im);
+
+*/
+BGD_DECLARE(void) gdImageGif(gdImagePtr im, FILE *outFile)
+{
+ gdIOCtx *out = gdNewFileCtx(outFile);
+ if (out == NULL) return;
+ gdImageGifCtx(im, out);
+ out->gd_free(out);
+}
+
+/*
+ Function: gdImageGifCtx
+
+ Writes a GIF image via a <gdIOCtx>. See <gdImageGif>.
+
+ Parameters:
+
+ im - The image to write
+ out - The <gdIOCtx> struct used to do the writing.
+
+ Returns:
+
+ Nothing.
+
+*/
+BGD_DECLARE(void) gdImageGifCtx(gdImagePtr im, gdIOCtxPtr out)
+{
+ gdImagePtr pim = 0, tim = im;
+ int interlace, BitsPerPixel;
+ interlace = im->interlace;
+
+ if(im->trueColor) {
+ /* Expensive, but the only way that produces an
+ acceptable result: mix down to a palette
+ based temporary image. */
+ pim = gdImageCreatePaletteFromTrueColor(im, 1, 256);
+ if(!pim) {
+ return;
+ }
+ tim = pim;
+ }
+
+ BitsPerPixel = colorstobpp(tim->colorsTotal);
+
+ /* All set, let's do it. */
+ GIFEncode(
+ out, tim->sx, tim->sy, interlace, 0, tim->transparent, BitsPerPixel,
+ tim->red, tim->green, tim->blue, tim);
+
+ if(pim) {
+ /* Destroy palette based temporary image. */
+ gdImageDestroy( pim);
+ }
+}
+
+
+/*
+ Function: gdImageGifAnimBeginPtr
+
+ Like <gdImageGifAnimBegin> except that it outputs to a memory
+ buffer. See <gdImageGifAnimBegin>.
+
+ The returned memory must be freed by the caller when it is no
+ longer needed. **The caller must invoke <gdFree>(), not free()**,
+ unless the caller is absolutely certain that the same
+ implementations of malloc, free, etc. are used both at library
+ build time and at application build time (but don't; it could
+ always change).
+
+ The 'size' parameter receives the total size of the block of
+ memory.
+
+ Parameters:
+
+ im - The reference image
+ size - Output: the size in bytes of the result.
+ GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default
+ Loops - Loop count; 0 -> infinite, -1 means no loop
+
+ Returns:
+
+ A pointer to the resulting data (the contents of the start of the
+ GIF) or NULL if an error occurred.
+
+*/
+
+BGD_DECLARE(void *) gdImageGifAnimBeginPtr(gdImagePtr im, int *size, int GlobalCM, int Loops)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+ if (out == NULL) return NULL;
+ gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
+ rv = gdDPExtractData(out, size);
+ out->gd_free(out);
+ return rv;
+}
+
+
+/*
+ Function: gdImageGifAnimBegin
+
+ This function must be called as the first function when creating a
+ GIF animation. It writes the correct GIF file headers to selected
+ file output, and prepares for frames to be added for the
+ animation. The image argument is not used to produce an image
+ frame to the file, it is only used to establish the GIF animation
+ frame size, interlacing options and the color
+ palette. <gdImageGifAnimAdd> is used to add the first and
+ subsequent frames to the animation, and the animation must be
+ terminated by writing a semicolon character (;) to it or by using
+ gdImageGifAnimEnd to do that.
+
+ The GlobalCM flag indicates if a global color map (or palette) is
+ used in the GIF89A header. A nonzero value specifies that a global
+ color map should be used to reduce the size of the animation. Of
+ course, if the color maps of individual frames differ greatly, a
+ global color map may not be a good idea. GlobalCM=1 means write
+ global color map, GlobalCM=0 means do not, and GlobalCM=-1 means
+ to do the default, which currently is to use a global color map.
+
+ If Loops is 0 or greater, the Netscape 2.0 extension for animation
+ loop count is written. 0 means infinite loop count. -1 means that
+ the extension is not added which results in no looping. -1 is the
+ default.
+
+ Variants:
+
+ <gdImageGifAnimBeginCtx> outputs the image via a <gdIOCtx> struct.
+
+ <gdImageGifAnimBeginPtr> stores the image in a large array of bytes.
+
+ Parameters:
+
+ im - The reference image
+ outfile - The output FILE*.
+ GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default
+ Loops - Loop count; 0 -> infinite, -1 means no loop
+
+ Returns:
+
+ Nothing.
+
+ Example:
+
+ See <gdImageGifAnimBegin>.
+
+*/
+
+BGD_DECLARE(void) gdImageGifAnimBegin(gdImagePtr im, FILE *outFile, int GlobalCM, int Loops)
+{
+ gdIOCtx *out = gdNewFileCtx(outFile);
+ if (out == NULL) return;
+ gdImageGifAnimBeginCtx(im, out, GlobalCM, Loops);
+ out->gd_free(out);
+}
+
+
+
+/*
+ Function: gdImageGifAnimBeginCtx
+
+ Like <gdImageGifAnimBegin> except that it outputs to <gdIOCtx>.
+ See <gdImageGifAnimBegin>.
+
+ Parameters:
+
+ im - The reference image
+ out - Pointer to the output <gdIOCtx>.
+ GlobalCM - Global colormap flag: 1 -> yes, 0 -> no, -1 -> do default
+ Loops - Loop count; 0 -> infinite, -1 means no loop
+
+ Returns:
+
+ Nothing.
+
+*/
+BGD_DECLARE(void) gdImageGifAnimBeginCtx(gdImagePtr im, gdIOCtxPtr out, int GlobalCM, int Loops)
+{
+ int B;
+ int RWidth, RHeight;
+ int Resolution;
+ int ColorMapSize;
+ int BitsPerPixel;
+ int Background = 0;
+ int i;
+
+ /* Default is to use global color map */
+ if (GlobalCM < 0) {
+ GlobalCM = 1;
+ }
+
+ BitsPerPixel = colorstobpp(im->colorsTotal);
+ ColorMapSize = 1 << BitsPerPixel;
+
+ RWidth = im->sx;
+ RHeight = im->sy;
+
+ Resolution = BitsPerPixel;
+
+ /* Write the Magic header */
+ gdPutBuf("GIF89a", 6, out);
+
+ /* Write out the screen width and height */
+ gifPutWord(RWidth, out);
+ gifPutWord(RHeight, out);
+
+ /* Indicate that there is a global colour map */
+ B = GlobalCM ? 0x80 : 0;
+
+ /* OR in the resolution */
+ B |= (Resolution - 1) << 4;
+
+ /* OR in the Bits per Pixel */
+ B |= (BitsPerPixel - 1);
+
+ /* Write it out */
+ gdPutC(B, out);
+
+ /* Write out the Background colour */
+ gdPutC(Background, out);
+
+ /* Byte of 0's (future expansion) */
+ gdPutC(0, out);
+
+ /* Write out the Global Colour Map */
+ if(GlobalCM) {
+ for(i = 0; i < ColorMapSize; ++i) {
+ gdPutC(im->red[i], out);
+ gdPutC(im->green[i], out);
+ gdPutC(im->blue[i], out);
+ }
+ }
+
+ if(Loops >= 0) {
+ gdPutBuf("!\377\13NETSCAPE2.0\3\1", 16, out);
+ gifPutWord(Loops, out);
+ gdPutC(0, out);
+ }
+}
+
+
+
+/*
+ Function: gdImageGifAnimAddPtr
+
+ Like <gdImageGifAnimAdd> (which contains more information) except
+ that it stores the data to write into memory and returns a pointer
+ to it.
+
+ This memory must be freed by the caller when it is no longer
+ needed. **The caller must invoke <gdFree>(), not free(),** unless
+ the caller is absolutely certain that the same implementations of
+ malloc, free, etc. are used both at library build time and at
+ application build time (but don't; it could always change).
+
+ The 'size' parameter receives the total size of the block of
+ memory.
+
+ Parameters:
+
+ im - The image to add.
+ size - Output: the size of the resulting buffer.
+ LocalCM - Flag. If 1, use a local color map for this frame.
+ LeftOfs - Left offset of image in frame.
+ TopOfs - Top offset of image in frame.
+ Delay - Delay before next frame (in 1/100 seconds)
+ Disposal - MODE: How to treat this frame when the next one loads.
+ previm - NULL or a pointer to the previous image written.
+
+ Returns:
+
+ Pointer to the resulting data or NULL if an error occurred.
+
+*/
+BGD_DECLARE(void *) gdImageGifAnimAddPtr(gdImagePtr im, int *size, int LocalCM,
+ int LeftOfs, int TopOfs, int Delay,
+ int Disposal, gdImagePtr previm)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
+ if (out == NULL) return NULL;
+ gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm);
+ rv = gdDPExtractData(out, size);
+ out->gd_free(out);
+ return rv;
+}
+
+
+/*
+ Function: gdImageGifAnimAdd
+
+ This function writes GIF animation frames to GIF animation, which
+ was initialized with <gdImageGifAnimBegin>. With _LeftOfs_ and
+ _TopOfs_ you can place this frame in different offset than (0,0)
+ inside the image screen as defined in <gdImageGifAnimBegin>. Delay
+ between the previous frame and this frame is in 1/100s
+ units. _Disposal_ is usually <gdDisposalNone>, meaning that the
+ pixels changed by this frame should remain on the display when the
+ next frame begins to render, but can also be <gdDisposalUnknown>
+ (not recommended), <gdDisposalRestoreBackground> (restores the
+ first allocated color of the global palette), or
+ <gdDisposalRestorePrevious> (restores the appearance of the
+ affected area before the frame was rendered). Only
+ <gdDisposalNone> is a sensible choice for the first frame. If
+ _previm_ is passed, the built-in GIF optimizer will always use
+ <gdDisposalNone> regardless of the Disposal parameter.
+
+ Setting the _LocalCM_ flag to 1 adds a local palette for this
+ image to the animation. Otherwise the global palette is assumed
+ and the user must make sure the palettes match. Use
+ <gdImagePaletteCopy> to do that.
+
+ Automatic optimization is activated by giving the previous image
+ as a parameter. This function then compares the images and only
+ writes the changed pixels to the new frame in animation. The
+ _Disposal_ parameter for optimized animations must be set to 1,
+ also for the first frame. _LeftOfs_ and _TopOfs_ parameters are
+ ignored for optimized frames. To achieve good optimization, it is
+ usually best to use a single global color map. To allow
+ <gdImageGifAnimAdd> to compress unchanged pixels via the use of a
+ transparent color, the image must include a transparent color.
+
+
+ Variants:
+
+ <gdImageGifAnimAddCtx> outputs its data via a <gdIOCtx> struct.
+
+ <gdImageGifAnimAddPtr> outputs its data to a memory buffer which
+ it returns.
+
+ Parameters:
+
+ im - The image to add.
+ outfile - The output FILE* being written.
+ LocalCM - Flag. If 1, use a local color map for this frame.
+ LeftOfs - Left offset of image in frame.
+ TopOfs - Top offset of image in frame.
+ Delay - Delay before next frame (in 1/100 seconds)
+ Disposal - MODE: How to treat this frame when the next one loads.
+ previm - NULL or a pointer to the previous image written.
+
+ Returns:
+
+ Nothing.
+
+ Example:
+
+ > {
+ > gdImagePtr im, im2, im3;
+ > int black, white, trans;
+ > FILE *out;
+ >
+ > im = gdImageCreate(100, 100); // Create the image
+ > white = gdImageColorAllocate(im, 255, 255, 255); // Allocate background
+ > black = gdImageColorAllocate(im, 0, 0, 0); // Allocate drawing color
+ > trans = gdImageColorAllocate(im, 1, 1, 1); // trans clr for compression
+ > gdImageRectangle(im, 0, 0, 10, 10, black); // Draw rectangle
+ >
+ > out = fopen("anim.gif", "wb");// Open output file in binary mode
+ > gdImageGifAnimBegin(im, out, 1, 3);// Write GIF hdr, global clr map,loops
+ > // Write the first frame. No local color map. Delay = 1s
+ > gdImageGifAnimAdd(im, out, 0, 0, 0, 100, 1, NULL);
+ >
+ > // construct the second frame
+ > im2 = gdImageCreate(100, 100);
+ > (void)gdImageColorAllocate(im2, 255, 255, 255); // White background
+ > gdImagePaletteCopy (im2, im); // Make sure the palette is identical
+ > gdImageRectangle(im2, 0, 0, 15, 15, black); // Draw something
+ > // Allow animation compression with transparent pixels
+ > gdImageColorTransparent (im2, trans);
+ > gdImageGifAnimAdd(im2, out, 0, 0, 0, 100, 1, im); // Add second frame
+ >
+ > // construct the third frame
+ > im3 = gdImageCreate(100, 100);
+ > (void)gdImageColorAllocate(im3, 255, 255, 255); // white background
+ > gdImagePaletteCopy (im3, im); // Make sure the palette is identical
+ > gdImageRectangle(im3, 0, 0, 15, 20, black); // Draw something
+ > // Allow animation compression with transparent pixels
+ > gdImageColorTransparent (im3, trans);
+ > // Add the third frame, compressing against the second one
+ > gdImageGifAnimAdd(im3, out, 0, 0, 0, 100, 1, im2);
+ > gdImageGifAnimEnd(out); // End marker, same as putc(';', out);
+ > fclose(out); // Close file
+ >
+ > // Destroy images
+ > gdImageDestroy(im);
+ > gdImageDestroy(im2);
+ > gdImageDestroy(im3);
+ > }
+
+*/
+
+BGD_DECLARE(void) gdImageGifAnimAdd(gdImagePtr im, FILE *outFile, int LocalCM,
+ int LeftOfs, int TopOfs, int Delay,
+ int Disposal, gdImagePtr previm)
+{
+ gdIOCtx *out = gdNewFileCtx(outFile);
+ if (out == NULL) return;
+ gdImageGifAnimAddCtx(im, out, LocalCM, LeftOfs, TopOfs, Delay, Disposal, previm);
+ out->gd_free(out);
+}
+
+static int comparewithmap(gdImagePtr im1, gdImagePtr im2, int c1, int c2, int *colorMap)
+{
+ if(!colorMap) {
+ return c1 == c2;
+ }
+
+ if(-2 != colorMap[c1]) {
+ return colorMap[c1] == c2;
+ }
+
+ return (colorMap[c1] = gdImageColorExactAlpha(im2, im1->red[c1], im1->green[c1], im1->blue[c1], im1->alpha[c1])) == c2;
+}
+
+/*
+ Function: gdImageGifAnimAddCtx
+
+ Adds an animation frame via a <gdIOCtxPtr>. See gdImageGifAnimAdd>.
+
+ Parameters:
+
+ im - The image to add.
+ out - The output <gdIOCtxPtr>.
+ LocalCM - Flag. If 1, use a local color map for this frame.
+ LeftOfs - Left offset of image in frame.
+ TopOfs - Top offset of image in frame.
+ Delay - Delay before next frame (in 1/100 seconds)
+ Disposal - MODE: How to treat this frame when the next one loads.
+ previm - NULL or a pointer to the previous image written.
+
+ Returns:
+
+ Nothing.
+
+*/
+BGD_DECLARE(void) gdImageGifAnimAddCtx(gdImagePtr im, gdIOCtxPtr out,
+ int LocalCM, int LeftOfs, int TopOfs,
+ int Delay, int Disposal,
+ gdImagePtr previm)
+{
+ gdImagePtr pim = NULL, tim = im;
+ int interlace, transparent, BitsPerPixel;
+ interlace = im->interlace;
+ transparent = im->transparent;
+
+ /* Default is no local color map */
+ if(LocalCM < 0) {
+ LocalCM = 0;
+ }
+
+ if(im->trueColor) {
+ /* Expensive, but the only way that produces an
+ acceptable result: mix down to a palette
+ based temporary image. */
+ pim = gdImageCreatePaletteFromTrueColor(im, 1, 256);
+ if (!pim) {
+ return;
+ }
+ tim = pim;
+ }
+
+ if (previm) {
+ /* create optimized animation. Compare this image to
+ the previous image and crop the temporary copy of
+ current image to include only changed rectangular
+ area. Also replace unchanged pixels inside this
+ area with transparent color. Transparent color
+ needs to be already allocated!
+ Preconditions:
+ TopOfs, LeftOfs are assumed 0
+
+ Images should be of same size. If not, a temporary
+ copy is made with the same size as previous image.
+
+ */
+ gdImagePtr prev_pim = 0, prev_tim = previm;
+ int x, y;
+ int min_x = 0;
+ int min_y = tim->sy;
+ int max_x = 0;
+ int max_y = 0;
+ int colorMap[256];
+
+ if (previm->trueColor) {
+ prev_pim = gdImageCreatePaletteFromTrueColor(previm, 1, 256);
+ if (!prev_pim) {
+ goto fail_end;
+ }
+ prev_tim = prev_pim;
+ }
+
+ for (x = 0; x < 256; ++x) {
+ colorMap[x] = -2;
+ }
+
+ /* First find bounding box of changed areas. */
+ /* first find the top changed row */
+ for (y = 0; y < tim->sy; ++y) {
+ for (x = 0; x < tim->sx; ++x) {
+ if (!comparewithmap(prev_tim, tim,
+ prev_tim->pixels[y][x],
+ tim->pixels[y][x],
+ colorMap)) {
+ min_y = max_y = y;
+ min_x = max_x = x;
+ goto break_top;
+ }
+ }
+ }
+
+break_top:
+ if (tim->sy == min_y) {
+ /* No changes in this frame!! Encode empty image. */
+ transparent = 0;
+ min_x = min_y = 1;
+ max_x = max_y = 0;
+ } else {
+ /* Then the bottom row */
+ for (y = tim->sy - 1; y > min_y; --y) {
+ for (x = 0; x < tim->sx; ++x) {
+ if (!comparewithmap
+ (prev_tim, tim,
+ prev_tim->pixels[y][x],
+ tim->pixels[y][x],
+ colorMap)) {
+ max_y = y;
+ if(x < min_x) {
+ min_x = x;
+ }
+ if(x > max_x) {
+ max_x = x;
+ }
+ goto break_bot;
+ }
+ }
+ }
+
+break_bot:
+ /* left side */
+ for (x = 0; x < min_x; ++x) {
+ for (y = min_y; y <= max_y; ++y) {
+ if (!comparewithmap
+ (prev_tim, tim,
+ prev_tim->pixels[y][x],
+ tim->pixels[y][x],
+ colorMap)) {
+ min_x = x;
+ goto break_left;
+ }
+ }
+ }
+
+break_left:
+ /* right side */
+ for (x = tim->sx - 1; x > max_x; --x) {
+ for (y = min_y; y <= max_y; ++y) {
+ if (!comparewithmap
+ (prev_tim, tim,
+ prev_tim->pixels[y][x],
+ tim->pixels[y][x],
+ colorMap)) {
+ max_x = x;
+ goto break_right;
+ }
+ }
+ }
+
+break_right:
+ ;
+ }
+
+ LeftOfs = min_x;
+ TopOfs = min_y;
+ Disposal = 1;
+
+ /* Make a copy of the image with the new offsets.
+ But only if necessary. */
+ if (min_x != 0 || max_x != tim->sx - 1
+ || min_y != 0 || max_y != tim->sy - 1
+ || transparent >= 0) {
+
+ gdImagePtr pim2 = gdImageCreate(max_x-min_x + 1, max_y-min_y + 1);
+
+ if (!pim2) {
+ if (prev_pim) {
+ gdImageDestroy(prev_pim);
+ }
+ goto fail_end;
+ }
+
+ gdImagePaletteCopy(pim2, LocalCM ? tim : prev_tim);
+ gdImageCopy(pim2, tim, 0, 0, min_x, min_y,
+ max_x - min_x + 1, max_y - min_y + 1);
+
+ if (pim) {
+ gdImageDestroy(pim);
+ }
+
+ tim = pim = pim2;
+ }
+
+ /* now let's compare pixels for transparent
+ optimization. But only if transparent is set. */
+ if (transparent >= 0) {
+ for(y = 0; y < tim->sy; ++y) {
+ for (x = 0; x < tim->sx; ++x) {
+ if(comparewithmap
+ (prev_tim, tim,
+ prev_tim->pixels[min_y + y][min_x + x],
+ tim->pixels[y][x], 0)) {
+ gdImageSetPixel(tim, x, y, transparent);
+ break;
+ }
+ }
+ }
+ }
+
+ if(prev_pim) {
+ gdImageDestroy(prev_pim);
+ }
+ }
+
+ BitsPerPixel = colorstobpp(tim->colorsTotal);
+
+ /* All set, let's do it. */
+ GIFAnimEncode(
+ out, tim->sx, tim->sy, LeftOfs, TopOfs, interlace, transparent,
+ Delay, Disposal, BitsPerPixel,
+ LocalCM ? tim->red : 0, tim->green, tim->blue, tim);
+
+fail_end:
+ if(pim) {
+ /* Destroy palette based temporary image. */
+ gdImageDestroy(pim);
+ }
+}
+
+
+
+/*
+ Function: gdImageGifAnimEnd
+
+ Terminates the GIF file properly.
+
+ (Previous versions of this function's documentation suggested just
+ manually writing a semicolon (';') instead since that is all this
+ function does. While that has no longer changed, we now suggest
+ that you do not do this and instead always call
+ <gdImageGifAnimEnd> (or equivalent) since later versions could
+ possibly do more or different things.)
+
+ Variants:
+
+ <gdImageGifAnimEndCtx> outputs its data via a <gdIOCtx> struct.
+
+ <gdImageGifAnimEndPtr> outputs its data to a memory buffer which
+ it returns.
+
+ Parameters:
+
+ outfile - the destination FILE*.
+
+ Returns:
+
+ Nothing.
+
+*/
+
+BGD_DECLARE(void) gdImageGifAnimEnd(FILE *outFile)
+{
+#if 1
+ putc(';', outFile);
+#else
+ gdIOCtx *out = gdNewFileCtx(outFile);
+ if (out == NULL) return;
+ gdImageGifAnimEndCtx(out);
+ out->gd_free(out);
+#endif
+}
+
+/*
+ Function: gdImageGifAnimEndPtr
+
+ Like <gdImageGifAnimEnd> (which contains more information) except
+ that it stores the data to write into memory and returns a pointer
+ to it.
+
+ This memory must be freed by the caller when it is no longer
+ needed. **The caller must invoke <gdFree>(), not free(),** unless
+ the caller is absolutely certain that the same implementations of
+ malloc, free, etc. are used both at library build time and at
+ application build time (but don't; it could always change).
+
+ The 'size' parameter receives the total size of the block of
+ memory.
+
+ Parameters:
+
+ size - Output: the size of the resulting buffer.
+
+ Returns:
+
+ Pointer to the resulting data or NULL if an error occurred.
+
+*/
+
+BGD_DECLARE(void *) gdImageGifAnimEndPtr(int *size)
+{
+ char *rv = (char *) gdMalloc(1);
+ if(!rv) {
+ return 0;
+ }
+ *rv = ';';
+ *size = 1;
+ return (void *)rv;
+}
+
+/*
+ Function: gdImageGifAnimEndCtx
+
+ Like <gdImageGifAnimEnd>, but writes its data via a <gdIOCtx>.
+
+ Parameters:
+
+ out - the destination <gdIOCtx>.
+
+ Returns:
+
+ Nothing.
+
+*/
+
+BGD_DECLARE(void) gdImageGifAnimEndCtx(gdIOCtx *out)
+{
+ /*
+ * Write the GIF file terminator
+ */
+ gdPutC(';', out);
+}
+
+static int colorstobpp(int colors)
+{
+ int bpp = 0;
+
+ if(colors <= 2)
+ bpp = 1;
+ else if(colors <= 4)
+ bpp = 2;
+ else if(colors <= 8)
+ bpp = 3;
+ else if(colors <= 16)
+ bpp = 4;
+ else if(colors <= 32)
+ bpp = 5;
+ else if(colors <= 64)
+ bpp = 6;
+ else if(colors <= 128)
+ bpp = 7;
+ else if(colors <= 256)
+ bpp = 8;
+
+ return bpp;
+}
+
+/*****************************************************************************
+ *
+ * GIFENCODE.C - GIF Image compression interface
+ *
+ * GIFEncode( FName, GHeight, GWidth, GInterlace, Background, Transparent,
+ * BitsPerPixel, Red, Green, Blue, gdImagePtr )
+ *
+ *****************************************************************************/
+
+#define TRUE 1
+#define FALSE 0
+
+/* Bump the 'curx' and 'cury' to point to the next pixel */
+static void BumpPixel(GifCtx *ctx)
+{
+ /* Bump the current X position */
+ ++(ctx->curx);
+
+ /* If we are at the end of a scan line, set curx back to the beginning
+ * If we are interlaced, bump the cury to the appropriate spot,
+ * otherwise, just increment it. */
+ if(ctx->curx == ctx->Width) {
+ ctx->curx = 0;
+
+ if(!ctx->Interlace) {
+ ++(ctx->cury);
+ } else {
+ switch(ctx->Pass) {
+
+ case 0:
+ ctx->cury += 8;
+ if(ctx->cury >= ctx->Height) {
+ ++(ctx->Pass);
+ ctx->cury = 4;
+ }
+ break;
+
+ case 1:
+ ctx->cury += 8;
+ if(ctx->cury >= ctx->Height) {
+ ++(ctx->Pass);
+ ctx->cury = 2;
+ }
+ break;
+
+ case 2:
+ ctx->cury += 4;
+ if(ctx->cury >= ctx->Height) {
+ ++(ctx->Pass);
+ ctx->cury = 1;
+ }
+ break;
+
+ case 3:
+ ctx->cury += 2;
+ break;
+ }
+ }
+ }
+}
+
+/* Return the next pixel from the image */
+static int GIFNextPixel(gdImagePtr im, GifCtx *ctx)
+{
+ int r;
+
+ if(ctx->CountDown == 0) {
+ return EOF;
+ }
+
+ --(ctx->CountDown);
+
+ r = gdImageGetPixel(im, ctx->curx, ctx->cury);
+
+ BumpPixel(ctx);
+
+ return r;
+}
+
+/* public */
+
+static void GIFEncode(gdIOCtxPtr fp, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
+{
+ int B;
+ int RWidth, RHeight;
+ int LeftOfs, TopOfs;
+ int Resolution;
+ int ColorMapSize;
+ int InitCodeSize;
+ int i;
+ GifCtx ctx;
+
+ memset(&ctx, 0, sizeof(ctx));
+
+ ctx.Interlace = GInterlace;
+ ctx.in_count = 1;
+
+ ColorMapSize = 1 << BitsPerPixel;
+
+ RWidth = ctx.Width = GWidth;
+ RHeight = ctx.Height = GHeight;
+ LeftOfs = TopOfs = 0;
+
+ Resolution = BitsPerPixel;
+
+ /* Calculate number of bits we are expecting */
+ ctx.CountDown = (long)ctx.Width * (long)ctx.Height;
+
+ /* Indicate which pass we are on (if interlace) */
+ ctx.Pass = 0;
+
+ /* The initial code size */
+ if(BitsPerPixel <= 1) {
+ InitCodeSize = 2;
+ } else {
+ InitCodeSize = BitsPerPixel;
+ }
+
+ /* Set up the current x and y position */
+ ctx.curx = ctx.cury = 0;
+
+ /* Write the Magic header */
+ gdPutBuf(Transparent < 0 ? "GIF87a" : "GIF89a", 6, fp);
+
+ /* Write out the screen width and height */
+ gifPutWord(RWidth, fp);
+ gifPutWord(RHeight, fp);
+
+ /* Indicate that there is a global colour map */
+ /* Yes, there is a color map */
+ B = 0x80;
+
+ /* OR in the resolution */
+ B |= (Resolution - 1) << 4;
+
+ /* OR in the Bits per Pixel */
+ B |= (BitsPerPixel - 1);
+
+ /* Write it out */
+ gdPutC(B, fp);
+
+ /* Write out the Background colour */
+ gdPutC(Background, fp);
+
+ /* Byte of 0's (future expansion) */
+ gdPutC(0, fp);
+
+ /* Write out the Global Colour Map */
+ for(i = 0; i < ColorMapSize; ++i) {
+ gdPutC(Red[i], fp);
+ gdPutC(Green[i], fp);
+ gdPutC(Blue[i], fp);
+ }
+
+ /* Write out extension for transparent colour index, if necessary. */
+ if(Transparent >= 0) {
+ gdPutC('!', fp);
+ gdPutC(0xf9, fp);
+ gdPutC(4, fp);
+ gdPutC(1, fp);
+ gdPutC(0, fp);
+ gdPutC(0, fp);
+ gdPutC((unsigned char) Transparent, fp);
+ gdPutC(0, fp);
+ }
+
+ /* Write an Image separator */
+ gdPutC(',', fp);
+
+ /* Write the Image header */
+ gifPutWord(LeftOfs, fp);
+ gifPutWord(TopOfs, fp);
+ gifPutWord(ctx.Width, fp);
+ gifPutWord(ctx.Height, fp);
+
+ /* Write out whether or not the image is interlaced */
+ if(ctx.Interlace) {
+ gdPutC(0x40, fp);
+ } else {
+ gdPutC(0x00, fp);
+ }
+
+ /* Write out the initial code size */
+ gdPutC(InitCodeSize, fp);
+
+ /* Go and actually compress the data */
+ compress(InitCodeSize + 1, fp, im, &ctx);
+
+ /* Write out a Zero-length packet (to end the series) */
+ gdPutC(0, fp);
+
+ /* Write the GIF file terminator */
+ gdPutC(';', fp);
+}
+
+static void GIFAnimEncode(gdIOCtxPtr fp, int IWidth, int IHeight, int LeftOfs, int TopOfs, int GInterlace, int Transparent, int Delay, int Disposal, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
+{
+ int B;
+ int ColorMapSize;
+ int InitCodeSize;
+ int i;
+ GifCtx ctx;
+
+ memset(&ctx, 0, sizeof(ctx));
+
+ ctx.Interlace = GInterlace;
+ ctx.in_count = 1;
+
+ ColorMapSize = 1 << BitsPerPixel;
+
+ if(LeftOfs < 0) {
+ LeftOfs = 0;
+ }
+ if(TopOfs < 0) {
+ TopOfs = 0;
+ }
+ if(Delay < 0) {
+ Delay = 100;
+ }
+ if(Disposal < 0) {
+ Disposal = 1;
+ }
+
+ ctx.Width = IWidth;
+ ctx.Height = IHeight;
+
+ /* Calculate number of bits we are expecting */
+ ctx.CountDown = (long)ctx.Width * (long)ctx.Height;
+
+ /* Indicate which pass we are on (if interlace) */
+ ctx.Pass = 0;
+
+ /* The initial code size */
+ if(BitsPerPixel <= 1) {
+ InitCodeSize = 2;
+ } else {
+ InitCodeSize = BitsPerPixel;
+ }
+
+ /* Set up the current x and y position */
+ ctx.curx = ctx.cury = 0;
+
+ /* Write out extension for image animation and looping */
+ gdPutC('!', fp);
+ gdPutC(0xf9, fp);
+ gdPutC(4, fp);
+ gdPutC((Transparent >= 0 ? 1 : 0) | (Disposal << 2), fp);
+ gdPutC((unsigned char)(Delay & 255), fp);
+ gdPutC((unsigned char)((Delay >> 8) & 255), fp);
+ gdPutC((unsigned char) Transparent, fp);
+ gdPutC(0, fp);
+
+ /* Write an Image separator */
+ gdPutC(',', fp);
+
+ /* Write out the Image header */
+ gifPutWord(LeftOfs, fp);
+ gifPutWord(TopOfs, fp);
+ gifPutWord(ctx.Width, fp);
+ gifPutWord(ctx.Height, fp);
+
+ /* Indicate that there is a local colour map */
+ B = (Red && Green && Blue) ? 0x80 : 0;
+
+ /* OR in the interlacing */
+ B |= ctx.Interlace ? 0x40 : 0;
+
+ /* OR in the Bits per Pixel */
+ B |= (Red && Green && Blue) ? (BitsPerPixel - 1) : 0;
+
+ /* Write it out */
+ gdPutC(B, fp);
+
+ /* Write out the Local Colour Map */
+ if(Red && Green && Blue) {
+ for(i = 0; i < ColorMapSize; ++i) {
+ gdPutC(Red[i], fp);
+ gdPutC(Green[i], fp);
+ gdPutC(Blue[i], fp);
+ }
+ }
+
+ /* Write out the initial code size */
+ gdPutC(InitCodeSize, fp);
+
+ /* Go and actually compress the data */
+ compress(InitCodeSize + 1, fp, im, &ctx);
+
+ /* Write out a Zero-length packet (to end the series) */
+ gdPutC(0, fp);
+}
+
+/***************************************************************************
+ *
+ * GIFCOMPR.C - GIF Image compression routines
+ *
+ * Lempel-Ziv compression based on 'compress'. GIF modifications by
+ * David Rowley (mgardi@watdcsu.waterloo.edu)
+ *
+ ***************************************************************************/
+
+/* General DEFINEs */
+
+#define GIFBITS 12
+
+#ifdef NO_UCHAR
+typedef char char_type;
+#else /* NO_UCHAR */
+typedef unsigned char char_type;
+#endif /* NO_UCHAR */
+
+/*
+ *
+ * GIF Image compression - modified 'compress'
+ *
+ * Based on: compress.c - File compression ala IEEE Computer, June 1984.
+ *
+ * By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
+ * Jim McKie (decvax!mcvax!jim)
+ * Steve Davies (decvax!vax135!petsd!peora!srd)
+ * Ken Turkowski (decvax!decwrl!turtlevax!ken)
+ * James A. Woods (decvax!ihnp4!ames!jaw)
+ * Joe Orost (decvax!vax135!petsd!joe)
+ *
+ */
+#include <ctype.h>
+
+#define ARGVAL() (*++(*argv) || (--argc && *++argv))
+
+#ifdef COMPATIBLE /* But wrong! */
+# define MAXCODE(n_bits) ((code_int) 1 << (n_bits) - 1)
+#else /* COMPATIBLE */
+# define MAXCODE(n_bits) (((code_int) 1 << (n_bits)) - 1)
+#endif /* COMPATIBLE */
+
+#define HashTabOf(i) ctx->htab[i]
+#define CodeTabOf(i) ctx->codetab[i]
+
+
+/*
+ * To save much memory, we overlay the table used by compress() with those
+ * used by decompress(). The tab_prefix table is the same size and type
+ * as the codetab. The tab_suffix table needs 2**GIFBITS characters. We
+ * get this from the beginning of htab. The output stack uses the rest
+ * of htab, and contains characters. There is plenty of room for any
+ * possible stack (stack used to be 8000 characters).
+ */
+
+#define tab_prefixof(i) CodeTabOf(i)
+#define tab_suffixof(i) ((char_type*)(htab))[i]
+#define de_stack ((char_type*)&tab_suffixof((code_int)1 << GIFBITS))
+
+/*
+ * compress stdin to stdout
+ *
+ * Algorithm: use open addressing double hashing (no chaining) on the
+ * prefix code / next character combination. We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe. Here, the modular division first probe is gives way
+ * to a faster exclusive-or manipulation. Also do block compression with
+ * an adaptive reset, whereby the code table is cleared when the compression
+ * ratio decreases, but after the table fills. The variable-length output
+ * codes are re-sized at this point, and a special CLEAR code is generated
+ * for the decompressor. Late addition: construct the table according to
+ * file size for noticeable speed improvement on small files. Please direct
+ * questions about this implementation to ames!jaw.
+ */
+
+static void output(code_int code, GifCtx *ctx);
+
+static void compress(int init_bits, gdIOCtxPtr outfile, gdImagePtr im, GifCtx *ctx)
+{
+ register long fcode;
+ register code_int i;
+ register int c;
+ register code_int ent;
+ register code_int disp;
+ register code_int hsize_reg;
+ register int hshift;
+
+ /* Set up the globals:
+ * g_init_bits - initial number of bits
+ * g_outfile - pointer to output file */
+ ctx->g_init_bits = init_bits;
+ ctx->g_outfile = outfile;
+
+ /* Set up the necessary values */
+ ctx->offset = 0;
+ ctx->out_count = 0;
+ ctx->clear_flg = 0;
+ ctx->in_count = 1;
+ ctx->maxcode = MAXCODE(ctx->n_bits = ctx->g_init_bits);
+
+ ctx->ClearCode = (1 << (init_bits - 1));
+ ctx->EOFCode = ctx->ClearCode + 1;
+ ctx->free_ent = ctx->ClearCode + 2;
+
+ char_init(ctx);
+
+ ent = GIFNextPixel(im, ctx);
+
+ hshift = 0;
+ for(fcode = (long)hsize; fcode < 65536L; fcode *= 2L) {
+ ++hshift;
+ }
+ hshift = 8 - hshift; /* set hash code range bound */
+
+ hsize_reg = hsize;
+ cl_hash((count_int) hsize_reg, ctx); /* clear hash table */
+
+ output((code_int)ctx->ClearCode, ctx);
+
+#ifdef SIGNED_COMPARE_SLOW
+ while((c = GIFNextPixel(im)) != (unsigned) EOF) {
+#else /* SIGNED_COMPARE_SLOW */
+ while((c = GIFNextPixel(im, ctx)) != EOF) {
+#endif /* SIGNED_COMPARE_SLOW */
+
+ ++(ctx->in_count);
+
+ fcode = (long) (((long) c << maxbits) + ent);
+ i = (((code_int)c << hshift) ^ ent); /* xor hashing */
+
+ if(HashTabOf(i) == fcode) {
+ ent = CodeTabOf (i);
+ continue;
+ } else if ((long)HashTabOf (i) < 0) {/* empty slot */
+ goto nomatch;
+ }
+
+ disp = hsize_reg - i; /* secondary hash (after G. Knott) */
+
+ if(i == 0) {
+ disp = 1;
+ }
+
+probe:
+ if((i -= disp) < 0) {
+ i += hsize_reg;
+ }
+
+ if(HashTabOf(i) == fcode) {
+ ent = CodeTabOf (i);
+ continue;
+ }
+
+ if((long)HashTabOf(i) > 0) {
+ goto probe;
+ }
+
+nomatch:
+ output((code_int) ent, ctx);
+ ++(ctx->out_count);
+ ent = c;
+#ifdef SIGNED_COMPARE_SLOW
+ if((unsigned) ctx->free_ent < (unsigned) maxmaxcode) {
+#else /*SIGNED_COMPARE_SLOW*/
+ if (ctx->free_ent < maxmaxcode) { /* } */
+#endif /*SIGNED_COMPARE_SLOW*/
+ CodeTabOf(i) = ctx->free_ent++; /* code -> hashtable */
+ HashTabOf(i) = fcode;
+ } else {
+ cl_block(ctx);
+ }
+ }
+
+ /* Put out the final code. */
+ output((code_int)ent, ctx);
+ ++(ctx->out_count);
+ output((code_int) ctx->EOFCode, ctx);
+}
+
+/*****************************************************************
+ * TAG( output )
+ *
+ * Output the given code.
+ * Inputs:
+ * code: A n_bits-bit integer. If == -1, then EOF. This assumes
+ * that n_bits =< (long)wordsize - 1.
+ * Outputs:
+ * Outputs code to the file.
+ * Assumptions:
+ * Chars are 8 bits long.
+ * Algorithm:
+ * Maintain a GIFBITS character long buffer (so that 8 codes will
+ * fit in it exactly). Use the VAX insv instruction to insert each
+ * code in turn. When the buffer fills up empty it and start over.
+ */
+
+static unsigned long masks[] = {
+ 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
+ 0x001F, 0x003F, 0x007F, 0x00FF,
+ 0x01FF, 0x03FF, 0x07FF, 0x0FFF,
+ 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
+};
+
+static void output(code_int code, GifCtx *ctx)
+{
+ ctx->cur_accum &= masks[ctx->cur_bits];
+
+ if(ctx->cur_bits > 0) {
+ ctx->cur_accum |= ((long)code << ctx->cur_bits);
+ } else {
+ ctx->cur_accum = code;
+ }
+
+ ctx->cur_bits += ctx->n_bits;
+
+ while(ctx->cur_bits >= 8) {
+ char_out((unsigned int)(ctx->cur_accum & 0xff), ctx);
+ ctx->cur_accum >>= 8;
+ ctx->cur_bits -= 8;
+ }
+
+ /*
+ * If the next entry is going to be too big for the code size,
+ * then increase it, if possible.
+ */
+ if(ctx->free_ent > ctx->maxcode || ctx->clear_flg) {
+ if(ctx->clear_flg) {
+ ctx->maxcode = MAXCODE (ctx->n_bits = ctx->g_init_bits);
+ ctx->clear_flg = 0;
+ } else {
+ ++(ctx->n_bits);
+ if(ctx->n_bits == maxbits) {
+ ctx->maxcode = maxmaxcode;
+ } else {
+ ctx->maxcode = MAXCODE(ctx->n_bits);
+ }
+ }
+ }
+
+ if(code == ctx->EOFCode) {
+ /* At EOF, write the rest of the buffer. */
+ while(ctx->cur_bits > 0) {
+ char_out((unsigned int)(ctx->cur_accum & 0xff), ctx);
+ ctx->cur_accum >>= 8;
+ ctx->cur_bits -= 8;
+ }
+
+ flush_char(ctx);
+ }
+}
+
+/*
+ * Clear out the hash table
+ */
+static void cl_block (GifCtx *ctx) /* table clear for block compress */
+{
+ cl_hash((count_int) hsize, ctx);
+ ctx->free_ent = ctx->ClearCode + 2;
+ ctx->clear_flg = 1;
+
+ output((code_int)ctx->ClearCode, ctx);
+}
+
+static void cl_hash(register count_int chsize, GifCtx *ctx) /* reset code table */
+{
+ register count_int *htab_p = ctx->htab+chsize;
+ register long i;
+ register long m1 = -1;
+
+ i = chsize - 16;
+ do { /* might use Sys V memset(3) here */
+ *(htab_p - 16) = m1;
+ *(htab_p - 15) = m1;
+ *(htab_p - 14) = m1;
+ *(htab_p - 13) = m1;
+ *(htab_p - 12) = m1;
+ *(htab_p - 11) = m1;
+ *(htab_p - 10) = m1;
+ *(htab_p - 9) = m1;
+ *(htab_p - 8) = m1;
+ *(htab_p - 7) = m1;
+ *(htab_p - 6) = m1;
+ *(htab_p - 5) = m1;
+ *(htab_p - 4) = m1;
+ *(htab_p - 3) = m1;
+ *(htab_p - 2) = m1;
+ *(htab_p - 1) = m1;
+ htab_p -= 16;
+ } while((i -= 16) >= 0);
+
+ for(i += 16; i > 0; --i) {
+ *--htab_p = m1;
+ }
+}
+
+/******************************************************************************
+ *
+ * GIF Specific routines
+ *
+ ******************************************************************************/
+
+/*
+ * Set up the 'byte output' routine
+ */
+static void char_init(GifCtx *ctx)
+{
+ ctx->a_count = 0;
+}
+
+/*
+ * Add a character to the end of the current packet, and if it is 254
+ * characters, flush the packet to disk.
+ */
+static void char_out(int c, GifCtx *ctx)
+{
+ ctx->accum[ctx->a_count++] = c;
+ if(ctx->a_count >= 254) {
+ flush_char(ctx);
+ }
+}
+
+/*
+ * Flush the packet to disk, and reset the accumulator
+ */
+static void flush_char(GifCtx *ctx)
+{
+ if(ctx->a_count > 0) {
+ gdPutC(ctx->a_count, ctx->g_outfile);
+ gdPutBuf(ctx->accum, ctx->a_count, ctx->g_outfile);
+ ctx->a_count = 0;
+ }
+}
+
+static int gifPutWord(int w, gdIOCtx *out)
+{
+ /* Byte order is little-endian */
+ gdPutC(w & 0xFF, out);
+ gdPutC((w >> 8) & 0xFF, out);
+ return 0;
+}