minimp3.h

/* LGPL Simple, Minimalistic, mp3 decoder based on minimp3
 *	©2017-2018 Yuichiro Nakada
 *
 * Basic usage:
 *
 * */

/*
 * MPEG Audio Layer III decoder
 * Copyright (c) 2001, 2002 Fabrice Bellard,
 *           (c) 2007 Martin J. Fiedler
 *
 * This file is a stripped-down version of the MPEG Audio decoder from
 * the FFmpeg libavcodec library.
 *
 * FFmpeg and minimp3 are 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 and minimp3 are 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
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#define INLINE inline
#define FASTCALL __attribute__((fastcall))
#include <math.h>

#define MP3_MAX_SAMPLES_PER_FRAME (1152*2)
typedef struct _mp3_info {
	int sample_rate;
	int channels;
	int audio_bytes;  // generated amount of audio per frame
} mp3_info_t;
typedef void* mp3_decoder_t;
extern mp3_decoder_t mp3_create(void);
extern int mp3_decode(mp3_decoder_t *dec, void *buf, int bytes, signed short *out, mp3_info_t *info);
extern void mp3_done(mp3_decoder_t *dec);
#define mp3_free(dec) do { mp3_done(dec); dec = NULL; } while(0)
size_t strlen(const char *s);
#define out(text) write(1, (const void *) text, strlen(text))

#define MP3_FRAME_SIZE 1152
#define MP3_MAX_CODED_FRAME_SIZE 1792
#define MP3_MAX_CHANNELS 2
#define SBLIMIT 32

#define MP3_STEREO  0
#define MP3_JSTEREO 1
#define MP3_DUAL    2
#define MP3_MONO    3

#define SAME_HEADER_MASK \
   (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))

#define FRAC_BITS   15
#define WFRAC_BITS  14

#define OUT_MAX (32767)
#define OUT_MIN (-32768)
#define OUT_SHIFT (WFRAC_BITS + FRAC_BITS - 15)

#define MODE_EXT_MS_STEREO 2
#define MODE_EXT_I_STEREO  1

#define FRAC_ONE    (1 << FRAC_BITS)
#define FIX(a)   ((int)((a) * FRAC_ONE))
#define FIXR(a)   ((int)((a) * FRAC_ONE + 0.5))
#define FRAC_RND(a) (((a) + (FRAC_ONE/2)) >> FRAC_BITS)
#define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5))

#ifndef _MSC_VER
#define MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
#define MULH(a,b) (((int64_t)(a) * (int64_t)(b)) >> 32)
#else
static INLINE int MULL(int a, int b)
{
	int res;
	__asm {
		mov eax, a
		imul b
		shr eax, 15
		shl edx, 17
		or eax, edx
		mov res, eax
	}
	return res;
}
static INLINE int MULH(int a, int b)
{
	int res;
	__asm {
		mov eax, a
		imul b
		mov res, edx
	}
	return res;
}
#endif
#define MULS(ra, rb) ((ra) * (rb))

#define ISQRT2 FIXR(0.70710678118654752440)

#define HEADER_SIZE 4
#define BACKSTEP_SIZE 512
#define EXTRABYTES 24

#define VLC_TYPE int16_t

////////////////////////////////////////////////////////////////////////////////

struct _granule;

typedef struct _bitstream {
	const uint8_t *buffer, *buffer_end;
	int index;
	int size_in_bits;
} bitstream_t;

typedef struct _vlc {
	int bits;
	VLC_TYPE (*table)[2]; ///< code, bits
	int table_size, table_allocated;
} vlc_t;

typedef struct _mp3_context {
	uint8_t last_buf[2*BACKSTEP_SIZE + EXTRABYTES];
	int last_buf_size;
	int frame_size;
	uint32_t free_format_next_header;
	int error_protection;
	int sample_rate;
	int sample_rate_index;
	int bit_rate;
	bitstream_t gb;
	bitstream_t in_gb;
	int nb_channels;
	int mode;
	int mode_ext;
	int lsf;
	int16_t synth_buf[MP3_MAX_CHANNELS][512 * 2];
	int synth_buf_offset[MP3_MAX_CHANNELS];
	int32_t sb_samples[MP3_MAX_CHANNELS][36][SBLIMIT];
	int32_t mdct_buf[MP3_MAX_CHANNELS][SBLIMIT * 18];
	int dither_state;
} mp3_context_t;

typedef struct _granule {
	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];
	int preflag;
	int short_start, long_end;
	uint8_t scale_factors[40];
	int32_t sb_hybrid[SBLIMIT * 18];
} granule_t;

typedef struct _huff_table {
	int xsize;
	const uint8_t *bits;
	const uint16_t *codes;
} huff_table_t;

static vlc_t huff_vlc[16];
static vlc_t huff_quad_vlc[2];
static uint16_t band_index_long[9][23];
#define TABLE_4_3_SIZE (8191 + 16)*4
static int8_t  *table_4_3_exp;
static uint32_t *table_4_3_value;
static uint32_t exp_table[512];
static uint32_t expval_table[512][16];
static int32_t is_table[2][16];
static int32_t is_table_lsf[2][2][16];
static int32_t csa_table[8][4];
static float csa_table_float[8][4];
static int32_t mdct_win[8][36];
static int16_t window[512];

////////////////////////////////////////////////////////////////////////////////

static const uint16_t mp3_bitrate_tab[2][15] = {
	{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 },
	{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
};

static const uint16_t mp3_freq_tab[3] = { 44100, 48000, 32000 };

static const int32_t mp3_enwindow[257] = {
	0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,
	-2,    -2,    -2,    -3,    -3,    -4,    -4,    -5,
	-5,    -6,    -7,    -7,    -8,    -9,   -10,   -11,
	-13,   -14,   -16,   -17,   -19,   -21,   -24,   -26,
	-29,   -31,   -35,   -38,   -41,   -45,   -49,   -53,
	-58,   -63,   -68,   -73,   -79,   -85,   -91,   -97,
	-104,  -111,  -117,  -125,  -132,  -139,  -147,  -154,
	-161,  -169,  -176,  -183,  -190,  -196,  -202,  -208,
	213,   218,   222,   225,   227,   228,   228,   227,
	224,   221,   215,   208,   200,   189,   177,   163,
	146,   127,   106,    83,    57,    29,    -2,   -36,
	-72,  -111,  -153,  -197,  -244,  -294,  -347,  -401,
	-459,  -519,  -581,  -645,  -711,  -779,  -848,  -919,
	-991, -1064, -1137, -1210, -1283, -1356, -1428, -1498,
	-1567, -1634, -1698, -1759, -1817, -1870, -1919, -1962,
	-2001, -2032, -2057, -2075, -2085, -2087, -2080, -2063,
	2037,  2000,  1952,  1893,  1822,  1739,  1644,  1535,
	1414,  1280,  1131,   970,   794,   605,   402,   185,
	-45,  -288,  -545,  -814, -1095, -1388, -1692, -2006,
	-2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
	-5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597,
	-7910, -8209, -8491, -8755, -8998, -9219, -9416, -9585,
	-9727, -9838, -9916, -9959, -9966, -9935, -9863, -9750,
	-9592, -9389, -9139, -8840, -8492, -8092, -7640, -7134,
	6574,  5959,  5288,  4561,  3776,  2935,  2037,  1082,
	70,  -998, -2122, -3300, -4533, -5818, -7154, -8540,
	-9975,-11455,-12980,-14548,-16155,-17799,-19478,-21189,
	-22929,-24694,-26482,-28289,-30112,-31947,-33791,-35640,
	-37489,-39336,-41176,-43006,-44821,-46617,-48390,-50137,
	-51853,-53534,-55178,-56778,-58333,-59838,-61289,-62684,
	-64019,-65290,-66494,-67629,-68692,-69679,-70590,-71420,
	-72169,-72835,-73415,-73908,-74313,-74630,-74856,-74992,
	75038,
};

static const uint8_t slen_table[2][16] = {
	{ 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
	{ 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 },
};

static const uint8_t lsf_nsf_table[6][3][4] = {
	{ {  6,  5,  5, 5 }, {  9,  9,  9, 9 }, {  6,  9,  9, 9 } },
	{ {  6,  5,  7, 3 }, {  9,  9, 12, 6 }, {  6,  9, 12, 6 } },
	{ { 11, 10,  0, 0 }, { 18, 18,  0, 0 }, { 15, 18,  0, 0 } },
	{ {  7,  7,  7, 0 }, { 12, 12, 12, 0 }, {  6, 15, 12, 0 } },
	{ {  6,  6,  6, 3 }, { 12,  9,  9, 6 }, {  6, 12,  9, 6 } },
	{ {  8,  8,  5, 0 }, { 15, 12,  9, 0 }, {  6, 18,  9, 0 } },
};

static const uint16_t mp3_huffcodes_1[4] = {
	0x0001, 0x0001, 0x0001, 0x0000,
};

static const uint8_t mp3_huffbits_1[4] = {
	1,  3,  2,  3,
};

static const uint16_t mp3_huffcodes_2[9] = {
	0x0001, 0x0002, 0x0001, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
	0x0000,
};

static const uint8_t mp3_huffbits_2[9] = {
	1,  3,  6,  3,  3,  5,  5,  5,
	6,
};

static const uint16_t mp3_huffcodes_3[9] = {
	0x0003, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0003, 0x0002,
	0x0000,
};

static const uint8_t mp3_huffbits_3[9] = {
	2,  2,  6,  3,  2,  5,  5,  5,
	6,
};

static const uint16_t mp3_huffcodes_5[16] = {
	0x0001, 0x0002, 0x0006, 0x0005, 0x0003, 0x0001, 0x0004, 0x0004,
	0x0007, 0x0005, 0x0007, 0x0001, 0x0006, 0x0001, 0x0001, 0x0000,
};

static const uint8_t mp3_huffbits_5[16] = {
	1,  3,  6,  7,  3,  3,  6,  7,
	6,  6,  7,  8,  7,  6,  7,  8,
};

static const uint16_t mp3_huffcodes_6[16] = {
	0x0007, 0x0003, 0x0005, 0x0001, 0x0006, 0x0002, 0x0003, 0x0002,
	0x0005, 0x0004, 0x0004, 0x0001, 0x0003, 0x0003, 0x0002, 0x0000,
};

static const uint8_t mp3_huffbits_6[16] = {
	3,  3,  5,  7,  3,  2,  4,  5,
	4,  4,  5,  6,  6,  5,  6,  7,
};

static const uint16_t mp3_huffcodes_7[36] = {
	0x0001, 0x0002, 0x000a, 0x0013, 0x0010, 0x000a, 0x0003, 0x0003,
	0x0007, 0x000a, 0x0005, 0x0003, 0x000b, 0x0004, 0x000d, 0x0011,
	0x0008, 0x0004, 0x000c, 0x000b, 0x0012, 0x000f, 0x000b, 0x0002,
	0x0007, 0x0006, 0x0009, 0x000e, 0x0003, 0x0001, 0x0006, 0x0004,
	0x0005, 0x0003, 0x0002, 0x0000,
};

static const uint8_t mp3_huffbits_7[36] = {
	1,  3,  6,  8,  8,  9,  3,  4,
	6,  7,  7,  8,  6,  5,  7,  8,
	8,  9,  7,  7,  8,  9,  9,  9,
	7,  7,  8,  9,  9, 10,  8,  8,
	9, 10, 10, 10,
};

static const uint16_t mp3_huffcodes_8[36] = {
	0x0003, 0x0004, 0x0006, 0x0012, 0x000c, 0x0005, 0x0005, 0x0001,
	0x0002, 0x0010, 0x0009, 0x0003, 0x0007, 0x0003, 0x0005, 0x000e,
	0x0007, 0x0003, 0x0013, 0x0011, 0x000f, 0x000d, 0x000a, 0x0004,
	0x000d, 0x0005, 0x0008, 0x000b, 0x0005, 0x0001, 0x000c, 0x0004,
	0x0004, 0x0001, 0x0001, 0x0000,
};

static const uint8_t mp3_huffbits_8[36] = {
	2,  3,  6,  8,  8,  9,  3,  2,
	4,  8,  8,  8,  6,  4,  6,  8,
	8,  9,  8,  8,  8,  9,  9, 10,
	8,  7,  8,  9, 10, 10,  9,  8,
	9,  9, 11, 11,
};

static const uint16_t mp3_huffcodes_9[36] = {
	0x0007, 0x0005, 0x0009, 0x000e, 0x000f, 0x0007, 0x0006, 0x0004,
	0x0005, 0x0005, 0x0006, 0x0007, 0x0007, 0x0006, 0x0008, 0x0008,
	0x0008, 0x0005, 0x000f, 0x0006, 0x0009, 0x000a, 0x0005, 0x0001,
	0x000b, 0x0007, 0x0009, 0x0006, 0x0004, 0x0001, 0x000e, 0x0004,
	0x0006, 0x0002, 0x0006, 0x0000,
};

static const uint8_t mp3_huffbits_9[36] = {
	3,  3,  5,  6,  8,  9,  3,  3,
	4,  5,  6,  8,  4,  4,  5,  6,
	7,  8,  6,  5,  6,  7,  7,  8,
	7,  6,  7,  7,  8,  9,  8,  7,
	8,  8,  9,  9,
};

static const uint16_t mp3_huffcodes_10[64] = {
	0x0001, 0x0002, 0x000a, 0x0017, 0x0023, 0x001e, 0x000c, 0x0011,
	0x0003, 0x0003, 0x0008, 0x000c, 0x0012, 0x0015, 0x000c, 0x0007,
	0x000b, 0x0009, 0x000f, 0x0015, 0x0020, 0x0028, 0x0013, 0x0006,
	0x000e, 0x000d, 0x0016, 0x0022, 0x002e, 0x0017, 0x0012, 0x0007,
	0x0014, 0x0013, 0x0021, 0x002f, 0x001b, 0x0016, 0x0009, 0x0003,
	0x001f, 0x0016, 0x0029, 0x001a, 0x0015, 0x0014, 0x0005, 0x0003,
	0x000e, 0x000d, 0x000a, 0x000b, 0x0010, 0x0006, 0x0005, 0x0001,
	0x0009, 0x0008, 0x0007, 0x0008, 0x0004, 0x0004, 0x0002, 0x0000,
};

static const uint8_t mp3_huffbits_10[64] = {
	1,  3,  6,  8,  9,  9,  9, 10,
	3,  4,  6,  7,  8,  9,  8,  8,
	6,  6,  7,  8,  9, 10,  9,  9,
	7,  7,  8,  9, 10, 10,  9, 10,
	8,  8,  9, 10, 10, 10, 10, 10,
	9,  9, 10, 10, 11, 11, 10, 11,
	8,  8,  9, 10, 10, 10, 11, 11,
	9,  8,  9, 10, 10, 11, 11, 11,
};

static const uint16_t mp3_huffcodes_11[64] = {
	0x0003, 0x0004, 0x000a, 0x0018, 0x0022, 0x0021, 0x0015, 0x000f,
	0x0005, 0x0003, 0x0004, 0x000a, 0x0020, 0x0011, 0x000b, 0x000a,
	0x000b, 0x0007, 0x000d, 0x0012, 0x001e, 0x001f, 0x0014, 0x0005,
	0x0019, 0x000b, 0x0013, 0x003b, 0x001b, 0x0012, 0x000c, 0x0005,
	0x0023, 0x0021, 0x001f, 0x003a, 0x001e, 0x0010, 0x0007, 0x0005,
	0x001c, 0x001a, 0x0020, 0x0013, 0x0011, 0x000f, 0x0008, 0x000e,
	0x000e, 0x000c, 0x0009, 0x000d, 0x000e, 0x0009, 0x0004, 0x0001,
	0x000b, 0x0004, 0x0006, 0x0006, 0x0006, 0x0003, 0x0002, 0x0000,
};

static const uint8_t mp3_huffbits_11[64] = {
	2,  3,  5,  7,  8,  9,  8,  9,
	3,  3,  4,  6,  8,  8,  7,  8,
	5,  5,  6,  7,  8,  9,  8,  8,
	7,  6,  7,  9,  8, 10,  8,  9,
	8,  8,  8,  9,  9, 10,  9, 10,
	8,  8,  9, 10, 10, 11, 10, 11,
	8,  7,  7,  8,  9, 10, 10, 10,
	8,  7,  8,  9, 10, 10, 10, 10,
};

static const uint16_t mp3_huffcodes_12[64] = {
	0x0009, 0x0006, 0x0010, 0x0021, 0x0029, 0x0027, 0x0026, 0x001a,
	0x0007, 0x0005, 0x0006, 0x0009, 0x0017, 0x0010, 0x001a, 0x000b,
	0x0011, 0x0007, 0x000b, 0x000e, 0x0015, 0x001e, 0x000a, 0x0007,
	0x0011, 0x000a, 0x000f, 0x000c, 0x0012, 0x001c, 0x000e, 0x0005,
	0x0020, 0x000d, 0x0016, 0x0013, 0x0012, 0x0010, 0x0009, 0x0005,
	0x0028, 0x0011, 0x001f, 0x001d, 0x0011, 0x000d, 0x0004, 0x0002,
	0x001b, 0x000c, 0x000b, 0x000f, 0x000a, 0x0007, 0x0004, 0x0001,
	0x001b, 0x000c, 0x0008, 0x000c, 0x0006, 0x0003, 0x0001, 0x0000,
};

static const uint8_t mp3_huffbits_12[64] = {
	4,  3,  5,  7,  8,  9,  9,  9,
	3,  3,  4,  5,  7,  7,  8,  8,
	5,  4,  5,  6,  7,  8,  7,  8,
	6,  5,  6,  6,  7,  8,  8,  8,
	7,  6,  7,  7,  8,  8,  8,  9,
	8,  7,  8,  8,  8,  9,  8,  9,
	8,  7,  7,  8,  8,  9,  9, 10,
	9,  8,  8,  9,  9,  9,  9, 10,
};

static const uint16_t mp3_huffcodes_13[256] = {
	0x0001, 0x0005, 0x000e, 0x0015, 0x0022, 0x0033, 0x002e, 0x0047,
	0x002a, 0x0034, 0x0044, 0x0034, 0x0043, 0x002c, 0x002b, 0x0013,
	0x0003, 0x0004, 0x000c, 0x0013, 0x001f, 0x001a, 0x002c, 0x0021,
	0x001f, 0x0018, 0x0020, 0x0018, 0x001f, 0x0023, 0x0016, 0x000e,
	0x000f, 0x000d, 0x0017, 0x0024, 0x003b, 0x0031, 0x004d, 0x0041,
	0x001d, 0x0028, 0x001e, 0x0028, 0x001b, 0x0021, 0x002a, 0x0010,
	0x0016, 0x0014, 0x0025, 0x003d, 0x0038, 0x004f, 0x0049, 0x0040,
	0x002b, 0x004c, 0x0038, 0x0025, 0x001a, 0x001f, 0x0019, 0x000e,
	0x0023, 0x0010, 0x003c, 0x0039, 0x0061, 0x004b, 0x0072, 0x005b,
	0x0036, 0x0049, 0x0037, 0x0029, 0x0030, 0x0035, 0x0017, 0x0018,
	0x003a, 0x001b, 0x0032, 0x0060, 0x004c, 0x0046, 0x005d, 0x0054,
	0x004d, 0x003a, 0x004f, 0x001d, 0x004a, 0x0031, 0x0029, 0x0011,
	0x002f, 0x002d, 0x004e, 0x004a, 0x0073, 0x005e, 0x005a, 0x004f,
	0x0045, 0x0053, 0x0047, 0x0032, 0x003b, 0x0026, 0x0024, 0x000f,
	0x0048, 0x0022, 0x0038, 0x005f, 0x005c, 0x0055, 0x005b, 0x005a,
	0x0056, 0x0049, 0x004d, 0x0041, 0x0033, 0x002c, 0x002b, 0x002a,
	0x002b, 0x0014, 0x001e, 0x002c, 0x0037, 0x004e, 0x0048, 0x0057,
	0x004e, 0x003d, 0x002e, 0x0036, 0x0025, 0x001e, 0x0014, 0x0010,
	0x0035, 0x0019, 0x0029, 0x0025, 0x002c, 0x003b, 0x0036, 0x0051,
	0x0042, 0x004c, 0x0039, 0x0036, 0x0025, 0x0012, 0x0027, 0x000b,
	0x0023, 0x0021, 0x001f, 0x0039, 0x002a, 0x0052, 0x0048, 0x0050,
	0x002f, 0x003a, 0x0037, 0x0015, 0x0016, 0x001a, 0x0026, 0x0016,
	0x0035, 0x0019, 0x0017, 0x0026, 0x0046, 0x003c, 0x0033, 0x0024,
	0x0037, 0x001a, 0x0022, 0x0017, 0x001b, 0x000e, 0x0009, 0x0007,
	0x0022, 0x0020, 0x001c, 0x0027, 0x0031, 0x004b, 0x001e, 0x0034,
	0x0030, 0x0028, 0x0034, 0x001c, 0x0012, 0x0011, 0x0009, 0x0005,
	0x002d, 0x0015, 0x0022, 0x0040, 0x0038, 0x0032, 0x0031, 0x002d,
	0x001f, 0x0013, 0x000c, 0x000f, 0x000a, 0x0007, 0x0006, 0x0003,
	0x0030, 0x0017, 0x0014, 0x0027, 0x0024, 0x0023, 0x0035, 0x0015,
	0x0010, 0x0017, 0x000d, 0x000a, 0x0006, 0x0001, 0x0004, 0x0002,
	0x0010, 0x000f, 0x0011, 0x001b, 0x0019, 0x0014, 0x001d, 0x000b,
	0x0011, 0x000c, 0x0010, 0x0008, 0x0001, 0x0001, 0x0000, 0x0001,
};

static const uint8_t mp3_huffbits_13[256] = {
	1,  4,  6,  7,  8,  9,  9, 10,
	9, 10, 11, 11, 12, 12, 13, 13,
	3,  4,  6,  7,  8,  8,  9,  9,
	9,  9, 10, 10, 11, 12, 12, 12,
	6,  6,  7,  8,  9,  9, 10, 10,
	9, 10, 10, 11, 11, 12, 13, 13,
	7,  7,  8,  9,  9, 10, 10, 10,
	10, 11, 11, 11, 11, 12, 13, 13,
	8,  7,  9,  9, 10, 10, 11, 11,
	10, 11, 11, 12, 12, 13, 13, 14,
	9,  8,  9, 10, 10, 10, 11, 11,
	11, 11, 12, 11, 13, 13, 14, 14,
	9,  9, 10, 10, 11, 11, 11, 11,
	11, 12, 12, 12, 13, 13, 14, 14,
	10,  9, 10, 11, 11, 11, 12, 12,
	12, 12, 13, 13, 13, 14, 16, 16,
	9,  8,  9, 10, 10, 11, 11, 12,
	12, 12, 12, 13, 13, 14, 15, 15,
	10,  9, 10, 10, 11, 11, 11, 13,
	12, 13, 13, 14, 14, 14, 16, 15,
	10, 10, 10, 11, 11, 12, 12, 13,
	12, 13, 14, 13, 14, 15, 16, 17,
	11, 10, 10, 11, 12, 12, 12, 12,
	13, 13, 13, 14, 15, 15, 15, 16,
	11, 11, 11, 12, 12, 13, 12, 13,
	14, 14, 15, 15, 15, 16, 16, 16,
	12, 11, 12, 13, 13, 13, 14, 14,
	14, 14, 14, 15, 16, 15, 16, 16,
	13, 12, 12, 13, 13, 13, 15, 14,
	14, 17, 15, 15, 15, 17, 16, 16,
	12, 12, 13, 14, 14, 14, 15, 14,
	15, 15, 16, 16, 19, 18, 19, 16,
};

static const uint16_t mp3_huffcodes_15[256] = {
	0x0007, 0x000c, 0x0012, 0x0035, 0x002f, 0x004c, 0x007c, 0x006c,
	0x0059, 0x007b, 0x006c, 0x0077, 0x006b, 0x0051, 0x007a, 0x003f,
	0x000d, 0x0005, 0x0010, 0x001b, 0x002e, 0x0024, 0x003d, 0x0033,
	0x002a, 0x0046, 0x0034, 0x0053, 0x0041, 0x0029, 0x003b, 0x0024,
	0x0013, 0x0011, 0x000f, 0x0018, 0x0029, 0x0022, 0x003b, 0x0030,
	0x0028, 0x0040, 0x0032, 0x004e, 0x003e, 0x0050, 0x0038, 0x0021,
	0x001d, 0x001c, 0x0019, 0x002b, 0x0027, 0x003f, 0x0037, 0x005d,
	0x004c, 0x003b, 0x005d, 0x0048, 0x0036, 0x004b, 0x0032, 0x001d,
	0x0034, 0x0016, 0x002a, 0x0028, 0x0043, 0x0039, 0x005f, 0x004f,
	0x0048, 0x0039, 0x0059, 0x0045, 0x0031, 0x0042, 0x002e, 0x001b,
	0x004d, 0x0025, 0x0023, 0x0042, 0x003a, 0x0034, 0x005b, 0x004a,
	0x003e, 0x0030, 0x004f, 0x003f, 0x005a, 0x003e, 0x0028, 0x0026,
	0x007d, 0x0020, 0x003c, 0x0038, 0x0032, 0x005c, 0x004e, 0x0041,
	0x0037, 0x0057, 0x0047, 0x0033, 0x0049, 0x0033, 0x0046, 0x001e,
	0x006d, 0x0035, 0x0031, 0x005e, 0x0058, 0x004b, 0x0042, 0x007a,
	0x005b, 0x0049, 0x0038, 0x002a, 0x0040, 0x002c, 0x0015, 0x0019,
	0x005a, 0x002b, 0x0029, 0x004d, 0x0049, 0x003f, 0x0038, 0x005c,
	0x004d, 0x0042, 0x002f, 0x0043, 0x0030, 0x0035, 0x0024, 0x0014,
	0x0047, 0x0022, 0x0043, 0x003c, 0x003a, 0x0031, 0x0058, 0x004c,
	0x0043, 0x006a, 0x0047, 0x0036, 0x0026, 0x0027, 0x0017, 0x000f,
	0x006d, 0x0035, 0x0033, 0x002f, 0x005a, 0x0052, 0x003a, 0x0039,
	0x0030, 0x0048, 0x0039, 0x0029, 0x0017, 0x001b, 0x003e, 0x0009,
	0x0056, 0x002a, 0x0028, 0x0025, 0x0046, 0x0040, 0x0034, 0x002b,
	0x0046, 0x0037, 0x002a, 0x0019, 0x001d, 0x0012, 0x000b, 0x000b,
	0x0076, 0x0044, 0x001e, 0x0037, 0x0032, 0x002e, 0x004a, 0x0041,
	0x0031, 0x0027, 0x0018, 0x0010, 0x0016, 0x000d, 0x000e, 0x0007,
	0x005b, 0x002c, 0x0027, 0x0026, 0x0022, 0x003f, 0x0034, 0x002d,
	0x001f, 0x0034, 0x001c, 0x0013, 0x000e, 0x0008, 0x0009, 0x0003,
	0x007b, 0x003c, 0x003a, 0x0035, 0x002f, 0x002b, 0x0020, 0x0016,
	0x0025, 0x0018, 0x0011, 0x000c, 0x000f, 0x000a, 0x0002, 0x0001,
	0x0047, 0x0025, 0x0022, 0x001e, 0x001c, 0x0014, 0x0011, 0x001a,
	0x0015, 0x0010, 0x000a, 0x0006, 0x0008, 0x0006, 0x0002, 0x0000,
};

static const uint8_t mp3_huffbits_15[256] = {
	3,  4,  5,  7,  7,  8,  9,  9,
	9, 10, 10, 11, 11, 11, 12, 13,
	4,  3,  5,  6,  7,  7,  8,  8,
	8,  9,  9, 10, 10, 10, 11, 11,
	5,  5,  5,  6,  7,  7,  8,  8,
	8,  9,  9, 10, 10, 11, 11, 11,
	6,  6,  6,  7,  7,  8,  8,  9,
	9,  9, 10, 10, 10, 11, 11, 11,
	7,  6,  7,  7,  8,  8,  9,  9,
	9,  9, 10, 10, 10, 11, 11, 11,
	8,  7,  7,  8,  8,  8,  9,  9,
	9,  9, 10, 10, 11, 11, 11, 12,
	9,  7,  8,  8,  8,  9,  9,  9,
	9, 10, 10, 10, 11, 11, 12, 12,
	9,  8,  8,  9,  9,  9,  9, 10,
	10, 10, 10, 10, 11, 11, 11, 12,
	9,  8,  8,  9,  9,  9,  9, 10,
	10, 10, 10, 11, 11, 12, 12, 12,
	9,  8,  9,  9,  9,  9, 10, 10,
	10, 11, 11, 11, 11, 12, 12, 12,
	10,  9,  9,  9, 10, 10, 10, 10,
	10, 11, 11, 11, 11, 12, 13, 12,
	10,  9,  9,  9, 10, 10, 10, 10,
	11, 11, 11, 11, 12, 12, 12, 13,
	11, 10,  9, 10, 10, 10, 11, 11,
	11, 11, 11, 11, 12, 12, 13, 13,
	11, 10, 10, 10, 10, 11, 11, 11,
	11, 12, 12, 12, 12, 12, 13, 13,
	12, 11, 11, 11, 11, 11, 11, 11,
	12, 12, 12, 12, 13, 13, 12, 13,
	12, 11, 11, 11, 11, 11, 11, 12,
	12, 12, 12, 12, 13, 13, 13, 13,
};

static const uint16_t mp3_huffcodes_16[256] = {
	0x0001, 0x0005, 0x000e, 0x002c, 0x004a, 0x003f, 0x006e, 0x005d,
	0x00ac, 0x0095, 0x008a, 0x00f2, 0x00e1, 0x00c3, 0x0178, 0x0011,
	0x0003, 0x0004, 0x000c, 0x0014, 0x0023, 0x003e, 0x0035, 0x002f,
	0x0053, 0x004b, 0x0044, 0x0077, 0x00c9, 0x006b, 0x00cf, 0x0009,
	0x000f, 0x000d, 0x0017, 0x0026, 0x0043, 0x003a, 0x0067, 0x005a,
	0x00a1, 0x0048, 0x007f, 0x0075, 0x006e, 0x00d1, 0x00ce, 0x0010,
	0x002d, 0x0015, 0x0027, 0x0045, 0x0040, 0x0072, 0x0063, 0x0057,
	0x009e, 0x008c, 0x00fc, 0x00d4, 0x00c7, 0x0183, 0x016d, 0x001a,
	0x004b, 0x0024, 0x0044, 0x0041, 0x0073, 0x0065, 0x00b3, 0x00a4,
	0x009b, 0x0108, 0x00f6, 0x00e2, 0x018b, 0x017e, 0x016a, 0x0009,
	0x0042, 0x001e, 0x003b, 0x0038, 0x0066, 0x00b9, 0x00ad, 0x0109,
	0x008e, 0x00fd, 0x00e8, 0x0190, 0x0184, 0x017a, 0x01bd, 0x0010,
	0x006f, 0x0036, 0x0034, 0x0064, 0x00b8, 0x00b2, 0x00a0, 0x0085,
	0x0101, 0x00f4, 0x00e4, 0x00d9, 0x0181, 0x016e, 0x02cb, 0x000a,
	0x0062, 0x0030, 0x005b, 0x0058, 0x00a5, 0x009d, 0x0094, 0x0105,
	0x00f8, 0x0197, 0x018d, 0x0174, 0x017c, 0x0379, 0x0374, 0x0008,
	0x0055, 0x0054, 0x0051, 0x009f, 0x009c, 0x008f, 0x0104, 0x00f9,
	0x01ab, 0x0191, 0x0188, 0x017f, 0x02d7, 0x02c9, 0x02c4, 0x0007,
	0x009a, 0x004c, 0x0049, 0x008d, 0x0083, 0x0100, 0x00f5, 0x01aa,
	0x0196, 0x018a, 0x0180, 0x02df, 0x0167, 0x02c6, 0x0160, 0x000b,
	0x008b, 0x0081, 0x0043, 0x007d, 0x00f7, 0x00e9, 0x00e5, 0x00db,
	0x0189, 0x02e7, 0x02e1, 0x02d0, 0x0375, 0x0372, 0x01b7, 0x0004,
	0x00f3, 0x0078, 0x0076, 0x0073, 0x00e3, 0x00df, 0x018c, 0x02ea,
	0x02e6, 0x02e0, 0x02d1, 0x02c8, 0x02c2, 0x00df, 0x01b4, 0x0006,
	0x00ca, 0x00e0, 0x00de, 0x00da, 0x00d8, 0x0185, 0x0182, 0x017d,
	0x016c, 0x0378, 0x01bb, 0x02c3, 0x01b8, 0x01b5, 0x06c0, 0x0004,
	0x02eb, 0x00d3, 0x00d2, 0x00d0, 0x0172, 0x017b, 0x02de, 0x02d3,
	0x02ca, 0x06c7, 0x0373, 0x036d, 0x036c, 0x0d83, 0x0361, 0x0002,
	0x0179, 0x0171, 0x0066, 0x00bb, 0x02d6, 0x02d2, 0x0166, 0x02c7,
	0x02c5, 0x0362, 0x06c6, 0x0367, 0x0d82, 0x0366, 0x01b2, 0x0000,
	0x000c, 0x000a, 0x0007, 0x000b, 0x000a, 0x0011, 0x000b, 0x0009,
	0x000d, 0x000c, 0x000a, 0x0007, 0x0005, 0x0003, 0x0001, 0x0003,
};

static const uint8_t mp3_huffbits_16[256] = {
	1,  4,  6,  8,  9,  9, 10, 10,
	11, 11, 11, 12, 12, 12, 13,  9,
	3,  4,  6,  7,  8,  9,  9,  9,
	10, 10, 10, 11, 12, 11, 12,  8,
	6,  6,  7,  8,  9,  9, 10, 10,
	11, 10, 11, 11, 11, 12, 12,  9,
	8,  7,  8,  9,  9, 10, 10, 10,
	11, 11, 12, 12, 12, 13, 13, 10,
	9,  8,  9,  9, 10, 10, 11, 11,
	11, 12, 12, 12, 13, 13, 13,  9,
	9,  8,  9,  9, 10, 11, 11, 12,
	11, 12, 12, 13, 13, 13, 14, 10,
	10,  9,  9, 10, 11, 11, 11, 11,
	12, 12, 12, 12, 13, 13, 14, 10,
	10,  9, 10, 10, 11, 11, 11, 12,
	12, 13, 13, 13, 13, 15, 15, 10,
	10, 10, 10, 11, 11, 11, 12, 12,
	13, 13, 13, 13, 14, 14, 14, 10,
	11, 10, 10, 11, 11, 12, 12, 13,
	13, 13, 13, 14, 13, 14, 13, 11,
	11, 11, 10, 11, 12, 12, 12, 12,
	13, 14, 14, 14, 15, 15, 14, 10,
	12, 11, 11, 11, 12, 12, 13, 14,
	14, 14, 14, 14, 14, 13, 14, 11,
	12, 12, 12, 12, 12, 13, 13, 13,
	13, 15, 14, 14, 14, 14, 16, 11,
	14, 12, 12, 12, 13, 13, 14, 14,
	14, 16, 15, 15, 15, 17, 15, 11,
	13, 13, 11, 12, 14, 14, 13, 14,
	14, 15, 16, 15, 17, 15, 14, 11,
	9,  8,  8,  9,  9, 10, 10, 10,
	11, 11, 11, 11, 11, 11, 11,  8,
};

static const uint16_t mp3_huffcodes_24[256] = {
	0x000f, 0x000d, 0x002e, 0x0050, 0x0092, 0x0106, 0x00f8, 0x01b2,
	0x01aa, 0x029d, 0x028d, 0x0289, 0x026d, 0x0205, 0x0408, 0x0058,
	0x000e, 0x000c, 0x0015, 0x0026, 0x0047, 0x0082, 0x007a, 0x00d8,
	0x00d1, 0x00c6, 0x0147, 0x0159, 0x013f, 0x0129, 0x0117, 0x002a,
	0x002f, 0x0016, 0x0029, 0x004a, 0x0044, 0x0080, 0x0078, 0x00dd,
	0x00cf, 0x00c2, 0x00b6, 0x0154, 0x013b, 0x0127, 0x021d, 0x0012,
	0x0051, 0x0027, 0x004b, 0x0046, 0x0086, 0x007d, 0x0074, 0x00dc,
	0x00cc, 0x00be, 0x00b2, 0x0145, 0x0137, 0x0125, 0x010f, 0x0010,
	0x0093, 0x0048, 0x0045, 0x0087, 0x007f, 0x0076, 0x0070, 0x00d2,
	0x00c8, 0x00bc, 0x0160, 0x0143, 0x0132, 0x011d, 0x021c, 0x000e,
	0x0107, 0x0042, 0x0081, 0x007e, 0x0077, 0x0072, 0x00d6, 0x00ca,
	0x00c0, 0x00b4, 0x0155, 0x013d, 0x012d, 0x0119, 0x0106, 0x000c,
	0x00f9, 0x007b, 0x0079, 0x0075, 0x0071, 0x00d7, 0x00ce, 0x00c3,
	0x00b9, 0x015b, 0x014a, 0x0134, 0x0123, 0x0110, 0x0208, 0x000a,
	0x01b3, 0x0073, 0x006f, 0x006d, 0x00d3, 0x00cb, 0x00c4, 0x00bb,
	0x0161, 0x014c, 0x0139, 0x012a, 0x011b, 0x0213, 0x017d, 0x0011,
	0x01ab, 0x00d4, 0x00d0, 0x00cd, 0x00c9, 0x00c1, 0x00ba, 0x00b1,
	0x00a9, 0x0140, 0x012f, 0x011e, 0x010c, 0x0202, 0x0179, 0x0010,
	0x014f, 0x00c7, 0x00c5, 0x00bf, 0x00bd, 0x00b5, 0x00ae, 0x014d,
	0x0141, 0x0131, 0x0121, 0x0113, 0x0209, 0x017b, 0x0173, 0x000b,
	0x029c, 0x00b8, 0x00b7, 0x00b3, 0x00af, 0x0158, 0x014b, 0x013a,
	0x0130, 0x0122, 0x0115, 0x0212, 0x017f, 0x0175, 0x016e, 0x000a,
	0x028c, 0x015a, 0x00ab, 0x00a8, 0x00a4, 0x013e, 0x0135, 0x012b,
	0x011f, 0x0114, 0x0107, 0x0201, 0x0177, 0x0170, 0x016a, 0x0006,
	0x0288, 0x0142, 0x013c, 0x0138, 0x0133, 0x012e, 0x0124, 0x011c,
	0x010d, 0x0105, 0x0200, 0x0178, 0x0172, 0x016c, 0x0167, 0x0004,
	0x026c, 0x012c, 0x0128, 0x0126, 0x0120, 0x011a, 0x0111, 0x010a,
	0x0203, 0x017c, 0x0176, 0x0171, 0x016d, 0x0169, 0x0165, 0x0002,
	0x0409, 0x0118, 0x0116, 0x0112, 0x010b, 0x0108, 0x0103, 0x017e,
	0x017a, 0x0174, 0x016f, 0x016b, 0x0168, 0x0166, 0x0164, 0x0000,
	0x002b, 0x0014, 0x0013, 0x0011, 0x000f, 0x000d, 0x000b, 0x0009,
	0x0007, 0x0006, 0x0004, 0x0007, 0x0005, 0x0003, 0x0001, 0x0003,
};

static const uint8_t mp3_huffbits_24[256] = {
	4,  4,  6,  7,  8,  9,  9, 10,
	10, 11, 11, 11, 11, 11, 12,  9,
	4,  4,  5,  6,  7,  8,  8,  9,
	9,  9, 10, 10, 10, 10, 10,  8,
	6,  5,  6,  7,  7,  8,  8,  9,
	9,  9,  9, 10, 10, 10, 11,  7,
	7,  6,  7,  7,  8,  8,  8,  9,
	9,  9,  9, 10, 10, 10, 10,  7,
	8,  7,  7,  8,  8,  8,  8,  9,
	9,  9, 10, 10, 10, 10, 11,  7,
	9,  7,  8,  8,  8,  8,  9,  9,
	9,  9, 10, 10, 10, 10, 10,  7,
	9,  8,  8,  8,  8,  9,  9,  9,
	9, 10, 10, 10, 10, 10, 11,  7,
	10,  8,  8,  8,  9,  9,  9,  9,
	10, 10, 10, 10, 10, 11, 11,  8,
	10,  9,  9,  9,  9,  9,  9,  9,
	9, 10, 10, 10, 10, 11, 11,  8,
	10,  9,  9,  9,  9,  9,  9, 10,
	10, 10, 10, 10, 11, 11, 11,  8,
	11,  9,  9,  9,  9, 10, 10, 10,
	10, 10, 10, 11, 11, 11, 11,  8,
	11, 10,  9,  9,  9, 10, 10, 10,
	10, 10, 10, 11, 11, 11, 11,  8,
	11, 10, 10, 10, 10, 10, 10, 10,
	10, 10, 11, 11, 11, 11, 11,  8,
	11, 10, 10, 10, 10, 10, 10, 10,
	11, 11, 11, 11, 11, 11, 11,  8,
	12, 10, 10, 10, 10, 10, 10, 11,
	11, 11, 11, 11, 11, 11, 11,  8,
	8,  7,  7,  7,  7,  7,  7,  7,
	7,  7,  7,  8,  8,  8,  8,  4,
};

static const huff_table_t mp3_huff_tables[16] = {
	{ 1, NULL, NULL },
	{ 2, mp3_huffbits_1, mp3_huffcodes_1 },
	{ 3, mp3_huffbits_2, mp3_huffcodes_2 },
	{ 3, mp3_huffbits_3, mp3_huffcodes_3 },
	{ 4, mp3_huffbits_5, mp3_huffcodes_5 },
	{ 4, mp3_huffbits_6, mp3_huffcodes_6 },
	{ 6, mp3_huffbits_7, mp3_huffcodes_7 },
	{ 6, mp3_huffbits_8, mp3_huffcodes_8 },
	{ 6, mp3_huffbits_9, mp3_huffcodes_9 },
	{ 8, mp3_huffbits_10, mp3_huffcodes_10 },
	{ 8, mp3_huffbits_11, mp3_huffcodes_11 },
	{ 8, mp3_huffbits_12, mp3_huffcodes_12 },
	{ 16, mp3_huffbits_13, mp3_huffcodes_13 },
	{ 16, mp3_huffbits_15, mp3_huffcodes_15 },
	{ 16, mp3_huffbits_16, mp3_huffcodes_16 },
	{ 16, mp3_huffbits_24, mp3_huffcodes_24 },
};

static const uint8_t mp3_huff_data[32][2] = {
	{ 0, 0 },
	{ 1, 0 },
	{ 2, 0 },
	{ 3, 0 },
	{ 0, 0 },
	{ 4, 0 },
	{ 5, 0 },
	{ 6, 0 },
	{ 7, 0 },
	{ 8, 0 },
	{ 9, 0 },
	{ 10, 0 },
	{ 11, 0 },
	{ 12, 0 },
	{ 0, 0 },
	{ 13, 0 },
	{ 14, 1 },
	{ 14, 2 },
	{ 14, 3 },
	{ 14, 4 },
	{ 14, 6 },
	{ 14, 8 },
	{ 14, 10 },
	{ 14, 13 },
	{ 15, 4 },
	{ 15, 5 },
	{ 15, 6 },
	{ 15, 7 },
	{ 15, 8 },
	{ 15, 9 },
	{ 15, 11 },
	{ 15, 13 },
};

static const uint8_t mp3_quad_codes[2][16] = {
	{  1,  5,  4,  5,  6,  5,  4,  4, 7,  3,  6,  0,  7,  2,  3,  1, },
	{ 15, 14, 13, 12, 11, 10,  9,  8, 7,  6,  5,  4,  3,  2,  1,  0, },
};

static const uint8_t mp3_quad_bits[2][16] = {
	{ 1, 4, 4, 5, 4, 6, 5, 6, 4, 5, 5, 6, 5, 6, 6, 6, },
	{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, },
};

static const uint8_t band_size_long[9][22] = {
	{
		4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
		12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158,
	}, /* 44100 */
	{
		4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
		12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192,
	}, /* 48000 */
	{
		4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12,
		16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26,
	}, /* 32000 */
	{
		6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
		20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54,
	}, /* 22050 */
	{
		6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
		18, 22, 26, 32, 38, 46, 52, 64, 70, 76, 36,
	}, /* 24000 */
	{
		6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
		20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54,
	}, /* 16000 */
	{
		6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
		20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54,
	}, /* 11025 */
	{
		6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
		20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54,
	}, /* 12000 */
	{
		12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32,
		40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2,
	}, /* 8000 */
};

