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

   1 /*
   2  * GIF demuxer
   3  * Copyright (c) 2012 Vitaliy E Sugrobov
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * GIF demuxer.
  25  */
  26
  27 #include "avformat.h"
  28 #include "libavutil/bprint.h"
  29 #include "libavutil/intreadwrite.h"
  30 #include "libavutil/opt.h"
  31 #include "internal.h"
  32 #include "libavcodec/gif.h"
  33
  34 typedef struct GIFDemuxContext {
  35     const AVClass *class;
  36     /**
  37      * Time span in hundredths of second before
  38      * the next frame should be drawn on screen.
  39      */
  40     int delay;
  41     /**
  42      * Minimum allowed delay between frames in hundredths of
  43      * second. Values below this threshold considered to be
  44      * invalid and set to value of default_delay.
  45      */
  46     int min_delay;
  47     int max_delay;
  48     int default_delay;
  49
  50     /**
  51      * loop options
  52      */
  53     int total_iter;
  54     int iter_count;
  55     int ignore_loop;
  56
  57     int nb_frames;
  58     int last_duration;
  59 } GIFDemuxContext;
  60
  61 /**
  62  * Major web browsers display gifs at ~10-15fps when rate
  63  * is not explicitly set or have too low values. We assume default rate to be 10.
  64  * Default delay = 100hundredths of second / 10fps = 10hos per frame.
  65  */
  66 #define GIF_DEFAULT_DELAY   10
  67 /**
  68  * By default delay values less than this threshold considered to be invalid.
  69  */
  70 #define GIF_MIN_DELAY       2
  71
  72 static int gif_probe(const AVProbeData *p)
  73 {
  74     /* check magick */
  75     if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
  76         return 0;
  77
  78     /* width or height contains zero? */
  79     if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
  80         return 0;
  81
  82     return AVPROBE_SCORE_MAX;
  83 }
  84
  85 static int resync(AVIOContext *pb)
  86 {
  87     int i;
  88     for (i = 0; i < 6; i++) {
  89         int b = avio_r8(pb);
  90         if (b != gif87a_sig[i] && b != gif89a_sig[i])
  91             i = -(b != 'G');
  92         if (avio_feof(pb))
  93             return AVERROR_EOF;
  94     }
  95     return 0;
  96 }
  97
  98 static int gif_skip_subblocks(AVIOContext *pb)
  99 {
 100     int sb_size, ret = 0;
 101
 102     while (0x00 != (sb_size = avio_r8(pb))) {
 103         if ((ret = avio_skip(pb, sb_size)) < 0)
 104             return ret;
 105     }
 106
 107     return ret;
 108 }
 109
 110 static int gif_read_header(AVFormatContext *s)
 111 {
 112     GIFDemuxContext *gdc = s->priv_data;
 113     AVIOContext     *pb  = s->pb;
 114     AVStream        *st;
 115     int type, width, height, ret, n, flags;
 116     int64_t nb_frames = 0, duration = 0;
 117
 118     if ((ret = resync(pb)) < 0)
 119         return ret;
 120
 121     gdc->delay  = gdc->default_delay;
 122     width  = avio_rl16(pb);
 123     height = avio_rl16(pb);
 124     flags = avio_r8(pb);
 125     avio_skip(pb, 1);
 126     n      = avio_r8(pb);
 127
 128     if (width == 0 || height == 0)
 129         return AVERROR_INVALIDDATA;
 130
 131     st = avformat_new_stream(s, NULL);
 132     if (!st)
 133         return AVERROR(ENOMEM);
 134
 135     if (flags & 0x80)
 136         avio_skip(pb, 3 * (1 << ((flags & 0x07) + 1)));
 137
 138     while ((type = avio_r8(pb)) != GIF_TRAILER) {
 139         if (avio_feof(pb))
 140             break;
 141         if (type == GIF_EXTENSION_INTRODUCER) {
 142             int subtype = avio_r8(pb);
 143             if (subtype == GIF_COM_EXT_LABEL) {
 144                 AVBPrint bp;
 145                 int block_size;
 146
 147                 av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
 148                 while ((block_size = avio_r8(pb)) != 0) {
 149                     avio_read_to_bprint(pb, &bp, block_size);
 150                 }
 151                 av_dict_set(&s->metadata, "comment", bp.str, 0);
 152                 av_bprint_finalize(&bp, NULL);
 153             } else if (subtype == GIF_GCE_EXT_LABEL) {
 154                 int block_size = avio_r8(pb);
 155
 156                 if (block_size == 4) {
 157                     int delay;
 158
 159                     avio_skip(pb, 1);
 160                     delay = avio_rl16(pb);
 161                     if (delay < gdc->min_delay)
 162                         delay = gdc->default_delay;
 163                     delay = FFMIN(delay, gdc->max_delay);
 164                     duration += delay;
 165                     avio_skip(pb, 1);
 166                 } else {
 167                     avio_skip(pb, block_size);
 168                 }
 169                 gif_skip_subblocks(pb);
 170             } else {
 171                 gif_skip_subblocks(pb);
 172             }
 173         } else if (type == GIF_IMAGE_SEPARATOR) {
 174             avio_skip(pb, 8);
 175             flags = avio_r8(pb);
 176             if (flags & 0x80)
 177                 avio_skip(pb, 3 * (1 << ((flags & 0x07) + 1)));
 178             avio_skip(pb, 1);
 179             gif_skip_subblocks(pb);
 180             nb_frames++;
 181         } else {
 182             break;
 183         }
 184     }
 185
 186     /* GIF format operates with time in "hundredths of second",
 187      * therefore timebase is 1/100 */
 188     avpriv_set_pts_info(st, 64, 1, 100);
 189     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 190     st->codecpar->codec_id   = AV_CODEC_ID_GIF;
 191     st->codecpar->width      = width;
 192     st->codecpar->height     = height;
 193     st->start_time           = 0;
 194     st->duration             = duration;
 195     st->nb_frames            = nb_frames;
 196     if (n) {
 197         st->codecpar->sample_aspect_ratio.num = n + 15;
 198         st->codecpar->sample_aspect_ratio.den = 64;
 199     }
 200
 201     /* jump to start because gif decoder needs header data too */
 202     if (avio_seek(pb, 0, SEEK_SET) != 0)
 203         return AVERROR(EIO);
 204
 205     return 0;
 206 }
 207
 208 static int gif_read_ext(AVFormatContext *s)
 209 {
 210     GIFDemuxContext *gdc = s->priv_data;
 211     AVIOContext *pb = s->pb;
 212     int sb_size, ext_label = avio_r8(pb);
 213     int ret;
 214
 215     if (ext_label == GIF_GCE_EXT_LABEL) {
 216         if ((sb_size = avio_r8(pb)) < 4) {
 217             av_log(s, AV_LOG_FATAL, "Graphic Control Extension block's size less than 4.\n");
 218             return AVERROR_INVALIDDATA;
 219         }
 220
 221         /* skip packed fields */
 222         if ((ret = avio_skip(pb, 1)) < 0)
 223             return ret;
 224
 225         gdc->delay = avio_rl16(pb);
 226
 227         if (gdc->delay < gdc->min_delay)
 228             gdc->delay = gdc->default_delay;
 229         gdc->delay = FFMIN(gdc->delay, gdc->max_delay);
 230
 231         /* skip the rest of the Graphic Control Extension block */
 232         if ((ret = avio_skip(pb, sb_size - 3)) < 0 )
 233             return ret;
 234     } else if (ext_label == GIF_APP_EXT_LABEL) {
 235         uint8_t data[256];
 236
 237         sb_size = avio_r8(pb);
 238         ret = avio_read(pb, data, sb_size);
 239         if (ret < 0 || !sb_size)
 240             return ret;
 241
 242         if (sb_size == strlen(NETSCAPE_EXT_STR)) {
 243             sb_size = avio_r8(pb);
 244             ret = avio_read(pb, data, sb_size);
 245             if (ret < 0 || !sb_size)
 246                 return ret;
 247
 248             if (sb_size == 3 && data[0] == 1) {
 249                 gdc->total_iter = AV_RL16(data+1);
 250
 251                 if (gdc->total_iter == 0)
 252                     gdc->total_iter = -1;
 253             }
 254         }
 255     }
 256
 257     if ((ret = gif_skip_subblocks(pb)) < 0)
 258         return ret;
 259
 260     return 0;
 261 }
 262
 263 static int gif_read_packet(AVFormatContext *s, AVPacket *pkt)
 264 {
 265     GIFDemuxContext *gdc = s->priv_data;
 266     AVIOContext *pb = s->pb;
 267     int packed_fields, block_label, ct_size,
 268         keyframe, frame_parsed = 0, ret;
 269     int64_t frame_start = avio_tell(pb), frame_end;
 270     unsigned char buf[6];
 271
 272     if ((ret = avio_read(pb, buf, 6)) == 6) {
 273         keyframe = memcmp(buf, gif87a_sig, 6) == 0 ||
 274                    memcmp(buf, gif89a_sig, 6) == 0;
 275     } else if (ret < 0) {
 276         return ret;
 277     } else {
 278         keyframe = 0;
 279     }
 280
 281     if (keyframe) {
 282 parse_keyframe:
 283         /* skip 2 bytes of width and 2 of height */
 284         if ((ret = avio_skip(pb, 4)) < 0)
 285             return ret;
 286
 287         packed_fields = avio_r8(pb);
 288
 289         /* skip 1 byte of Background Color Index and 1 byte of Pixel Aspect Ratio */
 290         if ((ret = avio_skip(pb, 2)) < 0)
 291             return ret;
 292
 293         /* global color table presence */
 294         if (packed_fields & 0x80) {
 295             ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
 296
 297             if ((ret = avio_skip(pb, ct_size)) < 0)
 298                 return ret;
 299         }
 300     } else {
 301         avio_seek(pb, -ret, SEEK_CUR);
 302         ret = AVERROR_EOF;
 303     }
 304
 305     while (GIF_TRAILER != (block_label = avio_r8(pb)) && !avio_feof(pb)) {
 306         if (block_label == GIF_EXTENSION_INTRODUCER) {
 307             if ((ret = gif_read_ext (s)) < 0 )
 308                 goto resync;
 309         } else if (block_label == GIF_IMAGE_SEPARATOR) {
 310             /* skip to last byte of Image Descriptor header */
 311             if ((ret = avio_skip(pb, 8)) < 0)
 312                 return ret;
 313
 314             packed_fields = avio_r8(pb);
 315
 316             /* local color table presence */
 317             if (packed_fields & 0x80) {
 318                 ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
 319
 320                 if ((ret = avio_skip(pb, ct_size)) < 0)
 321                     return ret;
 322             }
 323
 324             /* read LZW Minimum Code Size */
 325             if (avio_r8(pb) < 1) {
 326                 av_log(s, AV_LOG_ERROR, "lzw minimum code size must be >= 1\n");
 327                 goto resync;
 328             }
 329
 330             if ((ret = gif_skip_subblocks(pb)) < 0)
 331                 goto resync;
 332
 333             frame_end = avio_tell(pb);
 334
 335             if (avio_seek(pb, frame_start, SEEK_SET) != frame_start)
 336                 return AVERROR(EIO);
 337
 338             ret = av_get_packet(pb, pkt, frame_end - frame_start);
 339             if (ret < 0)
 340                 return ret;
 341
 342             if (keyframe)
 343                 pkt->flags |= AV_PKT_FLAG_KEY;
 344
 345             pkt->stream_index = 0;
 346             pkt->duration = gdc->delay;
 347
 348             gdc->nb_frames ++;
 349             gdc->last_duration = pkt->duration;
 350
 351             /* Graphic Control Extension's scope is single frame.
 352              * Remove its influence. */
 353             gdc->delay = gdc->default_delay;
 354             frame_parsed = 1;
 355
 356             break;
 357         } else {
 358             av_log(s, AV_LOG_ERROR, "invalid block label\n");
 359 resync:
 360             if (!keyframe)
 361                 avio_seek(pb, frame_start, SEEK_SET);
 362             if ((ret = resync(pb)) < 0)
 363                 return ret;
 364             frame_start = avio_tell(pb) - 6;
 365             keyframe = 1;
 366             goto parse_keyframe;
 367         }
 368     }
 369
 370     if ((ret >= 0 && !frame_parsed) || ret == AVERROR_EOF) {
 371         if (gdc->nb_frames == 1) {
 372             s->streams[0]->r_frame_rate = (AVRational) {100, gdc->last_duration};
 373         }
 374         /* This might happen when there is no image block
 375          * between extension blocks and GIF_TRAILER or EOF */
 376         if (!gdc->ignore_loop && (block_label == GIF_TRAILER || avio_feof(pb))
 377             && (gdc->total_iter < 0 || ++gdc->iter_count < gdc->total_iter))
 378             return avio_seek(pb, 0, SEEK_SET);
 379         return AVERROR_EOF;
 380     } else
 381         return ret;
 382 }
 383
 384 static const AVOption options[] = {
 385     { "min_delay"    , "minimum valid delay between frames (in hundredths of second)", offsetof(GIFDemuxContext, min_delay)    , AV_OPT_TYPE_INT, {.i64 = GIF_MIN_DELAY}    , 0, 100 * 60, AV_OPT_FLAG_DECODING_PARAM },
 386     { "max_gif_delay", "maximum valid delay between frames (in hundredths of seconds)", offsetof(GIFDemuxContext, max_delay)   , AV_OPT_TYPE_INT, {.i64 = 65535}            , 0, 65535   , AV_OPT_FLAG_DECODING_PARAM },
 387     { "default_delay", "default delay between frames (in hundredths of second)"      , offsetof(GIFDemuxContext, default_delay), AV_OPT_TYPE_INT, {.i64 = GIF_DEFAULT_DELAY}, 0, 100 * 60, AV_OPT_FLAG_DECODING_PARAM },
 388     { "ignore_loop"  , "ignore loop setting (netscape extension)"                    , offsetof(GIFDemuxContext, ignore_loop)  , AV_OPT_TYPE_BOOL,{.i64 = 1}                , 0,        1, AV_OPT_FLAG_DECODING_PARAM },
 389     { NULL },
 390 };
 391
 392 static const AVClass demuxer_class = {
 393     .class_name = "GIF demuxer",
 394     .item_name  = av_default_item_name,
 395     .option     = options,
 396     .version    = LIBAVUTIL_VERSION_INT,
 397     .category   = AV_CLASS_CATEGORY_DEMUXER,
 398 };
 399
 400 AVInputFormat ff_gif_demuxer = {
 401     .name           = "gif",
 402     .long_name      = NULL_IF_CONFIG_SMALL("CompuServe Graphics Interchange Format (GIF)"),
 403     .priv_data_size = sizeof(GIFDemuxContext),
 404     .read_probe     = gif_probe,
 405     .read_header    = gif_read_header,
 406     .read_packet    = gif_read_packet,
 407     .flags          = AVFMT_GENERIC_INDEX,
 408     .priv_class     = &demuxer_class,
 409 };