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
gif_probe(const AVProbeData * p)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
resync(AVIOContext * pb)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
gif_skip_subblocks(AVIOContext * pb)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
gif_read_header(AVFormatContext * s)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
gif_read_ext(AVFormatContext * s)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
gif_read_packet(AVFormatContext * s,AVPacket * pkt)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 };
410