#include "libavutil/attributes.h"
#include "libavutil/avassert.h"
#include "libavutil/channel_layout.h"
+#include "libavutil/crc.h"
#include "libavutil/float_dsp.h"
#include "libavutil/libm.h"
+#include "libavutil/mem_internal.h"
+#include "libavutil/thread.h"
+
#include "avcodec.h"
#include "get_bits.h"
#include "internal.h"
int err_recognition;
AVCodecContext* avctx;
MPADSPContext mpadsp;
- AVFloatDSPContext *fdsp;
+ void (*butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len);
AVFrame *frame;
+ uint32_t crc;
} MPADecodeContext;
#define HEADER_SIZE 4
#include "mpegaudiodata.h"
-#include "mpegaudiodectab.h"
-
-/* vlc structure for decoding layer 3 huffman tables */
-static VLC huff_vlc[16];
-static VLC_TYPE huff_vlc_tables[
- 0 + 128 + 128 + 128 + 130 + 128 + 154 + 166 +
- 142 + 204 + 190 + 170 + 542 + 460 + 662 + 414
- ][2];
-static const int huff_vlc_tables_sizes[16] = {
- 0, 128, 128, 128, 130, 128, 154, 166,
- 142, 204, 190, 170, 542, 460, 662, 414
-};
-static VLC huff_quad_vlc[2];
-static VLC_TYPE huff_quad_vlc_tables[128+16][2];
-static const int huff_quad_vlc_tables_sizes[2] = { 128, 16 };
-/* computed from band_size_long */
-static uint16_t band_index_long[9][23];
+
#include "mpegaudio_tablegen.h"
/* intensity stereo coef table */
-static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16];
-static INTFLOAT csa_table[8][4];
-static int16_t division_tab3[1<<6 ];
-static int16_t division_tab5[1<<8 ];
-static int16_t division_tab9[1<<11];
-
-static int16_t * const division_tabs[4] = {
- division_tab3, division_tab5, NULL, division_tab9
-};
-
-/* lower 2 bits: modulo 3, higher bits: shift */
-static uint16_t scale_factor_modshift[64];
/* [i][j]: 2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
static int32_t scale_factor_mult[15][3];
/* mult table for layer 2 group quantization */
int ra1, int ra2)
{
int l;
- g->region_size[0] = band_index_long[s->sample_rate_index][ra1 + 1] >> 1;
+ g->region_size[0] = ff_band_index_long[s->sample_rate_index][ra1 + 1];
/* should not overflow */
l = FFMIN(ra1 + ra2 + 2, 22);
- g->region_size[1] = band_index_long[s->sample_rate_index][ l] >> 1;
+ g->region_size[1] = ff_band_index_long[s->sample_rate_index][ l];
}
static void compute_band_indexes(MPADecodeContext *s, GranuleDef *g)
int shift, mod;
int64_t val;
- shift = scale_factor_modshift[scale_factor];
+ shift = ff_scale_factor_modshift[scale_factor];
mod = shift & 3;
shift >>= 2;
val = MUL64((int)(mant + (-1U << n) + 1), scale_factor_mult[n-1][mod]);
{
int shift, mod, val;
- shift = scale_factor_modshift[scale_factor];
+ shift = ff_scale_factor_modshift[scale_factor];
mod = shift & 3;
shift >>= 2;
unsigned int m;
int e;
- e = table_4_3_exp [4 * value + (exponent & 3)];
- m = table_4_3_value[4 * value + (exponent & 3)];
+ e = ff_table_4_3_exp [4 * value + (exponent & 3)];
+ m = ff_table_4_3_value[4 * value + (exponent & 3)];
e -= exponent >> 2;
#ifdef DEBUG
if(e < 1)
#endif
if (e > (SUINT)31)
return 0;
- m = (m + ((1U << e)>>1)) >> e;
+ m = (m + ((1U << e) >> 1)) >> e;
return m;
}
static av_cold void decode_init_static(void)
{
- int i, j, k;
- int offset;
-
- /* scale factors table for layer 1/2 */
- for (i = 0; i < 64; i++) {
- int shift, mod;
- /* 1.0 (i = 3) is normalized to 2 ^ FRAC_BITS */
- shift = i / 3;
- mod = i % 3;
- scale_factor_modshift[i] = mod | (shift << 2);
- }
+ int i, j;
/* scale factor multiply for layer 1 */
for (i = 0; i < 15; i++) {
scale_factor_mult[i][2]);
}
- RENAME(ff_mpa_synth_init)(RENAME(ff_mpa_synth_window));
-
- /* huffman decode tables */
- offset = 0;
- for (i = 1; i < 16; i++) {
- const HuffTable *h = &mpa_huff_tables[i];
- int xsize, x, y;
- uint8_t tmp_bits [512] = { 0 };
- uint16_t tmp_codes[512] = { 0 };
-
- xsize = h->xsize;
-
- j = 0;
- for (x = 0; x < xsize; x++) {
- for (y = 0; y < xsize; y++) {
- tmp_bits [(x << 5) | y | ((x&&y)<<4)]= h->bits [j ];
- tmp_codes[(x << 5) | y | ((x&&y)<<4)]= h->codes[j++];
- }
- }
-
- /* XXX: fail test */
- huff_vlc[i].table = huff_vlc_tables+offset;
- huff_vlc[i].table_allocated = huff_vlc_tables_sizes[i];
- init_vlc(&huff_vlc[i], 7, 512,
- tmp_bits, 1, 1, tmp_codes, 2, 2,
- INIT_VLC_USE_NEW_STATIC);
- offset += huff_vlc_tables_sizes[i];
- }
- av_assert0(offset == FF_ARRAY_ELEMS(huff_vlc_tables));
-
- offset = 0;
- for (i = 0; i < 2; i++) {
- huff_quad_vlc[i].table = huff_quad_vlc_tables+offset;
- huff_quad_vlc[i].table_allocated = huff_quad_vlc_tables_sizes[i];
- init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
- mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1,
- INIT_VLC_USE_NEW_STATIC);
- offset += huff_quad_vlc_tables_sizes[i];
- }
- av_assert0(offset == FF_ARRAY_ELEMS(huff_quad_vlc_tables));
-
- for (i = 0; i < 9; i++) {
- k = 0;
- for (j = 0; j < 22; j++) {
- band_index_long[i][j] = k;
- k += band_size_long[i][j];
- }
- band_index_long[i][22] = k;
- }
-
/* compute n ^ (4/3) and store it in mantissa/exp format */
mpegaudio_tableinit();
- for (i = 0; i < 4; i++) {
- if (ff_mpa_quant_bits[i] < 0) {
- for (j = 0; j < (1 << (-ff_mpa_quant_bits[i]+1)); j++) {
- int val1, val2, val3, steps;
- int val = j;
- steps = ff_mpa_quant_steps[i];
- val1 = val % steps;
- val /= steps;
- val2 = val % steps;
- val3 = val / steps;
- division_tabs[i][j] = val1 + (val2 << 4) + (val3 << 8);
- }
- }
- }
-
-
- for (i = 0; i < 7; i++) {
- float f;
- INTFLOAT v;
- if (i != 6) {
- f = tan((double)i * M_PI / 12.0);
- v = FIXR(f / (1.0 + f));
- } else {
- v = FIXR(1.0);
- }
- is_table[0][ i] = v;
- is_table[1][6 - i] = v;
- }
- /* invalid values */
- for (i = 7; i < 16; i++)
- is_table[0][i] = is_table[1][i] = 0.0;
-
for (i = 0; i < 16; i++) {
double f;
int e, k;
(float) is_table_lsf[j][1][i]);
}
}
-
- for (i = 0; i < 8; i++) {
- double ci, cs, ca;
- ci = ci_table[i];
- cs = 1.0 / sqrt(1.0 + ci * ci);
- ca = cs * ci;
-#if !USE_FLOATS
- csa_table[i][0] = FIXHR(cs/4);
- csa_table[i][1] = FIXHR(ca/4);
- csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);
- csa_table[i][3] = FIXHR(ca/4) - FIXHR(cs/4);
-#else
- csa_table[i][0] = cs;
- csa_table[i][1] = ca;
- csa_table[i][2] = ca + cs;
- csa_table[i][3] = ca - cs;
-#endif
- }
+ RENAME(ff_mpa_synth_init)();
+ ff_mpegaudiodec_common_init_static();
}
-#if USE_FLOATS
-static av_cold int decode_close(AVCodecContext * avctx)
-{
- MPADecodeContext *s = avctx->priv_data;
- av_freep(&s->fdsp);
-
- return 0;
-}
-#endif
-
static av_cold int decode_init(AVCodecContext * avctx)
{
- static int initialized_tables = 0;
+ static AVOnce init_static_once = AV_ONCE_INIT;
MPADecodeContext *s = avctx->priv_data;
- if (!initialized_tables) {
- decode_init_static();
- initialized_tables = 1;
- }
-
s->avctx = avctx;
#if USE_FLOATS
- s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
- if (!s->fdsp)
- return AVERROR(ENOMEM);
+ {
+ AVFloatDSPContext *fdsp;
+ fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
+ if (!fdsp)
+ return AVERROR(ENOMEM);
+ s->butterflies_float = fdsp->butterflies_float;
+ av_free(fdsp);
+ }
#endif
ff_mpadsp_init(&s->mpadsp);
if (avctx->codec_id == AV_CODEC_ID_MP3ADU)
s->adu_mode = 1;
+ ff_thread_once(&init_static_once, decode_init_static);
+
return 0;
}
out[11] = in0 + in5;
}
+static int handle_crc(MPADecodeContext *s, int sec_len)
+{
+ if (s->error_protection && (s->err_recognition & AV_EF_CRCCHECK)) {
+ const uint8_t *buf = s->gb.buffer - HEADER_SIZE;
+ int sec_byte_len = sec_len >> 3;
+ int sec_rem_bits = sec_len & 7;
+ const AVCRC *crc_tab = av_crc_get_table(AV_CRC_16_ANSI);
+ uint8_t tmp_buf[4];
+ uint32_t crc_val = av_crc(crc_tab, UINT16_MAX, &buf[2], 2);
+ crc_val = av_crc(crc_tab, crc_val, &buf[6], sec_byte_len);
+
+ AV_WB32(tmp_buf,
+ ((buf[6 + sec_byte_len] & (0xFF00 >> sec_rem_bits)) << 24) +
+ ((s->crc << 16) >> sec_rem_bits));
+
+ crc_val = av_crc(crc_tab, crc_val, tmp_buf, 3);
+
+ if (crc_val) {
+ av_log(s->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", crc_val);
+ if (s->err_recognition & AV_EF_EXPLODE)
+ return AVERROR_INVALIDDATA;
+ }
+ }
+ return 0;
+}
+
/* return the number of decoded frames */
static int mp_decode_layer1(MPADecodeContext *s)
{
int bound, i, v, n, ch, j, mant;
uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
+ int ret;
+
+ ret = handle_crc(s, (s->nb_channels == 1) ? 8*16 : 8*32);
+ if (ret < 0)
+ return ret;
if (s->mode == MPA_JSTEREO)
bound = (s->mode_ext + 1) * 4;
unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3], *sf;
int scale, qindex, bits, steps, k, l, m, b;
+ int ret;
/* select decoding table */
table = ff_mpa_l2_select_table(s->bit_rate / 1000, s->nb_channels,
}
}
+ ret = handle_crc(s, get_bits_count(&s->gb) - 16);
+ if (ret < 0)
+ return ret;
+
/* scale factors */
for (i = 0; i < sblimit; i++) {
for (ch = 0; ch < s->nb_channels; ch++) {
int v2;
/* 3 values at the same time */
v = get_bits(&s->gb, -bits);
- v2 = division_tabs[qindex][v];
+ v2 = ff_division_tabs[qindex][v];
steps = ff_mpa_quant_steps[qindex];
s->sb_samples[ch][k * 12 + l + 0][i] =
int mant, scale0, scale1;
scale0 = scale_factors[0][i][k];
scale1 = scale_factors[1][i][k];
- qindex = alloc_table[j+b];
+ qindex = alloc_table[j + b];
bits = ff_mpa_quant_bits[qindex];
if (bits < 0) {
/* 3 values at the same time */
gain = g->global_gain - 210;
shift = g->scalefac_scale + 1;
- bstab = band_size_long[s->sample_rate_index];
- pretab = mpa_pretab[g->preflag];
+ bstab = ff_band_size_long[s->sample_rate_index];
+ pretab = ff_mpa_pretab[g->preflag];
for (i = 0; i < g->long_end; i++) {
v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
len = bstab[i];
}
if (g->short_start < 13) {
- bstab = band_size_short[s->sample_rate_index];
+ bstab = ff_band_size_short[s->sample_rate_index];
gains[0] = gain - (g->subblock_gain[0] << 3);
gains[1] = gain - (g->subblock_gain[1] << 3);
gains[2] = gain - (g->subblock_gain[2] << 3);
continue;
/* select vlc table */
k = g->table_select[i];
- l = mpa_huff_data[k][0];
- linbits = mpa_huff_data[k][1];
- vlc = &huff_vlc[l];
+ l = ff_mpa_huff_data[k][0];
+ linbits = ff_mpa_huff_data[k][1];
+ vlc = &ff_huff_vlc[l];
if (!l) {
memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid) * 2 * j);
y = get_vlc2(&s->gb, vlc->table, 7, 3);
if (!y) {
- g->sb_hybrid[s_index ] =
- g->sb_hybrid[s_index+1] = 0;
+ g->sb_hybrid[s_index ] =
+ g->sb_hybrid[s_index + 1] = 0;
s_index += 2;
continue;
}
v = l3_unscale(y, exponent);
if (get_bits1(&s->gb))
v = -v;
- g->sb_hybrid[s_index+1] = v;
+ g->sb_hybrid[s_index + 1] = v;
}
} else {
x = y >> 5;
}
/* high frequencies */
- vlc = &huff_quad_vlc[g->count1table_select];
+ vlc = &ff_huff_quad_vlc[g->count1table_select];
last_pos = 0;
while (s_index <= 572) {
int pos, code;
code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
ff_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
- g->sb_hybrid[s_index+0] =
- g->sb_hybrid[s_index+1] =
- g->sb_hybrid[s_index+2] =
- g->sb_hybrid[s_index+3] = 0;
+ g->sb_hybrid[s_index + 0] =
+ g->sb_hybrid[s_index + 1] =
+ g->sb_hybrid[s_index + 2] =
+ g->sb_hybrid[s_index + 3] = 0;
while (code) {
static const int idxtab[16] = { 3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0 };
int v;
}
for (i = g->short_start; i < 13; i++) {
- len = band_size_short[s->sample_rate_index][i];
+ len = ff_band_size_short[s->sample_rate_index][i];
ptr1 = ptr;
dst = tmp;
for (j = len; j > 0; j--) {
{
int i, j, k, l;
int sf_max, sf, len, non_zero_found;
- INTFLOAT (*is_tab)[16], *tab0, *tab1, v1, v2;
+ INTFLOAT *tab0, *tab1, v1, v2;
+ const INTFLOAT (*is_tab)[16];
SUINTFLOAT tmp0, tmp1;
int non_zero_found_short[3];
/* for last band, use previous scale factor */
if (i != 11)
k -= 3;
- len = band_size_short[s->sample_rate_index][i];
+ len = ff_band_size_short[s->sample_rate_index][i];
for (l = 2; l >= 0; l--) {
tab0 -= len;
tab1 -= len;
non_zero_found_short[2];
for (i = g1->long_end - 1;i >= 0;i--) {
- len = band_size_long[s->sample_rate_index][i];
+ len = ff_band_size_long[s->sample_rate_index][i];
tab0 -= len;
tab1 -= len;
/* test if non zero band. if so, stop doing i-stereo */
/* NOTE: the 1/sqrt(2) normalization factor is included in the
global gain */
#if USE_FLOATS
- s->fdsp->butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
+ s->butterflies_float(g0->sb_hybrid, g1->sb_hybrid, 576);
#else
tab0 = g0->sb_hybrid;
tab1 = g1->sb_hybrid;
int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
GranuleDef *g;
int16_t exponents[576]; //FIXME try INTFLOAT
+ int ret;
/* read side info */
if (s->lsf) {
+ ret = handle_crc(s, ((s->nb_channels == 1) ? 8*9 : 8*17));
main_data_begin = get_bits(&s->gb, 8);
skip_bits(&s->gb, s->nb_channels);
nb_granules = 1;
} else {
+ ret = handle_crc(s, ((s->nb_channels == 1) ? 8*17 : 8*32));
main_data_begin = get_bits(&s->gb, 9);
if (s->nb_channels == 2)
skip_bits(&s->gb, 3);
s->granules[ch][1].scfsi = get_bits(&s->gb, 4);
}
}
+ if (ret < 0)
+ return ret;
for (gr = 0; gr < nb_granules; gr++) {
for (ch = 0; ch < s->nb_channels; ch++) {
if (!s->adu_mode) {
int skip;
- const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
+ const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb) >> 3);
s->extrasize = av_clip((get_bits_left(&s->gb) >> 3) - s->extrasize, 0,
FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
av_assert1((get_bits_count(&s->gb) & 7) == 0);
int slen, slen1, slen2;
/* MPEG-1 scale factors */
- slen1 = slen_table[0][g->scalefac_compress];
- slen2 = slen_table[1][g->scalefac_compress];
+ slen1 = ff_slen_table[0][g->scalefac_compress];
+ slen2 = ff_slen_table[1][g->scalefac_compress];
ff_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
if (g->block_type == 2) {
n = g->switch_point ? 17 : 18;
j = 0;
for (k = 0; k < 4; k++) {
- n = lsf_nsf_table[tindex2][tindex][k];
+ n = ff_lsf_nsf_table[tindex2][tindex][k];
sl = slen[k];
if (sl) {
for (i = 0; i < n; i++)
OUT_INT *samples_ptr;
init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
-
- /* skip error protection field */
if (s->error_protection)
- skip_bits(&s->gb, 16);
+ s->crc = get_bits(&s->gb, 16);
switch(s->layer) {
case 1:
align_get_bits(&s->gb);
i = (get_bits_left(&s->gb) >> 3) - s->extrasize;
if (i >= 0 && i <= BACKSTEP_SIZE) {
- memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
+ memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb) >> 3), i);
s->last_buf_size=i;
} else
av_log(s->avctx, AV_LOG_ERROR, "invalid old backstep %d\n", i);
return AVERROR_INVALIDDATA;
header = AV_RB32(buf);
- if (header>>8 == AV_RB32("TAG")>>8) {
+ if (header >> 8 == AV_RB32("TAG") >> 8) {
av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
return buf_size + skipped;
}
MP3On4DecodeContext *s = avctx->priv_data;
int i;
- if (s->mp3decctx[0])
- av_freep(&s->mp3decctx[0]->fdsp);
-
for (i = 0; i < s->frames; i++)
av_freep(&s->mp3decctx[i]);
{
MP3On4DecodeContext *s = avctx->priv_data;
MPEG4AudioConfig cfg;
- int i;
+ int i, ret;
if ((avctx->extradata_size < 2) || !avctx->extradata) {
av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
return AVERROR_INVALIDDATA;
}
- avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
- avctx->extradata_size * 8, 1);
+ avpriv_mpeg4audio_get_config2(&cfg, avctx->extradata,
+ avctx->extradata_size, 1, avctx);
if (!cfg.chan_config || cfg.chan_config > 7) {
av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
return AVERROR_INVALIDDATA;
// Allocate zeroed memory for the first decoder context
s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
if (!s->mp3decctx[0])
- goto alloc_fail;
+ return AVERROR(ENOMEM);
// Put decoder context in place to make init_decode() happy
avctx->priv_data = s->mp3decctx[0];
- decode_init(avctx);
+ ret = decode_init(avctx);
// Restore mp3on4 context pointer
avctx->priv_data = s;
+ if (ret < 0)
+ return ret;
s->mp3decctx[0]->adu_mode = 1; // Set adu mode
/* Create a separate codec/context for each frame (first is already ok).
for (i = 1; i < s->frames; i++) {
s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
if (!s->mp3decctx[i])
- goto alloc_fail;
+ return AVERROR(ENOMEM);
s->mp3decctx[i]->adu_mode = 1;
s->mp3decctx[i]->avctx = avctx;
s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
- s->mp3decctx[i]->fdsp = s->mp3decctx[0]->fdsp;
+ s->mp3decctx[i]->butterflies_float = s->mp3decctx[0]->butterflies_float;
}
return 0;
-alloc_fail:
- decode_close_mp3on4(avctx);
- return AVERROR(ENOMEM);
}