git.sesse.net Git - ffmpeg/blob - libavcodec/gif.c

   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;
  48     LZWState *lzw;
  49     uint8_t *buf;
  50     int buf_size;
  51     AVFrame *last_frame;
  52     int flags;
  53     int image;
  54     uint32_t palette[AVPALETTE_COUNT];  ///< local reference palette for !pal8
  55     int palette_loaded;
  56     int transparent_index;
  57     uint8_t *tmpl;                      ///< temporary line buffer
  58 } GIFContext;
  59
  60 enum {
  61     GF_OFFSETTING = 1<<0,
  62     GF_TRANSDIFF  = 1<<1,
  63 };
  64
  65 static int is_image_translucent(AVCodecContext *avctx,
  66                                 const uint8_t *buf, const int linesize)
  67 {
  68     GIFContext *s = avctx->priv_data;
  69     int trans = s->transparent_index;
  70
  71     if (trans < 0)
  72         return 0;
  73
  74     for (int y = 0; y < avctx->height; y++) {
  75         for (int x = 0; x < avctx->width; x++) {
  76             if (buf[x] == trans) {
  77                 return 1;
  78             }
  79         }
  80         buf += linesize;
  81     }
  82
  83     return 0;
  84 }
  85
  86 static int get_palette_transparency_index(const uint32_t *palette)
  87 {
  88     int transparent_color_index = -1;
  89     unsigned i, smallest_alpha = 0xff;
  90
  91     if (!palette)
  92         return -1;
  93
  94     for (i = 0; i < AVPALETTE_COUNT; i++) {
  95         const uint32_t v = palette[i];
  96         if (v >> 24 < smallest_alpha) {
  97             smallest_alpha = v >> 24;
  98             transparent_color_index = i;
  99         }
 100     }
 101     return smallest_alpha < 128 ? transparent_color_index : -1;
 102 }
 103
 104 static int pick_palette_entry(const uint8_t *buf, int linesize, int w, int h)
 105 {
 106     int histogram[AVPALETTE_COUNT] = {0};
 107     int x, y, i;
 108
 109     for (y = 0; y < h; y++) {
 110         for (x = 0; x < w; x++)
 111             histogram[buf[x]]++;
 112         buf += linesize;
 113     }
 114     for (i = 0; i < FF_ARRAY_ELEMS(histogram); i++)
 115         if (!histogram[i])
 116             return i;
 117     return -1;
 118 }
 119
 120 static void gif_crop_translucent(AVCodecContext *avctx,
 121                                  const uint8_t *buf, const int linesize,
 122                                  int *width, int *height,
 123                                  int *x_start, int *y_start)
 124 {
 125     GIFContext *s = avctx->priv_data;
 126     int trans = s->transparent_index;
 127
 128     /* Crop image */
 129     if ((s->flags & GF_OFFSETTING) && trans >= 0) {
 130         const int w = avctx->width;
 131         const int h = avctx->height;
 132         int x_end = w - 1,
 133             y_end = h - 1;
 134
 135         // crop top
 136         while (*y_start < y_end) {
 137             int is_trans = 1;
 138             for (int i = 0; i < w; i++) {
 139                 if (buf[linesize * *y_start + i] != trans) {
 140                     is_trans = 0;
 141                     break;
 142                 }
 143             }
 144
 145             if (!is_trans)
 146                 break;
 147             (*y_start)++;
 148         }
 149
 150         // crop bottom
 151         while (y_end > *y_start) {
 152             int is_trans = 1;
 153             for (int i = 0; i < w; i++) {
 154                 if (buf[linesize * y_end + i] != trans) {
 155                     is_trans = 0;
 156                     break;
 157                 }
 158             }
 159             if (!is_trans)
 160                 break;
 161             y_end--;
 162         }
 163
 164         // crop left
 165         while (*x_start < x_end) {
 166             int is_trans = 1;
 167             for (int i = *y_start; i < y_end; i++) {
 168                 if (buf[linesize * i + *x_start] != trans) {
 169                     is_trans = 0;
 170                     break;
 171                 }
 172             }
 173             if (!is_trans)
 174                 break;
 175             (*x_start)++;
 176         }
 177
 178         // crop right
 179         while (x_end > *x_start) {
 180             int is_trans = 1;
 181             for (int i = *y_start; i < y_end; i++) {
 182                 if (buf[linesize * i + x_end] != trans) {
 183                     is_trans = 0;
 184                     break;
 185                 }
 186             }
 187             if (!is_trans)
 188                 break;
 189             x_end--;
 190         }
 191
 192         *height = y_end + 1 - *y_start;
 193         *width  = x_end + 1 - *x_start;
 194         av_log(avctx, AV_LOG_DEBUG,"%dx%d image at pos (%d;%d) [area:%dx%d]\n",
 195                *width, *height, *x_start, *y_start, avctx->width, avctx->height);
 196     }
 197 }
 198
 199 static void gif_crop_opaque(AVCodecContext *avctx,
 200                             const uint32_t *palette,
 201                             const uint8_t *buf, const int linesize,
 202                             int *width, int *height, int *x_start, int *y_start)
 203 {
 204     GIFContext *s = avctx->priv_data;
 205
 206     /* Crop image */
 207     if ((s->flags & GF_OFFSETTING) && s->last_frame && !palette) {
 208         const uint8_t *ref = s->last_frame->data[0];
 209         const int ref_linesize = s->last_frame->linesize[0];
 210         int x_end = avctx->width  - 1,
 211             y_end = avctx->height - 1;
 212
 213         /* skip common lines */
 214         while (*y_start < y_end) {
 215             if (memcmp(ref + *y_start*ref_linesize, buf + *y_start*linesize, *width))
 216                 break;
 217             (*y_start)++;
 218         }
 219         while (y_end > *y_start) {
 220             if (memcmp(ref + y_end*ref_linesize, buf + y_end*linesize, *width))
 221                 break;
 222             y_end--;
 223         }
 224         *height = y_end + 1 - *y_start;
 225
 226         /* skip common columns */
 227         while (*x_start < x_end) {
 228             int same_column = 1;
 229             for (int y = *y_start; y <= y_end; y++) {
 230                 if (ref[y*ref_linesize + *x_start] != buf[y*linesize + *x_start]) {
 231                     same_column = 0;
 232                     break;
 233                 }
 234             }
 235             if (!same_column)
 236                 break;
 237             (*x_start)++;
 238         }
 239         while (x_end > *x_start) {
 240             int same_column = 1;
 241             for (int y = *y_start; y <= y_end; y++) {
 242                 if (ref[y*ref_linesize + x_end] != buf[y*linesize + x_end]) {
 243                     same_column = 0;
 244                     break;
 245                 }
 246             }
 247             if (!same_column)
 248                 break;
 249             x_end--;
 250         }
 251         *width = x_end + 1 - *x_start;
 252
 253         av_log(avctx, AV_LOG_DEBUG,"%dx%d image at pos (%d;%d) [area:%dx%d]\n",
 254                *width, *height, *x_start, *y_start, avctx->width, avctx->height);
 255     }
 256 }
 257
 258 static int gif_image_write_image(AVCodecContext *avctx,
 259                                  uint8_t **bytestream, uint8_t *end,
 260                                  const uint32_t *palette,
 261                                  const uint8_t *buf, const int linesize,
 262                                  AVPacket *pkt)
 263 {
 264     GIFContext *s = avctx->priv_data;
 265     int disposal, len = 0, height = avctx->height, width = avctx->width, x, y;
 266     int x_start = 0, y_start = 0, trans = s->transparent_index;
 267     int bcid = -1, honor_transparency = (s->flags & GF_TRANSDIFF) && s->last_frame && !palette;
 268     const uint8_t *ptr;
 269
 270     if (!s->image && avctx->frame_number && is_image_translucent(avctx, buf, linesize)) {
 271         gif_crop_translucent(avctx, buf, linesize, &width, &height, &x_start, &y_start);
 272         honor_transparency = 0;
 273         disposal = GCE_DISPOSAL_BACKGROUND;
 274     } else {
 275         gif_crop_opaque(avctx, palette, buf, linesize, &width, &height, &x_start, &y_start);
 276         disposal = GCE_DISPOSAL_INPLACE;
 277     }
 278
 279     if (s->image || !avctx->frame_number) { /* GIF header */
 280         const uint32_t *global_palette = palette ? palette : s->palette;
 281         const AVRational sar = avctx->sample_aspect_ratio;
 282         int64_t aspect = 0;
 283
 284         if (sar.num > 0 && sar.den > 0) {
 285             aspect = sar.num * 64LL / sar.den - 15;
 286             if (aspect < 0 || aspect > 255)
 287                 aspect = 0;
 288         }
 289
 290         bytestream_put_buffer(bytestream, gif89a_sig, sizeof(gif89a_sig));
 291         bytestream_put_le16(bytestream, avctx->width);
 292         bytestream_put_le16(bytestream, avctx->height);
 293
 294         bcid = get_palette_transparency_index(global_palette);
 295
 296         bytestream_put_byte(bytestream, 0xf7); /* flags: global clut, 256 entries */
 297         bytestream_put_byte(bytestream, bcid < 0 ? DEFAULT_TRANSPARENCY_INDEX : bcid); /* background color index */
 298         bytestream_put_byte(bytestream, aspect);
 299         for (int i = 0; i < 256; i++) {
 300             const uint32_t v = global_palette[i] & 0xffffff;
 301             bytestream_put_be24(bytestream, v);
 302         }
 303     }
 304
 305     if (honor_transparency && trans < 0) {
 306         trans = pick_palette_entry(buf + y_start*linesize + x_start,
 307                                    linesize, width, height);
 308         if (trans < 0) // TODO, patch welcome
 309             av_log(avctx, AV_LOG_DEBUG, "No available color, can not use transparency\n");
 310     }
 311
 312     if (trans < 0)
 313         honor_transparency = 0;
 314
 315     bcid = honor_transparency || disposal == GCE_DISPOSAL_BACKGROUND ? trans : get_palette_transparency_index(palette);
 316
 317     /* graphic control extension */
 318     bytestream_put_byte(bytestream, GIF_EXTENSION_INTRODUCER);
 319     bytestream_put_byte(bytestream, GIF_GCE_EXT_LABEL);
 320     bytestream_put_byte(bytestream, 0x04); /* block size */
 321     bytestream_put_byte(bytestream, disposal<<2 | (bcid >= 0));
 322     bytestream_put_le16(bytestream, 5); // default delay
 323     bytestream_put_byte(bytestream, bcid < 0 ? DEFAULT_TRANSPARENCY_INDEX : bcid);
 324     bytestream_put_byte(bytestream, 0x00);
 325
 326     /* image block */
 327     bytestream_put_byte(bytestream, GIF_IMAGE_SEPARATOR);
 328     bytestream_put_le16(bytestream, x_start);
 329     bytestream_put_le16(bytestream, y_start);
 330     bytestream_put_le16(bytestream, width);
 331     bytestream_put_le16(bytestream, height);
 332
 333     if (!palette) {
 334         bytestream_put_byte(bytestream, 0x00); /* flags */
 335     } else {
 336         unsigned i;
 337         bytestream_put_byte(bytestream, 1<<7 | 0x7); /* flags */
 338         for (i = 0; i < AVPALETTE_COUNT; i++) {
 339             const uint32_t v = palette[i];
 340             bytestream_put_be24(bytestream, v);
 341         }
 342     }
 343
 344     bytestream_put_byte(bytestream, 0x08);
 345
 346     ff_lzw_encode_init(s->lzw, s->buf, s->buf_size,
 347                        12, FF_LZW_GIF, 1);
 348
 349     ptr = buf + y_start*linesize + x_start;
 350     if (honor_transparency) {
 351         const int ref_linesize = s->last_frame->linesize[0];
 352         const uint8_t *ref = s->last_frame->data[0] + y_start*ref_linesize + x_start;
 353
 354         for (y = 0; y < height; y++) {
 355             memcpy(s->tmpl, ptr, width);
 356             for (x = 0; x < width; x++)
 357                 if (ref[x] == ptr[x])
 358                     s->tmpl[x] = trans;
 359             len += ff_lzw_encode(s->lzw, s->tmpl, width);
 360             ptr += linesize;
 361             ref += ref_linesize;
 362         }
 363     } else {
 364         for (y = 0; y < height; y++) {
 365             len += ff_lzw_encode(s->lzw, ptr, width);
 366             ptr += linesize;
 367         }
 368     }
 369     len += ff_lzw_encode_flush(s->lzw);
 370
 371     ptr = s->buf;
 372     while (len > 0) {
 373         int size = FFMIN(255, len);
 374         bytestream_put_byte(bytestream, size);
 375         if (end - *bytestream < size)
 376             return -1;
 377         bytestream_put_buffer(bytestream, ptr, size);
 378         ptr += size;
 379         len -= size;
 380     }
 381     bytestream_put_byte(bytestream, 0x00); /* end of image block */
 382     return 0;
 383 }
 384
 385 static av_cold int gif_encode_init(AVCodecContext *avctx)
 386 {
 387     GIFContext *s = avctx->priv_data;
 388
 389     if (avctx->width > 65535 || avctx->height > 65535) {
 390         av_log(avctx, AV_LOG_ERROR, "GIF does not support resolutions above 65535x65535\n");
 391         return AVERROR(EINVAL);
 392     }
 393
 394     s->transparent_index = -1;
 395
 396     s->lzw = av_mallocz(ff_lzw_encode_state_size);
 397     s->buf_size = avctx->width*avctx->height*2 + 1000;
 398     s->buf = av_malloc(s->buf_size);
 399     s->tmpl = av_malloc(avctx->width);
 400     if (!s->tmpl || !s->buf || !s->lzw)
 401         return AVERROR(ENOMEM);
 402
 403     if (avpriv_set_systematic_pal2(s->palette, avctx->pix_fmt) < 0)
 404         av_assert0(avctx->pix_fmt == AV_PIX_FMT_PAL8);
 405
 406     return 0;
 407 }
 408
 409 static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 410                             const AVFrame *pict, int *got_packet)
 411 {
 412     GIFContext *s = avctx->priv_data;
 413     uint8_t *outbuf_ptr, *end;
 414     const uint32_t *palette = NULL;
 415     int ret;
 416
 417     if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*7/5 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
 418         return ret;
 419     outbuf_ptr = pkt->data;
 420     end        = pkt->data + pkt->size;
 421
 422     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
 423         palette = (uint32_t*)pict->data[1];
 424
 425         if (!s->palette_loaded) {
 426             memcpy(s->palette, palette, AVPALETTE_SIZE);
 427             s->transparent_index = get_palette_transparency_index(palette);
 428             s->palette_loaded = 1;
 429         } else if (!memcmp(s->palette, palette, AVPALETTE_SIZE)) {
 430             palette = NULL;
 431         }
 432     }
 433
 434     gif_image_write_image(avctx, &outbuf_ptr, end, palette,
 435                           pict->data[0], pict->linesize[0], pkt);
 436     if (!s->last_frame && !s->image) {
 437         s->last_frame = av_frame_alloc();
 438         if (!s->last_frame)
 439             return AVERROR(ENOMEM);
 440     }
 441
 442     if (!s->image) {
 443         av_frame_unref(s->last_frame);
 444         ret = av_frame_ref(s->last_frame, (AVFrame*)pict);
 445         if (ret < 0)
 446             return ret;
 447     }
 448
 449     pkt->size   = outbuf_ptr - pkt->data;
 450     if (s->image || !avctx->frame_number)
 451         pkt->flags |= AV_PKT_FLAG_KEY;
 452     *got_packet = 1;
 453
 454     return 0;
 455 }
 456
 457 static int gif_encode_close(AVCodecContext *avctx)
 458 {
 459     GIFContext *s = avctx->priv_data;
 460
 461     av_freep(&s->lzw);
 462     av_freep(&s->buf);
 463     s->buf_size = 0;
 464     av_frame_free(&s->last_frame);
 465     av_freep(&s->tmpl);
 466     return 0;
 467 }
 468
 469 #define OFFSET(x) offsetof(GIFContext, x)
 470 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 471 static const AVOption gif_options[] = {
 472     { "gifflags", "set GIF flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = GF_OFFSETTING|GF_TRANSDIFF}, 0, INT_MAX, FLAGS, "flags" },
 473         { "offsetting", "enable picture offsetting", 0, AV_OPT_TYPE_CONST, {.i64=GF_OFFSETTING}, INT_MIN, INT_MAX, FLAGS, "flags" },
 474         { "transdiff", "enable transparency detection between frames", 0, AV_OPT_TYPE_CONST, {.i64=GF_TRANSDIFF}, INT_MIN, INT_MAX, FLAGS, "flags" },
 475     { "gifimage", "enable encoding only images per frame", OFFSET(image), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
 476     { NULL }
 477 };
 478
 479 static const AVClass gif_class = {
 480     .class_name = "GIF encoder",
 481     .item_name  = av_default_item_name,
 482     .option     = gif_options,
 483     .version    = LIBAVUTIL_VERSION_INT,
 484 };
 485
 486 AVCodec ff_gif_encoder = {
 487     .name           = "gif",
 488     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
 489     .type           = AVMEDIA_TYPE_VIDEO,
 490     .id             = AV_CODEC_ID_GIF,
 491     .priv_data_size = sizeof(GIFContext),
 492     .init           = gif_encode_init,
 493     .encode2        = gif_encode_frame,
 494     .close          = gif_encode_close,
 495     .pix_fmts       = (const enum AVPixelFormat[]){
 496         AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
 497         AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE
 498     },
 499     .priv_class     = &gif_class,
 500 };