change gif demuxer to gif decoder

Originally committed as revision 6760 to svn://svn.ffmpeg.org/ffmpeg/trunk

Changelog

@@ -64,6 +64,7 @@ version <next>
 - Tiertex .seq demuxer/video decoder
 - MTV demuxer
 - TIFF picture decoder
+- GIF picture decoder
 
 version 0.4.9-pre1:
 

MAINTAINERS

@@ -121,6 +121,7 @@ Codecs:
   flashsv.c                             Benjamin Larsson
   flicvideo.c                           Mike Melanson
   g726.c                                Roman Shaposhnik
+  gifdec.c                              Baptiste Coudurier
   h264*                                 Loren Merritt, Michael Niedermayer
   h261*                                 Michael Niedermayer
   h263*                                 Michael Niedermayer

libavcodec/Makefile

@@ -84,6 +84,7 @@ OBJS-$(CONFIG_FLASHSV_DECODER)         += flashsv.o
 OBJS-$(CONFIG_FLIC_DECODER)            += flicvideo.o
 OBJS-$(CONFIG_FOURXM_DECODER)          += 4xm.o
 OBJS-$(CONFIG_FRAPS_DECODER)           += fraps.o
+OBJS-$(CONFIG_GIF_DECODER)             += gifdec.o
 OBJS-$(CONFIG_H261_DECODER)            += h261.o
 OBJS-$(CONFIG_H261_ENCODER)            += h261.o
 OBJS-$(CONFIG_H264_DECODER)            += h264.o

libavcodec/allcodecs.c

@@ -193,6 +193,9 @@ void avcodec_register_all(void)
 #endif //CONFIG_RAWVIDEO_ENCODER
 
     /* decoders */
+#ifdef CONFIG_GIF_DECODER
+    register_avcodec(&gif_decoder);
+#endif
 #ifdef CONFIG_H263_DECODER
     register_avcodec(&h263_decoder);
 #endif //CONFIG_H263_DECODER

libavcodec/avcodec.h

