2005-12-17 18:14:38 +00:00
|
|
|
/*
|
2011-01-21 13:53:46 +00:00
|
|
|
* MP3 muxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
2003-09-08 22:34:28 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2003-09-08 22:34:28 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2003-09-08 22:34:28 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2003-09-08 22:34:28 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2003-09-08 22:34:28 +00:00
|
|
|
*/
|
2008-05-09 11:56:36 +00:00
|
|
|
|
2003-09-08 22:34:28 +00:00
|
|
|
#include "avformat.h"
|
2011-03-21 20:02:50 +00:00
|
|
|
#include "avio_internal.h"
|
2009-06-11 15:26:57 +00:00
|
|
|
#include "id3v1.h"
|
2011-01-21 13:53:46 +00:00
|
|
|
#include "id3v2.h"
|
2011-03-16 13:31:32 +00:00
|
|
|
#include "rawenc.h"
|
2011-05-03 18:19:31 +00:00
|
|
|
#include "libavutil/avstring.h"
|
2011-03-21 20:02:50 +00:00
|
|
|
#include "libavcodec/mpegaudio.h"
|
|
|
|
#include "libavcodec/mpegaudiodata.h"
|
|
|
|
#include "libavcodec/mpegaudiodecheader.h"
|
2011-01-21 13:53:46 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2011-01-21 19:54:35 +00:00
|
|
|
#include "libavutil/opt.h"
|
2011-05-22 10:46:29 +00:00
|
|
|
#include "libavutil/dict.h"
|
2012-02-25 01:17:37 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2014-04-12 13:20:57 +00:00
|
|
|
#include "libavutil/crc.h"
|
|
|
|
#include "libavutil/mathematics.h"
|
|
|
|
#include "libavutil/replaygain.h"
|
2007-05-22 08:23:45 +00:00
|
|
|
|
2009-02-02 22:13:03 +00:00
|
|
|
static int id3v1_set_string(AVFormatContext *s, const char *key,
|
|
|
|
uint8_t *buf, int buf_size)
|
2008-07-11 07:41:11 +00:00
|
|
|
{
|
2011-05-22 10:46:29 +00:00
|
|
|
AVDictionaryEntry *tag;
|
|
|
|
if ((tag = av_dict_get(s->metadata, key, NULL, 0)))
|
2011-05-03 18:19:31 +00:00
|
|
|
av_strlcpy(buf, tag->value, buf_size);
|
2009-02-02 22:13:03 +00:00
|
|
|
return !!tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
|
|
|
|
{
|
2011-05-22 10:46:29 +00:00
|
|
|
AVDictionaryEntry *tag;
|
2009-02-02 22:13:03 +00:00
|
|
|
int i, count = 0;
|
2008-07-11 07:41:11 +00:00
|
|
|
|
|
|
|
memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */
|
|
|
|
buf[0] = 'T';
|
|
|
|
buf[1] = 'A';
|
|
|
|
buf[2] = 'G';
|
2011-10-31 14:11:37 +00:00
|
|
|
/* we knowingly overspecify each tag length by one byte to compensate for the mandatory null byte added by av_strlcpy */
|
|
|
|
count += id3v1_set_string(s, "TIT2", buf + 3, 30 + 1); //title
|
|
|
|
count += id3v1_set_string(s, "TPE1", buf + 33, 30 + 1); //author|artist
|
|
|
|
count += id3v1_set_string(s, "TALB", buf + 63, 30 + 1); //album
|
2014-11-04 12:54:43 +00:00
|
|
|
count += id3v1_set_string(s, "TDRC", buf + 93, 4 + 1); //date
|
2011-10-31 14:11:37 +00:00
|
|
|
count += id3v1_set_string(s, "comment", buf + 97, 30 + 1);
|
2011-05-22 10:46:29 +00:00
|
|
|
if ((tag = av_dict_get(s->metadata, "TRCK", NULL, 0))) { //track
|
2008-07-11 07:41:11 +00:00
|
|
|
buf[125] = 0;
|
2009-02-02 22:13:03 +00:00
|
|
|
buf[126] = atoi(tag->value);
|
|
|
|
count++;
|
2008-07-11 07:41:11 +00:00
|
|
|
}
|
2009-09-15 23:40:10 +00:00
|
|
|
buf[127] = 0xFF; /* default to unknown genre */
|
2011-05-22 10:46:29 +00:00
|
|
|
if ((tag = av_dict_get(s->metadata, "TCON", NULL, 0))) { //genre
|
2009-02-02 22:14:28 +00:00
|
|
|
for(i = 0; i <= ID3v1_GENRE_MAX; i++) {
|
2011-11-02 19:17:25 +00:00
|
|
|
if (!av_strcasecmp(tag->value, ff_id3v1_genre_str[i])) {
|
2009-02-02 22:14:28 +00:00
|
|
|
buf[127] = i;
|
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
2008-07-11 07:41:11 +00:00
|
|
|
}
|
|
|
|
}
|
2009-02-02 22:13:03 +00:00
|
|
|
return count;
|
2008-07-11 07:41:11 +00:00
|
|
|
}
|
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
#define XING_NUM_BAGS 400
|
|
|
|
#define XING_TOC_SIZE 100
|
2014-04-12 13:20:57 +00:00
|
|
|
// size of the XING/LAME data, starting from the Xing tag
|
|
|
|
#define XING_SIZE 156
|
2011-10-23 23:01:21 +00:00
|
|
|
|
2011-03-21 20:02:50 +00:00
|
|
|
typedef struct MP3Context {
|
|
|
|
const AVClass *class;
|
2012-02-28 08:52:05 +00:00
|
|
|
ID3v2EncContext id3;
|
2011-03-21 20:02:50 +00:00
|
|
|
int id3v2_version;
|
2011-08-16 09:43:23 +00:00
|
|
|
int write_id3v1;
|
2014-01-14 20:47:45 +00:00
|
|
|
int write_xing;
|
2012-09-10 12:44:32 +00:00
|
|
|
|
|
|
|
/* xing header */
|
2014-04-12 13:20:57 +00:00
|
|
|
// a buffer containing the whole XING/LAME frame
|
|
|
|
uint8_t *xing_frame;
|
|
|
|
int xing_frame_size;
|
|
|
|
|
|
|
|
AVCRC audio_crc; // CRC of the audio data
|
|
|
|
uint32_t audio_size; // total size of the audio data
|
|
|
|
|
|
|
|
// offset of the XING/LAME frame in the file
|
|
|
|
int64_t xing_frame_offset;
|
|
|
|
// offset of the XING/INFO tag in the frame
|
|
|
|
int xing_offset;
|
|
|
|
|
2011-07-09 00:06:40 +00:00
|
|
|
int32_t frames;
|
|
|
|
int32_t size;
|
|
|
|
uint32_t want;
|
|
|
|
uint32_t seen;
|
|
|
|
uint32_t pos;
|
2012-09-10 12:44:32 +00:00
|
|
|
uint64_t bag[XING_NUM_BAGS];
|
2012-05-07 09:55:05 +00:00
|
|
|
int initial_bitrate;
|
|
|
|
int has_variable_bitrate;
|
2016-10-17 21:55:04 +00:00
|
|
|
int delay;
|
|
|
|
int padding;
|
2011-03-21 20:02:50 +00:00
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
/* index of the audio stream */
|
|
|
|
int audio_stream_idx;
|
|
|
|
/* number of attached pictures we still need to write */
|
|
|
|
int pics_to_write;
|
2011-01-21 19:54:35 +00:00
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
/* audio packets are queued here until we get all the attached pictures */
|
|
|
|
AVPacketList *queue, *queue_end;
|
2011-03-21 20:02:50 +00:00
|
|
|
} MP3Context;
|
2011-01-21 19:54:35 +00:00
|
|
|
|
2012-05-09 20:39:40 +00:00
|
|
|
static const uint8_t xing_offtbl[2][2] = {{32, 17}, {17, 9}};
|
2011-05-07 00:23:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Write an empty XING header and initialize respective data.
|
|
|
|
*/
|
|
|
|
static int mp3_write_xing(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
MP3Context *mp3 = s->priv_data;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
AVCodecParameters *par = s->streams[mp3->audio_stream_idx]->codecpar;
|
2014-04-12 13:20:57 +00:00
|
|
|
AVDictionaryEntry *enc = av_dict_get(s->streams[mp3->audio_stream_idx]->metadata, "encoder", NULL, 0);
|
|
|
|
AVIOContext *dyn_ctx;
|
2012-02-29 08:11:26 +00:00
|
|
|
int32_t header;
|
|
|
|
MPADecodeHeader mpah;
|
|
|
|
int srate_idx, i, channels;
|
2012-09-10 12:44:32 +00:00
|
|
|
int bitrate_idx;
|
2014-04-12 19:12:42 +00:00
|
|
|
int best_bitrate_idx = -1;
|
2014-04-09 16:22:53 +00:00
|
|
|
int best_bitrate_error = INT_MAX;
|
2014-04-12 13:20:57 +00:00
|
|
|
int ret;
|
2012-05-09 20:39:40 +00:00
|
|
|
int ver = 0;
|
2014-04-13 18:03:24 +00:00
|
|
|
int bytes_needed;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2016-09-27 14:26:37 +00:00
|
|
|
if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) || !mp3->write_xing)
|
2012-03-01 00:13:16 +00:00
|
|
|
return 0;
|
2012-02-29 08:11:26 +00:00
|
|
|
|
2012-05-09 20:39:40 +00:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++) {
|
|
|
|
const uint16_t base_freq = avpriv_mpa_freq_tab[i];
|
2012-05-09 20:39:40 +00:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (par->sample_rate == base_freq) ver = 0x3; // MPEG 1
|
|
|
|
else if (par->sample_rate == base_freq / 2) ver = 0x2; // MPEG 2
|
|
|
|
else if (par->sample_rate == base_freq / 4) ver = 0x0; // MPEG 2.5
|
2012-05-09 20:39:40 +00:00
|
|
|
else continue;
|
2012-05-09 20:39:40 +00:00
|
|
|
|
2012-05-09 20:39:40 +00:00
|
|
|
srate_idx = i;
|
|
|
|
break;
|
|
|
|
}
|
2011-10-17 07:28:53 +00:00
|
|
|
if (i == FF_ARRAY_ELEMS(avpriv_mpa_freq_tab)) {
|
2012-04-13 22:47:53 +00:00
|
|
|
av_log(s, AV_LOG_WARNING, "Unsupported sample rate, not writing Xing header.\n");
|
2011-05-07 00:23:28 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
switch (par->channels) {
|
2011-05-07 00:23:28 +00:00
|
|
|
case 1: channels = MPA_MONO; break;
|
|
|
|
case 2: channels = MPA_STEREO; break;
|
2012-09-09 18:39:40 +00:00
|
|
|
default: av_log(s, AV_LOG_WARNING, "Unsupported number of channels, "
|
|
|
|
"not writing Xing header.\n");
|
2012-09-16 12:14:47 +00:00
|
|
|
return -1;
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* dummy MPEG audio header */
|
2012-10-14 03:49:10 +00:00
|
|
|
header = 0xffU << 24; // sync
|
2012-05-09 20:39:40 +00:00
|
|
|
header |= (0x7 << 5 | ver << 3 | 0x1 << 1 | 0x1) << 16; // sync/audio-version/layer 3/no crc*/
|
2014-04-09 16:22:53 +00:00
|
|
|
header |= (srate_idx << 2) << 8;
|
2011-05-07 00:23:28 +00:00
|
|
|
header |= channels << 6;
|
|
|
|
|
2014-04-09 16:22:53 +00:00
|
|
|
for (bitrate_idx = 1; bitrate_idx < 15; bitrate_idx++) {
|
2014-04-13 18:03:24 +00:00
|
|
|
int bit_rate = 1000 * avpriv_mpa_bitrate_tab[ver != 3][3 - 1][bitrate_idx];
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
int error = FFABS(bit_rate - par->bit_rate);
|
2014-04-09 16:22:53 +00:00
|
|
|
|
2014-04-12 19:12:42 +00:00
|
|
|
if (error < best_bitrate_error) {
|
2014-04-09 16:22:53 +00:00
|
|
|
best_bitrate_error = error;
|
|
|
|
best_bitrate_idx = bitrate_idx;
|
2011-11-14 19:57:30 +00:00
|
|
|
}
|
|
|
|
}
|
2012-02-25 01:17:37 +00:00
|
|
|
av_assert0(best_bitrate_idx >= 0);
|
2011-11-14 19:57:30 +00:00
|
|
|
|
2014-04-12 19:12:42 +00:00
|
|
|
for (bitrate_idx = best_bitrate_idx; ; bitrate_idx++) {
|
2014-04-09 16:22:53 +00:00
|
|
|
int32_t mask = bitrate_idx << (4 + 8);
|
2011-05-07 00:23:28 +00:00
|
|
|
if (15 == bitrate_idx)
|
|
|
|
return -1;
|
2012-01-02 08:39:11 +00:00
|
|
|
header |= mask;
|
2014-04-09 16:22:53 +00:00
|
|
|
|
2016-02-03 23:20:51 +00:00
|
|
|
ret = avpriv_mpegaudio_decode_header(&mpah, header);
|
|
|
|
av_assert0(ret >= 0);
|
2014-10-24 12:48:12 +00:00
|
|
|
mp3->xing_offset = xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1] + 4;
|
|
|
|
bytes_needed = mp3->xing_offset + XING_SIZE;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2014-04-09 16:22:53 +00:00
|
|
|
if (bytes_needed <= mpah.frame_size)
|
2011-05-07 00:23:28 +00:00
|
|
|
break;
|
2014-04-09 16:22:53 +00:00
|
|
|
|
2012-01-02 08:39:11 +00:00
|
|
|
header &= ~mask;
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
ret = avio_open_dyn_buf(&dyn_ctx);
|
|
|
|
if (ret < 0)
|
2014-10-24 12:48:12 +00:00
|
|
|
return ret;
|
2014-04-12 13:20:57 +00:00
|
|
|
|
|
|
|
avio_wb32(dyn_ctx, header);
|
2012-09-10 12:44:32 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
ffio_fill(dyn_ctx, 0, mp3->xing_offset - 4);
|
|
|
|
ffio_wfourcc(dyn_ctx, "Xing");
|
|
|
|
avio_wb32(dyn_ctx, 0x01 | 0x02 | 0x04 | 0x08); // frames / size / TOC / vbr scale
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
mp3->size = mpah.frame_size;
|
2011-04-26 01:45:48 +00:00
|
|
|
mp3->want=1;
|
|
|
|
mp3->seen=0;
|
|
|
|
mp3->pos=0;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
avio_wb32(dyn_ctx, 0); // frames
|
|
|
|
avio_wb32(dyn_ctx, 0); // size
|
2012-09-10 12:44:32 +00:00
|
|
|
|
|
|
|
// TOC
|
|
|
|
for (i = 0; i < XING_TOC_SIZE; i++)
|
2014-10-24 12:48:12 +00:00
|
|
|
avio_w8(dyn_ctx, (uint8_t)(255 * i / XING_TOC_SIZE));
|
2014-04-12 13:20:57 +00:00
|
|
|
|
|
|
|
// vbr quality
|
|
|
|
// we write it, because some (broken) tools always expect it to be present
|
|
|
|
avio_wb32(dyn_ctx, 0);
|
|
|
|
|
|
|
|
// encoder short version string
|
|
|
|
if (enc) {
|
|
|
|
uint8_t encoder_str[9] = { 0 };
|
2014-10-24 13:47:33 +00:00
|
|
|
if ( strlen(enc->value) > sizeof(encoder_str)
|
|
|
|
&& !strcmp("Lavc libmp3lame", enc->value)) {
|
|
|
|
memcpy(encoder_str, "Lavf lame", 9);
|
|
|
|
} else
|
|
|
|
memcpy(encoder_str, enc->value, FFMIN(strlen(enc->value), sizeof(encoder_str)));
|
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
avio_write(dyn_ctx, encoder_str, sizeof(encoder_str));
|
|
|
|
} else
|
2014-10-24 12:48:12 +00:00
|
|
|
avio_write(dyn_ctx, "Lavf\0\0\0\0\0", 9);
|
2014-04-12 13:20:57 +00:00
|
|
|
|
|
|
|
avio_w8(dyn_ctx, 0); // tag revision 0 / unknown vbr method
|
|
|
|
avio_w8(dyn_ctx, 0); // unknown lowpass filter value
|
|
|
|
ffio_fill(dyn_ctx, 0, 8); // empty replaygain fields
|
|
|
|
avio_w8(dyn_ctx, 0); // unknown encoding flags
|
|
|
|
avio_w8(dyn_ctx, 0); // unknown abr/minimal bitrate
|
2016-10-17 21:55:04 +00:00
|
|
|
avio_wb24(dyn_ctx, 0); // empty encoder delay/padding
|
2014-04-12 13:20:57 +00:00
|
|
|
|
|
|
|
avio_w8(dyn_ctx, 0); // misc
|
|
|
|
avio_w8(dyn_ctx, 0); // mp3gain
|
|
|
|
avio_wb16(dyn_ctx, 0); // preset
|
|
|
|
|
|
|
|
// audio length and CRCs (will be updated later)
|
|
|
|
avio_wb32(dyn_ctx, 0); // music length
|
|
|
|
avio_wb16(dyn_ctx, 0); // music crc
|
|
|
|
avio_wb16(dyn_ctx, 0); // tag crc
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
ffio_fill(dyn_ctx, 0, mpah.frame_size - bytes_needed);
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
mp3->xing_frame_size = avio_close_dyn_buf(dyn_ctx, &mp3->xing_frame);
|
|
|
|
mp3->xing_frame_offset = avio_tell(s->pb);
|
|
|
|
avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size);
|
2012-07-04 20:22:18 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
mp3->audio_size = mp3->xing_frame_size;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a frame to XING data.
|
|
|
|
* Following lame's "VbrTag.c".
|
|
|
|
*/
|
2012-09-10 12:44:32 +00:00
|
|
|
static void mp3_xing_add_frame(MP3Context *mp3, AVPacket *pkt)
|
2011-05-07 00:23:28 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
mp3->frames++;
|
|
|
|
mp3->seen++;
|
2011-04-26 01:45:48 +00:00
|
|
|
mp3->size += pkt->size;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
if (mp3->want == mp3->seen) {
|
2011-04-26 01:45:48 +00:00
|
|
|
mp3->bag[mp3->pos] = mp3->size;
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
if (XING_NUM_BAGS == ++mp3->pos) {
|
2011-05-07 00:23:28 +00:00
|
|
|
/* shrink table to half size by throwing away each second bag. */
|
2012-09-10 12:44:32 +00:00
|
|
|
for (i = 1; i < XING_NUM_BAGS; i += 2)
|
2011-04-26 01:45:48 +00:00
|
|
|
mp3->bag[i >> 1] = mp3->bag[i];
|
2011-05-07 00:23:28 +00:00
|
|
|
|
|
|
|
/* double wanted amount per bag. */
|
2012-09-10 12:44:32 +00:00
|
|
|
mp3->want *= 2;
|
2011-05-07 00:23:28 +00:00
|
|
|
/* adjust current position to half of table size. */
|
2012-09-10 12:44:32 +00:00
|
|
|
mp3->pos = XING_NUM_BAGS / 2;
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
|
|
|
|
2011-04-26 01:45:48 +00:00
|
|
|
mp3->seen = 0;
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt)
|
2011-05-07 00:23:28 +00:00
|
|
|
{
|
2012-09-10 12:44:32 +00:00
|
|
|
MP3Context *mp3 = s->priv_data;
|
|
|
|
|
2012-10-16 18:27:16 +00:00
|
|
|
if (pkt->data && pkt->size >= 4) {
|
2014-04-12 19:12:42 +00:00
|
|
|
MPADecodeHeader mpah;
|
2015-10-09 13:16:46 +00:00
|
|
|
int ret;
|
2012-05-07 10:53:58 +00:00
|
|
|
int av_unused base;
|
2014-06-22 17:19:36 +00:00
|
|
|
uint32_t h;
|
|
|
|
|
|
|
|
h = AV_RB32(pkt->data);
|
2016-01-01 15:47:27 +00:00
|
|
|
ret = avpriv_mpegaudio_decode_header(&mpah, h);
|
2015-10-09 13:16:46 +00:00
|
|
|
if (ret >= 0) {
|
2014-06-22 17:19:36 +00:00
|
|
|
if (!mp3->initial_bitrate)
|
2014-06-23 01:34:13 +00:00
|
|
|
mp3->initial_bitrate = mpah.bit_rate;
|
|
|
|
if ((mpah.bit_rate == 0) || (mp3->initial_bitrate != mpah.bit_rate))
|
2014-06-22 17:19:36 +00:00
|
|
|
mp3->has_variable_bitrate = 1;
|
2014-06-23 01:34:13 +00:00
|
|
|
} else {
|
2017-03-27 19:31:46 +00:00
|
|
|
av_log(s, AV_LOG_WARNING, "Audio packet of size %d (starting with %08"PRIX32"...) "
|
2014-06-23 01:34:13 +00:00
|
|
|
"is invalid, writing it anyway.\n", pkt->size, h);
|
2012-11-16 08:21:17 +00:00
|
|
|
}
|
2011-05-07 00:23:28 +00:00
|
|
|
|
2012-05-07 09:55:05 +00:00
|
|
|
#ifdef FILTER_VBR_HEADERS
|
2011-05-07 00:23:28 +00:00
|
|
|
/* filter out XING and INFO headers. */
|
2014-04-12 19:12:42 +00:00
|
|
|
base = 4 + xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1];
|
2011-05-07 00:23:28 +00:00
|
|
|
|
|
|
|
if (base + 4 <= pkt->size) {
|
|
|
|
uint32_t v = AV_RB32(pkt->data + base);
|
|
|
|
|
2011-04-26 01:06:04 +00:00
|
|
|
if (MKBETAG('X','i','n','g') == v || MKBETAG('I','n','f','o') == v)
|
2011-05-07 00:23:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* filter out VBRI headers. */
|
|
|
|
base = 4 + 32;
|
|
|
|
|
2011-04-26 01:06:04 +00:00
|
|
|
if (base + 4 <= pkt->size && MKBETAG('V','B','R','I') == AV_RB32(pkt->data + base))
|
2011-05-07 00:23:28 +00:00
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
if (mp3->xing_offset) {
|
2016-10-17 21:55:04 +00:00
|
|
|
uint8_t *side_data = NULL;
|
|
|
|
int side_data_size = 0;
|
|
|
|
|
2012-09-16 12:14:47 +00:00
|
|
|
mp3_xing_add_frame(mp3, pkt);
|
2014-04-12 13:20:57 +00:00
|
|
|
mp3->audio_size += pkt->size;
|
|
|
|
mp3->audio_crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE),
|
|
|
|
mp3->audio_crc, pkt->data, pkt->size);
|
2016-10-17 21:55:04 +00:00
|
|
|
|
|
|
|
side_data = av_packet_get_side_data(pkt,
|
|
|
|
AV_PKT_DATA_SKIP_SAMPLES,
|
|
|
|
&side_data_size);
|
|
|
|
if (side_data && side_data_size >= 10) {
|
|
|
|
mp3->padding = FFMAX(AV_RL32(side_data + 4) + 528 + 1, 0);
|
|
|
|
if (!mp3->delay)
|
|
|
|
mp3->delay = FFMAX(AV_RL32(side_data) - 528 - 1, 0);
|
|
|
|
} else {
|
|
|
|
mp3->padding = 0;
|
|
|
|
}
|
2014-04-12 13:20:57 +00:00
|
|
|
}
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
2012-09-10 12:44:32 +00:00
|
|
|
|
|
|
|
return ff_raw_write_packet(s, pkt);
|
2011-05-07 00:23:28 +00:00
|
|
|
}
|
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
static int mp3_queue_flush(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
MP3Context *mp3 = s->priv_data;
|
2018-03-26 18:02:39 +00:00
|
|
|
AVPacket pkt;
|
2012-02-28 08:52:05 +00:00
|
|
|
int ret = 0, write = 1;
|
|
|
|
|
2013-12-30 17:13:08 +00:00
|
|
|
ff_id3v2_finish(&mp3->id3, s->pb, s->metadata_header_padding);
|
2012-02-28 08:52:05 +00:00
|
|
|
mp3_write_xing(s);
|
|
|
|
|
2018-03-26 18:02:39 +00:00
|
|
|
while (mp3->queue) {
|
|
|
|
ff_packet_list_get(&mp3->queue, &mp3->queue_end, &pkt);
|
|
|
|
if (write && (ret = mp3_write_audio_packet(s, &pkt)) < 0)
|
2012-02-28 08:52:05 +00:00
|
|
|
write = 0;
|
2018-03-26 18:02:39 +00:00
|
|
|
av_packet_unref(&pkt);
|
2012-02-28 08:52:05 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-16 12:31:58 +00:00
|
|
|
static void mp3_update_xing(AVFormatContext *s)
|
|
|
|
{
|
|
|
|
MP3Context *mp3 = s->priv_data;
|
2014-04-12 13:20:57 +00:00
|
|
|
AVReplayGain *rg;
|
|
|
|
uint16_t tag_crc;
|
|
|
|
uint8_t *toc;
|
|
|
|
int i, rg_size;
|
2012-09-16 12:31:58 +00:00
|
|
|
|
|
|
|
/* replace "Xing" identification string with "Info" for CBR files. */
|
2014-04-12 13:20:57 +00:00
|
|
|
if (!mp3->has_variable_bitrate)
|
|
|
|
AV_WL32(mp3->xing_frame + mp3->xing_offset, MKTAG('I', 'n', 'f', 'o'));
|
2012-09-16 12:31:58 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
AV_WB32(mp3->xing_frame + mp3->xing_offset + 8, mp3->frames);
|
|
|
|
AV_WB32(mp3->xing_frame + mp3->xing_offset + 12, mp3->size);
|
2012-09-16 12:31:58 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
toc = mp3->xing_frame + mp3->xing_offset + 16;
|
|
|
|
toc[0] = 0; // first toc entry has to be zero.
|
2012-09-16 12:31:58 +00:00
|
|
|
for (i = 1; i < XING_TOC_SIZE; ++i) {
|
|
|
|
int j = i * mp3->pos / XING_TOC_SIZE;
|
|
|
|
int seek_point = 256LL * mp3->bag[j] / mp3->size;
|
2014-04-12 13:20:57 +00:00
|
|
|
toc[i] = FFMIN(seek_point, 255);
|
2012-09-16 12:31:58 +00:00
|
|
|
}
|
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
/* write replaygain */
|
|
|
|
rg = (AVReplayGain*)av_stream_get_side_data(s->streams[0], AV_PKT_DATA_REPLAYGAIN,
|
|
|
|
&rg_size);
|
|
|
|
if (rg && rg_size >= sizeof(*rg)) {
|
|
|
|
uint16_t val;
|
|
|
|
|
|
|
|
AV_WB32(mp3->xing_frame + mp3->xing_offset + 131,
|
|
|
|
av_rescale(rg->track_peak, 1 << 23, 100000));
|
|
|
|
|
|
|
|
if (rg->track_gain != INT32_MIN) {
|
|
|
|
val = FFABS(rg->track_gain / 10000) & ((1 << 9) - 1);
|
|
|
|
val |= (rg->track_gain < 0) << 9;
|
|
|
|
val |= 1 << 13;
|
|
|
|
AV_WB16(mp3->xing_frame + mp3->xing_offset + 135, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rg->album_gain != INT32_MIN) {
|
|
|
|
val = FFABS(rg->album_gain / 10000) & ((1 << 9) - 1);
|
|
|
|
val |= (rg->album_gain < 0) << 9;
|
|
|
|
val |= 1 << 14;
|
|
|
|
AV_WB16(mp3->xing_frame + mp3->xing_offset + 137, val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-17 21:55:04 +00:00
|
|
|
/* write encoder delay/padding */
|
|
|
|
if (mp3->delay >= 1 << 12) {
|
|
|
|
mp3->delay = (1 << 12) - 1;
|
|
|
|
av_log(s, AV_LOG_WARNING, "Too many samples of initial padding.\n");
|
|
|
|
}
|
|
|
|
if (mp3->padding >= 1 << 12) {
|
|
|
|
mp3->padding = (1 << 12) - 1;
|
|
|
|
av_log(s, AV_LOG_WARNING, "Too many samples of trailing padding.\n");
|
|
|
|
}
|
|
|
|
AV_WB24(mp3->xing_frame + mp3->xing_offset + 141, (mp3->delay << 12) + mp3->padding);
|
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
AV_WB32(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 8, mp3->audio_size);
|
|
|
|
AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 4, mp3->audio_crc);
|
|
|
|
|
|
|
|
tag_crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), 0, mp3->xing_frame, 190);
|
|
|
|
AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 2, tag_crc);
|
|
|
|
|
|
|
|
avio_seek(s->pb, mp3->xing_frame_offset, SEEK_SET);
|
|
|
|
avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size);
|
2012-09-16 12:31:58 +00:00
|
|
|
avio_seek(s->pb, 0, SEEK_END);
|
|
|
|
}
|
|
|
|
|
2012-09-16 12:37:50 +00:00
|
|
|
static int mp3_write_trailer(struct AVFormatContext *s)
|
2009-10-19 23:22:23 +00:00
|
|
|
{
|
|
|
|
uint8_t buf[ID3v1_TAG_SIZE];
|
2011-03-21 20:02:50 +00:00
|
|
|
MP3Context *mp3 = s->priv_data;
|
2009-10-19 23:22:23 +00:00
|
|
|
|
2012-09-10 12:44:32 +00:00
|
|
|
if (mp3->pics_to_write) {
|
2012-02-28 08:52:05 +00:00
|
|
|
av_log(s, AV_LOG_WARNING, "No packets were sent for some of the "
|
|
|
|
"attached pictures.\n");
|
|
|
|
mp3_queue_flush(s);
|
|
|
|
}
|
|
|
|
|
2009-10-19 23:22:23 +00:00
|
|
|
/* write the id3v1 tag */
|
2012-09-10 12:44:32 +00:00
|
|
|
if (mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) {
|
2011-02-21 18:28:17 +00:00
|
|
|
avio_write(s->pb, buf, ID3v1_TAG_SIZE);
|
2009-10-19 23:22:23 +00:00
|
|
|
}
|
2011-03-21 20:02:50 +00:00
|
|
|
|
2012-09-16 12:37:50 +00:00
|
|
|
if (mp3->xing_offset)
|
|
|
|
mp3_update_xing(s);
|
2011-03-21 20:02:50 +00:00
|
|
|
|
2014-04-12 13:20:57 +00:00
|
|
|
av_freep(&mp3->xing_frame);
|
|
|
|
|
2009-10-19 23:22:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-10 23:25:19 +00:00
|
|
|
static int query_codec(enum AVCodecID id, int std_compliance)
|
2012-08-04 17:00:44 +00:00
|
|
|
{
|
2012-08-30 15:56:38 +00:00
|
|
|
const CodecMime *cm= ff_id3v2_mime_tags;
|
2012-08-10 23:25:19 +00:00
|
|
|
while(cm->id != AV_CODEC_ID_NONE) {
|
2012-08-04 17:00:44 +00:00
|
|
|
if(id == cm->id)
|
|
|
|
return MKTAG('A', 'P', 'I', 'C');
|
|
|
|
cm++;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-01-21 19:54:35 +00:00
|
|
|
static const AVOption options[] = {
|
|
|
|
{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
|
2014-01-14 21:06:03 +00:00
|
|
|
offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 0, 4, AV_OPT_FLAG_ENCODING_PARAM},
|
2011-08-16 09:43:23 +00:00
|
|
|
{ "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.",
|
2015-11-21 21:05:07 +00:00
|
|
|
offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
|
2014-01-14 20:47:45 +00:00
|
|
|
{ "write_xing", "Write the Xing header containing file duration.",
|
2015-11-21 21:05:07 +00:00
|
|
|
offsetof(MP3Context, write_xing), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
|
2011-01-21 19:54:35 +00:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const AVClass mp3_muxer_class = {
|
2011-04-29 09:30:02 +00:00
|
|
|
.class_name = "MP3 muxer",
|
|
|
|
.item_name = av_default_item_name,
|
|
|
|
.option = options,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
2011-01-21 19:54:35 +00:00
|
|
|
};
|
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
MP3Context *mp3 = s->priv_data;
|
|
|
|
|
|
|
|
if (pkt->stream_index == mp3->audio_stream_idx) {
|
|
|
|
if (mp3->pics_to_write) {
|
|
|
|
/* buffer audio packets until we get all the pictures */
|
2018-03-26 18:02:39 +00:00
|
|
|
int ret = ff_packet_list_put(&mp3->queue, &mp3->queue_end, pkt, FF_PACKETLIST_FLAG_REF_PACKET);
|
2017-10-06 18:55:09 +00:00
|
|
|
|
2018-03-26 18:02:39 +00:00
|
|
|
if (ret < 0) {
|
2014-08-27 00:31:14 +00:00
|
|
|
av_log(s, AV_LOG_WARNING, "Not enough memory to buffer audio. Skipping picture streams\n");
|
|
|
|
mp3->pics_to_write = 0;
|
|
|
|
mp3_queue_flush(s);
|
|
|
|
return mp3_write_audio_packet(s, pkt);
|
|
|
|
}
|
2012-02-28 08:52:05 +00:00
|
|
|
} else
|
2012-09-10 12:44:32 +00:00
|
|
|
return mp3_write_audio_packet(s, pkt);
|
2012-02-28 08:52:05 +00:00
|
|
|
} else {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* warn only once for each stream */
|
|
|
|
if (s->streams[pkt->stream_index]->nb_frames == 1) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
|
|
|
|
" ignoring.\n", pkt->stream_index);
|
|
|
|
}
|
|
|
|
if (!mp3->pics_to_write || s->streams[pkt->stream_index]->nb_frames >= 1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0)
|
|
|
|
return ret;
|
|
|
|
mp3->pics_to_write--;
|
|
|
|
|
|
|
|
/* flush the buffered audio packets */
|
|
|
|
if (!mp3->pics_to_write &&
|
|
|
|
(ret = mp3_queue_flush(s)) < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-03-21 20:02:50 +00:00
|
|
|
|
2007-05-22 08:28:32 +00:00
|
|
|
/**
|
2011-01-21 19:54:35 +00:00
|
|
|
* Write an ID3v2 header at beginning of stream
|
2007-05-22 08:28:32 +00:00
|
|
|
*/
|
|
|
|
|
2003-09-08 22:34:28 +00:00
|
|
|
static int mp3_write_header(struct AVFormatContext *s)
|
|
|
|
{
|
2011-01-21 19:54:35 +00:00
|
|
|
MP3Context *mp3 = s->priv_data;
|
2012-02-28 08:52:05 +00:00
|
|
|
int ret, i;
|
2009-10-05 16:06:00 +00:00
|
|
|
|
2014-01-14 21:06:03 +00:00
|
|
|
if (mp3->id3v2_version &&
|
|
|
|
mp3->id3v2_version != 3 &&
|
|
|
|
mp3->id3v2_version != 4) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid ID3v2 version requested: %d. Only "
|
|
|
|
"3, 4 or 0 (disabled) are allowed.\n", mp3->id3v2_version);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
/* check the streams -- we want exactly one audio and arbitrary number of
|
|
|
|
* video (attached pictures) */
|
|
|
|
mp3->audio_stream_idx = -1;
|
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
AVStream *st = s->streams[i];
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
|
|
|
|
if (mp3->audio_stream_idx >= 0 || st->codecpar->codec_id != AV_CODEC_ID_MP3) {
|
2012-02-28 08:52:05 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 "
|
|
|
|
"audio stream is required.\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
mp3->audio_stream_idx = i;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
} else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
|
2012-02-28 08:52:05 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Only audio streams and pictures are allowed in MP3.\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mp3->audio_stream_idx < 0) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
mp3->pics_to_write = s->nb_streams - 1;
|
|
|
|
|
2014-01-14 21:06:03 +00:00
|
|
|
if (mp3->pics_to_write && !mp3->id3v2_version) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Attached pictures were requested, but the "
|
|
|
|
"ID3v2 header is disabled.\n");
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mp3->id3v2_version) {
|
|
|
|
ff_id3v2_start(&mp3->id3, s->pb, mp3->id3v2_version, ID3v2_DEFAULT_MAGIC);
|
|
|
|
ret = ff_id3v2_write_metadata(s, &mp3->id3);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2007-05-22 08:28:32 +00:00
|
|
|
|
2012-02-28 08:52:05 +00:00
|
|
|
if (!mp3->pics_to_write) {
|
2014-01-14 21:06:03 +00:00
|
|
|
if (mp3->id3v2_version)
|
2013-12-30 17:13:08 +00:00
|
|
|
ff_id3v2_finish(&mp3->id3, s->pb, s->metadata_header_padding);
|
2011-03-21 20:02:50 +00:00
|
|
|
mp3_write_xing(s);
|
2012-02-28 08:52:05 +00:00
|
|
|
}
|
2011-03-21 20:02:50 +00:00
|
|
|
|
2003-09-08 22:34:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVOutputFormat ff_mp3_muxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "mp3",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
|
2014-05-21 13:27:09 +00:00
|
|
|
.mime_type = "audio/mpeg",
|
2011-07-16 20:18:12 +00:00
|
|
|
.extensions = "mp3",
|
|
|
|
.priv_data_size = sizeof(MP3Context),
|
2012-08-05 09:11:04 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_MP3,
|
|
|
|
.video_codec = AV_CODEC_ID_PNG,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = mp3_write_header,
|
2011-07-17 17:52:05 +00:00
|
|
|
.write_packet = mp3_write_packet,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_trailer = mp3_write_trailer,
|
2012-08-04 17:00:44 +00:00
|
|
|
.query_codec = query_codec,
|
2011-07-16 20:18:12 +00:00
|
|
|
.flags = AVFMT_NOTIMESTAMPS,
|
2012-04-06 14:50:48 +00:00
|
|
|
.priv_class = &mp3_muxer_class,
|
2003-09-08 22:34:28 +00:00
|
|
|
};
|