static const uint8_t band_size_short[9][13] = {
	{ 4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56, }, /* 44100 */
	{ 4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66, }, /* 48000 */
	{ 4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12, }, /* 32000 */
	{ 4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18, }, /* 22050 */
	{ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12, }, /* 24000 */
	{ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18, }, /* 16000 */
	{ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18, }, /* 11025 */
	{ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18, }, /* 12000 */
	{ 8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26, }, /* 8000 */
};

static const uint8_t mp3_pretab[2][22] = {
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 },
};

static const float ci_table[8] = {
	-0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f,
};

#define C1 FIXHR(0.98480775301220805936/2)
#define C2 FIXHR(0.93969262078590838405/2)
#define C3 FIXHR(0.86602540378443864676/2)
#define C4 FIXHR(0.76604444311897803520/2)
#define C5 FIXHR(0.64278760968653932632/2)
#define C6 FIXHR(0.5/2)
#define C7 FIXHR(0.34202014332566873304/2)
#define C8 FIXHR(0.17364817766693034885/2)

static const int icos36[9] = {
	FIXR(0.50190991877167369479),
	FIXR(0.51763809020504152469), //0
	FIXR(0.55168895948124587824),
	FIXR(0.61038729438072803416),
	FIXR(0.70710678118654752439), //1
	FIXR(0.87172339781054900991),
	FIXR(1.18310079157624925896),
	FIXR(1.93185165257813657349), //2
	FIXR(5.73685662283492756461),
};