@@ -37,8 +37,8 @@ extern "C" {
 #define AV_STRINGIFY(s)         AV_TOSTRING(s)
 #define AV_TOSTRING(s) #s
 
-#define LIBAVCODEC_VERSION_INT  ((51<<16)+(20<<8)+0)
+#define LIBAVCODEC_VERSION_INT  ((51<<16)+(21<<8)+0)
-#define LIBAVCODEC_VERSION      51.20.0
+#define LIBAVCODEC_VERSION      51.21.0
 #define LIBAVCODEC_BUILD        LIBAVCODEC_VERSION_INT
 
 #define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
@@ -148,6 +148,7 @@ enum CodecID {
     CODEC_ID_DSICINVIDEO,
     CODEC_ID_TIERTEXSEQVIDEO,
     CODEC_ID_TIFF,
+    CODEC_ID_GIF,
 
     /* various pcm "codecs" */
     CODEC_ID_PCM_S16LE= 0x10000,
@@ -2177,6 +2178,7 @@ extern AVCodec sonic_ls_encoder;
 extern AVCodec svq1_encoder;
 extern AVCodec x264_encoder;
 
+extern AVCodec gif_decoder;
 extern AVCodec h263_decoder;
 extern AVCodec h261_decoder;
 extern AVCodec mpeg4_decoder;

libavcodec/bytestream.h

@@ -0,0 +1,50 @@
+/*
+ * Bytestream functions
+ * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef FFMPEG_BYTESTREAM_H
+#define FFMPEG_BYTESTREAM_H
+
+static always_inline unsigned int bytestream_get_le32(uint8_t **b)
+{
+    (*b) += 4;
+    return LE_32(*b - 4);
+}
+
+static always_inline unsigned int bytestream_get_le16(uint8_t **b)
+{
+    (*b) += 2;
+    return LE_16(*b - 2);
+}
+
+static always_inline unsigned int bytestream_get_byte(uint8_t **b)
+{
+    (*b)++;
+    return (*b)[-1];
+}
+
+static always_inline unsigned int bytestream_get_buffer(uint8_t **b, uint8_t *dst, unsigned int size)
+{
+    memcpy(dst, *b, size);
+    (*b) += size;
+    return size;
+}
+
+#endif /* FFMPEG_BYTESTREAM_H */

libavcodec/gifdec.c

@@ -0,0 +1,495 @@
+/*
+ * GIF decoder
+ * Copyright (c) 2003 Fabrice Bellard.
+ * Copyright (c) 2006 Baptiste Coudurier.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+//#define DEBUG
+
+#include "avcodec.h"
+#include "bytestream.h"
+
+#define MAXBITS                 12
+#define         SIZTABLE        (1<<MAXBITS)
+
+#define GCE_DISPOSAL_NONE       0
+#define GCE_DISPOSAL_INPLACE    1
+#define GCE_DISPOSAL_BACKGROUND 2
+#define GCE_DISPOSAL_RESTORE    3
+
+typedef struct GifState {
+    int screen_width;
+    int screen_height;
+    int bits_per_pixel;
+    int background_color_index;
+    int transparent_color_index;
+    int color_resolution;
+    uint8_t *image_buf;
+    int image_linesize;
+    uint32_t image_palette[256];
+    int pix_fmt;
+
+    /* after the frame is displayed, the disposal method is used */
+    int gce_disposal;
+    /* delay during which the frame is shown */
+    int gce_delay;
+
+    /* LZW compatible decoder */
+    uint8_t *bytestream;
+    int eob_reached;
+    uint8_t *pbuf, *ebuf;
+    int bbits;
+    unsigned int bbuf;
+
+    int cursize;                /* The current code size */
+    int curmask;
+    int codesize;
+    int clear_code;
+    int end_code;
+    int newcodes;               /* First available code */
+    int top_slot;               /* Highest code for current size */
+    int slot;                   /* Last read code */
+    int fc, oc;
+    uint8_t *sp;
+    uint8_t stack[SIZTABLE];
+    uint8_t suffix[SIZTABLE];
+    uint16_t prefix[SIZTABLE];
+
+    /* aux buffers */
+    uint8_t global_palette[256 * 3];
+    uint8_t local_palette[256 * 3];
+    uint8_t buf[256];
+} GifState;
+
+static const uint8_t gif87a_sig[6] = "GIF87a";
+static const uint8_t gif89a_sig[6] = "GIF89a";
+
+static const uint16_t mask[17] =
+{
+    0x0000, 0x0001, 0x0003, 0x0007,
+    0x000F, 0x001F, 0x003F, 0x007F,
+    0x00FF, 0x01FF, 0x03FF, 0x07FF,
+    0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
+};
+
+static void GLZWDecodeInit(GifState * s, int csize)
+{
+    /* read buffer */
+    s->eob_reached = 0;
+    s->pbuf = s->buf;
+    s->ebuf = s->buf;
+    s->bbuf = 0;
+    s->bbits = 0;
+
+    /* decoder */
+    s->codesize = csize;
+    s->cursize = s->codesize + 1;
+    s->curmask = mask[s->cursize];
+    s->top_slot = 1 << s->cursize;
+    s->clear_code = 1 << s->codesize;
+    s->end_code = s->clear_code + 1;
+    s->slot = s->newcodes = s->clear_code + 2;
+    s->oc = s->fc = 0;
+    s->sp = s->stack;
+}
+
+/* XXX: optimize */
+static inline int GetCode(GifState * s)
+{
+    int c, sizbuf;
+    uint8_t *ptr;
+
+    while (s->bbits < s->cursize) {
+        ptr = s->pbuf;
+        if (ptr >= s->ebuf) {
+            if (!s->eob_reached) {
+                sizbuf = bytestream_get_byte(&s->bytestream);
+                s->ebuf = s->buf + sizbuf;
+                s->pbuf = s->buf;
+                if (sizbuf > 0) {
+                    bytestream_get_buffer(&s->bytestream, s->buf, sizbuf);
+                } else {
+                    s->eob_reached = 1;
+                }
+            }
+            ptr = s->pbuf;
+        }
+        s->bbuf |= ptr[0] << s->bbits;
+        ptr++;
+        s->pbuf = ptr;
+        s->bbits += 8;
+    }
+    c = s->bbuf & s->curmask;
+    s->bbuf >>= s->cursize;
+    s->bbits -= s->cursize;
+    return c;
+}
+
+/* NOTE: the algorithm here is inspired from the LZW GIF decoder
+   written by Steven A. Bennett in 1987. */
+/* return the number of byte decoded */
+static int GLZWDecode(GifState * s, uint8_t * buf, int len)
+{
+    int l, c, code, oc, fc;
+    uint8_t *sp;
+
+    if (s->end_code < 0)
+        return 0;
+
+    l = len;
+    sp = s->sp;
+    oc = s->oc;
+    fc = s->fc;
+
+    while (sp > s->stack) {
+        *buf++ = *(--sp);
+        if ((--l) == 0)
+            goto the_end;
+    }
+
+    for (;;) {
+        c = GetCode(s);
+        if (c == s->end_code) {
+            s->end_code = -1;
+            break;
+        } else if (c == s->clear_code) {
+            s->cursize = s->codesize + 1;
+            s->curmask = mask[s->cursize];
+            s->slot = s->newcodes;
+            s->top_slot = 1 << s->cursize;
+            while ((c = GetCode(s)) == s->clear_code);
+            if (c == s->end_code) {
+                s->end_code = -1;
+                break;
+            }
+            /* test error */
+            if (c >= s->slot)
+                c = 0;
+            fc = oc = c;
+            *buf++ = c;
+            if ((--l) == 0)
+                break;
+        } else {
+            code = c;
+            if (code >= s->slot) {
+                *sp++ = fc;
+                code = oc;
+            }
+            while (code >= s->newcodes) {
+                *sp++ = s->suffix[code];
+                code = s->prefix[code];
+            }
+            *sp++ = code;
+            if (s->slot < s->top_slot) {
+                s->suffix[s->slot] = fc = code;
+                s->prefix[s->slot++] = oc;
+                oc = c;
+            }
+            if (s->slot >= s->top_slot) {
+                if (s->cursize < MAXBITS) {
+                    s->top_slot <<= 1;
+                    s->curmask = mask[++s->cursize];
+                }
+            }
+            while (sp > s->stack) {
+                *buf++ = *(--sp);
+                if ((--l) == 0)
+                    goto the_end;
+            }
+        }
+    }
+  the_end:
+    s->sp = sp;
+    s->oc = oc;
+    s->fc = fc;
+    return len - l;
+}
+
+static int gif_read_image(GifState *s)
+{
+    int left, top, width, height, bits_per_pixel, code_size, flags;
+    int is_interleaved, has_local_palette, y, x, pass, y1, linesize, n, i;
+    uint8_t *ptr, *line, *d, *spal, *palette, *sptr, *ptr1;
+
+    left = bytestream_get_le16(&s->bytestream);
+    top = bytestream_get_le16(&s->bytestream);
+    width = bytestream_get_le16(&s->bytestream);
+    height = bytestream_get_le16(&s->bytestream);
+    flags = bytestream_get_byte(&s->bytestream);
+    is_interleaved = flags & 0x40;
+    has_local_palette = flags & 0x80;
+    bits_per_pixel = (flags & 0x07) + 1;
+#ifdef DEBUG
+    printf("gif: image x=%d y=%d w=%d h=%d\n", left, top, width, height);
+#endif
+
+    if (has_local_palette) {
+        bytestream_get_buffer(&s->bytestream, s->local_palette, 3 * (1 << bits_per_pixel));
+        palette = s->local_palette;
+    } else {
+        palette = s->global_palette;
+        bits_per_pixel = s->bits_per_pixel;
+    }
+
+    /* verify that all the image is inside the screen dimensions */
+    if (left + width > s->screen_width ||
+        top + height > s->screen_height)
+        return -EINVAL;
+
+    /* build the palette */
+        n = (1 << bits_per_pixel);
+        spal = palette;
+        for(i = 0; i < n; i++) {
+            s->image_palette[i] = (0xff << 24) |
+                (spal[0] << 16) | (spal[1] << 8) | (spal[2]);
+            spal += 3;
+        }
+        for(; i < 256; i++)
+            s->image_palette[i] = (0xff << 24);
+        /* handle transparency */
+        if (s->transparent_color_index >= 0)
+            s->image_palette[s->transparent_color_index] = 0;
+        line = NULL;
+
+    /* now get the image data */
+    code_size = bytestream_get_byte(&s->bytestream);
+    GLZWDecodeInit(s, code_size);
+
+    /* read all the image */
+    linesize = s->image_linesize;
+    ptr1 = s->image_buf + top * linesize + (left * 3);
+    ptr = ptr1;
+    pass = 0;
+    y1 = 0;
+    for (y = 0; y < height; y++) {
+            GLZWDecode(s, ptr, width);
+        if (is_interleaved) {
+            switch(pass) {
+            default:
+            case 0:
+            case 1:
+                y1 += 8;
+                ptr += linesize * 8;
+                if (y1 >= height) {
+                    y1 = 4;
+                    if (pass == 0)
+                        ptr = ptr1 + linesize * 4;
+                    else
+                        ptr = ptr1 + linesize * 2;
+                    pass++;
+                }
+                break;
+            case 2:
+                y1 += 4;
+                ptr += linesize * 4;
+                if (y1 >= height) {
+                    y1 = 1;
+                    ptr = ptr1 + linesize;
+                    pass++;
+                }
+                break;
+            case 3:
+                y1 += 2;
+                ptr += linesize * 2;
+                break;
+            }
+        } else {
+            ptr += linesize;
+        }
+    }
+    av_free(line);
+
+    /* read the garbage data until end marker is found */
+    while (!s->eob_reached)
+        GetCode(s);
+    return 0;
+}
+
+static int gif_read_extension(GifState *s)
+{
+    int ext_code, ext_len, i, gce_flags, gce_transparent_index;
+
+    /* extension */
+    ext_code = bytestream_get_byte(&s->bytestream);
+    ext_len = bytestream_get_byte(&s->bytestream);
+#ifdef DEBUG
+    printf("gif: ext_code=0x%x len=%d\n", ext_code, ext_len);
+#endif
+    switch(ext_code) {
+    case 0xf9:
+        if (ext_len != 4)
+            goto discard_ext;
+        s->transparent_color_index = -1;
+        gce_flags = bytestream_get_byte(&s->bytestream);
+        s->gce_delay = bytestream_get_le16(&s->bytestream);
+        gce_transparent_index = bytestream_get_byte(&s->bytestream);
+        if (gce_flags & 0x01)
+            s->transparent_color_index = gce_transparent_index;
+        else
+            s->transparent_color_index = -1;
+        s->gce_disposal = (gce_flags >> 2) & 0x7;
+#ifdef DEBUG
+        printf("gif: gce_flags=%x delay=%d tcolor=%d disposal=%d\n",
+               gce_flags, s->gce_delay,
+               s->transparent_color_index, s->gce_disposal);
+#endif
+        ext_len = bytestream_get_byte(&s->bytestream);
+        break;
+    }
+
+    /* NOTE: many extension blocks can come after */
+ discard_ext:
+    while (ext_len != 0) {
+        for (i = 0; i < ext_len; i++)
+            bytestream_get_byte(&s->bytestream);
+        ext_len = bytestream_get_byte(&s->bytestream);
+#ifdef DEBUG
+        printf("gif: ext_len1=%d\n", ext_len);
+#endif
+    }
+    return 0;
+}
+
+static int gif_read_header1(GifState *s)
+{
+    uint8_t sig[6];
+    int ret, v, n;
+    int has_global_palette;
+
+    /* read gif signature */
+    bytestream_get_buffer(&s->bytestream, sig, 6);
+    if (memcmp(sig, gif87a_sig, 6) != 0 &&
+        memcmp(sig, gif89a_sig, 6) != 0)
+        return -1;
+
+    /* read screen header */
+    s->transparent_color_index = -1;
+    s->screen_width = bytestream_get_le16(&s->bytestream);
+    s->screen_height = bytestream_get_le16(&s->bytestream);
+    if(   (unsigned)s->screen_width  > 32767
+       || (unsigned)s->screen_height > 32767){
+        av_log(NULL, AV_LOG_ERROR, "picture size too large\n");
+        return -1;
+    }
+
+    v = bytestream_get_byte(&s->bytestream);
+    s->color_resolution = ((v & 0x70) >> 4) + 1;
+    has_global_palette = (v & 0x80);
+    s->bits_per_pixel = (v & 0x07) + 1;
+    s->background_color_index = bytestream_get_byte(&s->bytestream);
+    bytestream_get_byte(&s->bytestream);                /* ignored */
+#ifdef DEBUG
+    printf("gif: screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
+           s->screen_width, s->screen_height, s->bits_per_pixel,
+           has_global_palette);
+#endif
+    if (has_global_palette) {
+        n = 1 << s->bits_per_pixel;
+        bytestream_get_buffer(&s->bytestream, s->global_palette, n * 3);
+    }
+    return 0;
+}
+
+static int gif_parse_next_image(GifState *s)
+{
+    int ret, code;
+
+    for (;;) {
+        code = bytestream_get_byte(&s->bytestream);
+#ifdef DEBUG
+        printf("gif: code=%02x '%c'\n", code, code);
+#endif
+        switch (code) {
+        case ',':
+            if (gif_read_image(s) < 0)
+                return -1;
+            ret = 0;
+            goto the_end;
+        case ';':
+            /* end of image */
+            ret = -1;
+            goto the_end;
+        case '!':
+            if (gif_read_extension(s) < 0)
+                return -1;
+            break;
+        case EOF:
+        default:
+            /* error or errneous EOF */
+            ret = -1;
+            goto the_end;
+        }
+    }
+  the_end:
+    return ret;
+}
+
+static int gif_decode_init(AVCodecContext *avctx)
+{
+    GifState *s = avctx->priv_data;
+
+    return 0;
+}
+
+static int gif_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
+{
+    GifState *s = avctx->priv_data;
+    AVFrame *picture = data;
+    int ret;
+
+    s->bytestream = buf;
+    if (gif_read_header1(s) < 0)
+        return -1;
+
+    /* allocate image buffer */
+    s->image_linesize = s->screen_width * 3;
+    s->image_buf = av_malloc(s->screen_height * s->image_linesize);
+    if (!s->image_buf)
+        return -ENOMEM;
+    s->pix_fmt = PIX_FMT_PAL8;
+    /* now we are ready: build format streams */
+
+    /* XXX: check if screen size is always valid */
+    avctx->width = s->screen_width;
+    avctx->height = s->screen_height;
+    avctx->pix_fmt = PIX_FMT_PAL8;
+
+    ret = gif_parse_next_image(s);
+    if (ret < 0)
+        return ret;
+
+    picture->data[0] = s->image_buf;
+    picture->linesize[0] = s->image_linesize;
+    picture->data[1] = s->image_palette;
+    picture->linesize[1] = 4;
+
+    *data_size = sizeof(AVPicture);
+    return 0;
+}
+
+AVCodec gif_decoder = {
+    "gif",
+    CODEC_TYPE_VIDEO,
+    CODEC_ID_GIF,
+    sizeof(GifState),
+    gif_decode_init,
+    NULL,
+    NULL,
+    gif_decode_frame,
+};