/*
  * GIF encoder.

  * Copyright (c) 2000 Fabrice Bellard
  * Copyright (c) 2002 Francois Revol
  * Copyright (c) 2006 Baptiste Coudurier

  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*
  * First version by Francois Revol revol@free.fr
  *
  * Features and limitations:
  * - currently no compression is performed,
  *   in fact the size of the data is 9/8 the size of the image in 8bpp
  * - uses only a global standard palette
  * - tested with IE 5.0, Opera for BeOS, NetPositive (BeOS), and Mozilla (BeOS).
  *
  * Reference documents:
  * http://www.goice.co.jp/member/mo/formats/gif.html
  * http://astronomy.swin.edu.au/pbourke/dataformats/gif/
  * http://www.dcs.ed.ac.uk/home/mxr/gfx/2d/GIF89a.txt
  *
  * this url claims to have an LZW algorithm not covered by Unisys patent:
  * http://www.msg.net/utility/whirlgif/gifencod.html
  * could help reduce the size of the files _a lot_...
  * some sites mentions an RLE type compression also.
  */
 
 #include "avcodec.h"
 #include "bytestream.h"

 #include "lzw.h"

 
 /* The GIF format uses reversed order for bitstreams... */
 /* at least they don't use PDP_ENDIAN :) */
 #define BITSTREAM_WRITER_LE
 

 #include "put_bits.h"

 typedef struct {
     AVFrame picture;

     LZWState *lzw;
     uint8_t *buf;

 } GIFContext;
 

 /* GIF header */

 static int gif_image_write_header(AVCodecContext *avctx,
                                   uint8_t **bytestream, uint32_t *palette)

 {
     int i;
     unsigned int v;
 
     bytestream_put_buffer(bytestream, "GIF", 3);
     bytestream_put_buffer(bytestream, "89a", 3);

     bytestream_put_le16(bytestream, avctx->width);
     bytestream_put_le16(bytestream, avctx->height);

 
     bytestream_put_byte(bytestream, 0xf7); /* flags: global clut, 256 entries */
     bytestream_put_byte(bytestream, 0x1f); /* background color index */
     bytestream_put_byte(bytestream, 0); /* aspect ratio */
 
     /* the global palette */

     for(i=0;i<256;i++) {
         v = palette[i];
         bytestream_put_be24(bytestream, v);

     }
 
     return 0;
 }
 

 static int gif_image_write_image(AVCodecContext *avctx,
                                  uint8_t **bytestream, uint8_t *end,

                                  const uint8_t *buf, int linesize)

 {

     GIFContext *s = avctx->priv_data;

     int len = 0, height;

     const uint8_t *ptr;
     /* image block */
 
     bytestream_put_byte(bytestream, 0x2c);

     bytestream_put_le16(bytestream, 0);
     bytestream_put_le16(bytestream, 0);

     bytestream_put_le16(bytestream, avctx->width);
     bytestream_put_le16(bytestream, avctx->height);

     bytestream_put_byte(bytestream, 0x00); /* flags */
     /* no local clut */
 
     bytestream_put_byte(bytestream, 0x08);
 

     ff_lzw_encode_init(s->lzw, s->buf, avctx->width*avctx->height,
                        12, FF_LZW_GIF, put_bits);

 
     ptr = buf;

     for (height = avctx->height; height--;) {
         len += ff_lzw_encode(s->lzw, ptr, avctx->width);
         ptr += linesize;
     }
     len += ff_lzw_encode_flush(s->lzw, flush_put_bits);
 
     ptr = s->buf;
     while (len > 0) {
         int size = FFMIN(255, len);
         bytestream_put_byte(bytestream, size);
         if (end - *bytestream < size)
             return -1;
         bytestream_put_buffer(bytestream, ptr, size);
         ptr += size;
         len -= size;

     }
     bytestream_put_byte(bytestream, 0x00); /* end of image block */
     bytestream_put_byte(bytestream, 0x3b);
     return 0;
 }
 

 static av_cold int gif_encode_init(AVCodecContext *avctx)

 {
     GIFContext *s = avctx->priv_data;
 
     avctx->coded_frame = &s->picture;

     s->lzw = av_mallocz(ff_lzw_encode_state_size);
     if (!s->lzw)

         return AVERROR(ENOMEM);

     s->buf = av_malloc(avctx->width*avctx->height*2);
     if (!s->buf)

          return AVERROR(ENOMEM);

     return 0;
 }
 
 /* better than nothing gif encoder */
 static int gif_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int buf_size, void *data)
 {
     GIFContext *s = avctx->priv_data;
     AVFrame *pict = data;
     AVFrame *const p = (AVFrame *)&s->picture;
     uint8_t *outbuf_ptr = outbuf;

     uint8_t *end = outbuf + buf_size;

 
     *p = *pict;

     p->pict_type = AV_PICTURE_TYPE_I;

     p->key_frame = 1;

     gif_image_write_header(avctx, &outbuf_ptr, (uint32_t *)pict->data[1]);

     gif_image_write_image(avctx, &outbuf_ptr, end, pict->data[0], pict->linesize[0]);

     return outbuf_ptr - outbuf;
 }
 

 static int gif_encode_close(AVCodecContext *avctx)
 {
     GIFContext *s = avctx->priv_data;
 
     av_freep(&s->lzw);
     av_freep(&s->buf);
     return 0;
 }
 

 AVCodec ff_gif_encoder = {

     "gif",

     AVMEDIA_TYPE_VIDEO,

     CODEC_ID_GIF,
     sizeof(GIFContext),
     gif_encode_init,
     gif_encode_frame,

     gif_encode_close,

     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE},

     .long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),

 };