static const int icos36h[9] = {
	FIXHR(0.50190991877167369479/2),
	FIXHR(0.51763809020504152469/2), //0
	FIXHR(0.55168895948124587824/2),
	FIXHR(0.61038729438072803416/2),
	FIXHR(0.70710678118654752439/2), //1
	FIXHR(0.87172339781054900991/2),
	FIXHR(1.18310079157624925896/4),
	FIXHR(1.93185165257813657349/4), //2
//    FIXHR(5.73685662283492756461),
};

////////////////////////////////////////////////////////////////////////////////

static INLINE int unaligned32_be(const uint8_t *p)
{
	return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);
}

#define MIN_CACHE_BITS 25

#define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
#define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))

#define OPEN_READER(name, gb) \
        int name##_index= (gb)->index;\
        int name##_cache= 0;\

#define CLOSE_READER(name, gb)\
        (gb)->index= name##_index;\

#define UPDATE_CACHE(name, gb)\
        name##_cache= unaligned32_be(&((gb)->buffer[name##_index>>3])) << (name##_index&0x07); \

#define SKIP_CACHE(name, gb, num)\
        name##_cache <<= (num);

#define SKIP_COUNTER(name, gb, num)\
        name##_index += (num);\

#define SKIP_BITS(name, gb, num)\
        {\
            SKIP_CACHE(name, gb, num)\
            SKIP_COUNTER(name, gb, num)\
        }\

