summaryrefslogtreecommitdiff
path: root/src/gif.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/gif.c')
-rw-r--r--src/gif.c1054
1 files changed, 1054 insertions, 0 deletions
diff --git a/src/gif.c b/src/gif.c
new file mode 100644
index 00000000..9806cbb1
--- /dev/null
+++ b/src/gif.c
@@ -0,0 +1,1054 @@
+/*
+ * File: gif.c
+ *
+ * Copyright (C) 1997 Raph Levien <raph@acm.org>
+ * Copyright (C) 2000-2002 Jorge Arellano Cid <jcid@dillo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+/*
+ * The GIF decoder for dillo. It is responsible for decoding GIF data
+ * and transferring it to the dicache.
+ */
+
+
+/* Notes 13 Oct 1997 --RLL
+ *
+ * Today, just for the hell of it, I implemented a new decoder from
+ * scratch. It's oriented around pushing bytes, while the old decoder
+ * was based around reads which may suspend. There were basically
+ * three motivations.
+ *
+ * 1. To increase the speed.
+ *
+ * 2. To fix some bugs I had seen, most likely due to suspension.
+ *
+ * 3. To make sure that the code had no buffer overruns or the like.
+ *
+ * 4. So that the code could be released under a freer license.
+ *
+ * Let's see how we did on speed. I used a large image for testing
+ * (fvwm95-2.gif).
+ *
+ * The old decoder spent a total of about 1.04 seconds decoding the
+ * image. Another .58 seconds went into Image_line, almost
+ * entirely conversion from colormap to RGB.
+ *
+ * The new decoder spent a total of 0.46 seconds decoding the image.
+ * However, the time for Image_line went up to 1.01 seconds.
+ * Thus, even though the decoder seems to be about twice as fast,
+ * the net gain is pretty minimal. Could this be because of cache
+ * effects?
+ *
+ * Lessons learned: The first, which I keep learning over and over, is
+ * not to try to optimize too much. It doesn't work. Just keep things
+ * simple.
+ *
+ * Second, it seems that the colormap to RGB conversion is really a
+ * significant part of the overall time. It's possible that going
+ * directly to 16 bits would help, but that's optimization again :)
+ */
+
+
+/* todo:
+ * + Make sure to handle error cases gracefully (including aborting the
+ * connection, if necessary).
+ */
+
+#include <config.h>
+#ifdef ENABLE_GIF
+
+#include <stdio.h> /* for sprintf */
+#include <string.h> /* for memcpy and memmove */
+
+#include "msg.h"
+#include "image.hh"
+#include "web.hh"
+#include "cache.h"
+#include "dicache.h"
+#include "prefs.h"
+
+#define DEBUG_LEVEL 6
+#include "debug.h"
+
+#define INTERLACE 0x40
+#define LOCALCOLORMAP 0x80
+
+#define LM_to_uint(a,b) ((((uchar_t)b)<<8)|((uchar_t)a))
+
+#define MAXCOLORMAPSIZE 256
+#define MAX_LWZ_BITS 12
+
+
+typedef struct _DilloGif {
+ DilloImage *Image;
+ DilloUrl *url;
+ int version;
+
+ int state;
+ size_t Start_Ofs;
+ uint_t Flags;
+
+ uchar_t input_code_size;
+ uchar_t *linebuf;
+ int pass;
+
+ uint_t y;
+
+ /* state for lwz_read_byte */
+ int code_size;
+
+ /* The original GifScreen from giftopnm */
+ uint_t Width;
+ uint_t Height;
+ size_t ColorMap_ofs;
+ uint_t ColorResolution;
+ uint_t NumColors;
+ int Background;
+ uint_t spill_line_index;
+#if 0
+ uint_t AspectRatio; /* AspectRatio (not used) */
+#endif
+
+ /* Gif89 extensions */
+ int transparent;
+#if 0
+ /* None are used: */
+ int delayTime;
+ int inputFlag;
+ int disposal;
+#endif
+
+ /* state for the new push-oriented decoder */
+ int packet_size; /* The amount of the data block left to process */
+ uint_t window;
+ int bits_in_window;
+ uint_t last_code; /* Last "compressed" code in the look up table */
+ uint_t line_index;
+ uchar_t **spill_lines;
+ int num_spill_lines_max;
+ int length[(1 << MAX_LWZ_BITS) + 1];
+ int code_and_byte[(1 << MAX_LWZ_BITS) + 1];
+} DilloGif;
+
+/* Some invariants:
+ *
+ * last_code <= code_mask
+ *
+ * code_and_byte is stored packed: (code << 8) | byte
+ */
+
+
+/*
+ * Forward declarations
+ */
+static void Gif_write(DilloGif *gif, void *Buf, uint_t BufSize);
+static void Gif_close(DilloGif *gif, CacheClient_t *Client);
+static size_t Gif_process_bytes(DilloGif *gif, const uchar_t *buf,
+ int bufsize, void *Buf);
+static DilloGif *Gif_new(DilloImage *Image, DilloUrl *url, int version);
+static void Gif_callback(int Op, CacheClient_t *Client);
+
+/* exported function */
+void *a_Gif_image(const char *Type, void *Ptr, CA_Callback_t *Call,
+ void **Data);
+
+
+/*
+ * MIME handler for "image/gif" type
+ * (Sets Gif_callback as cache-client)
+ */
+void *a_Gif_image(const char *Type, void *Ptr, CA_Callback_t *Call,
+ void **Data)
+{
+ DilloWeb *web = Ptr;
+ DICacheEntry *DicEntry;
+
+ if (!web->Image)
+ web->Image = a_Image_new(0, 0, NULL, prefs.bg_color);
+ /* todo: get the backgound color from the parent widget -- Livio. */
+
+ /* Add an extra reference to the Image (for dicache usage) */
+ a_Image_ref(web->Image);
+
+ DicEntry = a_Dicache_get_entry(web->url);
+ if (!DicEntry) {
+ /* Let's create an entry for this image... */
+ DicEntry = a_Dicache_add_entry(web->url);
+
+ /* ... and let the decoder feed it! */
+ *Data = Gif_new(web->Image, DicEntry->url, DicEntry->version);
+ *Call = (CA_Callback_t) Gif_callback;
+ } else {
+ /* Let's feed our client from the dicache */
+ a_Dicache_ref(DicEntry->url, DicEntry->version);
+ *Data = web->Image;
+ *Call = (CA_Callback_t) a_Dicache_callback;
+ }
+ return (web->Image->dw);
+}
+
+/*
+ * Create a new gif structure for decoding a gif into a RGB buffer
+ */
+static DilloGif *Gif_new(DilloImage *Image, DilloUrl *url, int version)
+{
+ DilloGif *gif = dMalloc(sizeof(DilloGif));
+
+ gif->Image = Image;
+ gif->url = url;
+ gif->version = version;
+
+ gif->Flags = 0;
+ gif->state = 0;
+ gif->Start_Ofs = 0;
+ gif->linebuf = NULL;
+ gif->Background = -1;
+ gif->transparent = -1;
+ gif->num_spill_lines_max = 0;
+ gif->spill_lines = NULL;
+ gif->window = 0;
+ gif->packet_size = 0;
+ gif->ColorMap_ofs = 0;
+
+ return gif;
+}
+
+/*
+ * This function is a cache client, it receives data from the cache
+ * and dispatches it to the appropriate gif-processing functions
+ */
+static void Gif_callback(int Op, CacheClient_t *Client)
+{
+ if (Op)
+ Gif_close(Client->CbData, Client);
+ else
+ Gif_write(Client->CbData, Client->Buf, Client->BufSize);
+}
+
+/*
+ * Receive and process new chunks of GIF image data
+ */
+static void Gif_write(DilloGif *gif, void *Buf, uint_t BufSize)
+{
+ uchar_t *buf;
+ int bufsize, bytes_consumed;
+
+ /* Sanity checks */
+ if (!Buf || !gif->Image || BufSize == 0)
+ return;
+
+ buf = ((uchar_t *) Buf) + gif->Start_Ofs;
+ bufsize = BufSize - gif->Start_Ofs;
+
+ DEBUG_MSG(5, "Gif_write: %u bytes\n", BufSize);
+
+ /* Process the bytes in the input buffer. */
+ bytes_consumed = Gif_process_bytes(gif, buf, bufsize, Buf);
+
+ if (bytes_consumed < 1)
+ return;
+ gif->Start_Ofs += bytes_consumed;
+
+ DEBUG_MSG(5, "exit Gif_write, bufsize=%ld\n", (long)bufsize);
+}
+
+/*
+ * Finish the decoding process (and free the memory)
+ */
+static void Gif_close(DilloGif *gif, CacheClient_t *Client)
+{
+ int i;
+
+ DEBUG_MSG(5, "destroy gif %p\n", gif);
+
+ a_Dicache_close(gif->url, gif->version, Client);
+
+ dFree(gif->linebuf);
+
+ if (gif->spill_lines != NULL) {
+ for (i = 0; i < gif->num_spill_lines_max; i++)
+ dFree(gif->spill_lines[i]);
+ dFree(gif->spill_lines);
+ }
+ dFree(gif);
+}
+
+
+/* --- GIF Extensions ----------------------------------------------------- */
+
+/*
+ * This reads a sequence of GIF data blocks.. and ignores them!
+ * Buf points to the first data block.
+ *
+ * Return Value
+ * 0 = There wasn't enough bytes read yet to read the whole datablock
+ * otherwise the size of the data blocks
+ */
+static inline size_t Gif_data_blocks(const uchar_t *Buf, size_t BSize)
+{
+ size_t Size = 0;
+
+ if (BSize < 1)
+ return 0;
+ while (Buf[0]) {
+ if (BSize <= (size_t)(Buf[0] + 1))
+ return 0;
+ Size += Buf[0] + 1;
+ BSize -= Buf[0] + 1;
+ Buf += Buf[0] + 1;
+ }
+ return Size + 1;
+}
+
+/*
+ * This is a GIF extension. We ignore it with this routine.
+ * Buffer points to just after the extension label.
+ *
+ * Return Value
+ * 0 -- block not processed
+ * otherwise the size of the extension label.
+ */
+static inline size_t Gif_do_generic_ext(const uchar_t *Buf, size_t BSize)
+{
+ size_t Size = Buf[0] + 1, DSize;
+
+ /* The Block size (the first byte) is supposed to be a specific size
+ * for each extension... we don't check.
+ */
+
+ if (Buf[0] > BSize)
+ return 0;
+ DSize = Gif_data_blocks(Buf + Size, BSize - Size);
+ if (!DSize)
+ return 0;
+ Size += DSize;
+ return Size <= BSize ? Size : 0;
+}
+
+/*
+ * ?
+ */
+static inline size_t
+ Gif_do_gc_ext(DilloGif *gif, const uchar_t *Buf, size_t BSize)
+{
+ /* Graphic Control Extension */
+ size_t Size = Buf[0] + 2;
+ uint_t Flags;
+
+ if (Size > BSize)
+ return 0;
+ Buf++;
+ Flags = Buf[0];
+
+ /* The packed fields */
+#if 0
+ gif->disposal = (Buf[0] >> 2) & 0x7;
+ gif->inputFlag = (Buf[0] >> 1) & 0x1;
+
+ /* Delay time */
+ gif->delayTime = LM_to_uint(Buf[1], Buf[2]);
+#endif
+
+ /* Transparent color index, may not be valid (unless flag is set) */
+ if ((Flags & 0x1)) {
+ gif->transparent = Buf[3];
+ }
+ return Size;
+}
+
+#define App_Ext (0xff)
+#define Cmt_Ext (0xfe)
+#define GC_Ext (0xf9)
+#define Txt_Ext (0x01)
+
+/*
+ * ?
+ * Return value:
+ * TRUE when the extension is over
+ */
+static size_t Gif_do_extension(DilloGif *gif, uint_t Label,
+ const uchar_t *buf,
+ size_t BSize)
+{
+ switch (Label) {
+ case GC_Ext: /* Graphics extension */
+ return Gif_do_gc_ext(gif, buf, BSize);
+
+ case Cmt_Ext: /* Comment extension */
+ return Gif_data_blocks(buf, BSize);
+
+ case Txt_Ext: /* Plain text Extension */
+ /* This extension allows (rcm thinks) the image to be rendered as text.
+ */
+ case App_Ext: /* Application Extension */
+ default:
+ return Gif_do_generic_ext(buf, BSize); /*Ignore Extension */
+ }
+}
+
+/* --- General Image Decoder ----------------------------------------------- */
+/* Here begins the new push-oriented decoder. */
+
+/*
+ * ?
+ */
+static void Gif_lwz_init(DilloGif *gif)
+{
+ gif->num_spill_lines_max = 1;
+ gif->spill_lines = dMalloc(sizeof(uchar_t *) * gif->num_spill_lines_max);
+
+ gif->spill_lines[0] = dMalloc(gif->Width);
+ gif->bits_in_window = 0;
+
+ /* First code in table = clear_code +1
+ * Last code in table = first code in table
+ * clear_code = (1<< input code size)
+ */
+ gif->last_code = (1 << gif->input_code_size) + 1;
+ memset(gif->code_and_byte, 0,
+ (1 + gif->last_code) * sizeof(gif->code_and_byte[0]));
+ gif->code_size = gif->input_code_size + 1;
+ gif->line_index = 0;
+}
+
+/*
+ * Send the image line to the dicache, also handling the interlacing.
+ */
+static void Gif_emit_line(DilloGif *gif, const uchar_t *linebuf)
+{
+ a_Dicache_write(gif->Image, gif->url, gif->version, linebuf, 0, gif->y);
+ if (gif->Flags & INTERLACE) {
+ switch (gif->pass) {
+ case 0:
+ case 1:
+ gif->y += 8;
+ break;
+ case 2:
+ gif->y += 4;
+ break;
+ case 3:
+ gif->y += 2;
+ break;
+ }
+ if (gif->y >= gif->Height) {
+ gif->pass++;
+ switch (gif->pass) {
+ case 1:
+ gif->y = 4;
+ break;
+ case 2:
+ gif->y = 2;
+ break;
+ case 3:
+ gif->y = 1;
+ break;
+ default:
+ /* arriving here is an error in the input image. */
+ gif->y = 0;
+ break;
+ }
+ }
+ } else {
+ if (gif->y < gif->Height)
+ gif->y++;
+ }
+}
+
+/*
+ * I apologize for the large size of this routine and the goto error
+ * construct - I almost _never_ do that. I offer the excuse of
+ * optimizing for speed.
+ *
+ * RCM -- busted these down into smaller subroutines... still very hard to
+ * read.
+ */
+
+
+/*
+ * Decode the packetized lwz bytes
+ */
+static void Gif_literal(DilloGif *gif, uint_t code)
+{
+ gif->linebuf[gif->line_index++] = code;
+ if (gif->line_index >= gif->Width) {
+ Gif_emit_line(gif, gif->linebuf);
+ gif->line_index = 0;
+ }
+ gif->length[gif->last_code + 1] = 2;
+ gif->code_and_byte[gif->last_code + 1] = (code << 8);
+ gif->code_and_byte[gif->last_code] |= code;
+}
+
+/*
+ * ?
+ */
+/* Profiling reveals over half the GIF time is spent here: */
+static void Gif_sequence(DilloGif *gif, uint_t code)
+{
+ uint_t o_index, o_size, orig_code;
+ uint_t sequence_length = gif->length[code];
+ uint_t line_index = gif->line_index;
+ int num_spill_lines;
+ int spill_line_index = gif->spill_line_index;
+ uchar_t *last_byte_ptr, *obuf;
+
+ gif->length[gif->last_code + 1] = sequence_length + 1;
+ gif->code_and_byte[gif->last_code + 1] = (code << 8);
+
+ /* We're going to traverse the sequence backwards. Thus,
+ * we need to allocate spill lines if the sequence won't
+ * fit entirely within the present scan line. */
+ if (line_index + sequence_length <= gif->Width) {
+ num_spill_lines = 0;
+ obuf = gif->linebuf;
+ o_index = line_index + sequence_length;
+ o_size = sequence_length - 1;
+ } else {
+ num_spill_lines = (line_index + sequence_length - 1) /
+ gif->Width;
+ o_index = (line_index + sequence_length - 1) % gif->Width + 1;
+ if (num_spill_lines > gif->num_spill_lines_max) {
+ /* Allocate more spill lines. */
+ spill_line_index = gif->num_spill_lines_max;
+ gif->num_spill_lines_max = num_spill_lines << 1;
+ gif->spill_lines = dRealloc(gif->spill_lines,
+ gif->num_spill_lines_max *
+ sizeof(uchar_t *));
+
+ for (; spill_line_index < gif->num_spill_lines_max;
+ spill_line_index++)
+ gif->spill_lines[spill_line_index] =
+ dMalloc(gif->Width);
+ }
+ spill_line_index = num_spill_lines - 1;
+ obuf = gif->spill_lines[spill_line_index];
+ o_size = o_index;
+ }
+ gif->line_index = o_index; /* for afterwards */
+
+ /* for fixing up later if last_code == code */
+ orig_code = code;
+ last_byte_ptr = obuf + o_index - 1;
+
+ /* spill lines are allocated, and we are clear to
+ * write. This loop does not write the first byte of
+ * the sequence, however (last byte traversed). */
+ while (sequence_length > 1) {
+ sequence_length -= o_size;
+ /* Write o_size bytes to
+ * obuf[o_index - o_size..o_index). */
+ for (; o_size > 0 && o_index > 0; o_size--) {
+ uint_t code_and_byte = gif->code_and_byte[code];
+
+ DEBUG_MSG(5, "%d ", gif->code_and_byte[code] & 255);
+
+ obuf[--o_index] = code_and_byte & 255;
+ code = code_and_byte >> 8;
+ }
+ /* Prepare for writing to next line. */
+ if (o_index == 0) {
+ if (spill_line_index > 0) {
+ spill_line_index--;
+ obuf = gif->spill_lines[spill_line_index];
+ o_size = gif->Width;
+ } else {
+ obuf = gif->linebuf;
+ o_size = sequence_length - 1;
+ }
+ o_index = gif->Width;
+ }
+ }
+ /* Ok, now we write the first byte of the sequence. */
+ /* We are sure that the code is literal. */
+ DEBUG_MSG(5, "%d", code);
+ obuf[--o_index] = code;
+ gif->code_and_byte[gif->last_code] |= code;
+
+ /* Fix up the output if the original code was last_code. */
+ if (orig_code == gif->last_code) {
+ *last_byte_ptr = code;
+ DEBUG_MSG(5, " fixed (%d)!", code);
+ }
+ DEBUG_MSG(5, "\n");
+
+ /* Output any full lines. */
+ if (gif->line_index >= gif->Width) {
+ Gif_emit_line(gif, gif->linebuf);
+ gif->line_index = 0;
+ }
+ if (num_spill_lines) {
+ if (gif->line_index)
+ Gif_emit_line(gif, gif->linebuf);
+ for (spill_line_index = 0;
+ spill_line_index < num_spill_lines - (gif->line_index ? 1 : 0);
+ spill_line_index++)
+ Gif_emit_line(gif, gif->spill_lines[spill_line_index]);
+ }
+ if (num_spill_lines) {
+ /* Swap the last spill line with the gif line, using
+ * linebuf as the swap temporary. */
+ uchar_t *linebuf = gif->spill_lines[num_spill_lines - 1];
+
+ gif->spill_lines[num_spill_lines - 1] = gif->linebuf;
+ gif->linebuf = linebuf;
+ }
+ gif->spill_line_index = spill_line_index;
+}
+
+/*
+ * ?
+ *
+ * Return Value:
+ * 2 -- quit
+ * 1 -- new last code needs to be done
+ * 0 -- okay, but reset the code table
+ * < 0 on error
+ * -1 if the decompression code was not in the lookup table
+ */
+static int Gif_process_code(DilloGif *gif, uint_t code, uint_t clear_code)
+{
+
+ /* A short table describing what to do with the code:
+ * code < clear_code : This is uncompressed, raw data
+ * code== clear_code : Reset the decompression table
+ * code== clear_code+1: End of data stream
+ * code > clear_code+1: Compressed code; look up in table
+ */
+ if (code < clear_code) {
+ /* a literal code. */
+ DEBUG_MSG(5, "literal\n");
+ Gif_literal(gif, code);
+ return 1;
+ } else if (code >= clear_code + 2) {
+ /* a sequence code. */
+ if (code > gif->last_code)
+ return -1;
+ Gif_sequence(gif, code);
+ return 1;
+ } else if (code == clear_code) {
+ /* clear code. Resets the whole table */
+ DEBUG_MSG(5, "clear\n");
+ return 0;
+ } else {
+ /* end code. */
+ DEBUG_MSG(5, "end\n");
+ return 2;
+ }
+}
+
+/*
+ * ?
+ */
+static int Gif_decode(DilloGif *gif, const uchar_t *buf, size_t bsize)
+{
+ /*
+ * Data block processing. The image stuff is a series of data blocks.
+ * Each data block is 1 to 256 bytes long. The first byte is the length
+ * of the data block. 0 == the last data block.
+ */
+ size_t bufsize, packet_size;
+ uint_t clear_code;
+ uint_t window;
+ int bits_in_window;
+ uint_t code;
+ int code_size;
+ uint_t code_mask;
+
+ bufsize = bsize;
+
+ /* Want to get all inner loop state into local variables. */
+ packet_size = gif->packet_size;
+ window = gif->window;
+ bits_in_window = gif->bits_in_window;
+ code_size = gif->code_size;
+ code_mask = (1 << code_size) - 1;
+ clear_code = 1 << gif->input_code_size;
+
+ /* If packet size == 0, we are at the start of a data block.
+ * The first byte of the data block indicates how big it is (0 == last
+ * datablock)
+ * packet size is set to this size; it indicates how much of the data block
+ * we have left to process.
+ */
+ while (bufsize > 0) {
+ /* lwz_bytes is the number of remaining lwz bytes in the packet. */
+ int lwz_bytes = MIN(packet_size, bufsize);
+
+ bufsize -= lwz_bytes;
+ packet_size -= lwz_bytes;
+ for (; lwz_bytes > 0; lwz_bytes--) {
+ /* printf ("%d ", *buf) would print the depacketized lwz stream. */
+
+ /* Push the byte onto the "end" of the window (MSB). The low order
+ * bits always come first in the LZW stream. */
+ window = (window >> 8) | (*buf++ << 24);
+ bits_in_window += 8;
+
+ while (bits_in_window >= code_size) {
+ /* Extract the code. The code is code_size (3 to 12) bits long,
+ * at the start of the window */
+ code = (window >> (32 - bits_in_window)) & code_mask;
+
+ DEBUG_MSG(5, "code = %d, ", code);
+
+ bits_in_window -= code_size;
+ switch (Gif_process_code(gif, code, clear_code)) {
+ case 1: /* Increment last code */
+ gif->last_code++;
+ /*gif->code_and_byte[gif->last_code+1]=0; */
+
+ if ((gif->last_code & code_mask) == 0) {
+ if (gif->last_code == (1 << MAX_LWZ_BITS))
+ gif->last_code--;
+ else {
+ code_size++;
+ code_mask = (1 << code_size) - 1;
+ }
+ }
+ break;
+
+ case 0: /* Reset codes size and mask */
+ gif->last_code = clear_code + 1;
+ code_size = gif->input_code_size + 1;
+ code_mask = (1 << code_size) - 1;
+ break;
+
+ case 2: /* End code... consume remaining data chunks..? */
+ goto error; /* Could clean up better? */
+ default:
+ printf("dillo_gif_decode: error!\n");
+ goto error;
+ }
+ }
+ }
+
+ /* We reach here if
+ * a) We have reached the end of the data block;
+ * b) we ran out of data before reaching the end of the data block
+ */
+ if (bufsize <= 0)
+ break; /* We are out of data; */
+
+ /* Start of new data block */
+ bufsize--;
+ if (!(packet_size = *buf++)) {
+ /* This is the "block terminator" -- the last data block */
+ gif->state = 999; /* BUG: should Go back to getting GIF blocks. */
+ break;
+ }
+ }
+
+ gif->packet_size = packet_size;
+ gif->window = window;
+ gif->bits_in_window = bits_in_window;
+ gif->code_size = code_size;
+ return bsize - bufsize;
+
+ error:
+ gif->state = 999;
+ return bsize - bufsize;
+}
+
+/*
+ * ?
+ */
+static int Gif_check_sig(DilloGif *gif, const uchar_t *ibuf, int ibsize)
+{
+ /* at beginning of file - read magic number */
+ if (ibsize < 6)
+ return 0;
+ if (memcmp(ibuf, "GIF", 3) != 0) {
+ gif->state = 999;
+ return 6;
+ }
+ if (memcmp(ibuf + 3, "87a", 3) != 0 &&
+ memcmp(ibuf + 3, "89a", 3) != 0) {
+ gif->state = 999;
+ return 6;
+ }
+ gif->state = 1;
+ return 6;
+}
+
+/* Read the color map
+ *
+ * Implements, from the spec:
+ * Global Color Table
+ * Local Color Table
+ */
+static inline size_t
+ Gif_do_color_table(DilloGif *gif, void *Buf,
+ const uchar_t *buf, size_t bsize, size_t CT_Size)
+{
+ size_t Size = 3 * (1 << (1 + CT_Size));
+
+ if (Size > bsize)
+ return 0;
+
+ gif->ColorMap_ofs = (ulong_t) buf - (ulong_t) Buf;
+ gif->NumColors = (1 << (1 + CT_Size));
+ return Size;
+}
+
+/*
+ * This implements, from the spec:
+ * <Logical Screen> ::= Logical Screen Descriptor [Global Color Table]
+ */
+static size_t Gif_get_descriptor(DilloGif *gif, void *Buf,
+ const uchar_t *buf, int bsize)
+{
+
+ /* screen descriptor */
+ size_t Size = 7, /* Size of descriptor */
+ mysize; /* Size of color table */
+ uchar_t Flags;
+
+ if (bsize < 7)
+ return 0;
+ Flags = buf[4];
+
+ if (Flags & LOCALCOLORMAP) {
+ mysize = Gif_do_color_table(
+ gif, Buf, buf + 7, (size_t)bsize - 7, Flags & (size_t)0x7);
+ if (!mysize)
+ return 0;
+ Size += mysize; /* Size of the color table that follows */
+ gif->Background = buf[5];
+ }
+ /* gif->Width = LM_to_uint(buf[0], buf[1]);
+ gif->Height = LM_to_uint(buf[2], buf[3]); */
+ gif->ColorResolution = (((buf[4] & 0x70) >> 3) + 1);
+ /* gif->AspectRatio = buf[6]; */
+
+ return Size;
+}
+
+/*
+ * This implements, from the spec:
+ * <Table-Based Image> ::= Image Descriptor [Local Color Table] Image Data
+ *
+ * ('Buf' points to just after the Image separator)
+ * we should probably just check that the local stuff is consistent
+ * with the stuff at the header. For now, we punt...
+ */
+static size_t Gif_do_img_desc(DilloGif *gif, void *Buf,
+ const uchar_t *buf, size_t bsize)
+{
+ uchar_t Flags;
+ size_t Size = 9 + 1; /* image descriptor size + first byte of image data */
+
+ if (bsize < 10)
+ return 0;
+
+ gif->Width = LM_to_uint(buf[4], buf[5]);
+ gif->Height = LM_to_uint(buf[6], buf[7]);
+ gif->linebuf = dMalloc(gif->Width);
+
+ a_Dicache_set_parms(gif->url, gif->version, gif->Image,
+ gif->Width, gif->Height, DILLO_IMG_TYPE_INDEXED);
+
+ Flags = buf[8];
+
+ gif->Flags |= Flags & INTERLACE;
+ gif->pass = 0;
+ bsize -= 9;
+ buf += 9;
+ if (Flags & LOCALCOLORMAP) {
+ size_t LSize = Gif_do_color_table(
+ gif, Buf, buf, bsize, Flags & (size_t)0x7);
+
+ if (!LSize)
+ return 0;
+ Size += LSize;
+ buf += LSize;
+ bsize -= LSize;
+ }
+ /* Finally, get the first byte of the LZW image data */
+ if (bsize < 1)
+ return 0;
+ gif->input_code_size = *buf++;
+ if (gif->input_code_size > 8) {
+ gif->state = 999;
+ return Size;
+ }
+ gif->y = 0;
+ Gif_lwz_init(gif);
+ gif->spill_line_index = 0;
+ gif->state = 3; /*Process the lzw data next */
+ if (gif->Image && gif->ColorMap_ofs) {
+ a_Dicache_set_cmap(gif->url, gif->version, gif->Image,
+ (uchar_t *) Buf + gif->ColorMap_ofs,
+ gif->NumColors, 256, gif->transparent);
+ }
+ return Size;
+}
+
+/* --- Top level data block processors ------------------------------------ */
+#define Img_Desc (0x2c)
+#define Trailer (0x3B)
+#define Ext_Id (0x21)
+
+/*
+ * This identifies which kind of GIF blocks are next, and processes them.
+ * It returns if there isn't enough data to process the next blocks, or if
+ * the next block is the lzw data (which is streamed differently)
+ *
+ * This implements, from the spec, <Data>* Trailer
+ * <Data> ::= <Graphic Block> | <Special-Purpose Block>
+ * <Special-Purpose Block> ::= Application Extension | Comment Extension
+ * <Graphic Block> ::= [Graphic Control Extension] <Graphic-Rendering Block>
+ * <Graphic-Rendering Block> ::= <Table-Based Image> | Plain Text Extension
+ *
+ * <Data>* --> GIF_Block
+ * <Data> --> while (...)
+ * <Special-Purpose Block> --> Gif_do_extension
+ * Graphic Control Extension --> Gif_do_extension
+ * Plain Text Extension --> Gif_do_extension
+ * <Table-Based Image> --> Gif_do_img_desc
+ *
+ * Return Value
+ * 0 if not enough data is present, otherwise the number of bytes
+ * "consumed"
+ */
+static size_t GIF_Block(DilloGif * gif, void *Buf,
+ const uchar_t *buf, size_t bsize)
+{
+ size_t Size = 0, mysize;
+ uchar_t C;
+
+ if (bsize < 1)
+ return 0;
+ while (gif->state == 2) {
+ if (bsize < 1)
+ return Size;
+ bsize--;
+ switch (*buf++) {
+ case Ext_Id:
+ /* get the extension type */
+ if (bsize < 2)
+ return Size;
+
+ /* Have the extension block intepreted. */
+ C = *buf++;
+ bsize--;
+ mysize = Gif_do_extension(gif, C, buf, bsize);
+
+ if (!mysize)
+ /* Not all of the extension is there.. quit until more data
+ * arrives */
+ return Size;
+
+ bsize -= mysize;
+ buf += mysize;
+
+ /* Increment the amount consumed by the extension introducer
+ * and id, and extension block size */
+ Size += mysize + 2;
+ /* Do more GIF Blocks */
+ continue;
+
+ case Img_Desc: /* Image descriptor */
+ mysize = Gif_do_img_desc(gif, Buf, buf, bsize);
+ if (!mysize)
+ return Size;
+
+ /* Increment the amount consumed by the Image Separator and the
+ * Resultant blocks */
+ Size += 1 + mysize;
+ return Size;
+
+ case Trailer:
+ gif->state = 999; /* BUG: should close the rest of the file */
+ return Size + 1;
+ break; /* GIF terminator */
+
+ default: /* Unknown */
+ /* gripe and complain */
+ MSG ("gif.c::GIF_Block: Error, 0x%x found\n", *(buf-1));
+ gif->state = 999;
+ return Size + 1;
+ }
+ }
+ return Size;
+}
+
+
+/*
+ * Process some bytes from the input gif stream. It's a state machine.
+ *
+ * From the GIF spec:
+ * <GIF Data Stream> ::= Header <Logical Screen> <Data>* Trailer
+ *
+ * <GIF Data Stream> --> Gif_process_bytes
+ * Header --> State 0
+ * <Logical Screen> --> State 1
+ * <Data>* --> State 2
+ * Trailer --> State > 3
+ *
+ * State == 3 is special... this is inside of <Data> but all of the stuff in
+ * there has been gotten and set up. So we stream it outside.
+ */
+static size_t Gif_process_bytes(DilloGif *gif, const uchar_t *ibuf,
+ int bufsize, void *Buf)
+{
+ int tmp_bufsize = bufsize;
+ size_t mysize;
+
+ switch (gif->state) {
+ case 0:
+ mysize = Gif_check_sig(gif, ibuf, tmp_bufsize);
+ if (!mysize)
+ break;
+ tmp_bufsize -= mysize;
+ ibuf += mysize;
+ if (gif->state != 1)
+ break;
+
+ case 1:
+ mysize = Gif_get_descriptor(gif, Buf, ibuf, tmp_bufsize);
+ if (!mysize)
+ break;
+ tmp_bufsize -= mysize;
+ ibuf += mysize;
+ gif->state = 2;
+
+ case 2:
+ /* Ok, this loop construction looks weird. It implements the <Data>* of
+ * the GIF grammar. All sorts of stuff is allocated to set up for the
+ * decode part (state ==2) and then there is the actual decode part (3)
+ */
+ mysize = GIF_Block(gif, Buf, ibuf, (size_t)tmp_bufsize);
+ if (!mysize)
+ break;
+ tmp_bufsize -= mysize;
+ ibuf += mysize;
+ if (gif->state != 3)
+ break;
+
+ case 3:
+ /* get an image byte */
+ /* The users sees all of this stuff */
+ mysize = Gif_decode(gif, ibuf, (size_t)tmp_bufsize);
+ if (mysize == 0)
+ break;
+ ibuf += mysize;
+ tmp_bufsize -= mysize;
+
+ default:
+ /* error - just consume all input */
+ tmp_bufsize = 0;
+ break;
+ }
+
+ DEBUG_MSG(5, "Gif_process_bytes: final state %d, %ld bytes consumed\n",
+ gif->state, (long)(bufsize - tmp_bufsize));
+
+ return bufsize - tmp_bufsize;
+}
+
+#endif /* ENABLE_GIF */