git.sesse.net Git - ffmpeg/blob - libavformat/gif.c

   1 /*
   2  * Animated GIF muxer
   3  * Copyright (c) 2000 Fabrice Bellard
   4  *
   5  * first version by Francois Revol <revol@free.fr>
   6  *
   7  * This file is part of Libav.
   8  *
   9  * Libav is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * Libav is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with Libav; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /*
  25  * Features and limitations:
  26  * - currently no compression is performed,
  27  *   in fact the size of the data is 9/8 the size of the image in 8bpp
  28  * - uses only a global standard palette
  29  * - tested with IE 5.0, Opera for BeOS, NetPositive (BeOS), and Mozilla (BeOS).
  30  *
  31  * Reference documents:
  32  * http://www.goice.co.jp/member/mo/formats/gif.html
  33  * http://astronomy.swin.edu.au/pbourke/dataformats/gif/
  34  * http://www.dcs.ed.ac.uk/home/mxr/gfx/2d/GIF89a.txt
  35  *
  36  * this url claims to have an LZW algorithm not covered by Unisys patent:
  37  * http://www.msg.net/utility/whirlgif/gifencod.html
  38  * could help reduce the size of the files _a lot_...
  39  * some sites mentions an RLE type compression also.
  40  */
  41
  42 #include "avformat.h"
  43 #include "libavutil/log.h"
  44 #include "libavutil/opt.h"
  45
  46 /* The GIF format uses reversed order for bitstreams... */
  47 /* at least they don't use PDP_ENDIAN :) */
  48 #define BITSTREAM_WRITER_LE
  49
  50 #include "libavcodec/put_bits.h"
  51
  52 /* bitstream minipacket size */
  53 #define GIF_CHUNKS 100
  54
  55 /* slows down the decoding (and some browsers don't like it) */
  56 /* update on the 'some browsers don't like it issue from above:
  57  * this was probably due to missing 'Data Sub-block Terminator'
  58  * (byte 19) in the app_header */
  59 #define GIF_ADD_APP_HEADER // required to enable looping of animated gif
  60
  61 typedef struct rgb_triplet {
  62     unsigned char r;
  63     unsigned char g;
  64     unsigned char b;
  65 } rgb_triplet;
  66
  67 /* we use the standard 216 color palette */
  68
  69 /* this script was used to create the palette:
  70  * for r in 00 33 66 99 cc ff; do
  71  *     for g in 00 33 66 99 cc ff; do
  72  *         echo -n "    "
  73  *         for b in 00 33 66 99 cc ff; do
  74  *             echo -n "{ 0x$r, 0x$g, 0x$b }, "
  75  *         done
  76  *         echo ""
  77  *     done
  78  * done
  79  */
  80
  81 static const rgb_triplet gif_clut[216] = {
  82     { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x33 }, { 0x00, 0x00, 0x66 }, { 0x00, 0x00, 0x99 }, { 0x00, 0x00, 0xcc }, { 0x00, 0x00, 0xff },
  83     { 0x00, 0x33, 0x00 }, { 0x00, 0x33, 0x33 }, { 0x00, 0x33, 0x66 }, { 0x00, 0x33, 0x99 }, { 0x00, 0x33, 0xcc }, { 0x00, 0x33, 0xff },
  84     { 0x00, 0x66, 0x00 }, { 0x00, 0x66, 0x33 }, { 0x00, 0x66, 0x66 }, { 0x00, 0x66, 0x99 }, { 0x00, 0x66, 0xcc }, { 0x00, 0x66, 0xff },
  85     { 0x00, 0x99, 0x00 }, { 0x00, 0x99, 0x33 }, { 0x00, 0x99, 0x66 }, { 0x00, 0x99, 0x99 }, { 0x00, 0x99, 0xcc }, { 0x00, 0x99, 0xff },
  86     { 0x00, 0xcc, 0x00 }, { 0x00, 0xcc, 0x33 }, { 0x00, 0xcc, 0x66 }, { 0x00, 0xcc, 0x99 }, { 0x00, 0xcc, 0xcc }, { 0x00, 0xcc, 0xff },
  87     { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0x33 }, { 0x00, 0xff, 0x66 }, { 0x00, 0xff, 0x99 }, { 0x00, 0xff, 0xcc }, { 0x00, 0xff, 0xff },
  88     { 0x33, 0x00, 0x00 }, { 0x33, 0x00, 0x33 }, { 0x33, 0x00, 0x66 }, { 0x33, 0x00, 0x99 }, { 0x33, 0x00, 0xcc }, { 0x33, 0x00, 0xff },
  89     { 0x33, 0x33, 0x00 }, { 0x33, 0x33, 0x33 }, { 0x33, 0x33, 0x66 }, { 0x33, 0x33, 0x99 }, { 0x33, 0x33, 0xcc }, { 0x33, 0x33, 0xff },
  90     { 0x33, 0x66, 0x00 }, { 0x33, 0x66, 0x33 }, { 0x33, 0x66, 0x66 }, { 0x33, 0x66, 0x99 }, { 0x33, 0x66, 0xcc }, { 0x33, 0x66, 0xff },
  91     { 0x33, 0x99, 0x00 }, { 0x33, 0x99, 0x33 }, { 0x33, 0x99, 0x66 }, { 0x33, 0x99, 0x99 }, { 0x33, 0x99, 0xcc }, { 0x33, 0x99, 0xff },
  92     { 0x33, 0xcc, 0x00 }, { 0x33, 0xcc, 0x33 }, { 0x33, 0xcc, 0x66 }, { 0x33, 0xcc, 0x99 }, { 0x33, 0xcc, 0xcc }, { 0x33, 0xcc, 0xff },
  93     { 0x33, 0xff, 0x00 }, { 0x33, 0xff, 0x33 }, { 0x33, 0xff, 0x66 }, { 0x33, 0xff, 0x99 }, { 0x33, 0xff, 0xcc }, { 0x33, 0xff, 0xff },
  94     { 0x66, 0x00, 0x00 }, { 0x66, 0x00, 0x33 }, { 0x66, 0x00, 0x66 }, { 0x66, 0x00, 0x99 }, { 0x66, 0x00, 0xcc }, { 0x66, 0x00, 0xff },
  95     { 0x66, 0x33, 0x00 }, { 0x66, 0x33, 0x33 }, { 0x66, 0x33, 0x66 }, { 0x66, 0x33, 0x99 }, { 0x66, 0x33, 0xcc }, { 0x66, 0x33, 0xff },
  96     { 0x66, 0x66, 0x00 }, { 0x66, 0x66, 0x33 }, { 0x66, 0x66, 0x66 }, { 0x66, 0x66, 0x99 }, { 0x66, 0x66, 0xcc }, { 0x66, 0x66, 0xff },
  97     { 0x66, 0x99, 0x00 }, { 0x66, 0x99, 0x33 }, { 0x66, 0x99, 0x66 }, { 0x66, 0x99, 0x99 }, { 0x66, 0x99, 0xcc }, { 0x66, 0x99, 0xff },
  98     { 0x66, 0xcc, 0x00 }, { 0x66, 0xcc, 0x33 }, { 0x66, 0xcc, 0x66 }, { 0x66, 0xcc, 0x99 }, { 0x66, 0xcc, 0xcc }, { 0x66, 0xcc, 0xff },
  99     { 0x66, 0xff, 0x00 }, { 0x66, 0xff, 0x33 }, { 0x66, 0xff, 0x66 }, { 0x66, 0xff, 0x99 }, { 0x66, 0xff, 0xcc }, { 0x66, 0xff, 0xff },
 100     { 0x99, 0x00, 0x00 }, { 0x99, 0x00, 0x33 }, { 0x99, 0x00, 0x66 }, { 0x99, 0x00, 0x99 }, { 0x99, 0x00, 0xcc }, { 0x99, 0x00, 0xff },
 101     { 0x99, 0x33, 0x00 }, { 0x99, 0x33, 0x33 }, { 0x99, 0x33, 0x66 }, { 0x99, 0x33, 0x99 }, { 0x99, 0x33, 0xcc }, { 0x99, 0x33, 0xff },
 102     { 0x99, 0x66, 0x00 }, { 0x99, 0x66, 0x33 }, { 0x99, 0x66, 0x66 }, { 0x99, 0x66, 0x99 }, { 0x99, 0x66, 0xcc }, { 0x99, 0x66, 0xff },
 103     { 0x99, 0x99, 0x00 }, { 0x99, 0x99, 0x33 }, { 0x99, 0x99, 0x66 }, { 0x99, 0x99, 0x99 }, { 0x99, 0x99, 0xcc }, { 0x99, 0x99, 0xff },
 104     { 0x99, 0xcc, 0x00 }, { 0x99, 0xcc, 0x33 }, { 0x99, 0xcc, 0x66 }, { 0x99, 0xcc, 0x99 }, { 0x99, 0xcc, 0xcc }, { 0x99, 0xcc, 0xff },
 105     { 0x99, 0xff, 0x00 }, { 0x99, 0xff, 0x33 }, { 0x99, 0xff, 0x66 }, { 0x99, 0xff, 0x99 }, { 0x99, 0xff, 0xcc }, { 0x99, 0xff, 0xff },
 106     { 0xcc, 0x00, 0x00 }, { 0xcc, 0x00, 0x33 }, { 0xcc, 0x00, 0x66 }, { 0xcc, 0x00, 0x99 }, { 0xcc, 0x00, 0xcc }, { 0xcc, 0x00, 0xff },
 107     { 0xcc, 0x33, 0x00 }, { 0xcc, 0x33, 0x33 }, { 0xcc, 0x33, 0x66 }, { 0xcc, 0x33, 0x99 }, { 0xcc, 0x33, 0xcc }, { 0xcc, 0x33, 0xff },
 108     { 0xcc, 0x66, 0x00 }, { 0xcc, 0x66, 0x33 }, { 0xcc, 0x66, 0x66 }, { 0xcc, 0x66, 0x99 }, { 0xcc, 0x66, 0xcc }, { 0xcc, 0x66, 0xff },
 109     { 0xcc, 0x99, 0x00 }, { 0xcc, 0x99, 0x33 }, { 0xcc, 0x99, 0x66 }, { 0xcc, 0x99, 0x99 }, { 0xcc, 0x99, 0xcc }, { 0xcc, 0x99, 0xff },
 110     { 0xcc, 0xcc, 0x00 }, { 0xcc, 0xcc, 0x33 }, { 0xcc, 0xcc, 0x66 }, { 0xcc, 0xcc, 0x99 }, { 0xcc, 0xcc, 0xcc }, { 0xcc, 0xcc, 0xff },
 111     { 0xcc, 0xff, 0x00 }, { 0xcc, 0xff, 0x33 }, { 0xcc, 0xff, 0x66 }, { 0xcc, 0xff, 0x99 }, { 0xcc, 0xff, 0xcc }, { 0xcc, 0xff, 0xff },
 112     { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0x33 }, { 0xff, 0x00, 0x66 }, { 0xff, 0x00, 0x99 }, { 0xff, 0x00, 0xcc }, { 0xff, 0x00, 0xff },
 113     { 0xff, 0x33, 0x00 }, { 0xff, 0x33, 0x33 }, { 0xff, 0x33, 0x66 }, { 0xff, 0x33, 0x99 }, { 0xff, 0x33, 0xcc }, { 0xff, 0x33, 0xff },
 114     { 0xff, 0x66, 0x00 }, { 0xff, 0x66, 0x33 }, { 0xff, 0x66, 0x66 }, { 0xff, 0x66, 0x99 }, { 0xff, 0x66, 0xcc }, { 0xff, 0x66, 0xff },
 115     { 0xff, 0x99, 0x00 }, { 0xff, 0x99, 0x33 }, { 0xff, 0x99, 0x66 }, { 0xff, 0x99, 0x99 }, { 0xff, 0x99, 0xcc }, { 0xff, 0x99, 0xff },
 116     { 0xff, 0xcc, 0x00 }, { 0xff, 0xcc, 0x33 }, { 0xff, 0xcc, 0x66 }, { 0xff, 0xcc, 0x99 }, { 0xff, 0xcc, 0xcc }, { 0xff, 0xcc, 0xff },
 117     { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0x33 }, { 0xff, 0xff, 0x66 }, { 0xff, 0xff, 0x99 }, { 0xff, 0xff, 0xcc }, { 0xff, 0xff, 0xff },
 118 };
 119
 120 /* GIF header */
 121 static int gif_image_write_header(AVIOContext *pb, int width, int height,
 122                                   int loop_count, uint32_t *palette)
 123 {
 124     int i;
 125     unsigned int v;
 126
 127     avio_write(pb, "GIF", 3);
 128     avio_write(pb, "89a", 3);
 129     avio_wl16(pb, width);
 130     avio_wl16(pb, height);
 131
 132     avio_w8(pb, 0xf7); /* flags: global clut, 256 entries */
 133     avio_w8(pb, 0x1f); /* background color index */
 134     avio_w8(pb, 0);    /* aspect ratio */
 135
 136     /* the global palette */
 137     if (!palette) {
 138         avio_write(pb, (const unsigned char *)gif_clut, 216 * 3);
 139         for (i = 0; i < ((256 - 216) * 3); i++)
 140             avio_w8(pb, 0);
 141     } else {
 142         for (i = 0; i < 256; i++) {
 143             v = palette[i];
 144             avio_w8(pb, (v >> 16) & 0xff);
 145             avio_w8(pb, (v >>  8) & 0xff);
 146             avio_w8(pb, (v)       & 0xff);
 147         }
 148     }
 149
 150     /* update: this is the 'NETSCAPE EXTENSION' that allows for looped animated
 151      * GIF, see http://members.aol.com/royalef/gifabout.htm#net-extension
 152      *
 153      * byte   1       : 33 (hex 0x21) GIF Extension code
 154      * byte   2       : 255 (hex 0xFF) Application Extension Label
 155      * byte   3       : 11 (hex (0x0B) Length of Application Block
 156      *                          (eleven bytes of data to follow)
 157      * bytes  4 to 11 : "NETSCAPE"
 158      * bytes 12 to 14 : "2.0"
 159      * byte  15       : 3 (hex 0x03) Length of Data Sub-Block
 160      *                          (three bytes of data to follow)
 161      * byte  16       : 1 (hex 0x01)
 162      * bytes 17 to 18 : 0 to 65535, an unsigned integer in
 163      *                          lo-hi byte format. This indicate the
 164      *                          number of iterations the loop should
 165      *                          be executed.
 166      * bytes 19       : 0 (hex 0x00) a Data Sub-block Terminator
 167      */
 168
 169     /* application extension header */
 170 #ifdef GIF_ADD_APP_HEADER
 171     if (loop_count >= 0 && loop_count <= 65535) {
 172         avio_w8(pb, 0x21);
 173         avio_w8(pb, 0xff);
 174         avio_w8(pb, 0x0b);
 175         // bytes 4 to 14
 176         avio_write(pb, "NETSCAPE2.0", sizeof("NETSCAPE2.0") - 1);
 177         avio_w8(pb, 0x03); // byte 15
 178         avio_w8(pb, 0x01); // byte 16
 179         avio_wl16(pb, (uint16_t)loop_count);
 180         avio_w8(pb, 0x00); // byte 19
 181     }
 182 #endif
 183     return 0;
 184 }
 185
 186 /* this is maybe slow, but allows for extensions */
 187 static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
 188 {
 189     return (((r) / 47) % 6) * 6 * 6 + (((g) / 47) % 6) * 6 + (((b) / 47) % 6);
 190 }
 191
 192 static int gif_image_write_image(AVIOContext *pb,
 193                                  int x1, int y1, int width, int height,
 194                                  const uint8_t *buf, int linesize, int pix_fmt)
 195 {
 196     PutBitContext p;
 197     uint8_t buffer[200]; /* 100 * 9 / 8 = 113 */
 198     int i, left, w, v;
 199     const uint8_t *ptr;
 200     /* image block */
 201
 202     avio_w8(pb, 0x2c);
 203     avio_wl16(pb, x1);
 204     avio_wl16(pb, y1);
 205     avio_wl16(pb, width);
 206     avio_wl16(pb, height);
 207     avio_w8(pb, 0x00); /* flags */
 208     /* no local clut */
 209
 210     avio_w8(pb, 0x08);
 211
 212     left = width * height;
 213
 214     init_put_bits(&p, buffer, 130);
 215
 216 /*
 217  * the thing here is the bitstream is written as little packets, with a size
 218  * byte before but it's still the same bitstream between packets (no flush !)
 219  */
 220     ptr = buf;
 221     w   = width;
 222     while (left > 0) {
 223         put_bits(&p, 9, 0x0100); /* clear code */
 224
 225         for (i = (left < GIF_CHUNKS) ? left : GIF_CHUNKS; i; i--) {
 226             if (pix_fmt == AV_PIX_FMT_RGB24) {
 227                 v    = gif_clut_index(ptr[0], ptr[1], ptr[2]);
 228                 ptr += 3;
 229             } else {
 230                 v = *ptr++;
 231             }
 232             put_bits(&p, 9, v);
 233             if (--w == 0) {
 234                 w    = width;
 235                 buf += linesize;
 236                 ptr  = buf;
 237             }
 238         }
 239
 240         if (left <= GIF_CHUNKS) {
 241             put_bits(&p, 9, 0x101); /* end of stream */
 242             flush_put_bits(&p);
 243         }
 244         if (put_bits_ptr(&p) - p.buf > 0) {
 245             avio_w8(pb, put_bits_ptr(&p) - p.buf); /* byte count of the packet */
 246             avio_write(pb, p.buf, put_bits_ptr(&p) - p.buf); /* the actual buffer */
 247             p.buf_ptr = p.buf; /* dequeue the bytes off the bitstream */
 248         }
 249         left -= GIF_CHUNKS;
 250     }
 251     avio_w8(pb, 0x00); /* end of image block */
 252
 253     return 0;
 254 }
 255
 256 typedef struct GIFContext {
 257     AVClass *class;         /** Class for private options. */
 258     int64_t time, file_time;
 259     uint8_t buffer[100]; /* data chunks */
 260     int loop;
 261 } GIFContext;
 262
 263 static int gif_write_header(AVFormatContext *s)
 264 {
 265     GIFContext *gif = s->priv_data;
 266     AVIOContext *pb = s->pb;
 267     AVCodecParameters *par, *video_par;
 268     int i, width, height /*, rate*/;
 269
 270 /* XXX: do we reject audio streams or just ignore them ?
 271  *  if (s->nb_streams > 1)
 272  *      return -1;
 273  */
 274     gif->time      = 0;
 275     gif->file_time = 0;
 276
 277     video_par = NULL;
 278     for (i = 0; i < s->nb_streams; i++) {
 279         par = s->streams[i]->codecpar;
 280         if (par->codec_type != AVMEDIA_TYPE_AUDIO)
 281             video_par = par;
 282     }
 283
 284     if (!video_par) {
 285         av_free(gif);
 286         return -1;
 287     } else {
 288         width  = video_par->width;
 289         height = video_par->height;
 290 //        rate = video_enc->time_base.den;
 291     }
 292
 293     if (video_par->format != AV_PIX_FMT_RGB24) {
 294         av_log(s, AV_LOG_ERROR,
 295                "ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n");
 296         return AVERROR(EIO);
 297     }
 298
 299     gif_image_write_header(pb, width, height, gif->loop, NULL);
 300
 301     avio_flush(s->pb);
 302     return 0;
 303 }
 304
 305 static int gif_write_video(AVFormatContext *s, AVStream *st,
 306                            const uint8_t *buf, int size)
 307 {
 308     AVCodecParameters *par = st->codecpar;
 309     AVIOContext *pb = s->pb;
 310     int jiffies;
 311
 312     /* graphic control extension block */
 313     avio_w8(pb, 0x21);
 314     avio_w8(pb, 0xf9);
 315     avio_w8(pb, 0x04); /* block size */
 316     avio_w8(pb, 0x04); /* flags */
 317
 318     /* 1 jiffy is 1/70 s */
 319     /* the delay_time field indicates the number of jiffies - 1 */
 320     /* XXX: should use delay, in order to be more accurate */
 321     /* instead of using the same rounded value each time */
 322     /* XXX: don't even remember if I really use it for now */
 323     jiffies = (70 * st->time_base.num / st->time_base.den) - 1;
 324
 325     avio_wl16(pb, jiffies);
 326
 327     avio_w8(pb, 0x1f); /* transparent color index */
 328     avio_w8(pb, 0x00);
 329
 330     gif_image_write_image(pb, 0, 0, par->width, par->height,
 331                           buf, par->width * 3, AV_PIX_FMT_RGB24);
 332
 333     return 0;
 334 }
 335
 336 static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
 337 {
 338     AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
 339     if (par->codec_type == AVMEDIA_TYPE_AUDIO)
 340         return 0; /* just ignore audio */
 341     else
 342         return gif_write_video(s, s->streams[pkt->stream_index], pkt->data, pkt->size);
 343 }
 344
 345 static int gif_write_trailer(AVFormatContext *s)
 346 {
 347     AVIOContext *pb = s->pb;
 348
 349     avio_w8(pb, 0x3b);
 350
 351     return 0;
 352 }
 353
 354 #define OFFSET(x) offsetof(GIFContext, x)
 355 #define ENC AV_OPT_FLAG_ENCODING_PARAM
 356 static const AVOption options[] = {
 357     { "loop", "Number of times to loop the output.", OFFSET(loop),
 358       AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 65535, ENC },
 359     { NULL },
 360 };
 361
 362 static const AVClass gif_muxer_class = {
 363     .class_name = "GIF muxer",
 364     .item_name  = av_default_item_name,
 365     .version    = LIBAVUTIL_VERSION_INT,
 366     .option     = options,
 367 };
 368
 369 AVOutputFormat ff_gif_muxer = {
 370     .name           = "gif",
 371     .long_name      = NULL_IF_CONFIG_SMALL("GIF Animation"),
 372     .mime_type      = "image/gif",
 373     .extensions     = "gif",
 374     .priv_data_size = sizeof(GIFContext),
 375     .audio_codec    = AV_CODEC_ID_NONE,
 376     .video_codec    = AV_CODEC_ID_RAWVIDEO,
 377     .write_header   = gif_write_header,
 378     .write_packet   = gif_write_packet,
 379     .write_trailer  = gif_write_trailer,
 380     .priv_class     = &gif_muxer_class,
 381 };