#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
#define LAST_SKIP_CACHE(name, gb, num) ;

#define SHOW_UBITS(name, gb, num)\
        NEG_USR32(name##_cache, num)

#define SHOW_SBITS(name, gb, num)\
        NEG_SSR32(name##_cache, num)

#define GET_CACHE(name, gb)\
        ((uint32_t)name##_cache)

static INLINE int get_bits_count(bitstream_t *s)
{
	return s->index;
}

static INLINE void skip_bits_long(bitstream_t *s, int n)
{
	s->index += n;
}
#define skip_bits skip_bits_long

static void init_get_bits(bitstream_t *s, const uint8_t *buffer, int bit_size)
{
	int buffer_size= (bit_size+7)>>3;
	if (buffer_size < 0 || bit_size < 0) {
		buffer_size = bit_size = 0;
		buffer = NULL;
	}
	s->buffer= buffer;
	s->size_in_bits= bit_size;
	s->buffer_end= buffer + buffer_size;
	s->index=0;
}

static INLINE unsigned int _get_bits(bitstream_t *s, int n)
{
	register int tmp;
	OPEN_READER(re, s)
	UPDATE_CACHE(re, s)
	tmp= SHOW_UBITS(re, s, n);
	LAST_SKIP_BITS(re, s, n)
	CLOSE_READER(re, s)
	return tmp;
}

static INLINE int get_bitsz(bitstream_t *s, int n)
{
	if (n == 0) {
		return 0;
	} else {
		return _get_bits(s, n);
	}
}

static INLINE unsigned int get_bits1(bitstream_t *s)
{
	int index= s->index;
	uint8_t result= s->buffer[ index>>3 ];
	result<<= (index&0x07);
	result>>= 8 - 1;
	index++;
	s->index= index;
	return result;
}

static INLINE void align_get_bits(bitstream_t *s)
{
	int n= (-get_bits_count(s)) & 7;
	if (n) {
		skip_bits(s, n);
	}
}

#define GET_DATA(v, table, i, wrap, size) \
{\
    const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
    switch(size) {\
    case 1:\
        v = *(const uint8_t *)ptr;\
        break;\
    case 2:\
        v = *(const uint16_t *)ptr;\
        break;\
    default:\
        v = *(const uint32_t *)ptr;\
        break;\
    }\
}

static INLINE int alloc_table(vlc_t *vlc, int size)
{
	int index;
	index = vlc->table_size;
	vlc->table_size += size;
	if (vlc->table_size > vlc->table_allocated) {
		vlc->table_allocated += (1 << vlc->bits);
		vlc->table = realloc(vlc->table, sizeof(VLC_TYPE) * 2 * vlc->table_allocated);
		if (!vlc->table) {
			return -1;
		}
	}
	return index;
}

static int build_table(
        vlc_t *vlc, int table_nb_bits,
        int nb_codes,
        const void *bits, int bits_wrap, int bits_size,
        const void *codes, int codes_wrap, int codes_size,
        uint32_t code_prefix, int n_prefix
)
{
	int i, j, k, n, table_size, table_index, nb, n1, index, code_prefix2;
	uint32_t code;
	VLC_TYPE (*table)[2];

	table_size = 1 << table_nb_bits;
	table_index = alloc_table(vlc, table_size);
	if (table_index < 0) {
		return -1;
	}
	table = &vlc->table[table_index];

	for (i=0; i<table_size; i++) {
		table[i][1] = 0; //bits
		table[i][0] = -1; //codes
	}

	for (i=0; i<nb_codes; i++) {
		GET_DATA(n, bits, i, bits_wrap, bits_size);
		GET_DATA(code, codes, i, codes_wrap, codes_size);
		if (n <= 0) {
			continue;
		}
		n -= n_prefix;
		code_prefix2= code >> n;
		if (n > 0 && code_prefix2 == code_prefix) {
			if (n <= table_nb_bits) {
				j = (code << (table_nb_bits - n)) & (table_size - 1);
				nb = 1 << (table_nb_bits - n);
				for (k=0; k<nb; k++) {
					if (table[j][1] /*bits*/ != 0) {
						return -1;
					}
					table[j][1] = n; //bits
					table[j][0] = i; //code
					j++;
				}
			} else {
				n -= table_nb_bits;
				j = (code >> n) & ((1 << table_nb_bits) - 1);
				n1 = -table[j][1]; //bits
				if (n > n1) {
					n1 = n;
				}
				table[j][1] = -n1; //bits
			}
		}
	}
	for (i=0; i<table_size; i++) {
		n = table[i][1]; //bits
		if (n < 0) {
			n = -n;
			if (n > table_nb_bits) {
				n = table_nb_bits;
				table[i][1] = -n; //bits
			}
			index = build_table(vlc, n, nb_codes,
			                    bits, bits_wrap, bits_size,
			                    codes, codes_wrap, codes_size,
			                    (code_prefix << table_nb_bits) | i,
			                    n_prefix + table_nb_bits);
			if (index < 0) {
				return -1;
			}
			table = &vlc->table[table_index];
			table[i][0] = index; //code
		}
	}
	return table_index;
}

static INLINE int init_vlc(
        vlc_t *vlc, int nb_bits, int nb_codes,
        const void *bits, int bits_wrap, int bits_size,
        const void *codes, int codes_wrap, int codes_size
)
{
	vlc->bits = nb_bits;
	if (build_table(vlc, nb_bits, nb_codes,
	                bits, bits_wrap, bits_size,
	                codes, codes_wrap, codes_size,
	                0, 0) < 0) {
		free(vlc->table);
		return -1;
	}
	return 0;
}

#define GET_VLC(code, name, gb, table, bits, max_depth)\
{\
    int n, index, nb_bits;\
\
    index= SHOW_UBITS(name, gb, bits);\
    code = table[index][0];\
    n    = table[index][1];\
\
    if(max_depth > 1 && n < 0){\
        LAST_SKIP_BITS(name, gb, bits)\
        UPDATE_CACHE(name, gb)\
\
        nb_bits = -n;\
\
        index= SHOW_UBITS(name, gb, nb_bits) + code;\
        code = table[index][0];\
        n    = table[index][1];\
        if(max_depth > 2 && n < 0){\
            LAST_SKIP_BITS(name, gb, nb_bits)\
            UPDATE_CACHE(name, gb)\
\
            nb_bits = -n;\
\
            index= SHOW_UBITS(name, gb, nb_bits) + code;\
            code = table[index][0];\
            n    = table[index][1];\
        }\
    }\
    SKIP_BITS(name, gb, n)\
}

static INLINE int get_vlc2(bitstream_t *s, VLC_TYPE (*table)[2], int bits, int max_depth)
{
	int code;

	OPEN_READER(re, s)
	UPDATE_CACHE(re, s)

	GET_VLC(code, re, s, table, bits, max_depth)

	CLOSE_READER(re, s)
	return code;
}

static void switch_buffer(mp3_context_t *s, int *pos, int *end_pos, int *end_pos2)
{
	if (s->in_gb.buffer && *pos >= s->gb.size_in_bits) {
		s->gb= s->in_gb;
		s->in_gb.buffer=NULL;
		skip_bits_long(&s->gb, *pos - *end_pos);
		*end_pos2=
		        *end_pos= *end_pos2 + get_bits_count(&s->gb) - *pos;
		*pos= get_bits_count(&s->gb);
	}
}

////////////////////////////////////////////////////////////////////////////////

static INLINE int mp3_check_header(uint32_t header)
{
	/* header */
	if ((header & 0xffe00000) != 0xffe00000) {
		return -1;
	}
	/* layer check */
	if ((header & (3<<17)) != (1 << 17)) {
		return -1;
	}
	/* bit rate */
	if ((header & (0xf<<12)) == 0xf<<12) {
		return -1;
	}
	/* frequency */
	if ((header & (3<<10)) == 3<<10) {
		return -1;
	}
	return 0;
}


static void lsf_sf_expand(
        int *slen, int sf, int n1, int n2, int n3
)
{
	if (n3) {
		slen[3] = sf % n3;
		sf /= n3;
	} else {
		slen[3] = 0;
	}
	if (n2) {
		slen[2] = sf % n2;
		sf /= n2;
	} else {
		slen[2] = 0;
	}
	slen[1] = sf % n1;
	sf /= n1;
	slen[0] = sf;
}

static INLINE int l3_unscale(int value, int exponent)
{
	unsigned int m;
	int e;

	e = table_4_3_exp  [4*value + (exponent&3)];
	m = table_4_3_value[4*value + (exponent&3)];
	e -= (exponent >> 2);
	if (e > 31) {
		return 0;
	}
	m = (m + (1 << (e-1))) >> e;

	return m;
}

static INLINE int round_sample(int *sum)
{
	int sum1;
	sum1 = (*sum) >> OUT_SHIFT;
	*sum &= (1<<OUT_SHIFT)-1;
	if (sum1 < OUT_MIN) {
		sum1 = OUT_MIN;
	} else if (sum1 > OUT_MAX) {
		sum1 = OUT_MAX;
	}
	return sum1;
}

static void exponents_from_scale_factors(
        mp3_context_t *s, granule_t *g, int16_t *exponents
)
{
	const uint8_t *bstab, *pretab;
	int len, i, j, k, l, v0, shift, gain, gains[3];
	int16_t *exp_ptr;

	exp_ptr = exponents;
	gain = g->global_gain - 210;
	shift = g->scalefac_scale + 1;

	bstab = band_size_long[s->sample_rate_index];
	pretab = mp3_pretab[g->preflag];
	for (i=0; i<g->long_end; i++) {
		v0 = gain - ((g->scale_factors[i] + pretab[i]) << shift) + 400;
		len = bstab[i];
		for (j=len; j>0; j--) {
			*exp_ptr++ = v0;
		}
	}

	if (g->short_start < 13) {
		bstab = 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);
		k = g->long_end;
		for (i=g->short_start; i<13; i++) {
			len = bstab[i];
			for (l=0; l<3; l++) {
				v0 = gains[l] - (g->scale_factors[k++] << shift) + 400;
				for (j=len; j>0; j--) {
					*exp_ptr++ = v0;
				}
			}
		}
	}
}

static void reorder_block(mp3_context_t *s, granule_t *g)
{
	int i, j, len;
	int32_t *ptr, *dst, *ptr1;
	int32_t tmp[576];

	if (g->block_type != 2) {
		return;
	}

	if (g->switch_point) {
		if (s->sample_rate_index != 8) {
			ptr = g->sb_hybrid + 36;
		} else {
			ptr = g->sb_hybrid + 48;
		}
	} else {
		ptr = g->sb_hybrid;
	}

	for (i=g->short_start; i<13; i++) {
		len = band_size_short[s->sample_rate_index][i];
		ptr1 = ptr;
		dst = tmp;
		for (j=len; j>0; j--) {
			*dst++ = ptr[0*len];
			*dst++ = ptr[1*len];
			*dst++ = ptr[2*len];
			ptr++;
		}
		ptr+=2*len;
		memcpy(ptr1, tmp, len * 3 * sizeof(*ptr1));
	}
}

static void compute_antialias(mp3_context_t *s, granule_t *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;
	}
}

static void compute_stereo(
        mp3_context_t *s, granule_t *g0, granule_t *g1
)
{
	int i, j, k, l;
	int32_t v1, v2;
	int sf_max, tmp0, tmp1, sf, len, non_zero_found;
	int32_t (*is_tab)[16];
	int32_t *tab0, *tab1;
	int non_zero_found_short[3];

	if (s->mode_ext & MODE_EXT_I_STEREO) {
		if (!s->lsf) {
			is_tab = is_table;
			sf_max = 7;
		} else {
			is_tab = is_table_lsf[g1->scalefac_compress & 1];
			sf_max = 16;
		}

		tab0 = g0->sb_hybrid + 576;
		tab1 = g1->sb_hybrid + 576;

		non_zero_found_short[0] = 0;
		non_zero_found_short[1] = 0;
		non_zero_found_short[2] = 0;
		k = (13 - g1->short_start) * 3 + g1->long_end - 3;
		for (i = 12; i >= g1->short_start; i--) {
			/* for last band, use previous scale factor */
			if (i != 11) {
				k -= 3;
			}
			len = band_size_short[s->sample_rate_index][i];
			for (l=2; l>=0; l--) {
				tab0 -= len;
				tab1 -= len;
				if (!non_zero_found_short[l]) {
					/* test if non zero band. if so, stop doing i-stereo */
					for (j=0; j<len; j++) {
						if (tab1[j] != 0) {
							non_zero_found_short[l] = 1;
							goto found1;
						}
					}
					sf = g1->scale_factors[k + l];
					if (sf >= sf_max) {
						goto found1;
					}

					v1 = is_tab[0][sf];
					v2 = is_tab[1][sf];
					for (j=0; j<len; j++) {
						tmp0 = tab0[j];
						tab0[j] = MULL(tmp0, v1);
						tab1[j] = MULL(tmp0, v2);
					}
				} else {
found1:
					if (s->mode_ext & MODE_EXT_MS_STEREO) {
						/* lower part of the spectrum : do ms stereo
						   if enabled */
						for (j=0; j<len; j++) {
							tmp0 = tab0[j];
							tmp1 = tab1[j];
							tab0[j] = MULL(tmp0 + tmp1, ISQRT2);
							tab1[j] = MULL(tmp0 - tmp1, ISQRT2);
						}
					}
				}
			}
		}

		non_zero_found = non_zero_found_short[0] |
		                 non_zero_found_short[1] |
		                 non_zero_found_short[2];

		for (i = g1->long_end - 1; i >= 0; i--) {
			len = band_size_long[s->sample_rate_index][i];
			tab0 -= len;
			tab1 -= len;
			/* test if non zero band. if so, stop doing i-stereo */
			if (!non_zero_found) {
				for (j=0; j<len; j++) {
					if (tab1[j] != 0) {
						non_zero_found = 1;
						goto found2;
					}
				}
				/* for last band, use previous scale factor */
				k = (i == 21) ? 20 : i;
				sf = g1->scale_factors[k];
				if (sf >= sf_max) {
					goto found2;
				}
				v1 = is_tab[0][sf];
				v2 = is_tab[1][sf];
				for (j=0; j<len; j++) {
					tmp0 = tab0[j];
					tab0[j] = MULL(tmp0, v1);
					tab1[j] = MULL(tmp0, v2);
				}
			} else {
found2:
				if (s->mode_ext & MODE_EXT_MS_STEREO) {
					/* lower part of the spectrum : do ms stereo
					   if enabled */
					for (j=0; j<len; j++) {
						tmp0 = tab0[j];
						tmp1 = tab1[j];
						tab0[j] = MULL(tmp0 + tmp1, ISQRT2);
						tab1[j] = MULL(tmp0 - tmp1, ISQRT2);
					}
				}
			}
		}
	} else if (s->mode_ext & MODE_EXT_MS_STEREO) {
		/* ms stereo ONLY */
		/* NOTE: the 1/sqrt(2) normalization factor is included in the
		   global gain */
		tab0 = g0->sb_hybrid;
		tab1 = g1->sb_hybrid;
		for (i=0; i<576; i++) {
			tmp0 = tab0[i];
			tmp1 = tab1[i];
			tab0[i] = tmp0 + tmp1;
			tab1[i] = tmp0 - tmp1;
		}
	}
}

static int huffman_decode(
        mp3_context_t *s, granule_t *g, int16_t *exponents, int end_pos2
)
{
	int s_index;
	int i;
	int last_pos, bits_left;
	vlc_t *vlc;
	int end_pos= s->gb.size_in_bits;
	if (end_pos2 < end_pos) {
		end_pos = end_pos2;
	}

	/* low frequencies (called big values) */
	s_index = 0;
	for (i=0; i<3; i++) {
		int j, k, l, linbits;
		j = g->region_size[i];
		if (j == 0) {
			continue;
		}
		/* select vlc table */
		k = g->table_select[i];
		l = mp3_huff_data[k][0];
		linbits = mp3_huff_data[k][1];
		vlc = &huff_vlc[l];

		if (!l) {
			memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*2*j);
			s_index += 2*j;
			continue;
		}

		/* read huffcode and compute each couple */
		for (; j>0; j--) {
			int exponent, x, y, v;
			int pos= get_bits_count(&s->gb);

			if (pos >= end_pos) {
				switch_buffer(s, &pos, &end_pos, &end_pos2);
				if (pos >= end_pos) {
					break;
				}
			}
			y = get_vlc2(&s->gb, vlc->table, 7, 3);

			if (!y) {
				g->sb_hybrid[s_index  ] =
				        g->sb_hybrid[s_index+1] = 0;
				s_index += 2;
				continue;
			}

			exponent= exponents[s_index];

			if (y&16) {
				x = y >> 5;
				y = y & 0x0f;
				if (x < 15) {
					v = expval_table[ exponent ][ x ];
				} else {
					x += get_bitsz(&s->gb, linbits);
					v = l3_unscale(x, exponent);
				}
				if (get_bits1(&s->gb)) {
					v = -v;
				}
				g->sb_hybrid[s_index] = v;
				if (y < 15) {
					v = expval_table[ exponent ][ y ];
				} else {
					y += get_bitsz(&s->gb, linbits);
					v = l3_unscale(y, exponent);
				}
				if (get_bits1(&s->gb)) {
					v = -v;
				}
				g->sb_hybrid[s_index+1] = v;
			} else {
				x = y >> 5;
				y = y & 0x0f;
				x += y;
				if (x < 15) {
					v = expval_table[ exponent ][ x ];
				} else {
					x += get_bitsz(&s->gb, linbits);
					v = l3_unscale(x, exponent);
				}
				if (get_bits1(&s->gb)) {
					v = -v;
				}
				g->sb_hybrid[s_index+!!y] = v;
				g->sb_hybrid[s_index+ !y] = 0;
			}
			s_index+=2;
		}
	}

	/* high frequencies */
	vlc = &huff_quad_vlc[g->count1table_select];
	last_pos=0;
	while (s_index <= 572) {
		int pos, code;
		pos = get_bits_count(&s->gb);
		if (pos >= end_pos) {
			if (pos > end_pos2 && last_pos) {
				/* some encoders generate an incorrect size for this
				   part. We must go back into the data */
				s_index -= 4;
				skip_bits_long(&s->gb, last_pos - pos);
				break;
			}
			switch_buffer(s, &pos, &end_pos, &end_pos2);
			if (pos >= end_pos) {
				break;
			}
		}
		last_pos= pos;

		code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
		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) {
			const static int idxtab[16]= {3,3,2,2,1,1,1,1,0,0,0,0,0,0,0,0};
			int v;
			int pos= s_index+idxtab[code];
			code ^= 8>>idxtab[code];
			v = exp_table[ exponents[pos] ];
			if (get_bits1(&s->gb)) {
				v = -v;
			}
			g->sb_hybrid[pos] = v;
		}
		s_index+=4;
	}
	memset(&g->sb_hybrid[s_index], 0, sizeof(*g->sb_hybrid)*(576 - s_index));

	/* skip extension bits */
	bits_left = end_pos2 - get_bits_count(&s->gb);
	if (bits_left < 0) {
		return -1;
	}
	skip_bits_long(&s->gb, bits_left);

	i= get_bits_count(&s->gb);
	switch_buffer(s, &i, &end_pos, &end_pos2);

	return 0;
}

