undo file modifiers that suck in
[ffmpeg.git] / 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/intreadwrite.h"
29 #include "libavutil/opt.h"
30 #include "internal.h"
31 #include "libavcodec/gif.h"
32
33 typedef struct GIFDemuxContext {
34     const AVClass *class;
35     uint32_t width;
36     uint32_t height;
37     /**
38      * Time span in hundredths of second before
39      * the next frame should be drawn on screen.
40      */
41     int delay;
42     /**
43      * Minimum allowed delay between frames in hundredths of
44      * second. Values below this threshold considered to be
45      * invalid and set to value of default_delay.
46      */
47     int min_delay;
48     int default_delay;
49     int total_duration; ///< In hundredths of second.
50     int frame_idx;
51 } GIFDemuxContext;
52
53 /**
54  * Major web browsers display gifs at ~10-15fps when rate
55  * is not explicitly set or have too low values. We assume default rate to be 10.
56  * Default delay = 100hundredths of second / 10fps = 10hos per frame.
57  */
58 #define GIF_DEFAULT_DELAY   10
59 /**
60  * By default delay values less than this threshold considered to be invalid.
61  */
62 #define GIF_MIN_DELAY       2
63
64 static int gif_probe(AVProbeData *p)
65 {
66     /* check magick */
67     if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
68         return 0;
69
70     /* width or height contains zero? */
71     if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
72         return 0;
73
74     return AVPROBE_SCORE_MAX;
75 }
76
77 static int gif_read_header(AVFormatContext *s)
78 {
79     GIFDemuxContext *gdc = s->priv_data;
80     AVIOContext     *pb  = s->pb;
81     AVStream        *st;
82     int ret;
83
84     /* skip 6-byte magick */
85     if ((ret = avio_skip(pb, 6)) < 0)
86         return ret;
87
88     gdc->delay  = gdc->default_delay;
89     gdc->width  = avio_rl16(pb);
90     gdc->height = avio_rl16(pb);
91
92     if (gdc->width == 0 || gdc->height == 0)
93         return AVERROR_INVALIDDATA;
94
95     st = avformat_new_stream(s, NULL);
96     if (!st)
97         return AVERROR(ENOMEM);
98
99     /* GIF format operates with time in "hundredths of second",
100      * therefore timebase is 1/100 */
101     avpriv_set_pts_info(st, 64, 1, 100);
102     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
103     st->codec->codec_id   = AV_CODEC_ID_GIF;
104     st->codec->width      = gdc->width;
105     st->codec->height     = gdc->height;
106
107     /* jump to start because gif decoder needs header data too */
108     if (avio_seek(pb, 0, SEEK_SET) != 0)
109         return AVERROR(EIO);
110
111     return 0;
112 }
113
114 static int gif_skip_subblocks(AVIOContext *pb)
115 {
116     int sb_size, ret = 0;
117
118     while (0x00 != (sb_size = avio_r8(pb))) {
119         if ((ret = avio_skip(pb, sb_size)) < 0)
120             return ret;
121     }
122
123     return ret;
124 }
125
126 static int gif_read_ext(AVFormatContext *s)
127 {
128     GIFDemuxContext *gdc = s->priv_data;
129     AVIOContext *pb = s->pb;
130     int sb_size, ext_label = avio_r8(pb);
131     int ret;
132
133     if (ext_label == GIF_GCE_EXT_LABEL) {
134         if ((sb_size = avio_r8(pb)) < 4) {
135             av_log(s, AV_LOG_FATAL, "Graphic Control Extension block's size less than 4.\n");
136             return AVERROR_INVALIDDATA;
137         }
138
139         /* skip packed fields */
140         if ((ret = avio_skip(pb, 1)) < 0)
141             return ret;
142
143         gdc->delay = avio_rl16(pb);
144
145         if (gdc->delay < gdc->min_delay)
146             gdc->delay = gdc->default_delay;
147
148         /* skip the rest of the Graphic Control Extension block */
149         if ((ret = avio_skip(pb, sb_size - 3)) < 0 )
150             return ret;
151     }
152
153     if ((ret = gif_skip_subblocks(pb)) < 0)
154         return ret;
155
156     return 0;
157 }
158
159 static int gif_read_packet(AVFormatContext *s, AVPacket *pkt)
160 {
161     GIFDemuxContext *gdc = s->priv_data;
162     AVIOContext *pb = s->pb;
163     int packed_fields, block_label, ct_size,
164         keyframe, frame_parsed = 0, ret;
165     int64_t frame_start = avio_tell(pb), frame_end;
166     unsigned char buf[6];
167
168     if ((ret = avio_read(pb, buf, 6)) == 6) {
169         keyframe = memcmp(buf, gif87a_sig, 6) == 0 ||
170                    memcmp(buf, gif89a_sig, 6) == 0;
171     } else if (ret < 0) {
172         return ret;
173     } else {
174         keyframe = 0;
175     }
176
177     if (keyframe) {
178         /* skip 2 bytes of width and 2 of height */
179         if ((ret = avio_skip(pb, 4)) < 0)
180             return ret;
181
182         packed_fields = avio_r8(pb);
183
184         /* skip 1 byte of Background Color Index and 1 byte of Pixel Aspect Ratio */
185         if ((ret = avio_skip(pb, 2)) < 0)
186             return ret;
187
188         /* glogal color table presence */
189         if (packed_fields & 0x80) {
190             ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
191
192             if ((ret = avio_skip(pb, ct_size)) < 0)
193                 return ret;
194         }
195
196         gdc->total_duration = 0;
197         gdc->frame_idx      = 0;
198     } else {
199         avio_seek(pb, -ret, SEEK_CUR);
200         ret = AVERROR_EOF;
201     }
202
203     while (GIF_TRAILER != (block_label = avio_r8(pb)) && !url_feof(pb)) {
204         if (block_label == GIF_EXTENSION_INTRODUCER) {
205             if ((ret = gif_read_ext (s)) < 0 )
206                 return ret;
207         } else if (block_label == GIF_IMAGE_SEPARATOR) {
208             /* skip to last byte of Image Descriptor header */
209             if ((ret = avio_skip(pb, 8)) < 0)
210                 return ret;
211
212             packed_fields = avio_r8(pb);
213
214             /* local color table presence */
215             if (packed_fields & 0x80) {
216                 ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
217
218                 if ((ret = avio_skip(pb, ct_size)) < 0)
219                     return ret;
220             }
221
222             /* read LZW Minimum Code Size */
223             if (avio_r8(pb) < 1) {
224                 av_log(s, AV_LOG_ERROR, "lzw minimum code size must be >= 1\n");
225                 return AVERROR_INVALIDDATA;
226             }
227
228             if ((ret = gif_skip_subblocks(pb)) < 0)
229                 return ret;
230
231             frame_end = avio_tell(pb);
232
233             if (avio_seek(pb, frame_start, SEEK_SET) != frame_start)
234                 return AVERROR(EIO);
235
236             ret = av_get_packet(pb, pkt, frame_end - frame_start);
237             if (ret < 0)
238                 return ret;
239
240             if (keyframe)
241                 pkt->flags |= AV_PKT_FLAG_KEY;
242
243             pkt->stream_index = 0;
244             pkt->pts = gdc->total_duration;
245             gdc->total_duration += gdc->delay;
246             pkt->duration = gdc->delay;
247             pkt->dts = gdc->frame_idx;
248
249             /* Graphic Control Extension's scope is single frame.
250              * Remove its influence. */
251             gdc->delay = gdc->default_delay;
252             gdc->frame_idx++;
253             frame_parsed = 1;
254
255             break;
256         } else {
257             av_log(s, AV_LOG_ERROR, "invalid block label\n");
258             return AVERROR_INVALIDDATA;
259         }
260     }
261
262     if (ret >= 0 && !frame_parsed) {
263         /* This might happen when there is no image block
264          * between extension blocks and GIF_TRAILER or EOF */
265         return  AVERROR_EOF;
266     } else
267         return ret;
268 }
269
270 static const AVOption options[] = {
271     { "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 },
272     { "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 },
273     { NULL },
274 };
275
276 static const AVClass demuxer_class = {
277     .class_name = "GIF demuxer",
278     .item_name  = av_default_item_name,
279     .option     = options,
280     .version    = LIBAVUTIL_VERSION_INT,
281     .category   = AV_CLASS_CATEGORY_DEMUXER,
282 };
283
284 AVInputFormat ff_gif_demuxer = {
285     .name           = "gif",
286     .long_name      = NULL_IF_CONFIG_SMALL("CompuServe Graphics Interchange Format (GIF)"),
287     .priv_data_size = sizeof(GIFDemuxContext),
288     .read_probe     = gif_probe,
289     .read_header    = gif_read_header,
290     .read_packet    = gif_read_packet,
291     .priv_class     = &demuxer_class,
292 };