2001-07-22 14:18:56 +00:00
|
|
|
/*
|
2008-05-26 03:56:43 +00:00
|
|
|
* Flash Compatible Streaming Format muxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2000 Fabrice Bellard
|
|
|
|
* Copyright (c) 2003 Tinic Uro
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2002-05-25 22:33:18 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2001-07-22 14:18:56 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2002-05-25 22:33:18 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2002-05-25 22:33:18 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2001-07-22 14:18:56 +00:00
|
|
|
*/
|
2008-05-09 11:56:36 +00:00
|
|
|
|
2009-04-12 08:35:26 +00:00
|
|
|
#include "libavcodec/put_bits.h"
|
2012-06-07 19:30:07 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2001-07-22 14:18:56 +00:00
|
|
|
#include "avformat.h"
|
2008-05-20 23:31:10 +00:00
|
|
|
#include "swf.h"
|
2007-03-02 10:32:08 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
static void put_swf_tag(AVFormatContext *s, int tag)
|
|
|
|
{
|
|
|
|
SWFContext *swf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2011-03-03 19:11:45 +00:00
|
|
|
swf->tag_pos = avio_tell(pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
swf->tag = tag;
|
|
|
|
/* reserve some room for the tag */
|
|
|
|
if (tag & TAG_LONG) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0);
|
|
|
|
avio_wl32(pb, 0);
|
2001-07-22 14:18:56 +00:00
|
|
|
} else {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 0);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_swf_end_tag(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
SWFContext *swf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t pos;
|
2001-07-22 14:18:56 +00:00
|
|
|
int tag_len, tag;
|
|
|
|
|
2011-03-03 19:11:45 +00:00
|
|
|
pos = avio_tell(pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
tag_len = pos - swf->tag_pos - 2;
|
|
|
|
tag = swf->tag;
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, swf->tag_pos, SEEK_SET);
|
2001-07-22 14:18:56 +00:00
|
|
|
if (tag & TAG_LONG) {
|
|
|
|
tag &= ~TAG_LONG;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, (tag << 6) | 0x3f);
|
|
|
|
avio_wl32(pb, tag_len - 4);
|
2001-07-22 14:18:56 +00:00
|
|
|
} else {
|
2012-06-07 19:30:07 +00:00
|
|
|
av_assert0(tag_len < 0x3f);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, (tag << 6) | tag_len);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, pos, SEEK_SET);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void max_nbits(int *nbits_ptr, int val)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (val == 0)
|
|
|
|
return;
|
2017-11-20 02:51:06 +00:00
|
|
|
val = FFABS(val);
|
2001-07-22 14:18:56 +00:00
|
|
|
n = 1;
|
|
|
|
while (val != 0) {
|
|
|
|
n++;
|
|
|
|
val >>= 1;
|
|
|
|
}
|
|
|
|
if (n > *nbits_ptr)
|
|
|
|
*nbits_ptr = n;
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void put_swf_rect(AVIOContext *pb,
|
2001-07-22 14:18:56 +00:00
|
|
|
int xmin, int xmax, int ymin, int ymax)
|
|
|
|
{
|
|
|
|
PutBitContext p;
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t buf[256];
|
2001-07-22 14:18:56 +00:00
|
|
|
int nbits, mask;
|
|
|
|
|
2003-10-13 10:59:57 +00:00
|
|
|
init_put_bits(&p, buf, sizeof(buf));
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
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);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
flush_put_bits(&p);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
2007-08-05 01:36:31 +00:00
|
|
|
put_bits(pb, 1, 0);
|
|
|
|
put_bits(pb, 1, 1);
|
|
|
|
put_bits(pb, nbits, dy & mask);
|
2001-07-22 14:18:56 +00:00
|
|
|
} else if (dy == 0) {
|
2007-08-05 01:36:31 +00:00
|
|
|
put_bits(pb, 1, 0);
|
|
|
|
put_bits(pb, 1, 0);
|
|
|
|
put_bits(pb, nbits, dx & mask);
|
2001-07-22 14:18:56 +00:00
|
|
|
} else {
|
2007-08-05 01:36:31 +00:00
|
|
|
put_bits(pb, 1, 1);
|
|
|
|
put_bits(pb, nbits, dx & mask);
|
|
|
|
put_bits(pb, nbits, dy & mask);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FRAC_BITS 16
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void put_swf_matrix(AVIOContext *pb,
|
2001-07-22 14:18:56 +00:00
|
|
|
int a, int b, int c, int d, int tx, int ty)
|
|
|
|
{
|
|
|
|
PutBitContext p;
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t buf[256];
|
2004-02-06 23:56:37 +00:00
|
|
|
int nbits;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2003-10-13 10:59:57 +00:00
|
|
|
init_put_bits(&p, buf, sizeof(buf));
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
put_bits(&p, 1, 1); /* a, d present */
|
2004-02-06 23:56:37 +00:00
|
|
|
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);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
put_bits(&p, 1, 1); /* b, c present */
|
2004-02-06 23:56:37 +00:00
|
|
|
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);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
|
|
|
flush_put_bits(&p);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, put_bits_ptr(&p) - p.buf);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swf_write_header(AVFormatContext *s)
|
|
|
|
{
|
2007-01-08 12:33:16 +00:00
|
|
|
SWFContext *swf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2001-07-22 14:18:56 +00:00
|
|
|
PutBitContext p;
|
2003-02-11 16:35:48 +00:00
|
|
|
uint8_t buf1[256];
|
2003-03-12 15:16:19 +00:00
|
|
|
int i, width, height, rate, rate_base;
|
2008-05-27 03:11:31 +00:00
|
|
|
int version;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
swf->sound_samples = 0;
|
|
|
|
swf->swf_frame_number = 0;
|
|
|
|
swf->video_frame_number = 0;
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
for(i=0;i<s->nb_streams;i++) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par = s->streams[i]->codecpar;
|
|
|
|
if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
|
|
|
if (swf->audio_par) {
|
2012-10-09 12:48:08 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports 1 audio stream\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_MP3) {
|
|
|
|
swf->audio_par = par;
|
2009-03-08 14:16:55 +00:00
|
|
|
swf->audio_fifo= av_fifo_alloc(AUDIO_FIFO_SIZE);
|
2009-05-21 23:12:41 +00:00
|
|
|
if (!swf->audio_fifo)
|
|
|
|
return AVERROR(ENOMEM);
|
2007-03-04 22:30:25 +00:00
|
|
|
} else {
|
2007-03-05 10:07:42 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports MP3\n");
|
2007-03-04 22:30:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (swf->video_par) {
|
2012-10-09 12:48:08 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports 1 video stream\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_VP6F ||
|
|
|
|
par->codec_id == AV_CODEC_ID_FLV1 ||
|
|
|
|
par->codec_id == AV_CODEC_ID_MJPEG) {
|
2014-05-18 10:12:59 +00:00
|
|
|
swf->video_st = s->streams[i];
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
swf->video_par = par;
|
2004-02-06 23:56:37 +00:00
|
|
|
} else {
|
2007-03-05 10:07:42 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "SWF muxer only supports VP6, FLV1 and MJPEG\n");
|
2004-02-06 23:56:37 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (!swf->video_par) {
|
2007-07-28 12:46:26 +00:00
|
|
|
/* currently, cannot work correctly if audio only */
|
2001-07-22 14:18:56 +00:00
|
|
|
width = 320;
|
|
|
|
height = 200;
|
2003-03-12 15:16:19 +00:00
|
|
|
rate = 10;
|
|
|
|
rate_base= 1;
|
2001-07-22 14:18:56 +00:00
|
|
|
} else {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
width = swf->video_par->width;
|
|
|
|
height = swf->video_par->height;
|
2014-05-18 10:12:59 +00:00
|
|
|
// TODO: should be avg_frame_rate
|
|
|
|
rate = swf->video_st->time_base.den;
|
|
|
|
rate_base = swf->video_st->time_base.num;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (!swf->audio_par)
|
2015-05-24 10:38:54 +00:00
|
|
|
swf->samples_per_frame = (44100LL * rate_base) / rate;
|
2008-05-27 22:31:09 +00:00
|
|
|
else
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
swf->samples_per_frame = (swf->audio_par->sample_rate * rate_base) / rate;
|
2004-02-06 23:56:37 +00:00
|
|
|
|
2011-02-24 06:36:04 +00:00
|
|
|
avio_write(pb, "FWS", 3);
|
2008-05-27 03:11:31 +00:00
|
|
|
|
|
|
|
if (!strcmp("avm2", s->oformat->name))
|
|
|
|
version = 9;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
else if (swf->video_par && swf->video_par->codec_id == AV_CODEC_ID_VP6F)
|
2008-05-27 03:11:31 +00:00
|
|
|
version = 8; /* version 8 and above support VP6 codec */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
else if (swf->video_par && swf->video_par->codec_id == AV_CODEC_ID_FLV1)
|
2008-05-27 03:11:31 +00:00
|
|
|
version = 6; /* version 6 and above support FLV1 codec */
|
2008-05-27 02:55:34 +00:00
|
|
|
else
|
2008-05-27 03:11:31 +00:00
|
|
|
version = 4; /* version 4 for mpeg audio support */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, version);
|
2008-05-27 03:11:31 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, DUMMY_FILE_SIZE); /* dummy size
|
2005-12-17 18:14:38 +00:00
|
|
|
(will be patched if not streamed) */
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_rect(pb, 0, width * 20, 0, height * 20);
|
2015-12-17 00:23:43 +00:00
|
|
|
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);
|
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, (rate * 256) / rate_base); /* frame rate */
|
2011-03-03 19:11:45 +00:00
|
|
|
swf->duration_pos = avio_tell(pb);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2008-01-20 18:30:04 +00:00
|
|
|
/* avm2/swf v9 (also v8?) files require a file attribute tag */
|
2008-05-27 03:11:31 +00:00
|
|
|
if (version == 9) {
|
2008-01-20 18:30:04 +00:00
|
|
|
put_swf_tag(s, TAG_FILEATTRIBUTES);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, 1<<3); /* set ActionScript v3/AVM2 flag */
|
2008-01-20 18:30:04 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* define a shape with the jpeg inside */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (swf->video_par && swf->video_par->codec_id == AV_CODEC_ID_MJPEG) {
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_tag(s, TAG_DEFINESHAPE);
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, SHAPE_ID); /* ID of shape */
|
2004-02-06 23:56:37 +00:00
|
|
|
/* bounding rectangle */
|
|
|
|
put_swf_rect(pb, 0, width, 0, height);
|
|
|
|
/* style info */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 1); /* one fill style */
|
|
|
|
avio_w8(pb, 0x41); /* clipped bitmap fill */
|
|
|
|
avio_wl16(pb, BITMAP_ID); /* bitmap ID */
|
2004-02-06 23:56:37 +00:00
|
|
|
/* position of the bitmap */
|
2015-05-24 01:59:26 +00:00
|
|
|
put_swf_matrix(pb, 1 << FRAC_BITS, 0,
|
|
|
|
0, 1 << FRAC_BITS, 0, 0);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0); /* no line style */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* 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 */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
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 */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* 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);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* end of shape */
|
|
|
|
put_bits(&p, 1, 0); /* not an edge */
|
|
|
|
put_bits(&p, 5, 0);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
flush_put_bits(&p);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf1, put_bits_ptr(&p) - p.buf);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (swf->audio_par && swf->audio_par->codec_id == AV_CODEC_ID_MP3) {
|
2008-05-27 03:41:51 +00:00
|
|
|
int v = 0;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
|
|
|
/* start sound */
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_tag(s, TAG_STREAMHEAD2);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch(swf->audio_par->sample_rate) {
|
2008-05-27 03:42:55 +00:00
|
|
|
case 11025: v |= 1 << 2; break;
|
|
|
|
case 22050: v |= 2 << 2; break;
|
|
|
|
case 44100: v |= 3 << 2; break;
|
2001-07-22 14:18:56 +00:00
|
|
|
default:
|
|
|
|
/* not supported */
|
2007-06-12 09:29:25 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "swf does not support that sample rate, choose from (44100, 22050, 11025).\n");
|
2001-07-22 14:18:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2004-02-06 23:56:37 +00:00
|
|
|
v |= 0x02; /* 16 bit playback */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (swf->audio_par->channels == 2)
|
2004-02-06 23:56:37 +00:00
|
|
|
v |= 0x01; /* stereo playback */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s->pb, v);
|
2001-07-22 14:18:56 +00:00
|
|
|
v |= 0x20; /* mp3 compressed */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s->pb, v);
|
|
|
|
avio_wl16(s->pb, swf->samples_per_frame); /* avg samples per frame */
|
|
|
|
avio_wl16(s->pb, 0);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
static int swf_write_video(AVFormatContext *s,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par, const uint8_t *buf, int size)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2004-02-06 23:56:37 +00:00
|
|
|
SWFContext *swf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* Flash Player limit */
|
2008-05-27 02:55:34 +00:00
|
|
|
if (swf->swf_frame_number == 16000)
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
|
2001-07-22 14:18:56 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->codec_id == AV_CODEC_ID_VP6F ||
|
|
|
|
par->codec_id == AV_CODEC_ID_FLV1) {
|
2007-08-05 01:40:07 +00:00
|
|
|
if (swf->video_frame_number == 0) {
|
2007-08-05 01:36:31 +00:00
|
|
|
/* create a new video object */
|
|
|
|
put_swf_tag(s, TAG_VIDEOSTREAM);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, VIDEO_ID);
|
2011-03-03 19:11:45 +00:00
|
|
|
swf->vframes_pos = avio_tell(pb);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, 15000); /* hard flash player limit */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_wl16(pb, par->width);
|
|
|
|
avio_wl16(pb, par->height);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
avio_w8(pb,ff_codec_get_tag(ff_swf_codec_tags, par->codec_id));
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
|
|
|
|
/* place the video object for the first time */
|
|
|
|
put_swf_tag(s, TAG_PLACEOBJECT2);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x36);
|
|
|
|
avio_wl16(pb, 1);
|
|
|
|
avio_wl16(pb, VIDEO_ID);
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_matrix(pb, 1 << FRAC_BITS, 0, 0, 1 << FRAC_BITS, 0, 0);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, swf->video_frame_number);
|
2011-02-24 06:36:04 +00:00
|
|
|
avio_write(pb, "video", 5);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x00);
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
} else {
|
|
|
|
/* mark the character for update */
|
|
|
|
put_swf_tag(s, TAG_PLACEOBJECT2);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x11);
|
|
|
|
avio_wl16(pb, 1);
|
|
|
|
avio_wl16(pb, swf->video_frame_number);
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
/* set video frame data */
|
|
|
|
put_swf_tag(s, TAG_VIDEOFRAME | TAG_LONG);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, VIDEO_ID);
|
|
|
|
avio_wl16(pb, swf->video_frame_number++);
|
|
|
|
avio_write(pb, buf, size);
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
} else if (par->codec_id == AV_CODEC_ID_MJPEG) {
|
2007-08-05 01:36:31 +00:00
|
|
|
if (swf->swf_frame_number > 0) {
|
|
|
|
/* remove the shape */
|
|
|
|
put_swf_tag(s, TAG_REMOVEOBJECT);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, SHAPE_ID); /* shape ID */
|
|
|
|
avio_wl16(pb, 1); /* depth */
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
|
|
|
|
/* free the bitmap */
|
|
|
|
put_swf_tag(s, TAG_FREECHARACTER);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, BITMAP_ID);
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_tag(s, TAG_JPEG2 | TAG_LONG);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, BITMAP_ID); /* ID of the image */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
/* a dummy jpeg header seems to be required */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(pb, 0xffd8ffd9);
|
2007-08-05 01:36:31 +00:00
|
|
|
/* write the jpeg image */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, size);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_end_tag(s);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
/* draw the shape */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_tag(s, TAG_PLACEOBJECT);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, SHAPE_ID); /* shape ID */
|
|
|
|
avio_wl16(pb, 1); /* depth */
|
2007-08-05 01:36:31 +00:00
|
|
|
put_swf_matrix(pb, 20 << FRAC_BITS, 0, 0, 20 << FRAC_BITS, 0, 0);
|
|
|
|
put_swf_end_tag(s);
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2008-05-27 22:34:31 +00:00
|
|
|
swf->swf_frame_number++;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* streaming sound always should be placed just before showframe tags */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (swf->audio_par && av_fifo_size(swf->audio_fifo)) {
|
2009-03-08 14:16:55 +00:00
|
|
|
int frame_size = av_fifo_size(swf->audio_fifo);
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_tag(s, TAG_STREAMBLOCK | TAG_LONG);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, swf->sound_samples);
|
|
|
|
avio_wl16(pb, 0); // seek samples
|
2011-04-24 15:46:50 +00:00
|
|
|
av_fifo_generic_read(swf->audio_fifo, pb, frame_size, (void*)avio_write);
|
2004-02-06 23:56:37 +00:00
|
|
|
put_swf_end_tag(s);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* update FIFO */
|
2007-03-04 22:30:25 +00:00
|
|
|
swf->sound_samples = 0;
|
2004-02-06 23:56:37 +00:00
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* output the frame */
|
|
|
|
put_swf_tag(s, TAG_SHOWFRAME);
|
|
|
|
put_swf_end_tag(s);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
static int swf_write_audio(AVFormatContext *s,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par, uint8_t *buf, int size)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
2004-02-06 23:56:37 +00:00
|
|
|
SWFContext *swf = s->priv_data;
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* Flash Player limit */
|
2008-05-27 02:55:34 +00:00
|
|
|
if (swf->swf_frame_number == 16000)
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
av_log(s, AV_LOG_INFO, "warning: Flash Player limit of 16000 frames reached\n");
|
2004-02-06 23:56:37 +00:00
|
|
|
|
2009-03-08 14:16:55 +00:00
|
|
|
if (av_fifo_size(swf->audio_fifo) + size > AUDIO_FIFO_SIZE) {
|
2007-03-04 22:30:25 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "audio fifo too small to mux audio essence\n");
|
|
|
|
return -1;
|
2004-02-06 23:56:37 +00:00
|
|
|
}
|
|
|
|
|
2009-03-08 14:16:55 +00:00
|
|
|
av_fifo_generic_write(swf->audio_fifo, buf, size, NULL);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
swf->sound_samples += av_get_audio_frame_duration2(par, size);
|
2007-03-04 22:30:25 +00:00
|
|
|
|
2004-02-06 23:56:37 +00:00
|
|
|
/* if audio only stream make sure we add swf frames */
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (!swf->video_par)
|
|
|
|
swf_write_video(s, par, 0, 0);
|
2001-07-22 14:18:56 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-05-29 02:06:32 +00:00
|
|
|
static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
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);
|
2001-07-22 14:18:56 +00:00
|
|
|
else
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
return swf_write_video(s, par, pkt->data, pkt->size);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swf_write_trailer(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
SWFContext *swf = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par, *video_par;
|
2001-07-22 14:18:56 +00:00
|
|
|
int file_size, i;
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
video_par = NULL;
|
2001-07-22 14:18:56 +00:00
|
|
|
for(i=0;i<s->nb_streams;i++) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
par = s->streams[i]->codecpar;
|
|
|
|
if (par->codec_type == AVMEDIA_TYPE_VIDEO)
|
|
|
|
video_par = par;
|
2012-10-27 21:02:17 +00:00
|
|
|
else {
|
2014-05-06 19:48:14 +00:00
|
|
|
av_fifo_freep(&swf->audio_fifo);
|
2012-10-27 21:02:17 +00:00
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
put_swf_tag(s, TAG_END);
|
|
|
|
put_swf_end_tag(s);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* patch file size and number of frames if not streamed */
|
2016-09-27 14:26:37 +00:00
|
|
|
if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && video_par) {
|
2011-03-03 19:11:45 +00:00
|
|
|
file_size = avio_tell(pb);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, 4, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl32(pb, file_size);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, swf->duration_pos, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, swf->video_frame_number);
|
2012-09-12 11:08:27 +00:00
|
|
|
if (swf->vframes_pos) {
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, swf->vframes_pos, SEEK_SET);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wl16(pb, swf->video_frame_number);
|
2012-09-12 11:08:27 +00:00
|
|
|
}
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, file_size, SEEK_SET);
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-13 23:44:16 +00:00
|
|
|
#if CONFIG_SWF_MUXER
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_swf_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "swf",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.mime_type = "application/x-shockwave-flash",
|
|
|
|
.extensions = "swf",
|
|
|
|
.priv_data_size = sizeof(SWFContext),
|
2012-08-05 09:11:04 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_MP3,
|
|
|
|
.video_codec = AV_CODEC_ID_FLV1,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = swf_write_header,
|
|
|
|
.write_packet = swf_write_packet,
|
|
|
|
.write_trailer = swf_write_trailer,
|
2011-05-26 18:19:04 +00:00
|
|
|
.flags = AVFMT_TS_NONSTRICT,
|
2001-07-22 14:18:56 +00:00
|
|
|
};
|
2006-07-10 21:14:37 +00:00
|
|
|
#endif
|
2009-01-13 23:44:16 +00:00
|
|
|
#if CONFIG_AVM2_MUXER
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_avm2_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "avm2",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("SWF (ShockWave Flash) (AVM2)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.mime_type = "application/x-shockwave-flash",
|
|
|
|
.priv_data_size = sizeof(SWFContext),
|
2012-08-05 09:11:04 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_MP3,
|
|
|
|
.video_codec = AV_CODEC_ID_FLV1,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = swf_write_header,
|
|
|
|
.write_packet = swf_write_packet,
|
|
|
|
.write_trailer = swf_write_trailer,
|
2011-05-26 18:19:04 +00:00
|
|
|
.flags = AVFMT_TS_NONSTRICT,
|
2008-01-20 18:30:04 +00:00
|
|
|
};
|
|
|
|
#endif
|