////////////////////////////////////////////////////////////////////////////////

static void imdct12(int *out, int *in)
{
	int in0, in1, in2, in3, in4, in5, t1, t2;

	in0= in[0*3];
	in1= in[1*3] + in[0*3];
	in2= in[2*3] + in[1*3];
	in3= in[3*3] + in[2*3];
	in4= in[4*3] + in[3*3];
	in5= in[5*3] + in[4*3];
	in5 += in3;
	in3 += in1;

	in2= MULH(2*in2, C3);
	in3= MULH(4*in3, C3);

	t1 = in0 - in4;
	t2 = MULH(2*(in1 - in5), icos36h[4]);

	out[ 7]=
	        out[10]= t1 + t2;
	out[ 1]=
	        out[ 4]= t1 - t2;

	in0 += in4>>1;
	in4 = in0 + in2;
	in5 += 2*in1;
	in1 = MULH(in5 + in3, icos36h[1]);
	out[ 8]=
	        out[ 9]= in4 + in1;
	out[ 2]=
	        out[ 3]= in4 - in1;

	in0 -= in2;
	in5 = MULH(2*(in5 - in3), icos36h[7]);
	out[ 0]=
	        out[ 5]= in0 - in5;
	out[ 6]=
	        out[11]= in0 + in5;
}

