lavf: Constify the probe function argument.
[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/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, -1);
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 };