FFmpeg
gif.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2000 Fabrice Bellard
3  * Copyright (c) 2002 Francois Revol
4  * Copyright (c) 2006 Baptiste Coudurier
5  * Copyright (c) 2018 Bjorn Roche
6  * Copyright (c) 2018 Paul B Mahol
7  *
8  * first version by Francois Revol <revol@free.fr>
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 /**
28  * @file
29  * GIF encoder
30  * @see http://www.w3.org/Graphics/GIF/spec-gif89a.txt
31  */
32 
33 #define BITSTREAM_WRITER_LE
34 #include "libavutil/opt.h"
35 #include "libavutil/imgutils.h"
36 #include "avcodec.h"
37 #include "bytestream.h"
38 #include "internal.h"
39 #include "lzw.h"
40 #include "gif.h"
41 
42 #include "put_bits.h"
43 
44 #define DEFAULT_TRANSPARENCY_INDEX 0x1f
45 
46 typedef struct GIFContext {
47  const AVClass *class;
51  int buf_size;
53  int flags;
54  int image;
56  uint32_t palette[AVPALETTE_COUNT]; ///< local reference palette for !pal8
59  uint8_t *tmpl; ///< temporary line buffer
60 } GIFContext;
61 
62 enum {
63  GF_OFFSETTING = 1<<0,
64  GF_TRANSDIFF = 1<<1,
65 };
66 
67 static void shrink_palette(const uint32_t *src, uint8_t *map,
68  uint32_t *dst, size_t *palette_count)
69 {
70  size_t colors_seen = 0;
71 
72  for (size_t i = 0; i < AVPALETTE_COUNT; i++) {
73  int seen = 0;
74  for (size_t c = 0; c < colors_seen; c++) {
75  if (src[i] == dst[c]) {
76  seen = 1;
77  break;
78  }
79  }
80  if (!seen) {
81  dst[colors_seen] = src[i];
82  map[i] = colors_seen;
83  colors_seen++;
84  }
85  }
86 
87  *palette_count = colors_seen;
88 }
89 
90 static void remap_frame_to_palette(const uint8_t *src, int src_linesize,
91  uint8_t *dst, int dst_linesize,
92  int w, int h, uint8_t *map)
93 {
94  for (int i = 0; i < h; i++)
95  for (int j = 0; j < w; j++)
96  dst[i * dst_linesize + j] = map[src[i * src_linesize + j]];
97 }
98 
100  const uint8_t *buf, const int linesize)
101 {
102  GIFContext *s = avctx->priv_data;
103  int trans = s->transparent_index;
104 
105  if (trans < 0)
106  return 0;
107 
108  for (int y = 0; y < avctx->height; y++) {
109  for (int x = 0; x < avctx->width; x++) {
110  if (buf[x] == trans) {
111  return 1;
112  }
113  }
114  buf += linesize;
115  }
116 
117  return 0;
118 }
119 
120 static int get_palette_transparency_index(const uint32_t *palette)
121 {
122  int transparent_color_index = -1;
123  unsigned i, smallest_alpha = 0xff;
124 
125  if (!palette)
126  return -1;
127 
128  for (i = 0; i < AVPALETTE_COUNT; i++) {
129  const uint32_t v = palette[i];
130  if (v >> 24 < smallest_alpha) {
131  smallest_alpha = v >> 24;
132  transparent_color_index = i;
133  }
134  }
135  return smallest_alpha < 128 ? transparent_color_index : -1;
136 }
137 
138 static int pick_palette_entry(const uint8_t *buf, int linesize, int w, int h)
139 {
140  int histogram[AVPALETTE_COUNT] = {0};
141  int x, y, i;
142 
143  for (y = 0; y < h; y++) {
144  for (x = 0; x < w; x++)
145  histogram[buf[x]]++;
146  buf += linesize;
147  }
148  for (i = 0; i < FF_ARRAY_ELEMS(histogram); i++)
149  if (!histogram[i])
150  return i;
151  return -1;
152 }
153 
155  const uint8_t *buf, const int linesize,
156  int *width, int *height,
157  int *x_start, int *y_start)
158 {
159  GIFContext *s = avctx->priv_data;
160  int trans = s->transparent_index;
161 
162  /* Crop image */
163  if ((s->flags & GF_OFFSETTING) && trans >= 0) {
164  const int w = avctx->width;
165  const int h = avctx->height;
166  int x_end = w - 1,
167  y_end = h - 1;
168 
169  // crop top
170  while (*y_start < y_end) {
171  int is_trans = 1;
172  for (int i = 0; i < w; i++) {
173  if (buf[linesize * *y_start + i] != trans) {
174  is_trans = 0;
175  break;
176  }
177  }
178 
179  if (!is_trans)
180  break;
181  (*y_start)++;
182  }
183 
184  // crop bottom
185  while (y_end > *y_start) {
186  int is_trans = 1;
187  for (int i = 0; i < w; i++) {
188  if (buf[linesize * y_end + i] != trans) {
189  is_trans = 0;
190  break;
191  }
192  }
193  if (!is_trans)
194  break;
195  y_end--;
196  }
197 
198  // crop left
199  while (*x_start < x_end) {
200  int is_trans = 1;
201  for (int i = *y_start; i < y_end; i++) {
202  if (buf[linesize * i + *x_start] != trans) {
203  is_trans = 0;
204  break;
205  }
206  }
207  if (!is_trans)
208  break;
209  (*x_start)++;
210  }
211 
212  // crop right
213  while (x_end > *x_start) {
214  int is_trans = 1;
215  for (int i = *y_start; i < y_end; i++) {
216  if (buf[linesize * i + x_end] != trans) {
217  is_trans = 0;
218  break;
219  }
220  }
221  if (!is_trans)
222  break;
223  x_end--;
224  }
225 
226  *height = y_end + 1 - *y_start;
227  *width = x_end + 1 - *x_start;
228  av_log(avctx, AV_LOG_DEBUG,"%dx%d image at pos (%d;%d) [area:%dx%d]\n",
229  *width, *height, *x_start, *y_start, avctx->width, avctx->height);
230  }
231 }
232 
233 static void gif_crop_opaque(AVCodecContext *avctx,
234  const uint32_t *palette,
235  const uint8_t *buf, const int linesize,
236  int *width, int *height, int *x_start, int *y_start)
237 {
238  GIFContext *s = avctx->priv_data;
239 
240  /* Crop image */
241  if ((s->flags & GF_OFFSETTING) && s->last_frame && !palette) {
242  const uint8_t *ref = s->last_frame->data[0];
243  const int ref_linesize = s->last_frame->linesize[0];
244  int x_end = avctx->width - 1,
245  y_end = avctx->height - 1;
246 
247  /* skip common lines */
248  while (*y_start < y_end) {
249  if (memcmp(ref + *y_start*ref_linesize, buf + *y_start*linesize, *width))
250  break;
251  (*y_start)++;
252  }
253  while (y_end > *y_start) {
254  if (memcmp(ref + y_end*ref_linesize, buf + y_end*linesize, *width))
255  break;
256  y_end--;
257  }
258  *height = y_end + 1 - *y_start;
259 
260  /* skip common columns */
261  while (*x_start < x_end) {
262  int same_column = 1;
263  for (int y = *y_start; y <= y_end; y++) {
264  if (ref[y*ref_linesize + *x_start] != buf[y*linesize + *x_start]) {
265  same_column = 0;
266  break;
267  }
268  }
269  if (!same_column)
270  break;
271  (*x_start)++;
272  }
273  while (x_end > *x_start) {
274  int same_column = 1;
275  for (int y = *y_start; y <= y_end; y++) {
276  if (ref[y*ref_linesize + x_end] != buf[y*linesize + x_end]) {
277  same_column = 0;
278  break;
279  }
280  }
281  if (!same_column)
282  break;
283  x_end--;
284  }
285  *width = x_end + 1 - *x_start;
286 
287  av_log(avctx, AV_LOG_DEBUG,"%dx%d image at pos (%d;%d) [area:%dx%d]\n",
288  *width, *height, *x_start, *y_start, avctx->width, avctx->height);
289  }
290 }
291 
293  uint8_t **bytestream, uint8_t *end,
294  const uint32_t *palette,
295  const uint8_t *buf, const int linesize,
296  AVPacket *pkt)
297 {
298  GIFContext *s = avctx->priv_data;
299  int disposal, len = 0, height = avctx->height, width = avctx->width, x, y;
300  int x_start = 0, y_start = 0, trans = s->transparent_index;
301  int bcid = -1, honor_transparency = (s->flags & GF_TRANSDIFF) && s->last_frame && !palette;
302  const uint8_t *ptr;
303  uint32_t shrunk_palette[AVPALETTE_COUNT];
304  uint8_t map[AVPALETTE_COUNT] = { 0 };
305  size_t shrunk_palette_count = 0;
306 
307  /*
308  * We memset to 0xff instead of 0x00 so that the transparency detection
309  * doesn't pick anything after the palette entries as the transparency
310  * index, and because GIF89a requires us to always write a power-of-2
311  * number of palette entries.
312  */
313  memset(shrunk_palette, 0xff, AVPALETTE_SIZE);
314 
315  if (!s->image && is_image_translucent(avctx, buf, linesize)) {
316  gif_crop_translucent(avctx, buf, linesize, &width, &height, &x_start, &y_start);
317  honor_transparency = 0;
318  disposal = GCE_DISPOSAL_BACKGROUND;
319  } else {
320  gif_crop_opaque(avctx, palette, buf, linesize, &width, &height, &x_start, &y_start);
321  disposal = GCE_DISPOSAL_INPLACE;
322  }
323 
324  if (s->image || !avctx->frame_number) { /* GIF header */
325  const uint32_t *global_palette = palette ? palette : s->palette;
326  const AVRational sar = avctx->sample_aspect_ratio;
327  int64_t aspect = 0;
328 
329  if (sar.num > 0 && sar.den > 0) {
330  aspect = sar.num * 64LL / sar.den - 15;
331  if (aspect < 0 || aspect > 255)
332  aspect = 0;
333  }
334 
335  bytestream_put_buffer(bytestream, gif89a_sig, sizeof(gif89a_sig));
336  bytestream_put_le16(bytestream, avctx->width);
337  bytestream_put_le16(bytestream, avctx->height);
338 
339  bcid = get_palette_transparency_index(global_palette);
340 
341  bytestream_put_byte(bytestream, ((uint8_t) s->use_global_palette << 7) | 0x70 | (s->use_global_palette ? 7 : 0)); /* flags: global clut, 256 entries */
342  bytestream_put_byte(bytestream, bcid < 0 ? DEFAULT_TRANSPARENCY_INDEX : bcid); /* background color index */
343  bytestream_put_byte(bytestream, aspect);
344  if (s->use_global_palette) {
345  for (int i = 0; i < 256; i++) {
346  const uint32_t v = global_palette[i] & 0xffffff;
347  bytestream_put_be24(bytestream, v);
348  }
349  }
350  }
351 
352  if (honor_transparency && trans < 0) {
353  trans = pick_palette_entry(buf + y_start*linesize + x_start,
354  linesize, width, height);
355  if (trans < 0) // TODO, patch welcome
356  av_log(avctx, AV_LOG_DEBUG, "No available color, can not use transparency\n");
357  }
358 
359  if (trans < 0)
360  honor_transparency = 0;
361 
362  if (palette || !s->use_global_palette) {
363  const uint32_t *pal = palette ? palette : s->palette;
364  shrink_palette(pal, map, shrunk_palette, &shrunk_palette_count);
365  }
366 
367  bcid = honor_transparency || disposal == GCE_DISPOSAL_BACKGROUND ? trans : get_palette_transparency_index(palette);
368 
369  /* graphic control extension */
370  bytestream_put_byte(bytestream, GIF_EXTENSION_INTRODUCER);
371  bytestream_put_byte(bytestream, GIF_GCE_EXT_LABEL);
372  bytestream_put_byte(bytestream, 0x04); /* block size */
373  bytestream_put_byte(bytestream, disposal<<2 | (bcid >= 0));
374  bytestream_put_le16(bytestream, 5); // default delay
375  bytestream_put_byte(bytestream, bcid < 0 ? DEFAULT_TRANSPARENCY_INDEX : (shrunk_palette_count ? map[bcid] : bcid));
376  bytestream_put_byte(bytestream, 0x00);
377 
378  /* image block */
379  bytestream_put_byte(bytestream, GIF_IMAGE_SEPARATOR);
380  bytestream_put_le16(bytestream, x_start);
381  bytestream_put_le16(bytestream, y_start);
382  bytestream_put_le16(bytestream, width);
383  bytestream_put_le16(bytestream, height);
384 
385  if (palette || !s->use_global_palette) {
386  const uint32_t *pal = palette ? palette : s->palette;
387  unsigned pow2_count = av_log2(shrunk_palette_count - 1);
388  unsigned i;
389 
390  bytestream_put_byte(bytestream, 1<<7 | pow2_count); /* flags */
391  for (i = 0; i < 1 << (pow2_count + 1); i++) {
392  const uint32_t v = pal[i];
393  bytestream_put_be24(bytestream, v);
394  }
395  } else {
396  bytestream_put_byte(bytestream, 0x00); /* flags */
397  }
398 
399  bytestream_put_byte(bytestream, 0x08);
400 
401  ff_lzw_encode_init(s->lzw, s->buf, s->buf_size,
402  12, FF_LZW_GIF, 1);
403 
404  if (shrunk_palette_count) {
405  if (!s->shrunk_buf) {
406  s->shrunk_buf = av_malloc(avctx->height * linesize);
407  if (!s->shrunk_buf) {
408  av_log(avctx, AV_LOG_ERROR, "Could not allocated remapped frame buffer.\n");
409  return AVERROR(ENOMEM);
410  }
411  }
412  remap_frame_to_palette(buf, linesize, s->shrunk_buf, linesize, avctx->width, avctx->height, map);
413  ptr = s->shrunk_buf + y_start*linesize + x_start;
414  } else {
415  ptr = buf + y_start*linesize + x_start;
416  }
417  if (honor_transparency) {
418  const int ref_linesize = s->last_frame->linesize[0];
419  const uint8_t *ref = s->last_frame->data[0] + y_start*ref_linesize + x_start;
420 
421  for (y = 0; y < height; y++) {
422  memcpy(s->tmpl, ptr, width);
423  for (x = 0; x < width; x++)
424  if (ref[x] == ptr[x])
425  s->tmpl[x] = trans;
426  len += ff_lzw_encode(s->lzw, s->tmpl, width);
427  ptr += linesize;
428  ref += ref_linesize;
429  }
430  } else {
431  for (y = 0; y < height; y++) {
432  len += ff_lzw_encode(s->lzw, ptr, width);
433  ptr += linesize;
434  }
435  }
436  len += ff_lzw_encode_flush(s->lzw);
437 
438  ptr = s->buf;
439  while (len > 0) {
440  int size = FFMIN(255, len);
441  bytestream_put_byte(bytestream, size);
442  if (end - *bytestream < size)
443  return -1;
444  bytestream_put_buffer(bytestream, ptr, size);
445  ptr += size;
446  len -= size;
447  }
448  bytestream_put_byte(bytestream, 0x00); /* end of image block */
449  return 0;
450 }
451 
453 {
454  GIFContext *s = avctx->priv_data;
455 
456  if (avctx->width > 65535 || avctx->height > 65535) {
457  av_log(avctx, AV_LOG_ERROR, "GIF does not support resolutions above 65535x65535\n");
458  return AVERROR(EINVAL);
459  }
460 
461  s->transparent_index = -1;
462 
464  s->buf_size = avctx->width*avctx->height*2 + 1000;
465  s->buf = av_malloc(s->buf_size);
466  s->tmpl = av_malloc(avctx->width);
467  if (!s->tmpl || !s->buf || !s->lzw)
468  return AVERROR(ENOMEM);
469 
470  if (avpriv_set_systematic_pal2(s->palette, avctx->pix_fmt) < 0)
472 
473  return 0;
474 }
475 
477  const AVFrame *pict, int *got_packet)
478 {
479  GIFContext *s = avctx->priv_data;
480  uint8_t *outbuf_ptr, *end;
481  const uint32_t *palette = NULL;
482  int ret;
483 
484  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*7/5 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
485  return ret;
486  outbuf_ptr = pkt->data;
487  end = pkt->data + pkt->size;
488 
489  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
490  palette = (uint32_t*)pict->data[1];
491 
492  if (!s->palette_loaded) {
493  memcpy(s->palette, palette, AVPALETTE_SIZE);
495  s->palette_loaded = 1;
496  } else if (!memcmp(s->palette, palette, AVPALETTE_SIZE)) {
497  palette = NULL;
498  }
499  }
500 
501  gif_image_write_image(avctx, &outbuf_ptr, end, palette,
502  pict->data[0], pict->linesize[0], pkt);
503  if (!s->last_frame && !s->image) {
504  s->last_frame = av_frame_alloc();
505  if (!s->last_frame)
506  return AVERROR(ENOMEM);
507  }
508 
509  if (!s->image) {
511  ret = av_frame_ref(s->last_frame, (AVFrame*)pict);
512  if (ret < 0)
513  return ret;
514  }
515 
516  pkt->size = outbuf_ptr - pkt->data;
517  if (s->image || !avctx->frame_number)
518  pkt->flags |= AV_PKT_FLAG_KEY;
519  *got_packet = 1;
520 
521  return 0;
522 }
523 
525 {
526  GIFContext *s = avctx->priv_data;
527 
528  av_freep(&s->lzw);
529  av_freep(&s->buf);
530  av_freep(&s->shrunk_buf);
531  s->buf_size = 0;
533  av_freep(&s->tmpl);
534  return 0;
535 }
536 
537 #define OFFSET(x) offsetof(GIFContext, x)
538 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
539 static const AVOption gif_options[] = {
540  { "gifflags", "set GIF flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = GF_OFFSETTING|GF_TRANSDIFF}, 0, INT_MAX, FLAGS, "flags" },
541  { "offsetting", "enable picture offsetting", 0, AV_OPT_TYPE_CONST, {.i64=GF_OFFSETTING}, INT_MIN, INT_MAX, FLAGS, "flags" },
542  { "transdiff", "enable transparency detection between frames", 0, AV_OPT_TYPE_CONST, {.i64=GF_TRANSDIFF}, INT_MIN, INT_MAX, FLAGS, "flags" },
543  { "gifimage", "enable encoding only images per frame", OFFSET(image), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
544  { "global_palette", "write a palette to the global gif header where feasible", OFFSET(use_global_palette), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
545  { NULL }
546 };
547 
548 static const AVClass gif_class = {
549  .class_name = "GIF encoder",
550  .item_name = av_default_item_name,
551  .option = gif_options,
552  .version = LIBAVUTIL_VERSION_INT,
553 };
554 
556  .name = "gif",
557  .long_name = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
558  .type = AVMEDIA_TYPE_VIDEO,
559  .id = AV_CODEC_ID_GIF,
560  .priv_data_size = sizeof(GIFContext),
562  .encode2 = gif_encode_frame,
563  .close = gif_encode_close,
564  .pix_fmts = (const enum AVPixelFormat[]){
567  },
568  .priv_class = &gif_class,
569  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
570 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
AVOption.
Definition: opt.h:248
uint32_t palette[AVPALETTE_COUNT]
local reference palette for !pal8
Definition: gif.c:56
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define GCE_DISPOSAL_BACKGROUND
Definition: gif.h:39
static int get_palette_transparency_index(const uint32_t *palette)
Definition: gif.c:120
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
static int gif_encode_close(AVCodecContext *avctx)
Definition: gif.c:524
static const AVClass gif_class
Definition: gif.c:548
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int ff_lzw_encode(struct LZWEncodeState *s, const uint8_t *inbuf, int insize)
LZW main compress function.
Definition: lzwenc.c:229
#define GIF_GCE_EXT_LABEL
Definition: gif.h:45
int av_log2(unsigned v)
Definition: intmath.c:26
AVCodec ff_gif_encoder
Definition: gif.c:555
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
int image
Definition: gif.c:54
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static AVPacket pkt
AVCodec.
Definition: codec.h:190
int use_global_palette
Definition: gif.c:55
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:176
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
int buf_size
Definition: gif.c:51
#define height
uint8_t * data
Definition: packet.h:363
static int gif_image_write_image(AVCodecContext *avctx, uint8_t **bytestream, uint8_t *end, const uint32_t *palette, const uint8_t *buf, const int linesize, AVPacket *pkt)
Definition: gif.c:292
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t * tmpl
temporary line buffer
Definition: gif.c:59
int flags
Definition: gif.c:53
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define FLAGS
Definition: gif.c:538
#define src
Definition: vp8dsp.c:255
Definition: lzw.c:46
void ff_lzw_encode_init(struct LZWEncodeState *s, uint8_t *outbuf, int outsize, int maxbits, enum FF_LZW_MODES mode, int little_endian)
Initialize LZW encoder.
Definition: lzwenc.c:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
LZWState * lzw
Definition: gif.c:48
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
Definition: gif.c:46
uint8_t * shrunk_buf
Definition: gif.c:50
const char * name
Name of the codec implementation.
Definition: codec.h:197
static void shrink_palette(const uint32_t *src, uint8_t *map, uint32_t *dst, size_t *palette_count)
Definition: gif.c:67
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
#define OFFSET(x)
Definition: gif.c:537
#define GIF_IMAGE_SEPARATOR
Definition: gif.h:44
#define FFMIN(a, b)
Definition: common.h:105
Definition: lzw.h:38
static int pick_palette_entry(const uint8_t *buf, int linesize, int w, int h)
Definition: gif.c:138
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
static void gif_crop_translucent(AVCodecContext *avctx, const uint8_t *buf, const int linesize, int *width, int *height, int *x_start, int *y_start)
Definition: gif.c:154
#define width
int width
picture width / height.
Definition: avcodec.h:704
uint8_t w
Definition: llviddspenc.c:39
#define s(width, name)
Definition: cbs_vp9.c:257
#define GIF_EXTENSION_INTRODUCER
Definition: gif.h:43
if(ret)
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
static void gif_crop_opaque(AVCodecContext *avctx, const uint32_t *palette, const uint8_t *buf, const int linesize, int *width, int *height, int *x_start, int *y_start)
Definition: gif.c:233
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
GIF format definitions.
main external API structure.
Definition: avcodec.h:531
static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: gif.c:476
Describe the class of an AVClass context structure.
Definition: log.h:67
Rational number (pair of numerator and denominator).
Definition: rational.h:58
uint8_t * buf
Definition: gif.c:49
const VDPAUPixFmtMap * map
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
#define GCE_DISPOSAL_INPLACE
Definition: gif.h:38
LZW decoding routines.
static int is_image_translucent(AVCodecContext *avctx, const uint8_t *buf, const int linesize)
Definition: gif.c:99
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
static const uint8_t gif89a_sig[6]
Definition: gif.h:35
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
int den
Denominator.
Definition: rational.h:60
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
void * priv_data
Definition: avcodec.h:558
AVFrame * last_frame
Definition: gif.c:52
int ff_lzw_encode_flush(struct LZWEncodeState *s)
Write end code and flush bitstream.
Definition: lzwenc.c:262
int len
static av_cold int gif_encode_init(AVCodecContext *avctx)
Definition: gif.c:452
int transparent_index
Definition: gif.c:58
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1222
#define av_freep(p)
int palette_loaded
Definition: gif.c:57
const int ff_lzw_encode_state_size
Definition: lzwenc.c:67
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static const AVOption gif_options[]
Definition: gif.c:539
static void remap_frame_to_palette(const uint8_t *src, int src_linesize, uint8_t *dst, int dst_linesize, int w, int h, uint8_t *map)
Definition: gif.c:90
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int i
Definition: input.c:407
#define DEFAULT_TRANSPARENCY_INDEX
Definition: gif.c:44
bitstream writer API