gif.c 6.61 KB
Newer Older
1
/*
2
 * Animated GIF muxer
3
 * Copyright (c) 2000 Fabrice Bellard
4
 *
5 6
 * first version by Francois Revol <revol@free.fr>
 *
7 8 9
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
10 11
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 23 24
 */

#include "avformat.h"
Clément Bœsch's avatar
Clément Bœsch committed
25
#include "internal.h"
26 27
#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
28 29
#include "libavutil/log.h"
#include "libavutil/opt.h"
30
#include "libavcodec/bytestream.h"
31
#include "libavcodec/gif.h"
32

33
typedef struct GIFContext {
34
    AVClass *class;
35
    int loop;
36
    int last_delay;
37
    int duration;
38 39 40
    int64_t last_pos;
    int have_end;
    AVPacket *prev_pkt;
41 42 43 44
} GIFContext;

static int gif_write_header(AVFormatContext *s)
{
45
    if (s->nb_streams != 1 ||
46 47
        s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
        s->streams[0]->codecpar->codec_id   != AV_CODEC_ID_GIF) {
48
        av_log(s, AV_LOG_ERROR,
49
               "GIF muxer supports only a single video GIF stream.\n");
50 51 52
        return AVERROR(EINVAL);
    }

Clément Bœsch's avatar
Clément Bœsch committed
53
    avpriv_set_pts_info(s->streams[0], 64, 1, 100);
54 55 56 57

    return 0;
}

58
static int gif_parse_packet(AVFormatContext *s, uint8_t *data, int size)
59
{
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
    GetByteContext gb;
    int x;

    bytestream2_init(&gb, data, size);

    while (bytestream2_get_bytes_left(&gb) > 0) {
        x = bytestream2_get_byte(&gb);
        if (x != GIF_EXTENSION_INTRODUCER)
            return 0;

        x = bytestream2_get_byte(&gb);
        while (x != GIF_GCE_EXT_LABEL && bytestream2_get_bytes_left(&gb) > 0) {
            int block_size = bytestream2_get_byte(&gb);
            if (!block_size)
                break;
            bytestream2_skip(&gb, block_size);
        }
77

78 79
        if (x == GIF_GCE_EXT_LABEL)
            return bytestream2_tell(&gb) + 2;
80
    }
81

82 83 84 85 86
    return 0;
}

static int gif_get_delay(GIFContext *gif, AVPacket *prev, AVPacket *new)
{
87
    if (new && new->pts != AV_NOPTS_VALUE)
88
        gif->duration = av_clip_uint16(new->pts - prev->pts);
89 90
    else if (!new && gif->last_delay >= 0)
        gif->duration = gif->last_delay;
Clément Bœsch's avatar
Clément Bœsch committed
91

92
    return gif->duration;
93 94
}

