mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-12-27 01:42:20 +00:00
f4167842c1
More exactly: Not more than one stream of each type for which a default codec (i.e. AVOutputFormat.(audio|video|subtitle)_codec) is set; for those types for which no such codec is set (or for which no designated default codec in AVOutputFormat exists at all) no streams are permitted. Given that with this flag set the default codecs become more important, they are now set explicitly to AV_CODEC_ID_NONE for "unset"; the earlier code relied on AV_CODEC_ID_NONE being equal to zero, so that default static initialization set it accordingly; but this is not how one is supposed to use an enum. Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
577 lines
18 KiB
C
577 lines
18 KiB
C
/*
|
|
* Flash Compatible Streaming Format muxer
|
|
* Copyright (c) 2000 Fabrice Bellard
|
|
* Copyright (c) 2003 Tinic Uro
|
|
*
|
|
* 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 "config_components.h"
|
|
|
|
#include "libavcodec/put_bits.h"
|
|
#include "libavutil/avassert.h"
|
|
#include "libavutil/fifo.h"
|
|
#include "avformat.h"
|
|
#include "flv.h"
|
|
#include "mux.h"
|
|
#include "swf.h"
|
|
|
|
#define AUDIO_FIFO_SIZE 65536
|
|
|
|
typedef struct SWFEncContext {
|
|
int64_t duration_pos;
|
|
int64_t tag_pos;
|
|
int64_t vframes_pos;
|
|
int samples_per_frame;
|
|
int sound_samples;
|
|
int swf_frame_number;
|
|
int video_frame_number;
|
|
int tag;
|
|
AVFifo *audio_fifo;
|
|
AVCodecParameters *audio_par, *video_par;
|
|
AVStream *video_st;
|
|
} SWFEncContext;
|
|
|
|
static void put_swf_tag(AVFormatContext *s, int tag)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
AVIOContext *pb = s->pb;
|
|
|
|
swf->tag_pos = avio_tell(pb);
|
|
swf->tag = tag;
|
|
/* reserve some room for the tag */
|
|
if (tag & TAG_LONG) {
|
|
avio_wl16(pb, 0);
|
|
avio_wl32(pb, 0);
|
|
} else {
|
|
avio_wl16(pb, 0);
|
|
}
|
|
}
|
|
|
|
static void put_swf_end_tag(AVFormatContext *s)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
AVIOContext *pb = s->pb;
|
|
int64_t pos;
|
|
int tag_len, tag;
|
|
|
|
pos = avio_tell(pb);
|
|
tag_len = pos - swf->tag_pos - 2;
|
|
tag = swf->tag;
|
|
avio_seek(pb, swf->tag_pos, SEEK_SET);
|
|
if (tag & TAG_LONG) {
|
|
tag &= ~TAG_LONG;
|
|
avio_wl16(pb, (tag << 6) | 0x3f);
|
|
avio_wl32(pb, tag_len - 4);
|
|
} else {
|
|
av_assert0(tag_len < 0x3f);
|
|
avio_wl16(pb, (tag << 6) | tag_len);
|
|
}
|
|
avio_seek(pb, pos, SEEK_SET);
|
|
}
|
|
|
|
static inline void max_nbits(int *nbits_ptr, int val)
|
|
{
|
|
int n;
|
|
|
|
if (val == 0)
|
|
return;
|
|
val = FFABS(val);
|
|
n = 1;
|
|
while (val != 0) {
|
|
n++;
|
|
val >>= 1;
|
|
}
|
|
if (n > *nbits_ptr)
|
|
*nbits_ptr = n;
|
|
}
|
|
|
|
static void put_swf_rect(AVIOContext *pb,
|
|
int xmin, int xmax, int ymin, int ymax)
|
|
{
|
|
PutBitContext p;
|
|
uint8_t buf[256];
|
|
int nbits, mask;
|
|
|
|
init_put_bits(&p, buf, sizeof(buf));
|
|
|
|
nbits = 0;
|
|
max_nbits(&nbits, xmin);
|
|
max_nbits(&nbits, xmax);
|
|
max_nbits(&nbits, ymin);
|
|
max_nbits(&nbits, ymax);
|
|
mask = (1 << nbits) - 1;
|
|
|
|
/* rectangle info */
|
|
put_bits(&p, 5, nbits);
|
|
put_bits(&p, nbits, xmin & mask);
|
|
put_bits(&p, nbits, xmax & mask);
|
|
put_bits(&p, nbits, ymin & mask);
|
|
put_bits(&p, nbits, ymax & mask);
|
|
|
|
flush_put_bits(&p);
|
|
avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
|
|
}
|
|
|
|
static void put_swf_line_edge(PutBitContext *pb, int dx, int dy)
|
|
{
|
|
int nbits, mask;
|
|
|
|
put_bits(pb, 1, 1); /* edge */
|
|
put_bits(pb, 1, 1); /* line select */
|
|
nbits = 2;
|
|
max_nbits(&nbits, dx);
|
|
max_nbits(&nbits, dy);
|
|
|
|
mask = (1 << nbits) - 1;
|
|
put_bits(pb, 4, nbits - 2); /* 16 bits precision */
|
|
if (dx == 0) {
|
|
put_bits(pb, 1, 0);
|
|
put_bits(pb, 1, 1);
|
|
put_bits(pb, nbits, dy & mask);
|
|
} else if (dy == 0) {
|
|
put_bits(pb, 1, 0);
|
|
put_bits(pb, 1, 0);
|
|
put_bits(pb, nbits, dx & mask);
|
|
} else {
|
|
put_bits(pb, 1, 1);
|
|
put_bits(pb, nbits, dx & mask);
|
|
put_bits(pb, nbits, dy & mask);
|
|
}
|
|
}
|
|
|
|
#define FRAC_BITS 16
|
|
|
|
static void put_swf_matrix(AVIOContext *pb,
|
|
int a, int b, int c, int d, int tx, int ty)
|
|
{
|
|
PutBitContext p;
|
|
uint8_t buf[256];
|
|
int nbits;
|
|
|
|
init_put_bits(&p, buf, sizeof(buf));
|
|
|
|
put_bits(&p, 1, 1); /* a, d present */
|
|
nbits = 1;
|
|
max_nbits(&nbits, a);
|
|
max_nbits(&nbits, d);
|
|
put_bits(&p, 5, nbits); /* nb bits */
|
|
put_bits(&p, nbits, a);
|
|
put_bits(&p, nbits, d);
|
|
|
|
put_bits(&p, 1, 1); /* b, c present */
|
|
nbits = 1;
|
|
max_nbits(&nbits, c);
|
|
max_nbits(&nbits, b);
|
|
put_bits(&p, 5, nbits); /* nb bits */
|
|
put_bits(&p, nbits, c);
|
|
put_bits(&p, nbits, b);
|
|
|
|
nbits = 1;
|
|
max_nbits(&nbits, tx);
|
|
max_nbits(&nbits, ty);
|
|
put_bits(&p, 5, nbits); /* nb bits */
|
|
put_bits(&p, nbits, tx);
|
|
put_bits(&p, nbits, ty);
|
|
|
|
flush_put_bits(&p);
|
|
avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
|
|
}
|
|
|
|
static int swf_write_header(AVFormatContext *s)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
AVIOContext *pb = s->pb;
|
|
PutBitContext p;
|
|
uint8_t buf1[256];
|
|
int i, width, height, rate, rate_base;
|
|
int version;
|
|
|
|
swf->sound_samples = 0;
|
|
swf->swf_frame_number = 0;
|
|
swf->video_frame_number = 0;
|
|
|
|
for(i=0;i<s->nb_streams;i++) {
|
|
AVCodecParameters *par = s->streams[i]->codecpar;
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
|
if (par->codec_id == AV_CODEC_ID_MP3) {
|
|
swf->audio_par = par;
|
|
swf->audio_fifo = av_fifo_alloc2(AUDIO_FIFO_SIZE, 1, 0);
|
|
if (!swf->audio_fifo)
|
|
return AVERROR(ENOMEM);
|
|
} else {
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");
|
|
return -1;
|
|
}
|
|
} else {
|
|
if (ff_codec_get_tag(ff_swf_codec_tags, par->codec_id) ||
|
|
par->codec_id == AV_CODEC_ID_PNG ||
|
|
par->codec_id == AV_CODEC_ID_MJPEG) {
|
|
swf->video_st = s->streams[i];
|
|
swf->video_par = par;
|
|
} else {
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV, Flash Screen Video, PNG and MJPEG\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!swf->video_par) {
|
|
/* currently, cannot work correctly if audio only */
|
|
width = 320;
|
|
height = 200;
|
|
rate = 10;
|
|
rate_base= 1;
|
|
} else {
|
|
width = swf->video_par->width;
|
|
height = swf->video_par->height;
|
|
// TODO: should be avg_frame_rate
|
|
rate = swf->video_st->time_base.den;
|
|
rate_base = swf->video_st->time_base.num;
|
|
}
|
|
|
|
if (!swf->audio_par)
|
|
swf->samples_per_frame = (44100LL * rate_base) / rate;
|
|
else
|
|
swf->samples_per_frame = (swf->audio_par->sample_rate * rate_base) / rate;
|
|
|
|
avio_write(pb, "FWS", 3);
|
|
|
|
if (!strcmp("avm2", s->oformat->name))
|
|
version = 9;
|
|
else if (swf->video_par && (swf->video_par->codec_id == AV_CODEC_ID_VP6A ||
|
|
swf->video_par->codec_id == AV_CODEC_ID_VP6F ||
|
|
swf->video_par->codec_id == AV_CODEC_ID_PNG))
|
|
version = 8; /* version 8 and above support VP6 and PNG codec */
|
|
else if (swf->video_par && swf->video_par->codec_id == AV_CODEC_ID_FLASHSV)
|
|
version = 7; /* version 7 and above support Flash Screen Video codec */
|
|
else if (swf->video_par && swf->video_par->codec_id == AV_CODEC_ID_FLV1)
|
|
version = 6; /* version 6 and above support FLV1 codec */
|
|
else
|
|
version = 4; /* version 4 for mpeg audio support */
|
|
avio_w8(pb, version);
|
|
|
|
avio_wl32(pb, DUMMY_FILE_SIZE); /* dummy size
|
|
(will be patched if not streamed) */
|
|
|
|
put_swf_rect(pb, 0, width * 20, 0, height * 20);
|
|
if ((rate * 256LL) / rate_base >= (1<<16)) {
|
|
av_log(s, AV_LOG_ERROR, "Invalid (too large) frame rate %d/%d\n", rate, rate_base);
|
|
return AVERROR(EINVAL);
|
|
}
|
|
avio_wl16(pb, (rate * 256LL) / rate_base); /* frame rate */
|
|
swf->duration_pos = avio_tell(pb);
|
|
avio_wl16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
|
|
|
|
/* swf v8 and later files require a file attribute tag */
|
|
if (version >= 8) {
|
|
put_swf_tag(s, TAG_FILEATTRIBUTES);
|
|
avio_wl32(pb, (version >= 9) << 3); /* set ActionScript v3/AVM2 flag */
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
/* define a shape with the jpeg inside */
|
|
if (swf->video_par && (swf->video_par->codec_id == AV_CODEC_ID_MJPEG || swf->video_par->codec_id == AV_CODEC_ID_PNG)) {
|
|
put_swf_tag(s, TAG_DEFINESHAPE);
|
|
|
|
avio_wl16(pb, SHAPE_ID); /* ID of shape */
|
|
/* bounding rectangle */
|
|
put_swf_rect(pb, 0, width, 0, height);
|
|
/* style info */
|
|
avio_w8(pb, 1); /* one fill style */
|
|
avio_w8(pb, 0x41); /* clipped bitmap fill */
|
|
avio_wl16(pb, BITMAP_ID); /* bitmap ID */
|
|
/* position of the bitmap */
|
|
put_swf_matrix(pb, 1 << FRAC_BITS, 0,
|
|
0, 1 << FRAC_BITS, 0, 0);
|
|
avio_w8(pb, 0); /* no line style */
|
|
|
|
/* shape drawing */
|
|
init_put_bits(&p, buf1, sizeof(buf1));
|
|
put_bits(&p, 4, 1); /* one fill bit */
|
|
put_bits(&p, 4, 0); /* zero line bit */
|
|
|
|
put_bits(&p, 1, 0); /* not an edge */
|
|
put_bits(&p, 5, FLAG_MOVETO | FLAG_SETFILL0);
|
|
put_bits(&p, 5, 1); /* nbits */
|
|
put_bits(&p, 1, 0); /* X */
|
|
put_bits(&p, 1, 0); /* Y */
|
|
put_bits(&p, 1, 1); /* set fill style 1 */
|
|
|
|
/* draw the rectangle ! */
|
|
put_swf_line_edge(&p, width, 0);
|
|
put_swf_line_edge(&p, 0, height);
|
|
put_swf_line_edge(&p, -width, 0);
|
|
put_swf_line_edge(&p, 0, -height);
|
|
|
|
/* end of shape */
|
|
put_bits(&p, 1, 0); /* not an edge */
|
|
put_bits(&p, 5, 0);
|
|
|
|
flush_put_bits(&p);
|
|
avio_write(pb, buf1, put_bits_ptr(&p) - p.buf);
|
|
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
if (swf->audio_par && swf->audio_par->codec_id == AV_CODEC_ID_MP3) {
|
|
int v = 0;
|
|
|
|
/* start sound */
|
|
put_swf_tag(s, TAG_STREAMHEAD2);
|
|
switch(swf->audio_par->sample_rate) {
|
|
case 11025: v |= 1 << 2; break;
|
|
case 22050: v |= 2 << 2; break;
|
|
case 44100: v |= 3 << 2; break;
|
|
default:
|
|
/* not supported */
|
|
av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
|
|
return -1;
|
|
}
|
|
v |= 0x02; /* 16 bit playback */
|
|
if (swf->audio_par->ch_layout.nb_channels == 2)
|
|
v |= 0x01; /* stereo playback */
|
|
avio_w8(s->pb, v);
|
|
v |= 0x20; /* mp3 compressed */
|
|
avio_w8(s->pb, v);
|
|
avio_wl16(s->pb, swf->samples_per_frame); /* avg samples per frame */
|
|
avio_wl16(s->pb, 0);
|
|
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)
|
|
{
|
|
avio_write(opaque, buf, *nb_elems);
|
|
return 0;
|
|
}
|
|
|
|
static int swf_write_video(AVFormatContext *s,
|
|
AVCodecParameters *par, const uint8_t *buf, int size, unsigned pkt_flags)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
AVIOContext *pb = s->pb;
|
|
unsigned codec_tag = ff_codec_get_tag(ff_swf_codec_tags, par->codec_id);
|
|
|
|
/* Flash Player limit */
|
|
if (swf->swf_frame_number == 16000)
|
|
av_log(s, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
|
|
|
|
if (codec_tag) {
|
|
if (swf->video_frame_number == 0) {
|
|
/* create a new video object */
|
|
put_swf_tag(s, TAG_VIDEOSTREAM);
|
|
avio_wl16(pb, VIDEO_ID);
|
|
swf->vframes_pos = avio_tell(pb);
|
|
avio_wl16(pb, 15000); /* hard flash player limit */
|
|
avio_wl16(pb, par->width);
|
|
avio_wl16(pb, par->height);
|
|
avio_w8(pb, 0);
|
|
avio_w8(pb, codec_tag);
|
|
put_swf_end_tag(s);
|
|
|
|
/* place the video object for the first time */
|
|
put_swf_tag(s, TAG_PLACEOBJECT2);
|
|
avio_w8(pb, 0x36);
|
|
avio_wl16(pb, 1);
|
|
avio_wl16(pb, VIDEO_ID);
|
|
put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
|
|
avio_wl16(pb, swf->video_frame_number);
|
|
avio_write(pb, "video", 5);
|
|
avio_w8(pb, 0x00);
|
|
put_swf_end_tag(s);
|
|
} else {
|
|
/* mark the character for update */
|
|
put_swf_tag(s, TAG_PLACEOBJECT2);
|
|
avio_w8(pb, 0x11);
|
|
avio_wl16(pb, 1);
|
|
avio_wl16(pb, swf->video_frame_number);
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
/* set video frame data */
|
|
put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
|
|
avio_wl16(pb, VIDEO_ID);
|
|
avio_wl16(pb, swf->video_frame_number++);
|
|
if (par->codec_id == AV_CODEC_ID_FLASHSV) {
|
|
/* FrameType and CodecId is needed here even if it is not documented correctly in the SWF specs */
|
|
int flags = codec_tag | (pkt_flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER);
|
|
avio_w8(pb, flags);
|
|
}
|
|
avio_write(pb, buf, size);
|
|
put_swf_end_tag(s);
|
|
} else if (par->codec_id == AV_CODEC_ID_MJPEG || par->codec_id == AV_CODEC_ID_PNG) {
|
|
if (swf->swf_frame_number > 0) {
|
|
/* remove the shape */
|
|
put_swf_tag(s, TAG_REMOVEOBJECT);
|
|
avio_wl16(pb, SHAPE_ID); /* shape ID */
|
|
avio_wl16(pb, 1); /* depth */
|
|
put_swf_end_tag(s);
|
|
|
|
/* free the bitmap */
|
|
put_swf_tag(s, TAG_FREECHARACTER);
|
|
avio_wl16(pb, BITMAP_ID);
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
|
|
|
|
avio_wl16(pb, BITMAP_ID); /* ID of the image */
|
|
|
|
/* a dummy jpeg header seems to be required */
|
|
if (par->codec_id == AV_CODEC_ID_MJPEG)
|
|
avio_wb32(pb, 0xffd8ffd9);
|
|
/* write the jpeg/png image */
|
|
avio_write(pb, buf, size);
|
|
|
|
put_swf_end_tag(s);
|
|
|
|
/* draw the shape */
|
|
|
|
put_swf_tag(s, TAG_PLACEOBJECT);
|
|
avio_wl16(pb, SHAPE_ID); /* shape ID */
|
|
avio_wl16(pb, 1); /* depth */
|
|
put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
|
|
put_swf_end_tag(s);
|
|
}
|
|
|
|
swf->swf_frame_number++;
|
|
|
|
/* streaming sound always should be placed just before showframe tags */
|
|
if (swf->audio_par && av_fifo_can_read(swf->audio_fifo)) {
|
|
size_t frame_size = av_fifo_can_read(swf->audio_fifo);
|
|
put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
|
|
avio_wl16(pb, swf->sound_samples);
|
|
avio_wl16(pb, 0); // seek samples
|
|
av_fifo_read_to_cb(swf->audio_fifo, fifo_avio_wrapper, pb, &frame_size);
|
|
put_swf_end_tag(s);
|
|
|
|
/* update FIFO */
|
|
swf->sound_samples = 0;
|
|
}
|
|
|
|
/* output the frame */
|
|
put_swf_tag(s, TAG_SHOWFRAME);
|
|
put_swf_end_tag(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int swf_write_audio(AVFormatContext *s, AVCodecParameters *par,
|
|
const uint8_t *buf, int size)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
|
|
/* Flash Player limit */
|
|
if (swf->swf_frame_number == 16000)
|
|
av_log(s, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
|
|
|
|
if (av_fifo_can_write(swf->audio_fifo) < size) {
|
|
av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");
|
|
return -1;
|
|
}
|
|
|
|
av_fifo_write(swf->audio_fifo, buf, size);
|
|
swf->sound_samples += av_get_audio_frame_duration2(par, size);
|
|
|
|
/* if audio only stream make sure we add swf frames */
|
|
if (!swf->video_par)
|
|
swf_write_video(s, par, 0, 0, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
{
|
|
AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO)
|
|
return swf_write_audio(s, par, pkt->data, pkt->size);
|
|
else
|
|
return swf_write_video(s, par, pkt->data, pkt->size, pkt->flags);
|
|
}
|
|
|
|
static int swf_write_trailer(AVFormatContext *s)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
AVIOContext *pb = s->pb;
|
|
int file_size;
|
|
|
|
put_swf_tag(s, TAG_END);
|
|
put_swf_end_tag(s);
|
|
|
|
/* patch file size and number of frames if not streamed */
|
|
if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && swf->video_par) {
|
|
file_size = avio_tell(pb);
|
|
avio_seek(pb, 4, SEEK_SET);
|
|
avio_wl32(pb, file_size);
|
|
avio_seek(pb, swf->duration_pos, SEEK_SET);
|
|
avio_wl16(pb, swf->video_frame_number);
|
|
if (swf->vframes_pos) {
|
|
avio_seek(pb, swf->vframes_pos, SEEK_SET);
|
|
avio_wl16(pb, swf->video_frame_number);
|
|
}
|
|
avio_seek(pb, file_size, SEEK_SET);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void swf_deinit(AVFormatContext *s)
|
|
{
|
|
SWFEncContext *swf = s->priv_data;
|
|
|
|
av_fifo_freep2(&swf->audio_fifo);
|
|
}
|
|
|
|
#if CONFIG_SWF_MUXER
|
|
const FFOutputFormat ff_swf_muxer = {
|
|
.p.name = "swf",
|
|
.p.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
|
|
.p.mime_type = "application/x-shockwave-flash",
|
|
.p.extensions = "swf",
|
|
.priv_data_size = sizeof(SWFEncContext),
|
|
.p.audio_codec = AV_CODEC_ID_MP3,
|
|
.p.video_codec = AV_CODEC_ID_FLV1,
|
|
.p.subtitle_codec = AV_CODEC_ID_NONE,
|
|
.write_header = swf_write_header,
|
|
.write_packet = swf_write_packet,
|
|
.write_trailer = swf_write_trailer,
|
|
.deinit = swf_deinit,
|
|
.p.flags = AVFMT_TS_NONSTRICT,
|
|
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
|
|
};
|
|
#endif
|
|
#if CONFIG_AVM2_MUXER
|
|
const FFOutputFormat ff_avm2_muxer = {
|
|
.p.name = "avm2",
|
|
.p.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash) (AVM2)"),
|
|
.p.mime_type = "application/x-shockwave-flash",
|
|
.priv_data_size = sizeof(SWFEncContext),
|
|
.p.audio_codec = AV_CODEC_ID_MP3,
|
|
.p.video_codec = AV_CODEC_ID_FLV1,
|
|
.p.subtitle_codec = AV_CODEC_ID_NONE,
|
|
.write_header = swf_write_header,
|
|
.write_packet = swf_write_packet,
|
|
.write_trailer = swf_write_trailer,
|
|
.deinit = swf_deinit,
|
|
.p.flags = AVFMT_TS_NONSTRICT,
|
|
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
|
|
};
|
|
#endif
|