2005-12-17 19:14:38 +01:00
|
|
|
/*
|
2005-07-15 14:50:00 +02:00
|
|
|
* Yamaha SMAF format
|
|
|
|
* Copyright (c) 2005 Vidar Madsen
|
|
|
|
*
|
2006-10-07 17:30:46 +02:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2005-07-15 14:50:00 +02:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 17:30:46 +02:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2005-07-15 14:50:00 +02:00
|
|
|
*
|
2006-10-07 17:30:46 +02:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2005-07-15 14:50:00 +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
|
2006-10-07 17:30:46 +02:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 23:43:26 +01:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-07-15 14:50:00 +02:00
|
|
|
*/
|
2012-04-07 22:56:48 +02:00
|
|
|
|
|
|
|
#include "libavutil/channel_layout.h"
|
2005-07-15 14:50:00 +02:00
|
|
|
#include "avformat.h"
|
2011-02-24 07:36:02 +01:00
|
|
|
#include "avio_internal.h"
|
2013-05-09 10:37:31 +02:00
|
|
|
#include "internal.h"
|
2010-08-30 23:17:34 +02:00
|
|
|
#include "pcm.h"
|
2012-12-28 23:18:48 +01:00
|
|
|
#include "rawenc.h"
|
2006-07-12 02:09:34 +02:00
|
|
|
#include "riff.h"
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct MMFContext {
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t atrpos, atsqpos, awapos;
|
2012-12-03 19:26:43 +01:00
|
|
|
int64_t data_end;
|
2013-01-06 16:38:24 +01:00
|
|
|
int stereo;
|
2005-07-15 14:50:00 +02:00
|
|
|
} MMFContext;
|
|
|
|
|
2008-08-24 19:24:34 +02:00
|
|
|
static const int mmf_rates[] = { 4000, 8000, 11025, 22050, 44100 };
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2008-07-11 09:39:33 +02:00
|
|
|
static int mmf_rate(int code)
|
|
|
|
{
|
2013-05-09 10:37:31 +02:00
|
|
|
if ((code < 0) || (code > 4))
|
2008-07-11 09:39:33 +02:00
|
|
|
return -1;
|
|
|
|
return mmf_rates[code];
|
|
|
|
}
|
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MMF_MUXER
|
2005-07-15 14:50:00 +02:00
|
|
|
static int mmf_rate_code(int rate)
|
|
|
|
{
|
|
|
|
int i;
|
2013-05-09 10:37:31 +02:00
|
|
|
for (i = 0; i < 5; i++)
|
|
|
|
if (mmf_rates[i] == rate)
|
2005-07-15 14:50:00 +02:00
|
|
|
return i;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy of end_tag() from avienc.c, but for big-endian chunk size */
|
2011-02-20 11:04:12 +01:00
|
|
|
static void end_tag_be(AVIOContext *pb, int64_t start)
|
2005-07-15 14:50:00 +02:00
|
|
|
{
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t pos;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-03-03 20:11:45 +01:00
|
|
|
pos = avio_tell(pb);
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, start - 4, SEEK_SET);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(pb, (uint32_t)(pos - start));
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, pos, SEEK_SET);
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mmf_write_header(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
MMFContext *mmf = s->priv_data;
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = s->pb;
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t pos;
|
2005-07-15 14:50:00 +02:00
|
|
|
int rate;
|
2014-05-18 04:02:44 +02:00
|
|
|
const char *version = s->flags & AVFMT_FLAG_BITEXACT ?
|
2013-01-05 23:39:46 +01:00
|
|
|
"VN:Lavf," :
|
|
|
|
"VN:"LIBAVFORMAT_IDENT",";
|
2005-07-15 14:50:00 +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
|
|
|
rate = mmf_rate_code(s->streams[0]->codecpar->sample_rate);
|
2013-05-09 10:37:31 +02:00
|
|
|
if (rate < 0) {
|
2013-05-10 09:35:33 +02:00
|
|
|
av_log(s, AV_LOG_ERROR, "Unsupported sample rate %d, supported are 4000, 8000, 11025, 22050 and 44100\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 20:42:52 +02:00
|
|
|
s->streams[0]->codecpar->sample_rate);
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR(EINVAL);
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
2005-12-17 19:14:38 +01:00
|
|
|
|
2016-04-10 21:58:15 +02:00
|
|
|
mmf->stereo = s->streams[0]->codecpar->channels > 1;
|
2013-01-06 16:38:24 +01:00
|
|
|
if (mmf->stereo &&
|
2014-11-06 14:48:23 +01:00
|
|
|
s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
|
2013-01-06 16:38:24 +01:00
|
|
|
av_log(s, AV_LOG_ERROR, "Yamaha SMAF stereo is experimental, "
|
|
|
|
"add '-strict %d' if you want to use it.\n",
|
|
|
|
FF_COMPLIANCE_EXPERIMENTAL);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2011-02-24 07:36:02 +01:00
|
|
|
ffio_wfourcc(pb, "MMMD");
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(pb, 0);
|
2009-06-23 01:09:34 +02:00
|
|
|
pos = ff_start_tag(pb, "CNTI");
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0); /* class */
|
2012-03-21 22:11:25 +01:00
|
|
|
avio_w8(pb, 1); /* type */
|
|
|
|
avio_w8(pb, 1); /* code type */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0); /* status */
|
|
|
|
avio_w8(pb, 0); /* counts */
|
2013-01-05 23:11:09 +01:00
|
|
|
end_tag_be(pb, pos);
|
2013-01-05 23:11:09 +01:00
|
|
|
|
2013-01-05 23:11:09 +01:00
|
|
|
pos = ff_start_tag(pb, "OPDA");
|
2013-01-05 23:39:46 +01:00
|
|
|
avio_write(pb, version, strlen(version)); /* metadata ("ST:songtitle,VN:version,...") */
|
2005-07-15 14:50:00 +02:00
|
|
|
end_tag_be(pb, pos);
|
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(pb, "ATR\x00", 4);
|
|
|
|
avio_wb32(pb, 0);
|
2011-03-03 20:11:45 +01:00
|
|
|
mmf->atrpos = avio_tell(pb);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0); /* format type */
|
|
|
|
avio_w8(pb, 0); /* sequence type */
|
2013-01-06 16:38:24 +01:00
|
|
|
avio_w8(pb, (mmf->stereo << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0); /* wave base bit */
|
|
|
|
avio_w8(pb, 2); /* time base d */
|
|
|
|
avio_w8(pb, 2); /* time base g */
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-02-24 07:36:02 +01:00
|
|
|
ffio_wfourcc(pb, "Atsq");
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(pb, 16);
|
2011-03-03 20:11:45 +01:00
|
|
|
mmf->atsqpos = avio_tell(pb);
|
2005-07-15 14:50:00 +02:00
|
|
|
/* Will be filled on close */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2009-06-23 01:09:34 +02:00
|
|
|
mmf->awapos = ff_start_tag(pb, "Awa\x01");
|
2005-07-15 14:50:00 +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
|
|
|
avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codecpar->sample_rate);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(pb);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write a variable-length symbol */
|
2011-02-20 11:04:12 +01:00
|
|
|
static void put_varlength(AVIOContext *pb, int val)
|
2005-07-15 14:50:00 +02:00
|
|
|
{
|
2013-05-09 10:37:31 +02:00
|
|
|
if (val < 128)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, val);
|
2005-07-15 14:50:00 +02:00
|
|
|
else {
|
|
|
|
val -= 128;
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0x80 | val >> 7);
|
|
|
|
avio_w8(pb, 0x7f & val);
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mmf_write_trailer(AVFormatContext *s)
|
|
|
|
{
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = s->pb;
|
2005-07-15 14:50:00 +02:00
|
|
|
MMFContext *mmf = s->priv_data;
|
2008-10-03 12:16:29 +02:00
|
|
|
int64_t pos, size;
|
2005-07-15 14:50:00 +02:00
|
|
|
int gatetime;
|
|
|
|
|
2016-09-27 16:26:37 +02:00
|
|
|
if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
|
2005-07-15 14:50:00 +02:00
|
|
|
/* Fill in length fields */
|
|
|
|
end_tag_be(pb, mmf->awapos);
|
|
|
|
end_tag_be(pb, mmf->atrpos);
|
|
|
|
end_tag_be(pb, 8);
|
|
|
|
|
2013-05-09 10:37:31 +02:00
|
|
|
pos = avio_tell(pb);
|
2005-07-15 14:50:00 +02:00
|
|
|
size = pos - mmf->awapos;
|
|
|
|
|
|
|
|
/* Fill Atsq chunk */
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, mmf->atsqpos, SEEK_SET);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
/* "play wav" */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0); /* start time */
|
2013-01-06 16:38:24 +01:00
|
|
|
avio_w8(pb, (mmf->stereo << 6) | 1); /* (channel << 6) | wavenum */
|
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
|
|
|
gatetime = size * 500 / s->streams[0]->codecpar->sample_rate;
|
2005-07-15 14:50:00 +02:00
|
|
|
put_varlength(pb, gatetime); /* duration */
|
|
|
|
|
|
|
|
/* "nop" */
|
|
|
|
put_varlength(pb, gatetime); /* start time */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(pb, "\xff\x00", 2); /* nop */
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
/* "end of sequence" */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(pb, "\x00\x00\x00\x00", 4);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-02-28 14:57:54 +01:00
|
|
|
avio_seek(pb, pos, SEEK_SET);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(pb);
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-09-03 00:45:13 +02:00
|
|
|
#endif /* CONFIG_MMF_MUXER */
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
static int mmf_probe(AVProbeData *p)
|
|
|
|
{
|
|
|
|
/* check file header */
|
|
|
|
if (p->buf[0] == 'M' && p->buf[1] == 'M' &&
|
|
|
|
p->buf[2] == 'M' && p->buf[3] == 'D' &&
|
|
|
|
p->buf[8] == 'C' && p->buf[9] == 'N' &&
|
|
|
|
p->buf[10] == 'T' && p->buf[11] == 'I')
|
|
|
|
return AVPROBE_SCORE_MAX;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* mmf input */
|
2012-01-12 13:20:36 +01:00
|
|
|
static int mmf_read_header(AVFormatContext *s)
|
2005-07-15 14:50:00 +02:00
|
|
|
{
|
|
|
|
MMFContext *mmf = s->priv_data;
|
|
|
|
unsigned int tag;
|
2011-02-20 11:04:12 +01:00
|
|
|
AVIOContext *pb = s->pb;
|
2005-07-15 14:50:00 +02:00
|
|
|
AVStream *st;
|
2011-06-01 18:26:27 +02:00
|
|
|
int64_t size;
|
2005-07-15 14:50:00 +02:00
|
|
|
int rate, params;
|
|
|
|
|
2011-02-21 16:43:01 +01:00
|
|
|
tag = avio_rl32(pb);
|
2005-07-15 14:50:00 +02:00
|
|
|
if (tag != MKTAG('M', 'M', 'M', 'D'))
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2011-06-01 18:26:27 +02:00
|
|
|
avio_skip(pb, 4); /* file_size */
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
/* Skip some unused chunks that may or may not be present */
|
2013-05-09 10:37:31 +02:00
|
|
|
for (;; avio_skip(pb, size)) {
|
|
|
|
tag = avio_rl32(pb);
|
2011-02-21 16:43:01 +01:00
|
|
|
size = avio_rb32(pb);
|
2013-05-09 10:37:31 +02:00
|
|
|
if (tag == MKTAG('C', 'N', 'T', 'I'))
|
|
|
|
continue;
|
|
|
|
if (tag == MKTAG('O', 'P', 'D', 'A'))
|
|
|
|
continue;
|
2005-07-15 14:50:00 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tag = "ATRx", where "x" = track number */
|
2006-04-21 00:17:11 +02:00
|
|
|
if ((tag & 0xffffff) == MKTAG('M', 'T', 'R', 0)) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "MIDI like format found, unsupported\n");
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR_PATCHWELCOME;
|
2006-04-21 00:17:11 +02:00
|
|
|
}
|
2005-07-15 14:50:00 +02:00
|
|
|
if ((tag & 0xffffff) != MKTAG('A', 'T', 'R', 0)) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Unsupported SMAF chunk %08x\n", tag);
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR_PATCHWELCOME;
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
|
|
|
|
2011-02-21 16:43:01 +01:00
|
|
|
avio_r8(pb); /* format type */
|
|
|
|
avio_r8(pb); /* sequence type */
|
|
|
|
params = avio_r8(pb); /* (channel << 7) | (format << 4) | rate */
|
2013-05-09 10:37:31 +02:00
|
|
|
rate = mmf_rate(params & 0x0f);
|
|
|
|
if (rate < 0) {
|
2005-07-15 14:50:00 +02:00
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid sample rate\n");
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
2011-02-21 16:43:01 +01:00
|
|
|
avio_r8(pb); /* wave base bit */
|
|
|
|
avio_r8(pb); /* time base d */
|
|
|
|
avio_r8(pb); /* time base g */
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
/* Skip some unused chunks that may or may not be present */
|
2013-05-09 10:37:31 +02:00
|
|
|
for (;; avio_skip(pb, size)) {
|
|
|
|
tag = avio_rl32(pb);
|
2011-02-21 16:43:01 +01:00
|
|
|
size = avio_rb32(pb);
|
2013-05-09 10:37:31 +02:00
|
|
|
if (tag == MKTAG('A', 't', 's', 'q'))
|
|
|
|
continue;
|
|
|
|
if (tag == MKTAG('A', 's', 'p', 'I'))
|
|
|
|
continue;
|
2005-07-15 14:50:00 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure it's followed by an Awa chunk, aka wave data */
|
|
|
|
if ((tag & 0xffffff) != MKTAG('A', 'w', 'a', 0)) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Unexpected SMAF chunk %08x\n", tag);
|
2012-12-04 12:59:46 +01:00
|
|
|
return AVERROR_INVALIDDATA;
|
2005-07-15 14:50:00 +02:00
|
|
|
}
|
2012-12-03 19:26:43 +01:00
|
|
|
mmf->data_end = avio_tell(pb) + size;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2011-06-18 11:43:24 +02:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2005-07-15 14:50:00 +02:00
|
|
|
if (!st)
|
2007-07-19 17:21:30 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2005-07-15 14:50:00 +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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_ADPCM_YAMAHA;
|
|
|
|
st->codecpar->sample_rate = rate;
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->channels = (params >> 7) + 1;
|
|
|
|
st->codecpar->channel_layout = params >> 7 ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
|
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 = 4;
|
|
|
|
st->codecpar->bit_rate = st->codecpar->sample_rate *
|
|
|
|
st->codecpar->bits_per_coded_sample;
|
2005-07-15 14:50:00 +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
|
|
|
avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_SIZE 4096
|
|
|
|
|
2013-05-09 10:37:31 +02:00
|
|
|
static int mmf_read_packet(AVFormatContext *s, AVPacket *pkt)
|
2005-07-15 14:50:00 +02:00
|
|
|
{
|
|
|
|
MMFContext *mmf = s->priv_data;
|
2012-12-03 19:26:43 +01:00
|
|
|
int64_t left, size;
|
|
|
|
int ret;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2012-12-03 19:26:43 +01:00
|
|
|
left = mmf->data_end - avio_tell(s->pb);
|
|
|
|
size = FFMIN(left, MAX_SIZE);
|
2014-08-07 22:12:41 +02:00
|
|
|
if (avio_feof(s->pb) || size <= 0)
|
2012-11-24 15:24:13 +01:00
|
|
|
return AVERROR_EOF;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2012-05-01 19:59:29 +02:00
|
|
|
ret = av_get_packet(s->pb, pkt, size);
|
2005-07-15 14:50:00 +02:00
|
|
|
if (ret < 0)
|
2012-05-01 19:59:29 +02:00
|
|
|
return ret;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
2012-05-01 19:59:29 +02:00
|
|
|
pkt->stream_index = 0;
|
2005-07-15 14:50:00 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MMF_DEMUXER
|
2011-01-25 23:03:28 +01:00
|
|
|
AVInputFormat ff_mmf_demuxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "mmf",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
|
|
|
|
.priv_data_size = sizeof(MMFContext),
|
|
|
|
.read_probe = mmf_probe,
|
|
|
|
.read_header = mmf_read_header,
|
|
|
|
.read_packet = mmf_read_packet,
|
2012-12-03 19:26:43 +01:00
|
|
|
.flags = AVFMT_GENERIC_INDEX,
|
2005-07-15 14:50:00 +02:00
|
|
|
};
|
2006-07-10 23:14:37 +02:00
|
|
|
#endif
|
2013-05-09 10:37:31 +02:00
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MMF_MUXER
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mmf_muxer = {
|
2013-05-09 10:37:31 +02:00
|
|
|
.name = "mmf",
|
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
|
|
|
|
.mime_type = "application/vnd.smaf",
|
|
|
|
.extensions = "mmf",
|
|
|
|
.priv_data_size = sizeof(MMFContext),
|
|
|
|
.audio_codec = AV_CODEC_ID_ADPCM_YAMAHA,
|
|
|
|
.video_codec = AV_CODEC_ID_NONE,
|
|
|
|
.write_header = mmf_write_header,
|
2013-05-10 09:35:33 +02:00
|
|
|
.write_packet = ff_raw_write_packet,
|
2013-05-09 10:37:31 +02:00
|
|
|
.write_trailer = mmf_write_trailer,
|
2005-07-15 14:50:00 +02:00
|
|
|
};
|
2006-07-10 23:14:37 +02:00
|
|
|
#endif
|