static void imdct36(int *out, int *buf, int *in, int *win)
{
	int i, j, t0, t1, t2, t3, s0, s1, s2, s3;
	int tmp[18], *tmp1, *in1;

	for (i=17; i>=1; i--) {
		in[i] += in[i-1];
	}
	for (i=17; i>=3; i-=2) {
		in[i] += in[i-2];
	}

	for (j=0; j<2; j++) {
		tmp1 = tmp + j;
		in1 = in + j;
		t2 = in1[2*4] + in1[2*8] - in1[2*2];

		t3 = in1[2*0] + (in1[2*6]>>1);
		t1 = in1[2*0] - in1[2*6];
		tmp1[ 6] = t1 - (t2>>1);
		tmp1[16] = t1 + t2;

		t0 = MULH(2*(in1[2*2] + in1[2*4]),    C2);
		t1 = MULH(   in1[2*4] - in1[2*8] , -2*C8);
		t2 = MULH(2*(in1[2*2] + in1[2*8]),   -C4);

		tmp1[10] = t3 - t0 - t2;
		tmp1[ 2] = t3 + t0 + t1;
		tmp1[14] = t3 + t2 - t1;

		tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);
		t2 = MULH(2*(in1[2*1] + in1[2*5]),    C1);
		t3 = MULH(   in1[2*5] - in1[2*7] , -2*C7);
		t0 = MULH(2*in1[2*3], C3);

		t1 = MULH(2*(in1[2*1] + in1[2*7]),   -C5);

		tmp1[ 0] = t2 + t3 + t0;
		tmp1[12] = t2 + t1 - t0;
		tmp1[ 8] = t3 - t1 - t0;
	}

	i = 0;
	for (j=0; j<4; j++) {
		t0 = tmp[i];
		t1 = tmp[i + 2];
		s0 = t1 + t0;
		s2 = t1 - t0;

		t2 = tmp[i + 1];
		t3 = tmp[i + 3];
		s1 = MULH(2*(t3 + t2), icos36h[j]);
		s3 = MULL(t3 - t2, icos36[8 - j]);

		t0 = s0 + s1;
		t1 = s0 - s1;
		out[(9 + j)*SBLIMIT] =  MULH(t1, win[9 + j]) + buf[9 + j];
		out[(8 - j)*SBLIMIT] =  MULH(t1, win[8 - j]) + buf[8 - j];
		buf[9 + j] = MULH(t0, win[18 + 9 + j]);
		buf[8 - j] = MULH(t0, win[18 + 8 - j]);

		t0 = s2 + s3;
		t1 = s2 - s3;
		out[(9 + 8 - j)*SBLIMIT] =  MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j];
		out[(        j)*SBLIMIT] =  MULH(t1, win[        j]) + buf[        j];
		buf[9 + 8 - j] = MULH(t0, win[18 + 9 + 8 - j]);
		buf[      + j] = MULH(t0, win[18         + j]);
		i += 4;
	}

	s0 = tmp[16];
	s1 = MULH(2*tmp[17], icos36h[4]);
	t0 = s0 + s1;
	t1 = s0 - s1;
	out[(9 + 4)*SBLIMIT] =  MULH(t1, win[9 + 4]) + buf[9 + 4];
	out[(8 - 4)*SBLIMIT] =  MULH(t1, win[8 - 4]) + buf[8 - 4];
	buf[9 + 4] = MULH(t0, win[18 + 9 + 4]);
	buf[8 - 4] = MULH(t0, win[18 + 8 - 4]);
}

static void compute_imdct(
        mp3_context_t *s, granule_t *g, int32_t *sb_samples, int32_t *mdct_buf
)
{
	int32_t *ptr, *win, *win1, *buf, *out_ptr, *ptr1;
	int32_t out2[12];
	int i, j, mdct_long_end, v, sblimit;

	/* find last non zero block */
	ptr = g->sb_hybrid + 576;
	ptr1 = g->sb_hybrid + 2 * 18;
	while (ptr >= ptr1) {
		ptr -= 6;
		v = ptr[0] | ptr[1] | ptr[2] | ptr[3] | ptr[4] | ptr[5];
		if (v != 0) {
			break;
		}
	}
	sblimit = ((ptr - g->sb_hybrid) / 18) + 1;

	if (g->block_type == 2) {
		/* XXX: check for 8000 Hz */
		if (g->switch_point) {
			mdct_long_end = 2;
		} else {
			mdct_long_end = 0;
		}
	} else {
		mdct_long_end = sblimit;
	}

	buf = mdct_buf;
	ptr = g->sb_hybrid;
	for (j=0; j<mdct_long_end; j++) {
		/* apply window & overlap with previous buffer */
		out_ptr = sb_samples + j;
		/* select window */
		if (g->switch_point && j < 2) {
			win1 = mdct_win[0];
		} else {
			win1 = mdct_win[g->block_type];
		}
		/* select frequency inversion */
		win = win1 + ((4 * 36) & -(j & 1));
		imdct36(out_ptr, buf, ptr, win);
		out_ptr += 18*SBLIMIT;
		ptr += 18;
		buf += 18;
	}
	for (j=mdct_long_end; j<sblimit; j++) {
		/* select frequency inversion */
		win = mdct_win[2] + ((4 * 36) & -(j & 1));
		out_ptr = sb_samples + j;

		for (i=0; i<6; i++) {
			*out_ptr = buf[i];
			out_ptr += SBLIMIT;
		}
		imdct12(out2, ptr + 0);
		for (i=0; i<6; i++) {
			*out_ptr = MULH(out2[i], win[i]) + buf[i + 6*1];
			buf[i + 6*2] = MULH(out2[i + 6], win[i + 6]);
			out_ptr += SBLIMIT;
		}
		imdct12(out2, ptr + 1);
		for (i=0; i<6; i++) {
			*out_ptr = MULH(out2[i], win[i]) + buf[i + 6*2];
			buf[i + 6*0] = MULH(out2[i + 6], win[i + 6]);
			out_ptr += SBLIMIT;
		}
		imdct12(out2, ptr + 2);
		for (i=0; i<6; i++) {
			buf[i + 6*0] = MULH(out2[i], win[i]) + buf[i + 6*0];
			buf[i + 6*1] = MULH(out2[i + 6], win[i + 6]);
			buf[i + 6*2] = 0;
		}
		ptr += 18;
		buf += 18;
	}
	/* zero bands */
	for (j=sblimit; j<SBLIMIT; j++) {
		/* overlap */
		out_ptr = sb_samples + j;
		for (i=0; i<18; i++) {
			*out_ptr = buf[i];
			buf[i] = 0;
			out_ptr += SBLIMIT;
		}
		buf += 18;
	}
}

#define SUM8(sum, op, w, p) \
{                                               \
    sum op MULS((w)[0 * 64], p[0 * 64]);\
    sum op MULS((w)[1 * 64], p[1 * 64]);\
    sum op MULS((w)[2 * 64], p[2 * 64]);\
    sum op MULS((w)[3 * 64], p[3 * 64]);\
    sum op MULS((w)[4 * 64], p[4 * 64]);\
    sum op MULS((w)[5 * 64], p[5 * 64]);\
    sum op MULS((w)[6 * 64], p[6 * 64]);\
    sum op MULS((w)[7 * 64], p[7 * 64]);\
}

