2013-08-04 14:33:36 +02:00
|
|
|
/*
|
|
|
|
* RIFF demuxing functions and data
|
|
|
|
* Copyright (c) 2000 Fabrice Bellard
|
|
|
|
*
|
2013-08-06 18:30:26 +02:00
|
|
|
* This file is part of FFmpeg.
|
2013-08-04 14:33:36 +02:00
|
|
|
*
|
2013-08-06 18:30:26 +02:00
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2013-08-04 14:33:36 +02: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.
|
|
|
|
*
|
2013-08-06 18:30:26 +02:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2013-08-04 14:33:36 +02: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
|
2013-08-06 18:30:26 +02:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2013-08-04 14:33:36 +02:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "libavutil/dict.h"
|
|
|
|
#include "libavutil/error.h"
|
|
|
|
#include "libavutil/log.h"
|
|
|
|
#include "libavutil/mathematics.h"
|
|
|
|
#include "libavcodec/avcodec.h"
|
|
|
|
#include "libavcodec/bytestream.h"
|
|
|
|
#include "avformat.h"
|
|
|
|
#include "avio_internal.h"
|
|
|
|
#include "riff.h"
|
|
|
|
|
2014-02-12 15:51:38 +01:00
|
|
|
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
|
2013-08-06 18:30:26 +02:00
|
|
|
{
|
2015-06-28 12:56:22 +02:00
|
|
|
int ret;
|
2013-08-06 18:30:26 +02:00
|
|
|
av_assert0(sizeof(*g) == 16); //compiler will optimize this out
|
2015-06-28 12:56:22 +02:00
|
|
|
ret = avio_read(s, *g, sizeof(*g));
|
|
|
|
if (ret < (int)sizeof(*g)) {
|
2013-08-06 18:30:26 +02:00
|
|
|
memset(*g, 0, sizeof(*g));
|
2015-06-28 12:56:22 +02:00
|
|
|
return ret < 0 ? ret : AVERROR_INVALIDDATA;
|
2014-02-12 15:51:38 +01:00
|
|
|
}
|
|
|
|
return 0;
|
2013-08-06 18:30:26 +02:00
|
|
|
}
|
|
|
|
|
2013-08-04 14:33:36 +02:00
|
|
|
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; guids[i].id != AV_CODEC_ID_NONE; i++)
|
|
|
|
if (!ff_guidcmp(guids[i].guid, guid))
|
|
|
|
return guids[i].id;
|
|
|
|
return AV_CODEC_ID_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We could be given one of the three possible structures here:
|
|
|
|
* WAVEFORMAT, PCMWAVEFORMAT or WAVEFORMATEX. Each structure
|
|
|
|
* is an expansion of the previous one with the fields added
|
|
|
|
* at the bottom. PCMWAVEFORMAT adds 'WORD wBitsPerSample' and
|
|
|
|
* WAVEFORMATEX adds 'WORD cbSize' and basically makes itself
|
|
|
|
* an openended structure.
|
|
|
|
*/
|
|
|
|
|
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 20:42:52 +02:00
|
|
|
static void parse_waveformatex(AVIOContext *pb, AVCodecParameters *par)
|
2013-08-04 14:33:36 +02:00
|
|
|
{
|
|
|
|
ff_asf_guid subformat;
|
2012-05-02 16:34:45 +02:00
|
|
|
int bps;
|
|
|
|
|
|
|
|
bps = avio_rl16(pb);
|
2013-08-06 18:30:26 +02:00
|
|
|
if (bps)
|
2016-04-10 21:58:15 +02:00
|
|
|
par->bits_per_coded_sample = bps;
|
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 20:42:52 +02:00
|
|
|
par->channel_layout = avio_rl32(pb); /* dwChannelMask */
|
2013-08-04 14:33:36 +02:00
|
|
|
|
|
|
|
ff_get_guid(pb, &subformat);
|
|
|
|
if (!memcmp(subformat + 4,
|
2015-09-16 14:03:13 +02:00
|
|
|
(const uint8_t[]){ FF_AMBISONIC_BASE_GUID }, 12) ||
|
2017-02-16 14:03:38 +01:00
|
|
|
!memcmp(subformat + 4,
|
|
|
|
(const uint8_t[]){ FF_BROKEN_BASE_GUID }, 12) ||
|
2015-09-16 14:03:13 +02:00
|
|
|
!memcmp(subformat + 4,
|
2013-08-04 14:33:36 +02:00
|
|
|
(const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
|
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 20:42:52 +02:00
|
|
|
par->codec_tag = AV_RL32(subformat);
|
|
|
|
par->codec_id = ff_wav_codec_get_id(par->codec_tag,
|
|
|
|
par->bits_per_coded_sample);
|
2013-08-04 14:33:36 +02: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 20:42:52 +02:00
|
|
|
par->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
|
|
|
|
if (!par->codec_id)
|
|
|
|
av_log(pb, AV_LOG_WARNING,
|
2013-08-04 14:33:36 +02:00
|
|
|
"unknown subformat:"FF_PRI_GUID"\n",
|
|
|
|
FF_ARG_GUID(subformat));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-17 12:04:37 +01:00
|
|
|
/* "big_endian" values are needed for RIFX file format */
|
2015-07-11 12:41:42 +02:00
|
|
|
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb,
|
2016-04-10 21:58:15 +02:00
|
|
|
AVCodecParameters *par, int size, int big_endian)
|
2013-08-04 14:33:36 +02:00
|
|
|
{
|
|
|
|
int id;
|
2015-12-03 20:16:00 +01:00
|
|
|
uint64_t bitrate = 0;
|
2013-08-04 14:33:36 +02:00
|
|
|
|
2015-06-30 12:59:16 +02:00
|
|
|
if (size < 14) {
|
2016-04-10 21:58:15 +02:00
|
|
|
avpriv_request_sample(s, "wav header size < 14");
|
2015-06-28 17:32:40 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
2015-06-30 12:59:16 +02:00
|
|
|
}
|
2014-11-30 01:52:04 +01:00
|
|
|
|
2016-04-10 21:58:15 +02:00
|
|
|
par->codec_type = AVMEDIA_TYPE_AUDIO;
|
2014-12-17 12:04:37 +01:00
|
|
|
if (!big_endian) {
|
|
|
|
id = avio_rl16(pb);
|
2015-11-01 13:15:36 +01:00
|
|
|
if (id != 0x0165) {
|
2016-04-10 21:58:15 +02:00
|
|
|
par->channels = avio_rl16(pb);
|
|
|
|
par->sample_rate = avio_rl32(pb);
|
2015-11-01 13:15:36 +01:00
|
|
|
bitrate = avio_rl32(pb) * 8LL;
|
2016-04-10 21:58:15 +02:00
|
|
|
par->block_align = avio_rl16(pb);
|
2015-11-01 13:15:36 +01:00
|
|
|
}
|
2014-12-17 12:04:37 +01:00
|
|
|
} else {
|
|
|
|
id = avio_rb16(pb);
|
2016-04-10 21:58:15 +02:00
|
|
|
par->channels = avio_rb16(pb);
|
|
|
|
par->sample_rate = avio_rb32(pb);
|
2015-07-12 16:24:20 +02:00
|
|
|
bitrate = avio_rb32(pb) * 8LL;
|
2016-04-10 21:58:15 +02:00
|
|
|
par->block_align = avio_rb16(pb);
|
2014-12-17 12:04:37 +01:00
|
|
|
}
|
2013-08-04 14:33:36 +02:00
|
|
|
if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */
|
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 20:42:52 +02:00
|
|
|
par->bits_per_coded_sample = 8;
|
2014-12-17 12:04:37 +01:00
|
|
|
} else {
|
|
|
|
if (!big_endian) {
|
2016-04-10 21:58:15 +02:00
|
|
|
par->bits_per_coded_sample = avio_rl16(pb);
|
2014-12-17 12:04:37 +01:00
|
|
|
} else {
|
2016-04-10 21:58:15 +02:00
|
|
|
par->bits_per_coded_sample = avio_rb16(pb);
|
2014-12-17 12:04:37 +01:00
|
|
|
}
|
|
|
|
}
|
2013-08-04 14:33:36 +02:00
|
|
|
if (id == 0xFFFE) {
|
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 20:42:52 +02:00
|
|
|
par->codec_tag = 0;
|
2013-08-04 14:33:36 +02: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 20:42:52 +02:00
|
|
|
par->codec_tag = id;
|
2016-04-10 21:58:15 +02:00
|
|
|
par->codec_id = ff_wav_codec_get_id(id,
|
|
|
|
par->bits_per_coded_sample);
|
2013-08-04 14:33:36 +02:00
|
|
|
}
|
2015-11-01 13:15:36 +01:00
|
|
|
if (size >= 18 && id != 0x0165) { /* We're obviously dealing with WAVEFORMATEX */
|
2013-08-04 14:33:36 +02:00
|
|
|
int cbSize = avio_rl16(pb); /* cbSize */
|
2014-12-17 12:04:37 +01:00
|
|
|
if (big_endian) {
|
2016-04-10 21:58:15 +02:00
|
|
|
avpriv_report_missing_feature(s, "WAVEFORMATEX support for RIFX files");
|
2014-12-17 12:04:37 +01:00
|
|
|
return AVERROR_PATCHWELCOME;
|
|
|
|
}
|
2013-08-04 14:33:36 +02:00
|
|
|
size -= 18;
|
|
|
|
cbSize = FFMIN(size, cbSize);
|
|
|
|
if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
|
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 20:42:52 +02:00
|
|
|
parse_waveformatex(pb, par);
|
2013-08-04 14:33:36 +02:00
|
|
|
cbSize -= 22;
|
|
|
|
size -= 22;
|
|
|
|
}
|
|
|
|
if (cbSize > 0) {
|
2016-04-10 21:58:15 +02:00
|
|
|
av_freep(&par->extradata);
|
2016-04-14 18:21:08 +02:00
|
|
|
if (ff_get_extradata(s, par, pb, cbSize) < 0)
|
2013-08-04 14:33:36 +02:00
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
size -= cbSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* It is possible for the chunk to contain garbage at the end */
|
|
|
|
if (size > 0)
|
|
|
|
avio_skip(pb, size);
|
2015-11-01 13:15:36 +01:00
|
|
|
} else if (id == 0x0165 && size >= 32) {
|
|
|
|
int nb_streams, i;
|
|
|
|
|
|
|
|
size -= 4;
|
2016-04-10 21:58:15 +02:00
|
|
|
av_freep(&par->extradata);
|
2016-04-14 18:21:08 +02:00
|
|
|
if (ff_get_extradata(s, par, pb, size) < 0)
|
2015-11-01 13:15:36 +01:00
|
|
|
return AVERROR(ENOMEM);
|
2016-04-10 21:58:15 +02:00
|
|
|
nb_streams = AV_RL16(par->extradata + 4);
|
|
|
|
par->sample_rate = AV_RL32(par->extradata + 12);
|
|
|
|
par->channels = 0;
|
2015-11-01 13:15:36 +01:00
|
|
|
bitrate = 0;
|
|
|
|
if (size < 8 + nb_streams * 20)
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
for (i = 0; i < nb_streams; i++)
|
2016-04-10 21:58:15 +02:00
|
|
|
par->channels += par->extradata[8 + i * 20 + 17];
|
2013-08-04 14:33:36 +02:00
|
|
|
}
|
2015-07-11 18:40:31 +02:00
|
|
|
|
2016-04-10 21:58:15 +02:00
|
|
|
par->bit_rate = bitrate;
|
2015-07-11 18:40:31 +02: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 20:42:52 +02:00
|
|
|
if (par->sample_rate <= 0) {
|
2015-07-11 12:41:42 +02:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
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 20:42:52 +02:00
|
|
|
"Invalid sample rate: %d\n", par->sample_rate);
|
2013-09-28 22:32:39 +02:00
|
|
|
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 20:42:52 +02:00
|
|
|
if (par->codec_id == AV_CODEC_ID_AAC_LATM) {
|
2013-08-04 14:33:36 +02:00
|
|
|
/* Channels and sample_rate values are those prior to applying SBR
|
|
|
|
* and/or PS. */
|
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 20:42:52 +02:00
|
|
|
par->channels = 0;
|
|
|
|
par->sample_rate = 0;
|
2013-08-04 14:33:36 +02:00
|
|
|
}
|
|
|
|
/* override bits_per_coded_sample for G.726 */
|
2016-04-10 21:58:15 +02:00
|
|
|
if (par->codec_id == AV_CODEC_ID_ADPCM_G726 && par->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 20:42:52 +02:00
|
|
|
par->bits_per_coded_sample = par->bit_rate / par->sample_rate;
|
2013-08-04 14:33:36 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
|
|
|
|
{
|
|
|
|
enum AVCodecID id;
|
|
|
|
id = ff_codec_get_id(ff_codec_wav_tags, tag);
|
|
|
|
if (id <= 0)
|
|
|
|
return id;
|
|
|
|
|
|
|
|
if (id == AV_CODEC_ID_PCM_S16LE)
|
|
|
|
id = ff_get_pcm_codec_id(bps, 0, 0, ~1);
|
|
|
|
else if (id == AV_CODEC_ID_PCM_F32LE)
|
|
|
|
id = ff_get_pcm_codec_id(bps, 1, 0, 0);
|
|
|
|
|
|
|
|
if (id == AV_CODEC_ID_ADPCM_IMA_WAV && bps == 8)
|
|
|
|
id = AV_CODEC_ID_PCM_ZORK;
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2013-08-06 18:30:26 +02:00
|
|
|
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, unsigned *esize)
|
2013-08-04 14:33:36 +02:00
|
|
|
{
|
|
|
|
int tag1;
|
2013-08-06 18:30:26 +02:00
|
|
|
if(esize) *esize = avio_rl32(pb);
|
|
|
|
else avio_rl32(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 20:42:52 +02:00
|
|
|
st->codecpar->width = avio_rl32(pb);
|
|
|
|
st->codecpar->height = (int32_t)avio_rl32(pb);
|
2013-08-04 14:33:36 +02:00
|
|
|
avio_rl16(pb); /* planes */
|
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 20:42:52 +02:00
|
|
|
st->codecpar->bits_per_coded_sample = avio_rl16(pb); /* depth */
|
|
|
|
tag1 = avio_rl32(pb);
|
2013-08-04 14:33:36 +02:00
|
|
|
avio_rl32(pb); /* ImageSize */
|
|
|
|
avio_rl32(pb); /* XPelsPerMeter */
|
|
|
|
avio_rl32(pb); /* YPelsPerMeter */
|
|
|
|
avio_rl32(pb); /* ClrUsed */
|
|
|
|
avio_rl32(pb); /* ClrImportant */
|
|
|
|
return tag1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ff_read_riff_info(AVFormatContext *s, int64_t size)
|
|
|
|
{
|
|
|
|
int64_t start, end, cur;
|
|
|
|
AVIOContext *pb = s->pb;
|
|
|
|
|
|
|
|
start = avio_tell(pb);
|
|
|
|
end = start + size;
|
|
|
|
|
|
|
|
while ((cur = avio_tell(pb)) >= 0 &&
|
|
|
|
cur <= end - 8 /* = tag + size */) {
|
|
|
|
uint32_t chunk_code;
|
|
|
|
int64_t chunk_size;
|
|
|
|
char key[5] = { 0 };
|
|
|
|
char *value;
|
|
|
|
|
|
|
|
chunk_code = avio_rl32(pb);
|
|
|
|
chunk_size = avio_rl32(pb);
|
2014-08-07 22:12:41 +02:00
|
|
|
if (avio_feof(pb)) {
|
2013-08-06 18:30:26 +02:00
|
|
|
if (chunk_code || chunk_size) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "INFO subchunk truncated\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
return AVERROR_EOF;
|
|
|
|
}
|
2013-08-04 14:33:36 +02:00
|
|
|
if (chunk_size > end ||
|
|
|
|
end - chunk_size < cur ||
|
|
|
|
chunk_size == UINT_MAX) {
|
2013-08-06 18:30:26 +02:00
|
|
|
avio_seek(pb, -9, SEEK_CUR);
|
|
|
|
chunk_code = avio_rl32(pb);
|
|
|
|
chunk_size = avio_rl32(pb);
|
|
|
|
if (chunk_size > end || end - chunk_size < cur || chunk_size == UINT_MAX) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "too big INFO subchunk\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2013-08-04 14:33:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
chunk_size += (chunk_size & 1);
|
|
|
|
|
|
|
|
if (!chunk_code) {
|
|
|
|
if (chunk_size)
|
|
|
|
avio_skip(pb, chunk_size);
|
|
|
|
else if (pb->eof_reached) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "truncated file\n");
|
|
|
|
return AVERROR_EOF;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-08-06 18:30:26 +02:00
|
|
|
value = av_mallocz(chunk_size + 1);
|
2013-08-04 14:33:36 +02:00
|
|
|
if (!value) {
|
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"out of memory, unable to read INFO tag\n");
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
AV_WL32(key, chunk_code);
|
2016-01-28 22:06:07 +01:00
|
|
|
// Work around VC++ 2015 Update 1 code-gen bug:
|
|
|
|
// https://connect.microsoft.com/VisualStudio/feedback/details/2291638
|
|
|
|
key[4] = 0;
|
2013-08-04 14:33:36 +02:00
|
|
|
|
|
|
|
if (avio_read(pb, value, chunk_size) != chunk_size) {
|
|
|
|
av_log(s, AV_LOG_WARNING,
|
|
|
|
"premature end of file while reading INFO tag\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
av_dict_set(&s->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|