2003-10-01 07:39:38 +03:00
|
|
|
/*
|
2012-01-20 21:56:51 +03:00
|
|
|
* Westwood Studios VQA Format Demuxer
|
2016-04-27 19:45:23 +02:00
|
|
|
* Copyright (c) 2003 The FFmpeg project
|
2003-10-01 07:39:38 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2003-10-01 07:39:38 +03:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 18:30:46 +03:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2003-10-01 07:39:38 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2003-10-01 07:39:38 +03: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
|
2006-10-07 18:30:46 +03:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-13 00:43:26 +02:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2003-10-01 07:39:38 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2010-04-20 17:45:34 +03:00
|
|
|
* @file
|
2012-01-20 21:56:51 +03:00
|
|
|
* Westwood Studios VQA file demuxer
|
2003-10-01 07:39:38 +03:00
|
|
|
* by Mike Melanson (melanson@pcisys.net)
|
|
|
|
* for more information on the Westwood file formats, visit:
|
|
|
|
* http://www.pcisys.net/~melanson/codecs/
|
|
|
|
* http://www.geocities.com/SiliconValley/8682/aud3.txt
|
|
|
|
*/
|
|
|
|
|
2009-01-12 00:19:48 +02:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2003-10-01 07:39:38 +03:00
|
|
|
#include "avformat.h"
|
2011-11-29 21:28:15 +03:00
|
|
|
#include "internal.h"
|
2003-10-01 07:39:38 +03:00
|
|
|
|
2004-03-14 06:04:08 +02:00
|
|
|
#define FORM_TAG MKBETAG('F', 'O', 'R', 'M')
|
|
|
|
#define WVQA_TAG MKBETAG('W', 'V', 'Q', 'A')
|
|
|
|
#define VQHD_TAG MKBETAG('V', 'Q', 'H', 'D')
|
|
|
|
#define FINF_TAG MKBETAG('F', 'I', 'N', 'F')
|
|
|
|
#define SND0_TAG MKBETAG('S', 'N', 'D', '0')
|
2006-11-29 07:42:59 +02:00
|
|
|
#define SND1_TAG MKBETAG('S', 'N', 'D', '1')
|
2004-03-14 06:04:08 +02:00
|
|
|
#define SND2_TAG MKBETAG('S', 'N', 'D', '2')
|
|
|
|
#define VQFR_TAG MKBETAG('V', 'Q', 'F', 'R')
|
2003-10-01 07:39:38 +03:00
|
|
|
|
2003-10-04 20:41:56 +03:00
|
|
|
/* don't know what these tags are for, but acknowledge their existence */
|
2004-03-14 06:04:08 +02:00
|
|
|
#define CINF_TAG MKBETAG('C', 'I', 'N', 'F')
|
|
|
|
#define CINH_TAG MKBETAG('C', 'I', 'N', 'H')
|
|
|
|
#define CIND_TAG MKBETAG('C', 'I', 'N', 'D')
|
|
|
|
#define PINF_TAG MKBETAG('P', 'I', 'N', 'F')
|
|
|
|
#define PINH_TAG MKBETAG('P', 'I', 'N', 'H')
|
|
|
|
#define PIND_TAG MKBETAG('P', 'I', 'N', 'D')
|
2006-11-29 07:42:59 +02:00
|
|
|
#define CMDS_TAG MKBETAG('C', 'M', 'D', 'S')
|
2003-10-04 20:41:56 +03:00
|
|
|
|
2003-10-01 07:39:38 +03:00
|
|
|
#define VQA_HEADER_SIZE 0x2A
|
|
|
|
#define VQA_PREAMBLE_SIZE 8
|
|
|
|
|
|
|
|
typedef struct WsVqaDemuxContext {
|
2012-03-21 03:04:49 +03:00
|
|
|
int version;
|
|
|
|
int bps;
|
|
|
|
int channels;
|
|
|
|
int sample_rate;
|
2003-10-01 07:39:38 +03:00
|
|
|
int audio_stream_index;
|
|
|
|
int video_stream_index;
|
|
|
|
} WsVqaDemuxContext;
|
|
|
|
|
2019-03-21 02:18:37 +02:00
|
|
|
static int wsvqa_probe(const AVProbeData *p)
|
2003-10-01 07:39:38 +03:00
|
|
|
{
|
|
|
|
/* need 12 bytes to qualify */
|
|
|
|
if (p->buf_size < 12)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* check for the VQA signatures */
|
2007-01-20 00:12:59 +02:00
|
|
|
if ((AV_RB32(&p->buf[0]) != FORM_TAG) ||
|
|
|
|
(AV_RB32(&p->buf[8]) != WVQA_TAG))
|
2003-10-01 07:39:38 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
}
|
|
|
|
|
2012-01-12 15:20:36 +03:00
|
|
|
static int wsvqa_read_header(AVFormatContext *s)
|
2003-10-01 07:39:38 +03:00
|
|
|
{
|
2007-04-08 23:24:16 +03:00
|
|
|
WsVqaDemuxContext *wsvqa = s->priv_data;
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2003-10-01 07:39:38 +03:00
|
|
|
AVStream *st;
|
2013-10-13 23:21:03 +03:00
|
|
|
uint8_t *header;
|
|
|
|
uint8_t scratch[VQA_PREAMBLE_SIZE];
|
|
|
|
uint32_t chunk_tag;
|
|
|
|
uint32_t chunk_size;
|
2012-03-21 03:04:49 +03:00
|
|
|
int fps;
|
2003-10-01 07:39:38 +03:00
|
|
|
|
|
|
|
/* initialize the video decoder stream */
|
2011-06-18 12:43:24 +03:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2003-10-01 07:39:38 +03:00
|
|
|
if (!st)
|
2007-07-19 18:21:30 +03:00
|
|
|
return AVERROR(ENOMEM);
|
2012-01-23 18:52:49 +03:00
|
|
|
st->start_time = 0;
|
2003-10-01 07:39:38 +03:00
|
|
|
wsvqa->video_stream_index = st->index;
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_WS_VQA;
|
|
|
|
st->codecpar->codec_tag = 0; /* no fourcc */
|
2003-10-01 07:39:38 +03:00
|
|
|
|
|
|
|
/* skip to the start of the VQA header */
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(pb, 20, SEEK_SET);
|
2003-10-01 07:39:38 +03:00
|
|
|
|
|
|
|
/* the VQA header needs to go to the decoder */
|
2016-04-14 18:21:08 +02:00
|
|
|
if (ff_get_extradata(s, st->codecpar, pb, VQA_HEADER_SIZE) < 0)
|
2013-07-02 01:15:25 +03:00
|
|
|
return AVERROR(ENOMEM);
|
2016-04-10 21:58:15 +02:00
|
|
|
header = st->codecpar->extradata;
|
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 21:42:52 +03:00
|
|
|
st->codecpar->width = AV_RL16(&header[6]);
|
|
|
|
st->codecpar->height = AV_RL16(&header[8]);
|
2012-01-23 19:38:00 +03:00
|
|
|
fps = header[12];
|
2012-03-21 03:04:50 +03:00
|
|
|
st->nb_frames =
|
|
|
|
st->duration = AV_RL16(&header[4]);
|
2012-01-23 19:38:00 +03:00
|
|
|
if (fps < 1 || fps > 30) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "invalid fps: %d\n", fps);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
avpriv_set_pts_info(st, 64, 1, fps);
|
2003-10-01 07:39:38 +03:00
|
|
|
|
2012-03-21 03:04:49 +03:00
|
|
|
wsvqa->version = AV_RL16(&header[ 0]);
|
|
|
|
wsvqa->sample_rate = AV_RL16(&header[24]);
|
|
|
|
wsvqa->channels = header[26];
|
|
|
|
wsvqa->bps = header[27];
|
|
|
|
wsvqa->audio_stream_index = -1;
|
2003-10-04 20:41:56 +03:00
|
|
|
|
2012-03-21 03:04:49 +03:00
|
|
|
s->ctx_flags |= AVFMTCTX_NOHEADER;
|
2003-10-01 07:39:38 +03:00
|
|
|
|
2003-10-04 20:41:56 +03:00
|
|
|
/* there are 0 or more chunks before the FINF chunk; iterate until
|
|
|
|
* FINF has been skipped and the file will be ready to be demuxed */
|
|
|
|
do {
|
2011-10-09 00:40:37 +03:00
|
|
|
if (avio_read(pb, scratch, VQA_PREAMBLE_SIZE) != VQA_PREAMBLE_SIZE)
|
2007-07-19 18:23:32 +03:00
|
|
|
return AVERROR(EIO);
|
2007-01-20 00:12:59 +02:00
|
|
|
chunk_tag = AV_RB32(&scratch[0]);
|
|
|
|
chunk_size = AV_RB32(&scratch[4]);
|
2003-10-04 20:41:56 +03:00
|
|
|
|
2016-04-27 19:45:23 +02:00
|
|
|
/* catch any unknown header tags, for curiosity */
|
2003-10-04 20:41:56 +03:00
|
|
|
switch (chunk_tag) {
|
|
|
|
case CINF_TAG:
|
|
|
|
case CINH_TAG:
|
|
|
|
case CIND_TAG:
|
|
|
|
case PINF_TAG:
|
|
|
|
case PINH_TAG:
|
|
|
|
case PIND_TAG:
|
|
|
|
case FINF_TAG:
|
2006-11-29 07:42:59 +02:00
|
|
|
case CMDS_TAG:
|
2003-10-04 20:41:56 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-03-27 09:45:35 +02:00
|
|
|
av_log(s, AV_LOG_ERROR, " note: unknown chunk seen (%s)\n",
|
|
|
|
av_fourcc2str(chunk_tag));
|
2003-10-04 20:41:56 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, chunk_size);
|
2003-10-04 20:41:56 +03:00
|
|
|
} while (chunk_tag != FINF_TAG);
|
2003-10-01 07:39:38 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wsvqa_read_packet(AVFormatContext *s,
|
|
|
|
AVPacket *pkt)
|
|
|
|
{
|
2007-04-08 23:24:16 +03:00
|
|
|
WsVqaDemuxContext *wsvqa = s->priv_data;
|
2011-02-20 12:04:12 +02:00
|
|
|
AVIOContext *pb = s->pb;
|
2006-11-29 07:42:59 +02:00
|
|
|
int ret = -1;
|
2013-10-13 23:21:03 +03:00
|
|
|
uint8_t preamble[VQA_PREAMBLE_SIZE];
|
|
|
|
uint32_t chunk_type;
|
|
|
|
uint32_t chunk_size;
|
2003-10-01 07:39:38 +03:00
|
|
|
int skip_byte;
|
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
while (avio_read(pb, preamble, VQA_PREAMBLE_SIZE) == VQA_PREAMBLE_SIZE) {
|
2007-01-20 00:12:59 +02:00
|
|
|
chunk_type = AV_RB32(&preamble[0]);
|
|
|
|
chunk_size = AV_RB32(&preamble[4]);
|
2011-12-15 22:25:50 +03:00
|
|
|
|
2006-11-29 07:42:59 +02:00
|
|
|
skip_byte = chunk_size & 0x01;
|
|
|
|
|
2012-03-21 03:04:49 +03:00
|
|
|
if ((chunk_type == SND0_TAG) || (chunk_type == SND1_TAG) ||
|
|
|
|
(chunk_type == SND2_TAG) || (chunk_type == VQFR_TAG)) {
|
2006-11-29 07:42:59 +02:00
|
|
|
|
2011-12-15 22:27:51 +03:00
|
|
|
ret= av_get_packet(pb, pkt, chunk_size);
|
|
|
|
if (ret<0)
|
2007-07-19 18:23:32 +03:00
|
|
|
return AVERROR(EIO);
|
2006-11-29 07:42:59 +02:00
|
|
|
|
2012-03-21 03:04:49 +03:00
|
|
|
switch (chunk_type) {
|
|
|
|
case SND0_TAG:
|
|
|
|
case SND1_TAG:
|
|
|
|
case SND2_TAG:
|
|
|
|
if (wsvqa->audio_stream_index == -1) {
|
|
|
|
AVStream *st = avformat_new_stream(s, NULL);
|
|
|
|
if (!st)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
|
|
|
wsvqa->audio_stream_index = st->index;
|
|
|
|
if (!wsvqa->sample_rate)
|
|
|
|
wsvqa->sample_rate = 22050;
|
|
|
|
if (!wsvqa->channels)
|
|
|
|
wsvqa->channels = 1;
|
|
|
|
if (!wsvqa->bps)
|
|
|
|
wsvqa->bps = 8;
|
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 21:42:52 +03:00
|
|
|
st->codecpar->sample_rate = wsvqa->sample_rate;
|
|
|
|
st->codecpar->bits_per_coded_sample = wsvqa->bps;
|
|
|
|
st->codecpar->channels = wsvqa->channels;
|
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
2012-03-21 03:04:49 +03: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 21:42:52 +03:00
|
|
|
avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
|
2012-03-21 03:04:49 +03:00
|
|
|
|
|
|
|
switch (chunk_type) {
|
|
|
|
case SND0_TAG:
|
|
|
|
if (wsvqa->bps == 16)
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
|
2012-03-21 03:04:49 +03: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 21:42:52 +03:00
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
|
2012-03-21 03:04:49 +03:00
|
|
|
break;
|
|
|
|
case SND1_TAG:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_WESTWOOD_SND1;
|
2012-03-21 03:04:49 +03:00
|
|
|
break;
|
|
|
|
case SND2_TAG:
|
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 21:42:52 +03:00
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_WS;
|
2016-04-10 21:58:15 +02:00
|
|
|
if (ff_alloc_extradata(st->codecpar, 2))
|
2012-03-21 03:04:49 +03:00
|
|
|
return AVERROR(ENOMEM);
|
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 21:42:52 +03:00
|
|
|
AV_WL16(st->codecpar->extradata, wsvqa->version);
|
2012-03-21 03:04:49 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-29 07:42:59 +02:00
|
|
|
pkt->stream_index = wsvqa->audio_stream_index;
|
2012-03-21 03:04:49 +03:00
|
|
|
switch (chunk_type) {
|
|
|
|
case SND1_TAG:
|
|
|
|
/* unpacked size is stored in header */
|
2012-12-14 19:55:25 +03:00
|
|
|
if(pkt->data)
|
|
|
|
pkt->duration = AV_RL16(pkt->data) / wsvqa->channels;
|
2012-03-21 03:04:49 +03:00
|
|
|
break;
|
|
|
|
case SND2_TAG:
|
|
|
|
/* 2 samples/byte, 1 or 2 samples per frame depending on stereo */
|
|
|
|
pkt->duration = (chunk_size * 2) / wsvqa->channels;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case VQFR_TAG:
|
2006-11-29 07:42:59 +02:00
|
|
|
pkt->stream_index = wsvqa->video_stream_index;
|
2012-01-23 19:06:35 +03:00
|
|
|
pkt->duration = 1;
|
2012-03-21 03:04:49 +03:00
|
|
|
break;
|
2006-11-29 07:42:59 +02:00
|
|
|
}
|
2012-03-21 03:04:49 +03:00
|
|
|
|
2006-11-29 07:42:59 +02:00
|
|
|
/* stay on 16-bit alignment */
|
|
|
|
if (skip_byte)
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, 1);
|
2006-11-29 07:42:59 +02:00
|
|
|
|
|
|
|
return ret;
|
2003-10-01 07:39:38 +03:00
|
|
|
} else {
|
2006-11-29 07:42:59 +02:00
|
|
|
switch(chunk_type){
|
|
|
|
case CMDS_TAG:
|
|
|
|
break;
|
|
|
|
default:
|
2017-03-27 21:31:46 +02:00
|
|
|
av_log(s, AV_LOG_INFO, "Skipping unknown chunk %s\n",
|
|
|
|
av_fourcc2str(av_bswap32(chunk_type)));
|
2006-11-29 07:42:59 +02:00
|
|
|
}
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(pb, chunk_size + skip_byte);
|
2003-10-01 07:39:38 +03:00
|
|
|
}
|
2006-11-29 07:42:59 +02:00
|
|
|
}
|
2003-10-01 07:39:38 +03:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-01-26 00:03:28 +02:00
|
|
|
AVInputFormat ff_wsvqa_demuxer = {
|
2011-07-16 23:18:12 +03:00
|
|
|
.name = "wsvqa",
|
2012-07-25 00:51:41 +03:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Westwood Studios VQA"),
|
2011-07-16 23:18:12 +03:00
|
|
|
.priv_data_size = sizeof(WsVqaDemuxContext),
|
|
|
|
.read_probe = wsvqa_probe,
|
|
|
|
.read_header = wsvqa_read_header,
|
|
|
|
.read_packet = wsvqa_read_packet,
|
2003-10-01 07:39:38 +03:00
|
|
|
};
|