#define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
{                                               \
    int tmp;\
    tmp = p[0 * 64];\
    sum1 op1 MULS((w1)[0 * 64], tmp);\
    sum2 op2 MULS((w2)[0 * 64], tmp);\
    tmp = p[1 * 64];\
    sum1 op1 MULS((w1)[1 * 64], tmp);\
    sum2 op2 MULS((w2)[1 * 64], tmp);\
    tmp = p[2 * 64];\
    sum1 op1 MULS((w1)[2 * 64], tmp);\
    sum2 op2 MULS((w2)[2 * 64], tmp);\
    tmp = p[3 * 64];\
    sum1 op1 MULS((w1)[3 * 64], tmp);\
    sum2 op2 MULS((w2)[3 * 64], tmp);\
    tmp = p[4 * 64];\
    sum1 op1 MULS((w1)[4 * 64], tmp);\
    sum2 op2 MULS((w2)[4 * 64], tmp);\
    tmp = p[5 * 64];\
    sum1 op1 MULS((w1)[5 * 64], tmp);\
    sum2 op2 MULS((w2)[5 * 64], tmp);\
    tmp = p[6 * 64];\
    sum1 op1 MULS((w1)[6 * 64], tmp);\
    sum2 op2 MULS((w2)[6 * 64], tmp);\
    tmp = p[7 * 64];\
    sum1 op1 MULS((w1)[7 * 64], tmp);\
    sum2 op2 MULS((w2)[7 * 64], tmp);\
}

#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)

#define BF(a, b, c, s)\
{\
    tmp0 = tab[a] + tab[b];\
    tmp1 = tab[a] - tab[b];\
    tab[a] = tmp0;\
    tab[b] = MULH(tmp1<<(s), c);\
}

#define BF1(a, b, c, d)\
{\
    BF(a, b, COS4_0, 1);\
    BF(c, d,-COS4_0, 1);\
    tab[c] += tab[d];\
}

#define BF2(a, b, c, d)\
{\
    BF(a, b, COS4_0, 1);\
    BF(c, d,-COS4_0, 1);\
    tab[c] += tab[d];\
    tab[a] += tab[c];\
    tab[c] += tab[b];\
    tab[b] += tab[d];\
}

#define ADD(a, b) tab[a] += tab[b]

static void dct32(int32_t *out, int32_t *tab)
{
	int tmp0, tmp1;

	/* pass 1 */
	BF( 0, 31, COS0_0 , 1);
	BF(15, 16, COS0_15, 5);
	/* pass 2 */
	BF( 0, 15, COS1_0 , 1);
	BF(16, 31,-COS1_0 , 1);
	/* pass 1 */
	BF( 7, 24, COS0_7 , 1);
	BF( 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 */
	BF( 3, 28, COS0_3 , 1);
	BF(12, 19, COS0_12, 2);
	/* pass 2 */
	BF( 3, 12, COS1_3 , 1);
	BF(19, 28,-COS1_3 , 1);
	/* pass 1 */
	BF( 4, 27, COS0_4 , 1);
	BF(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 */
	BF( 1, 30, COS0_1 , 1);
	BF(14, 17, COS0_14, 3);
	/* pass 2 */
	BF( 1, 14, COS1_1 , 1);
	BF(17, 30,-COS1_1 , 1);
	/* pass 1 */
	BF( 6, 25, COS0_6 , 1);
	BF( 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 */
	BF( 2, 29, COS0_2 , 1);
	BF(13, 18, COS0_13, 3);
	/* pass 2 */
	BF( 2, 13, COS1_2 , 1);
	BF(18, 29,-COS1_2 , 1);
	/* pass 1 */
	BF( 5, 26, COS0_5 , 1);
	BF(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] = tab[0];
	out[16] = tab[1];
	out[ 8] = tab[2];
	out[24] = tab[3];
	out[ 4] = tab[4];
	out[20] = tab[5];
	out[12] = tab[6];
	out[28] = tab[7];
	out[ 2] = tab[8];
	out[18] = tab[9];
	out[10] = tab[10];
	out[26] = tab[11];
	out[ 6] = tab[12];
	out[22] = tab[13];
	out[14] = tab[14];
	out[30] = tab[15];

	ADD(24, 28);
	ADD(28, 26);
	ADD(26, 30);
	ADD(30, 25);
	ADD(25, 29);
	ADD(29, 27);
	ADD(27, 31);

	out[ 1] = tab[16] + tab[24];
	out[17] = tab[17] + tab[25];
	out[ 9] = tab[18] + tab[26];
	out[25] = tab[19] + tab[27];
	out[ 5] = tab[20] + tab[28];
	out[21] = tab[21] + tab[29];
	out[13] = tab[22] + tab[30];
	out[29] = tab[23] + tab[31];
	out[ 3] = tab[24] + tab[20];
	out[19] = tab[25] + tab[21];
	out[11] = tab[26] + tab[22];
	out[27] = tab[27] + tab[23];
	out[ 7] = tab[28] + tab[18];
	out[23] = tab[29] + tab[19];
	out[15] = tab[30] + tab[17];
	out[31] = tab[31];
}

static void mp3_synth_filter(
        int16_t *synth_buf_ptr, int *synth_buf_offset,
        int16_t *window, int *dither_state,
        int16_t *samples, int incr,
        int32_t sb_samples[SBLIMIT]
)
{
	int32_t tmp[32];
	register int16_t *synth_buf;
	register const int16_t *w, *w2, *p;
	int j, offset, v;
	int16_t *samples2;
	int sum, sum2;

	dct32(tmp, sb_samples);

	offset = *synth_buf_offset;
	synth_buf = synth_buf_ptr + offset;

	for (j=0; j<32; j++) {
		v = tmp[j];
		/* NOTE: can cause a loss in precision if very high amplitude
		   sound */
		if (v > 32767) {
			v = 32767;
		} else if (v < -32768) {
			v = -32768;
		}
		synth_buf[j] = v;
	}
	/* copy to avoid wrap */
	memcpy(synth_buf + 512, synth_buf, 32 * sizeof(int16_t));

	samples2 = samples + 31 * incr;
	w = window;
	w2 = window + 31;

	sum = *dither_state;
	p = synth_buf + 16;
	SUM8(sum, +=, w, p);
	p = synth_buf + 48;
	SUM8(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, +=, sum2, -=, w, w2, p);
		p = synth_buf + 48 - j;
		SUM8P2(sum, -=, sum2, -=, 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(sum, -=, w + 32, p);
	*samples = round_sample(&sum);
	*dither_state= sum;

	offset = (offset - 32) & 511;
	*synth_buf_offset = offset;
}

////////////////////////////////////////////////////////////////////////////////

static int decode_header(mp3_context_t *s, uint32_t header)
{
	int sample_rate, frame_size, mpeg25, padding;
	int sample_rate_index, bitrate_index;
	if (header & (1<<20)) {
		s->lsf = (header & (1<<19)) ? 0 : 1;
		mpeg25 = 0;
	} else {
		s->lsf = 1;
		mpeg25 = 1;
	}

	sample_rate_index = (header >> 10) & 3;
	sample_rate = mp3_freq_tab[sample_rate_index] >> (s->lsf + mpeg25);
	sample_rate_index += 3 * (s->lsf + mpeg25);
	s->sample_rate_index = sample_rate_index;
	s->error_protection = ((header >> 16) & 1) ^ 1;
	s->sample_rate = sample_rate;

	bitrate_index = (header >> 12) & 0xf;
	padding = (header >> 9) & 1;
	s->mode = (header >> 6) & 3;
	s->mode_ext = (header >> 4) & 3;
	s->nb_channels = (s->mode == MP3_MONO) ? 1 : 2;

	if (bitrate_index != 0) {
		frame_size = mp3_bitrate_tab[s->lsf][bitrate_index];
		s->bit_rate = frame_size * 1000;
		s->frame_size = (frame_size * 144000) / (sample_rate << s->lsf) + padding;
	} else {
		/* if no frame size computed, signal it */
		return 1;
	}
	return 0;
}

static int mp_decode_layer3(mp3_context_t *s)
{
	int nb_granules, main_data_begin, private_bits;
	int gr, ch, blocksplit_flag, i, j, k, n, bits_pos;
	granule_t *g;
	static granule_t granules[2][2];
	static int16_t exponents[576];
	const uint8_t *ptr;

	if (s->lsf) {
		main_data_begin = _get_bits(&s->gb, 8);
		private_bits = _get_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);
		} else {
			private_bits = _get_bits(&s->gb, 5);
		}
		nb_granules = 2;
		for (ch=0; ch<s->nb_channels; ch++) {
			granules[ch][0].scfsi = 0; /* all scale factors are transmitted */
			granules[ch][1].scfsi = _get_bits(&s->gb, 4);
		}
	}

	for (gr=0; gr<nb_granules; gr++) {
		for (ch=0; ch<s->nb_channels; ch++) {
			g = &granules[ch][gr];
			g->part2_3_length = _get_bits(&s->gb, 12);
			g->big_values = _get_bits(&s->gb, 9);
			g->global_gain = _get_bits(&s->gb, 8);
			/* if MS stereo only is selected, we precompute the
			   1/sqrt(2) renormalization factor */
			if ((s->mode_ext & (MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO)) ==
			                MODE_EXT_MS_STEREO) {
				g->global_gain -= 2;
			}
			if (s->lsf) {
				g->scalefac_compress = _get_bits(&s->gb, 9);
			} else {
				g->scalefac_compress = _get_bits(&s->gb, 4);
			}
			blocksplit_flag = _get_bits(&s->gb, 1);
			if (blocksplit_flag) {
				g->block_type = _get_bits(&s->gb, 2);
				if (g->block_type == 0) {
					return -1;
				}
				g->switch_point = _get_bits(&s->gb, 1);
				for (i=0; i<2; i++) {
					g->table_select[i] = _get_bits(&s->gb, 5);
				}
				for (i=0; i<3; i++) {
					g->subblock_gain[i] = _get_bits(&s->gb, 3);
				}
				/* compute huffman coded region sizes */
				if (g->block_type == 2) {
					g->region_size[0] = (36 / 2);
				} else {
					if (s->sample_rate_index <= 2) {
						g->region_size[0] = (36 / 2);
					} else if (s->sample_rate_index != 8) {
						g->region_size[0] = (54 / 2);
					} else {
						g->region_size[0] = (108 / 2);
					}
				}
				g->region_size[1] = (576 / 2);
			} else {
				int region_address1, region_address2, l;
				g->block_type = 0;
				g->switch_point = 0;
				for (i=0; i<3; i++) {
					g->table_select[i] = _get_bits(&s->gb, 5);
				}
				/* compute huffman coded region sizes */
				region_address1 = _get_bits(&s->gb, 4);
				region_address2 = _get_bits(&s->gb, 3);
				g->region_size[0] =
				        band_index_long[s->sample_rate_index][region_address1 + 1] >> 1;
				l = region_address1 + region_address2 + 2;
				/* should not overflow */
				if (l > 22) {
					l = 22;
				}
				g->region_size[1] =
				        band_index_long[s->sample_rate_index][l] >> 1;
			}
			/* convert region offsets to region sizes and truncate
			   size to big_values */
			g->region_size[2] = (576 / 2);
			j = 0;
			for (i=0; i<3; i++) {
				k = g->region_size[i];
				if (g->big_values < k) {
					k = g->big_values;
				}
				g->region_size[i] = k - j;
				j = k;
			}

			/* compute band indexes */
			if (g->block_type == 2) {
				if (g->switch_point) {
					/* if switched mode, we handle the 36 first samples as
					   long blocks.  For 8000Hz, we handle the 48 first
					   exponents as long blocks (XXX: check this!) */
					if (s->sample_rate_index <= 2) {
						g->long_end = 8;
					} else if (s->sample_rate_index != 8) {
						g->long_end = 6;
					} else {
						g->long_end = 4;        /* 8000 Hz */
					}

					g->short_start = 2 + (s->sample_rate_index != 8);
				} else {
					g->long_end = 0;
					g->short_start = 0;
				}
			} else {
				g->short_start = 13;
				g->long_end = 22;
			}

			g->preflag = 0;
			if (!s->lsf) {
				g->preflag = _get_bits(&s->gb, 1);
			}
			g->scalefac_scale = _get_bits(&s->gb, 1);
			g->count1table_select = _get_bits(&s->gb, 1);
		}
	}

	ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
	/* now we get bits from the main_data_begin offset */
	if (main_data_begin > s->last_buf_size) {
		s->last_buf_size= main_data_begin;
	}

	memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
	s->in_gb= s->gb;
	init_get_bits(&s->gb, s->last_buf + s->last_buf_size - main_data_begin, main_data_begin*8);

	for (gr=0; gr<nb_granules; gr++) {
		for (ch=0; ch<s->nb_channels; ch++) {
			g = &granules[ch][gr];

			bits_pos = get_bits_count(&s->gb);

			if (!s->lsf) {
				uint8_t *sc;
				int slen, slen1, slen2;

				/* MPEG1 scale factors */
				slen1 = slen_table[0][g->scalefac_compress];
				slen2 = slen_table[1][g->scalefac_compress];
				if (g->block_type == 2) {
					n = g->switch_point ? 17 : 18;
					j = 0;
					if (slen1) {
						for (i=0; i<n; i++) {
							g->scale_factors[j++] = _get_bits(&s->gb, slen1);
						}
					} else {
						memset((void*) &g->scale_factors[j], 0, n);
						j += n;
//                        for(i=0;i<n;i++)
//                            g->scale_factors[j++] = 0;
					}
					if (slen2) {
						for (i=0; i<18; i++) {
							g->scale_factors[j++] = _get_bits(&s->gb, slen2);
						}
						for (i=0; i<3; i++) {
							g->scale_factors[j++] = 0;
						}
					} else {
						for (i=0; i<21; i++) {
							g->scale_factors[j++] = 0;
						}
					}
				} else {
					sc = granules[ch][0].scale_factors;
					j = 0;
					for (k=0; k<4; k++) {
						n = (k == 0 ? 6 : 5);
						if ((g->scfsi & (0x8 >> k)) == 0) {
							slen = (k < 2) ? slen1 : slen2;
							if (slen) {
								for (i=0; i<n; i++) {
									g->scale_factors[j++] = _get_bits(&s->gb, slen);
								}
							} else {
								memset((void*) &g->scale_factors[j], 0, n);
								j += n;
//                                for(i=0;i<n;i++)
//                                    g->scale_factors[j++] = 0;
							}
						} else {
							/* simply copy from last granule */
							for (i=0; i<n; i++) {
								g->scale_factors[j] = sc[j];
								j++;
							}
						}
					}
					g->scale_factors[j++] = 0;
				}
			} else {
				int tindex, tindex2, slen[4], sl, sf;

				/* LSF scale factors */
				if (g->block_type == 2) {
					tindex = g->switch_point ? 2 : 1;
				} else {
					tindex = 0;
				}
				sf = g->scalefac_compress;
				if ((s->mode_ext & MODE_EXT_I_STEREO) && ch == 1) {
					/* intensity stereo case */
					sf >>= 1;
					if (sf < 180) {
						lsf_sf_expand(slen, sf, 6, 6, 0);
						tindex2 = 3;
					} else if (sf < 244) {
						lsf_sf_expand(slen, sf - 180, 4, 4, 0);
						tindex2 = 4;
					} else {
						lsf_sf_expand(slen, sf - 244, 3, 0, 0);
						tindex2 = 5;
					}
				} else {
					/* normal case */
					if (sf < 400) {
						lsf_sf_expand(slen, sf, 5, 4, 4);
						tindex2 = 0;
					} else if (sf < 500) {
						lsf_sf_expand(slen, sf - 400, 5, 4, 0);
						tindex2 = 1;
					} else {
						lsf_sf_expand(slen, sf - 500, 3, 0, 0);
						tindex2 = 2;
						g->preflag = 1;
					}
				}

				j = 0;
				for (k=0; k<4; k++) {
					n = lsf_nsf_table[tindex2][tindex][k];
					sl = slen[k];
					if (sl) {
						for (i=0; i<n; i++) {
							g->scale_factors[j++] = _get_bits(&s->gb, sl);
						}
					} else {
						memset((void*) &g->scale_factors[j], 0, n);
						j += n;
//                        for(i=0;i<n;i++)
//                            g->scale_factors[j++] = 0;
					}
				}
				/* XXX: should compute exact size */
				memset((void*) &g->scale_factors[j], 0, 40 - j);
//                for(;j<40;j++)
//                    g->scale_factors[j] = 0;
			}

			exponents_from_scale_factors(s, g, exponents);

			/* read Huffman coded residue */
			if (huffman_decode(s, g, exponents,
			                   bits_pos + g->part2_3_length) < 0) {
				return -1;
			}
		} /* ch */

		if (s->nb_channels == 2) {
			compute_stereo(s, &granules[0][gr], &granules[1][gr]);
		}

		for (ch=0; ch<s->nb_channels; ch++) {
			g = &granules[ch][gr];
			reorder_block(s, g);
			compute_antialias(s, g);
			compute_imdct(s, g, &s->sb_samples[ch][18 * gr][0], s->mdct_buf[ch]);
		}
	} /* gr */
	return nb_granules * 18;
}

static int mp3_decode_main(
        mp3_context_t *s,
        int16_t *samples, const uint8_t *buf, int buf_size
)
{
	int i, nb_frames, ch;
	int16_t *samples_ptr;

	init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE)*8);

	if (s->error_protection) {
		_get_bits(&s->gb, 16);
	}

	nb_frames = mp_decode_layer3(s);

	s->last_buf_size=0;
	if (s->in_gb.buffer) {
		align_get_bits(&s->gb);
		i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;
		if (i >= 0 && i <= BACKSTEP_SIZE) {
			memmove(s->last_buf, s->gb.buffer + (get_bits_count(&s->gb)>>3), i);
			s->last_buf_size=i;
		}
		s->gb= s->in_gb;
	}

	align_get_bits(&s->gb);
	i= (s->gb.size_in_bits - get_bits_count(&s->gb))>>3;

	if (i<0 || i > BACKSTEP_SIZE || nb_frames<0) {
		i = buf_size - HEADER_SIZE;
		if (BACKSTEP_SIZE < i) {
			i = BACKSTEP_SIZE;
		}
	}
	memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
	s->last_buf_size += i;

	/* apply the synthesis filter */
	for (ch=0; ch<s->nb_channels; ch++) {
		samples_ptr = samples + ch;
		for (i=0; i<nb_frames; i++) {
			mp3_synth_filter(
			        s->synth_buf[ch], &(s->synth_buf_offset[ch]),
			        window, &s->dither_state,
			        samples_ptr, s->nb_channels,
			        s->sb_samples[ch][i]
			);
			samples_ptr += 32 * s->nb_channels;
		}
	}
	return nb_frames * 32 * sizeof(uint16_t) * s->nb_channels;
}

