2007-05-30 09:44:16 +00:00
|
|
|
/*
|
|
|
|
* "Real" compatible muxer.
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2000, 2001 Fabrice Bellard
|
2007-05-30 09:44:16 +00:00
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* This file is part of Libav.
|
2007-05-30 09:44:16 +00:00
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* Libav is free software; you can redistribute it and/or
|
2007-05-30 09:44:16 +00:00
|
|
|
* 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.
|
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* Libav is distributed in the hope that it will be useful,
|
2007-05-30 09:44:16 +00:00
|
|
|
* 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
|
2011-03-18 17:35:10 +00:00
|
|
|
* License along with Libav; if not, write to the Free Software
|
2007-05-30 09:44:16 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include "avformat.h"
|
2011-02-24 06:36:02 +00:00
|
|
|
#include "avio_internal.h"
|
2007-05-30 09:44:16 +00:00
|
|
|
#include "rm.h"
|
2011-05-22 10:46:29 +00:00
|
|
|
#include "libavutil/dict.h"
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2014-09-22 07:19:33 +00:00
|
|
|
typedef struct StreamInfo {
|
2008-12-13 21:40:20 +00:00
|
|
|
int nb_packets;
|
|
|
|
int packet_total_size;
|
|
|
|
int packet_max_size;
|
|
|
|
/* codec related output */
|
|
|
|
int bit_rate;
|
|
|
|
float frame_rate;
|
|
|
|
int nb_frames; /* current frame number */
|
|
|
|
int total_frames; /* total number of frames */
|
|
|
|
int num;
|
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;
|
2008-12-13 21:40:20 +00:00
|
|
|
} StreamInfo;
|
|
|
|
|
2014-09-22 07:19:33 +00:00
|
|
|
typedef struct RMMuxContext {
|
2008-12-13 21:40:20 +00:00
|
|
|
StreamInfo streams[2];
|
|
|
|
StreamInfo *audio_stream, *video_stream;
|
|
|
|
int data_pos; /* position of the data after the header */
|
|
|
|
} RMMuxContext;
|
|
|
|
|
2007-05-30 09:44:16 +00:00
|
|
|
/* in ms */
|
|
|
|
#define BUFFER_DURATION 0
|
2015-03-02 15:52:26 +00:00
|
|
|
/* the header needs at most 7 + 4 + 12 B */
|
|
|
|
#define MAX_HEADER_SIZE (7 + 4 + 12)
|
|
|
|
/* UINT16_MAX is the maximal chunk size */
|
|
|
|
#define MAX_PACKET_SIZE (UINT16_MAX - MAX_HEADER_SIZE)
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void put_str(AVIOContext *s, const char *tag)
|
2007-05-30 09:44:16 +00:00
|
|
|
{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s,strlen(tag));
|
2007-05-30 09:44:16 +00:00
|
|
|
while (*tag) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, *tag++);
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static void put_str8(AVIOContext *s, const char *tag)
|
2007-05-30 09:44:16 +00:00
|
|
|
{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, strlen(tag));
|
2007-05-30 09:44:16 +00:00
|
|
|
while (*tag) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, *tag++);
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-28 18:21:25 +00:00
|
|
|
static int rv10_write_header(AVFormatContext *ctx,
|
2010-05-28 18:21:57 +00:00
|
|
|
int data_size, int index_pos)
|
2007-05-30 09:44:16 +00:00
|
|
|
{
|
2008-12-13 21:40:20 +00:00
|
|
|
RMMuxContext *rm = ctx->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *s = ctx->pb;
|
2007-05-30 09:44:16 +00:00
|
|
|
StreamInfo *stream;
|
|
|
|
unsigned char *data_offset_ptr, *start_ptr;
|
|
|
|
const char *desc, *mimetype;
|
|
|
|
int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
|
|
|
|
int bit_rate, v, duration, flags, data_pos;
|
2011-05-22 10:46:29 +00:00
|
|
|
AVDictionaryEntry *tag;
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
start_ptr = s->buf_ptr;
|
|
|
|
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s, ".RMF");
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,18); /* header size */
|
|
|
|
avio_wb16(s,0);
|
|
|
|
avio_wb32(s,0);
|
|
|
|
avio_wb32(s,4 + ctx->nb_streams); /* num headers */
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s,"PROP");
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, 50);
|
|
|
|
avio_wb16(s, 0);
|
2007-05-30 09:44:16 +00:00
|
|
|
packet_max_size = 0;
|
|
|
|
packet_total_size = 0;
|
|
|
|
nb_packets = 0;
|
|
|
|
bit_rate = 0;
|
|
|
|
duration = 0;
|
|
|
|
for(i=0;i<ctx->nb_streams;i++) {
|
|
|
|
StreamInfo *stream = &rm->streams[i];
|
|
|
|
bit_rate += stream->bit_rate;
|
|
|
|
if (stream->packet_max_size > packet_max_size)
|
|
|
|
packet_max_size = stream->packet_max_size;
|
|
|
|
nb_packets += stream->nb_packets;
|
|
|
|
packet_total_size += stream->packet_total_size;
|
|
|
|
/* select maximum duration */
|
|
|
|
v = (int) (1000.0 * (float)stream->total_frames / stream->frame_rate);
|
|
|
|
if (v > duration)
|
|
|
|
duration = v;
|
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, bit_rate); /* max bit rate */
|
|
|
|
avio_wb32(s, bit_rate); /* avg bit rate */
|
|
|
|
avio_wb32(s, packet_max_size); /* max packet size */
|
2007-05-30 09:44:16 +00:00
|
|
|
if (nb_packets > 0)
|
|
|
|
packet_avg_size = packet_total_size / nb_packets;
|
|
|
|
else
|
|
|
|
packet_avg_size = 0;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, packet_avg_size); /* avg packet size */
|
|
|
|
avio_wb32(s, nb_packets); /* num packets */
|
|
|
|
avio_wb32(s, duration); /* duration */
|
|
|
|
avio_wb32(s, BUFFER_DURATION); /* preroll */
|
|
|
|
avio_wb32(s, index_pos); /* index offset */
|
2007-05-30 09:44:16 +00:00
|
|
|
/* computation of data the data offset */
|
|
|
|
data_offset_ptr = s->buf_ptr;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, 0); /* data offset : will be patched after */
|
|
|
|
avio_wb16(s, ctx->nb_streams); /* num streams */
|
2007-05-30 09:44:16 +00:00
|
|
|
flags = 1 | 2; /* save allowed & perfect play */
|
2016-09-27 14:26:37 +00:00
|
|
|
if (!(s->seekable & AVIO_SEEKABLE_NORMAL))
|
2007-05-30 09:44:16 +00:00
|
|
|
flags |= 4; /* live broadcast */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, flags);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
/* comments */
|
|
|
|
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s,"CONT");
|
2009-02-17 21:40:38 +00:00
|
|
|
size = 4 * 2 + 10;
|
|
|
|
for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
|
2011-05-22 10:46:29 +00:00
|
|
|
tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
|
2009-02-17 21:40:38 +00:00
|
|
|
if(tag) size += strlen(tag->value);
|
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,size);
|
|
|
|
avio_wb16(s,0);
|
2009-02-17 21:40:38 +00:00
|
|
|
for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
|
2011-05-22 10:46:29 +00:00
|
|
|
tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
|
2009-02-17 21:40:38 +00:00
|
|
|
put_str(s, tag ? tag->value : "");
|
|
|
|
}
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
for(i=0;i<ctx->nb_streams;i++) {
|
|
|
|
int codec_data_size;
|
|
|
|
|
|
|
|
stream = &rm->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
|
|
|
if (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2007-05-30 09:44:16 +00:00
|
|
|
desc = "The Audio Stream";
|
|
|
|
mimetype = "audio/x-pn-realaudio";
|
|
|
|
codec_data_size = 73;
|
|
|
|
} else {
|
|
|
|
desc = "The Video Stream";
|
|
|
|
mimetype = "video/x-pn-realvideo";
|
|
|
|
codec_data_size = 34;
|
|
|
|
}
|
|
|
|
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s,"MDPR");
|
2007-05-30 09:44:16 +00:00
|
|
|
size = 10 + 9 * 4 + strlen(desc) + strlen(mimetype) + codec_data_size;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, size);
|
|
|
|
avio_wb16(s, 0);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, i); /* stream number */
|
|
|
|
avio_wb32(s, stream->bit_rate); /* max bit rate */
|
|
|
|
avio_wb32(s, stream->bit_rate); /* avg bit rate */
|
|
|
|
avio_wb32(s, stream->packet_max_size); /* max packet size */
|
2007-05-30 09:44:16 +00:00
|
|
|
if (stream->nb_packets > 0)
|
|
|
|
packet_avg_size = stream->packet_total_size /
|
|
|
|
stream->nb_packets;
|
|
|
|
else
|
|
|
|
packet_avg_size = 0;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, packet_avg_size); /* avg packet size */
|
|
|
|
avio_wb32(s, 0); /* start time */
|
|
|
|
avio_wb32(s, BUFFER_DURATION); /* preroll */
|
2007-05-30 09:44:16 +00:00
|
|
|
/* duration */
|
2016-09-27 14:26:37 +00:00
|
|
|
if (!(s->seekable & AVIO_SEEKABLE_NORMAL) || !stream->total_frames)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, (int)(3600 * 1000));
|
2007-05-30 09:44:16 +00:00
|
|
|
else
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
|
2007-05-30 09:44:16 +00:00
|
|
|
put_str8(s, desc);
|
|
|
|
put_str8(s, mimetype);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, codec_data_size);
|
2007-05-30 09:44:16 +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 (stream->par->codec_type == AVMEDIA_TYPE_AUDIO) {
|
2007-05-30 09:44:16 +00:00
|
|
|
int coded_frame_size, fscode, sample_rate;
|
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
|
|
|
int frame_size = av_get_audio_frame_duration2(stream->par, 0);
|
|
|
|
sample_rate = stream->par->sample_rate;
|
|
|
|
coded_frame_size = (stream->par->bit_rate *
|
2014-11-15 15:48:59 +00:00
|
|
|
frame_size) / (8 * sample_rate);
|
2007-05-30 09:44:16 +00:00
|
|
|
/* audio codec info */
|
2011-02-24 06:36:04 +00:00
|
|
|
avio_write(s, ".ra", 3);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, 0xfd);
|
|
|
|
avio_wb32(s, 0x00040000); /* version */
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s, ".ra4");
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, 0x01b53530); /* stream length */
|
|
|
|
avio_wb16(s, 4); /* unknown */
|
|
|
|
avio_wb32(s, 0x39); /* header size */
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
switch(sample_rate) {
|
|
|
|
case 48000:
|
|
|
|
case 24000:
|
|
|
|
case 12000:
|
|
|
|
fscode = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case 44100:
|
|
|
|
case 22050:
|
|
|
|
case 11025:
|
|
|
|
fscode = 2;
|
|
|
|
break;
|
|
|
|
case 32000:
|
|
|
|
case 16000:
|
|
|
|
case 8000:
|
|
|
|
fscode = 3;
|
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, fscode); /* codec additional info, for AC-3, seems
|
2007-05-30 09:44:16 +00:00
|
|
|
to be a frequency code */
|
|
|
|
/* special hack to compensate rounding errors... */
|
|
|
|
if (coded_frame_size == 557)
|
|
|
|
coded_frame_size--;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, coded_frame_size); /* frame length */
|
|
|
|
avio_wb32(s, 0x51540); /* unknown */
|
|
|
|
avio_wb32(s, 0x249f0); /* unknown */
|
|
|
|
avio_wb32(s, 0x249f0); /* unknown */
|
|
|
|
avio_wb16(s, 0x01);
|
2007-05-30 09:44:16 +00:00
|
|
|
/* frame length : seems to be very important */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, coded_frame_size);
|
|
|
|
avio_wb32(s, 0); /* unknown */
|
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_wb16(s, stream->par->sample_rate); /* sample rate */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, 0x10); /* unknown */
|
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_wb16(s, stream->par->channels);
|
2007-05-30 09:44:16 +00:00
|
|
|
put_str8(s, "Int0"); /* codec name */
|
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 (stream->par->codec_tag) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(s, 4); /* tag length */
|
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_wl32(s, stream->par->codec_tag);
|
2010-05-28 18:21:25 +00:00
|
|
|
} else {
|
|
|
|
av_log(ctx, AV_LOG_ERROR, "Invalid codec tag\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, 0); /* title length */
|
|
|
|
avio_wb16(s, 0); /* author length */
|
|
|
|
avio_wb16(s, 0); /* copyright length */
|
|
|
|
avio_w8(s, 0); /* end of header */
|
2007-05-30 09:44:16 +00:00
|
|
|
} else {
|
|
|
|
/* video codec info */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,34); /* size */
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s, "VIDO");
|
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(stream->par->codec_id == AV_CODEC_ID_RV10)
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s,"RV10");
|
2007-05-30 09:44:16 +00:00
|
|
|
else
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s,"RV20");
|
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_wb16(s, stream->par->width);
|
|
|
|
avio_wb16(s, stream->par->height);
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s, (int) stream->frame_rate); /* frames per seconds ? */
|
|
|
|
avio_wb32(s,0); /* unknown meaning */
|
|
|
|
avio_wb16(s, (int) stream->frame_rate); /* unknown meaning */
|
|
|
|
avio_wb32(s,0); /* unknown meaning */
|
|
|
|
avio_wb16(s, 8); /* unknown meaning */
|
2016-04-27 17:45:23 +00:00
|
|
|
/* Seems to be the codec version: only use basic H.263. The next
|
|
|
|
versions seems to add a differential DC coding as in
|
|
|
|
MPEG... nothing new under the sun. */
|
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(stream->par->codec_id == AV_CODEC_ID_RV10)
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,0x10000000);
|
2007-05-30 09:44:16 +00:00
|
|
|
else
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,0x20103001);
|
|
|
|
//avio_wb32(s,0x10003000);
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* patch data offset field */
|
|
|
|
data_pos = s->buf_ptr - start_ptr;
|
|
|
|
rm->data_pos = data_pos;
|
|
|
|
data_offset_ptr[0] = data_pos >> 24;
|
|
|
|
data_offset_ptr[1] = data_pos >> 16;
|
|
|
|
data_offset_ptr[2] = data_pos >> 8;
|
|
|
|
data_offset_ptr[3] = data_pos;
|
|
|
|
|
|
|
|
/* data stream */
|
2011-02-24 06:36:02 +00:00
|
|
|
ffio_wfourcc(s, "DATA");
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s,data_size + 10 + 8);
|
|
|
|
avio_wb16(s,0);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, nb_packets); /* number of packets */
|
|
|
|
avio_wb32(s,0); /* next data header */
|
2010-05-28 18:21:25 +00:00
|
|
|
return 0;
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
|
|
|
|
int length, int key_frame)
|
|
|
|
{
|
|
|
|
int timestamp;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *s = ctx->pb;
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
stream->nb_packets++;
|
|
|
|
stream->packet_total_size += length;
|
|
|
|
if (length > stream->packet_max_size)
|
|
|
|
stream->packet_max_size = length;
|
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(s,0); /* version */
|
|
|
|
avio_wb16(s,length + 12);
|
|
|
|
avio_wb16(s, stream->num); /* stream number */
|
2007-05-30 09:44:16 +00:00
|
|
|
timestamp = (1000 * (float)stream->nb_frames) / stream->frame_rate;
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(s, timestamp); /* timestamp */
|
|
|
|
avio_w8(s, 0); /* reserved */
|
|
|
|
avio_w8(s, key_frame ? 2 : 0); /* flags */
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int rm_write_header(AVFormatContext *s)
|
|
|
|
{
|
2008-12-13 21:40:20 +00:00
|
|
|
RMMuxContext *rm = s->priv_data;
|
2007-05-30 09:44:16 +00:00
|
|
|
StreamInfo *stream;
|
|
|
|
int n;
|
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;
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
for(n=0;n<s->nb_streams;n++) {
|
2014-05-18 10:12:59 +00:00
|
|
|
AVStream *st = s->streams[n];
|
2014-11-15 15:48:59 +00:00
|
|
|
int frame_size;
|
2014-05-18 10:12:59 +00:00
|
|
|
|
2007-05-30 09:44:16 +00:00
|
|
|
s->streams[n]->id = n;
|
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[n]->codecpar;
|
2007-05-30 09:44:16 +00:00
|
|
|
stream = &rm->streams[n];
|
|
|
|
memset(stream, 0, sizeof(StreamInfo));
|
|
|
|
stream->num = n;
|
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
|
|
|
stream->bit_rate = par->bit_rate;
|
|
|
|
stream->par = par;
|
2007-05-30 09:44:16 +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
|
|
|
switch (par->codec_type) {
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
2007-05-30 09:44:16 +00:00
|
|
|
rm->audio_stream = stream;
|
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
|
|
|
frame_size = av_get_audio_frame_duration2(par, 0);
|
|
|
|
stream->frame_rate = (float)par->sample_rate / (float)frame_size;
|
2007-05-30 09:44:16 +00:00
|
|
|
/* XXX: dummy values */
|
|
|
|
stream->packet_max_size = 1024;
|
|
|
|
stream->nb_packets = 0;
|
|
|
|
stream->total_frames = stream->nb_packets;
|
|
|
|
break;
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
2007-05-30 09:44:16 +00:00
|
|
|
rm->video_stream = stream;
|
2014-05-18 10:12:59 +00:00
|
|
|
// TODO: should be avg_frame_rate
|
|
|
|
stream->frame_rate = (float)st->time_base.den / (float)st->time_base.num;
|
2007-05-30 09:44:16 +00:00
|
|
|
/* XXX: dummy values */
|
|
|
|
stream->packet_max_size = 4096;
|
|
|
|
stream->nb_packets = 0;
|
|
|
|
stream->total_frames = stream->nb_packets;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-28 18:21:25 +00:00
|
|
|
if (rv10_write_header(s, 0, 0))
|
|
|
|
return AVERROR_INVALIDDATA;
|
2011-03-14 19:39:06 +00:00
|
|
|
avio_flush(s->pb);
|
2007-05-30 09:44:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rm_write_audio(AVFormatContext *s, const uint8_t *buf, int size, int flags)
|
|
|
|
{
|
2008-12-13 21:40:20 +00:00
|
|
|
RMMuxContext *rm = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-05-30 09:44:16 +00:00
|
|
|
StreamInfo *stream = rm->audio_stream;
|
|
|
|
int i;
|
|
|
|
|
2010-03-31 12:29:58 +00:00
|
|
|
write_packet_header(s, stream, size, !!(flags & AV_PKT_FLAG_KEY));
|
2007-05-30 09:44:16 +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 (stream->par->codec_id == AV_CODEC_ID_AC3) {
|
2010-05-28 18:21:57 +00:00
|
|
|
/* for AC-3, the words seem to be reversed */
|
2015-03-21 14:38:37 +00:00
|
|
|
for (i = 0; i < size; i += 2) {
|
|
|
|
avio_w8(pb, buf[i + 1]);
|
|
|
|
avio_w8(pb, buf[i]);
|
2010-05-28 18:21:57 +00:00
|
|
|
}
|
2010-05-28 18:21:25 +00:00
|
|
|
} else {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, size);
|
2010-05-28 18:21:25 +00:00
|
|
|
}
|
2007-05-30 09:44:16 +00:00
|
|
|
stream->nb_frames++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int flags)
|
|
|
|
{
|
2008-12-13 21:40:20 +00:00
|
|
|
RMMuxContext *rm = s->priv_data;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-05-30 09:44:16 +00:00
|
|
|
StreamInfo *stream = rm->video_stream;
|
2010-03-31 12:29:58 +00:00
|
|
|
int key_frame = !!(flags & AV_PKT_FLAG_KEY);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
/* XXX: this is incorrect: should be a parameter */
|
|
|
|
|
|
|
|
/* Well, I spent some time finding the meaning of these bits. I am
|
|
|
|
not sure I understood everything, but it works !! */
|
2015-03-02 15:52:26 +00:00
|
|
|
if (size > MAX_PACKET_SIZE) {
|
|
|
|
avpriv_report_missing_feature(s, "Muxing packets larger than 64 kB");
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
}
|
2007-12-02 17:51:05 +00:00
|
|
|
write_packet_header(s, stream, size + 7 + (size >= 0x4000)*4, key_frame);
|
2007-05-30 09:44:16 +00:00
|
|
|
/* bit 7: '1' if final packet of a frame converted in several packets */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x81);
|
2016-04-27 17:45:23 +00:00
|
|
|
/* bit 7: '1' if I-frame. bits 6..0 : sequence number in current
|
2007-05-30 09:44:16 +00:00
|
|
|
frame starting from 1 */
|
|
|
|
if (key_frame) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x81);
|
2007-05-30 09:44:16 +00:00
|
|
|
} else {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, 0x01);
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
2007-12-02 17:51:05 +00:00
|
|
|
if(size >= 0x4000){
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(pb, size); /* total frame size */
|
|
|
|
avio_wb32(pb, size); /* offset from the start or the end */
|
2007-12-02 17:51:05 +00:00
|
|
|
}else{
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb16(pb, 0x4000 | size); /* total frame size */
|
|
|
|
avio_wb16(pb, 0x4000 | size); /* offset from the start or the end */
|
2007-12-02 17:51:05 +00:00
|
|
|
}
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_w8(pb, stream->nb_frames & 0xff);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(pb, buf, size);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
|
|
|
stream->nb_frames++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
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 (s->streams[pkt->stream_index]->codecpar->codec_type ==
|
2010-03-30 23:30:55 +00:00
|
|
|
AVMEDIA_TYPE_AUDIO)
|
2007-05-30 09:44:16 +00:00
|
|
|
return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
|
|
|
|
else
|
|
|
|
return rm_write_video(s, pkt->data, pkt->size, pkt->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rm_write_trailer(AVFormatContext *s)
|
|
|
|
{
|
2008-12-13 21:40:20 +00:00
|
|
|
RMMuxContext *rm = s->priv_data;
|
2007-05-30 09:44:16 +00:00
|
|
|
int data_size, index_pos, i;
|
2011-02-20 10:04:12 +00:00
|
|
|
AVIOContext *pb = s->pb;
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2016-09-27 14:26:37 +00:00
|
|
|
if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
|
2007-05-30 09:44:16 +00:00
|
|
|
/* end of file: finish to write header */
|
2011-03-17 06:41:19 +00:00
|
|
|
index_pos = avio_tell(pb);
|
2007-05-30 09:44:16 +00:00
|
|
|
data_size = index_pos - rm->data_pos;
|
|
|
|
|
2009-03-21 20:34:24 +00:00
|
|
|
/* FIXME: write index */
|
|
|
|
|
2007-05-30 09:44:16 +00:00
|
|
|
/* undocumented end header */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(pb, 0);
|
|
|
|
avio_wb32(pb, 0);
|
2007-05-30 09:44:16 +00:00
|
|
|
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(pb, 0, SEEK_SET);
|
2007-05-30 09:44:16 +00:00
|
|
|
for(i=0;i<s->nb_streams;i++)
|
|
|
|
rm->streams[i].total_frames = rm->streams[i].nb_frames;
|
2009-03-21 20:34:24 +00:00
|
|
|
rv10_write_header(s, data_size, 0);
|
2007-05-30 09:44:16 +00:00
|
|
|
} else {
|
|
|
|
/* undocumented end header */
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_wb32(pb, 0);
|
|
|
|
avio_wb32(pb, 0);
|
2007-05-30 09:44:16 +00:00
|
|
|
}
|
2012-09-09 19:35:23 +00:00
|
|
|
|
2007-05-30 09:44:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_rm_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "rm",
|
2012-07-24 21:51:41 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("RealMedia"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.mime_type = "application/vnd.rn-realmedia",
|
|
|
|
.extensions = "rm,ra",
|
|
|
|
.priv_data_size = sizeof(RMMuxContext),
|
2012-08-05 09:11:04 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_AC3,
|
|
|
|
.video_codec = AV_CODEC_ID_RV10,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = rm_write_header,
|
|
|
|
.write_packet = rm_write_packet,
|
|
|
|
.write_trailer = rm_write_trailer,
|
2012-04-06 14:50:48 +00:00
|
|
|
.codec_tag = (const AVCodecTag* const []){ ff_rm_codec_tags, 0 },
|
2007-05-30 09:44:16 +00:00
|
|
|
};
|