unsigned long MadDecoder::xingFrames(struct mad_bitptr ptr, unsigned bitlen)
{
#define XING_MAGIC ( ('X' << 24) | ('i' << 16) | ('n' << 8) | 'g' )
if (bitlen >= 96 && mad_bit_read(&ptr, 32) == XING_MAGIC && (mad_bit_read(&ptr, 32) & 1)) // XING_FRAMES
return mad_bit_read(&ptr, 32);
return 0;
}
/*
* NAME: parse_xing()
* DESCRIPTION: parse a Xing VBR tag
*/
static
int parse_xing(struct tag_xing *xing,
struct mad_bitptr *ptr, unsigned int *bitlen)
{
if (*bitlen < 32)
goto fail;
xing->flags = mad_bit_read(ptr, 32);
*bitlen -= 32;
if (xing->flags & TAG_XING_FRAMES) {
if (*bitlen < 32)
goto fail;
xing->frames = mad_bit_read(ptr, 32);
*bitlen -= 32;
}
if (xing->flags & TAG_XING_BYTES) {
if (*bitlen < 32)
goto fail;
xing->bytes = mad_bit_read(ptr, 32);
*bitlen -= 32;
}
if (xing->flags & TAG_XING_TOC) {
int i;
if (*bitlen < 800)
goto fail;
for (i = 0; i < 100; ++i)
xing->toc[i] = mad_bit_read(ptr, 8);
*bitlen -= 800;
}
if (xing->flags & TAG_XING_SCALE) {
if (*bitlen < 32)
goto fail;
xing->scale = mad_bit_read(ptr, 32);
*bitlen -= 32;
}
return 0;
fail:
xing->flags = 0;
return -1;
}
/*
* NAME: decode_header()
* DESCRIPTION: read header data and following CRC word
*/
static
int decode_header(struct mad_header *header, struct mad_stream *stream)
{
unsigned int index;
header->flags = 0;
header->private_bits = 0;
/* header() */
/* syncword */
mad_bit_skip(&stream->ptr, 11);
/* MPEG 2.5 indicator (really part of syncword) */
if (mad_bit_read(&stream->ptr, 1) == 0)
header->flags |= MAD_FLAG_MPEG_2_5_EXT;
/* ID */
if (mad_bit_read(&stream->ptr, 1) == 0)
header->flags |= MAD_FLAG_LSF_EXT;
else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
stream->error = MAD_ERROR_LOSTSYNC;
return -1;
}
/* layer */
header->layer = 4 - mad_bit_read(&stream->ptr, 2);
if (header->layer == 4) {
stream->error = MAD_ERROR_BADLAYER;
return -1;
}
/* protection_bit */
if (mad_bit_read(&stream->ptr, 1) == 0) {
header->flags |= MAD_FLAG_PROTECTION;
header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
}
/* bitrate_index */
index = mad_bit_read(&stream->ptr, 4);
if (index == 15) {
stream->error = MAD_ERROR_BADBITRATE;
return -1;
}
if (header->flags & MAD_FLAG_LSF_EXT)
header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
else
/*
* NAME: I_sample()
* DESCRIPTION: decode one requantized Layer I sample from a bitstream
*/
static
mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb)
{
mad_fixed_t sample;
sample = mad_bit_read(ptr, nb);
/* invert most significant bit, extend sign, then scale to fixed format */
sample ^= 1 << (nb - 1);
sample |= -(sample & (1 << (nb - 1)));
sample <<= MAD_F_FRACBITS - (nb - 1);
/* requantize the sample */
/* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */
sample += MAD_F_ONE >> (nb - 1);
return mad_f_mul(sample, linear_table[nb - 2]);
/* s' = factor * s'' */
/* (to be performed by caller) */
}
/*
* NAME: II_samples()
* DESCRIPTION: decode three requantized Layer II samples from a bitstream
*/
static
void II_samples(struct mad_bitptr *ptr,
struct quantclass const *quantclass,
mad_fixed_t output[3])
{
unsigned int nb, s, sample[3];
if ((nb = quantclass->group)) {
unsigned int c, nlevels;
/* degrouping */
c = mad_bit_read(ptr, quantclass->bits);
nlevels = quantclass->nlevels;
for (s = 0; s < 3; ++s) {
sample[s] = c % nlevels;
c /= nlevels;
}
}
else {
nb = quantclass->bits;
for (s = 0; s < 3; ++s)
sample[s] = mad_bit_read(ptr, nb);
}
for (s = 0; s < 3; ++s) {
mad_fixed_t requantized;
/* invert most significant bit, extend sign, then scale to fixed format */
requantized = sample[s] ^ (1 << (nb - 1));
requantized |= -(requantized & (1 << (nb - 1)));
requantized <<= MAD_F_FRACBITS - (nb - 1);
/* requantize the sample */
/* s'' = C * (s''' + D) */
output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C);
/* s' = factor * s'' */
/* (to be performed by caller) */
}
}
static
void II_samples(struct mad_bitptr *ptr,
struct quantclass const *quantclass,
mad_fixed_t output[3])
{
unsigned int nb, s, sample[3];
if ((nb = quantclass->group)) {
unsigned int c, nlevels;
c = mad_bit_read(ptr, quantclass->bits);
nlevels = quantclass->nlevels;
for (s = 0; s < 3; ++s) {
sample[s] = c % nlevels;
c /= nlevels;
}
}
else {
nb = quantclass->bits;
for (s = 0; s < 3; ++s)
sample[s] = mad_bit_read(ptr, nb);
}
for (s = 0; s < 3; ++s) {
mad_fixed_t requantized;
requantized = sample[s] ^ (1 << (nb - 1));
requantized |= -(requantized & (1 << (nb - 1)));
requantized <<= MAD_F_FRACBITS - (nb - 1);
/* s'' = C * (s''' + D) */
output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C);
/* s' = factor * s'' */
}
}
/*
* NAME: parse_xing()
* DESCRIPTION: read a Xing VBR tag
*/
static
int parse_xing(struct xing *xing, struct mad_bitptr ptr, unsigned int bitlen)
{
if (bitlen < 64 || mad_bit_read(&ptr, 32) != XING_MAGIC)
goto fail;
xing->flags = mad_bit_read(&ptr, 32);
bitlen -= 64;
if (xing->flags & XING_FRAMES)
{
if (bitlen < 32)
goto fail;
xing->frames = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_BYTES)
{
if (bitlen < 32)
goto fail;
xing->bytes = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_TOC)
{
int i;
if (bitlen < 800)
goto fail;
for (i = 0; i < 100; ++i)
xing->toc[i] = (unsigned char) mad_bit_read(&ptr, 8);
bitlen -= 800;
}
if (xing->flags & XING_SCALE)
{
if (bitlen < 32)
goto fail;
xing->scale = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
return 0;
fail:
xing->flags = 0;
return -1;
}
static
mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb)
{
mad_fixed_t sample;
sample = mad_bit_read(ptr, nb);
sample ^= 1 << (nb - 1);
sample |= -(sample & (1 << (nb - 1)));
sample <<= MAD_F_FRACBITS - (nb - 1);
/* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */
sample += MAD_F_ONE >> (nb - 1);
return mad_f_mul(sample, linear_table[nb - 2]);
/* s' = factor * s'' */
}
static bool
parse_lame(struct lame *lame, struct mad_bitptr *ptr, int *bitlen)
{
int adj = 0;
int name;
int orig;
int sign;
int gain;
int i;
/* Unlike the xing header, the lame tag has a fixed length. Fail if
* not all 36 bytes (288 bits) are there. */
if (*bitlen < 288)
return false;
for (i = 0; i < 9; i++)
lame->encoder[i] = (char)mad_bit_read(ptr, 8);
lame->encoder[9] = '\0';
*bitlen -= 72;
/* This is technically incorrect, since the encoder might not be lame.
* But there's no other way to determine if this is a lame tag, and we
* wouldn't want to go reading a tag that's not there. */
if (!g_str_has_prefix(lame->encoder, "LAME"))
return false;
if (sscanf(lame->encoder+4, "%u.%u",
&lame->version.major, &lame->version.minor) != 2)
return false;
g_debug("detected LAME version %i.%i (\"%s\")\n",
lame->version.major, lame->version.minor, lame->encoder);
/* The reference volume was changed from the 83dB used in the
* ReplayGain spec to 89dB in lame 3.95.1. Bump the gain for older
* versions, since everyone else uses 89dB instead of 83dB.
* Unfortunately, lame didn't differentiate between 3.95 and 3.95.1, so
* it's impossible to make the proper adjustment for 3.95.
* Fortunately, 3.95 was only out for about a day before 3.95.1 was
* released. -- tmz */
if (lame->version.major < 3 ||
(lame->version.major == 3 && lame->version.minor < 95))
adj = 6;
mad_bit_read(ptr, 16);
lame->peak = mad_f_todouble(mad_bit_read(ptr, 32) << 5); /* peak */
g_debug("LAME peak found: %f\n", lame->peak);
lame->track_gain = 0;
name = mad_bit_read(ptr, 3); /* gain name */
orig = mad_bit_read(ptr, 3); /* gain originator */
sign = mad_bit_read(ptr, 1); /* sign bit */
gain = mad_bit_read(ptr, 9); /* gain*10 */
if (gain && name == 1 && orig != 0) {
lame->track_gain = ((sign ? -gain : gain) / 10.0) + adj;
g_debug("LAME track gain found: %f\n", lame->track_gain);
}
/* tmz reports that this isn't currently written by any version of lame
* (as of 3.97). Since we have no way of testing it, don't use it.
* Wouldn't want to go blowing someone's ears just because we read it
* wrong. :P -- jat */
lame->album_gain = 0;
#if 0
name = mad_bit_read(ptr, 3); /* gain name */
orig = mad_bit_read(ptr, 3); /* gain originator */
sign = mad_bit_read(ptr, 1); /* sign bit */
gain = mad_bit_read(ptr, 9); /* gain*10 */
if (gain && name == 2 && orig != 0) {
lame->album_gain = ((sign ? -gain : gain) / 10.0) + adj;
g_debug("LAME album gain found: %f\n", lame->track_gain);
}
#else
mad_bit_read(ptr, 16);
#endif
mad_bit_read(ptr, 16);
lame->encoder_delay = mad_bit_read(ptr, 12);
lame->encoder_padding = mad_bit_read(ptr, 12);
g_debug("encoder delay is %i, encoder padding is %i\n",
lame->encoder_delay, lame->encoder_padding);
mad_bit_read(ptr, 80);
lame->crc = mad_bit_read(ptr, 16);
*bitlen -= 216;
return true;
}
/* bitrate_index */
index = mad_bit_read(&stream->ptr, 4);
if (index == 15) {
stream->error = MAD_ERROR_BADBITRATE;
return -1;
}
if (header->flags & MAD_FLAG_LSF_EXT)
header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
else
header->bitrate = bitrate_table[header->layer - 1][index];
/* sampling_frequency */
index = mad_bit_read(&stream->ptr, 2);
if (index == 3) {
stream->error = MAD_ERROR_BADSAMPLERATE;
return -1;
}
header->samplerate = samplerate_table[index];
if (header->flags & MAD_FLAG_LSF_EXT) {
header->samplerate /= 2;
if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
header->samplerate /= 2;
}
int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
unsigned int nch, bound, ch, s, sb, nb;
unsigned char allocation[2][32], scalefactor[2][32];
nch = MAD_NCHANNELS(header);
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[ch][sb] = nb ? nb + 1 : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[0][sb] =
allocation[1][sb] = nb ? nb + 1 : 0;
}
for (sb = 0; sb < 32; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb] = (unsigned char)(mad_bit_read(&stream->ptr, 6));
if (scalefactor[ch][sb] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
}
}
}
for (s = 0; s < 12; ++s) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = allocation[ch][sb];
frame->sbsample[ch][s][sb] = nb ?
mad_f_mul(I_sample(&stream->ptr, nb),
sf_table[scalefactor[ch][sb]]) : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
if ((nb = allocation[0][sb])) {
mad_fixed_t sample;
sample = I_sample(&stream->ptr, nb);
for (ch = 0; ch < nch; ++ch) {
frame->sbsample[ch][s][sb] =
mad_f_mul(sample, sf_table[scalefactor[ch][sb]]);
}
}
else {
for (ch = 0; ch < nch; ++ch)
frame->sbsample[ch][s][sb] = 0;
}
}
}
return 0;
}
/*
* NAME: layer->II()
* DESCRIPTION: decode a single Layer II frame
*/
int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
struct mad_bitptr start;
unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb;
unsigned char const *offsets;
unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3];
mad_fixed_t samples[3];
nch = MAD_NCHANNELS(header);
if (header->flags & MAD_FLAG_LSF_EXT)
index = 4;
else {
switch (nch == 2 ? header->bitrate / 2 : header->bitrate) {
case 32000:
case 48000:
index = (header->samplerate == 32000) ? 3 : 2;
break;
case 56000:
case 64000:
case 80000:
index = 0;
break;
default:
index = (header->samplerate == 48000) ? 0 : 1;
}
}
sblimit = sbquant_table[index].sblimit;
offsets = sbquant_table[index].offsets;
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (bound > sblimit)
bound = sblimit;
start = stream->ptr;
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
for (ch = 0; ch < nch; ++ch)
allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal);
}
for (sb = bound; sb < sblimit; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
allocation[0][sb] =
allocation[1][sb] = mad_bit_read(&stream->ptr, nbal);
}
/* decode scalefactor selection info */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb])
scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2);
}
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(start, mad_bit_length(&start, &stream->ptr),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode scalefactors */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6);
switch (scfsi[ch][sb]) {
case 2:
scalefactor[ch][sb][2] =
scalefactor[ch][sb][1] =
scalefactor[ch][sb][0];
break;
case 0:
scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6);
/* fall through */
case 1:
case 3:
scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6);
}
if (scfsi[ch][sb] & 1)
scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1];
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb][0] == 63 ||
scalefactor[ch][sb][1] == 63 ||
scalefactor[ch][sb][2] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (gr = 0; gr < 12; ++gr) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if ((index = allocation[ch][sb])) {
index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (s = 0; s < 3; ++s) {
frame->sbsample[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
else {
for (s = 0; s < 3; ++s)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
for (sb = bound; sb < sblimit; ++sb) {
if ((index = allocation[0][sb])) {
index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
frame->sbsample[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
}
else {
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
for (sb = sblimit; sb < 32; ++sb)
frame->sbsample[ch][3 * gr + s][sb] = 0;
}
}
}
return 0;
}
/*
* NAME: xing->parse()
* DESCRIPTION: parse a Xing VBR header
*/
int xing_parse(struct xing *xing, struct mad_bitptr ptr, unsigned int bitlen)
{
const unsigned XING_MAGIC = (('X' << 24) | ('i' << 16) | ('n' << 8) | 'g');
const unsigned INFO_MAGIC = (('I' << 24) | ('n' << 16) | ('f' << 8) | 'o');
unsigned data;
if (bitlen < 64)
goto fail;
data = mad_bit_read(&ptr, 32);
if( data == XING_MAGIC )
xing->type = xing::XING;
else if( data == INFO_MAGIC )
xing->type = xing::INFO;
else
goto fail;
xing->flags = mad_bit_read(&ptr, 32);
bitlen -= 64;
if (xing->flags & XING_FRAMES)
{
if (bitlen < 32)
goto fail;
xing->frames = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_BYTES)
{
if (bitlen < 32)
goto fail;
xing->bytes = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_TOC)
{
if (bitlen < 800)
goto fail;
for (int i = 0; i < 100; ++i)
xing->toc[i] = (unsigned char) mad_bit_read(&ptr, 8);
bitlen -= 800;
}
if (xing->flags & XING_SCALE)
{
if (bitlen < 32)
goto fail;
xing->scale = mad_bit_read(&ptr, 32);
bitlen -= 32;
}
return 0;
fail:
xing->flags = 0;
return -1;
}
/*
* NAME: layer->I()
* DESCRIPTION: decode a single Layer I frame
*/
int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
unsigned int nch, bound, ch, s, sb, nb;
unsigned char allocation[2][32], scalefactor[2][32];
nch = MAD_NCHANNELS(header);
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[ch][sb] = nb ? nb + 1 : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
nb = mad_bit_read(&stream->ptr, 4);
if (nb == 15) {
stream->error = MAD_ERROR_BADBITALLOC;
return -1;
}
allocation[0][sb] =
allocation[1][sb] = nb ? nb + 1 : 0;
}
/* decode scalefactors */
for (sb = 0; sb < 32; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6);
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (s = 0; s < 12; ++s) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
nb = allocation[ch][sb];
frame->sbsample[ch][s][sb] = nb ?
mad_f_mul(I_sample(&stream->ptr, nb),
sf_table[scalefactor[ch][sb]]) : 0;
}
}
for (sb = bound; sb < 32; ++sb) {
if ((nb = allocation[0][sb])) {
mad_fixed_t sample;
sample = I_sample(&stream->ptr, nb);
for (ch = 0; ch < nch; ++ch) {
frame->sbsample[ch][s][sb] =
mad_f_mul(sample, sf_table[scalefactor[ch][sb]]);
}
}
else {
for (ch = 0; ch < nch; ++ch)
frame->sbsample[ch][s][sb] = 0;
}
}
}
return 0;
}
static xmms_xing_lame_t *
parse_lame (struct mad_bitptr *ptr)
{
struct mad_bitptr save = *ptr;
unsigned long magic;
unsigned char const *version;
xmms_xing_lame_t *lame;
lame = g_new0 (xmms_xing_lame_t, 1);
/*
if (*bitlen < 36 * 8)
goto fail;
*/
/* bytes $9A-$A4: Encoder short VersionString */
magic = mad_bit_read (ptr, 4 * 8);
if (magic != LAME_MAGIC)
goto fail;
XMMS_DBG ("LAME tag found!");
version = mad_bit_nextbyte (ptr);
mad_bit_skip (ptr, 5 * 8);
/* byte $A5: Info Tag revision + VBR method */
lame->revision = mad_bit_read (ptr, 4);
if (lame->revision == 15)
goto fail;
lame->vbr_method = mad_bit_read (ptr, 4);
/* byte $A6: Lowpass filter value (Hz) */
lame->lowpass_filter = mad_bit_read (ptr, 8) * 100;
/* bytes $A7-$AA: 32 bit "Peak signal amplitude" */
lame->peak = mad_bit_read (ptr, 32) << 5;
/* bytes $AB-$AC: 16 bit "Radio Replay Gain" */
/*
rgain_parse(&lame->replay_gain[0], ptr);
*/
/* bytes $AD-$AE: 16 bit "Audiophile Replay Gain" */
/*
rgain_parse(&lame->replay_gain[1], ptr);
*/
mad_bit_skip (ptr, 32);
/*
* As of version 3.95.1, LAME writes Replay Gain values with a reference of
* 89 dB SPL instead of the 83 dB specified in the Replay Gain proposed
* standard. Here we compensate for the heresy.
*/
if (magic == LAME_MAGIC) {
char str[6];
/*
unsigned major = 0, minor = 0, patch = 0;
int i;
*/
memcpy (str, version, 5);
str[5] = 0;
/*
sscanf(str, "%u.%u.%u", &major, &minor, &patch);
if (major > 3 ||
(major == 3 && (minor > 95 ||
(minor == 95 && str[4] == '.')))) {
for (i = 0; i < 2; ++i) {
if (RGAIN_SET(&lame->replay_gain[i]))
lame->replay_gain[i].adjustment -= 60;
}
}
*/
}
/* byte $AF: Encoding flags + ATH Type */
lame->flags = mad_bit_read (ptr, 4);
lame->ath_type = mad_bit_read (ptr, 4);
/* byte $B0: if ABR {specified bitrate} else {minimal bitrate} */
lame->bitrate = mad_bit_read (ptr, 8);
/* bytes $B1-$B3: Encoder delays */
lame->start_delay = mad_bit_read (ptr, 12);
lame->end_padding = mad_bit_read (ptr, 12);
/* byte $B4: Misc */
lame->source_samplerate = mad_bit_read (ptr, 2);
if (mad_bit_read (ptr, 1))
lame->flags |= XMMS_XING_LAME_UNWISE;
lame->stereo_mode = mad_bit_read (ptr, 3);
lame->noise_shaping = mad_bit_read (ptr, 2);
/* byte $B5: MP3 Gain */
lame->gain = mad_bit_read (ptr, 8);
/* bytes $B6-B7: Preset and surround info */
mad_bit_skip (ptr, 2);
lame->surround = mad_bit_read (ptr, 3);
lame->preset = mad_bit_read (ptr, 11);
/* bytes $B8-$BB: MusicLength */
lame->music_length = mad_bit_read (ptr, 32);
/* bytes $BC-$BD: MusicCRC */
lame->music_crc = mad_bit_read (ptr, 16);
/* bytes $BE-$BF: CRC-16 of Info Tag */
/*
if (mad_bit_read(ptr, 16) != crc)
goto fail;
*/
return lame;
fail:
g_free (lame);
*ptr = save;
return NULL;
}
xmms_xing_t *
xmms_xing_parse (struct mad_bitptr ptr)
{
xmms_xing_t *xing;
guint32 xing_magic;
xing_magic = mad_bit_read (&ptr, 4*8);
/* Xing or Info */
if (xing_magic != 0x58696e67 && xing_magic != 0x496e666f) {
return NULL;
}
xing = g_new0 (xmms_xing_t, 1);
g_return_val_if_fail (xing, NULL);
xing->flags = mad_bit_read (&ptr, 32);
if (xmms_xing_has_flag (xing, XMMS_XING_FRAMES))
xing->frames = mad_bit_read (&ptr, 32);
if (xmms_xing_has_flag (xing, XMMS_XING_BYTES))
xing->bytes = mad_bit_read (&ptr, 32);
if (xmms_xing_has_flag (xing, XMMS_XING_TOC)) {
gint i;
for (i = 0; i < 100; i++)
xing->toc[i] = mad_bit_read (&ptr, 8);
}
if (xmms_xing_has_flag (xing, XMMS_XING_SCALE)) {
/* just move the pointer forward */
mad_bit_read (&ptr, 32);
}
xing->lame = parse_lame (&ptr);
/*
if (strncmp ((gchar *)ptr.byte, "LAME", 4) == 0) {
lame = g_new0 (xmms_xing_lame_t, 1);
XMMS_DBG ("Parsing LAME tag");
mad_bit_skip (&ptr, 4 * 8);
mad_bit_nextbyte (&ptr);
mad_bit_skip (&ptr, (8 * 5) + 12);
lame->peak_amplitude = mad_bit_read (&ptr, 32);
lame->radio_gain = mad_bit_read (&ptr, 16);
lame->audiophile_gain = mad_bit_read (&ptr, 16);
mad_bit_skip (&ptr, 16);
lame->encoder_delay_start = mad_bit_read (&ptr, 12);
lame->encoder_delay_stop = mad_bit_read (&ptr, 12);
mad_bit_skip (&ptr, 8);
lame->mp3_gain = mad_bit_read (&ptr, 8);
xing->lame = lame;
}
*/
if (xmms_xing_has_flag (xing, XMMS_XING_FRAMES) && xing->frames == 0) {
xmms_log_info ("Corrupt xing header (frames == 0), ignoring");
xmms_xing_free (xing);
return NULL;
}
if (xmms_xing_has_flag (xing, XMMS_XING_BYTES) && xing->bytes == 0) {
xmms_log_info ("Corrupt xing header (bytes == 0), ignoring");
xmms_xing_free (xing);
return NULL;
}
if (xmms_xing_has_flag (xing, XMMS_XING_TOC)) {
gint i;
for (i = 0; i < 99; i++) {
if (xing->toc[i] > xing->toc[i + 1]) {
xmms_log_info ("Corrupt xing header (toc not monotonic), ignoring");
xmms_xing_free (xing);
return NULL;
}
}
}
return xing;
}
static bool
parse_xing(struct xing *xing, struct mad_bitptr *ptr, int *oldbitlen)
{
unsigned long bits;
int bitlen;
int bitsleft;
int i;
bitlen = *oldbitlen;
if (bitlen < 16)
return false;
bits = mad_bit_read(ptr, 16);
bitlen -= 16;
if (bits == XI_MAGIC) {
if (bitlen < 16)
return false;
if (mad_bit_read(ptr, 16) != NG_MAGIC)
return false;
bitlen -= 16;
xing->magic = XING_MAGIC_XING;
} else if (bits == IN_MAGIC) {
if (bitlen < 16)
return false;
if (mad_bit_read(ptr, 16) != FO_MAGIC)
return false;
bitlen -= 16;
xing->magic = XING_MAGIC_INFO;
}
else if (bits == NG_MAGIC) xing->magic = XING_MAGIC_XING;
else if (bits == FO_MAGIC) xing->magic = XING_MAGIC_INFO;
else
return false;
if (bitlen < 32)
return false;
xing->flags = mad_bit_read(ptr, 32);
bitlen -= 32;
if (xing->flags & XING_FRAMES) {
if (bitlen < 32)
return false;
xing->frames = mad_bit_read(ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_BYTES) {
if (bitlen < 32)
return false;
xing->bytes = mad_bit_read(ptr, 32);
bitlen -= 32;
}
if (xing->flags & XING_TOC) {
if (bitlen < 800)
return false;
for (i = 0; i < 100; ++i) xing->toc[i] = mad_bit_read(ptr, 8);
bitlen -= 800;
}
if (xing->flags & XING_SCALE) {
if (bitlen < 32)
return false;
xing->scale = mad_bit_read(ptr, 32);
bitlen -= 32;
}
/* Make sure we consume no less than 120 bytes (960 bits) in hopes that
* the LAME tag is found there, and not right after the Xing header */
bitsleft = 960 - ((*oldbitlen) - bitlen);
if (bitsleft < 0)
return false;
else if (bitsleft > 0) {
mad_bit_read(ptr, bitsleft);
bitlen -= bitsleft;
}
*oldbitlen = bitlen;
return true;
}
/*
* NAME: layer->II()
* DESCRIPTION: decode a single Layer II frame
*/
int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame)
{
struct mad_header *header = &frame->header;
struct mad_bitptr start;
unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb;
unsigned char const *offsets;
unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3];
mad_fixed_t samples[3];
nch = MAD_NCHANNELS(header);
if (header->flags & MAD_FLAG_LSF_EXT)
index = 4;
else if (header->flags & MAD_FLAG_FREEFORMAT)
goto freeformat;
else {
unsigned long bitrate_per_channel;
bitrate_per_channel = header->bitrate;
if (nch == 2) {
bitrate_per_channel /= 2;
# if defined(OPT_STRICT)
/*
* ISO/IEC 11172-3 allows only single channel mode for 32, 48, 56, and
* 80 kbps bitrates in Layer II, but some encoders ignore this
* restriction. We enforce it if OPT_STRICT is defined.
*/
if (bitrate_per_channel <= 28000 || bitrate_per_channel == 40000) {
stream->error = MAD_ERROR_BADMODE;
return -1;
}
# endif
}
else { /* nch == 1 */
if (bitrate_per_channel > 192000) {
/*
* ISO/IEC 11172-3 does not allow single channel mode for 224, 256,
* 320, or 384 kbps bitrates in Layer II.
*/
stream->error = MAD_ERROR_BADMODE;
return -1;
}
}
if (bitrate_per_channel <= 48000)
index = (header->samplerate == 32000) ? 3 : 2;
else if (bitrate_per_channel <= 80000)
index = 0;
else {
freeformat:
index = (header->samplerate == 48000) ? 0 : 1;
}
}
sblimit = sbquant_table[index].sblimit;
offsets = sbquant_table[index].offsets;
bound = 32;
if (header->mode == MAD_MODE_JOINT_STEREO) {
header->flags |= MAD_FLAG_I_STEREO;
bound = 4 + header->mode_extension * 4;
}
if (bound > sblimit)
bound = sblimit;
start = stream->ptr;
/* decode bit allocations */
for (sb = 0; sb < bound; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
for (ch = 0; ch < nch; ++ch)
allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal);
}
for (sb = bound; sb < sblimit; ++sb) {
nbal = bitalloc_table[offsets[sb]].nbal;
allocation[0][sb] =
allocation[1][sb] = mad_bit_read(&stream->ptr, nbal);
}
/* decode scalefactor selection info */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb])
scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2);
}
}
/* check CRC word */
if (header->flags & MAD_FLAG_PROTECTION) {
header->crc_check =
mad_bit_crc(start, mad_bit_length(&start, &stream->ptr),
header->crc_check);
if (header->crc_check != header->crc_target &&
!(frame->options & MAD_OPTION_IGNORECRC)) {
stream->error = MAD_ERROR_BADCRC;
return -1;
}
}
/* decode scalefactors */
for (sb = 0; sb < sblimit; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if (allocation[ch][sb]) {
scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6);
switch (scfsi[ch][sb]) {
case 2:
scalefactor[ch][sb][2] =
scalefactor[ch][sb][1] =
scalefactor[ch][sb][0];
break;
case 0:
scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6);
/* fall through */
case 1:
case 3:
scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6);
}
if (scfsi[ch][sb] & 1)
scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1];
# if defined(OPT_STRICT)
/*
* Scalefactor index 63 does not appear in Table B.1 of
* ISO/IEC 11172-3. Nonetheless, other implementations accept it,
* so we only reject it if OPT_STRICT is defined.
*/
if (scalefactor[ch][sb][0] == 63 ||
scalefactor[ch][sb][1] == 63 ||
scalefactor[ch][sb][2] == 63) {
stream->error = MAD_ERROR_BADSCALEFACTOR;
return -1;
}
# endif
}
}
}
/* decode samples */
for (gr = 0; gr < 12; ++gr) {
for (sb = 0; sb < bound; ++sb) {
for (ch = 0; ch < nch; ++ch) {
if ((index = allocation[ch][sb])) {
int off = bitalloc_table[offsets[sb]].offset;
index = offset_table[off][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (s = 0; s < 3; ++s) {
(*frame->sbsample)[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
else {
for (s = 0; s < 3; ++s)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
for (sb = bound; sb < sblimit; ++sb) {
if ((index = allocation[0][sb])) {
int off = bitalloc_table[offsets[sb]].offset;
index = offset_table[off][index - 1];
II_samples(&stream->ptr, &qc_table[index], samples);
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
(*frame->sbsample)[ch][3 * gr + s][sb] =
mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
}
}
}
else {
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
for (ch = 0; ch < nch; ++ch) {
for (s = 0; s < 3; ++s) {
for (sb = sblimit; sb < 32; ++sb)
(*frame->sbsample)[ch][3 * gr + s][sb] = 0;
}
}
}
return 0;
}
/*
* NAME: tag->parse()
* DESCRIPTION: parse Xing/LAME tag(s)
*/
int tag_parse(struct tag *tag, struct mad_stream const *stream)
{
struct mad_bitptr ptr = stream->anc_ptr;
struct mad_bitptr start = ptr;
unsigned int bitlen = stream->anc_bitlen;
unsigned long magic;
int i;
if (bitlen < 32)
return -1;
magic = mad_bit_read(&ptr, 32);
bitlen -= 32;
if (magic != XING_MAGIC &&
magic != INFO_MAGIC &&
magic != LAME_MAGIC) {
/*
* Due to an unfortunate historical accident, a Xing VBR tag may be
* misplaced in a stream with CRC protection. We check for this by
* assuming the tag began two octets prior and the high bits of the
* following flags field are always zero.
*/
if (magic != ((XING_MAGIC << 16) & 0xffffffffL) &&
magic != ((INFO_MAGIC << 16) & 0xffffffffL))
return -1;
magic >>= 16;
/* backtrack the bit pointer */
ptr = start;
mad_bit_skip(&ptr, 16);
bitlen += 16;
}
if ((magic & 0x0000ffffL) == (XING_MAGIC & 0x0000ffffL))
tag->flags |= TAG_VBR;
/* Xing tag */
if (magic == LAME_MAGIC) {
ptr = start;
bitlen += 32;
}
else if (parse_xing(&tag->xing, &ptr, &bitlen) == 0)
tag->flags |= TAG_XING;
/* encoder string */
if (bitlen >= 20 * 8) {
start = ptr;
for (i = 0; i < 20; ++i) {
tag->encoder[i] = mad_bit_read(&ptr, 8);
if (tag->encoder[i] == 0)
break;
/* keep only printable ASCII chars */
if (tag->encoder[i] < 0x20 || tag->encoder[i] >= 0x7f) {
tag->encoder[i] = 0;
break;
}
}
tag->encoder[20] = 0;
ptr = start;
}
/* LAME tag */
if (stream->next_frame - stream->this_frame >= 192 &&
parse_lame(&tag->lame, &ptr, &bitlen,
crc_compute(stream->this_frame, 190, 0x0000)) == 0) {
tag->flags |= TAG_LAME;
tag->encoder[9] = 0;
}
else {
for (i = 0; i < 20; ++i) {
if (tag->encoder[i] == 0)
break;
/* stop at padding chars */
if (tag->encoder[i] == 0x55) {
tag->encoder[i] = 0;
break;
}
}
}
return 0;
}