////////////////////////////////////////////////////////////////////////////////

static int mp3_decode_init(mp3_context_t *s)
{
	static int init=0;
	int i, j, k;

	if (!init) {
		/* synth init */
		for (i=0; i<257; i++) {
			int v;
			v = mp3_enwindow[i];
#if 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;
			}
		}

		/* huffman decode tables */
		for (i=1; i<16; i++) {
			const huff_table_t *h = &mp3_huff_tables[i];
			int xsize, x, y;
			unsigned int n;
			uint8_t  tmp_bits [512];
			uint16_t tmp_codes[512];

			memset(tmp_bits , 0, sizeof(tmp_bits ));
			memset(tmp_codes, 0, sizeof(tmp_codes));

			xsize = h->xsize;
			n = xsize * 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++];
				}
			}

			init_vlc(&huff_vlc[i], 7, 512,
			         tmp_bits, 1, 1, tmp_codes, 2, 2);
		}
		for (i=0; i<2; i++) {
			init_vlc(&huff_quad_vlc[i], i == 0 ? 7 : 4, 16,
			         mp3_quad_bits[i], 1, 1, mp3_quad_codes[i], 1, 1);
		}

		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 */
		table_4_3_exp= malloc(TABLE_4_3_SIZE * sizeof(table_4_3_exp[0]));
		if (!table_4_3_exp) {
			return -1;
		}
		table_4_3_value= malloc(TABLE_4_3_SIZE * sizeof(table_4_3_value[0]));
		if (!table_4_3_value) {
			return -1;
		}

		for (i=1; i<TABLE_4_3_SIZE; i++) {
			double f, fm;
			int e, m;
			f = pow((double)(i/4), 4.0 / 3.0) * pow(2, (i&3)*0.25);
			fm = frexp(f, &e);
			m = (uint32_t)(fm*(1LL<<31) + 0.5);
			e+= FRAC_BITS - 31 + 5 - 100;
			table_4_3_value[i] = m;
			table_4_3_exp[i] = -e;
		}
		for (i=0; i<512*16; i++) {
			int exponent= (i>>4);
			double f= pow(i&15, 4.0 / 3.0) * pow(2, (exponent-400)*0.25 + FRAC_BITS + 5);
			expval_table[exponent][i&15]= f;
			if ((i&15)==1) {
				exp_table[exponent]= f;
			}
		}

		for (i=0; i<7; i++) {
			float f;
			int 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;
		}
		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;

			for (j=0; j<2; j++) {
				e = -(j + 1) * ((i + 1) >> 1);
				f = pow(2.0, e / 4.0);
				k = i & 1;
				is_table_lsf[j][k ^ 1][i] = FIXR(f);
				is_table_lsf[j][k][i] = FIXR(1.0);
			}
		}

		for (i=0; i<8; i++) {
			float ci, cs, ca;
			ci = ci_table[i];
			cs = 1.0 / sqrt(1.0 + ci * ci);
			ca = cs * ci;
			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;
		}

		/* compute mdct windows */
		for (i=0; i<36; i++) {
			for (j=0; j<4; j++) {
				double d;

				if (j==2 && i%3 != 1) {
					continue;
				}

				d= sin(M_PI * (i + 0.5) / 36.0);
				if (j==1) {
					if     (i>=30) {
						d= 0;
					} else if (i>=24) {
						d= sin(M_PI * (i - 18 + 0.5) / 12.0);
					} else if (i>=18) {
						d= 1;
					}
				} else if (j==3) {
					if     (i<  6) {
						d= 0;
					} else if (i< 12) {
						d= sin(M_PI * (i -  6 + 0.5) / 12.0);
					} else if (i< 18) {
						d= 1;
					}
				}
				d*= 0.5 / cos(M_PI*(2*i + 19)/72);
				if (j==2) {
					mdct_win[j][i/3] = FIXHR((d / (1<<5)));
				} else {
					mdct_win[j][i  ] = FIXHR((d / (1<<5)));
				}
			}
		}
		for (j=0; j<4; j++) {
			for (i=0; i<36; i+=2) {
				mdct_win[j + 4][i] = mdct_win[j][i];
				mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1];
			}
		}
		init = 1;
	}
	return 0;
}

static int mp3_decode_frame(
        mp3_context_t *s,
        int16_t *out_samples, int *data_size,
        uint8_t *buf, int buf_size
)
{
	uint32_t header;
	int out_size;
	int extra_bytes = 0;

retry:
	if (buf_size < HEADER_SIZE) {
		return -1;
	}

	header = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
	if (mp3_check_header(header) < 0) {
		buf++;
		buf_size--;
		extra_bytes++;
		goto retry;
	}

	if (decode_header(s, header) == 1) {
		s->frame_size = -1;
		return -1;
	}

	if (s->frame_size<=0 || s->frame_size > buf_size) {
		return -1;  // incomplete frame
	}
	if (s->frame_size < buf_size) {
		buf_size = s->frame_size;
	}

	out_size = mp3_decode_main(s, out_samples, buf, buf_size);
	if (out_size>=0) {
		*data_size = out_size;
	}
	// else: Error while decoding MPEG audio frame.
	s->frame_size += extra_bytes;
	return buf_size;
}

////////////////////////////////////////////////////////////////////////////////

mp3_decoder_t mp3_create(void)
{
	void *dec = calloc(sizeof(mp3_context_t), 1);
	if (dec) {
		mp3_decode_init((mp3_context_t*) dec);
	}
	return (mp3_decoder_t) dec;
}

void mp3_done(mp3_decoder_t *dec)
{
	if (dec) {
		free(dec);
	}
}

int mp3_decode(mp3_decoder_t *dec, void *buf, int bytes, signed short *out, mp3_info_t *info)
{
	int res, size = -1;
	mp3_context_t *s = (mp3_context_t*) dec;
	if (!s) {
		return 0;
	}
	res = mp3_decode_frame(s, (int16_t*) out, &size, buf, bytes);
	if (res < 0) {
		return 0;
	}
	if (info) {
		info->sample_rate = s->sample_rate;
		info->channels = s->nb_channels;
		info->audio_bytes = size;
	}
	return s->frame_size;
}

#undef UPDATE_CACHE
#undef BF