FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gifdec.c
Go to the documentation of this file.
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  /**
36  * Time span in hundredths of second before
37  * the next frame should be drawn on screen.
38  */
39  int delay;
40  /**
41  * Minimum allowed delay between frames in hundredths of
42  * second. Values below this threshold considered to be
43  * invalid and set to value of default_delay.
44  */
45  int min_delay;
46  int max_delay;
48 
49  /**
50  * loop options
51  */
55 
56  int nb_frames;
59 
60 /**
61  * Major web browsers display gifs at ~10-15fps when rate
62  * is not explicitly set or have too low values. We assume default rate to be 10.
63  * Default delay = 100hundredths of second / 10fps = 10hos per frame.
64  */
65 #define GIF_DEFAULT_DELAY 10
66 /**
67  * By default delay values less than this threshold considered to be invalid.
68  */
69 #define GIF_MIN_DELAY 2
70 
71 static int gif_probe(AVProbeData *p)
72 {
73  /* check magick */
74  if (memcmp(p->buf, gif87a_sig, 6) && memcmp(p->buf, gif89a_sig, 6))
75  return 0;
76 
77  /* width or height contains zero? */
78  if (!AV_RL16(&p->buf[6]) || !AV_RL16(&p->buf[8]))
79  return 0;
80 
81  return AVPROBE_SCORE_MAX;
82 }
83 
84 static int resync(AVIOContext *pb)
85 {
86  int i;
87  for (i = 0; i < 6; i++) {
88  int b = avio_r8(pb);
89  if (b != gif87a_sig[i] && b != gif89a_sig[i])
90  i = -(b != 'G');
91  if (avio_feof(pb))
92  return AVERROR_EOF;
93  }
94  return 0;
95 }
96 
98 {
99  GIFDemuxContext *gdc = s->priv_data;
100  AVIOContext *pb = s->pb;
101  AVStream *st;
102  int width, height, ret;
103 
104  if ((ret = resync(pb)) < 0)
105  return ret;
106 
107  gdc->delay = gdc->default_delay;
108  width = avio_rl16(pb);
109  height = avio_rl16(pb);
110 
111  if (width == 0 || height == 0)
112  return AVERROR_INVALIDDATA;
113 
114  st = avformat_new_stream(s, NULL);
115  if (!st)
116  return AVERROR(ENOMEM);
117 
118  /* GIF format operates with time in "hundredths of second",
119  * therefore timebase is 1/100 */
120  avpriv_set_pts_info(st, 64, 1, 100);
123  st->codecpar->width = width;
124  st->codecpar->height = height;
125 
126  /* jump to start because gif decoder needs header data too */
127  if (avio_seek(pb, 0, SEEK_SET) != 0)
128  return AVERROR(EIO);
129 
130  return 0;
131 }
132 
134 {
135  int sb_size, ret = 0;
136 
137  while (0x00 != (sb_size = avio_r8(pb))) {
138  if ((ret = avio_skip(pb, sb_size)) < 0)
139  return ret;
140  }
141 
142  return ret;
143 }
144 
146 {
147  GIFDemuxContext *gdc = s->priv_data;
148  AVIOContext *pb = s->pb;
149  int sb_size, ext_label = avio_r8(pb);
150  int ret;
151 
152  if (ext_label == GIF_GCE_EXT_LABEL) {
153  if ((sb_size = avio_r8(pb)) < 4) {
154  av_log(s, AV_LOG_FATAL, "Graphic Control Extension block's size less than 4.\n");
155  return AVERROR_INVALIDDATA;
156  }
157 
158  /* skip packed fields */
159  if ((ret = avio_skip(pb, 1)) < 0)
160  return ret;
161 
162  gdc->delay = avio_rl16(pb);
163 
164  if (gdc->delay < gdc->min_delay)
165  gdc->delay = gdc->default_delay;
166  gdc->delay = FFMIN(gdc->delay, gdc->max_delay);
167 
168  /* skip the rest of the Graphic Control Extension block */
169  if ((ret = avio_skip(pb, sb_size - 3)) < 0 )
170  return ret;
171  } else if (ext_label == GIF_APP_EXT_LABEL) {
172  uint8_t data[256];
173 
174  sb_size = avio_r8(pb);
175  ret = avio_read(pb, data, sb_size);
176  if (ret < 0 || !sb_size)
177  return ret;
178 
179  if (sb_size == strlen(NETSCAPE_EXT_STR)) {
180  sb_size = avio_r8(pb);
181  ret = avio_read(pb, data, sb_size);
182  if (ret < 0 || !sb_size)
183  return ret;
184 
185  if (sb_size == 3 && data[0] == 1) {
186  gdc->total_iter = AV_RL16(data+1);
187 
188  if (gdc->total_iter == 0)
189  gdc->total_iter = -1;
190  }
191  }
192  }
193 
194  if ((ret = gif_skip_subblocks(pb)) < 0)
195  return ret;
196 
197  return 0;
198 }
199 
201 {
202  GIFDemuxContext *gdc = s->priv_data;
203  AVIOContext *pb = s->pb;
204  int packed_fields, block_label, ct_size,
205  keyframe, frame_parsed = 0, ret;
206  int64_t frame_start = avio_tell(pb), frame_end;
207  unsigned char buf[6];
208 
209  if ((ret = avio_read(pb, buf, 6)) == 6) {
210  keyframe = memcmp(buf, gif87a_sig, 6) == 0 ||
211  memcmp(buf, gif89a_sig, 6) == 0;
212  } else if (ret < 0) {
213  return ret;
214  } else {
215  keyframe = 0;
216  }
217 
218  if (keyframe) {
219 parse_keyframe:
220  /* skip 2 bytes of width and 2 of height */
221  if ((ret = avio_skip(pb, 4)) < 0)
222  return ret;
223 
224  packed_fields = avio_r8(pb);
225 
226  /* skip 1 byte of Background Color Index and 1 byte of Pixel Aspect Ratio */
227  if ((ret = avio_skip(pb, 2)) < 0)
228  return ret;
229 
230  /* global color table presence */
231  if (packed_fields & 0x80) {
232  ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
233 
234  if ((ret = avio_skip(pb, ct_size)) < 0)
235  return ret;
236  }
237  } else {
238  avio_seek(pb, -ret, SEEK_CUR);
239  ret = AVERROR_EOF;
240  }
241 
242  while (GIF_TRAILER != (block_label = avio_r8(pb)) && !avio_feof(pb)) {
243  if (block_label == GIF_EXTENSION_INTRODUCER) {
244  if ((ret = gif_read_ext (s)) < 0 )
245  goto resync;
246  } else if (block_label == GIF_IMAGE_SEPARATOR) {
247  /* skip to last byte of Image Descriptor header */
248  if ((ret = avio_skip(pb, 8)) < 0)
249  return ret;
250 
251  packed_fields = avio_r8(pb);
252 
253  /* local color table presence */
254  if (packed_fields & 0x80) {
255  ct_size = 3 * (1 << ((packed_fields & 0x07) + 1));
256 
257  if ((ret = avio_skip(pb, ct_size)) < 0)
258  return ret;
259  }
260 
261  /* read LZW Minimum Code Size */
262  if (avio_r8(pb) < 1) {
263  av_log(s, AV_LOG_ERROR, "lzw minimum code size must be >= 1\n");
264  goto resync;
265  }
266 
267  if ((ret = gif_skip_subblocks(pb)) < 0)
268  goto resync;
269 
270  frame_end = avio_tell(pb);
271 
272  if (avio_seek(pb, frame_start, SEEK_SET) != frame_start)
273  return AVERROR(EIO);
274 
275  ret = av_get_packet(pb, pkt, frame_end - frame_start);
276  if (ret < 0)
277  return ret;
278 
279  if (keyframe)
280  pkt->flags |= AV_PKT_FLAG_KEY;
281 
282  pkt->stream_index = 0;
283  pkt->duration = gdc->delay;
284 
285  gdc->nb_frames ++;
286  gdc->last_duration = pkt->duration;
287 
288  /* Graphic Control Extension's scope is single frame.
289  * Remove its influence. */
290  gdc->delay = gdc->default_delay;
291  frame_parsed = 1;
292 
293  break;
294  } else {
295  av_log(s, AV_LOG_ERROR, "invalid block label\n");
296 resync:
297  if (!keyframe)
298  avio_seek(pb, frame_start, SEEK_SET);
299  if ((ret = resync(pb)) < 0)
300  return ret;
301  frame_start = avio_tell(pb) - 6;
302  keyframe = 1;
303  goto parse_keyframe;
304  }
305  }
306 
307  if ((ret >= 0 && !frame_parsed) || ret == AVERROR_EOF) {
308  if (gdc->nb_frames == 1) {
309  s->streams[0]->r_frame_rate = (AVRational) {100, gdc->last_duration};
310  }
311  /* This might happen when there is no image block
312  * between extension blocks and GIF_TRAILER or EOF */
313  if (!gdc->ignore_loop && (block_label == GIF_TRAILER || avio_feof(pb))
314  && (gdc->total_iter < 0 || ++gdc->iter_count < gdc->total_iter))
315  return avio_seek(pb, 0, SEEK_SET);
316  return AVERROR_EOF;
317  } else
318  return ret;
319 }
320 
321 static const AVOption options[] = {
322  { "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 },
323  { "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 },
324  { "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 },
325  { "ignore_loop" , "ignore loop setting (netscape extension)" , offsetof(GIFDemuxContext, ignore_loop) , AV_OPT_TYPE_BOOL,{.i64 = 1} , 0, 1, AV_OPT_FLAG_DECODING_PARAM },
326  { NULL },
327 };
328 
329 static const AVClass demuxer_class = {
330  .class_name = "GIF demuxer",
331  .item_name = av_default_item_name,
332  .option = options,
333  .version = LIBAVUTIL_VERSION_INT,
334  .category = AV_CLASS_CATEGORY_DEMUXER,
335 };
336 
338  .name = "gif",
339  .long_name = NULL_IF_CONFIG_SMALL("CompuServe Graphics Interchange Format (GIF)"),
340  .priv_data_size = sizeof(GIFDemuxContext),
345  .priv_class = &demuxer_class,
346 };
#define NULL
Definition: coverity.c:32
static int gif_read_header(AVFormatContext *s)
Definition: gifdec.c:97
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int default_delay
Definition: gifdec.c:47
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static const AVOption options[]
Definition: gifdec.c:321
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4581
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3981
const char * b
Definition: vf_curves.c:113
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
static const uint8_t gif87a_sig[6]
Definition: gif.h:34
#define GIF_GCE_EXT_LABEL
Definition: gif.h:45
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:304
static AVPacket pkt
int nb_frames
Definition: gifdec.c:56
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
Format I/O context.
Definition: avformat.h:1338
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
uint8_t
int width
Video only.
Definition: avcodec.h:4047
AVOptions.
int iter_count
Definition: gifdec.c:53
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1619
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4214
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1406
#define height
static int flags
Definition: log.c:57
#define AVERROR_EOF
End of file.
Definition: error.h:55
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:289
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:511
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:604
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1633
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
int last_duration
Definition: gifdec.c:57
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3977
static int max_delay(struct NCSofa *sofa)
Definition: af_sofalizer.c:507
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1607
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:595
static void frame_end(MpegEncContext *s)
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:463
#define GIF_IMAGE_SEPARATOR
Definition: gif.h:44
static int gif_skip_subblocks(AVIOContext *pb)
Definition: gifdec.c:133
int min_delay
Minimum allowed delay between frames in hundredths of second.
Definition: gifdec.c:45
static const AVClass demuxer_class
Definition: gifdec.c:329
#define FFMIN(a, b)
Definition: common.h:96
int ignore_loop
Definition: gifdec.c:54
#define width
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
#define GIF_APP_EXT_LABEL
Definition: gif.h:46
AVInputFormat ff_gif_demuxer
Definition: gifdec.c:337
#define GIF_EXTENSION_INTRODUCER
Definition: gif.h:43
static int gif_probe(AVProbeData *p)
Definition: gifdec.c:71
static int gif_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gifdec.c:200
int max_delay
Definition: gifdec.c:46
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:514
Stream structure.
Definition: avformat.h:889
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static int resync(AVIOContext *pb)
Definition: gifdec.c:84
AVIOContext * pb
I/O context.
Definition: avformat.h:1380
GIF format definitions.
static int frame_start(MpegEncContext *s)
int total_iter
loop options
Definition: gifdec.c:52
void * buf
Definition: avisynth_c.h:690
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:487
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int delay
Time span in hundredths of second before the next frame should be drawn on screen.
Definition: gifdec.c:39
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
#define GIF_TRAILER
Definition: gif.h:42
This structure contains the data a format has to probe a file.
Definition: avformat.h:461
static int gif_read_ext(AVFormatContext *s)
Definition: gifdec.c:145
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:473
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:710
Main libavformat public API header.
#define NETSCAPE_EXT_STR
Definition: gif.h:47
static const uint8_t gif89a_sig[6]
Definition: gif.h:35
#define GIF_DEFAULT_DELAY
Major web browsers display gifs at ~10-15fps when rate is not explicitly set or have too low values...
Definition: gifdec.c:65
void * priv_data
Format private data.
Definition: avformat.h:1366
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:664
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
AVCodecParameters * codecpar
Definition: avformat.h:1241
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:328
int stream_index
Definition: avcodec.h:1603
#define GIF_MIN_DELAY
By default delay values less than this threshold considered to be invalid.
Definition: gifdec.c:69
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1103
This structure stores compressed data.
Definition: avcodec.h:1578