2005-12-17 20:14:38 +02:00
|
|
|
/*
|
2011-01-21 15:53:46 +02:00
|
|
|
* MP3 demuxer
|
2009-01-19 17:46:40 +02:00
|
|
|
* Copyright (c) 2003 Fabrice Bellard
|
2003-09-09 01:34:28 +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-09-09 01:34:28 +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-09-09 01:34:28 +03:00
|
|
|
*
|
2006-10-07 18:30:46 +03:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2003-09-09 01:34:28 +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-09-09 01:34:28 +03:00
|
|
|
*/
|
2008-05-09 14:56:36 +03:00
|
|
|
|
2013-07-06 06:34:36 +03:00
|
|
|
#include "libavutil/opt.h"
|
2008-05-09 14:56:36 +03:00
|
|
|
#include "libavutil/avstring.h"
|
2009-10-20 01:36:57 +03:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2014-04-13 15:23:57 +03:00
|
|
|
#include "libavutil/crc.h"
|
2011-05-22 13:46:29 +03:00
|
|
|
#include "libavutil/dict.h"
|
2011-06-04 14:58:23 +03:00
|
|
|
#include "libavutil/mathematics.h"
|
2003-09-09 01:34:28 +03:00
|
|
|
#include "avformat.h"
|
2011-11-29 21:28:15 +03:00
|
|
|
#include "internal.h"
|
2014-04-13 15:23:57 +03:00
|
|
|
#include "avio_internal.h"
|
2009-01-15 14:23:03 +02:00
|
|
|
#include "id3v2.h"
|
2009-06-11 18:26:57 +03:00
|
|
|
#include "id3v1.h"
|
2014-02-19 23:02:12 +03:00
|
|
|
#include "replaygain.h"
|
|
|
|
|
2015-03-10 01:02:00 +02:00
|
|
|
#include "libavcodec/avcodec.h"
|
2009-09-22 15:39:19 +03:00
|
|
|
#include "libavcodec/mpegaudiodecheader.h"
|
|
|
|
|
2012-09-02 01:30:41 +03:00
|
|
|
#define XING_FLAG_FRAMES 0x01
|
|
|
|
#define XING_FLAG_SIZE 0x02
|
2012-09-02 16:36:18 +03:00
|
|
|
#define XING_FLAG_TOC 0x04
|
2014-10-18 17:25:16 +03:00
|
|
|
#define XING_FLAC_QSCALE 0x08
|
2012-09-02 16:36:18 +03:00
|
|
|
|
|
|
|
#define XING_TOC_COUNT 100
|
2012-09-02 01:30:41 +03:00
|
|
|
|
2015-10-20 12:17:21 +02:00
|
|
|
|
2012-05-08 04:47:58 +03:00
|
|
|
typedef struct {
|
2013-07-06 06:34:36 +03:00
|
|
|
AVClass *class;
|
2012-05-08 04:47:58 +03:00
|
|
|
int64_t filesize;
|
2012-09-20 23:00:52 +03:00
|
|
|
int xing_toc;
|
2012-07-04 23:01:46 +03:00
|
|
|
int start_pad;
|
|
|
|
int end_pad;
|
2013-07-06 06:34:36 +03:00
|
|
|
int usetoc;
|
2014-04-12 19:25:41 +03:00
|
|
|
unsigned frames; /* Total number of frames in file */
|
2014-04-17 23:07:45 +03:00
|
|
|
unsigned header_filesize; /* Total number of bytes in the stream */
|
2013-07-07 14:15:32 +03:00
|
|
|
int is_cbr;
|
2012-09-20 23:00:52 +03:00
|
|
|
} MP3DecContext;
|
2012-05-08 04:47:58 +03:00
|
|
|
|
2016-02-26 19:10:08 +02:00
|
|
|
enum CheckRet {
|
|
|
|
CHECK_WRONG_HEADER = -1,
|
|
|
|
CHECK_SEEK_FAILED = -2,
|
|
|
|
};
|
|
|
|
|
2015-10-20 12:17:21 +02:00
|
|
|
static int check(AVIOContext *pb, int64_t pos, uint32_t *header);
|
2015-05-27 14:48:10 +02:00
|
|
|
|
2003-09-09 01:34:28 +03:00
|
|
|
/* mp3 read */
|
2006-06-06 01:41:14 +03:00
|
|
|
|
2019-03-21 02:18:37 +02:00
|
|
|
static int mp3_read_probe(const AVProbeData *p)
|
2006-06-06 01:41:14 +03:00
|
|
|
{
|
2007-07-08 16:42:46 +03:00
|
|
|
int max_frames, first_frames = 0;
|
2016-06-11 02:41:45 +02:00
|
|
|
int whole_used = 0;
|
2016-01-01 22:03:33 +02:00
|
|
|
int frames, ret;
|
2018-05-12 18:33:27 +02:00
|
|
|
int framesizes, max_framesizes;
|
2006-09-10 23:31:58 +03:00
|
|
|
uint32_t header;
|
2019-11-07 18:16:22 +02:00
|
|
|
const uint8_t *buf, *buf0, *buf2, *buf3, *end;
|
2015-02-26 21:11:19 +02:00
|
|
|
|
2009-01-19 23:54:06 +02:00
|
|
|
buf0 = p->buf;
|
2010-02-28 18:40:17 +02:00
|
|
|
end = p->buf + p->buf_size - sizeof(uint32_t);
|
2019-11-11 03:05:01 +02:00
|
|
|
while (buf0 < end && !*buf0)
|
2010-02-28 18:40:17 +02:00
|
|
|
buf0++;
|
2006-06-06 01:41:14 +03:00
|
|
|
|
2006-09-10 23:31:58 +03:00
|
|
|
max_frames = 0;
|
2018-05-12 18:33:27 +02:00
|
|
|
max_framesizes = 0;
|
2009-01-19 23:54:06 +02:00
|
|
|
buf = buf0;
|
2006-06-06 01:41:14 +03:00
|
|
|
|
2019-11-11 03:05:01 +02:00
|
|
|
for (; buf < end; buf = buf2+1) {
|
2006-09-10 23:31:58 +03:00
|
|
|
buf2 = buf;
|
2019-11-11 03:05:01 +02:00
|
|
|
for (framesizes = frames = 0; buf2 < end; frames++) {
|
2015-01-02 10:49:20 +02:00
|
|
|
MPADecodeHeader h;
|
2019-11-07 18:16:22 +02:00
|
|
|
int header_emu = 0;
|
2020-02-26 19:38:33 +02:00
|
|
|
int available;
|
2015-01-02 10:49:20 +02:00
|
|
|
|
2007-07-06 12:32:34 +03:00
|
|
|
header = AV_RB32(buf2);
|
2015-01-02 10:49:20 +02:00
|
|
|
ret = avpriv_mpegaudio_decode_header(&h, header);
|
2020-02-26 19:38:33 +02:00
|
|
|
if (ret != 0)
|
2006-09-10 23:31:58 +03:00
|
|
|
break;
|
2019-11-07 18:16:22 +02:00
|
|
|
|
2020-02-26 19:38:33 +02:00
|
|
|
available = FFMIN(h.frame_size, end - buf2);
|
|
|
|
for (buf3 = buf2 + 4; buf3 < buf2 + available; buf3++) {
|
2019-11-07 18:16:22 +02:00
|
|
|
uint32_t next_sync = AV_RB32(buf3);
|
|
|
|
header_emu += (next_sync & MP3_MASK) == (header & MP3_MASK);
|
|
|
|
}
|
|
|
|
if (header_emu > 2)
|
|
|
|
break;
|
2018-05-12 18:33:27 +02:00
|
|
|
framesizes += h.frame_size;
|
2020-02-26 19:38:33 +02:00
|
|
|
if (available < h.frame_size) {
|
|
|
|
frames++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
buf2 += h.frame_size;
|
2006-09-10 23:31:58 +03:00
|
|
|
}
|
|
|
|
max_frames = FFMAX(max_frames, frames);
|
2018-05-12 18:33:27 +02:00
|
|
|
max_framesizes = FFMAX(max_framesizes, framesizes);
|
2019-11-11 03:05:01 +02:00
|
|
|
if (buf == buf0) {
|
2006-09-21 00:23:32 +03:00
|
|
|
first_frames= frames;
|
2016-06-11 02:41:45 +02:00
|
|
|
if (buf2 == end + sizeof(uint32_t))
|
|
|
|
whole_used = 1;
|
|
|
|
}
|
2006-09-10 23:31:58 +03:00
|
|
|
}
|
2009-09-29 13:23:47 +03:00
|
|
|
// keep this in sync with ac3 probe, both need to avoid
|
|
|
|
// issues with MPEG-files!
|
2015-07-18 04:09:48 +02:00
|
|
|
if (first_frames>=7) return AVPROBE_SCORE_EXTENSION + 1;
|
2019-11-11 03:05:01 +02:00
|
|
|
else if (max_frames>200 && p->buf_size < 2*max_framesizes)return AVPROBE_SCORE_EXTENSION;
|
|
|
|
else if (max_frames>=4 && p->buf_size < 2*max_framesizes) return AVPROBE_SCORE_EXTENSION / 2;
|
|
|
|
else if (ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)
|
2013-08-26 01:57:35 +03:00
|
|
|
return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;
|
2019-11-11 03:05:01 +02:00
|
|
|
else if (first_frames > 1 && whole_used) return 5;
|
|
|
|
else if (max_frames>=1 && p->buf_size < 10*max_framesizes) return 1;
|
2006-09-10 23:31:58 +03:00
|
|
|
else return 0;
|
2019-11-11 03:05:01 +02:00
|
|
|
//mpegps_mp3_unrecognized_format.mpg has max_frames=3
|
2006-06-06 01:41:14 +03:00
|
|
|
}
|
|
|
|
|
2015-04-14 21:24:35 +02:00
|
|
|
static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
|
2012-09-02 16:36:18 +03:00
|
|
|
{
|
|
|
|
int i;
|
2012-09-20 23:00:52 +03:00
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2015-12-01 20:54:38 +02:00
|
|
|
int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;
|
|
|
|
int fill_index = (mp3->usetoc || fast_seek) && duration > 0;
|
2012-09-02 16:36:18 +03:00
|
|
|
|
|
|
|
if (!filesize &&
|
|
|
|
!(filesize = avio_size(s->pb))) {
|
|
|
|
av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
|
2013-07-07 13:50:41 +03:00
|
|
|
fill_index = 0;
|
2012-09-02 16:36:18 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < XING_TOC_COUNT; i++) {
|
|
|
|
uint8_t b = avio_r8(s->pb);
|
2013-07-07 13:50:41 +03:00
|
|
|
if (fill_index)
|
2013-07-07 13:37:07 +03:00
|
|
|
av_add_index_entry(s->streams[0],
|
2015-04-14 21:24:35 +02:00
|
|
|
av_rescale(b, filesize, 256),
|
2012-09-02 16:36:18 +03:00
|
|
|
av_rescale(i, duration, XING_TOC_COUNT),
|
|
|
|
0, 0, AVINDEX_KEYFRAME);
|
|
|
|
}
|
2013-07-07 13:50:41 +03:00
|
|
|
if (fill_index)
|
|
|
|
mp3->xing_toc = 1;
|
2012-09-02 16:36:18 +03:00
|
|
|
}
|
|
|
|
|
2015-04-14 21:24:35 +02:00
|
|
|
static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
|
2014-04-12 19:25:41 +03:00
|
|
|
MPADecodeHeader *c, uint32_t spf)
|
2007-10-23 16:35:20 +03:00
|
|
|
{
|
2014-04-13 15:23:57 +03:00
|
|
|
#define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
|
2017-10-03 15:50:37 +02:00
|
|
|
#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m) + 1))
|
2014-04-13 15:23:57 +03:00
|
|
|
|
|
|
|
uint16_t crc;
|
2014-04-12 19:25:41 +03:00
|
|
|
uint32_t v;
|
2014-04-13 15:23:57 +03:00
|
|
|
|
|
|
|
char version[10];
|
|
|
|
|
|
|
|
uint32_t peak = 0;
|
|
|
|
int32_t r_gain = INT32_MIN, a_gain = INT32_MIN;
|
|
|
|
|
2013-04-19 22:30:39 +03:00
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2013-08-05 03:52:41 +03:00
|
|
|
static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
|
2014-07-24 16:34:36 +03:00
|
|
|
uint64_t fsize = avio_size(s->pb);
|
2015-04-24 12:26:39 +02:00
|
|
|
fsize = fsize >= avio_tell(s->pb) ? fsize - avio_tell(s->pb) : 0;
|
2012-09-02 16:36:18 +03:00
|
|
|
|
2007-10-23 20:10:41 +03:00
|
|
|
/* Check for Xing / Info tag */
|
2014-04-12 19:25:41 +03:00
|
|
|
avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);
|
2011-02-21 17:43:01 +02:00
|
|
|
v = avio_rb32(s->pb);
|
2014-04-12 19:25:41 +03:00
|
|
|
mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
|
2014-04-13 15:23:57 +03:00
|
|
|
if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)
|
|
|
|
return;
|
|
|
|
|
|
|
|
v = avio_rb32(s->pb);
|
|
|
|
if (v & XING_FLAG_FRAMES)
|
|
|
|
mp3->frames = avio_rb32(s->pb);
|
|
|
|
if (v & XING_FLAG_SIZE)
|
2014-04-18 00:51:45 +03:00
|
|
|
mp3->header_filesize = avio_rb32(s->pb);
|
2014-07-24 16:34:36 +03:00
|
|
|
if (fsize && mp3->header_filesize) {
|
|
|
|
uint64_t min, delta;
|
|
|
|
min = FFMIN(fsize, mp3->header_filesize);
|
|
|
|
delta = FFMAX(fsize, mp3->header_filesize) - min;
|
|
|
|
if (fsize > mp3->header_filesize && delta > min >> 4) {
|
|
|
|
mp3->frames = 0;
|
2015-04-24 12:26:39 +02:00
|
|
|
av_log(s, AV_LOG_WARNING,
|
|
|
|
"invalid concatenated file detected - using bitrate for duration\n");
|
2014-07-24 16:34:36 +03:00
|
|
|
} else if (delta > min >> 4) {
|
|
|
|
av_log(s, AV_LOG_WARNING,
|
|
|
|
"filesize and duration do not match (growing file?)\n");
|
|
|
|
}
|
|
|
|
}
|
2014-04-18 00:51:45 +03:00
|
|
|
if (v & XING_FLAG_TOC)
|
2015-04-14 21:24:35 +02:00
|
|
|
read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,
|
2014-04-12 19:25:41 +03:00
|
|
|
(AVRational){spf, c->sample_rate},
|
|
|
|
st->time_base));
|
2014-04-13 15:23:57 +03:00
|
|
|
/* VBR quality */
|
2014-10-18 17:25:16 +03:00
|
|
|
if (v & XING_FLAC_QSCALE)
|
|
|
|
avio_rb32(s->pb);
|
2012-07-04 23:01:46 +03:00
|
|
|
|
2014-04-13 15:23:57 +03:00
|
|
|
/* Encoder short version string */
|
|
|
|
memset(version, 0, sizeof(version));
|
|
|
|
avio_read(s->pb, version, 9);
|
|
|
|
|
|
|
|
/* Info Tag revision + VBR method */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* Lowpass filter value */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* ReplayGain peak */
|
|
|
|
v = avio_rb32(s->pb);
|
|
|
|
peak = av_rescale(v, 100000, 1 << 23);
|
|
|
|
|
|
|
|
/* Radio ReplayGain */
|
|
|
|
v = avio_rb16(s->pb);
|
|
|
|
|
|
|
|
if (MIDDLE_BITS(v, 13, 15) == 1) {
|
|
|
|
r_gain = MIDDLE_BITS(v, 0, 8) * 10000;
|
|
|
|
|
|
|
|
if (v & (1 << 9))
|
|
|
|
r_gain *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Audiophile ReplayGain */
|
|
|
|
v = avio_rb16(s->pb);
|
|
|
|
|
|
|
|
if (MIDDLE_BITS(v, 13, 15) == 2) {
|
|
|
|
a_gain = MIDDLE_BITS(v, 0, 8) * 10000;
|
|
|
|
|
|
|
|
if (v & (1 << 9))
|
|
|
|
a_gain *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Encoding flags + ATH Type */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* if ABR {specified bitrate} else {minimal bitrate} */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* Encoder delays */
|
2019-11-11 03:05:01 +02:00
|
|
|
v = avio_rb24(s->pb);
|
|
|
|
if (AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')
|
2014-10-24 19:06:26 +03:00
|
|
|
|| AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')
|
|
|
|
|| AV_RB32(version) == MKBETAG('L', 'a', 'v', 'c')
|
|
|
|
) {
|
2014-04-18 00:51:45 +03:00
|
|
|
|
|
|
|
mp3->start_pad = v>>12;
|
|
|
|
mp3-> end_pad = v&4095;
|
2015-04-22 12:24:37 +02:00
|
|
|
st->start_skip_samples = mp3->start_pad + 528 + 1;
|
2014-09-21 13:51:41 +03:00
|
|
|
if (mp3->frames) {
|
|
|
|
st->first_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;
|
|
|
|
st->last_discard_sample = mp3->frames * (int64_t)spf;
|
|
|
|
}
|
2020-06-08 22:08:37 +02:00
|
|
|
if (!st->start_time)
|
|
|
|
st->start_time = av_rescale_q(st->start_skip_samples,
|
|
|
|
(AVRational){1, c->sample_rate},
|
|
|
|
st->time_base);
|
2014-04-18 00:51:45 +03:00
|
|
|
av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3-> end_pad);
|
|
|
|
}
|
2014-04-13 15:23:57 +03:00
|
|
|
|
|
|
|
/* Misc */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* MP3 gain */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
|
|
|
|
/* Preset and surround info */
|
|
|
|
avio_rb16(s->pb);
|
|
|
|
|
|
|
|
/* Music length */
|
|
|
|
avio_rb32(s->pb);
|
|
|
|
|
|
|
|
/* Music CRC */
|
|
|
|
avio_rb16(s->pb);
|
|
|
|
|
|
|
|
/* Info Tag CRC */
|
|
|
|
crc = ffio_get_checksum(s->pb);
|
|
|
|
v = avio_rb16(s->pb);
|
|
|
|
|
|
|
|
if (v == crc) {
|
|
|
|
ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);
|
|
|
|
av_dict_set(&st->metadata, "encoder", version, 0);
|
2007-10-23 16:35:20 +03:00
|
|
|
}
|
2014-04-12 19:25:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)
|
|
|
|
{
|
|
|
|
uint32_t v;
|
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2007-10-23 20:10:41 +03:00
|
|
|
|
2007-10-24 07:56:22 +03:00
|
|
|
/* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(s->pb, base + 4 + 32, SEEK_SET);
|
2011-02-21 17:43:01 +02:00
|
|
|
v = avio_rb32(s->pb);
|
2014-04-12 19:25:41 +03:00
|
|
|
if (v == MKBETAG('V', 'B', 'R', 'I')) {
|
2007-10-24 07:56:22 +03:00
|
|
|
/* Check tag version */
|
2014-04-12 19:25:41 +03:00
|
|
|
if (avio_rb16(s->pb) == 1) {
|
2010-07-27 13:08:34 +03:00
|
|
|
/* skip delay and quality */
|
2011-03-15 10:14:38 +02:00
|
|
|
avio_skip(s->pb, 4);
|
2014-04-17 23:07:45 +03:00
|
|
|
mp3->header_filesize = avio_rb32(s->pb);
|
2014-04-12 19:25:41 +03:00
|
|
|
mp3->frames = avio_rb32(s->pb);
|
2007-10-24 07:56:22 +03:00
|
|
|
}
|
|
|
|
}
|
2014-04-12 19:25:41 +03:00
|
|
|
}
|
2007-10-24 07:56:22 +03:00
|
|
|
|
2007-10-23 16:35:20 +03:00
|
|
|
/**
|
2007-10-24 07:56:22 +03:00
|
|
|
* Try to find Xing/Info/VBRI tags and compute duration from info therein
|
2007-10-23 16:35:20 +03:00
|
|
|
*/
|
2009-01-04 18:23:18 +02:00
|
|
|
static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
|
2007-10-23 16:35:20 +03:00
|
|
|
{
|
2007-10-23 20:10:41 +03:00
|
|
|
uint32_t v, spf;
|
2009-01-23 14:09:32 +02:00
|
|
|
MPADecodeHeader c;
|
2009-01-04 18:23:18 +02:00
|
|
|
int vbrtag_size = 0;
|
2014-04-12 19:25:41 +03:00
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2015-10-09 15:16:46 +02:00
|
|
|
int ret;
|
2007-10-23 16:35:20 +03:00
|
|
|
|
2014-04-13 15:23:57 +03:00
|
|
|
ffio_init_checksum(s->pb, ff_crcA001_update, 0);
|
|
|
|
|
2011-02-21 17:43:01 +02:00
|
|
|
v = avio_rb32(s->pb);
|
2007-11-04 21:52:08 +02:00
|
|
|
|
2015-10-09 15:16:46 +02:00
|
|
|
ret = avpriv_mpegaudio_decode_header(&c, v);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
else if (ret == 0)
|
2009-01-04 18:23:18 +02:00
|
|
|
vbrtag_size = c.frame_size;
|
2019-11-11 03:05:01 +02:00
|
|
|
if (c.layer != 3)
|
2009-01-04 18:23:18 +02:00
|
|
|
return -1;
|
2007-10-23 16:35:20 +03:00
|
|
|
|
2012-09-02 16:36:18 +03:00
|
|
|
spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
|
|
|
|
|
2014-04-12 19:25:41 +03:00
|
|
|
mp3->frames = 0;
|
2014-04-17 23:07:45 +03:00
|
|
|
mp3->header_filesize = 0;
|
2007-10-23 20:10:41 +03:00
|
|
|
|
2015-04-14 21:24:35 +02:00
|
|
|
mp3_parse_info_tag(s, st, &c, spf);
|
2014-04-12 19:25:41 +03:00
|
|
|
mp3_parse_vbri_tag(s, st, base);
|
2007-10-24 07:56:22 +03:00
|
|
|
|
2014-04-17 23:07:45 +03:00
|
|
|
if (!mp3->frames && !mp3->header_filesize)
|
2009-01-04 18:23:18 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Skip the vbr tag frame */
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
|
2007-10-23 20:10:41 +03:00
|
|
|
|
2014-04-12 19:25:41 +03:00
|
|
|
if (mp3->frames)
|
|
|
|
st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},
|
2010-07-27 13:08:34 +03:00
|
|
|
st->time_base);
|
2014-04-17 23:07:45 +03:00
|
|
|
if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)
|
2016-04-10 21:58:15 +02:00
|
|
|
st->codecpar->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);
|
2013-07-07 14:15:32 +03:00
|
|
|
|
2009-01-04 18:23:18 +02:00
|
|
|
return 0;
|
2007-10-23 16:35:20 +03:00
|
|
|
}
|
|
|
|
|
2012-01-12 15:20:36 +03:00
|
|
|
static int mp3_read_header(AVFormatContext *s)
|
2003-09-09 01:34:28 +03:00
|
|
|
{
|
2013-04-19 22:30:39 +03:00
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2003-09-09 01:34:28 +03:00
|
|
|
AVStream *st;
|
2008-10-03 13:16:29 +03:00
|
|
|
int64_t off;
|
2014-02-19 23:02:12 +03:00
|
|
|
int ret;
|
2015-04-14 21:24:36 +02:00
|
|
|
int i;
|
2003-09-09 01:34:28 +03:00
|
|
|
|
2017-01-28 18:25:27 +02:00
|
|
|
s->metadata = s->internal->id3v2_meta;
|
|
|
|
s->internal->id3v2_meta = NULL;
|
|
|
|
|
2011-06-18 12:43:24 +03:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2003-09-09 01:34:28 +03:00
|
|
|
if (!st)
|
2007-07-19 18:21:30 +03:00
|
|
|
return AVERROR(ENOMEM);
|
2003-09-09 01:34:28 +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
|
|
|
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
st->codecpar->codec_id = AV_CODEC_ID_MP3;
|
2012-07-24 18:40:25 +03:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
|
2007-10-18 18:02:34 +03:00
|
|
|
st->start_time = 0;
|
2005-12-17 20:14:38 +02:00
|
|
|
|
2009-11-22 23:04:18 +02:00
|
|
|
// lcm of all mp3 sample rates
|
2011-11-29 21:28:15 +03:00
|
|
|
avpriv_set_pts_info(st, 64, 1, 14112000);
|
2009-11-22 23:04:18 +02:00
|
|
|
|
2012-01-22 00:53:57 +03:00
|
|
|
s->pb->maxsize = -1;
|
2011-03-03 21:11:45 +02:00
|
|
|
off = avio_tell(s->pb);
|
2010-02-10 14:44:16 +02:00
|
|
|
|
2011-05-22 13:46:29 +03:00
|
|
|
if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
|
2009-10-06 00:36:56 +03:00
|
|
|
ff_id3v1_read(s);
|
2003-09-09 01:34:28 +03:00
|
|
|
|
2019-11-11 03:05:01 +02:00
|
|
|
if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
|
2012-05-08 04:47:58 +03:00
|
|
|
mp3->filesize = avio_size(s->pb);
|
|
|
|
|
2009-01-04 18:23:18 +02:00
|
|
|
if (mp3_parse_vbr_tags(s, st, off) < 0)
|
2011-02-28 15:57:54 +02:00
|
|
|
avio_seek(s->pb, off, SEEK_SET);
|
2007-10-23 16:35:20 +03:00
|
|
|
|
2014-02-19 23:02:12 +03:00
|
|
|
ret = ff_replaygain_export(st, s->metadata);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-05-27 14:48:10 +02:00
|
|
|
off = avio_tell(s->pb);
|
|
|
|
for (i = 0; i < 64 * 1024; i++) {
|
2015-10-20 12:17:21 +02:00
|
|
|
uint32_t header, header2;
|
|
|
|
int frame_size;
|
2015-05-27 16:18:31 +02:00
|
|
|
if (!(i&1023))
|
|
|
|
ffio_ensure_seekback(s->pb, i + 1024 + 4);
|
2015-10-20 12:17:21 +02:00
|
|
|
frame_size = check(s->pb, off + i, &header);
|
|
|
|
if (frame_size > 0) {
|
2016-02-26 19:10:08 +02:00
|
|
|
ret = avio_seek(s->pb, off, SEEK_SET);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2015-10-20 12:17:21 +02:00
|
|
|
ffio_ensure_seekback(s->pb, i + 1024 + frame_size + 4);
|
2016-02-26 19:10:08 +02:00
|
|
|
ret = check(s->pb, off + i + frame_size, &header2);
|
|
|
|
if (ret >= 0 &&
|
2019-11-11 03:05:02 +02:00
|
|
|
(header & MP3_MASK) == (header2 & MP3_MASK))
|
2015-10-20 12:17:21 +02:00
|
|
|
{
|
2016-03-08 17:54:42 +02:00
|
|
|
av_log(s, i > 0 ? AV_LOG_INFO : AV_LOG_VERBOSE, "Skipping %d bytes of junk at %"PRId64".\n", i, off);
|
2016-02-26 19:10:08 +02:00
|
|
|
ret = avio_seek(s->pb, off + i, SEEK_SET);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2015-10-20 12:17:21 +02:00
|
|
|
break;
|
2016-02-26 19:10:08 +02:00
|
|
|
} else if (ret == CHECK_SEEK_FAILED) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Invalid frame size (%d): Could not seek to %"PRId64".\n", frame_size, off + i + frame_size);
|
|
|
|
return AVERROR(EINVAL);
|
2015-10-20 12:17:21 +02:00
|
|
|
}
|
2016-02-26 19:10:08 +02:00
|
|
|
} else if (frame_size == CHECK_SEEK_FAILED) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Failed to read frame size: Could not seek to %"PRId64".\n", (int64_t) (i + 1024 + frame_size + 4));
|
|
|
|
return AVERROR(EINVAL);
|
2015-05-27 14:48:10 +02:00
|
|
|
}
|
2016-02-26 19:10:08 +02:00
|
|
|
ret = avio_seek(s->pb, off, SEEK_SET);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2015-05-27 14:48:10 +02:00
|
|
|
}
|
|
|
|
|
2015-04-14 21:24:36 +02:00
|
|
|
// the seek index is relative to the end of the xing vbr headers
|
|
|
|
for (i = 0; i < st->nb_index_entries; i++)
|
|
|
|
st->index_entries[i].pos += avio_tell(s->pb);
|
|
|
|
|
2003-09-09 01:34:28 +03:00
|
|
|
/* the parameters will be extracted from the compressed bitstream */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MP3_PACKET_SIZE 1024
|
|
|
|
|
|
|
|
static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
2013-04-19 22:30:39 +03:00
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
2003-09-09 01:34:28 +03:00
|
|
|
int ret, size;
|
2012-05-08 04:47:58 +03:00
|
|
|
int64_t pos;
|
2005-12-17 20:14:38 +02:00
|
|
|
|
2019-11-11 03:05:01 +02:00
|
|
|
size = MP3_PACKET_SIZE;
|
2012-05-08 04:47:58 +03:00
|
|
|
pos = avio_tell(s->pb);
|
2019-11-11 03:05:01 +02:00
|
|
|
if (mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
|
2012-05-08 04:47:58 +03:00
|
|
|
size= FFMIN(size, mp3->filesize - pos);
|
2003-09-09 01:34:28 +03:00
|
|
|
|
2019-11-11 03:05:01 +02:00
|
|
|
ret = av_get_packet(s->pb, pkt, size);
|
2003-09-09 01:34:28 +03:00
|
|
|
if (ret <= 0) {
|
2011-09-21 01:51:53 +03:00
|
|
|
if(ret<0)
|
|
|
|
return ret;
|
|
|
|
return AVERROR_EOF;
|
2003-09-09 01:34:28 +03:00
|
|
|
}
|
2011-01-22 00:55:31 +02:00
|
|
|
|
2012-07-29 02:56:31 +03:00
|
|
|
pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
|
2003-09-09 01:34:28 +03:00
|
|
|
pkt->stream_index = 0;
|
2011-01-22 00:55:31 +02:00
|
|
|
|
2003-09-09 01:34:28 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-12 15:55:17 +02:00
|
|
|
#define SEEK_WINDOW 4096
|
2015-07-11 17:38:26 +02:00
|
|
|
|
2015-10-20 12:17:21 +02:00
|
|
|
static int check(AVIOContext *pb, int64_t pos, uint32_t *ret_header)
|
2012-10-21 03:42:16 +03:00
|
|
|
{
|
2015-07-12 15:55:17 +02:00
|
|
|
int64_t ret = avio_seek(pb, pos, SEEK_SET);
|
2016-02-26 19:10:08 +02:00
|
|
|
uint8_t header_buf[4];
|
2012-10-21 03:42:16 +03:00
|
|
|
unsigned header;
|
|
|
|
MPADecodeHeader sd;
|
|
|
|
if (ret < 0)
|
2016-02-26 19:10:08 +02:00
|
|
|
return CHECK_SEEK_FAILED;
|
|
|
|
|
|
|
|
ret = avio_read(pb, &header_buf[0], 4);
|
2016-11-22 23:54:50 +02:00
|
|
|
/* We should always find four bytes for a valid mpa header. */
|
|
|
|
if (ret < 4)
|
2016-02-26 19:10:08 +02:00
|
|
|
return CHECK_SEEK_FAILED;
|
2015-07-11 17:38:26 +02:00
|
|
|
|
2016-02-26 19:10:08 +02:00
|
|
|
header = AV_RB32(&header_buf[0]);
|
2012-10-21 03:42:16 +03:00
|
|
|
if (ff_mpa_check_header(header) < 0)
|
2016-02-26 19:10:08 +02:00
|
|
|
return CHECK_WRONG_HEADER;
|
2012-10-21 03:42:16 +03:00
|
|
|
if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
|
2016-02-26 19:10:08 +02:00
|
|
|
return CHECK_WRONG_HEADER;
|
2015-07-11 17:38:26 +02:00
|
|
|
|
2015-10-20 12:17:21 +02:00
|
|
|
if (ret_header)
|
|
|
|
*ret_header = header;
|
2012-10-21 03:42:16 +03:00
|
|
|
return sd.frame_size;
|
|
|
|
}
|
|
|
|
|
2015-07-20 02:41:44 +02:00
|
|
|
static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)
|
2012-07-04 23:01:46 +03:00
|
|
|
{
|
2013-10-25 20:35:55 +03:00
|
|
|
int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
|
2014-09-07 22:44:19 +03:00
|
|
|
int64_t best_pos;
|
2015-07-19 19:31:08 +02:00
|
|
|
int best_score, i, j;
|
|
|
|
int64_t ret;
|
2015-04-22 12:24:38 +02:00
|
|
|
|
2015-07-19 19:31:08 +02:00
|
|
|
avio_seek(s->pb, FFMAX(target_pos - SEEK_WINDOW, 0), SEEK_SET);
|
|
|
|
ret = avio_seek(s->pb, target_pos, SEEK_SET);
|
2012-09-02 16:36:18 +03:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-07-04 23:01:46 +03:00
|
|
|
|
2012-10-21 03:42:16 +03:00
|
|
|
#define MIN_VALID 3
|
2015-07-19 19:31:08 +02:00
|
|
|
best_pos = target_pos;
|
2014-09-07 22:44:19 +03:00
|
|
|
best_score = 999;
|
2019-11-11 03:05:01 +02:00
|
|
|
for (i = 0; i < SEEK_WINDOW; i++) {
|
2015-07-19 19:31:08 +02:00
|
|
|
int64_t pos = target_pos + (dir > 0 ? i - SEEK_WINDOW/4 : -i);
|
2014-09-07 22:44:19 +03:00
|
|
|
int64_t candidate = -1;
|
|
|
|
int score = 999;
|
2014-11-18 05:04:37 +02:00
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
continue;
|
|
|
|
|
2019-11-11 03:05:01 +02:00
|
|
|
for (j = 0; j < MIN_VALID; j++) {
|
2015-10-20 12:17:21 +02:00
|
|
|
ret = check(s->pb, pos, NULL);
|
2019-11-11 03:05:01 +02:00
|
|
|
if (ret < 0) {
|
2016-02-26 19:10:08 +02:00
|
|
|
if (ret == CHECK_WRONG_HEADER) {
|
|
|
|
break;
|
|
|
|
} else if (ret == CHECK_SEEK_FAILED) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Could not seek to %"PRId64".\n", pos);
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
|
|
|
}
|
2017-11-20 04:49:42 +02:00
|
|
|
if ((target_pos - pos)*dir <= 0 && FFABS(MIN_VALID/2-j) < score) {
|
2014-09-07 22:44:19 +03:00
|
|
|
candidate = pos;
|
2017-11-20 04:49:42 +02:00
|
|
|
score = FFABS(MIN_VALID/2-j);
|
2014-09-07 22:44:19 +03:00
|
|
|
}
|
2012-10-21 03:42:16 +03:00
|
|
|
pos += ret;
|
2012-09-02 16:36:18 +03:00
|
|
|
}
|
2014-09-07 22:44:19 +03:00
|
|
|
if (best_score > score && j == MIN_VALID) {
|
|
|
|
best_pos = candidate;
|
|
|
|
best_score = score;
|
|
|
|
if(score == 0)
|
|
|
|
break;
|
|
|
|
}
|
2012-09-02 16:36:18 +03:00
|
|
|
}
|
2012-07-04 23:01:46 +03:00
|
|
|
|
2015-07-19 19:31:08 +02:00
|
|
|
return avio_seek(s->pb, best_pos, SEEK_SET);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
MP3DecContext *mp3 = s->priv_data;
|
|
|
|
AVIndexEntry *ie, ie1;
|
|
|
|
AVStream *st = s->streams[0];
|
|
|
|
int64_t best_pos;
|
2015-12-01 20:54:38 +02:00
|
|
|
int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;
|
2015-09-01 02:08:30 +02:00
|
|
|
int64_t filesize = mp3->header_filesize;
|
2015-07-19 19:31:08 +02:00
|
|
|
|
2015-09-01 02:08:30 +02:00
|
|
|
if (filesize <= 0) {
|
|
|
|
int64_t size = avio_size(s->pb);
|
|
|
|
if (size > 0 && size > s->internal->data_offset)
|
|
|
|
filesize = size - s->internal->data_offset;
|
|
|
|
}
|
|
|
|
|
2015-12-01 20:54:38 +02:00
|
|
|
if (mp3->xing_toc && (mp3->usetoc || (fast_seek && !mp3->is_cbr))) {
|
|
|
|
int64_t ret = av_index_search_timestamp(st, timestamp, flags);
|
|
|
|
|
|
|
|
// NOTE: The MP3 TOC is not a precise lookup table. Accuracy is worse
|
|
|
|
// for bigger files.
|
|
|
|
av_log(s, AV_LOG_WARNING, "Using MP3 TOC to seek; may be imprecise.\n");
|
|
|
|
|
2015-07-19 19:31:08 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ie = &st->index_entries[ret];
|
2015-12-01 20:54:38 +02:00
|
|
|
} else if (fast_seek && st->duration > 0 && filesize > 0) {
|
|
|
|
if (!mp3->is_cbr)
|
|
|
|
av_log(s, AV_LOG_WARNING, "Using scaling to seek VBR MP3; may be imprecise.\n");
|
|
|
|
|
|
|
|
ie = &ie1;
|
|
|
|
timestamp = av_clip64(timestamp, 0, st->duration);
|
|
|
|
ie->timestamp = timestamp;
|
|
|
|
ie->pos = av_rescale(timestamp, filesize, st->duration) + s->internal->data_offset;
|
2015-07-19 19:31:08 +02:00
|
|
|
} else {
|
2015-12-01 20:54:38 +02:00
|
|
|
return -1; // generic index code
|
2015-07-19 19:31:08 +02:00
|
|
|
}
|
|
|
|
|
2015-07-20 02:41:44 +02:00
|
|
|
best_pos = mp3_sync(s, ie->pos, flags);
|
2015-07-19 19:31:08 +02:00
|
|
|
if (best_pos < 0)
|
|
|
|
return best_pos;
|
2015-04-20 20:42:38 +02:00
|
|
|
|
2015-09-01 02:08:30 +02:00
|
|
|
if (mp3->is_cbr && ie == &ie1 && mp3->frames) {
|
2015-04-20 20:42:38 +02:00
|
|
|
int frame_duration = av_rescale(st->duration, 1, mp3->frames);
|
|
|
|
ie1.timestamp = frame_duration * av_rescale(best_pos - s->internal->data_offset, mp3->frames, mp3->header_filesize);
|
|
|
|
}
|
|
|
|
|
2012-10-21 03:42:16 +03:00
|
|
|
ff_update_cur_dts(s, st, ie->timestamp);
|
|
|
|
return 0;
|
2012-07-04 23:01:46 +03:00
|
|
|
}
|
|
|
|
|
2013-07-06 06:34:36 +03:00
|
|
|
static const AVOption options[] = {
|
2015-11-21 23:05:07 +02:00
|
|
|
{ "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM},
|
2013-07-06 06:34:36 +03:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const AVClass demuxer_class = {
|
|
|
|
.class_name = "mp3",
|
|
|
|
.item_name = av_default_item_name,
|
|
|
|
.option = options,
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
|
|
.category = AV_CLASS_CATEGORY_DEMUXER,
|
|
|
|
};
|
|
|
|
|
2011-01-26 00:03:28 +02:00
|
|
|
AVInputFormat ff_mp3_demuxer = {
|
2011-07-16 23:18:12 +03:00
|
|
|
.name = "mp3",
|
2012-07-24 04:23:48 +03:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
|
2011-07-16 23:18:12 +03:00
|
|
|
.read_probe = mp3_read_probe,
|
|
|
|
.read_header = mp3_read_header,
|
|
|
|
.read_packet = mp3_read_packet,
|
2012-09-02 16:36:18 +03:00
|
|
|
.read_seek = mp3_seek,
|
2012-09-20 23:00:52 +03:00
|
|
|
.priv_data_size = sizeof(MP3DecContext),
|
2012-04-06 17:50:48 +03:00
|
|
|
.flags = AVFMT_GENERIC_INDEX,
|
2013-09-09 17:30:35 +03:00
|
|
|
.extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */
|
2013-07-06 06:34:36 +03:00
|
|
|
.priv_class = &demuxer_class,
|
2009-09-22 15:39:19 +03:00
|
|
|
};
|