mirror of https://git.ffmpeg.org/ffmpeg.git
234 lines
7.1 KiB
C
234 lines
7.1 KiB
C
/*
|
|
* webp muxer
|
|
* Copyright (c) 2014 Michael Niedermayer
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
#include "libavutil/intreadwrite.h"
|
|
#include "libavutil/opt.h"
|
|
#include "libavcodec/bytestream.h"
|
|
#include "avformat.h"
|
|
#include "internal.h"
|
|
#include "mux.h"
|
|
|
|
typedef struct WebpContext{
|
|
AVClass *class;
|
|
int frame_count;
|
|
AVPacket *last_pkt; /* Not owned by us */
|
|
int loop;
|
|
int wrote_webp_header;
|
|
int using_webp_anim_encoder;
|
|
} WebpContext;
|
|
|
|
static int webp_init(AVFormatContext *s)
|
|
{
|
|
WebpContext *const w = s->priv_data;
|
|
AVStream *st = s->streams[0];
|
|
|
|
w->last_pkt = ffformatcontext(s)->pkt;
|
|
|
|
avpriv_set_pts_info(st, 24, 1, 1000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int is_animated_webp_packet(AVPacket *pkt)
|
|
{
|
|
int skip = 0;
|
|
unsigned flags = 0;
|
|
|
|
if (pkt->size < 4)
|
|
return AVERROR_INVALIDDATA;
|
|
if (AV_RL32(pkt->data) == AV_RL32("RIFF"))
|
|
skip = 12;
|
|
// Safe to do this as a valid WebP bitstream is >=30 bytes.
|
|
if (pkt->size < skip + 4)
|
|
return AVERROR_INVALIDDATA;
|
|
if (AV_RL32(pkt->data + skip) == AV_RL32("VP8X")) {
|
|
flags |= pkt->data[skip + 4 + 4];
|
|
}
|
|
|
|
if (flags & 2) // ANIMATION_FLAG is on
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns 1 if it has written a RIFF header with a correct length field
|
|
*/
|
|
static int flush(AVFormatContext *s, int trailer, int64_t pts)
|
|
{
|
|
WebpContext *w = s->priv_data;
|
|
AVStream *st = s->streams[0];
|
|
uint8_t buf[12 /* RIFF+WEBP */ + 18 /* VP8X */ +
|
|
14 /* ANIM */ + 24 /* ANMF */], *bufp = buf;
|
|
int writing_webp_header = 0, skip = 0;
|
|
unsigned flags = 0;
|
|
int vp8x = 0;
|
|
|
|
if (!w->last_pkt->size)
|
|
return 0;
|
|
|
|
if (AV_RL32(w->last_pkt->data) == AV_RL32("RIFF"))
|
|
skip = 12;
|
|
|
|
if (AV_RL32(w->last_pkt->data + skip) == AV_RL32("VP8X")) {
|
|
flags |= w->last_pkt->data[skip + 4 + 4];
|
|
vp8x = 1;
|
|
skip += AV_RL32(w->last_pkt->data + skip + 4) + 8;
|
|
}
|
|
|
|
if (!w->wrote_webp_header) {
|
|
bytestream_put_le32(&bufp, MKTAG('R', 'I', 'F', 'F'));
|
|
bytestream_put_le32(&bufp, 0); /* Size to be patched later */
|
|
bytestream_put_le32(&bufp, MKTAG('W', 'E', 'B', 'P'));
|
|
writing_webp_header = 1;
|
|
w->wrote_webp_header = 1;
|
|
if (w->frame_count > 1) // first non-empty packet
|
|
w->frame_count = 1; // so we don't count previous empty packets.
|
|
}
|
|
|
|
if (w->frame_count == 1) {
|
|
if (!trailer) {
|
|
vp8x = 1;
|
|
flags |= 2 + 16;
|
|
}
|
|
|
|
if (vp8x) {
|
|
bytestream_put_le32(&bufp, MKTAG('V', 'P', '8', 'X'));
|
|
bytestream_put_le32(&bufp, 10);
|
|
bytestream_put_byte(&bufp, flags);
|
|
bytestream_put_le24(&bufp, 0);
|
|
bytestream_put_le24(&bufp, st->codecpar->width - 1);
|
|
bytestream_put_le24(&bufp, st->codecpar->height - 1);
|
|
}
|
|
if (!trailer) {
|
|
bytestream_put_le32(&bufp, MKTAG('A', 'N', 'I', 'M'));
|
|
bytestream_put_le32(&bufp, 6);
|
|
bytestream_put_le32(&bufp, 0xFFFFFFFF);
|
|
bytestream_put_le16(&bufp, w->loop);
|
|
}
|
|
}
|
|
|
|
if (w->frame_count > trailer) {
|
|
bytestream_put_le32(&bufp, MKTAG('A', 'N', 'M', 'F'));
|
|
bytestream_put_le32(&bufp, 16 + w->last_pkt->size - skip);
|
|
bytestream_put_le24(&bufp, 0);
|
|
bytestream_put_le24(&bufp, 0);
|
|
bytestream_put_le24(&bufp, st->codecpar->width - 1);
|
|
bytestream_put_le24(&bufp, st->codecpar->height - 1);
|
|
if (w->last_pkt->pts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE) {
|
|
bytestream_put_le24(&bufp, pts - w->last_pkt->pts);
|
|
} else
|
|
bytestream_put_le24(&bufp, w->last_pkt->duration);
|
|
bytestream_put_byte(&bufp, 0);
|
|
}
|
|
if (trailer && writing_webp_header)
|
|
AV_WL32(buf + 4, bufp - (buf + 8) + w->last_pkt->size - skip);
|
|
avio_write(s->pb, buf, bufp - buf);
|
|
avio_write(s->pb, w->last_pkt->data + skip, w->last_pkt->size - skip);
|
|
av_packet_unref(w->last_pkt);
|
|
|
|
return trailer && writing_webp_header;
|
|
}
|
|
|
|
static int webp_write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
{
|
|
WebpContext *w = s->priv_data;
|
|
int ret;
|
|
|
|
if (!pkt->size)
|
|
return 0;
|
|
ret = is_animated_webp_packet(pkt);
|
|
if (ret < 0)
|
|
return ret;
|
|
w->using_webp_anim_encoder |= ret;
|
|
|
|
if (w->using_webp_anim_encoder) {
|
|
avio_write(s->pb, pkt->data, pkt->size);
|
|
w->wrote_webp_header = 1; // for good measure
|
|
} else {
|
|
int ret;
|
|
if ((ret = flush(s, 0, pkt->pts)) < 0)
|
|
return ret;
|
|
av_packet_ref(w->last_pkt, pkt);
|
|
}
|
|
++w->frame_count;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int webp_write_trailer(AVFormatContext *s)
|
|
{
|
|
unsigned filesize;
|
|
WebpContext *w = s->priv_data;
|
|
|
|
if (w->using_webp_anim_encoder) {
|
|
if (w->loop) { // Write loop count.
|
|
if (avio_seek(s->pb, 42, SEEK_SET) == 42)
|
|
avio_wl16(s->pb, w->loop);
|
|
}
|
|
} else {
|
|
int ret;
|
|
if ((ret = flush(s, 1, AV_NOPTS_VALUE)) < 0)
|
|
return ret;
|
|
|
|
if (!ret) {
|
|
filesize = avio_tell(s->pb);
|
|
if (avio_seek(s->pb, 4, SEEK_SET) == 4) {
|
|
avio_wl32(s->pb, filesize - 8);
|
|
// Note: without the following, avio only writes 8 bytes to the file.
|
|
avio_seek(s->pb, filesize, SEEK_SET);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define OFFSET(x) offsetof(WebpContext, x)
|
|
#define ENC AV_OPT_FLAG_ENCODING_PARAM
|
|
static const AVOption options[] = {
|
|
{ "loop", "Number of times to loop the output: 0 - infinite loop", OFFSET(loop),
|
|
AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 65535, ENC },
|
|
{ NULL },
|
|
};
|
|
|
|
static const AVClass webp_muxer_class = {
|
|
.class_name = "WebP muxer",
|
|
.item_name = av_default_item_name,
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
.option = options,
|
|
};
|
|
const FFOutputFormat ff_webp_muxer = {
|
|
.p.name = "webp",
|
|
.p.long_name = NULL_IF_CONFIG_SMALL("WebP"),
|
|
.p.extensions = "webp",
|
|
.priv_data_size = sizeof(WebpContext),
|
|
.p.video_codec = AV_CODEC_ID_WEBP,
|
|
.p.audio_codec = AV_CODEC_ID_NONE,
|
|
.p.subtitle_codec = AV_CODEC_ID_NONE,
|
|
.init = webp_init,
|
|
.write_packet = webp_write_packet,
|
|
.write_trailer = webp_write_trailer,
|
|
.p.priv_class = &webp_muxer_class,
|
|
.p.flags = AVFMT_VARIABLE_FPS,
|
|
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH |
|
|
FF_OFMT_FLAG_ONLY_DEFAULT_CODECS,
|
|
};
|