* MPEG Audio decoder
* Copyright (c) 2001, 2002 Fabrice Bellard
*
- * This file is part of FFmpeg.
+ * This file is part of Libav.
*
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
* 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
- * License along with FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
* MPEG Audio decoder.
*/
+#include "libavutil/audioconvert.h"
#include "avcodec.h"
#include "get_bits.h"
-#include "dsputil.h"
+#include "mathops.h"
+#include "mpegaudiodsp.h"
/*
* TODO:
- * - in low precision mode, use more 16 bit multiplies in synth filter
* - test lsf / mpeg25 extensively.
*/
#include "mpegaudio.h"
#include "mpegaudiodecheader.h"
-#include "mathops.h"
+#define BACKSTEP_SIZE 512
+#define EXTRABYTES 24
+
+/* layer 3 "granule" */
+typedef struct GranuleDef {
+ uint8_t scfsi;
+ int part2_3_length;
+ int big_values;
+ int global_gain;
+ int scalefac_compress;
+ uint8_t block_type;
+ uint8_t switch_point;
+ int table_select[3];
+ int subblock_gain[3];
+ uint8_t scalefac_scale;
+ uint8_t count1table_select;
+ int region_size[3]; /* number of huffman codes in each region */
+ int preflag;
+ int short_start, long_end; /* long/short band indexes */
+ uint8_t scale_factors[40];
+ INTFLOAT sb_hybrid[SBLIMIT * 18]; /* 576 samples */
+} GranuleDef;
+
+typedef struct MPADecodeContext {
+ MPA_DECODE_HEADER
+ uint8_t last_buf[2*BACKSTEP_SIZE + EXTRABYTES];
+ int last_buf_size;
+ /* next header (used in free format parsing) */
+ uint32_t free_format_next_header;
+ GetBitContext gb;
+ GetBitContext in_gb;
+ DECLARE_ALIGNED(32, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512 * 2];
+ int synth_buf_offset[MPA_MAX_CHANNELS];
+ DECLARE_ALIGNED(32, INTFLOAT, sb_samples)[MPA_MAX_CHANNELS][36][SBLIMIT];
+ INTFLOAT mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
+ GranuleDef granules[2][2]; /* Used in Layer 3 */
+#ifdef DEBUG
+ int frame_count;
+#endif
+ int adu_mode; ///< 0 for standard mp3, 1 for adu formatted mp3
+ int dither_state;
+ int error_recognition;
+ AVCodecContext* avctx;
+ MPADSPContext mpadsp;
+} MPADecodeContext;
#if CONFIG_FLOAT
# define SHR(a,b) ((a)*(1.0f/(1<<(b))))
-# define compute_antialias compute_antialias_float
# define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
# define FIXR(x) ((float)(x))
# define FIXHR(x) ((float)(x))
# define MULH3(x, y, s) ((s)*(y)*(x))
# define MULLx(x, y, s) ((y)*(x))
# define RENAME(a) a ## _float
+# define OUT_FMT AV_SAMPLE_FMT_FLT
#else
# define SHR(a,b) ((a)>>(b))
-# define compute_antialias compute_antialias_integer
/* WARNING: only correct for posititive numbers */
# define FIXR_OLD(a) ((int)((a) * FRAC_ONE + 0.5))
# define FIXR(a) ((int)((a) * FRAC_ONE + 0.5))
# define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))
# define MULH3(x, y, s) MULH((s)*(x), y)
# define MULLx(x, y, s) MULL(x,y,s)
-# define RENAME(a) a
+# define RENAME(a) a ## _fixed
+# define OUT_FMT AV_SAMPLE_FMT_S16
#endif
/****************/
#include "mpegaudiodata.h"
#include "mpegaudiodectab.h"
-static void compute_antialias_integer(MPADecodeContext *s, GranuleDef *g);
-static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g);
-static void apply_window_mp3_c(MPA_INT *synth_buf, MPA_INT *window,
- int *dither_state, OUT_INT *samples, int incr);
-
/* vlc structure for decoding layer 3 huffman tables */
static VLC huff_vlc[16];
static VLC_TYPE huff_vlc_tables[
/* intensity stereo coef table */
static INTFLOAT is_table[2][16];
static INTFLOAT is_table_lsf[2][2][16];
-static int32_t csa_table[8][4];
-static float csa_table_float[8][4];
+static INTFLOAT csa_table[8][4];
static INTFLOAT mdct_win[8][36];
+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) */
SCALE_GEN(4.0 / 9.0), /* 9 steps */
};
-DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512];
-
/**
* Convert region offsets to region sizes and truncate
* size to big_values.
return m;
}
-/* all integer n^(4/3) computation code */
-#define DEV_ORDER 13
-
-#define POW_FRAC_BITS 24
-#define POW_FRAC_ONE (1 << POW_FRAC_BITS)
-#define POW_FIX(a) ((int)((a) * POW_FRAC_ONE))
-#define POW_MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> POW_FRAC_BITS)
-
-static int dev_4_3_coefs[DEV_ORDER];
-
-#if 0 /* unused */
-static int pow_mult3[3] = {
- POW_FIX(1.0),
- POW_FIX(1.25992104989487316476),
- POW_FIX(1.58740105196819947474),
-};
-#endif
-
-static av_cold void int_pow_init(void)
-{
- int i, a;
-
- a = POW_FIX(1.0);
- for(i=0;i<DEV_ORDER;i++) {
- a = POW_MULL(a, POW_FIX(4.0 / 3.0) - i * POW_FIX(1.0)) / (i + 1);
- dev_4_3_coefs[i] = a;
- }
-}
-
-#if 0 /* unused, remove? */
-/* return the mantissa and the binary exponent */
-static int int_pow(int i, int *exp_ptr)
-{
- int e, er, eq, j;
- int a, a1;
-
- /* renormalize */
- a = i;
- e = POW_FRAC_BITS;
- while (a < (1 << (POW_FRAC_BITS - 1))) {
- a = a << 1;
- e--;
- }
- a -= (1 << POW_FRAC_BITS);
- a1 = 0;
- for(j = DEV_ORDER - 1; j >= 0; j--)
- a1 = POW_MULL(a, dev_4_3_coefs[j] + a1);
- a = (1 << POW_FRAC_BITS) + a1;
- /* exponent compute (exact) */
- e = e * 4;
- er = e % 3;
- eq = e / 3;
- a = POW_MULL(a, pow_mult3[er]);
- while (a >= 2 * POW_FRAC_ONE) {
- a = a >> 1;
- eq++;
- }
- /* convert to float */
- while (a < POW_FRAC_ONE) {
- a = a << 1;
- eq--;
- }
- /* now POW_FRAC_ONE <= a < 2 * POW_FRAC_ONE */
-#if POW_FRAC_BITS > FRAC_BITS
- a = (a + (1 << (POW_FRAC_BITS - FRAC_BITS - 1))) >> (POW_FRAC_BITS - FRAC_BITS);
- /* correct overflow */
- if (a >= 2 * (1 << FRAC_BITS)) {
- a = a >> 1;
- eq++;
- }
-#endif
- *exp_ptr = eq;
- return a;
-}
-#endif
-
static av_cold int decode_init(AVCodecContext * avctx)
{
MPADecodeContext *s = avctx->priv_data;
int i, j, k;
s->avctx = avctx;
- s->apply_window_mp3 = apply_window_mp3_c;
+
+ ff_mpadsp_init(&s->mpadsp);
avctx->sample_fmt= OUT_FMT;
s->error_recognition= avctx->error_recognition;
scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
- dprintf(avctx, "%d: norm=%x s=%x %x %x\n",
+ av_dlog(avctx, "%d: norm=%x s=%x %x %x\n",
i, norm,
scale_factor_mult[i][0],
scale_factor_mult[i][1],
/* compute n ^ (4/3) and store it in mantissa/exp format */
- int_pow_init();
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;
k = i & 1;
is_table_lsf[j][k ^ 1][i] = FIXR(f);
is_table_lsf[j][k][i] = FIXR(1.0);
- dprintf(avctx, "is_table_lsf %d %d: %x %x\n",
- i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);
+ av_dlog(avctx, "is_table_lsf %d %d: %f %f\n",
+ i, j, (float) is_table_lsf[j][0][i],
+ (float) is_table_lsf[j][1][i]);
}
}
ci = ci_table[i];
cs = 1.0 / sqrt(1.0 + ci * ci);
ca = cs * ci;
+#if !CONFIG_FLOAT
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);
- csa_table_float[i][0] = cs;
- csa_table_float[i][1] = ca;
- csa_table_float[i][2] = ca + cs;
- csa_table_float[i][3] = ca - cs;
+#else
+ csa_table[i][0] = cs;
+ csa_table[i][1] = ca;
+ csa_table[i][2] = ca + cs;
+ csa_table[i][3] = ca - cs;
+#endif
}
/* compute mdct windows */
return 0;
}
-/* tab[i][j] = 1.0 / (2.0 * cos(pi*(2*k+1) / 2^(6 - j))) */
-
-/* cos(i*pi/64) */
-
-#define COS0_0 FIXHR(0.50060299823519630134/2)
-#define COS0_1 FIXHR(0.50547095989754365998/2)
-#define COS0_2 FIXHR(0.51544730992262454697/2)
-#define COS0_3 FIXHR(0.53104259108978417447/2)
-#define COS0_4 FIXHR(0.55310389603444452782/2)
-#define COS0_5 FIXHR(0.58293496820613387367/2)
-#define COS0_6 FIXHR(0.62250412303566481615/2)
-#define COS0_7 FIXHR(0.67480834145500574602/2)
-#define COS0_8 FIXHR(0.74453627100229844977/2)
-#define COS0_9 FIXHR(0.83934964541552703873/2)
-#define COS0_10 FIXHR(0.97256823786196069369/2)
-#define COS0_11 FIXHR(1.16943993343288495515/4)
-#define COS0_12 FIXHR(1.48416461631416627724/4)
-#define COS0_13 FIXHR(2.05778100995341155085/8)
-#define COS0_14 FIXHR(3.40760841846871878570/8)
-#define COS0_15 FIXHR(10.19000812354805681150/32)
-
-#define COS1_0 FIXHR(0.50241928618815570551/2)
-#define COS1_1 FIXHR(0.52249861493968888062/2)
-#define COS1_2 FIXHR(0.56694403481635770368/2)
-#define COS1_3 FIXHR(0.64682178335999012954/2)
-#define COS1_4 FIXHR(0.78815462345125022473/2)
-#define COS1_5 FIXHR(1.06067768599034747134/4)
-#define COS1_6 FIXHR(1.72244709823833392782/4)
-#define COS1_7 FIXHR(5.10114861868916385802/16)
-
-#define COS2_0 FIXHR(0.50979557910415916894/2)
-#define COS2_1 FIXHR(0.60134488693504528054/2)
-#define COS2_2 FIXHR(0.89997622313641570463/2)
-#define COS2_3 FIXHR(2.56291544774150617881/8)
-
-#define COS3_0 FIXHR(0.54119610014619698439/2)
-#define COS3_1 FIXHR(1.30656296487637652785/4)
-
-#define COS4_0 FIXHR(0.70710678118654752439/2)
-
-/* butterfly operator */
-#define BF(a, b, c, s)\
-{\
- tmp0 = val##a + val##b;\
- tmp1 = val##a - val##b;\
- val##a = tmp0;\
- val##b = MULH3(tmp1, c, 1<<(s));\
-}
-
-#define BF0(a, b, c, s)\
-{\
- tmp0 = tab[a] + tab[b];\
- tmp1 = tab[a] - tab[b];\
- val##a = tmp0;\
- val##b = MULH3(tmp1, c, 1<<(s));\
-}
-
-#define BF1(a, b, c, d)\
-{\
- BF(a, b, COS4_0, 1);\
- BF(c, d,-COS4_0, 1);\
- val##c += val##d;\
-}
-
-#define BF2(a, b, c, d)\
-{\
- BF(a, b, COS4_0, 1);\
- BF(c, d,-COS4_0, 1);\
- val##c += val##d;\
- val##a += val##c;\
- val##c += val##b;\
- val##b += val##d;\
-}
-
-#define ADD(a, b) val##a += val##b
-
-/* DCT32 without 1/sqrt(2) coef zero scaling. */
-static void dct32(INTFLOAT *out, const INTFLOAT *tab)
-{
- INTFLOAT tmp0, tmp1;
-
- INTFLOAT val0 , val1 , val2 , val3 , val4 , val5 , val6 , val7 ,
- val8 , val9 , val10, val11, val12, val13, val14, val15,
- val16, val17, val18, val19, val20, val21, val22, val23,
- val24, val25, val26, val27, val28, val29, val30, val31;
-
- /* pass 1 */
- BF0( 0, 31, COS0_0 , 1);
- BF0(15, 16, COS0_15, 5);
- /* pass 2 */
- BF( 0, 15, COS1_0 , 1);
- BF(16, 31,-COS1_0 , 1);
- /* pass 1 */
- BF0( 7, 24, COS0_7 , 1);
- BF0( 8, 23, COS0_8 , 1);
- /* pass 2 */
- BF( 7, 8, COS1_7 , 4);
- BF(23, 24,-COS1_7 , 4);
- /* pass 3 */
- BF( 0, 7, COS2_0 , 1);
- BF( 8, 15,-COS2_0 , 1);
- BF(16, 23, COS2_0 , 1);
- BF(24, 31,-COS2_0 , 1);
- /* pass 1 */
- BF0( 3, 28, COS0_3 , 1);
- BF0(12, 19, COS0_12, 2);
- /* pass 2 */
- BF( 3, 12, COS1_3 , 1);
- BF(19, 28,-COS1_3 , 1);
- /* pass 1 */
- BF0( 4, 27, COS0_4 , 1);
- BF0(11, 20, COS0_11, 2);
- /* pass 2 */
- BF( 4, 11, COS1_4 , 1);
- BF(20, 27,-COS1_4 , 1);
- /* pass 3 */
- BF( 3, 4, COS2_3 , 3);
- BF(11, 12,-COS2_3 , 3);
- BF(19, 20, COS2_3 , 3);
- BF(27, 28,-COS2_3 , 3);
- /* pass 4 */
- BF( 0, 3, COS3_0 , 1);
- BF( 4, 7,-COS3_0 , 1);
- BF( 8, 11, COS3_0 , 1);
- BF(12, 15,-COS3_0 , 1);
- BF(16, 19, COS3_0 , 1);
- BF(20, 23,-COS3_0 , 1);
- BF(24, 27, COS3_0 , 1);
- BF(28, 31,-COS3_0 , 1);
-
-
-
- /* pass 1 */
- BF0( 1, 30, COS0_1 , 1);
- BF0(14, 17, COS0_14, 3);
- /* pass 2 */
- BF( 1, 14, COS1_1 , 1);
- BF(17, 30,-COS1_1 , 1);
- /* pass 1 */
- BF0( 6, 25, COS0_6 , 1);
- BF0( 9, 22, COS0_9 , 1);
- /* pass 2 */
- BF( 6, 9, COS1_6 , 2);
- BF(22, 25,-COS1_6 , 2);
- /* pass 3 */
- BF( 1, 6, COS2_1 , 1);
- BF( 9, 14,-COS2_1 , 1);
- BF(17, 22, COS2_1 , 1);
- BF(25, 30,-COS2_1 , 1);
-
- /* pass 1 */
- BF0( 2, 29, COS0_2 , 1);
- BF0(13, 18, COS0_13, 3);
- /* pass 2 */
- BF( 2, 13, COS1_2 , 1);
- BF(18, 29,-COS1_2 , 1);
- /* pass 1 */
- BF0( 5, 26, COS0_5 , 1);
- BF0(10, 21, COS0_10, 1);
- /* pass 2 */
- BF( 5, 10, COS1_5 , 2);
- BF(21, 26,-COS1_5 , 2);
- /* pass 3 */
- BF( 2, 5, COS2_2 , 1);
- BF(10, 13,-COS2_2 , 1);
- BF(18, 21, COS2_2 , 1);
- BF(26, 29,-COS2_2 , 1);
- /* pass 4 */
- BF( 1, 2, COS3_1 , 2);
- BF( 5, 6,-COS3_1 , 2);
- BF( 9, 10, COS3_1 , 2);
- BF(13, 14,-COS3_1 , 2);
- BF(17, 18, COS3_1 , 2);
- BF(21, 22,-COS3_1 , 2);
- BF(25, 26, COS3_1 , 2);
- BF(29, 30,-COS3_1 , 2);
-
- /* pass 5 */
- BF1( 0, 1, 2, 3);
- BF2( 4, 5, 6, 7);
- BF1( 8, 9, 10, 11);
- BF2(12, 13, 14, 15);
- BF1(16, 17, 18, 19);
- BF2(20, 21, 22, 23);
- BF1(24, 25, 26, 27);
- BF2(28, 29, 30, 31);
-
- /* pass 6 */
-
- ADD( 8, 12);
- ADD(12, 10);
- ADD(10, 14);
- ADD(14, 9);
- ADD( 9, 13);
- ADD(13, 11);
- ADD(11, 15);
-
- out[ 0] = val0;
- out[16] = val1;
- out[ 8] = val2;
- out[24] = val3;
- out[ 4] = val4;
- out[20] = val5;
- out[12] = val6;
- out[28] = val7;
- out[ 2] = val8;
- out[18] = val9;
- out[10] = val10;
- out[26] = val11;
- out[ 6] = val12;
- out[22] = val13;
- out[14] = val14;
- out[30] = val15;
-
- ADD(24, 28);
- ADD(28, 26);
- ADD(26, 30);
- ADD(30, 25);
- ADD(25, 29);
- ADD(29, 27);
- ADD(27, 31);
-
- out[ 1] = val16 + val24;
- out[17] = val17 + val25;
- out[ 9] = val18 + val26;
- out[25] = val19 + val27;
- out[ 5] = val20 + val28;
- out[21] = val21 + val29;
- out[13] = val22 + val30;
- out[29] = val23 + val31;
- out[ 3] = val24 + val20;
- out[19] = val25 + val21;
- out[11] = val26 + val22;
- out[27] = val27 + val23;
- out[ 7] = val28 + val18;
- out[23] = val29 + val19;
- out[15] = val30 + val17;
- out[31] = val31;
-}
-
-#if CONFIG_FLOAT
-static inline float round_sample(float *sum)
-{
- float sum1=*sum;
- *sum = 0;
- return sum1;
-}
-
-/* signed 16x16 -> 32 multiply add accumulate */
-#define MACS(rt, ra, rb) rt+=(ra)*(rb)
-
-/* signed 16x16 -> 32 multiply */
-#define MULS(ra, rb) ((ra)*(rb))
-
-#define MLSS(rt, ra, rb) rt-=(ra)*(rb)
-
-#elif FRAC_BITS <= 15
-
-static inline int round_sample(int *sum)
-{
- int sum1;
- sum1 = (*sum) >> OUT_SHIFT;
- *sum &= (1<<OUT_SHIFT)-1;
- return av_clip(sum1, OUT_MIN, OUT_MAX);
-}
-
-/* signed 16x16 -> 32 multiply add accumulate */
-#define MACS(rt, ra, rb) MAC16(rt, ra, rb)
-
-/* signed 16x16 -> 32 multiply */
-#define MULS(ra, rb) MUL16(ra, rb)
-
-#define MLSS(rt, ra, rb) MLS16(rt, ra, rb)
-
-#else
-
-static inline int round_sample(int64_t *sum)
-{
- int sum1;
- sum1 = (int)((*sum) >> OUT_SHIFT);
- *sum &= (1<<OUT_SHIFT)-1;
- return av_clip(sum1, OUT_MIN, OUT_MAX);
-}
-
-# define MULS(ra, rb) MUL64(ra, rb)
-# define MACS(rt, ra, rb) MAC64(rt, ra, rb)
-# define MLSS(rt, ra, rb) MLS64(rt, ra, rb)
-#endif
-
-#define SUM8(op, sum, w, p) \
-{ \
- op(sum, (w)[0 * 64], (p)[0 * 64]); \
- op(sum, (w)[1 * 64], (p)[1 * 64]); \
- op(sum, (w)[2 * 64], (p)[2 * 64]); \
- op(sum, (w)[3 * 64], (p)[3 * 64]); \
- op(sum, (w)[4 * 64], (p)[4 * 64]); \
- op(sum, (w)[5 * 64], (p)[5 * 64]); \
- op(sum, (w)[6 * 64], (p)[6 * 64]); \
- op(sum, (w)[7 * 64], (p)[7 * 64]); \
-}
-
-#define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
-{ \
- INTFLOAT tmp;\
- tmp = p[0 * 64];\
- op1(sum1, (w1)[0 * 64], tmp);\
- op2(sum2, (w2)[0 * 64], tmp);\
- tmp = p[1 * 64];\
- op1(sum1, (w1)[1 * 64], tmp);\
- op2(sum2, (w2)[1 * 64], tmp);\
- tmp = p[2 * 64];\
- op1(sum1, (w1)[2 * 64], tmp);\
- op2(sum2, (w2)[2 * 64], tmp);\
- tmp = p[3 * 64];\
- op1(sum1, (w1)[3 * 64], tmp);\
- op2(sum2, (w2)[3 * 64], tmp);\
- tmp = p[4 * 64];\
- op1(sum1, (w1)[4 * 64], tmp);\
- op2(sum2, (w2)[4 * 64], tmp);\
- tmp = p[5 * 64];\
- op1(sum1, (w1)[5 * 64], tmp);\
- op2(sum2, (w2)[5 * 64], tmp);\
- tmp = p[6 * 64];\
- op1(sum1, (w1)[6 * 64], tmp);\
- op2(sum2, (w2)[6 * 64], tmp);\
- tmp = p[7 * 64];\
- op1(sum1, (w1)[7 * 64], tmp);\
- op2(sum2, (w2)[7 * 64], tmp);\
-}
-
-void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window)
-{
- int i;
-
- /* max = 18760, max sum over all 16 coefs : 44736 */
- for(i=0;i<257;i++) {
- INTFLOAT v;
- v = ff_mpa_enwindow[i];
-#if CONFIG_FLOAT
- v *= 1.0 / (1LL<<(16 + FRAC_BITS));
-#elif WFRAC_BITS < 16
- v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
-#endif
- window[i] = v;
- if ((i & 63) != 0)
- v = -v;
- if (i != 0)
- window[512 - i] = v;
- }
-}
-
-static void apply_window_mp3_c(MPA_INT *synth_buf, MPA_INT *window,
- int *dither_state, OUT_INT *samples, int incr)
-{
- register const MPA_INT *w, *w2, *p;
- int j;
- OUT_INT *samples2;
-#if CONFIG_FLOAT
- float sum, sum2;
-#elif FRAC_BITS <= 15
- int sum, sum2;
-#else
- int64_t sum, sum2;
-#endif
-
- /* copy to avoid wrap */
- memcpy(synth_buf + 512, synth_buf, 32 * sizeof(*synth_buf));
-
- samples2 = samples + 31 * incr;
- w = window;
- w2 = window + 31;
-
- sum = *dither_state;
- p = synth_buf + 16;
- SUM8(MACS, sum, w, p);
- p = synth_buf + 48;
- SUM8(MLSS, sum, w + 32, p);
- *samples = round_sample(&sum);
- samples += incr;
- w++;
-
- /* we calculate two samples at the same time to avoid one memory
- access per two sample */
- for(j=1;j<16;j++) {
- sum2 = 0;
- p = synth_buf + 16 + j;
- SUM8P2(sum, MACS, sum2, MLSS, w, w2, p);
- p = synth_buf + 48 - j;
- SUM8P2(sum, MLSS, sum2, MLSS, w + 32, w2 + 32, p);
-
- *samples = round_sample(&sum);
- samples += incr;
- sum += sum2;
- *samples2 = round_sample(&sum);
- samples2 -= incr;
- w++;
- w2--;
- }
-
- p = synth_buf + 32;
- SUM8(MLSS, sum, w + 32, p);
- *samples = round_sample(&sum);
- *dither_state= sum;
-}
-
-
-/* 32 sub band synthesis filter. Input: 32 sub band samples, Output:
- 32 samples. */
-/* XXX: optimize by avoiding ring buffer usage */
-#if !CONFIG_FLOAT
-void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset,
- MPA_INT *window, int *dither_state,
- OUT_INT *samples, int incr,
- INTFLOAT sb_samples[SBLIMIT])
-{
- register MPA_INT *synth_buf;
- int offset;
-#if FRAC_BITS <= 15
- int32_t tmp[32];
- int j;
-#endif
-
- offset = *synth_buf_offset;
- synth_buf = synth_buf_ptr + offset;
-
-#if FRAC_BITS <= 15
- dct32(tmp, sb_samples);
- for(j=0;j<32;j++) {
- /* NOTE: can cause a loss in precision if very high amplitude
- sound */
- synth_buf[j] = av_clip_int16(tmp[j]);
- }
-#else
- dct32(synth_buf, sb_samples);
-#endif
-
- apply_window_mp3_c(synth_buf, window, dither_state, samples, incr);
-
- offset = (offset - 32) & 511;
- *synth_buf_offset = offset;
-}
-#endif
-
#define C3 FIXHR(0.86602540378443864676/2)
/* 0.5 / cos(pi*(2*i+1)/36) */
else
bound = sblimit;
- dprintf(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
+ av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
/* sanity check */
if( bound > sblimit ) bound = sblimit;
qindex = alloc_table[j+b];
bits = ff_mpa_quant_bits[qindex];
if (bits < 0) {
+ int v2;
/* 3 values at the same time */
v = get_bits(&s->gb, -bits);
- steps = ff_mpa_quant_steps[qindex];
+ v2 = division_tabs[qindex][v];
+ steps = ff_mpa_quant_steps[qindex];
+
s->sb_samples[ch][k * 12 + l + 0][i] =
- l2_unscale_group(steps, v % steps, scale);
- v = v / steps;
+ l2_unscale_group(steps, v2 & 15, scale);
s->sb_samples[ch][k * 12 + l + 1][i] =
- l2_unscale_group(steps, v % steps, scale);
- v = v / steps;
+ l2_unscale_group(steps, (v2 >> 4) & 15, scale);
s->sb_samples[ch][k * 12 + l + 2][i] =
- l2_unscale_group(steps, v, scale);
+ l2_unscale_group(steps, v2 >> 8 , scale);
} else {
for(m=0;m<3;m++) {
v = get_bits(&s->gb, bits);
exponent= exponents[s_index];
- dprintf(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
+ av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
i, g->region_size[i] - j, x, y, exponent);
if(y&16){
x = y >> 5;
last_pos= pos;
code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
- dprintf(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
+ av_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]=
}
}
-static void compute_antialias_integer(MPADecodeContext *s,
- GranuleDef *g)
-{
- int32_t *ptr, *csa;
- int n, i;
-
- /* we antialias only "long" bands */
- if (g->block_type == 2) {
- if (!g->switch_point)
- return;
- /* XXX: check this for 8000Hz case */
- n = 1;
- } else {
- n = SBLIMIT - 1;
- }
-
- ptr = g->sb_hybrid + 18;
- for(i = n;i > 0;i--) {
- int tmp0, tmp1, tmp2;
- csa = &csa_table[0][0];
-#define INT_AA(j) \
- tmp0 = ptr[-1-j];\
- tmp1 = ptr[ j];\
- tmp2= MULH(tmp0 + tmp1, csa[0+4*j]);\
- ptr[-1-j] = 4*(tmp2 - MULH(tmp1, csa[2+4*j]));\
- ptr[ j] = 4*(tmp2 + MULH(tmp0, csa[3+4*j]));
-
- INT_AA(0)
- INT_AA(1)
- INT_AA(2)
- INT_AA(3)
- INT_AA(4)
- INT_AA(5)
- INT_AA(6)
- INT_AA(7)
-
- ptr += 18;
- }
-}
+#if CONFIG_FLOAT
+#define AA(j) do { \
+ float tmp0 = ptr[-1-j]; \
+ float tmp1 = ptr[ j]; \
+ ptr[-1-j] = tmp0 * csa_table[j][0] - tmp1 * csa_table[j][1]; \
+ ptr[ j] = tmp0 * csa_table[j][1] + tmp1 * csa_table[j][0]; \
+ } while (0)
+#else
+#define AA(j) do { \
+ int tmp0 = ptr[-1-j]; \
+ int tmp1 = ptr[ j]; \
+ int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]); \
+ ptr[-1-j] = 4*(tmp2 - MULH(tmp1, csa_table[j][2])); \
+ ptr[ j] = 4*(tmp2 + MULH(tmp0, csa_table[j][3])); \
+ } while (0)
+#endif
-static void compute_antialias_float(MPADecodeContext *s,
- GranuleDef *g)
+static void compute_antialias(MPADecodeContext *s, GranuleDef *g)
{
- float *ptr;
+ INTFLOAT *ptr;
int n, i;
/* we antialias only "long" bands */
ptr = g->sb_hybrid + 18;
for(i = n;i > 0;i--) {
- float tmp0, tmp1;
- float *csa = &csa_table_float[0][0];
-#define FLOAT_AA(j)\
- tmp0= ptr[-1-j];\
- tmp1= ptr[ j];\
- ptr[-1-j] = tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j];\
- ptr[ j] = tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j];
-
- FLOAT_AA(0)
- FLOAT_AA(1)
- FLOAT_AA(2)
- FLOAT_AA(3)
- FLOAT_AA(4)
- FLOAT_AA(5)
- FLOAT_AA(6)
- FLOAT_AA(7)
+ AA(0);
+ AA(1);
+ AA(2);
+ AA(3);
+ AA(4);
+ AA(5);
+ AA(6);
+ AA(7);
ptr += 18;
}
/* main layer3 decoding function */
static int mp_decode_layer3(MPADecodeContext *s)
{
- int nb_granules, main_data_begin, private_bits;
+ int nb_granules, main_data_begin;
int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
GranuleDef *g;
int16_t exponents[576]; //FIXME try INTFLOAT
/* read side info */
if (s->lsf) {
main_data_begin = get_bits(&s->gb, 8);
- private_bits = get_bits(&s->gb, s->nb_channels);
+ skip_bits(&s->gb, s->nb_channels);
nb_granules = 1;
} else {
main_data_begin = get_bits(&s->gb, 9);
if (s->nb_channels == 2)
- private_bits = get_bits(&s->gb, 3);
+ skip_bits(&s->gb, 3);
else
- private_bits = get_bits(&s->gb, 5);
+ skip_bits(&s->gb, 5);
nb_granules = 2;
for(ch=0;ch<s->nb_channels;ch++) {
s->granules[ch][0].scfsi = 0;/* all scale factors are transmitted */
for(gr=0;gr<nb_granules;gr++) {
for(ch=0;ch<s->nb_channels;ch++) {
- dprintf(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
+ av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
g = &s->granules[ch][gr];
g->part2_3_length = get_bits(&s->gb, 12);
g->big_values = get_bits(&s->gb, 9);
/* compute huffman coded region sizes */
region_address1 = get_bits(&s->gb, 4);
region_address2 = get_bits(&s->gb, 3);
- dprintf(s->avctx, "region1=%d region2=%d\n",
+ av_dlog(s->avctx, "region1=%d region2=%d\n",
region_address1, region_address2);
ff_init_long_region(s, g, region_address1, region_address2);
}
g->preflag = get_bits1(&s->gb);
g->scalefac_scale = get_bits1(&s->gb);
g->count1table_select = get_bits1(&s->gb);
- dprintf(s->avctx, "block_type=%d switch_point=%d\n",
+ av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
g->block_type, g->switch_point);
}
}
const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
assert((get_bits_count(&s->gb) & 7) == 0);
/* now we get bits from the main_data_begin offset */
- dprintf(s->avctx, "seekback: %d\n", main_data_begin);
+ av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
/* MPEG1 scale factors */
slen1 = slen_table[0][g->scalefac_compress];
slen2 = slen_table[1][g->scalefac_compress];
- dprintf(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
+ av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
if (g->block_type == 2) {
n = g->switch_point ? 17 : 18;
j = 0;
if (s->error_protection)
skip_bits(&s->gb, 16);
- dprintf(s->avctx, "frame %d:\n", s->frame_count);
+ av_dlog(s->avctx, "frame %d:\n", s->frame_count);
switch(s->layer) {
case 1:
s->avctx->frame_size = 384;
samples_ptr = samples + ch;
for(i=0;i<nb_frames;i++) {
RENAME(ff_mpa_synth_filter)(
-#if CONFIG_FLOAT
- s,
-#endif
+ &s->mpadsp,
s->synth_buf[ch], &(s->synth_buf_offset[ch]),
RENAME(ff_mpa_synth_window), &s->dither_state,
samples_ptr, s->nb_channels,
}
/* update codec info */
avctx->channels = s->nb_channels;
- avctx->bit_rate = s->bit_rate;
+ avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
+ if (!avctx->bit_rate)
+ avctx->bit_rate = s->bit_rate;
avctx->sub_id = s->layer;
if(*data_size < 1152*avctx->channels*sizeof(OUT_INT))
s->last_buf_size= 0;
}
-#if CONFIG_MP3ADU_DECODER
+#if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
static int decode_frame_adu(AVCodecContext * avctx,
void *data, int *data_size,
AVPacket *avpkt)
/* update codec info */
avctx->sample_rate = s->sample_rate;
avctx->channels = s->nb_channels;
- avctx->bit_rate = s->bit_rate;
+ if (!avctx->bit_rate)
+ avctx->bit_rate = s->bit_rate;
avctx->sub_id = s->layer;
s->frame_size = len;
*data_size = out_size;
return buf_size;
}
-#endif /* CONFIG_MP3ADU_DECODER */
+#endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
-#if CONFIG_MP3ON4_DECODER
+#if CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER
/**
* Context for MP3On4 decoder
int i;
for (i = 0; i < s->frames; i++)
- if (s->mp3decctx[i])
- av_free(s->mp3decctx[i]);
+ av_free(s->mp3decctx[i]);
return 0;
}
*data_size = out_size;
return buf_size;
}
-#endif /* CONFIG_MP3ON4_DECODER */
+#endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
#if !CONFIG_FLOAT
#if CONFIG_MP1_DECODER
-AVCodec mp1_decoder =
+AVCodec ff_mp1_decoder =
{
"mp1",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP2_DECODER
-AVCodec mp2_decoder =
+AVCodec ff_mp2_decoder =
{
"mp2",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3_DECODER
-AVCodec mp3_decoder =
+AVCodec ff_mp3_decoder =
{
"mp3",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ADU_DECODER
-AVCodec mp3adu_decoder =
+AVCodec ff_mp3adu_decoder =
{
"mp3adu",
AVMEDIA_TYPE_AUDIO,
};
#endif
#if CONFIG_MP3ON4_DECODER
-AVCodec mp3on4_decoder =
+AVCodec ff_mp3on4_decoder =
{
"mp3on4",
AVMEDIA_TYPE_AUDIO,
projects / ffmpeg / blobdiff