95
static int gif_write_packet(AVFormatContext *s, AVPacket *new_pkt)
96 97
{
    GIFContext *gif = s->priv_data;
98 99
    AVIOContext *pb = s->pb;
    AVPacket *pkt = gif->prev_pkt;
100 101

    if (!gif->prev_pkt) {
102
        gif->prev_pkt = av_packet_alloc();
103 104
        if (!gif->prev_pkt)
            return AVERROR(ENOMEM);
105 106 107 108 109 110
        return av_packet_ref(gif->prev_pkt, new_pkt);
    }

    gif->last_pos = avio_tell(pb);
    if (pkt->size > 0)
        gif->have_end = pkt->data[pkt->size - 1] == GIF_TRAILER;
111

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
    if (!gif->last_pos) {
        int delay_pos;
        int off = 13;

        if (pkt->size < 13)
            return AVERROR(EINVAL);

        if (pkt->data[10] & 0x80)
            off += 3 * (1 << ((pkt->data[10] & 0x07) + 1));

        if (pkt->size < off + 2)
            return AVERROR(EINVAL);

        avio_write(pb, pkt->data, off);

        if (pkt->data[off] == GIF_EXTENSION_INTRODUCER && pkt->data[off + 1] == 0xff)
            off += 19;

        if (pkt->size <= off)
            return AVERROR(EINVAL);

        /* "NETSCAPE EXTENSION" for looped animation GIF */
        if (gif->loop >= 0) {
            avio_w8(pb, GIF_EXTENSION_INTRODUCER); /* GIF Extension code */
            avio_w8(pb, GIF_APP_EXT_LABEL); /* Application Extension Label */
            avio_w8(pb, 0x0b); /* Length of Application Block */
            avio_write(pb, "NETSCAPE2.0", sizeof("NETSCAPE2.0") - 1);
            avio_w8(pb, 0x03); /* Length of Data Sub-Block */
            avio_w8(pb, 0x01);
            avio_wl16(pb, (uint16_t)gif->loop);
            avio_w8(pb, 0x00); /* Data Sub-block Terminator */
143 144
        }

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
        delay_pos = gif_parse_packet(s, pkt->data + off, pkt->size - off);
        if (delay_pos > 0 && delay_pos < pkt->size - off - 2) {
            avio_write(pb, pkt->data + off, delay_pos);
            avio_wl16(pb, gif_get_delay(gif, pkt, new_pkt));
            avio_write(pb, pkt->data + off + delay_pos + 2, pkt->size - off - delay_pos - 2);
        } else {
            avio_write(pb, pkt->data + off, pkt->size - off);
        }
    } else {
        int delay_pos = gif_parse_packet(s, pkt->data, pkt->size);

        if (delay_pos > 0 && delay_pos < pkt->size - 2) {
            avio_write(pb, pkt->data, delay_pos);
            avio_wl16(pb, gif_get_delay(gif, pkt, new_pkt));
            avio_write(pb, pkt->data + delay_pos + 2, pkt->size - delay_pos - 2);
        } else {
            avio_write(pb, pkt->data, pkt->size);
        }
163
    }
164 165 166 167 168 169

    av_packet_unref(gif->prev_pkt);
    if (new_pkt)
        return av_packet_ref(gif->prev_pkt, new_pkt);

    return 0;
170 171
}

172 173
static int gif_write_trailer(AVFormatContext *s)
{
174
    GIFContext *gif = s->priv_data;
175
    AVIOContext *pb = s->pb;
176

177 178 179
    if (!gif->prev_pkt)
        return AVERROR(EINVAL);

180 181 182 183 184
    gif_write_packet(s, NULL);

    if (!gif->have_end)
        avio_w8(pb, GIF_TRAILER);
    av_packet_free(&gif->prev_pkt);
185

186 187 188
    return 0;
}

189 190 191
#define OFFSET(x) offsetof(GIFContext, x)
#define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
192 193
    { "loop", "Number of times to loop the output: -1 - no loop, 0 - infinite loop", OFFSET(loop),
      AV_OPT_TYPE_INT, { .i64 = 0 }, -1, 65535, ENC },
194
    { "final_delay", "Force delay (in centiseconds) after the last frame", OFFSET(last_delay),
195
      AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, ENC },
196 197 198 199 200 201 202 203 204 205
    { NULL },
};

static const AVClass gif_muxer_class = {
    .class_name = "GIF muxer",
    .item_name  = av_default_item_name,
    .version    = LIBAVUTIL_VERSION_INT,
    .option     = options,
};

206
AVOutputFormat ff_gif_muxer = {
207
    .name           = "gif",
208
    .long_name      = NULL_IF_CONFIG_SMALL("CompuServe Graphics Interchange Format (GIF)"),
209 210 211
    .mime_type      = "image/gif",
    .extensions     = "gif",
    .priv_data_size = sizeof(GIFContext),
212
    .audio_codec    = AV_CODEC_ID_NONE,
213
    .video_codec    = AV_CODEC_ID_GIF,
214 215 216 217
    .write_header   = gif_write_header,
    .write_packet   = gif_write_packet,
    .write_trailer  = gif_write_trailer,
    .priv_class     = &gif_muxer_class,
Clément Bœsch's avatar
Clément Bœsch committed
218
    .flags          = AVFMT_VARIABLE_FPS,
219
};