cb1c71bd377a60b459d03236202416565ac49799
[ffmpeg.git] / libavcodec / gif.c
1 /*
2  * GIF encoder.
3  * Copyright (c) 2000 Fabrice Bellard
4  * Copyright (c) 2002 Francois Revol
5  * Copyright (c) 2006 Baptiste Coudurier
6  *
7  * first version by Francois Revol <revol@free.fr>
8  *
9  * This file is part of Libav.
10  *
11  * Libav is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * Libav is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with Libav; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25
26 /*
27  * Features and limitations:
28  * - currently no compression is performed,
29  *   in fact the size of the data is 9/8 the size of the image in 8bpp
30  * - uses only a global standard palette
31  * - tested with IE 5.0, Opera for BeOS, NetPositive (BeOS), and Mozilla (BeOS).
32  *
33  * Reference documents:
34  * http://www.goice.co.jp/member/mo/formats/gif.html
35  * http://astronomy.swin.edu.au/pbourke/dataformats/gif/
36  * http://www.dcs.ed.ac.uk/home/mxr/gfx/2d/GIF89a.txt
37  *
38  * this url claims to have an LZW algorithm not covered by Unisys patent:
39  * http://www.msg.net/utility/whirlgif/gifencod.html
40  * could help reduce the size of the files _a lot_...
41  * some sites mentions an RLE type compression also.
42  */
43
44 #include "avcodec.h"
45 #include "bytestream.h"
46 #include "internal.h"
47 #include "lzw.h"
48
49 /* The GIF format uses reversed order for bitstreams... */
50 /* at least they don't use PDP_ENDIAN :) */
51 #define BITSTREAM_WRITER_LE
52
53 #include "put_bits.h"
54
55 typedef struct GIFContext {
56     LZWState *lzw;
57     uint8_t *buf;
58 } GIFContext;
59
60 /* GIF header */
61 static int gif_image_write_header(AVCodecContext *avctx,
62                                   uint8_t **bytestream, uint32_t *palette)
63 {
64     int i;
65     unsigned int v;
66
67     bytestream_put_buffer(bytestream, "GIF", 3);
68     bytestream_put_buffer(bytestream, "89a", 3);
69     bytestream_put_le16(bytestream, avctx->width);
70     bytestream_put_le16(bytestream, avctx->height);
71
72     bytestream_put_byte(bytestream, 0xf7); /* flags: global clut, 256 entries */
73     bytestream_put_byte(bytestream, 0x1f); /* background color index */
74     bytestream_put_byte(bytestream, 0); /* aspect ratio */
75
76     /* the global palette */
77     for(i=0;i<256;i++) {
78         v = palette[i];
79         bytestream_put_be24(bytestream, v);
80     }
81
82     return 0;
83 }
84
85 static int gif_image_write_image(AVCodecContext *avctx,
86                                  uint8_t **bytestream, uint8_t *end,
87                                  const uint8_t *buf, int linesize)
88 {
89     GIFContext *s = avctx->priv_data;
90     int len = 0, height;
91     const uint8_t *ptr;
92     /* image block */
93
94     bytestream_put_byte(bytestream, 0x2c);
95     bytestream_put_le16(bytestream, 0);
96     bytestream_put_le16(bytestream, 0);
97     bytestream_put_le16(bytestream, avctx->width);
98     bytestream_put_le16(bytestream, avctx->height);
99     bytestream_put_byte(bytestream, 0x00); /* flags */
100     /* no local clut */
101
102     bytestream_put_byte(bytestream, 0x08);
103
104     ff_lzw_encode_init(s->lzw, s->buf, avctx->width*avctx->height,
105                        12, FF_LZW_GIF, put_bits);
106
107     ptr = buf;
108     for (height = avctx->height; height--;) {
109         len += ff_lzw_encode(s->lzw, ptr, avctx->width);
110         ptr += linesize;
111     }
112     len += ff_lzw_encode_flush(s->lzw, flush_put_bits);
113
114     ptr = s->buf;
115     while (len > 0) {
116         int size = FFMIN(255, len);
117         bytestream_put_byte(bytestream, size);
118         if (end - *bytestream < size)
119             return -1;
120         bytestream_put_buffer(bytestream, ptr, size);
121         ptr += size;
122         len -= size;
123     }
124     bytestream_put_byte(bytestream, 0x00); /* end of image block */
125     bytestream_put_byte(bytestream, 0x3b);
126     return 0;
127 }
128
129 static av_cold int gif_encode_init(AVCodecContext *avctx)
130 {
131     GIFContext *s = avctx->priv_data;
132
133     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
134     avctx->coded_frame->key_frame = 1;
135
136     s->lzw = av_mallocz(ff_lzw_encode_state_size);
137     if (!s->lzw)
138         return AVERROR(ENOMEM);
139     s->buf = av_malloc(avctx->width*avctx->height*2);
140     if (!s->buf)
141          return AVERROR(ENOMEM);
142     return 0;
143 }
144
145 /* better than nothing gif encoder */
146 static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
147                             const AVFrame *pict, int *got_packet)
148 {
149     uint8_t *outbuf_ptr, *end;
150     int ret;
151
152     if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*7/5 + FF_MIN_BUFFER_SIZE)) < 0) {
153         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
154         return ret;
155     }
156     outbuf_ptr = pkt->data;
157     end        = pkt->data + pkt->size;
158
159     gif_image_write_header(avctx, &outbuf_ptr, (uint32_t *)pict->data[1]);
160     gif_image_write_image(avctx, &outbuf_ptr, end, pict->data[0], pict->linesize[0]);
161
162     pkt->size   = outbuf_ptr - pkt->data;
163     pkt->flags |= AV_PKT_FLAG_KEY;
164     *got_packet = 1;
165
166     return 0;
167 }
168
169 static int gif_encode_close(AVCodecContext *avctx)
170 {
171     GIFContext *s = avctx->priv_data;
172
173     av_freep(&s->lzw);
174     av_freep(&s->buf);
175     return 0;
176 }
177
178 AVCodec ff_gif_encoder = {
179     .name           = "gif",
180     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
181     .type           = AVMEDIA_TYPE_VIDEO,
182     .id             = AV_CODEC_ID_GIF,
183     .priv_data_size = sizeof(GIFContext),
184     .init           = gif_encode_init,
185     .encode2        = gif_encode_frame,
186     .close          = gif_encode_close,
187     .pix_fmts       = (const enum AVPixelFormat[]){
188         AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,
189         AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE
190     },
191 };